Vaccinarsi o no? un progetto sull'osservazione dell'immunità di gregge attraverso la simulazione delle malattie: 15 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Panoramica del progetto:

Il nostro progetto esplora l'immunità di gregge e spera di incoraggiare le persone a farsi vaccinare per ridurre i tassi di infezione nelle nostre comunità. Il nostro programma simula come una malattia infetta una popolazione con diverse percentuali di tassi di vaccinati e non vaccinati. Mostra l'immunità di gregge mostrando come un numero maggiore della popolazione vaccinata può ridurre il numero di persone colpite.

Lo modelliamo in Matlab usando concetti di teoria dei grafi. La teoria dei grafi è un modo matematico per rappresentare le relazioni tra gli oggetti. Nella teoria dei grafi, i grafi hanno vertici (o nodi) collegati da bordi (o linee). Per il nostro progetto, i nodi sono gli individui interessati ei bordi sono le loro connessioni. Ad esempio, se due nodi sono collegati con un bordo, significa che sono "amici" o hanno una qualche forma di contatto tra loro. Questo contatto è un modo per diffondere la malattia. Questo è il motivo per cui abbiamo usato la teoria dei grafi per modellare il nostro concetto perché volevamo vedere come la malattia si diffonde tra gli individui che sono collegati in una popolazione.

Il nostro progetto coinvolge anche il Metodo Monte Carlo. Il metodo Monte Carlo sono algoritmi che creano campionamenti casuali ripetuti per ricevere risultati numerici. Nel nostro progetto, utilizziamo questo metodo per eseguire più volte la nostra simulazione modificando la percentuale di non vaccinati iniziali per vedere la velocità con cui le persone vengono infettate.

Tutto il codice del progetto è collegato in basso!

Credito PC:

Link Matlab a Teoria dei grafi:

Passaggio 1: creare una matrice di adiacenza

Crea un nuovo copione. Chiameremo il nostro "infectionSim.m".

Creeremo una variabile 'NUMOFPEOPLE'. Puoi assegnarlo a qualsiasi valore intero. Questo rappresenterà il numero di persone nella tua popolazione.

D'ora in poi, assumeremo che

NUMOFPEPOLI = 20;

Iniziare utilizzando le funzioni di teoria dei grafi di Matlab per un grafo non orientato.

Se sei interessato a saperne di più, ecco un link per approfondire l'argomento.

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

Creata una matrice di adiacenza.

adjMatrix = zeros(NUMOFPEOPLE);

Questo creerà una matrice quadrata di 0. Ogni riga nella matrice è una persona. Ogni colonna nella matrice è una persona o un amico che la persona incontra durante il giorno.

Vedere la Figura 100 (sopra) per aiutare a visualizzare l'aspetto di adjMatrix per 20 persone.

**Da questo punto in poi supporremo che NUMOFPEOPLE sia uguale a 20.**

Puoi provare a tracciare questa matrice di adiacenza. Ecco qualche informazione in più sul tracciamento di questi tipi di matrici.

Nota: come funziona la matrice di adiacenza.

Ex:

%creando la matrice adiacente

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] % plotting g = grafico(a); %usando la funzione del grafico (teoria dei grafi) figure(1); h = grafico(g);

Vedere la Figura 1 (sopra) per vedere come aggiungere bordi nella matrice di adiacenza, utilizzando il codice in "Nota".

Passaggio 2: creare relazioni

Ora che le persone (vertici o nodi) sono state create, dobbiamo creare una rete di relazioni (linee o bordi del grafo). Questo simulerà il modo in cui le persone interagiscono e incontrano altre persone durante il giorno.

Questo può essere fatto in molti modi. Un modo per completare questa attività consiste nell'assegnare prima un numero casuale a ciascuna persona per determinare con quante persone ciascuna persona interagirà in un giorno.

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

Questo crea una matrice 1 per 20 di numeri interi casuali che rappresentano il numero di interazioni che ogni persona ha al giorno. Le colonne di questa matrice sarebbero il numero corrispondente a ciascuna persona. Ad esempio, se assegniamo il minimoFriendsPersonCanHave = 2 e mostFriendsPersonCanHave = 5, otterremmo valori casuali tra 2 e 5.

Hai problemi con randi()? Nel terminale, digita

aiuto randi

Successivamente, creiamo una matrice randomizzata (chiamata "allFriendsmatrix") di come ogni persona nella popolazione è connessa/interagisce all'interno della popolazione.

tempMatrix = ;

conteggio = 0; allFriendsMatrix = ; for k = 1:NUMOFPEOPLE while length(tempMatrix) ~= numOfFriendsMatrix(k) count = count +1; temp = randi([1, NUMOFPEOPLE]); tempMatrix(count) = temp; end clear each while length(tempMatrix) ~= 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; conteggio = 0; fine

Spiegazione approfondita del codice:

Per prima cosa creiamo una matrice temporanea vuota per contenere l'elenco di amici/interazioni di ogni persona. Inizializziamo anche count, che tiene traccia di dove inserire la nuova connessione casuale in tempMatrix. I cicli for vengono eseguiti 20 volte in modo che ciò avvenga per ogni singola persona nella popolazione. Il primo ciclo while viene eseguito finché il tempMatrix di ogni persona è della stessa lunghezza del numero di interazioni assegnato casualmente. In questo ciclo, viene generato un numero casuale corrispondente alla persona nella popolazione e inserito nel tempMatrix. Poiché le lunghezze di ciascuna delle tempMatrix sono diverse, era necessario creare alcuni valori NaN in modo da poter concatenare tutte queste tempMaticies in un'unica matrice ("allFriendsMatrix"). Il secondo ciclo while risolve questo problema aggiungendo NaN in ogni tempMatrix. Il ciclo while è stato impostato per essere eseguito 9 volte perché è un numero maggiore di 5, che era il limite superiore di amici che una persona può essere assegnata. Il valore '9' è variabile e può/deve essere modificato quando 'mostFriendsPersonCanHave' è maggiore di 9. Le ultime tre righe di codice (esclusa la fine) aggiungono il tempMatrix nella riga successiva di 'allFriendsMatrix'. Quindi cancella tempMatrix e conta per la persona successiva.

Produzione

Questo è l'aspetto che dovrebbe avere l'output per la prima esecuzione del ciclo for (prima delle ultime tre righe).

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

Quindi, aggiungi queste relazioni ad adjMatrix.

per ogni riga = 1:NUMOFPEOPLE

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

Codice Spiegazione

Questo doppio for loop passa attraverso ogni riga e colonna di 'allFriendsMatrix'. L'istruzione if verrà eseguita per tutti i valori che non sono "NaN". Fondamentalmente creerà i bordi o le linee del grafico. Quindi la prima riga che verrà creata è da persona 1 a persona 16 e da persona 16 a persona 1. Poiché non è indirizzato, 1 deve essere modificato per entrambi! Non possiamo avere solo il bordo da 1 a 16 e non da 16 a 1. Devono essere simmetrici affinché funzioni correttamente in Matlab.

Nella nostra simulazione, abbiamo stabilito che le persone non possono interagire con se stesse. Quando abbiamo randomizzato i valori, c'è la possibilità che la nostra matrice adiacente abbia questo errore.

Risolviamo questo problema con il seguente codice:

per ciascuno = 1:NUMOFPEOPLE

adjMatrix(ciascuno, ciascuno) = 0; fine

Codice Spiegazione

Questo ciclo for assicura che la persona 1 non sia collegata alla persona 1, la persona 2 non sia collegata alla persona 2, ecc. matrice dall'alto a sinistra in basso a destra sono tutti 0.

Produzione

Questo è l'adjMatrix finale per questa simulazione corrente. Questo tiene conto di tutte le linee nel grafico (Figura 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

Vedere la Figura 2 per vedere il grafico di 'adjMatrix'.

Passaggio 3: aggiungi le statistiche sulla malattia

Ora che il tuo programma può creare un grafico con un insieme di persone casuali e creare relazioni casuali, dobbiamo inserire le informazioni o le statistiche della malattia per vedere come queste interazioni all'interno di una popolazione possono aumentare o diminuire l'infezione.

Crea queste variabili:

unvacc %tipo: doppio; percentuale di possibilità che le persone non vaccinate non contraggono la malattia

vacc %tipo: doppio; percentuale di possibilità che le persone vaccinate non si ammalano unvacc_perc %type: double; percentuale popolazione non vaccinata init_infect %type: int; percentuale di popolazione vaccinata

Successivamente dobbiamo fare alcuni calcoli.

Creeremo un 'InfectionMat' che è una matrice 3*NUMOFPEOPLE.

vacc_perc = 1-unvacc_perc;

infezioneMat = nan(3, NUMOFPEOPLE); numero = round(vacc_perc * NUMOFPEOPLE); infezioneMat(1, 1:numero) = vacc; infezioneMat(1, numero+1:end) = unvacc; infezioneMat(2, 1:fine) = 0; infezioneMat(2, 1:init_infect) = 1;

Codice Spiegazione

riga 1: calcolata la percentuale di popolazione non vaccinata

riga 2: crea una matrice di numeri 3*N di persone

riga 3: scopri il numero di persone vaccinate dalla percentuale di vaccinati

riga 4: per le persone vaccinate, dare loro un'immunità associata al vaccino. Questo valore viene assegnato in base alla ricerca sulla malattia.

riga 5: per il resto della popolazione (persone non vaccinate), dare loro la percentuale di immunità. Questo valore viene assegnato in base alla ricerca sulla malattia.

riga 6: inizialmente imposta tutte le persone su non infette.

riga 7: per il numero di persone inizialmente infette, compilare di conseguenza la prima coppia di colonne.

Ora che abbiamo impostato tutti i parametri per la simulazione della malattia, randomizzeremo la possibilità che la persona (sia vaccinata che non vaccinata) venga infettata. Questo viene fatto nel passaggio successivo assegnando valori casuali tra 0 e 1 a ciascuna persona nella terza riga di questo 'InfectionMat'.

Passaggio 4: randomizzare la possibilità che una persona vaccinata e non vaccinata possa essere infettata

Quindi, assegna a ogni persona un numero casuale, questo verrà utilizzato in seguito per determinare se la persona viene infettata o meno.

for w = 1:length(infectionMat)

infezioneMat(3, w) = rand; fine

Spiegazione del codice

Questo ciclo for si occupa della terza riga dell'"infectionMat" creato nell'ultimo passaggio. 'rand' assegna un valore compreso tra 0 e 1 a ciascun indice della riga 3.

Produzione

infezioneMat è ora completo! Questo è stato con una popolazione con vaccinazione al 100% e 1 persona inizialmente infetta.

infezioneMat =

Colonne da 1 a 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,8500 0,7500 0,7500 0,7500 Colonne 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

riga 1: percentuale di possibilità di NON contrarre la malattia

riga 2: Infetto o non infetto (valore booleano)

riga 3: numero utilizzato per verificare se una persona non infetta viene infettata se incontra una persona infetta. Se una persona non infetta incontra una persona infetta, questo numero è maggiore del numero nella riga 1 (per la stessa colonna), quindi sono infette. Codificheremo questa funzionalità nel passaggio 7.

Passaggio 5: creare matrici di persone non vaccinate e infette dalle informazioni iniziali

Crea 2 matrici chiamate "matrixUnvacc" e "matrixInfected" che memorizzano tutte le persone infette da infezioniMat. Questo verrà utilizzato in modo da poter codificare a colori il grafico di coloro che sono infetti, non vaccinati o vaccinati, aiutando a visualizzare l'impatto degli individui non vaccinati rispetto a quelli vaccinati.

cancella ciascuno

matriceInfettata = ; matriceUnvacc = ; for h= 1:length(infectionMat) if infezioneMat(1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; fine fine per persona = 1:NUMOFPEOPLE if infezioneMat(2, persona) == 1 matrixInfected = [matrixInfected, person]; fine fine

Codice Spiegazione

Crea due matrici vuote per memorizzare i numeri delle persone non vaccinate e infette, rispettivamente. Entrambi i cicli for vengono eseguiti 20 volte e se l'istruzione if è soddisfatta, il numero viene aggiunto alla matrice corretta.

Produzione

matriceUnvacc =

matrixInfected =

[1]

Passaggio 6: tracciare il grafico iniziale

Successivamente andremo a tracciare la matrice di adiacenza.

g = grafico(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(['Percentuale di persone non vaccinate: ', num2str(title_unvacc), '%']); pausa (velocità)

Spiegazione del codice

La teoria dei grafi in Matlab ha funzioni integrate. Quando usiamo la funzione graph(), siamo in grado di tradurre 'adjMatrix' in un vero e proprio grafico non orientato. Dobbiamo quindi creare una trama usando la funzione plot() per vedere effettivamente come appare. Impostiamo questo plot() su una variabile in modo da poter manipolare e cambiare i colori del grafico più facilmente durante la simulazione. Tutte le persone (o nodi) sono inizialmente impostate sul colore "blu". Successivamente, tutte le persone non vaccinate vengono impostate sul colore "verde". Le persone infette vengono quindi impostate sul colore "rosso". Il titolo è impostato in base al determinato valore percentuale di persone non vaccinate sottoposte a test. La funzione pause() interrompe temporaneamente l'esecuzione di MatLab. Passiamo attraverso la velocità variabile che si sviluppa che viene calcolata in secondi.

Vedere l'immagine (sopra) per vedere un grafico con codice colore casuale.

Ulteriori informazioni sulla funzione highlight() in MatLab.

Passaggio 7: simulare la progressione dell'infezione

Successivamente dobbiamo capire chi viene infettato dopo le interazioni (registrate in adjMatrix) e aggiornare il grafico quando qualcuno viene infettato.

Usa adjMatrix per determinare quali persone sono infette dopo le loro interazioni con le persone in un giorno.

per ogni riga = 1: lunghezza (adjMatrix)

if infezioniMat(2, eachRow) == 1 for eachCol = 1:length(adjMatrix) if adjMatrix(eachRow, eachCol) == 1 % eachRow = la persona % eachCol = il suo amico % ogni amico di ogni persona e vedere se vengono infettati. se infezioneMat(3, ogniCol) > infezioneMat(1, ogniCol) infezioneMat(2, ogniCol) = 1; highlight(p, eachCol, 'NodeColor', 'r') pause(speed) end end end end end

Il ciclo for passa attraverso ogni persona. Controlla che se la persona è infetta, controllerà ciascuna delle persone/amici con cui ha interagito e verificherà se il livello di immunità dell'amico era maggiore della forza della malattia. È qui che entra in gioco l'"infectionMat" che abbiamo creato in precedenza. La prima e la terza riga di ogni colonna dell'amico vengono confrontate e se la terza riga è maggiore, significa che l'amico non aveva un'immunità sufficientemente alta per sfuggire alla malattia e alla fine viene infettato. Passiamo anche al colore usando highlight() in rosso se vengono infettati.

Ora il tuo codice per la simulazione dovrebbe funzionare! e per qualsiasi dimensione della popolazione, basta cambiare NUMOFPEOPLE!

Passaggio 8: utilizzare la teoria di Monte Carlo

Per fare un ulteriore passo avanti ed estrarre i dati dal nostro simulatore ("infectionSim.m"), volevamo calcolare e rappresentare graficamente l'andamento della percentuale di persone non vaccinate che sono state infettate e la percentuale di persone vaccinate che sono state infettate. Ipotizziamo che la percentuale di persone vaccinate che sono state infettate dovrebbe essere molto inferiore alla percentuale di persone non vaccinate che sono state infettate.

Passaggio 9: trasformare il file ('infectionSim.m') con la simulazione in una funzione

Per eseguire Monte Carlo, vorremmo eseguire la simulazione più volte e accumulare dati in modo da poterli utilizzare per rappresentare graficamente le percentuali di persone che sono state infettate.

La funzione potrebbe essere impostata in questo modo:

output della funzione = infezioniSim(unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Commenta le variabili nella tua simulazione poiché ora le stai passando attraverso il file principale (cominceremo a scriverlo nel passaggio 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

La nuova variabile

velocità

verrà assegnato nel file principale (Monte_Carlo.m).

Nota: non dimenticare la fine in fondo al file della funzione per terminare la funzione!

Passaggio 10: calcolare la percentuale di persone non vaccinate e vaccinate che sono state infettate

Questo calcola la percentuale di persone non vaccinate che sono state infettate. Questo codice va in fondo al file 'infectionSim.m'.

numero_di_unvacc = 0;

number_of_infec_unvacc = 0; %calcola la percentuale di persone non vaccinate che sono state infettate per x = 1:length(infectionMat) se infezioneMat(1, x) == unvacc numero_di_unvacc = numero_di_unvacc+1; end if infezioneMat(1, x) == unvacc & infezioneMat(2, x) == 1 numero_di_infezione_unvacc = numero_di_infezione_unvacc +1; fine fine percent_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

Spiegazione del codice

Nel ciclo for, eseguirà un ciclo di NUMOFPEOPLE volte. Ogni volta che il numero nell'infectionMat corrisponde al numero unvacc (cioè 0,95 == 0,95), allora il numero di persone non vaccinate sarà aumentato di 1. Ogni volta che il numero nell'infectionMat corrisponde al numero unvacc e sono infette, il il numero di persone infette e non vaccinate aumenta di 1. L'ultima riga divide il numero di persone infette e non vaccinate per il numero totale di persone non vaccinate. Quindi la percentuale viene calcolata da questo.

Sfida:

Prova a calcolare la percentuale di vaccinati di persone che si sono infettate! (Suggerimento: è molto simile a questo codice sopra, tuttavia alcune variabili vengono modificate e i nomi vengono modificati.)

Successivamente viene calcolata la percentuale di persone infette in base alla popolazione totale:

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

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

Spiegazione del codice

La somma cumulativa viene calcolata utilizzando la seconda riga dell'infezioneMat, che memorizza 1 e 0 a seconda che la persona sia infetta o meno. Poiché la funzione cumsum() restituisce una matrice, prendiamo l'ultimo valore nella matrice ('pre_per_infect(1, NUMOFPEOPLE)'), che dovrebbe essere la somma effettiva di tutti i valori di 'infectionMat(2,:)'. Dividendo la somma per il NUMOFPEOPLE e moltiplicandola per 100, si ottiene la percentuale finale di infetti sulla popolazione totale.

Passaggio 11: crea una variabile di output nella tua funzione 'infectionSim.m'

output = [per_infect, percentuale_of_unvacc_and_infec, percentuale_of_vacc_and_infec];

Spiegazione del codice

Memorizza queste informazioni in output, che verrà rimandato in main (Monte_Carlo.m) quando la funzione viene chiamata e terminata l'esecuzione. Questi dati vengono utilizzati per rappresentare graficamente i punti percentuali di infetti di coloro che sono vaccinati e non vaccinati.

La tua funzione "infectionSim.m" dovrebbe essere completata ora! Tuttavia, non verrà eseguito perché dobbiamo ancora scrivere il main!

Passaggio 12: creare un menu per ottenere le condizioni iniziali della simulazione dall'utente

Ricorda come abbiamo detto la variabile

velocità

verrebbe creato e passato attraverso la funzione principale? Dobbiamo ottenere i valori da passare alla funzione. Nota, l'ordine dei valori quando si chiama la funzione è importante!

Inizia chiedendo all'utente di digitare alcune risposte nel terminale.

> Scegli una malattia. Nota che fa distinzione tra maiuscole e minuscole >> Pertosse >> Influenza >> Morbillo >> Malattia scelta: Influenza >> Scegli la dimensione della popolazione. >> 20 >> 200 >> Popolazione scelta: 20 >> Scegli velocità di simulazione. >> Veloce >> Lento >> Velocità scelta: Veloce

Questo codice qui sotto chiede all'utente quale malattia vuole esaminare.

disp('Scegli una malattia. Nota che fa distinzione tra maiuscole e minuscole')

fprintf('Pertosse\nInfluenza\nMorbillo\n') malattia = input('Malattia scelta: ', 's'); if isequal(malattia, 'Pertosse') vacc =.85; %15 percento di probabilità di contrarre la malattia unvacc =.20; %80 percento di possibilità di ammalarsi altrimenti se isequal(malattia, 'Influenza') vacc =.75; %25 percento di probabilità di contrarre la malattia unvacc =.31; %69% di possibilità di ammalarsi altrimenti se isequal(malattia, 'Morbillo') vacc =.97; %3 percento di possibilità di ammalarsi unvacc =.10; %90 percento di possibilità di contrarre la malattia

Spiegazione del codice:

La funzione disp() stampa l'istruzione sullo schermo e stampa anche le diverse opzioni. La malattia sarà assegnata di conseguenza. Questa versione attualmente non tiene conto di input non validi. Un input non valido produrrà un errore e interromperà completamente il programma. Ad ogni malattia sono associati valori vacc e unvacc. Questi valori NON sono casuali. Abbiamo ottenuto questi valori dalla ricerca di statistiche sulle malattie.

Successivamente, dobbiamo chiedere all'utente se desidera testare una popolazione grande o piccola per la malattia prescelta.

disp('Scegli la dimensione della popolazione.')

fprintf('20\n200\n') speed = input('Popolazione scelta: ', 's'); if isequal(speed, '20') popolazione_dimensione = 20; elseif isequal(speed, '200') popolazione_dimensione = 200; fine

Spiegazione del codice

Questo stampa una dichiarazione per l'utente e chiede all'utente di inserire la dimensione della popolazione che vuole testare. Questa versione attualmente non tiene conto di input non validi. Un input non valido produrrà un errore e interromperà completamente il programma. 20 è stato scelto perché è una piccola dimensione del campione che dà ancora una buona idea di come l'infezione si diffonda in una piccola popolazione. 200 persone sono state scelte come l'opzione più grande perché 200 punti tracciati sul grafico avevano a malapena alcuna sovrapposizione di punti, quindi tutto poteva essere facilmente visto e distinto l'uno dall'altro.

Successivamente, dobbiamo trovare la velocità della simulazione.

disp('Scegli la velocità di simulazione.')

fprintf('Veloce\nLento\n') speed = input('Velocità scelta: ', 's'); if isequal(speed, 'Fast') sim_speed = 0; elseif isequal(speed, 'Slow') sim_speed = 0.25; fine

Spiegazione del codice

Questo processo era lo stesso di ottenere il tipo di malattia e la dimensione della popolazione. Per il digiuno, non ci sarà pausa. e per slow, ci sarà un ritardo di 0,25 secondi nel ciclo for durante l'esecuzione della simulazione.

Grande! Ora abbiamo tutti gli input dell'utente di cui abbiamo bisogno! Passiamo alla raccolta dei dati per diverse percentuali di persone non vaccinate.

Passaggio 13: scegli una % di persone non vaccinate e calcola la media di non vaccinate e infette per la percentuale scelta

Questo codice è per lo 0% delle persone non vaccinate.

% ------- %0 Non vaccinato ------------

per_infect_av_0 = ; percent_of_unvacc_and_infec_av_0 = ; for i = 1:20 out = infezioneSim(unvacc, vacc, dimensioni_popolazione, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out(1, 1)]; percent_of_unvacc_and_infec_av_0 = [percentage_of_unvacc_and_infec_av_0, out(1, 2)]; fine medium_infected_0 = mean(per_infect_av_0); mean_unvacc_and_infected_0 = mean(percentage_of_unvacc_and_infec_av_0);

Spiegazione del codice:

Il ciclo for viene eseguito 20 volte. L'output della funzione, infezioniSim(), è memorizzato in out. Ogni volta che viene eseguito il ciclo for, la percentuale di infetti nella popolazione totale viene aggiunta alla matrice, 'per_infect_av_0'. Inoltre, la percentuale di non vaccinati e infetti viene aggiunta ogni volta alla matrice 'percentage_of_unvacc_and_infec_av_0'. Nelle ultime due righe, queste due matrici sopra menzionate vengono poi mediate e memorizzate in variabili. Per riassumere, le percentuali sono memorizzate per ogni simulazione, mediate e rappresentate graficamente. Monte Carlo viene utilizzato per mostrare il valore medio dell'esecuzione di una simulazione e mostrare il risultato. Per i nostri scopi sperimentali, scegliamo di eseguire la simulazione 20 volte e di fare la media di quei valori.

Sfida:

Ripeti per tutte le percentuali che vuoi testare! Questo può essere fatto modificando i nomi delle variabili in base ai numeri percentuali. Abbiamo testato per 0%, 5%, 10%, 20%, 30% e 50%.

Suggerimento:

L'unica riga che deve essere modificata nel codice attuale è

out = infezioniSim(unvacc, vacc, popolazione_dimensione, 0, 1, sim_speed);

Cambia lo zero in percentuale in forma decimale. Ad esempio, per una simulazione non vaccinata al 5%, lo 0 deve essere sostituito con 0,5.

Passaggio 14: grafico: "Trend dell'infezione nei non vaccinati vs. Vaccinati per malattie specificate'

Questo è il codice per tracciare un grafico dell'andamento dell'infezione in persone non vaccinate rispetto a persone non vaccinate.

graph_mat_y = [media_infettata_0, media_infetta_5, media_infetta_10, media_infetta_20, media_infetta_30, media_infetta_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; pendenza = (average_infected_5-average_infected_0)/5; line_y = [media_infetti_0, (pendenza*50)+media_infetti_0]; riga_x = [0, 50]; figure(2) plot(graph_mat_x, graph_mat_y); line(line_x, line_y, 'Color', 'red', 'LineStyle', '--'); title(['Trend nella non vaccinazione per ', malattia]); xlabel('Percentuale di non vaccinati iniziali'); ylabel('Percentuale di finali infetti')

Spiegazione del codice

riga 1: valori y assegnati alle medie della percentuale di infetti

riga 2: valori x assegnati alla percentuale di percentuale iniziale non vaccinata

riga 3: calcola la pendenza dello 0% e del 5%

riga 4: memorizza i valori y della riga. Questa è una continuazione della sezione dallo 0% al 5%.

riga 5: memorizza i valori y della riga. Questa linea copre la lunghezza del grafico.

riga 6: crea la figura

riga 7: tracciare nel grafico i valori x e y della percentuale di infetti, che non sono vaccinati.

linea 8: traccia la linea. Questo è usato per mostrare che non aumenta linearmente, ma esponenzialmente.

riga 9: Imposta il titolo per il grafico.

riga 10-11: Imposta le etichette x e y per il grafico.

Ora dovresti essere in grado di vedere che maggiore è la percentuale di popolazione non vaccinata, maggiore è la quantità di infezione. Vedrai anche che la maggior parte dei punti che diventano rossi sono punti verdi, a dimostrazione del fatto che il vaccino aiuta in una certa misura! Spero ti sia piaciuto questo tutorial. Commenta se hai domande!

Passaggio 15: Prodotto finale: come appare la simulazione

Tutto il codice lo trovate qui