להתחסן או לא? פרויקט בנושא התבוננות בחסינות העדר באמצעות סימולציה של מחלות: 15 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

סקירה כללית של הפרויקט:

הפרויקט שלנו בוחן את חסינות העדר ומקווה לעודד אנשים לקבל חיסונים כדי להפחית את שיעורי ההדבקה בקהילות שלנו. התוכנית שלנו מדמה כיצד מחלה מדביקה אוכלוסייה עם אחוזים שונים של שיעורים מחוסנים ולא מחוסנים. הוא מראה את חסינות העדר בכך שהוא מראה כיצד מספר מוגבר של האוכלוסייה המחוסנת יכול להקטין את מספר האנשים שנפגעו.

אנו מודלים זאת ב- Matlab תוך שימוש במושגי תורת הגרפים. תורת הגרפים היא דרך מתמטית לייצג את היחסים בין אובייקטים. בתורת הגרפים, לגרפים יש קודקודים (או צמתים) המחוברים בקצוות (או בקווים). עבור הפרויקט שלנו, הצמתים הם האנשים הנוגעים בדבר והקצוות הם הקשרים שלהם. לדוגמה, אם שני צמתים מחוברים עם קצה אז זה אומר שהם "חברים" או שיש להם איזושהי מגע זה עם זה. מגע זה הוא דרך להתפשטות המחלה. זו הסיבה שהשתמשנו בתורת הגרפים כדי לדגמן את הרעיון שלנו מכיוון שרצינו לראות כיצד המחלה מתפשטת בקרב אנשים המחוברים באוכלוסייה.

הפרויקט שלנו כולל גם את שיטת מונטה קרלו. שיטת מונטה קרלו הינה אלגוריתמים היוצרים דגימות אקראיות חוזרות ונשנות לקבלת תוצאות מספריות. בפרויקט שלנו, אנו משתמשים בשיטה זו כדי להריץ את הסימולציה שלנו מספר פעמים ולשנות את אחוז החסונים הראשונים כדי לראות את הקצב שבו אנשים נדבקים.

כל קוד הפרויקט מקושר בתחתית!

אשראי מחשב:

קישור Matlab לתיאוריית הגרף:

שלב 1: צור מטריצת סמיכות

צור סקריפט חדש. אנחנו הולכים לקרוא לזה שלנו 'זיהום Sim'.

אנו הולכים ליצור משתנה 'NUMOFPEOPLE'. אתה יכול להקצות אותו לכל ערך שלם. זה ייצג את מספר האנשים באוכלוסייה שלך.

מעתה ואילך, נניח זאת

NUMOFPEOPLE = 20;

ראשית התחל על ידי שימוש בפונקציות של תורת הגרפים של Matlab עבור גרף לא מכוון.

אם אתה מעוניין ללמוד יותר, הנה קישור שתוכל לקרוא עליו יותר לעומק.

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

יצר מטריצת סמיכות.

adjMatrix = אפסים (NUMOFPEOPLE);

פעולה זו תיצור מטריצה מרובעת של 0s. כל שורה במטריצה היא אדם. כל טור במטריצה הוא אדם או חבר שהאדם פוגש במהלך היום.

עיין באיור 100 (למעלה) כדי לעזור לדמיין כיצד נראה adjMatrix עבור 20 אנשים.

** מנקודה זו ואילך נניח ש- NUMOFPEOPLE שווה ל -20. **

אתה יכול לנסות לתכנן את מטריצת הסמיכות הזו. להלן מידע נוסף אודות התוויית מטריצות מסוג זה.

הערה: כיצד פועלת מטריצת הסמיכות.

לְשֶׁעָבַר:

%מה שהופך את המטריצה הסמוכה

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] %זומם g = גרף (א); %באמצעות פונקציית הגרף (תורת הגרף) איור (1); h = עלילה (ז);

עיין באיור 1 (למעלה) כדי לראות כיצד להוסיף קצוות במטריצת הסמיכות, באמצעות הקוד ב"הערה ".

שלב 2: צור מערכות יחסים

כעת, כשהאנשים (קודקודים או צמתים) נוצרים, עלינו ליצור רשת של יחסים (קווים או קצוות הגרף). זה ידמה כיצד אנשים מתקשרים ופוגשים אנשים אחרים לאורך כל היום.

ניתן לעשות זאת בדרכים רבות. אחת הדרכים להשלים משימה זו היא להקצות תחילה מספר אקראי לכל אדם כדי לקבוע עם כמה אנשים כל אדם יתקשר איתו ביום.

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

זה יוצר מטריצה של 1 על 20 של מספרים שלמים אקראיים המייצגים את מספר האינטראקציות שיש לכל אדם ביום. העמודות של מטריצה זו יהיו המספר המתאים לכל אדם. למשל אם נקצה את leastFriendsPersonCanHave = 2 ואת רובFriendsPersonCanHave = 5, נקבל ערכים אקראיים בין 2 ל -5.

מתקשה עם רנדי ()? במסוף, הקלד

עזור לרנדי

לאחר מכן, אנו יוצרים מטריצה אקראית (הנקראת "allFriendsmatrix") של האופן שבו כל אדם באוכלוסייה מחובר/אינטראקציה בתוך האוכלוסייה.

tempMatrix = ;

ספירה = 0; allFriendsMatrix = ; עבור k = 1: NUMOFPEOPLE בעוד אורך (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (count) = temp; סוף לנקות כל אורך (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; לסיים allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; ספירה = 0; סוֹף

הסבר מעמיק על הקוד:

ראשית אנו יוצרים מטריצה זמנית ריקה שתכיל את רשימת החברים/אינטראקציות של כל אדם. אנו גם מאתחלים את הספירה, שפשוט עוקבת אחר היכן להדביק את החיבור האקראי החדש ב- tempMatrix. הלולאות for פועלות 20 פעמים כך שזה קורה לכל אדם בנפרד באוכלוסייה. לולאת ה- while הראשונה פועלת עד שה tempMatrix של כל אדם הוא באותו אורך של מספר האינטראקציות שהוקצו באופן אקראי. בלולאה זו, מספר אקראי המתאים לאדם באוכלוסייה נוצר ומונח לתוך tempMatrix. מכיוון שאורכי כל אחת מה tempMatrixes שונים, היינו צריכים ליצור כמה ערכי NaN כדי שנוכל לחבר את כל tempMaticies כולם למטריצה אחת ('allFriendsMatrix'). הלולאה השנייה בעוד פותרת בעיה זו על ידי הוספת NaN לכל tempMatrix. לולאת ה- while נקבעה לפעול 9 פעמים מכיוון שהיא מספר גדול מ -5, שהיה הגבול העליון של חברים שאפשר להקצות לאדם. הערך '9' משתנה וניתן/חייב לשנות אותו כאשר 'mostFriendsPersonCanHave' גדול מ- 9. שלוש שורות הקוד האחרונות (לא כולל הסוף) מוסיפות את tempMatrix לשורה הבאה של 'allFriendsMatrix'. ואז הוא מנקה את tempMatrix וסופר לאדם הבא.

תְפוּקָה

כך אמור להיראות הפלט לריצה הראשונה דרך לולאת ה- for (לפני שלוש השורות האחרונות).

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 NaN 10 13 NaN NaN NaN NaN NaN NaN NaN 11 17 2 NaN NaN NaN NaN NaN NaN NaN 10 12 NaN 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 NaN 3 8 17 17 14 NaN NaN NaN NaN 20 19 3 NaN NaN NaN NaN NaN NaN NaN 13 10 NaN NaN NaN NaN 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 10 19 NaN NaN NaN NaN NaN NaN NaN 5 18 NaN 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

לאחר מכן, הוסף מערכות יחסים אלה ל- adjMatrix.

עבור eachRow = 1: NUMOFPEOPLE

עבור eachCol = 1: 9 אם isnan (allFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; סוף סוף סוף

הסבר קוד

הלולאה הכפולה הזו עוברת בכל שורה ועמודה של 'allFriendsMatrix'. המשפט if יפעל עבור כל הערכים שאינם 'NaN'. בעיקרון זה ייצור את הקצוות או הקווים של הגרף. אז השורה הראשונה שזה יעשה היא אדם 1 לאדם 16 ואדם 16 לאדם 1. מכיוון שהוא אינו מכוון, יש לשנות 1 עבור שניהם! אנחנו לא יכולים לקבל רק את הקצה 1 עד 16 ולא 16 עד 1. הם חייבים להיות סימטריים כדי שזה יפעל כראוי ב- Matlab.

בסימולציה שלנו, קבענו שאנשים אינם יכולים לתקשר עם עצמם. כאשר אקראי את הערכים, יש סיכוי שלמטריצה הסמוכה שלנו יש שגיאות אלה.

בואו נתקן את זה עם הקוד הבא:

עבור כל אחד = 1: NUMOFPEOPLE

adjMatrix (כל אחד, כל אחד) = 0; סוֹף

הסבר קוד

זה עבור לולאה מבטיח שאדם 1 אינו מחובר לאדם 1, אדם 2 אינו מחובר לאדם 2 וכו 'על ידי הפיכת כולם 0. כפי שניתן לראות להלן בחלק הפלט, יש לנו את האלכסון של הריבוע. מטריצה מצד שמאל למעלה מימין למטה כולם 0.

תְפוּקָה

זהו ה- adjMatrix הסופי לסימולציה הנוכחית הזו. זה מהווה את כל השורות בתרשים (איור 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

ראה איור 2 כדי לראות גרף של 'adjMatrix'.

שלב 3: הוסף סטטיסטיקה של מחלות

כעת, כאשר התוכנית שלך יכולה ליצור גרף עם קבוצה של אנשים אקראיים וליצור קשרים אקראיים, עלינו להזין את המידע או הסטטיסטיקה של המחלה כדי לראות כיצד אינטראקציות אלה בתוך אוכלוסייה יכולות להגדיל או להקטין את ההדבקה.

צור את המשתנים האלה:

סוג unvacc %: כפול; אחוז הסיכוי שאנשים לא מחוסנים לא יקבלו את המחלה

סוג חיסון: כפול; אחוז הסיכוי שאנשים מחוסנים לא יקבלו את המחלה unvacc_perc %type: כפול; אחוז האוכלוסייה לא מחוסן init_infect %type: int; אחוז האוכלוסייה מחוסנים

בשלב הבא עלינו לבצע כמה חישובים.

אנו הולכים לעשות 'זיהוי מט' שהוא מטריצת 3*NUMOFPEOPLE.

vacc_perc = 1-unvacc_perc;

infectMat = nan (3, NUMOFPEOPLE); מספר = עגול (vacc_perc * NUMOFPEOPLE); זיהום מט (1, 1: מספר) = חיסון; infectMat (1, מספר+1: סוף) = unvacc; infectMat (2, 1: end) = 0; infectMat (2, 1: init_infect) = 1;

הסבר קוד

שורה 1: אחוז האוכלוסייה המחוסן מחושב

שורה 2: צור מטריצת מספר 3*N של אנשים

שורה 3: גלה את מספר האנשים המחוסנים מאחוזים מחוסנים

שורה 4: לאנשים המחוסנים, תנו להם חסינות הקשורה בחיסון. ערך זה מוקצה על סמך מחקרים אודות המחלה.

שורה 5: לשאר האוכלוסייה (אנשים לא מחוסנים), העניקו להם את אחוז החסינות. ערך זה מוקצה על סמך מחקרים אודות המחלה.

שורה 6: הגדר תחילה את כל האנשים שלא נדבקו.

שורה 7: עבור מספר האנשים שנדבקו בהתחלה, מלא את העמודות הזוגות הראשונות בהתאם.

כעת, לאחר שקבענו את כל הפרמטרים לסימולציה של המחלה, אנו הולכים לעשות אקראי את הסיכוי שהאדם (גם מחוסן וגם לא מחוסן) נדבק. זה נעשה בשלב הבא על ידי הקצאת ערכים אקראיים בין 0 ל -1 לכל אדם בשורה השלישית של 'זיהום מט' זה.

שלב 4: אקראי את הסיכוי שאדם מחוסן ולא מחוסן יכול להידבק

לאחר מכן, הקצה לכל אדם מספר אקראי, זה ישמש מאוחר יותר כדי לקבוע אם האדם נדבק או לא.

עבור w = 1: אורך (infectMat)

infectMat (3, w) = rand; סוֹף

הסבר קוד

זה עבור לולאה עוסק בשורה השלישית של ה- 'infectMat' שנוצר בשלב האחרון. 'rand' מקצה ערך בין 0 ל -1 לכל אינדקס של שורה 3.

תְפוּקָה

infectionMat הושלם כעת! זה היה עם אוכלוסייה עם 100% חיסון ואדם אחד נדבק בתחילה.

infectMat =

טורים 1 עד 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.8352 עמודים 0.7500 0.7500 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: אחוז הסיכוי לא לחלות במחלה

שורה 2: נגוע או לא נגוע (ערך בוליאני)

שורה 3: מספר המשמש לבדיקה אם אדם שאינו נגוע נדבק אם הוא פוגש אדם נגוע. אם אדם שאינו נגוע פוגש אדם נגוע, מספר זה גדול מהמספר בשורה 1 (עבור אותה עמודה), אז הוא נדבק. אנו נקודד פונקציונליות זו בשלב 7.

שלב 5: צור מטריצות של אנשים שאינם מחוסנים ונדבקים ממידע ראשוני

צור 2 מטריצות בשם "matrixUnvacc" ו- "matrixInfected" המאחסנות את כל האנשים הנגועים מ- infectMat. זה ישמש על מנת שנוכל לצבוע את הגרף של אלה שנדבקו, לא מחוסנים או מחוסנים, ומסייע לדמיין את ההשפעה של אנשים לא מחוסנים לעומת אנשים מחוסנים.

לנקות כל אחת

matrixInfected = ; matrixUnvacc = ; עבור h = 1: length (infectMat) אם infectMat (1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; סוף סוף לאדם = 1: NUMOFPEOPLE אם infectMat (2, person) == 1 matrixInfected = [matrixInfected, person]; סוף סוף

הסבר קוד

צור שני מטריצות ריקות לאחסון מספרי האנשים שאינם מחוסנים ונגועים בהתאמה. הן עבור לולאות שרצות 20 פעמים ואם הצהרת if מתקיימת, המספר מתווסף למטריצה הנכונה.

תְפוּקָה

matrixUnvacc =

matrixInfected =

[1]

שלב 6: עלילת הגרף הראשוני

לאחר מכן אנו הולכים לתוות את מטריצת הסמיכות.

g = graph (adjMatrix);

איור (1) p = plot (g, 'NodeColor', 'b', 'MarkerSize', 7); הדגשה (p, matrixUnvacc, 'NodeColor', 'g') הדגשה (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title (['אחוז האנשים שאינם מחוסנים:', num2str (title_unvacc), '%']); הפסקה (מהירות)

הסבר קוד

תורת הגרפים ב- Matlab כוללת פונקציות מובנות. כאשר אנו משתמשים בפונקציה graph (), אנו יכולים לתרגם את 'adjMatrix' לגרף בפועל ללא כיוון. לאחר מכן עלינו ליצור עלילה באמצעות הפונקציה העלילה () כדי לראות כיצד היא נראית. הגדרנו את העלילה () למשתנה כך שנוכל לתפעל ולשנות את צבעי העלילה ביתר קלות לאורך הסימולציה. כל האנשים (או הצמתים) מוגדרים בתחילה בצבע 'כחול'. לאחר מכן, כל האנשים הלא מחוסנים מוגדרים לצבע 'ירוק'. האנשים הנגועים נקבעים לאחר מכן לצבע 'אדום'. הכותרת נקבעת על פי ערך האחוז המסוים של אנשים לא מחוסנים הנבדקים. הפונקציה pause () עוצרת באופן זמני את ביצוע MatLab. אנו עוברים את המהירות המשתנה המתפזרת המחושבת בשניות.

עיין בתמונה (למעלה) כדי לראות גרף מקודד בצבע אקראי.

למידע נוסף על פונקציית ה- highlight () ב- MatLab.

שלב 7: לדמות את התקדמות הזיהום

בשלב הבא עלינו להבין מי נדבק לאחר האינטראקציות (נרשם ב- adjMatrix) ולעדכן את הגרף כאשר מישהו נדבק.

השתמש ב- adjMatrix כדי לקבוע אילו אנשים נדבקים לאחר האינטראקציות שלהם עם אנשים ביום.

עבור כל שורה = 1: אורך (adjMatrix)

אם infectMat (2, eachRow) == 1 עבור eachCol = 1: length (adjMatrix) אם adjMatrix (eachRow, eachCol) == 1 % eachRow = האדם % eachCol = חבר שלו % החבר של כל אדם ובדוק אם הם נדבקים. אם infectMat (3, eachCol)> infectMat (1, eachCol) infectMat (2, eachCol) = 1; הדגש (p, eachCol, 'NodeColor', 'r') השהה (מהירות) סוף סוף סוף סוף סוף סוף

לולאות ה- for לולאות דרך כל אדם. הוא בודק שאם האדם נדבק, הוא יבדוק כל אחד מהאנשים/חברים איתם יצרו אינטראקציה ויבדוק אם רמת החסינות של החבר הייתה גדולה יותר מעוצמת המחלה. כאן נכנס לתמונה ה- 'infectMat' שיצרנו קודם לכן. השורה הראשונה והשלישית בכל עמודה של החבר מושווים ואם השורה השלישית גדולה יותר, המשמעות היא שלחבר לא הייתה חסינות מספיק גבוהה כדי להימלט מהמחלה ובסופו של דבר נדבק. אנו גם משנים לצבע באמצעות הדגשה () לאדום אם הם נדבקים.

עכשיו הקוד שלך לסימולציה אמור לעבוד! ולכל גודל אוכלוסייה, פשוט שנה NUMOFPEOPLE!

שלב 8: השתמש בתורת מונטה קרלו

כדי לקחת את זה צעד אחד קדימה ולחלץ נתונים מהסימולטור שלנו ('infectSim.m'), רצינו לחשב ולרשום את המגמה באחוזים של אנשים לא מחוסנים שנדבקו ואחוז האנשים המחוסנים שנדבקו. אנו משערים שאחוז האנשים המחוסנים שנדבקו צריך להיות נמוך בהרבה מאחוז האנשים הלא מחוסנים שנדבקו.

שלב 9: הפוך את הקובץ ('infectSim.m') בעזרת הסימולציה לפונקציה

כדי להריץ את מונטה קרלו, נרצה להריץ את הסימולציה מספר פעמים ולצבור נתונים כדי שנוכל להשתמש בהם כדי לתרשם את אחוזי האנשים שנדבקו.

ניתן להגדיר את הפונקציה כך:

פלט פונקציה = זיהום סים (unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

הגיבו על המשתנים בסימולציה שלכם מכיוון שעכשיו אתם מעבירים אותם דרך הקובץ הראשי (נתחיל לכתוב זאת בשלב 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

המשתנה החדש

מְהִירוּת

יוקצה בקובץ הראשי (Monte_Carlo.m).

הערה: אל תשכח את הסוף בתחתית קובץ הפונקציות לסיום הפונקציה!

שלב 10: חשב את אחוז האנשים שאינם מחוסנים ומחוסנים שנדבקו

זה מחשב את אחוז האנשים הלא מחוסנים שנדבקו. קוד זה נכנס בתחתית הקובץ 'infectSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; %מחשב את אחוז האנשים שאינם מחוסנים שנדבקו ב- x = 1: length (infectMat) אם infectMat (1, x) == unvacc number_of_unvacc = number_of_unvacc+1; סוף אם infectMat (1, x) == unvacc & infectMat (2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; סוף סוף אחוז_אופן_אונוואק_אנד_אינפיק = (מספר_אופק_אונבק / מספר_אופן_אוואק)*100;

הסבר קוד

בלולאת ה- for, היא תעשה לולאה מעל NUMOFPEOPLE פעמים. בכל פעם שהמספר ב- infectionMat תואם את מספר unvacc (כלומר 0.95 == 0.95), אזי מספר האנשים שאינם מחוסנים יוגדל ב -1. מספר הנדבקים והלא מחוסנים עולה בשורה 1. השורה האחרונה מחלקת את מספר הנדבקים והלא מחוסנים במספר הכולל של אנשים לא מחוסנים. ואז האחוז מחושב מכאן.

אתגר:

נסה לחשב את אחוז המחוסנים של אנשים שנדבקו! (רמז: הוא דומה מאוד לקוד לעיל, אולם חלק מהמשתנים משתנים ושמות מותאמים.)

לאחר מכן מחושב אחוז האנשים שנדבקו בהתבסס על כלל האוכלוסייה:

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

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

הסבר קוד

הסכום המצטבר מחושב באמצעות השורה השנייה של ה- InfectionMat, המאחסן 1 ו 0, תלוי אם האדם נדבק או לא.מכיוון שפונקציית cumsum () מחזירה מטריצה, אנו לוקחים את הערך האחרון במטריצה ('pre_per_infect (1, NUMOFPEOPLE)'), שאמור להיות הסכום בפועל של כל הערכים מתוך 'infectMat (2,:)'. על ידי חלוקת הסכום במספר ה- NUMOFPEOPLE והכפלתו ב- 100, נקבל את האחוז הסופי של הנדבקים בכל האוכלוסייה.

שלב 11: צור משתנה פלט בפונקציית 'infectSim.m' שלך

פלט = [per_infect, percent_of_unvacc_and_infec, percentage_of_vacc_and_infec];

הסבר קוד

אחסן מידע זה בפלט, שיישלח חזרה למערכת הראשית (Monte_Carlo.m) כאשר הפונקציה תתקשר ותסתיים. נתונים אלה משמשים לשרטוט נקודות האחוז של הנדבקים של אלה שחוסנו ולא מחוסנים.

יש לבצע את הפונקציה 'infectSim.m' שלך כעת! עם זאת, זה לא יפעל כי אנחנו עדיין צריכים לכתוב את הראשי!

שלב 12: צור תפריט כדי לקבל תנאים ראשוניים של הסימולציה מהמשתמש

זכור כיצד אמרנו את המשתנה

מְהִירוּת

ייווצר ויועבר דרך הפונקציה העיקרית? עלינו להשיג את הערכים כדי לעבור לפונקציה. שימו לב, סדר הערכים בעת קריאת הפונקציה משנה!

התחל בכך שתבקש מהמשתמש להקליד מספר תשובות במסוף.

> בחר מחלה. שים לב שזה תלוי באותיות רישיות >> שעלת >> שפעת >> חצבת >> מחלה שנבחרה: שפעת >> בחר גודל אוכלוסייה. >> 20 >> 200 >> אוכלוסייה שנבחרה: 20 >> מהירות בחירת סימולציה. >> מהיר >> איטי >> מהירות שנבחרה: מהירה

קוד זה להלן שואל את המשתמש לאיזו מחלה הוא רוצה לבדוק.

disp ('בחר מחלה. שים לב שהיא רגישה לאותיות')

fprintf ('Pertussis / nFlu / nMeasles / n') disease = input ('מחלה נבחרה:', 's'); אם חיסון שווה (מחלה, 'שעלת') =.85; %15 אחוז סיכוי לחלות במחלה unvacc =.20; 80 %סיכוי לחלות במחלה אחרת אם החיסון אינו שווה (מחלה, 'שפעת') =.75; %25 אחוז סיכוי לחלות במחלה unvacc =.31; %69 אחוז סיכוי לחלות במחלה אחרת אם החיסון לא שווה (מחלה, 'חצבת') =.97; %3 %סיכוי לחלות במחלה unvacc =.10; %90 אחוז סיכוי לחלות במחלה

הסבר קוד:

הפונקציה disp () מדפיסה את ההצהרה למסך והיא גם מדפיסה את האפשרויות השונות. המחלה תוקצה בהתאם. גרסה זו אינה מהווה כרגע קלט לא חוקי. קלט לא חוקי יפיק שגיאה ויעצור את התוכנית לחלוטין. לכל מחלה יש ערכי חיסון ו unvacc הקשורים אליה. ערכים אלה אינם אקראיים. את הערכים האלה קיבלנו מחקר נתונים סטטיסטיים אודות המחלות.

לאחר מכן, עלינו לשאול את המשתמש אם הוא רוצה לבדוק גודל אוכלוסייה גדול או קטן עבור המחלה שבחרה.

disp ('בחר גודל אוכלוסייה'.)

fprintf ('20 / n200 / n ') speed = input (' אוכלוסייה שנבחרה: ',' s '); אם איזון (מהירות, '20') אוכלוסיית_גודל = 20; elseif שוויון (מהירות, '200') גודל_אוכלוסייה = 200; סוֹף

הסבר קוד

זה אכן מדפיס הצהרה למשתמש ומבקש מהמשתמש להזין את גודל האוכלוסייה שהוא רוצה לבדוק. גרסה זו אינה מהווה כרגע קלט לא חוקי. קלט לא חוקי יפיק שגיאה ויעצור את התוכנית לחלוטין. 20 נבחרו מכיוון שזה גודל מדגם קטן שעדיין נותן מושג טוב כיצד התפשטות הזיהום בקרב אוכלוסייה קטנה. 200 אנשים נבחרו כאופציה הגדולה יותר מכיוון של -200 נקודות שהוצבו על הגרף היו בקושי חפיפה של נקודות כך שניתן היה לראות הכל ולהבדיל זה מזה.

לאחר מכן, עלינו למצוא את מהירות הסימולציה.

disp ('בחר מהירות סימולציה'.)

fprintf ('מהיר / n איטי / n') מהירות = קלט ('מהירות שנבחרה:', 's'); אם שווה (מהירות, 'מהיר') sim_speed = 0; elseif שווה (מהירות, 'איטי') sim_speed = 0.25; סוֹף

הסבר קוד

תהליך זה היה זהה לקבלת סוג המחלה וגודל האוכלוסייה. לצום לא תהיה הפסקה. ובאיטיות, יהיה פיגור של 0.25 שניות בלולאת ה- for בעת הפעלת הסימולציה.

גדול! עכשיו יש לנו את כל התשומות מהמשתמש שאנחנו צריכים! בואו נעבור לאיסוף נתונים עבור אחוזים שונים של אנשים לא מחוסנים.

שלב 13: בחר אחוז מהאנשים הלא מחוסנים וחשב את ממוצע החסנים והנדבקים באחוזים שנבחרו

קוד זה מיועד ל -0% מהאנשים הלא מחוסנים.

% ------- % 0 לא מחוסן ------------

per_infect_av_0 = ; percent_of_unvacc_and_infec_av_0 = ; עבור i = 1:20 החוצה = זיהום Sim (unvacc, vacc, size_size, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, החוצה (1, 1)]; percent_of_unvacc_and_infec_av_0 = [percent_of_unvacc_and_infec_av_0, החוצה (1, 2)]; סוף ממוצע_נדבק_0 = ממוצע (per_infect_av_0); average_unvacc_and_infected_0 = ממוצע (אחוז_אופן_ואנק_וא_אינפעק_0);

הסבר קוד:

לולאת ה- for מופעלת 20 פעמים. הפלט מהפונקציה, infectSim (), מאוחסן החוצה. בכל פעם ריצת הלולאה for, אז אחוז הנדבקים בכל האוכלוסייה מתווסף למטריצה, 'per_infect_av_0'. בנוסף, אחוז הבלתי מחוסנים והנגועים מתווסף בכל פעם גם למטריצה 'percent_of_unvacc_and_infec_av_0'. בשתי השורות האחרונות, לאחר מכן ממוצעים של שתי מטריצות אלה, שהוזכרו לעיל, ומאוחסנות במשתנים. לסיכום, האחוזים נשמרים עבור כל סימולציה, ממוצעים ומתווים גרפים. מונטה קרלו משמש להראות את הערך הממוצע של הפעלת סימולציה והצגת התוצאה. למטרות הניסוי שלנו, אנו בוחרים להריץ את הסימולציה פי 20 ולממוצע ערכים אלה.

אתגר:

חזור על כל האחוזים שברצונך לבדוק! ניתן לעשות זאת על ידי שינוי שמות המשתנים בהתאם למספרי האחוזים. בדקנו 0%, 5%, 10%, 20%, 30%ו- 50%.

רֶמֶז:

השורה היחידה שיש לשנות בקוד בפועל היא

out = infectSim (unvacc, vacc, size_size, 0, 1, sim_speed);

שנה את האפס לאחוז בצורה עשרונית. לדוגמה, עבור 5% סימולציה לא מחוסנת, יש להחליף את ה- 0 ב- 0.5.

שלב 14: גרף: 'מגמת ההדבקה ב- Vs. מחוסנים למחלות ספציפיות '

זהו הקוד לביצוע גרף של מגמת ההדבקה בקרב אנשים לא מחוסנים לעומת אנשים שאינם מחוסנים.

graph_mat_y = [ממוצע_נדבקים_0, ממוצע_נדבקים_5, ממוצע_נדבקים_10, ממוצע_נדבקים_20, ממוצע_נדבקים_30, ממוצע_נדבקים_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; שיפוע = (ממוצע_נגוע_5-ממוצע_נפגע_0)/5; line_y = [ממוצע_נגוע_0, (שיפוע*50)+ממוצע_נדבק_0]; line_x = [0, 50]; איור (2) עלילה (graph_mat_x, graph_mat_y); line (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); title (['מגמה בחוסר חיסון', מחלה]); xlabel ('אחוז הראשונים שלא חוסנו'); ylabel ('אחוז הנדבקים סופיים')

הסבר קוד

שורה 1: הקצאת ערכי y לממוצעים של אחוזים נגועים

שורה 2: מוקצים ערכי x לאחוז האחוזים ההתחלתיים שאינם מחוסנים

שורה 3: חשב את השיפוע של 0% ו- 5%

שורה 4: אחסן ערכי y של שורה. זהו המשך של סעיף 0% עד 5%.

שורה 5: אחסן ערכי y של שורה. קו זה משתרע על פני אורך הגרף.

שורה 6: צור דמות

שורה 7: משרטטים את ערכי הגרף x ו- y של האחוזים הנגועים, שאינם מחוסנים.

שורה 8: משרטטים את השורה. זה משמש להראות שזה לא גדל באופן לינארי, אלא אקספוננציאלי.

שורה 9: הגדר את הכותרת של הגרף.

שורה 10-11: הגדר תוויות x ו- y לגרף.

כעת אתה אמור להיות מסוגל לראות שככל שאחוז האוכלוסייה גדול יותר מחוסן, כמות הזיהומים גדולה יותר. תוכלו גם לראות שרוב הנקודות שהופכות לאדומות הן נקודות ירוקות, מה שמראה שהחיסון אכן עוזר במידה מסוימת! מקווה שאהבתם את ההדרכה הזו. הגיבו אם יש לכם שאלות!

שלב 15: מוצר סופי: איך נראית הסימולציה

כל הקוד ניתן למצוא כאן