Oltani vagy sem? egy projekt az állomány immunitásának megfigyeléséről a betegségek szimulációján keresztül: 15 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

A projekt áttekintése:

Projektünk az állomány immunitását vizsgálja, és azt reméli, hogy ösztönözni tudjuk az embereket oltásra, hogy csökkentsük a fertőzöttséget közösségeinkben. Programunk szimulálja, hogy egy betegség hogyan fertőzi meg a lakosságot különböző százalékos oltott és nem oltott arányokkal. Az állomány immunitását mutatja, megmutatva, hogy a beoltott populáció megnövekedett száma hogyan csökkentheti az érintettek számát.

Ezt a Matlabban modellezzük gráfelméleti fogalmak segítségével. A gráfelmélet matematikai módszer az objektumok közötti kapcsolatok ábrázolására. A gráfelméletben a gráfok csúcsokkal (vagy csomópontokkal) vannak összekötve élekkel (vagy vonalakkal). Projektünkben a csomópontok az érintett személyek, a szélek pedig a kapcsolataik. Például, ha két csomópont egy éllel van összekötve, akkor ez azt jelenti, hogy "barátok" vagy valamilyen formában érintkeznek egymással. Ez a kapcsolat a betegség terjedésének módja. Ezért használtuk fel gráfelméletet koncepciónk modellezésére, mert látni akartuk, hogyan terjed a betegség a populációban összekapcsolt egyének között.

Projektünk magában foglalja a Monte Carlo -módszert is. A Monte Carlo módszer olyan algoritmus, amely ismétlődő véletlen mintavételt hoz létre a numerikus eredmények fogadásához. Projektünkben ezt a módszert használjuk a szimulációnk futtatásához, többször megváltoztatva a kezdeti vakcinálatlanok százalékos arányát, hogy lássuk, milyen arányban fertőződnek meg az emberek.

Az összes projektkód alul van linkelve!

PC-hitel:

A Matlab linkje a Graph Theory-hoz:

1. lépés: Hozzon létre szomszédsági mátrixot

Hozzon létre egy új szkriptet. A mi fertőzésünk Simm.

Létrehozunk egy "NUMOFPEOPLE" változót. Bármilyen egész értékhez rendelheti. Ez jelzi a lakosság létszámát.

Mostantól ezt feltételezzük

NUMOFPEOPLE = 20;

Először a Matlab gráfelméleti függvényeit használja egy irányítatlan gráfhoz.

Ha többet szeretne megtudni, itt van egy link, ahol részletesebben olvashat róla.

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

Létrehozott egy szomszédsági mátrixot.

adjMatrix = nullák (NUMOFPEOPLE);

Ezzel létrejön egy négyzet alakú mátrix. A mátrix minden sora egy személy. A mátrix minden oszlopa egy személy vagy barát, akivel a nap folyamán találkozik.

Lásd a 100. ábrát (fent), hogy segítsen elképzelni, hogyan néz ki az adjMatrix 20 ember számára.

** Ettől kezdve feltételezzük, hogy a NUMOFPEOPLE egyenlő 20 -mal. **

Megpróbálhatja ábrázolni ezt a szomszédsági mátrixot. Itt van egy kis információ az ilyen típusú mátrixok ábrázolásáról.

Megjegyzés: A szomszédsági mátrix működése.

Volt:

%teszi a szomszédos mátrixot

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] %ábrázolás g = grafikon (a); %a gráffüggvény (gráfelmélet) használatával (1); h = diagram (g);

Lásd az 1. ábrát (fent), hogy megtudja, hogyan adhat hozzá éleket a szomszédsági mátrixhoz a "Megjegyzés" kóddal.

2. lépés: Hozzon létre kapcsolatokat

Most, hogy a személyek (csúcsok vagy csomópontok) létrejöttek, létre kell hoznunk egy kapcsolathálózatot (a gráf vonalait vagy széleit). Ez szimulálja, hogy az emberek hogyan lépnek kapcsolatba és találkoznak másokkal egy nap alatt.

Ezt sokféleképpen meg lehet tenni. Ennek a feladatnak az egyik módja az, hogy először egy véletlen számot rendel hozzá minden személyhez, hogy meghatározza, hány ember fog kapcsolatba lépni egy nap alatt.

numOfFriendsMatrix = randi ([legkisebbFriendsPersonCanHave, mostFriendsPersonCanHave], 1, NUMOFPEOPLE);

Ez 1-20 mátrixot tartalmaz véletlenszerű egész számokból, amelyek az egyes személyek napi interakcióinak számát jelzik. Ennek a mátrixnak az oszlopai az egyes személyeknek megfelelő számok. Például, ha hozzárendeljük a lessFriendsPersonCanHave = 2 és mostFriendsPersonCanHave = 5 értékeket, akkor véletlenszerű értékeket kapunk 2 és 5 között.

Problémái vannak a randi () -val? A terminálban írja be

segíts randi

Ezután elkészítünk egy randomizált mátrixot (az úgynevezett "allFriendsmatrix") arról, hogy a populáció minden egyes tagja hogyan kapcsolódik/interakcióba lép a populáción belül.

tempMatrix = ;

szám = 0; allFriendsMatrix = ; k = 1 esetén: NUMOFPEOPLE, míg hossza (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (count) = temp; vége minden törlés közben hosszú (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; szám = 0; vége

A kód részletes magyarázata:

Először létre kell hoznunk egy üres ideiglenes mátrixot az egyes személyek baráti/interakciós listájának tárolására. Inicializáljuk a számlálást is, amely csak nyomon követi, hogy hová illessze az új véletlenszerű kapcsolatot a tempMatrix -ban. A for ciklusok 20 -szor futnak, így ez a populáció minden egyes személyére megtörténik. Az első while ciklus addig fut, amíg az egyes személyek tempMatrix -ja megegyezik a véletlenszerűen hozzárendelt interakciók számával. Ebben a ciklusban a populációban lévő személynek megfelelő véletlen szám jön létre és kerül a tempMatrix -ba. Mivel az egyes tempMatrixok hossza eltérő, létre kellett hoznunk néhány NaN -értéket, hogy ezeket a tempMatic -eket egyetlen mátrixba („allFriendsMatrix”) össze tudjuk kapcsolni. A második while ciklus ezt a problémát úgy oldja meg, hogy NaN -t ad hozzá minden egyes tempMatrix -hoz. A while ciklus 9 -szer futott, mert az 5 -nél nagyobb szám, amely a barátok felső határa volt, akikhez hozzárendelhető egy személy. A „9” érték változó, és akkor lehet/kell változtatni, ha a „mostFriendsPersonCanHave” nagyobb, mint 9. A kód utolsó három sora (kivéve a végét) hozzáadja a tempMatrixot az „allFriendsMatrix” következő sorához. Ezután törli a tempMatrix -ot és számolja a következő személyt.

Kimenet

Így kell kinéznie a kimenetnek a for ciklus első futtatásakor (az utolsó három sor előtt).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

allFriendsMatrix =

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

Ezután adja hozzá ezeket a kapcsolatokat az adjMatrix -hoz.

eachRow = 1: NUMOFPEOPLE

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

Kódmagyarázat

Ez a dupla ciklus végigmegy az „allFriendsMatrix” minden során és oszlopán. Az if utasítás minden olyan értékre fut, amely nem 'NaN'. Alapvetően a grafikon széleit vagy vonalait hozza létre. Tehát az első sor ez lesz az 1. személytől a 16. személyig és a 16. személytől az 1. személyig. Nem csak az élünk 1 -től 16 -ig terjedhet, hanem 16 -tól 1 -ig. Szimmetrikusnak kell lenniük ahhoz, hogy megfelelően fusson a Matlabban.

Szimulációnk során megállapítottuk, hogy az emberek nem tudnak kölcsönhatásba lépni önmagukkal. Amikor randomizáltuk az értékeket, akkor van esély arra, hogy a szomszédos mátrixunkban vannak ilyen hibák.

Javítsuk ki ezt a következő kóddal:

mindegyikre = 1: NUMOFPEOPLE

adjMatrix (mindegyik, mindegyik) = 0; vége

Kódmagyarázat

Ez a hurok esetén biztosítja, hogy az 1. személy ne kapcsolódjon az 1. személyhez, a 2. személy ne kapcsolódjon a 2. személyhez stb., Ha mindegyiket 0 -ra állítja. Amint az alábbiakban a kimeneti részben látható, megvan a négyzet átlója a mátrix a bal felső saroktól a jobb alsóig mind 0.

Kimenet

Ez a jelenlegi szimuláció utolsó adjMatrix -ja. Ez a grafikon összes sora (2. ábra).

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

Az „adjMatrix” grafikonját lásd a 2. ábrán.

3. lépés: Adja hozzá a betegségstatisztikákat

Most, hogy a programja létrehozhat egy grafikont véletlenszerű személyek halmazával, és véletlenszerű kapcsolatokat hozhat létre, be kell írnunk a betegség adatait vagy statisztikáit, hogy lássuk, hogyan növelhetik vagy csökkenthetik a fertőzést ezek a populáción belüli interakciók.

Hozza létre ezeket a változókat:

unvacc %típus: dupla; százalékos esélye van arra, hogy a nem oltott emberek ne kapják meg a betegséget

vakc %típusa: kettős; százalékos esélye annak, hogy a beoltott emberek nem kapják meg a betegséget unvacc_perc %type: double; százalékos populáció nem oltott init_infect %típus: int; százaléka oltott

Ezután néhány számítást kell elvégeznünk.

Készítünk egy „fertőzésmat”, amely egy 3*NUMOFPEOPLE mátrix.

vacc_perc = 1-unvacc_perc;

fertőzésMat = nan (3, NUMOFPEOPLE); szám = kerek (vacc_perc * NUMOFPEOPLE); fertőzésMat (1, 1: szám) = vakcina; fertőzésMat (1, szám+1: vége) = unvacc; fertőzésMat (2, 1: vége) = 0; fertőzésMat (2, 1: init_infect) = 1;

Kódmagyarázat

1. sor: A vakcinázatlan populáció százalékos aránya kiszámítva

2. sor: hozzon létre egy 3*N számú ember mátrixot

3. sor: az oltottak százalékos arányából megtudhatja az oltottak számát

4. sor: a vakcinázott személyek számára adjon immunitást az oltás megszerzéséhez. Ezt az értéket a betegséggel kapcsolatos kutatások alapján határozzák meg.

5. sor: a lakosság többi része (vakcinázatlan személyek) számára adja meg a százalékos immunitást. Ezt az értéket a betegséggel kapcsolatos kutatások alapján határozzák meg.

6. sor: kezdetben állítsa be az összes embert, hogy ne legyen fertőzött.

7. sor: az eredetileg fertőzöttek számának megfelelően töltse ki az első pár oszlopot.

Most, hogy minden paramétert beállítottunk a betegségszimulációhoz, véletlenszerűen kiválasztjuk annak esélyét, hogy a személy (oltott és oltatlan is) megfertőződik -e. Ezt a következő lépésben úgy kell elvégezni, hogy 0 és 1 közötti véletlen értékeket rendel hozzá minden személyhez a „fertőzésMat” harmadik sorában.

4. lépés: Randomizálja annak esélyét, hogy egy oltott és nem oltott személy megfertőződhet

Ezután rendeljen minden személyhez egy véletlen számot, amelyet később használnak annak megállapítására, hogy a személy megfertőződik -e vagy sem.

w = 1 esetén: hossz (fertőzésMat)

fertőzésMat (3, w) = rand; vége

Kódmagyarázat

Ez a ciklus az utolsó lépésben létrehozott „infekcijaMat” harmadik sorával foglalkozik. A "rand" 0 és 1 közötti értéket rendel a 3. sor minden indexéhez.

Kimenet

fertőzésMat most befejeződött! Ez a populáció 100% -os oltással és 1 fővel volt fertőzött.

fertőzésMat =

1–12. Oszlop 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 0,0869 0,5489 0,3177 0,9927 0,7236 0,5721 0,7172 0,9766 0,4270 0,9130 0,8973 0,00 0,7500 Oszlop 0.7500 0.7500 0 0 0 0 0 0 0 0 0 0.0480 0.3593 0.2958 0.6291 0.1362 0.3740 0.8648 0.2503

1. sor: Százalékos esély, hogy NEM kapja el a betegséget

2. sor: Fertőzött vagy nem fertőzött (logikai érték)

3. sor: Szám, amellyel ellenőrizhető, hogy a nem fertőzött személy megfertőződik -e, ha fertőzött személlyel találkozik. Ha egy nem fertőzött személy találkozik fertőzött személlyel, ez a szám nagyobb, mint az 1. sorban (ugyanazon oszlop esetén) szereplő szám, akkor fertőzött. Ezt a funkciót a 7. lépésben kódoljuk.

5. lépés: Hozzon létre mátrixokat a vakcinázatlan és fertőzött emberekről a kezdeti információkból

Hozzon létre 2 „mátrixUnvacc” és „matrixInfected” nevű mátrixot, amelyek tárolják az összes fertőzött személyt a fertőzéstől. Ezt arra használjuk, hogy színkódolhassuk a fertőzött, nem oltott vagy oltott személyek grafikonját, segítve a vakcinázatlan és a vakcinázott személyek hatásának vizualizálását.

tisztítsa meg mindegyiket

matrixInfected = ; mátrixUnvacc = ; h = 1 esetén: hossz (fertőzésMat), ha fertőzésMat (1, h) == unvacc matrixUnvacc = [mátrixUnvacc, h]; end end for person = 1: NUMOFPEOPLE if fertőzésMat (2, személy) == 1 matrixInfected = [matrixInfected, személy]; vége vége

Kódmagyarázat

Hozzon létre két üres mátrixot a vakcinázatlan és fertőzött személyek számának tárolására. Mindkét ciklus 20 -szor fut, és ha az if utasítás teljesül, akkor a szám hozzáadódik a helyes mátrixhoz.

Kimenet

matrixUnvacc =

matrixInfected =

[1]

6. lépés: A kezdeti grafikon ábrázolása

Ezután a szomszédsági mátrixot ábrázoljuk.

g = grafikon (adjMatrix);

(1) ábra p = plot (g, 'NodeColor', 'b', 'MarkerSize', 7); kiemelés (p, matrixUnvacc, 'NodeColor', 'g') kiemelés (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title (['Az oltatlanok százaléka:', num2str (title_unvacc), '%']); szünet (sebesség)

Kódmagyarázat

A Matlab grafikonelmélete beépített függvényeket tartalmaz. A graph () függvény használatakor le tudjuk fordítani az „adjMatrix” -t egy tényleges irányítatlan gráffá. Ezután létre kell hoznunk egy plotot a plot () függvény használatával, hogy valóban lássuk, hogyan néz ki. Ezt a diagramot () változónak állítjuk be, hogy a szimuláció során könnyebben tudjuk manipulálni és megváltoztatni a diagram színeit. Minden ember (vagy csomópont) kezdetben a „kék” színre van állítva. Ezután minden oltatlan ember a „zöld” színre van állítva. A fertőzött embereket ezután a „vörös” színre állítják. A címet a be nem oltott személyek bizonyos százalékos értékének megfelelően állítják be. A pause () függvény ideiglenesen leállítja a MatLab végrehajtását. Áthaladunk a változó sebességgel, amelyet másodpercek alatt számolunk.

Lásd a fenti képet, hogy véletlenszerűen színkódolt grafikont láthasson.

További információ a MatLab kiemelés () függvényéről.

7. lépés: Szimulálja a fertőzés előrehaladását

Ezután ki kell találnunk, hogy ki fertőződik meg az interakciók után (rögzítve az adjMatrix -ban), és frissítenünk kell a grafikont, ha valaki megfertőződik.

Az adjMatrix segítségével határozza meg, hogy mely emberek fertőződtek meg az emberekkel való interakció után egy nap alatt.

mindegyik sorhoz = 1: hossz (adjMatrix)

if fertőzésMat (2, mindegyik sor) == 1 mindegyikreCol = 1: hossz (adjMatrix) if adjMatrix (eachRow, eachCol) == 1 % eachRow = a személy % everyCol = a barátja % minden ember barátja, és nézze meg, hogy fertőzött -e. ha fertőzésMat (3, mindegyikCol)> fertőzésMat (1, mindegyikCol) fertőzésMat (2, mindegyikCol) = 1; kiemelés (p, eachCol, 'NodeColor', 'r') szünet (sebesség) vége vége vége vége vége

A for ciklus minden egyes személyen áthalad. Ellenőrzi, hogy ha a személy fertőzött, akkor minden embert/barátot, akivel kapcsolatba lépett, ellenőrizni fogja, és hogy a barát immunitási szintje nagyobb volt -e, mint a betegség erőssége. Itt jön szóba a korábban létrehozott „fertőző mat”. A barát minden oszlopának 1. és 3. sorát összehasonlítjuk, és ha a 3. sor nagyobb, az azt jelenti, hogy a barát nem volt elég magas immunitással a betegség elől, és végül megfertőződik. Mi is színre váltunk a kiemelés () használatával vörösre, ha megfertőződnek.

Most a szimuláció kódjának működnie kell! és bármilyen méretű népesség esetén csak cseréljen NUMOFPEOPLE -t!

8. lépés: Használja a Monte Carlo elméletet

Annak érdekében, hogy ezt a lépést tovább tegyük, és adatokat nyerjünk ki a szimulátorunkból („infekcijaSim.m”), ki akartuk számítani és ábrázolni a nem fertőzött vakcinázottak százalékos arányát és a vakcinázottak százalékát. Feltételezésünk szerint a védőoltással fertőzöttek százalékos arányának sokkal alacsonyabbnak kell lennie, mint a vakcinázatlanoké.

9. lépés: Készítse el a fájlt ('infekcijaSim.m') a szimulációval egy funkcióvá

A Monte Carlo futtatásához szeretnénk többször is futtatni a szimulációt, és adatokat gyűjteni annak érdekében, hogy felhasználhassuk a fertőzöttek százalékos arányának ábrázolására.

A funkció a következőképpen állítható be:

függvény kimenet = fertőzésSim (unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Írja le a szimulációban szereplő változókat, mivel most ezeket adja át a fő fájlban (ezt a 12. lépésben kezdjük el írni):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

Az új változó

sebesség

lesz hozzárendelve a fő fájlhoz (Monte_Carlo.m).

Megjegyzés: A funkció befejezéséhez ne felejtse el a függvény alján lévő végét!

10. lépés: Számítsa ki a fertőzött nem oltott és oltott emberek százalékos arányát

Ez kiszámítja a vakcinázatlanok százalékos arányát, akik megfertőződtek. Ez a kód az "infekcijaSim.m" fájl alján található.

unvacc_száma = 0;

number_of_infec_unvacc = 0; %kiszámítja az oltatlan emberek százalékos arányát, akik megfertőződtek x = 1 esetén: hossz (fertőzésMat), ha fertőzésMat (1, x) == unvacc szám_of_unvacc = szám_feltöltetlen+1; vége, ha fertőzésMat (1, x) == unvacc & fertőzésMat (2, x) == 1_f_infec_unvacc = number_of_infec_unvacc +1; vége vége százalékos_azonosító_ és_fegyverzet = (szám_azonosító_száma / szám_azonosító_száma)*100;

Kódmagyarázat

A for ciklusban NUMOFPEOPLE alkalommal ciklusos lesz. Minden alkalommal, amikor a fertőzésmatikus szám megegyezik a vakcinázatlan számmal (azaz 0,95 == 0,95), akkor a nem oltott személyek száma 1 -gyel növekszik. a fertőzöttek és a nem oltottak száma 1 -gyel nő. Az utolsó sor osztja el a fertőzött, nem oltottak számát a nem oltott személyek számával. Ezután a százalékot ebből számítják ki.

Kihívás:

Próbálja meg kiszámítani a fertőzöttek százalékos oltását! (Tipp: nagyon hasonlít ehhez a fenti kódhoz, azonban néhány változó megváltozik, és a nevek módosulnak.)

Ezután kiszámítják a fertőzöttek százalékát a teljes népesség alapján:

pre_per_infect = cumsum (fertőzésMat (2,:));

per_infect = (pre_per_infect (1, NUMOFPEOPLE)/NUMOFPEOPLE)*100;

Kódmagyarázat

Az összesített összeget a fertőzésMat második sora alapján kell kiszámítani, amely 1 -et és 0 -at tárol attól függően, hogy a személy fertőzött -e vagy sem. Mivel a cumsum () függvény visszaad egy mátrixot, a mátrix utolsó értékét vesszük ('pre_per_infect (1, NUMOFPEOPLE)'), amelynek az 'infekcióMat (2,:)' összes értékének tényleges összegének kell lennie. Ha az összeget elosztjuk a NUMOFPEOPLE -al, és megszorozzuk 100 -zal, akkor megkapjuk a fertőzöttek végső százalékát a teljes populációban.

11. lépés: Hozzon létre egy kimeneti változót a „fertőzésSim.m” funkciójában

output = [per_infect, proc_of_unvacc_and_infec, percent_of_vacc_and_infec];

Kódmagyarázat

Tárolja ezeket az információkat a kimenetben, amelyeket a funkció hívásakor és futásakor visszaküld a main (Monte_Carlo.m) címre. Ezeket az adatokat arra használják, hogy grafikonon ábrázolják a vakcinázott és nem oltott fertőzöttek százalékos arányát.

Az 'infekcióSim.m' funkcióját most végre kell hajtani! Azonban nem fog futni, mert még mindig meg kell írnunk a főt!

12. lépés: Hozzon létre egy menüt a szimuláció kezdeti feltételeinek a felhasználótól való lekéréséhez

Ne feledje, hogyan mondtuk a változót

sebesség

létrejön és áthalad a fő funkción? Meg kell szereznünk a függvényhez átadandó értékeket. Megjegyzés: a függvény meghívásakor az értékek sorrendje számít!

Kezdje azzal, hogy megkéri a felhasználót, hogy írjon be néhány választ a terminálba.

> Válasszon betegséget. Ne feledje, hogy a kis- és nagybetűket megkülönböztetik >> Pertussis >> Influenza >> Kanyaró >> Kiválasztott betegség: influenza >> Válassza ki a populáció méretét. >> 20 >> 200 >> Választott populáció: 20 >> Szimulációs sebesség kiválasztása. >> Gyors >> Lassú >> Választott sebesség: Gyors

Ez az alábbi kód megkérdezi a felhasználót, hogy milyen betegségre szeretne figyelni.

disp ("Válasszon ki egy betegséget. Vegye figyelembe, hogy a kis- és nagybetűk érzékenyek")

fprintf ('Pertussis / nFlu / nMearles / n') disease = input ('Kiválasztott betegség:', 's'); ha isequal (betegség, „Pertussis”) vacc = 0,85; %15 százalék esély a betegség elkapására unvacc =.20; %80 százalék az esélye a betegség megszerzésére, ha más (betegség, „influenza”) oltás = 0,75; %25 százalék esély a betegség elkapására unvacc =.31; %69 százalék az esélye a betegség megszerzésére, ha más (betegség, „kanyaró”) oltás = 0,97; %3 százalék esély a betegség elkapására unvacc =.10; 90 %az esélye, hogy véget ér a betegség

A kód magyarázata:

A disp () függvény kinyomtatja a nyilatkozatot a képernyőre, és kinyomtatja a különböző lehetőségeket is. A betegséget ennek megfelelően rendelik hozzá. Ez a verzió jelenleg nem veszi figyelembe az érvénytelen bevitelt. Az érvénytelen bemenet hibát okoz, és teljesen leállítja a programot. Minden betegséghez vakcinázási és védőoltási értékek kapcsolódnak. Ezek az értékek NEM véletlenszerűek. Ezeket az értékeket a betegségekre vonatkozó statisztikák kutatásából nyertük.

Ezt követően meg kell kérdeznünk a felhasználót, hogy nagy vagy kis populációt szeretne -e tesztelni a választott betegség szempontjából.

disp ('A populáció méretének kiválasztása.')

fprintf ('20 / n200 / n ') speed = input (' Kiválasztott populáció: ',' s '); ha isequal (sebesség, '20') népesség_méret = 20; elseif isequal (sebesség, '200') népesség_méret = 200; vége

Kódmagyarázat

Ez kinyomtat egy nyilatkozatot a felhasználónak, és kéri a felhasználót, hogy adja meg, hogy mekkora populációt szeretne tesztelni. Ez a verzió jelenleg nem veszi figyelembe az érvénytelen bevitelt. Az érvénytelen bemenet hibát okoz, és teljesen leállítja a programot. A 20 -at azért választották ki, mert ez egy kicsi minta, amely még mindig jó képet ad arról, hogyan terjed a fertőzés egy kis populációban. 200 embert választottak nagyobb opciónak, mert a grafikonon ábrázolt 200 pontban alig volt átfedés, így minden könnyen látható és megkülönböztethető volt egymástól.

Ezután meg kell találnunk a szimuláció sebességét.

disp ('Szimulációs sebesség kiválasztása.')

fprintf ('Gyors / nLassú / n') speed = input ('Sebesség választva:', 's'); if isequal (speed, 'Fast') sim_speed = 0; elseif isequal (sebesség, 'Lassú') sim_speed = 0,25; vége

Kódmagyarázat

Ez a folyamat megegyezett a betegség típusának és a populáció méretének megállapításával. A gyors, nem lesz szünet. lassú esetén pedig 0,25 másodperces késés lesz a for ciklusban a szimuláció futtatásakor.

Nagy! Most már minden szükséges adatot megkapunk a felhasználótól! Folytassuk az adatok begyűjtésével a nem oltott emberek különböző százalékairól.

13. lépés: Válassza ki a nem oltott emberek százalékát, és számítsa ki a nem oltott és fertőzött átlagot a kiválasztott százalékhoz

Ez a kód a vakcinázatlan emberek 0% -ára vonatkozik.

% ------- % 0 Nem oltott ------------

per_infect_av_0 = ; százalékos_azonosító_ és_felesleg_av_0 = ; i = 1:20 ki = fertőzésSim (unvacc, vakc, populációméret, 0, 1, sim_sebesség); per_infect_av_0 = [per_infect_av_0, out (1, 1)]; percent_of_unvacc_and_infec_av_0 = [percent_of_unvacc_and_infec_av_0, out (1, 2)]; vége átlagos_fertőzött_0 = átlag (fertőzött_av_0); átlagos_unvacc_and_infected_0 = átlag (százalékos_vagyon_ és_fertőzés_av_0);

A kód magyarázata:

A for ciklus 20 -szor fut. A fertőzésSim () függvény kimenete ki van tárolva. Minden alkalommal, amikor a for ciklus fut, a fertőzöttek százalékos aránya a teljes populációban hozzáadódik a „per_infect_av_0” mátrixhoz. Ezenkívül a nem oltott és fertőzöttek százalékos arányát is minden alkalommal hozzáadják a 'százalékos_azonosító_ és_fegyverzet_ mátrix' mátrixhoz. Az utolsó két sorban ezt a két, fent említett mátrixot átlagoljuk, és változókban tároljuk. Összefoglalva, a százalékokat minden szimulációhoz tároljuk, átlagoljuk és grafikonokkal ábrázoljuk. A Monte Carlo -t a szimuláció futtatásának és az eredmény megjelenítésének átlagos értékének megjelenítésére használják. Kísérleti céljaink szerint a szimulációt 20 -szor futtatjuk, és átlagoljuk ezeket az értékeket.

Kihívás:

Ismételje meg az összes tesztelni kívánt százalékot! Ezt úgy lehet megtenni, hogy a változóneveket a százalékos számoknak megfelelően módosítjuk. Vizsgáltunk 0%, 5%, 10%, 20%, 30%és 50%.

Célzás:

Az egyetlen sor, amelyet meg kell változtatni a tényleges kódban, az

ki = fertőzésSim (unvacc, vakcina, populáció_méret, 0, 1, sim_sebesség);

Változtassa meg a nullát százalékra tizedes formában. Például 5% vakcinázatlan szimuláció esetén a 0 -t fel kell cserélni 0,5 -re.

14. lépés: Grafikon: „A fertőzés tendenciája a vakcinázatlan vs. Meghatározott betegség miatt oltva"

Ez a kód arra szolgál, hogy grafikont készítsen a vakcinázatlan személyek és a nem oltott személyek fertőzésének tendenciájáról.

grafikon_mat_y = [átlagos_fertőzött_0, átlagos_fertőzött_5, átlagos_fertőzött_10, átlagos_fertőzött_20, átlagos_fertőzött_30, átlagos_fertőzött_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; lejtés = (átlagos_fertőzött_5-átlagos_fertőzött_0)/5; vonal_y = [átlagos_fertőzött_0, (meredekség*50)+átlagos_fertőzött_0]; line_x = [0, 50]; ábra (2) plot (graph_mat_x, graph_mat_y); line (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); title (['Tendents az oltás hiánya', betegség]); xlabel ('A kezdeti vakcinálatlanok százaléka'); ylabel ('A végső fertőzöttek százalékos aránya')

Kódmagyarázat

1. sor: y értékeket rendelt a fertőzöttek százalékos átlagaihoz

2. sor: x értékeket rendelt a vakcinálatlan kezdeti százalék százalékához

3. sor: számítsa ki a 0% és az 5% -os meredekséget

4. sor: a sor y értékeinek tárolása. Ez a 0% és 5% közötti szakasz folytatása.

5. sor: a sor y értékeinek tárolása. Ez a vonal a grafikon hosszát öleli fel.

6. sor: ábra készítése

7. sor: ábrázolja a vakcinálatlan fertőzöttek százalékos x és y grafikonjait.

8. sor: ábrázolja a vonalat. Ezzel azt mutatjuk be, hogy nem lineárisan, hanem exponenciálisan növekszik.

9. sor: Állítsa be a grafikon címét.

10-11. sor: Állítsa be a grafikon x és y címkéit.

Most már látnia kell, hogy a lakosság nagyobb százaléka nem oltott, annál nagyobb a fertőzés. Azt is látni fogja, hogy a pirosra váltó pontok többsége zöld pötty, ami azt mutatja, hogy a vakcina bizonyos mértékig segít! Remélem tetszett ez az oktatóanyag. Kommentelj, ha kérdésed van!

15. lépés: Végtermék: Így néz ki a szimuláció

Az összes kód megtalálható itt