Impfen lassen oder nicht? ein Projekt zur Beobachtung der Herdenimmunität durch Krankheitssimulation - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Projektübersicht:

Unser Projekt untersucht die Herdenimmunität und hofft, Menschen dazu zu ermutigen, sich impfen zu lassen, um die Infektionsraten in unseren Gemeinden zu senken. Unser Programm simuliert, wie eine Krankheit eine Bevölkerung mit unterschiedlichen Prozentsätzen von geimpften und ungeimpften Raten infiziert. Es zeigt die Herdenimmunität, indem es zeigt, wie eine erhöhte Anzahl der geimpften Bevölkerung die Anzahl der betroffenen Menschen verringern kann.

Wir modellieren dies in Matlab mit Konzepten der Graphentheorie. Die Graphentheorie ist eine mathematische Methode, um die Beziehungen zwischen Objekten darzustellen. In der Graphentheorie haben Graphen Scheitelpunkte (oder Knoten), die durch Kanten (oder Linien) verbunden sind. Für unser Projekt sind die Knoten die betroffenen Personen und die Kanten ihre Verbindungen. Wenn beispielsweise zwei Knoten mit einer Kante verbunden sind, bedeutet dies, dass sie "Freunde" sind oder irgendeine Form von Kontakt miteinander haben. Dieser Kontakt ist ein Weg für die Ausbreitung der Krankheit. Aus diesem Grund haben wir die Graphentheorie verwendet, um unser Konzept zu modellieren, weil wir sehen wollten, wie sich Krankheiten zwischen Individuen ausbreiten, die in einer Population miteinander verbunden sind.

Unser Projekt beinhaltet auch die Monte-Carlo-Methode. Die Monte-Carlo-Methode sind Algorithmen, die wiederholte Zufallsstichproben erstellen, um numerische Ergebnisse zu erhalten. In unserem Projekt verwenden wir diese Methode, um unsere Simulation mehrmals auszuführen, indem wir den Prozentsatz der anfänglichen Ungeimpften ändern, um die Rate zu sehen, mit der sich Menschen infizieren.

Der gesamte Projektcode ist unten verlinkt!

PC-Gutschrift:

Matlab-Link zur Graphentheorie:

Schritt 1: Adjazenzmatrix erstellen

Erstellen Sie ein neues Skript. Wir werden unsere 'infectionSim.m' nennen.

Wir werden eine Variable 'NUMOFPEOPLE' erstellen. Sie können ihn jedem ganzzahligen Wert zuweisen. Dies entspricht der Anzahl der Personen in Ihrer Bevölkerung.

Ab jetzt gehen wir davon aus

ANZAHL PERSONEN = 20;

Beginnen Sie zunächst mit der Verwendung der Graphentheoriefunktionen von Matlab für einen ungerichteten Graphen.

Wenn Sie mehr erfahren möchten, finden Sie hier einen Link, um mehr darüber zu erfahren.

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

Erstellt eine Adjazenzmatrix.

adjMatrix = Nullen (NUMOFPEOPLE);

Dadurch wird eine quadratische Matrix von 0s erstellt. Jede Zeile in der Matrix ist eine Person. Jede Spalte in der Matrix ist eine Person oder ein Freund, den die Person im Laufe des Tages trifft.

Siehe Abbildung 100 (oben), um zu visualisieren, wie adjMatrix für 20 Personen aussieht.

**Von diesem Punkt an gehen wir davon aus, dass NUMOFPEOPLE gleich 20 ist.**

Sie können versuchen, diese Adjazenzmatrix zu zeichnen. Hier sind ein paar weitere Informationen zum Plotten dieser Arten von Matrizen.

Hinweis: Funktionsweise der Adjazenzmatrix.

Ex:

%machen der angrenzenden Matrix

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] %-Plot g = graph(a); %mit der Graphfunktion (Graphtheorie) figure(1); h = Auftrag (g);

Siehe Abbildung 1 (oben), um zu sehen, wie Sie Kanten in der Adjazenzmatrix hinzufügen, indem Sie den Code in "Hinweis" verwenden.

Schritt 2: Erstellen Sie Beziehungen

Nachdem nun die Personen (Vertices oder Nodes) erstellt wurden, müssen wir ein Netzwerk von Relationen (Linien oder Kanten des Graphen) erstellen. Dies simuliert, wie Menschen im Laufe eines Tages interagieren und andere Menschen treffen.

Dies kann auf viele Arten erfolgen. Eine Möglichkeit, diese Aufgabe abzuschließen, besteht darin, jeder Person zunächst eine Zufallszahl zuzuweisen, um zu bestimmen, mit wie vielen Personen jede Person an einem Tag interagieren wird.

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

Dies ergibt eine 1-mal-20-Matrix aus zufälligen ganzen Zahlen, die die Anzahl der Interaktionen darstellt, die jede Person pro Tag hat. Die Spalten dieser Matrix wären die Nummern, die jeder Person entsprechen. Wenn wir z. B. am wenigstenFriendsPersonCanHave = 2 und mostFriendsPersonCanHave = 5 zuweisen, würden wir zufällige Werte zwischen 2 und 5 erhalten.

Haben Sie Probleme mit randi()? Geben Sie im Terminal ein

hilfe randi

Als nächstes erstellen wir eine randomisierte Matrix (genannt "allFriendsmatrix"), wie jede Person in der Population verbunden ist/mit ihr interagiert.

tempMatrix = ;

zählen = 0; allFriendsMatrix = ; for k = 1:NUMOFPEOPLE while length(tempMatrix) ~= numOfFriendsMatrix(k) count = count +1; temp = randi([1, ANZAHL]); tempMatrix(Anzahl) = temp; end clear jedes while length(tempMatrix) ~= 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; zählen = 0; Ende

Ausführliche Erklärung des Codes:

Zuerst erstellen wir eine leere temporäre Matrix, um die Freundes-/Interaktionsliste jeder Person zu speichern. Wir initialisieren auch count, der nur verfolgt, wo die neue zufällige Verbindung in der tempMatrix eingefügt werden soll. Die for-Schleifen laufen 20 Mal, damit dies für jede einzelne Person in der Population geschieht. Die erste while-Schleife läuft, bis die tempMatrix jeder Person die gleiche Länge der zufällig zugewiesenen Anzahl von Interaktionen hat. In dieser Schleife wird eine Zufallszahl entsprechend der Person in der Bevölkerung generiert und in die tempMatrix platziert. Da die Längen der einzelnen tempMatrixen unterschiedlich sind, mussten wir einige NaN-Werte erstellen, damit wir all diese tempMatrixen in einer Matrix ('allFriendsMatrix') verketten können. Die zweite while-Schleife löst dieses Problem, indem sie NaNs zu jeder tempMatrix hinzufügt. Die while-Schleife wurde so eingestellt, dass sie 9 Mal ausgeführt wird, da es sich um eine Zahl größer als 5 handelt, was die Obergrenze der Freunde war, die einer Person zugewiesen werden können. Der Wert '9' ist variabel und kann/muss geändert werden, wenn 'mostFriendsPersonCanHave' größer als 9 ist. Die letzten drei Codezeilen (ohne Ende) fügen die tempMatrix in die nächste Zeile der 'allFriendsMatrix' ein. Dann löscht es tempMatrix und zählt für die nächste Person.

Ausgabe

So sollte die Ausgabe beim ersten Durchlauf der for-Schleife (vor den letzten drei Zeilen) aussehen.

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

Fügen Sie als Nächstes diese Beziehungen der adjMatrix hinzu.

für jede Zeile = 1:NUMOFPEOPLE

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

Code-Erklärung

Diese doppelte for-Schleife durchläuft jede Zeile und Spalte der 'allFriendsMatrix'. Die if-Anweisung wird für alle Werte ausgeführt, die nicht 'NaN' sind. Grundsätzlich werden die Kanten oder Linien des Diagramms erstellt. Die erste Zeile ist also Person 1 zu Person 16 und Person 16 zu Person 1. Da sie ungerichtet ist, muss 1 für beide geändert werden! Wir können nicht nur die Kante 1 zu 16 und nicht 16 zu 1 haben. Sie müssen symmetrisch sein, damit sie in Matlab richtig läuft.

In unserer Simulation haben wir festgestellt, dass Menschen nicht mit sich selbst interagieren können. Wenn wir die Werte randomisiert haben, besteht die Möglichkeit, dass unsere benachbarte Matrix diese Fehler aufweist.

Lassen Sie uns dies mit dem folgenden Code beheben:

für jeden = 1:NUMOFPEOPLE

adjMatrix(jeder, jeder) = 0; Ende

Code-Erklärung

Diese for-Schleife stellt sicher, dass Person 1 nicht mit Person 1 verbunden ist, Person 2 ist nicht mit Person 2 usw. verbunden, indem sie alle zu 0 macht. Wie Sie unten im Ausgabeabschnitt sehen können, haben wir die Diagonale des Quadrats Matrix von links oben nach rechts unten sind alle Nullen.

Ausgabe

Dies ist die letzte adjMatrix für diese aktuelle Simulation. Dies berücksichtigt alle Linien im Diagramm (Abbildung 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

Siehe Abbildung 2, um das Diagramm von 'adjMatrix' zu sehen.

Schritt 3: Fügen Sie Krankheitsstatistiken hinzu

Da Ihr Programm nun ein Diagramm mit einer Reihe zufälliger Personen und zufällige Beziehungen erstellen kann, müssen wir die Informationen oder Statistiken der Krankheit eingeben, um zu sehen, wie diese Interaktionen innerhalb einer Population die Infektion erhöhen oder verringern können.

Erstellen Sie diese Variablen:

unvacc %type: doppelt; Prozentuale Wahrscheinlichkeit, dass ungeimpfte Menschen nicht erkranken

vcc %type: doppelt; prozentuale Wahrscheinlichkeit, dass geimpfte Personen nicht krank werden unvacc_perc %type: double; Prozent der Bevölkerung ungeimpft init_infect %type: int; Prozent der geimpften Bevölkerung

Als nächstes müssen wir einige Berechnungen durchführen.

Wir werden eine 'infectionMat' erstellen, die eine 3*NUMOFPEOPLE-Matrix ist.

vcc_perc = 1-unvacc_perc;

InfektionMat = nan(3, ANZAHL PERSONEN); Zahl = Runde (vacc_perc * NUMOFPEOPLE); InfektionMat(1, 1:Zahl) = vcc; InfektionMat(1, Zahl+1:Ende) = unvacc; InfektionMat(2, 1:Ende) = 0; InfektionMat(2, 1:init_infect) = 1;

Code-Erklärung

Zeile 1: Prozentsatz der ungeimpften Bevölkerung berechnet

Zeile 2: Erstellen Sie eine 3*N-Anzahl von Personen-Matrix

Zeile 3: Ermitteln Sie die Anzahl der geimpften Personen anhand des geimpften Prozentsatzes

Zeile 4: Geben Sie den Geimpften eine Immunität, die mit der Impfung verbunden ist. Dieser Wert wird basierend auf der Forschung über die Krankheit zugewiesen.

Zeile 5: für den Rest der Bevölkerung (ungeimpfte Personen) geben Sie die prozentuale Immunität an. Dieser Wert wird basierend auf der Forschung über die Krankheit zugewiesen.

Zeile 6: Stellen Sie zunächst alle Personen auf nicht infiziert ein.

Zeile 7: Füllen Sie für die Anzahl der Erstinfizierten die ersten paar Spalten entsprechend aus.

Nachdem wir nun alle Parameter für die Krankheitssimulation festgelegt haben, werden wir die Wahrscheinlichkeit, ob die Person (sowohl geimpft als auch ungeimpft) infiziert wird, randomisieren. Dies geschieht im nächsten Schritt, indem jeder Person in der dritten Reihe dieser 'InfektionsMatte' zufällige Werte zwischen 0 und 1 zugewiesen werden.

Schritt 4: Zufällige Ansteckung einer geimpften und ungeimpften Person

Als nächstes weisen Sie jeder Person eine Zufallszahl zu, anhand dieser wird später festgestellt, ob sich die Person infiziert oder nicht.

für w = 1:Länge (Infektionsmatte)

InfektionMat(3, w) = Rand; Ende

Code-Erklärung

Diese for-Schleife befasst sich mit der dritten Zeile der im letzten Schritt erstellten 'infectionMat'. 'rand' weist jedem Index von Zeile 3 einen Wert zwischen 0 und 1 zu.

Ausgabe

InfektionMat ist nun fertig! Dies war bei einer Bevölkerung mit 100 % Impfung und einer anfänglich infizierten Person.

InfektionMat =

Spalten 1 bis 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 0,8352500 0,7500 0,7 bis 20352500 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

Zeile 1: Prozentuale Wahrscheinlichkeit, die Krankheit NICHT zu bekommen

Zeile 2: Infiziert oder nicht infiziert (Boolescher Wert)

Zeile 3: Nummer, mit der überprüft wird, ob sich eine nicht infizierte Person ansteckt, wenn sie eine infizierte Person trifft. Trifft eine nicht infizierte Person auf eine infizierte Person, ist diese Zahl größer als die Zahl in Zeile 1 (für dieselbe Spalte), dann sind sie infiziert. Wir werden diese Funktionalität in Schritt 7 codieren.

Schritt 5: Erstellen Sie Matrizen von ungeimpften und infizierten Personen anhand der ersten Informationen

Erstellen Sie 2 Matrizen namens "matrixUnvacc" und "matrixInfected", die alle infizierten Personen von der InfektionsMat speichert. Dies wird verwendet, damit wir das Diagramm der infizierten, ungeimpften oder geimpften Personen farblich kodieren können, um die Auswirkungen von ungeimpften gegenüber geimpften Personen zu visualisieren.

lösche jeden

MatrixInfiziert = ; MatrixUnvacc = ; für h= 1:Länge(InfektionsMat) wenn InfektionMat(1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; end end for person = 1:NUMOFPEOPLE if infektionMat(2, person) == 1 matrixInfected = [matrixInfected, person]; Ende Ende

Code-Erklärung

Erstellen Sie zwei leere Matrizen, um die Nummern der ungeimpften bzw. infizierten Personen zu speichern. Beide for-Schleifen laufen 20 Mal und wenn die if-Anweisung erfüllt ist, wird die Zahl zur richtigen Matrix addiert.

Ausgabe

MatrixUnvacc =

MatrixInfiziert =

[1]

Schritt 6: Zeichnen Sie das anfängliche Diagramm

Als nächstes zeichnen wir die Adjazenzmatrix.

g = graph(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(['Prozent der ungeimpften Personen: ', num2str(title_unvacc), '%']); Pause (Geschwindigkeit)

Codeerklärung

Die Graphentheorie in Matlab hat eingebaute Funktionen. Wenn wir die Funktion graph() verwenden, können wir die 'adjMatrix' in einen tatsächlichen ungerichteten Graphen übersetzen. Wir müssen dann mit der Funktion plot() einen Plot erstellen, um tatsächlich zu sehen, wie er aussieht. Wir setzen dieses plot() auf eine Variable, damit wir die Farben des Plots während der Simulation einfacher manipulieren und ändern können. Alle Personen (oder Knoten) sind zunächst auf die Farbe 'blau' eingestellt. Als nächstes werden alle ungeimpften Personen auf die Farbe 'grün' gesetzt. Die Infizierten werden dann auf die Farbe „Rot“gesetzt. Der Titel wird nach dem bestimmten Prozentsatz der getesteten ungeimpften Personen festgelegt. Die Funktion pause() stoppt die MatLab-Ausführung vorübergehend. Wir durchlaufen die variable Geschwindigkeit, die gespreizt wird, die in Sekunden berechnet wird.

Siehe Bild (oben), um ein zufällig farbcodiertes Diagramm zu sehen.

Erfahren Sie mehr über die Highlight()-Funktion in MatLab.

Schritt 7: Simulieren Sie das Fortschreiten der Infektion

Als nächstes müssen wir herausfinden, wer sich nach den Interaktionen (aufgezeichnet in der adjMatrix) infiziert und das Diagramm aktualisieren, wenn sich jemand infiziert.

Verwenden Sie die adjMatrix, um zu bestimmen, welche Personen nach ihren Interaktionen mit Personen an einem Tag infiziert sind.

for eachRow = 1:length(adjMatrix)

if InfektionMat(2, eachRow) == 1 for eachCol = 1:length(adjMatrix) if adjMatrix(eachRow, eachCol) == 1 % eachRow = die Person % eachCol = ihr Freund % der Freund jeder Person und sehen, ob sie sich infizieren. wenn InfektionMat(3, jedesCol) > InfektionMat(1,jeCol) InfektionMat(2, jedesCol) = 1; Highlight(p, eachCol, 'NodeColor', 'r') Pause(Geschwindigkeit) Ende Ende Ende Ende Ende

Die for-Schleife durchläuft jede Person. Es überprüft, ob die Person infiziert ist, jede der Personen / Freunde, mit denen sie interagiert hat, und überprüft, ob die Immunität des Freundes höher war als die Stärke der Krankheit. Hier kommt die „infectionMat“ins Spiel, die wir zuvor erstellt haben. Die 1. und 3. Reihe jeder Spalte des Freundes werden verglichen und wenn die 3. Reihe größer ist, bedeutet dies, dass der Freund keine ausreichend hohe Immunität hatte, um der Krankheit zu entgehen und sich letztendlich infiziert. Wir ändern auch die Farbe mit Highlight() zu Rot, wenn sie infiziert werden.

Jetzt sollte Ihr Code für die Simulation funktionieren! und für jede Bevölkerungsgröße ändern Sie einfach NUMOFPEOPLE!

Schritt 8: Verwenden Sie die Monte-Carlo-Theorie

Um noch einen Schritt weiter zu gehen und Daten aus unserem Simulator ('infectionSim.m') zu extrahieren, wollten wir den Trend in Prozent der ungeimpften Personen, die sich infizierten, und des Prozentsatzes der geimpften Personen, die sich infizierten, berechnen und grafisch darstellen. Wir gehen davon aus, dass der Prozentsatz der geimpften Personen, die sich infiziert haben, viel niedriger sein sollte als der Prozentsatz der ungeimpften Personen, die sich infiziert haben.

Schritt 9: Machen Sie die Datei ('infectionSim.m') mit der Simulation in eine Funktion

Um Monte Carlo auszuführen, möchten wir die Simulation mehrmals ausführen und Daten sammeln, damit wir diese verwenden können, um den Prozentsatz der infizierten Personen grafisch darzustellen.

Die Funktion könnte so aufgebaut sein:

Funktionsausgabe = InfektionSim(unvacc, vcc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Kommentieren Sie die Variablen in Ihrer Simulation aus, da Sie diese jetzt über die Hauptdatei übergeben (wir beginnen, dies in Schritt 12 zu schreiben):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

Die neue Variable

Geschwindigkeit

wird in der Hauptdatei (Monte_Carlo.m) zugewiesen.

Hinweis: Vergessen Sie nicht das Ende am Ende der Funktionsdatei, um die Funktion zu beenden!

Schritt 10: Berechnen Sie den Prozentsatz der ungeimpften und geimpften Personen, die sich infiziert haben

Dieser berechnet den Prozentsatz der ungeimpften Personen, die sich infiziert haben. Dieser Code befindet sich am Ende der Datei 'infectionSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; %berechnet den Prozentsatz ungeimpfter Personen, die sich für x = 1:length(infectionMat) infiziert haben, wenn InfektionMat(1, x) == unvacc number_of_unvacc = number_of_unvacc+1; Ende if InfektionMat(1, x) == unvacc & InfektionMat(2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; Ende Ende Prozentsatz_von_Unvacc_and_infec = (Anzahl_von_Infec_Unvacc / Anzahl_von_Unvacc)*100;

Code-Erklärung

In der for-Schleife wird NUMOFPEOPLE-mal durchlaufen. Jedes Mal, wenn die Zahl in der InfektionsMat der Unvacc-Zahl entspricht (also 0,95 == 0,95), dann wird die Zahl der ungeimpften Personen um 1 erhöht Zahl der Infizierten und Ungeimpften steigt um 1. Die letzte Zeile teilt die Zahl der Infizierten und Ungeimpften durch die Gesamtzahl der Ungeimpften. Daraus wird dann der Prozentsatz berechnet.

Herausforderung:

Versuchen Sie, den Prozentsatz der geimpften Personen zu berechnen, die sich infiziert haben! (Hinweis: Es ist diesem obigen Code sehr ähnlich, jedoch wurden einige Variablen geändert und Namen angepasst.)

Als nächstes wird der Prozentsatz der Infizierten bezogen auf die Gesamtbevölkerung berechnet:

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

pro_infect = (pre_per_infect(1, NUMOFPERSONEN)/NUMOFPERSONEN)*100;

Codeerklärung

Die kumulative Summe wird anhand der zweiten Zeile der InfektionsMat berechnet, die 1s und 0s speichert, je nachdem, ob die Person infiziert ist oder nicht. Da die Funktion cumsum() eine Matrix zurückgibt, nehmen wir den letzten Wert in der Matrix ('pre_per_infect(1, NUMOFPEOPLE)'), der die tatsächliche Summe aller Werte von 'infectionMat(2,:)' sein sollte. Indem wir die Summe durch die ANZAHL PERSONEN dividieren und mit 100 multiplizieren, erhalten wir den endgültigen Prozentsatz der Infizierten in der Gesamtbevölkerung.

Schritt 11: Erstellen Sie eine Ausgabevariable in Ihrer Funktion 'infectionSim.m'

Ausgabe = [pro_infekt, Prozentsatz_von_unvacc_and_infec, Prozentsatz_von_vacc_and_infec];

Codeerklärung

Speichern Sie diese Informationen in der Ausgabe, die an main (Monte_Carlo.m) zurückgesendet wird, wenn die Funktion aufgerufen und ausgeführt wird. Diese Daten werden verwendet, um die Prozentpunkte der Infizierten der Geimpften und Ungeimpften grafisch darzustellen.

Ihre 'infectionSim.m'-Funktion sollte jetzt ausgeführt werden! Es wird jedoch nicht ausgeführt, da wir noch den Main schreiben müssen!

Schritt 12: Erstellen Sie ein Menü, um die Anfangsbedingungen der Simulation vom Benutzer abzurufen

Denken Sie daran, wie wir die Variable gesagt haben

Geschwindigkeit

erstellt und durch die Hauptfunktion übergeben würde? Wir müssen die Werte abrufen, die an die Funktion übergeben werden sollen. Beachten Sie, dass die Reihenfolge der Werte beim Aufruf der Funktion keine Rolle spielt!

Bitten Sie den Benutzer zunächst, einige Antworten in das Terminal einzugeben.

> Wählen Sie eine Krankheit. Beachten Sie die Groß-/Kleinschreibung >> Keuchhusten >> Grippe >> Masern >> Ausgewählte Krankheit: Grippe >> Wählen Sie die Populationsgröße aus. >> 20 >> 200 >> Gewählte Population: 20 >> Pick-Geschwindigkeit der Simulation. >> Schnell >> Langsam >> Gewählte Geschwindigkeit: Schnell

Dieser Code unten fragt den Benutzer, welche Krankheit er untersuchen möchte.

disp('Wählen Sie eine Krankheit aus. Beachten Sie, dass die Groß-/Kleinschreibung beachtet werden muss.')

fprintf('Pertussis\nGrippe\nMasern\n') disease = input('Ausgewählte Krankheit: ', 's'); if isequal(Krankheit, 'Pertussis') vcc =.85; %15-prozentige Wahrscheinlichkeit, dass die Krankheit nicht geimpft wird = 0,20; %80-prozentige Wahrscheinlichkeit, an einer Krankheit zu erkranken elseif isequal(Krankheit, 'Grippe') vcc = 0,75; %25-prozentige Wahrscheinlichkeit, dass die Krankheit nicht geimpft wird =.31; %69-prozentige Wahrscheinlichkeit, an einer Krankheit zu erkranken elseif isequal(Krankheit, 'Masern') vcc = 0,97; %3 Prozent Wahrscheinlichkeit, dass die Krankheit nicht geimpft wird = 0,10; %90-prozentige Wahrscheinlichkeit, dass die Krankheit endet

Code-Erklärung:

Die Funktion disp() gibt die Anweisung auf dem Bildschirm aus und gibt auch die verschiedenen Optionen aus. Die Krankheit wird entsprechend zugeordnet. Diese Version berücksichtigt derzeit keine ungültigen Eingaben. Eine ungültige Eingabe erzeugt einen Fehler und stoppt das Programm vollständig. Jeder Krankheit sind Vacci- und Unvacci-Werte zugeordnet. Diese Werte sind NICHT zufällig. Diese Werte haben wir aus der Recherche von Statistiken über die Krankheiten erhalten.

Als nächstes müssen wir den Benutzer fragen, ob er eine große oder kleine Population auf die von ihm gewählte Krankheit testen möchte.

disp('Bevölkerungsgröße auswählen.')

fprintf('20\n200\n') speed = input('Ausgewählte Bevölkerung: ', 's'); if isequal(speed, '20') population_size = 20; elseif isequal(speed, '200') population_size = 200; Ende

Codeerklärung

Dies druckt eine Aussage an den Benutzer aus und fordert den Benutzer auf, einzugeben, welche Populationsgröße er testen möchte. Diese Version berücksichtigt derzeit keine ungültigen Eingaben. Eine ungültige Eingabe erzeugt einen Fehler und stoppt das Programm vollständig. 20 wurde ausgewählt, weil es sich um eine kleine Stichprobengröße handelt, die immer noch eine gute Vorstellung davon gibt, wie sich die Infektion in einer kleinen Population ausbreitet. 200 Personen wurden als die größere Option ausgewählt, da 200 Punkte, die auf dem Diagramm aufgetragen wurden, kaum Überschneidungen von Punkten aufwiesen, sodass alles leicht gesehen und voneinander unterschieden werden konnte.

Als nächstes müssen wir die Geschwindigkeit der Simulation ermitteln.

disp('Geschwindigkeit der Simulation auswählen.')

fprintf('Schnell\nLangsam\n') speed = input('Gewählte Geschwindigkeit: ', 's'); if isequal(speed, 'Fast') sim_speed = 0; elseif isequal(speed, 'Slow') sim_speed = 0.25; Ende

Codeerklärung

Dieser Prozess war derselbe, wie die Art der Krankheit und die Bevölkerungsgröße zu ermitteln. Für schnell wird es keine Pause geben. und für langsam gibt es eine Verzögerung von 0,25 Sekunden in der for-Schleife, wenn die Simulation ausgeführt wird.

Groß! Jetzt haben wir alle Eingaben des Benutzers, die wir brauchen! Kommen wir zum Sammeln von Daten für verschiedene Prozentsätze ungeimpfter Personen.

Schritt 13: Wählen Sie einen Prozentsatz der ungeimpften Personen und berechnen Sie den Durchschnitt der ungeimpften und infizierten Personen für den ausgewählten Prozentsatz

Dieser Code gilt für 0% der ungeimpften Personen.

% ------- %0 Ungeimpft ------------

per_infect_av_0 = ; Prozentsatz_von_unvacc_and_infec_av_0 = ; für i = 1:20 out = InfektionSim(unvacc, vcc, population_size, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out(1, 1)]; Prozentsatz_von_unvacc_and_infec_av_0 = [Prozentsatz_von_unvacc_and_infec_av_0, out(1, 2)]; Ende Average_infected_0 = mean(per_infect_av_0); Durchschnitt_unvacc_and_infected_0 = Mittelwert (Prozentsatz_von_unvacc_and_infec_av_0);

Code-Erklärung:

Die for-Schleife wird 20 Mal durchlaufen. Die Ausgabe der Funktion InfektionSim() wird in out gespeichert. Jedes Mal, wenn die for-Schleife ausgeführt wird, wird der Prozentsatz der Infizierten in der Gesamtpopulation zur Matrix 'per_infect_av_0' hinzugefügt. Darüber hinaus wird der Prozentsatz der Ungeimpften und Infizierten jedes Mal in die Matrix „Prozentsatz_von_unvacc_and_infec_av_0“aufgenommen. In den letzten beiden Zeilen werden diese beiden oben genannten Matrizen dann gemittelt und in Variablen gespeichert. Zusammenfassend werden die Prozentsätze für jede Simulation gespeichert, gemittelt und grafisch dargestellt. Monte Carlo wird verwendet, um den Durchschnittswert einer Simulation anzuzeigen und das Ergebnis anzuzeigen. Für unsere experimentellen Zwecke haben wir uns entschieden, die Simulation 20 Mal auszuführen und diese Werte zu mitteln.

Herausforderung:

Wiederholen Sie dies für alle Prozentsätze, die Sie testen möchten! Dies kann durch Ändern der Variablennamen entsprechend den Prozentzahlen erfolgen. Wir haben auf 0 %, 5 %, 10 %, 20 %, 30 % und 50 % getestet.

Hinweis:

Die einzige Zeile, die im eigentlichen Code geändert werden muss, ist

out = InfektionSim(unvacc, vcc, population_size, 0, 1, sim_speed);

Ändern Sie die Null in den Prozentwert in Dezimalform. Zum Beispiel sollte für eine 5% ungeimpfte Simulation die 0 durch 0,5 ersetzt werden.

Schritt 14: Diagramm: „Der Infektionstrend bei ungeimpften vs. Geimpft gegen eine bestimmte Krankheit"

Dies ist der Code, um eine grafische Darstellung des Infektionstrends bei ungeimpften Personen gegenüber ungeimpften Personen zu erstellen.

graph_mat_y = [durchschnittlich_infiziert_0, durchschnittlich_infiziert_5, durchschnittlich_infiziert_10, durchschnittlich_infiziert_20, durchschnittlich_infiziert_30, durchschnittlich_infiziert_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; Steigung = (average_infected_5-average_infected_0)/5; line_y = [average_infected_0, (Steigung*50)+average_infected_0]; line_x = [0, 50]; figure(2) plot(graph_mat_x, graph_mat_y); line(line_x, line_y, 'Color', 'red', 'LineStyle', '--'); title(['Trend bei Nichtimpfung für', Krankheit]); xlabel('Prozentsatz der anfänglich ungeimpften'); ylabel('Prozentsatz der endgültigen Infizierten')

Codeerklärung

Zeile 1: dem Durchschnitt der Infizierten y-Werte zugewiesen

Zeile 2: dem Prozentsatz des anfänglichen Prozentsatzes der ungeimpften x Werte zugewiesen

Zeile 3: Berechnen Sie die Steigung von 0% und 5%

Zeile 4: y-Werte von Zeile speichern. Dies ist eine Fortsetzung des Abschnitts 0 % bis 5 %.

Zeile 5: y-Werte von Zeile speichern. Diese Linie überspannt die Länge des Graphen.

Zeile 6: Figur erstellen

Zeile 7: Zeichnen Sie die x- und y-Werte der prozentualen Infizierten, die nicht geimpft sind, im Diagramm auf.

Zeile 8: Zeichnen Sie die Linie. Damit wird gezeigt, dass er nicht linear, sondern exponentiell ansteigt.

Zeile 9: Titel für die Grafik festlegen.

Zeile 10-11: Setze x- und y-Beschriftungen für den Graphen.

Jetzt sollten Sie sehen können, dass je größer der Anteil der ungeimpften Bevölkerung ist, desto größer ist die Infektionsrate. Sie werden auch sehen, dass die meisten roten Punkte grüne Punkte sind, was zeigt, dass der Impfstoff bis zu einem gewissen Grad hilft! Ich hoffe, Ihnen hat dieses Tutorial gefallen. Kommentieren Sie, wenn Sie Fragen haben!

Schritt 15: Endprodukt: Wie die Simulation aussieht

Alle Codes finden Sie hier