ვაქცინაცია თუ არა? დაავადებათა სიმულაციის გზით ნახირი იმუნიტეტის დაკვირვების პროექტი: 15 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

პროექტის მიმოხილვა:

ჩვენი პროექტი იკვლევს ნახირის იმუნიტეტს და იმედოვნებს, რომ წაახალისებს ხალხს მიიღოს ვაქცინაცია, რათა შეამციროს ინფექციის მაჩვენებელი ჩვენს თემებში. ჩვენი პროგრამა ახდენს სიმულაციას, თუ როგორ აინფიცირებს დაავადება მოსახლეობას ვაქცინირებული და არავაქცინირებული პროცენტული მაჩვენებლებით. ის გვიჩვენებს ნახირის იმუნიტეტს იმის ჩვენებით, თუ როგორ შეუძლია ვაქცინირებული მოსახლეობის რაოდენობის შემცირებას დაზარალებულთა რიცხვი.

ჩვენ ამას ვაკეთებთ მოდლაბში გრაფიკის თეორიის ცნებების გამოყენებით. გრაფიკის თეორია არის მათემატიკური გზა საგნებს შორის ურთიერთობების წარმოსაჩენად. გრაფიკის თეორიაში გრაფიკებს აქვთ წვეროები (ან კვანძები), რომლებიც დაკავშირებულია კიდეებით (ან ხაზებით). ჩვენი პროექტისთვის კვანძები არიან დაინტერესებული პირები და კიდეები მათი კავშირებია. მაგალითად, თუ ორი კვანძი უკავშირდება ზღვარს, ეს ნიშნავს რომ ისინი "მეგობრები" არიან ან აქვთ რაიმე სახის კონტაქტი ერთმანეთთან. ეს კონტაქტი არის დაავადების გავრცელების საშუალება. სწორედ ამიტომ ჩვენ გამოვიყენეთ გრაფიკის თეორია ჩვენი კონცეფციის მოდელირებისთვის, რადგან გვინდოდა ვნახოთ, როგორ ვრცელდება დაავადება მოსახლეობაში, რომლებიც დაკავშირებულია პოპულაციაში.

ჩვენი პროექტი ასევე მოიცავს მონტე კარლოს მეთოდს. მონტე კარლოს მეთოდი არის ალგორითმები, რომლებიც ქმნიან განმეორებით შემთხვევით შერჩევას რიცხვითი შედეგების მისაღებად. ჩვენს პროექტში ჩვენ ვიყენებთ ამ მეთოდს იმისთვის, რომ ჩვენი სიმულაცია რამდენჯერმე შეცვალოს პირველადი არავაქცინირებული პროცენტული მაჩვენებელი, რათა დაინახოს რამდენად ინფიცირდება ხალხი.

პროექტის ყველა კოდი დაკავშირებულია ბოლოში!

PC კრედიტი:

Matlab ბმული გრაფიკის თეორიასთან:

ნაბიჯი 1: შექმენით მიმდებარე მატრიცა

შექმენით ახალი სკრიპტი. ჩვენ ვაპირებთ მოვუწოდებთ ჩვენს "ინფექციის Sim.m".

ჩვენ ვაპირებთ შევქმნათ ცვლადი 'NUMOFPEOPLE'. თქვენ შეგიძლიათ მიანიჭოთ ის მთელ მნიშვნელობას. ეს იქნება თქვენი მოსახლეობის რაოდენობის რაოდენობა.

ამიერიდან ჩვენ ამას ვივარაუდებთ

NUMOFPEOPLE = 20;

პირველი დაიწყეთ Matlab– ის გრაფიკის თეორიული ფუნქციების გამოყენებით არა მიმართული გრაფიკისთვის.

თუ თქვენ დაინტერესებული ხართ მეტის სწავლით, აქ არის ბმული, რომ უფრო დეტალურად წაიკითხოთ ამის შესახებ.

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

შეიქმნა მიმდებარე მატრიცა.

adjMatrix = ნულოვანი (NUMOFPEOPLE);

ეს შექმნის 0 -ის კვადრატულ მატრიცას. მატრიცის თითოეული რიგი არის პიროვნება. მატრიცის თითოეული სვეტი არის ადამიანი ან მეგობარი, რომელსაც ადამიანი ხვდება მთელი დღის განმავლობაში.

იხილეთ ფიგურა 100 (ზემოთ), რათა დაგეხმაროთ ვიზუალიზაციაში, თუ როგორ გამოიყურება adjMatrix 20 ადამიანისთვის.

** ამ მომენტიდან ჩვენ ვივარაუდოთ, რომ NUMOPPOPLE ტოლია 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 = გრაფიკი (a); %გრაფიკის ფუნქციის (გრაფიკის თეორია) ფიგურის (1) გამოყენებით; h = ნაკვეთი (g);

იხილეთ სურათი 1 (ზემოთ), რომ ნახოთ თუ როგორ უნდა დაამატოთ კიდეები მიმდებარე მატრიცაში, კოდის გამოყენებით "შენიშვნა".

ნაბიჯი 2: შექმენით ურთიერთობები

ახლა, როდესაც ადამიანები (წვეროები ან კვანძები) იქმნება, ჩვენ უნდა შევქმნათ ურთიერთობების ქსელი (გრაფის ხაზები ან კიდეები). ეს იქნება იმიტირებული, თუ როგორ ურთიერთობენ ადამიანები და ხვდებიან სხვა ადამიანებს მთელი დღის განმავლობაში.

ეს შეიძლება გაკეთდეს მრავალი გზით. ამ ამოცანის შესრულების ერთ -ერთი გზაა პირველ რიგში მიანიჭოთ შემთხვევითი რიცხვი თითოეულ ადამიანს, რათა დადგინდეს რამდენ ადამიანთან იქნება თითოეული ადამიანი ერთ დღეში.

numOfFriendsMatrix = რანდი ([მინიმუმFriendsPersonCanHave, mostFriendsPersonCanHave], 1, NUMOFPEOPLE);

ეს ქმნის შემთხვევითი რიცხვების 1 -დან 20 -ის მატრიცას, რომელიც წარმოადგენს თითოეული ადამიანის ურთიერთქმედების რაოდენობას დღეში. ამ მატრიცის სვეტები იქნება თითოეული ადამიანის შესაბამისი რიცხვი. მაგალითად, თუ მინიმალურ მინიჭებას მივცემთFriendsPersonCanHave = 2 და mostFriendsPersonCanHave = 5, ჩვენ მივიღებთ შემთხვევით მნიშვნელობებს 2 -დან 5 -მდე.

გაწუხებთ რანდი ()? ტერმინალში, ჩაწერეთ

რანდის დახმარება

შემდეგი, ჩვენ ვაკეთებთ რანდომიზებულ მატრიქსს (ე.წ. "allFriendsmatrix"), თუ როგორ არის დაკავშირებული/ურთიერთქმედებს მოსახლეობაში თითოეული ადამიანი პოპულაციაში.

tempMatrix = ;

დათვლა = 0; allFriendsMatrix = ; k = 1 -ისთვის: NUMOFPEOPLE ხოლო სიგრძე (tempMatrix) ~ = numOfFriendsMatrix (k) რაოდენობა = რაოდენობა +1; temp = რანდი ([1, NUMOFPEOPLE]); tempMatrix (რაოდენობა) = temp; ბოლომდე გასუფთავება სანამ სიგრძე (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; დასრულდება allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; დათვლა = 0; დასასრული

კოდის სიღრმისეული ახსნა:

პირველ რიგში ჩვენ ვქმნით ცარიელ დროებით მატრიცას, რომ შევინარჩუნოთ თითოეული ადამიანის მეგობარი/ინტერაქციის სია. ჩვენ ასევე ვიწყებთ დათვლას, რომელიც თვალყურს ადევნებს, თუ სად უნდა ჩავყაროთ ახალი შემთხვევითი კავშირი tempMatrix– ში. For for მარყუჟები მუშაობს 20 -ჯერ ისე, რომ ეს მოხდეს მოსახლეობის თითოეულ ინდივიდზე. პირველი ხოლო მარყუჟი გადის მანამ, სანამ თითოეული ადამიანის tempMatrix არ იქნება შემთხვევით მინიჭებული რაოდენობის ურთიერთქმედების იგივე სიგრძე. ამ მარყუჟში წარმოიქმნება შემთხვევითი რიცხვი, რომელიც შეესაბამება მოსახლეობას და მოთავსებულია tempMatrix– ში. ვინაიდან თითოეული tempMatrixes- ის სიგრძე განსხვავებულია, ჩვენ გვჭირდება NaN მნიშვნელობების შექმნა, რათა შევძლოთ ყველა ამ tempMaticies- ის გაერთიანება ერთ მატრიცაში ('allFriendsMatrix'). მეორე while loop აგვარებს ამ პრობლემას NaN- ის დამატებით თითოეულ tempMatrix- ში. ხოლო მარყუჟის დაყენება იყო 9 -ჯერ, რადგან ის არის რიცხვი 5 -ზე მეტი, რაც იყო მეგობრების ზედა ზღვარი, რომელსაც შეიძლება მივაკუთვნოთ ადამიანი. მნიშვნელობა '9' ცვალებადია და შეიძლება/უნდა შეიცვალოს, როდესაც 'mostFriendsPersonCanHave' 9 -ზე მეტია. კოდის ბოლო სამი ხაზი (დასასრულის გამოკლებით) tempMatrix- ს ამატებს "allFriendsMatrix" - ის მომდევნო რიგში. შემდეგ ის ასუფთავებს tempMatrix- ს და ითვლის შემდეგ პირს.

გამომავალი

ეს არის ის, რაც გამომავალი უნდა გამოიყურებოდეს for for loop– ის პირველი გაშვებისას (ბოლო სამი ხაზის წინ).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

allFriendsMatrix =

16 8 17 16 13 NaN NaN NaN NaN Na 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 Na 12 NaN NaN NaN NaN NaN NaN NaN NaN 4 13 2 12 NaN 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 NaN 20 19 3 NaN NaN NaN NaN NaN NaN NaN 13 10 NaN NaN NaN NaN NaN NaN NaN 2N 18 10 16 NaN NaN NaN NaN NaN NaN 2 6 14 3 13 NaN NaN NaN NaN NaN 8 16 14 8 NaN NaN NaN NaN NaN NaN 7 7 NaN NaN NaN NaN NaN NaN NaN 19 10 9 NaN NaN NaN NaN NaN NaN NaN 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 NaN 16 7 13 10 1 NaN NaN NaN NaN

შემდეგი, დაამატეთ ეს ურთიერთობები adjMatrix- ში.

თითოეული რიგისთვის = 1: NUMOFPEOPLE

eachCol = 1: 9 თუ ისნანი (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 -მდე. ისინი სიმეტრიული უნდა იყოს იმისთვის, რომ ის სწორად მუშაობდეს მატლაბში.

ჩვენს სიმულაციაში ჩვენ დავადგინეთ, რომ ადამიანებს არ შეუძლიათ ურთიერთქმედება საკუთარ თავთან. როდესაც ჩვენ რანდომიზებულია ღირებულებები, არის შანსი, რომ ჩვენს მეზობელ მატრიცას ჰქონდეს ეს შეცდომები.

მოდით გავასწოროთ ეს შემდეგი კოდით:

თითოეულისთვის = 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 %ტიპი: ორმაგი; მოსახლეობის პროცენტი არავაქცინირებული init_infect %ტიპი: int; მოსახლეობის პროცენტი აცრილია

შემდეგი, ჩვენ უნდა გავაკეთოთ გამოთვლები.

ჩვენ ვაპირებთ გავაკეთოთ "ინფექციის მატი", რომელიც არის 3*NUMOFPEOPLE მატრიცა.

vac_perc = 1-unvacc_perc;

ინფექციაMat = nan (3, NUMOFPEOPLE); ნომერი = მრგვალი (vac_perc * NUMOFPEOPLE); ინფექციის მატი (1, 1: ნომერი) = ვაქცინა; ინფექციის მატი (1, ნომერი+1: დასასრული) = unvacc; ინფექციის მატი (2, 1: დასასრული) = 0; ინფექციის მატი (2, 1: init_infect) = 1;

კოდის ახსნა

ხაზი 1: მოსახლეობის პროცენტი არავაქცინირებული გამოითვლება

ხაზი 2: შექმენით ადამიანების 3*N რაოდენობის მატრიცა

ხაზი 3: გაარკვიეთ ვაქცინირებული ადამიანების რაოდენობა პროცენტიდან

ხაზი 4: აცრილ ადამიანებს მიანიჭეთ იმუნიტეტი, რომელიც დაკავშირებულია ვაქცინასთან. ეს მნიშვნელობა განისაზღვრება დაავადების კვლევის საფუძველზე.

ხაზი 5: დანარჩენი მოსახლეობისთვის (არავაქცინირებული პირები) მიეცით მათ პროცენტული იმუნიტეტი. ეს მნიშვნელობა განისაზღვრება დაავადების კვლევის საფუძველზე.

ხაზი 6: თავდაპირველად დააყენეთ ყველა ადამიანი რომ არ იყოს ინფიცირებული.

ხაზი 7: თავდაპირველად ინფიცირებული ადამიანების რაოდენობისათვის, შესაბამისად შეავსეთ პირველი წყვილი სვეტები.

ახლა, როდესაც ჩვენ დავადგინეთ ყველა პარამეტრი დაავადების სიმულაციისთვის, ჩვენ ვაპირებთ შემთხვევით შემთხვევას, დაინფიცირდეს თუ არა ადამიანი (ვაქცინირებულიც და არავაქცინირებულიც). ეს კეთდება მომდევნო ეტაპზე, შემთხვევითი მნიშვნელობების მინიჭებით 0 -დან 1 -მდე თითოეულ ადამიანს ამ "ინფექციის მატის" მესამე რიგში.

ნაბიჯი 4: რანდომიზირეთ შანსი, რომ ვაქცინირებული და არავაქცინირებული ადამიანი დაინფიცირდეს

შემდეგი, მიანიჭეთ თითოეულ ადამიანს შემთხვევითი ნომერი, რომელიც მოგვიანებით იქნება გამოყენებული იმის დასადგენად, ინფიცირდება თუ არა ადამიანი.

w = 1 -ისთვის: სიგრძე (ინფექციის მატი)

ინფექციაMat (3, w) = რანდი; დასასრული

კოდის ახსნა

ეს მარყუჟისთვის ეხება ბოლო ეტაპზე შექმნილ "ინფექციის მატის" მესამე რიგს. 'rand' ანიჭებს მნიშვნელობას 0 -დან 1 -მდე მე -3 რიგის თითოეულ ინდექსს.

გამომავალი

infeMat ახლა დასრულებულია! ეს იყო 100% -იანი ვაქცინაციის მქონე მოსახლეობით და 1 ადამიანი თავდაპირველად დაინფიცირდა.

ინფექცია Mat =

სვეტები 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 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.7500 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.00007 0.0000000000000000000000000000000000000000000000000000000000000000000000. ku ku 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

რიგი 1: პროცენტული შანსი, რომ არ მიიღოთ დაავადება

რიგი 2: ინფიცირებული თუ არა ინფიცირებული (ლოგიკური მნიშვნელობა)

რიგი 3: ნომერი, რომელიც გამოიყენება იმის შესამოწმებლად, ინფიცირდება თუ არა ადამიანი ინფიცირებული პირთან შეხვედრის შემთხვევაში. თუ არაინფიცირებული პირი ხვდება ინფიცირებულ პირს, ეს რიცხვი უფრო დიდია ვიდრე 1 სტრიქონის ნომერი (ერთი და იგივე სვეტისთვის), მაშინ ისინი ინფიცირებულნი არიან. ჩვენ დავაკოპირებთ ამ ფუნქციონირებას მე –7 ნაბიჯში.

ნაბიჯი 5: შექმენით იმ ადამიანების მატრიცები, რომლებიც არ არიან აცრილები და დაინფიცირებულნი საწყისი ინფორმაციისგან

შექმენით 2 მატრიცა სახელწოდებით "matrixUnvacc" და "matrixInfected", რომელიც ინახავს ყველა ინფიცირებულ ადამიანს ინფექციისგან. ეს იქნება გამოყენებული ისე, რომ ჩვენ შეგვიძლია ფერადი კოდი გავაკეთოთ ინფიცირებულთა, არავაქცინირებულთა ან ვაქცინირებულთა გრაფიკზე, რაც ხელს შეუწყობს არავაქცინირებულთა და ვაქცინირებულთა გავლენის ვიზუალიზაციას.

გაასუფთავეთ თითოეული

matrixInfected = ; matrixUnvacc = ; h = 1 -ისთვის: სიგრძე (ინფექციამათ) თუ ინფექციამათ (1, თ) == unvacc matrixUnvacc = [matrixUnvacc, h]; დასასრული ადამიანისთვის = 1: NUMOFPEOPLE თუ ინფექცია Mat (2, პირი) == 1 matrixInfected = [matrixInfected, პირი]; დასასრული დასასრული

კოდის ახსნა

შექმენით ორი ცარიელი მატრიცა იმ ადამიანების რიცხვის შესანახად, რომლებიც შესაბამისად არ არიან აცრილები და ინფიცირებულები. ორივე მარყუჟისთვის მუშაობს 20 -ჯერ და თუ if განცხადება დაკმაყოფილებულია, მაშინ რიცხვი ემატება სწორ მატრიცას.

გამომავალი

matrixUnvacc =

მატრიცაინფიცირებული =

[1]

ნაბიჯი 6: ნაკვეთი საწყისი გრაფიკი

შემდეგი ჩვენ ვაპირებთ დავხატოთ მიმდებარე მატრიცა.

g = გრაფიკი (adjMatrix);

ფიგურა (1) p = ნაკვეთი (g, 'NodeColor', 'b', 'MarkerSize', 7); მონიშნეთ (p, matrixUnvacc, 'NodeColor', 'g') მონიშნეთ (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; სათაური (['ადამიანების პროცენტი არავაქცინირებული:', num2str (title_unvacc), '%']); პაუზა (სიჩქარე)

კოდის ახსნა

გრაფიკის თეორია Matlab– ში ჩაშენებულია ფუნქციებში. როდესაც ჩვენ ვიყენებთ გრაფის () ფუნქციას, ჩვენ შეგვიძლია გადავიყვანოთ "adjMatrix" რეალურ არა მიმართულ გრაფაში. შემდეგ ჩვენ უნდა შევქმნათ ნაკვეთი ნაკვეთის () ფუნქციის გამოყენებით, რათა რეალურად დავინახოთ როგორ გამოიყურება. ჩვენ ამ ნაკვეთს () ვანიჭებთ ცვლადს, რათა სიმულაციის განმავლობაში უფრო ადვილად შევძლოთ მანიპულირება და შეცვალოთ ნაკვეთის ფერები. ყველა ადამიანი (ან კვანძი) თავდაპირველად არის მითითებული ფერი "ლურჯი". შემდეგი, ყველა არავაქცინირებული ადამიანი მითითებულია "მწვანე" ფერიზე. ამის შემდეგ ინფიცირებულებს აქვთ ფერი "წითელი". სათაური განისაზღვრება ტესტირების არავაქცინირებული ადამიანების გარკვეული პროცენტული ღირებულების მიხედვით. პაუზა () ფუნქცია დროებით აჩერებს MatLab- ის შესრულებას. ჩვენ გავდივართ ცვლადი სიჩქარით, რომელიც ვრცელდება, რომელიც გამოითვლება წამებში.

იხილეთ სურათი (ზემოთ) შემთხვევითი ფერის კოდირებული გრაფიკის სანახავად.

შეიტყვეთ მეტი MatLab– ში highlight () ფუნქციის შესახებ.

ნაბიჯი 7: ინფექციის პროგრესირების სიმულაცია

შემდეგ ჩვენ უნდა გავარკვიოთ ვინ ინფიცირდება ურთიერთქმედების შემდეგ (ჩაწერილია adjMatrix– ში) და განაახლოთ გრაფიკი, როდესაც ვინმე ინფიცირდება.

გამოიყენეთ adjMatrix იმის დასადგენად, თუ რომელი ადამიანია ინფიცირებული ადამიანებთან ურთიერთობის შემდეგ.

თითოეული რიგისთვის = 1: სიგრძე (adjMatrix)

თუ ინფექცია Mat (2, თითოეული რიგი) == 1 თითოეული Col = 1: სიგრძე (adjMatrix) თუ adjMatrix (თითოეული რიგი, თითოეული კოლი) == 1 % თითოეული რიგი = პირი % eachCol = მისი მეგობარი % თითოეული ადამიანის მეგობარი და ნახე თუ არა ინფიცირებული რა თუ ინფექცია Mat (3, თითოეული Col)> ინფექცია Mat (1, თითოეული Col) ინფექცია Mat (2, თითოეული Col) = 1; გამოყოფა (p, eachCol, 'NodeColor', 'r') პაუზა (სიჩქარე) დასასრული დასასრული დასასრული დასასრული დასასრული

For მარყუჟის მარყუჟები თითოეული ადამიანის მეშვეობით. ის ამოწმებს, რომ თუ ადამიანი ინფიცირებულია, ის შეამოწმებს თითოეულ იმ ადამიანს/მეგობარს, რომელთანაც ურთიერთობდა და შეამოწმებს თუ არა მეგობრის იმუნიტეტი უფრო მაღალი ვიდრე დაავადების სიძლიერე. ეს არის ის ადგილი, სადაც ადრე შექმნილი "ინფექციის მატი" შემოდის. მეგობრის თითოეული სვეტის პირველი და მე -3 რიგები შედარებულია და თუ მე -3 რიგი უფრო დიდია, ეს ნიშნავს, რომ მეგობარს არ გააჩნდა იმუნიტეტი საკმარისად მაღალი, რომ გაექცეს დაავადებას და საბოლოოდ ინფიცირდება. ჩვენ ასევე ვიცვლით ფერს ხაზგასმით () წითელით, თუ ისინი დაინფიცირდებიან.

ახლა სიმულაციის თქვენი კოდი უნდა იმუშაოს! და ნებისმიერი ზომის მოსახლეობისთვის, უბრალოდ შეცვალეთ NUMOFPEOPLE!

ნაბიჯი 8: გამოიყენეთ მონტე კარლოს თეორია

ერთი ნაბიჯის გადადგმისთვის და ჩვენი სიმულატორიდან მონაცემების ამოღების მიზნით ("ინფექცია Sim.m"), ჩვენ გვსურს გამოვთვალოთ და დავხატოთ ტენდენცია არავაქცინირებული ადამიანების პროცენტულ მაჩვენებლებში და ინფიცირებულთა პროცენტებში. ჩვენ ვვარაუდობთ, რომ ინფიცირებული ადამიანების პროცენტი გაცილებით დაბალი უნდა იყოს ვიდრე ინფიცირებული არავაქცინირებული ადამიანების პროცენტი.

ნაბიჯი 9: გააკეთეთ ფაილი ("infeSim.m") სიმულაციით ფუნქციაში

მონტე კარლოს გასაშვებად, ჩვენ გვსურს სიმულაციის რამდენჯერმე გაშვება და მონაცემების დაგროვება, რათა ეს გამოვიყენოთ ინფიცირებულთა პროცენტული მაჩვენებლების გამოსახატავად.

ფუნქცია შეიძლება შეიქმნას ასე:

ფუნქცია გამომავალი = ინფექცია Sim (unvacc, vac, NUMOFPEOPLE, unvacc_perc, init_infect, სიჩქარე)

კომენტარი გააკეთეთ თქვენს სიმულაციურ ცვლადებზე, რადგან ახლა თქვენ გადასცემთ მათ ძირითად ფაილს (ჩვენ ამის წერას დავიწყებთ მე –12 ნაბიჯში):

unvacc, vac, NUMOFPEOPLE, unvacc_perc, init_infect

ახალი ცვლადი

სიჩქარე

გადაეცემა ძირითად ფაილში (Monte_Carlo.m).

შენიშვნა: არ დაივიწყოთ ფუნქციის ფაილის ბოლოში დასასრული ფუნქციის დასასრულებლად!

ნაბიჯი 10: გამოთვალეთ დაინფიცირებული და ვაქცინირებული ადამიანების პროცენტი

ეს ითვლის დაინფიცირებული არავაქცინირებული ადამიანების პროცენტს. ეს კოდი მიდის "infeSim.m" ფაილის ბოლოში.

ნომერი_ინვაქცია = 0;

ნომერი_ინფექ_უნვაცი = 0; %ითვლის არავაქცინირებული ადამიანების პროცენტულ რაოდენობას, რომლებიც დაინფიცირდნენ x = 1: სიგრძით (ინფექცია) თუ ინფექცია მატი (1, x) == unvacc number_of_unvacc = number_of_unvacc+1; დასრულდება, თუ ინფექციაა მატი (1, x) == unvacc & დასასრულის დასასრული_ინვაცი_და_ინფექცია = (რიცხვი_ინფეკი_უნვაცი / ნომერი_ინვაქსი)*100;

კოდის ახსნა

For for მარყუჟში, ის მარყუჟდება NUMOFPEOPLE -ჯერ. ყოველ ჯერზე ინფექციის რიცხვი მატი შეესაბამება არავაქცინის რიცხვს (ანუ 0.95 == 0.95), მაშინ არავაქცინირებული ადამიანების რიცხვი გაიზრდება 1 -ით. ყოველ ჯერზე ინფექციის რიცხვი მატი შეესაბამება არავაქცინის რიცხვს და ისინი ინფიცირებულნი არიან, ინფიცირებულთა და არავაქცინირებულთა რიცხვი იზრდება 1. ბოლო ხაზი ყოფს ინფიცირებულთა, არავაქცინირებულთა რიცხვს არავაქცინირებულთა საერთო რაოდენობას. შემდეგ პროცენტი გამოითვლება აქედან.

გამოწვევა:

შეეცადეთ გამოთვალოთ იმ ადამიანების პროცენტი, ვინც დაინფიცირდა! (მინიშნება: ეს ძალიან ჰგავს ამ კოდს, თუმცა ზოგიერთი ცვლადი იცვლება და სახელები მორგებულია.)

შემდეგ გამოითვლება ინფიცირებულთა პროცენტი მთლიანი მოსახლეობის მიხედვით:

pre_per_infect = cumsum (ინფექციის მატი (2,:));

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

კოდის ახსნა

კუმულაციური ჯამი გამოითვლება ინფექციის მეორე რიგის გამოყენებით, რომელიც ინახავს 1 -ს და 0 -ს იმისდა მიხედვით, არის თუ არა ადამიანი ინფიცირებული.ვინაიდან cumsum () ფუნქცია მატრიცას უბრუნებს, ჩვენ ვიღებთ ბოლო მნიშვნელობას მატრიცაში ('pre_per_infect (1, NUMOFPEOPLE)', რომელიც უნდა იყოს ყველა მნიშვნელობის ფაქტობრივი ჯამი 'infeMat (2,:)'. თანხის გაყოფისას NUMOFPEOPLE- ზე და მისი გამრავლებით 100 -ზე, ჩვენ ვიღებთ ინფიცირებულთა საბოლოო პროცენტულ მაჩვენებელს საერთო მოსახლეობაში.

ნაბიჯი 11: შექმენით გამომავალი ცვლადი თქვენს ფუნქციაში "ინფექცია Sim.m"

გამომავალი = [თითო_ინფექცია, პროცენტული_ინვაკე_ და_ინფექცია, პროცენტული_ვაქცი_და_ინფექცია];

კოდის ახსნა

შეინახეთ ეს ინფორმაცია გამომავალში, რომელიც დაუბრუნდება მთავარს (Monte_Carlo.m), როდესაც ფუნქცია გამოიძახება და დასრულდება. ეს მონაცემები გამოიყენება ინფიცირებულთა პროცენტული მაჩვენებლების გამოსახატავად, ვინც აცრილია და არავაქცინირებულია.

თქვენი "infeSim.m" ფუნქცია ახლავე უნდა გაკეთდეს! თუმცა, ის არ გაუშვება, რადგან ჩვენ მაინც გვჭირდება მთავარი!

ნაბიჯი 12: შექმენით მენიუ მომხმარებლისგან სიმულაციის საწყისი პირობების მისაღებად

დაიმახსოვრეთ როგორ ვთქვით ცვლადი

სიჩქარე

შეიქმნება და გაივლის ძირითად ფუნქციას? ჩვენ უნდა მივიღოთ მნიშვნელობები ფუნქციაზე გადასასვლელად. შენიშვნა, მნიშვნელობათა რიგს ფუნქციის გამოძახებისას მნიშვნელობა აქვს!

დაიწყეთ მომხმარებლის მოთხოვნით, ჩაწეროთ რამდენიმე პასუხი ტერმინალში.

> აირჩიე დაავადება. გაითვალისწინეთ, რომ ის არის დიდი ასოებით განხილული >> პერტუსი >> გრიპი >> წითელა >> დაავადება არჩეული: გრიპი >> შეარჩიეთ მოსახლეობის ზომა. >> 20 >> 200 >> არჩეული მოსახლეობა: 20 >> შეარჩიეთ სიმულაციის სიჩქარე. >> სწრაფი >> ნელი >> არჩეული სიჩქარე: სწრაფი

ქვემოთ მოყვანილი კოდი ეკითხება მომხმარებელს, თუ რა დაავადების ნახვა სურთ მათ.

დისპეპი ("აარჩიე დაავადება. გაითვალისწინე, რომ ის არის სენსიტიური")

fprintf ('Pertussis / n გრიპი / n წითელა / n') დაავადება = შეყვანა ('დაავადება არჩეული:', 's'); თუ არის არათანაბარი (დაავადება, "პერტუსი") ვაქცინა =.85; %15 პროცენტით დაავადების unvacc მიღების შანსი =.20; %80 პროცენტი დაავადების მიღების სხვაგვარად არათანაბარი (დაავადება, "გრიპი") ვაქცინა =.75; %25 პროცენტით დაავადების unvacc მიღების შანსი =.31; %69 პროცენტი დაავადების მიღების სხვაგვარად არათანაბარი (დაავადება, "წითელა") ვაქცინა =.97; %3 პროცენტი დაავადების მიღების ვაქცინის =.10; %90 პროცენტი დაავადების დასრულების

კოდის ახსნა:

Disp () ფუნქცია ამობეჭდავს განცხადებას ეკრანზე და ასევე ამობეჭდავს სხვადასხვა ვარიანტს. დაავადება დაინიშნება შესაბამისად. ეს ვერსია ამჟამად არ ითვალისწინებს არასწორ შეყვანას. არასწორი შეყვანა გამოიწვევს შეცდომას და მთლიანად შეაჩერებს პროგრამას. თითოეულ დაავადებას აქვს მასთან დაკავშირებული ვაქცინა და არავაქციონირებული ღირებულებები. ეს მნიშვნელობები შემთხვევითი არ არის. ჩვენ მივიღეთ ეს ღირებულებები დაავადებების შესახებ სტატისტიკის კვლევის შედეგად.

შემდეგი, ჩვენ უნდა ვკითხოთ მომხმარებელს, სურს თუ არა დიდი ან მცირე ზომის მოსახლეობის ტესტირება მათ მიერ არჩეულ დაავადებაზე.

disp ("აირჩიე მოსახლეობის ზომა.")

fprintf ('20 / n200 / n ') სიჩქარე = შეყვანა (' არჩეული მოსახლეობა: ',' 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 = ; პროცენტული_უნვაცი_და_ინფექ_ავ_0 = ; i = 1:20 გარეთ = ინფექცია Sim (unvacc, ვაქცინა, მოსახლეობის ზომა, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out (1, 1)]; პროცენტი_უნვაცი_და_ინფეკი_ავ_0 = [პროცენტი_უნვაცი_და_ინფექ_ავ_0, გარეთ (1, 2)]; ბოლოს საშუალო_ინფიცირებული_0 = საშუალო (თითო_ინფიცირებული_ავ_0); საშუალო_უვაცი_და_ინფიცირებული_0 = საშუალო (პროცენტული_უნვაცი_და_ინფექ_ავ_0);

კოდის ახსნა:

For მარყუჟის გაშვება ხდება 20 -ჯერ. ფუნქციის გამომუშავება, ინფექცია Sim (), ინახება გარეთ. ყოველ ჯერზე for მარყუჟის გაშვება, მაშინ პროცენტული ინფიცირებული მთლიანი მოსახლეობის ემატება matrix, 'per_infect_av_0'. გარდა ამისა, არავაქცინირებულთა და ინფიცირებულთა პროცენტული მაჩვენებელი ასევე ყოველ ჯერზე ემატება 'პროცენტის_უნვაცინის_და_ინფექ_ავ_0' მატრიქსს. ბოლო ორ სტრიქონში, ეს ორი, ზემოთ ნახსენები მატრიცები შემდეგ ხდება საშუალო და ინახება ცვლადებში. მოკლედ რომ ვთქვათ, პროცენტები ინახება თითოეული სიმულაციისთვის, საშუალოდ და გრაფიკულად. მონტე კარლო გამოიყენება სიმულაციის გაშვების საშუალო საშუალო მნიშვნელობისა და შედეგის ჩვენებისათვის. ჩვენი ექსპერიმენტული მიზნებისათვის, ჩვენ ვირჩევთ სიმულაციის 20 -ჯერ გაშვებას და ამ მნიშვნელობების საშუალო მნიშვნელობას.

გამოწვევა:

გაიმეორეთ ყველა იმ პროცენტისთვის, რომლის გამოცდა გსურთ! ეს შეიძლება გაკეთდეს ცვლადების სახელების შეცვლით პროცენტული რიცხვების მიხედვით. ჩვენ შევამოწმეთ 0%, 5%, 10%, 20%, 30%და 50%.

მინიშნება:

ერთადერთი ხაზი, რომელიც უნდა შეიცვალოს რეალურ კოდში არის

გარეთ = ინფექცია Sim (unvacc, vacc, population_size, 0, 1, sim_speed);

შეცვალეთ ნული პროცენტულად ათწილადის სახით. მაგალითად, 5% არავაქცინირებული სიმულაციისთვის, 0 უნდა შეიცვალოს 0.5 -ით.

ნაბიჯი 14: გრაფიკი:”ინფექციის ტენდენცია არავაქცინირებულთა წინააღმდეგ. ვაქცინირებული სპეციფიკური დაავადებისათვის '

ეს არის კოდი, რომელიც ასახავს ინფექციის ტენდენციის გრაფიკს არავაქცინირებულ ადამიანებთან შედარებით არავაქცინირებულ პირებთან.

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_x, line_y, 'ფერი', 'წითელი', 'LineStyle', '-'); სათაური (['ტენდენცია არავაქცინაციისათვის', დაავადება]); 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: საბოლოო პროდუქტი: როგორ გამოიყურება სიმულაცია

ყველა კოდი შეგიძლიათ იხილოთ აქ