Zaszczepić się czy nie? projekt dotyczący obserwacji odporności stada poprzez symulację choroby: 15 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

Przegląd projektu:

Nasz projekt bada odporność stada i ma nadzieję zachęcić ludzi do szczepień w celu zmniejszenia liczby infekcji w naszych społecznościach. Nasz program symuluje, w jaki sposób choroba infekuje populację o różnym odsetku zaszczepionych i niezaszczepionych. Pokazuje odporność stada, pokazując, jak zwiększona liczba zaszczepionej populacji może zmniejszyć liczbę osób dotkniętych chorobą.

Modelujemy to w Matlab za pomocą koncepcji teorii grafów. Teoria grafów to matematyczny sposób przedstawiania relacji między obiektami. W teorii grafów grafy mają wierzchołki (lub węzły) połączone krawędziami (lub liniami). W naszym projekcie węzły to poszczególne jednostki, a krawędzie to ich połączenia. Na przykład, jeśli dwa węzły są połączone krawędzią, oznacza to, że są „przyjaciółmi” lub mają ze sobą jakąś formę kontaktu. Ten kontakt jest sposobem na rozprzestrzenianie się choroby. Dlatego użyliśmy teorii grafów do modelowania naszej koncepcji, ponieważ chcieliśmy zobaczyć, jak choroba rozprzestrzenia się wśród osobników połączonych w populacji.

Nasz projekt obejmuje również metodę Monte Carlo. Metoda Monte Carlo to algorytmy, które tworzą powtarzane losowe próbkowanie w celu uzyskania wyników liczbowych. W naszym projekcie używamy tej metody do kilkukrotnego uruchomienia naszej symulacji, zmieniając procent początkowo niezaszczepionych, aby zobaczyć, w jakim tempie ludzie zarażają się.

Cały kod projektu jest połączony na dole!

Źródło:

Link do Matlaba do teorii grafów:

Krok 1: Utwórz macierz sąsiedztwa

Utwórz nowy skrypt. Naszą nazwę będziemy nazywać „infectionSim.m”.

Utworzymy zmienną 'NUMOFPEOPLE'. Możesz przypisać go do dowolnej wartości całkowitej. Będzie to reprezentować liczbę osób w twojej populacji.

Od teraz założymy, że

LICZBA OSÓB = 20;

Zacznij od wykorzystania funkcji teorii grafów Matlaba dla grafu nieskierowanego.

Jeśli chcesz dowiedzieć się więcej, oto link, aby przeczytać więcej na ten temat.

www.mathworks.com/help/matlab/math/directed-and-undirected-graphs.html

Utworzono macierz sąsiedztwa.

adjMatrix = zera(LICZBALUB);

To stworzy kwadratową macierz zer. Każdy wiersz w macierzy to osoba. Każda kolumna w macierzy to osoba lub przyjaciel, z którym ta osoba spotyka się w ciągu dnia.

Zobacz Rysunek 100 (powyżej), aby pomóc zwizualizować, jak adjMatrix wygląda dla 20 osób.

**Od tego momentu zakładamy, że NUMOFPEOPLE jest równe 20.**

Możesz spróbować wykreślić tę macierz sąsiedztwa. Oto trochę więcej informacji na temat wykreślania tego typu macierzy.

Uwaga: Jak działa macierz sąsiedztwa.

Były:

%tworzenie sąsiedniej macierzy

a = [0, 1, 0, 0, 0; 1, 0, 1, 1, 1; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0] %wykreślanie g = graph(a); %korzystanie z funkcji grafu (teoria grafów) figure(1); h = działka(g);

Zobacz rysunek 1 (powyżej), aby zobaczyć, jak dodać krawędzie w macierzy sąsiedztwa, używając kodu w „Uwaga”.

Krok 2: Twórz relacje

Teraz, gdy ludzie (wierzchołki lub węzły) są już utworzone, musimy stworzyć sieć relacji (linie lub krawędzie grafu). Będzie to symulować, w jaki sposób ludzie wchodzą w interakcje i spotykają się z innymi ludźmi w ciągu dnia.

Można to zrobić na wiele sposobów. Jednym ze sposobów wykonania tego zadania jest najpierw przypisanie losowej liczby każdej osobie, aby określić, z iloma osobami każda osoba będzie współdziałać w ciągu dnia.

numOfFriendsMatrix = randi([najmniejszaOsobaPrzyjaciółMożnaMieć, najwięcejPrzyjaciółOsobaMożnaMieć], 1, LICZBA LUDZI);

To tworzy macierz losowych liczb całkowitych 1 na 20 reprezentujących liczbę interakcji każdej osoby w ciągu dnia. Kolumny tej macierzy to liczba odpowiadająca każdej osobie. Na przykład, jeśli przypiszemy lessFriendsPersonCanHave = 2 i mostFriendsPersonCanHave = 5, otrzymamy losowe wartości od 2 do 5.

Masz problem z randi()? W terminalu wpisz

pomóż Randi

Następnie tworzymy losową macierz (zwaną „allFriendsmatrix”) pokazującą, w jaki sposób każda osoba w populacji jest połączona/interakcja z populacją.

tempMatrix = ;

liczba = 0; allFriendsMatrix = ; dla k = 1:LICZBAPEOPLE while length(tempMatrix) ~= numOfFriendsMatrix(k) count = count +1; temp = randi([1, LICZBA LUDZI]); tempMatrix(liczba) = temp; end clear each while length(tempMatrix) ~= 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; liczba = 0; kończyć się

Dogłębne wyjaśnienie kodu:

Najpierw tworzymy pustą tymczasową macierz do przechowywania listy znajomych/interakcji każdej osoby. Inicjujemy również licznik, który po prostu śledzi, gdzie umieścić nowe losowe połączenie w tempMatrix. Pętle for uruchamiają się 20 razy, tak że dzieje się tak dla każdej osoby w populacji. Pierwsza pętla while działa, dopóki tempMatrix każdej osoby nie będzie miała tej samej długości co losowo przypisana liczba interakcji. W tej pętli losowa liczba odpowiadająca osobie w populacji jest generowana i umieszczana w tempMatrix. Ponieważ długości poszczególnych tempMatrix są różne, musieliśmy utworzyć pewne wartości NaN, aby móc połączyć wszystkie te tempMatrix w jedną macierz („allFriendsMatrix”). Druga pętla while rozwiązuje ten problem, dodając NaN do każdego tempMatrix. Pętla while została ustawiona na uruchomienie 9 razy, ponieważ jest to liczba większa niż 5, czyli górna granica znajomych, do których można przypisać daną osobę. Wartość „9” jest zmienna i może/musi zostać zmieniona, gdy „mostFriendsPersonCanHave” jest większa niż 9. Ostatnie trzy wiersze kodu (z wyłączeniem końca) dodają tempMatrix do następnego wiersza „allFriendsMatrix”. Następnie czyści tempMatrix i liczy dla następnej osoby.

Wyjście

Tak powinien wyglądać wynik przy pierwszym uruchomieniu pętli for (przed ostatnimi trzema wierszami).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

wszyscyPrzyjacieleMatrix =

16 8 17 16 13 NaN NaN NaN NaN 8 8 2 7 11 NaN NaN NaN NaN 10 13 NaN NaN NaN NaN NaN NaN NaN 11 17 2 NaN NaN NaN NaN NaN NaN 10 12 NaN NaN NaN NaN NaN NaN NaN 4 13 2 12 NaN NaN NaN NaN NaN 17 10 9 3 1 NaN NaN NaN NaN 16 16 6 NaN NaN NaN NaN NaN NaN 3 8 17 17 14 NaN NaN NaN NaN 20 19 3 NaN NaN NaN NaN NaN NaN 13 10 NaN NaN NaN NaN NaN NaN NaN 2 18 10 16 NaN NaN NaN NaN NaN 2 6 14 3 13 NaN NaN NaN NaN 8 16 14 8 NaN NaN NaN NaN NaN 7 7 NaN NaN NaN NaN NaN NaN NaN 19 10 9 NaN NaN NaN NaN NaN NaN 10 19 NaN NaN NaN NaN NaN NaN NaN 5 18 NaN NaN NaN NaN NaN NaN NaN 1 7 NaN NaN NaN NaN NaN NaN NaN 16 7 13 10 1 NaN NaN NaN NaN

Następnie dodaj te relacje do adjMatrix.

dla każdego wiersza = 1: LICZBA OSÓB

for eachCol = 1:9 if isnan(allFriendsMatrix(eachRow, eachCol)) == 0 adjMatrix(eachRow, allFriendsMatrix(eachRow, eachCol)) = 1; adjMatrix(allFriendsMatrix(eachRow, eachCol), eachRow) = 1; koniec koniec koniec

Kod Wyjaśnienie

Ta podwójna pętla for przechodzi przez każdy wiersz i kolumnę „allFriendsMatrix”. Instrukcja if zostanie uruchomiona dla wszystkich wartości, które nie są „NaN”. Zasadniczo utworzy krawędzie lub linie wykresu. Więc pierwsza linia, którą to utworzy, to osoba 1 na osobę 16 i osoba 16 na osobę 1. Ponieważ jest nieskierowana, 1 należy zmienić dla obu! Nie możemy po prostu mieć krawędzi od 1 do 16, a nie od 16 do 1. Muszą one być symetryczne, aby działały poprawnie w Matlabie.

W naszej symulacji ustaliliśmy, że ludzie nie mogą wchodzić w interakcje ze sobą. Gdy zrandomizowaliśmy wartości, istnieje szansa, że sąsiednia macierz zawiera te błędy.

Naprawmy to następującym kodem:

dla każdego = 1: LICZBA OSÓB

adjMatrix(każdy, każdy) = 0; kończyć się

Kod Wyjaśnienie

Ta pętla for zapewnia, że osoba 1 nie jest połączona z osobą 1, osoba 2 nie jest połączona z osobą 2 itd., zmieniając je wszystkie na 0. Jak widać poniżej w sekcji danych wyjściowych, mamy przekątną kwadratu macierz od górnego lewego do dolnego prawego to same zera.

Wyjście

To jest ostatnia macierz adjMatrix dla obecnej symulacji. To wyjaśnia wszystkie linie na wykresie (Rysunek 2).

adjMatrix =

0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 1 0 1 0 1 1 1 1 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0

Zobacz Rysunek 2, aby zobaczyć wykres 'adjMatrix'.

Krok 3: Dodaj statystyki choroby

Teraz, gdy Twój program może utworzyć wykres z zestawem przypadkowych osób i stworzyć losowe relacje, musimy wprowadzić informacje o chorobie lub statystyki, aby zobaczyć, jak te interakcje w populacji mogą zwiększyć lub zmniejszyć infekcję.

Utwórz te zmienne:

unvacc %type: podwójny; procentowa szansa, że osoby niezaszczepione nie zachorują

vacc %typ: podwójny; procent szans na to, że zaszczepione osoby nie zachorują unvacc_perc %type: double; procent populacji niezaszczepionych init_infect %type: int; procent populacji zaszczepionych

Następnie musimy wykonać kilka obliczeń.

Stworzymy 'infectionMat', która jest macierzą 3*LICZBY LUDZI.

vacc_perc = 1-unvacc_perc;

infekcjaMat = nan(3, LICZBA LUDZI); liczba = okrągła(vacc_perc * LICZBA LUDZI); infekcjaMat(1, 1:liczba) = vacc; infekcjaMat(1, liczba+1:koniec) = unvacc; infekcjaMat(2, 1:koniec) = 0; zakażenieMat(2, 1:init_infect) = 1;

Kod Wyjaśnienie

wiersz 1: Obliczono odsetek populacji niezaszczepionych

linia 2: utwórz macierz 3*N liczby osób

linia 3: sprawdź liczbę osób zaszczepionych z procentu zaszczepionych

wiersz 4: w przypadku osób zaszczepionych podaj odporność związaną z otrzymaniem szczepionki. Ta wartość jest przypisywana na podstawie badań dotyczących choroby.

wiersz 5: dla reszty populacji (osoby nieszczepione) podaj procent odporności. Ta wartość jest przypisywana na podstawie badań dotyczących choroby.

linia 6: początkowo ustaw wszystkich ludzi na niezainfekowanych.

wiersz 7: dla liczby osób początkowo zarażonych, wypełnij odpowiednio kilka pierwszych kolumn.

Teraz, gdy ustawiliśmy już wszystkie parametry symulacji choroby, będziemy losować szansę, czy dana osoba (zarówno zaszczepiona, jak i nieszczepiona) zostanie zarażona. Odbywa się to w następnym kroku, przypisując losowe wartości od 0 do 1 każdej osobie w trzecim rzędzie tej 'infectionMat'.

Krok 4: Losuj szansę, że osoba zaszczepiona i nieszczepiona może zostać zarażona

Następnie przypisz każdej osobie losową liczbę, która posłuży później do ustalenia, czy dana osoba zostanie zarażona, czy nie.

dla w = 1:długość(infekcjaMata)

infekcjaMat(3, w) = rand; kończyć się

Wyjaśnienie kodu

Ta pętla for zajmuje się trzecim wierszem 'infectionMat' utworzonej w ostatnim kroku. „rand” przypisuje wartość od 0 do 1 do każdego indeksu wiersza 3.

Wyjście

infectionMat jest teraz gotowy! Było to w populacji ze 100% szczepieniami i 1 osobą początkowo zakażoną.

infekcjaMat =

Kolumny 1 do 12 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 1,0000 0 0 0 0 0 0 0 0 0 0 0 0,0869 0,5489 0,3177 0,9927 0,7236 0,5721 0,7172 0,9766 0,4270 0,9130 0,8973 do 0,8500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0,7500 0 0 0 0 0 0 0 0 0,0480 0,3593 0,2958 0,6291 0,1362 0,3740 0,8648 0,2503

wiersz 1: Procent szans na NIE zachorowanie

wiersz 2: Zainfekowany lub niezainfekowany (wartość logiczna)

wiersz 3: Numer używany do sprawdzenia, czy osoba, która nie jest zarażona, zostanie zarażona, jeśli spotka osobę zarażoną. Jeśli niezainfekowana osoba spotka osobę zarażoną, ta liczba jest większa niż liczba w wierszu 1 (dla tej samej kolumny), to jest zarażona. Zakodujemy tę funkcję w kroku 7.

Krok 5: Utwórz na podstawie wstępnych informacji matryce osób niezaszczepionych i zarażonych

Utwórz 2 macierze o nazwie „matrixUnvacc” i „matrixInfected”, które przechowują wszystkie zainfekowane osoby z infekcjiMat. Posłuży to do oznaczenia kolorami wykresu osób zakażonych, nieszczepionych lub zaszczepionych, pomagając w wizualizacji wpływu osób nieszczepionych w porównaniu z osobami zaszczepionymi.

wyczyść każdy

macierzInfected = ; macierz Unvacc = ; for h= 1:length(infectionMat) if infectionMat(1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; end end dla osoby = 1:NUMOFPEOPLE jeśli infekcjaMat(2, osoba) == 1 macierzZainfekowana = [macierzZainfekowana, osoba]; koniec koniec

Kod Wyjaśnienie

Utwórz dwie puste macierze do przechowywania liczby osób, które są odpowiednio niezaszczepione i zarażone. Obie pętle for uruchamiają się 20 razy i jeśli instrukcja if jest spełniona, liczba jest dodawana do właściwej macierzy.

Wyjście

macierz Unvacc =

macierzZainfekowany =

[1]

Krok 6: Sporządź początkowy wykres

Następnie wykreślimy macierz sąsiedztwa.

g = wykres(adjMatrix);

figure(1) p = plot(g, 'NodeColor', 'b', 'MarkerSize', 7); highlight(p, matrixUnvacc, 'NodeColor', 'g') highlight(p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title(['Procent osób niezaszczepionych: ', num2str(title_unvacc), '%']); pauza (prędkość)

Wyjaśnienie kodu

Teoria grafów w Matlabie ma wbudowane funkcje. Kiedy używamy funkcji graph(), jesteśmy w stanie przetłumaczyć 'adjMatrix' na rzeczywisty wykres nieskierowany. Następnie musimy utworzyć wykres za pomocą funkcji plot(), aby zobaczyć, jak wygląda. Ustawiamy ten plot() na zmienną, dzięki czemu możemy łatwiej manipulować i zmieniać kolory wykresu podczas całej symulacji. Wszystkie osoby (lub węzły) są początkowo ustawione na kolor „niebieski”. Następnie wszystkie osoby niezaszczepione są ustawiane na kolor „zielony”. Zakażeni ludzie są następnie ustawiani na kolor „czerwony”. Tytuł jest ustalany według określonej wartości procentowej badanych osób nieszczepionych. Funkcja pause() tymczasowo zatrzymuje wykonywanie MatLaba. Przechodzimy przez zmienną prędkość, która jest rozprowadzana, która jest liczona w sekundach.

Zobacz zdjęcie (powyżej), aby zobaczyć losowy wykres kodowany kolorami.

Dowiedz się więcej o funkcji highlight() w MatLabie.

Krok 7: Symuluj postęp infekcji

Następnie musimy dowiedzieć się, kto zostanie zainfekowany po interakcji (zapisanym w adjMatrix) i zaktualizować wykres, gdy ktoś zostanie zainfekowany.

Użyj adjMatrix, aby określić, którzy ludzie są zarażeni po ich interakcjach z ludźmi w ciągu dnia.

dla każdego wiersza = 1:długość(adjMatrix)

if zakażenieMat(2, eachRow) == 1 for eachCol = 1:length(adjMatrix) if adjMatrix(eachRow, eachCol) == 1 % eachRow = osoba % eachCol = jego znajomy % znajomy każdej osoby i sprawdź, czy nie są zainfekowane. if zakażenieMat(3, eachCol) > zakażenieMat(1, eachCol) zakażenieMat(2, eachCol) = 1; highlight(p, eachCol, 'NodeColor', 'r') pause(speed) end end end end end

Pętla for przechodzi przez każdą osobę. Sprawdza, czy jeśli dana osoba jest zarażona, sprawdza każdą osobę/przyjaciela, z którą wchodził w interakcję i sprawdza, czy poziom odporności przyjaciela był większy niż siła choroby. W tym miejscu do gry wkracza stworzona wcześniej przez nas „infectionMat”. Porównywany jest pierwszy i trzeci wiersz każdej kolumny przyjaciela i jeśli trzeci wiersz jest większy, oznacza to, że przyjaciel nie miał wystarczająco wysokiej odporności, aby uciec przed chorobą i ostatecznie zostaje zarażony. Zmieniamy również kolor za pomocą highlight() na czerwony, jeśli zostaną zainfekowane.

Teraz Twój kod do symulacji powinien działać! i dla dowolnej wielkości populacji, po prostu zmień LICZBA LUDZI!

Krok 8: Użyj teorii Monte Carlo

Aby pójść o krok dalej i wydobyć dane z naszego symulatora („infectionSim.m”), chcieliśmy obliczyć i wykreślić trend procentowy niezaszczepionych osób, które zostały zarażone, oraz procent zaszczepionych osób, które zostały zarażone. Stawiamy hipotezę, że odsetek zaszczepionych osób, które się zaraziły, powinien być znacznie niższy niż odsetek osób niezaszczepionych, które się zaraziły.

Krok 9: Przekształć plik ('infectionSim.m') z symulacją w funkcję

Aby uruchomić Monte Carlo, chcielibyśmy wielokrotnie przeprowadzać symulację i gromadzić dane, abyśmy mogli wykorzystać je do wykreślenia odsetka osób, które zostały zainfekowane.

Funkcję można skonfigurować tak:

wyjście funkcji = infekcjaSim(unvacc, vacc, LICZBA LUDZI, unvacc_perc, init_infect, speed)

Zakomentuj zmienne w swojej symulacji, ponieważ teraz przekazujesz je przez główny plik (zaczniemy to pisać w kroku 12):

unvacc, vacc, LICZBA LUDZI, unvacc_perc, init_infect

Nowa zmienna

prędkość

zostaną przypisane w głównym pliku (Monte_Carlo.m).

Uwaga: Nie zapomnij o końcu na dole pliku funkcji, aby zakończyć funkcję!

Krok 10: Oblicz odsetek osób niezaszczepionych i zaszczepionych, które zostały zarażone

To oblicza procent niezaszczepionych osób, które zostały zarażone. Ten kod znajduje się na końcu pliku 'infectionSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; % oblicza procent niezaszczepionych osób, które zostały zarażone przez x = 1:długość(infectionMat) ifinformationMat(1, x) == unvacc number_of_unvacc = number_of_unvacc+1; koniec jeśli zakażenieMat(1, x) == unvacc & zakażenieMat(2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; end end percent_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

Wyjaśnienie kodu

W pętli for zapętli się NUMOFPEOPLE razy. Za każdym razem, gdy liczba w infekcjiMat odpowiada liczbie niezaszczepionej (tj. 0,95 == 0,95), wtedy liczba osób niezaszczepionych zostanie zwiększona o 1. Za każdym razem, gdy liczba w zakażeniuMat odpowiada liczbie niezaszczepionej i są one liczba zakażonych i niezaszczepionych wzrasta o 1. Ostatnia linia dzieli liczbę zakażonych, niezaszczepionych przez całkowitą liczbę osób niezaszczepionych. Następnie z tego oblicza się procent.

Wyzwanie:

Spróbuj obliczyć procent zaszczepionych osób, które się zaraziły! (Wskazówka: jest bardzo podobny do powyższego kodu, jednak niektóre zmienne są zmieniane, a nazwy dostosowywane.)

Następnie obliczany jest procent zarażonych osób w oparciu o całkowitą populację:

pre_per_infect = cumsum(infectionMat(2,:));

per_infect = (pre_per_infect(1, LICZBA LUDZI)/LICZBA LUDZI)*100;

Wyjaśnienie kodu

Skumulowana suma jest obliczana przy użyciu drugiego wiersza infekcjiMat, który przechowuje jedynki i zera w zależności od tego, czy dana osoba jest zarażona, czy nie. Ponieważ funkcja cumsum() zwraca macierz, bierzemy ostatnią wartość w macierzy ('pre_per_infect(1, NUMOFPEOPLE)'), która powinna być rzeczywistą sumą wszystkich wartości z 'infectionMat(2,:)'. Dzieląc sumę przez LICZBĘ LUDZI i mnożąc ją przez 100 otrzymujemy ostateczny procent zarażonych w całej populacji.

Krok 11: Utwórz zmienną wyjściową w swojej funkcji „infectionSim.m”

wyjście = [na_infekcję, procent_od_nieskażonych_i_zakażeń, procent_od_odinfekowania_i_infekcji];

Wyjaśnienie kodu

Przechowuj te informacje w danych wyjściowych, które zostaną wysłane z powrotem do głównego (Monte_Carlo.m) po wywołaniu funkcji i zakończeniu jej działania. Dane te służą do wykreślenia procentu zarażonych osób zaszczepionych i nieszczepionych.

Twoja funkcja 'infectionSim.m' powinna być teraz wykonana! Jednak nie będzie działać, ponieważ nadal musimy napisać główny!

Krok 12: Utwórz menu, aby uzyskać początkowe warunki symulacji od użytkownika

Pamiętaj, jak powiedzieliśmy zmienną

prędkość

zostanie utworzony i przekazany przez główną funkcję? Musimy uzyskać wartości, które mają zostać przekazane do funkcji. Uwaga, kolejność wartości podczas wywoływania funkcji ma znaczenie!

Zacznij od poproszenia użytkownika o wpisanie kilku odpowiedzi w terminalu.

> Wybierz chorobę. Pamiętaj, że wielkość liter jest rozróżniana>> Krztusiec >> Grypa >> Odra >> Wybrana choroba: Grypa >> Wybierz wielkość populacji. >> 20 >> 200 >> Wybrana populacja: 20 >> Wybierz prędkość symulacji. >> Szybko >> Wolno >> Wybrana prędkość: Szybko

Poniższy kod pyta użytkownika, jaką chorobę chce zbadać.

disp('Wybierz chorobę. Pamiętaj, że rozróżniana jest wielkość liter')

fprintf('Krztusiec\nGrypa\nOdra\n') choroba = input('Wybrana choroba: ', 's'); if isequal(choroba, 'Krztusiec') vacc = 0,85; %15% szansy na odszczepienie choroby = 0,20; %80 procent szans na zachorowanie w innym przypadkujeśli isequal(choroba, 'Grypa') vacc = 0,75; %25 procent szans na zachorowanie na nieszczepienie = 0,31; %69 procent szans na zachorowanie w innym przypadkujeśli isequal(choroba, 'Odra') vacc = 0,97; %3% szansy na odszczepienie choroby = 0,10; %90 procent szans na zakończenie choroby

Wyjaśnienie kodu:

Funkcja disp() wyświetla instrukcję na ekranie, a także wyświetla różne opcje. Choroba zostanie odpowiednio przypisana. Ta wersja obecnie nie uwzględnia nieprawidłowych danych wejściowych. Nieprawidłowe dane wejściowe spowodują błąd i całkowicie zatrzyma program. Z każdą chorobą związane są wartości vacc i unvacc. Te wartości NIE są losowe. Otrzymaliśmy te wartości z badania statystyk dotyczących chorób.

Następnie musimy zapytać użytkownika, czy chce przetestować dużą czy małą populację pod kątem wybranej przez siebie choroby.

disp('Wybierz wielkość populacji.')

fprintf('20\n200\n') speed = input('Wybrana populacja: ', 's'); if isequal(speed, '20') populacja_size = 20; elseif isequal(speed, '200') populacja_size = 200; kończyć się

Wyjaśnienie kodu

Spowoduje to wydrukowanie instrukcji dla użytkownika i poproszenie użytkownika o podanie wielkości populacji, którą chce przetestować. Ta wersja obecnie nie uwzględnia nieprawidłowych danych wejściowych. Nieprawidłowe dane wejściowe spowodują błąd i całkowicie zatrzyma program. 20 został wybrany, ponieważ jest to niewielka próbka, która nadal daje dobre wyobrażenie o tym, jak infekcja rozprzestrzenia się w małej populacji. Jako większą opcję wybrano 200 osób, ponieważ 200 punktów na wykresie prawie się nie pokrywało, więc wszystko można było łatwo zobaczyć i odróżnić od siebie.

Następnie musimy znaleźć prędkość symulacji.

disp('Wybierz prędkość symulacji.')

fprintf('Szybko\nWolno\n') speed = input('Wybrana prędkość: ', 's'); if isequal(speed, 'Fast') sim_speed = 0; elseif isequal(speed, 'Slow') sim_speed = 0,25; kończyć się

Wyjaśnienie kodu

Proces ten był taki sam, jak uzyskiwanie rodzaju choroby i wielkości populacji. Na szybko nie będzie przerwy. a dla powolnych, będzie 0,25 sekundy opóźnienia w pętli for podczas uruchamiania symulacji.

Świetny! Teraz mamy wszystkie potrzebne dane wejściowe od użytkownika! Przejdźmy do zbierania danych dla różnych odsetków osób nieszczepionych.

Krok 13: Wybierz % osób niezaszczepionych i oblicz średnią niezaszczepionych i zarażonych na wybrany procent

Ten kod jest przeznaczony dla 0% osób nieszczepionych.

% ------- %0 Nieszczepione ------------

per_infect_av_0 = ; percent_of_unvacc_and_infec_av_0 = ; dla i = 1:20 out = infekcjiSim(unvacc, vacc, populacja_size, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out(1, 1)]; percent_of_unvacc_and_infec_av_0 = [procent_of_unvacc_and_infec_av_0, out(1, 2)]; koniec średnia_zainfekowana_0 = średnia(na_zainfekowaną_śr_0); średnia_unvacc_and_infected_0 = średnia(procent_unvacc_and_infec_av_0);

Wyjaśnienie kodu:

Pętla for jest uruchamiana 20 razy. Dane wyjściowe funkcji infekcjaSim() są przechowywane w out. Za każdym razem, gdy uruchamiana jest pętla for, procent zainfekowanych w całej populacji jest dodawany do macierzy „per_infect_av_0”. Ponadto odsetek osób niezaszczepionych i zarażonych jest również dodawany za każdym razem do macierzy „procent_of_unvacc_and_infec_av_0”. W ostatnich dwóch wierszach te dwie, wyżej wymienione macierze są następnie uśredniane i przechowywane w zmiennych. Podsumowując, wartości procentowe są przechowywane dla każdej symulacji, uśredniane i przedstawiane na wykresach. Monte Carlo służy do pokazywania średniej wartości przebiegu symulacji i pokazywania wyniku. Dla naszych celów eksperymentalnych postanawiamy przeprowadzić symulację 20 razy i uśredniamy te wartości.

Wyzwanie:

Powtórz dla wszystkich wartości procentowych, które chcesz przetestować! Można to zrobić zmieniając nazwy zmiennych zgodnie z liczbami procentowymi. Testowaliśmy dla 0%, 5%, 10%, 20%, 30% i 50%.

Wskazówka:

Jedyny wiersz, który należy zmienić w rzeczywistym kodzie, to

out = zakażenieSim(unvacc, vacc, populacja_rozmiar, 0, 1, sim_speed);

Zmień zero na procent w postaci dziesiętnej. Na przykład, dla 5% nieszczepionych symulacji, 0 powinno być zastąpione przez 0.5.

Krok 14: Wykres: „Trend infekcji u nieszczepionych vs. Zaszczepione na określone choroby”

Jest to kod do stworzenia wykresu trendu infekcji u osób niezaszczepionych w porównaniu z osobami niezaszczepionymi.

graph_mat_y = [średnia_zainfekowanych_0, średnia_zainfekowanych_5, średnia_zainfekowanych_10, średnia_infekowanych_20, średnia_infekowanych_30, średnia_infekowanych_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; nachylenie = (średnia_zainfekowana_5-średnia_zainfekowana_0)/5; linia_y = [średnia_zainfekowana_0, (nachylenie*50)+średnia_zainfekowana_0]; linia_x = [0, 50]; rysunek(2) wykres(graph_mat_x, graph_mat_y); line(line_x, line_y, 'Kolor', 'czerwony', 'Styl Linii', '--'); title(['Trend w nieszczepieniach dla', choroba]); xlabel('Procent początkowo niezaszczepionych'); ylabel('Procent ostatecznego zainfekowania')

Wyjaśnienie kodu

linia 1: przypisano wartości y do średnich odsetka zarażonych

wiersz 2: przypisano wartości x do procentu początkowego odsetka osób niezaszczepionych

linia 3: oblicz nachylenie 0% i 5%

linia 4: przechowuj wartości y linii. Jest to kontynuacja sekcji 0% do 5%.

linia 5: przechowuj wartości y linii. Ta linia obejmuje długość wykresu.

linia 6: utwórz figurę!

linia 7: wykreśl wykres wartości x i y odsetka zarażonych osób niezaszczepionych.

linia 8: wykreśl linię. Służy to do pokazania, że nie rośnie liniowo, ale wykładniczo.

linia 9: Ustaw tytuł wykresu.

wiersz 10-11: Ustaw etykiety x i y dla wykresu.

Teraz powinieneś być w stanie zauważyć, że im większy odsetek populacji nie jest zaszczepiony, tym większa ilość infekcji. Zobaczysz również, że większość kropek, które zmieniają kolor na czerwony, to kropki zielone, co pokazuje, że szczepionka w pewnym stopniu pomaga! Mam nadzieję, że podobał Ci się ten samouczek. Skomentuj, jeśli masz jakieś pytania!

Krok 15: Produkt końcowy: Jak wygląda symulacja

Cały kod można znaleźć tutaj