टीका लगवाना है या नहीं? रोग अनुकार के माध्यम से हर्ड इम्युनिटी के निरीक्षण पर एक परियोजना: १५ कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

परियोजना का अवलोकन:

हमारी परियोजना झुंड प्रतिरक्षा की खोज करती है और हमारे समुदायों में संक्रमण दर को कम करने के लिए लोगों को टीकाकरण प्राप्त करने के लिए प्रोत्साहित करने की उम्मीद करती है। हमारा कार्यक्रम इस बात का अनुकरण करता है कि कैसे एक बीमारी टीकाकरण और असंबद्ध दरों के विभिन्न प्रतिशत के साथ आबादी को संक्रमित करती है। यह यह दिखाते हुए झुंड की प्रतिरक्षा को दर्शाता है कि टीके लगाने वाली आबादी की बढ़ी हुई संख्या प्रभावित लोगों की संख्या को कैसे कम कर सकती है।

हम इसे ग्राफ सिद्धांत अवधारणाओं का उपयोग करके मैटलैब में मॉडल करते हैं। ग्राफ सिद्धांत वस्तुओं के बीच संबंधों का प्रतिनिधित्व करने का एक गणितीय तरीका है। ग्राफ सिद्धांत में, ग्राफ़ में किनारों (या रेखाओं) से जुड़े शिखर (या नोड्स) होते हैं। हमारी परियोजना के लिए, नोड्स संबंधित व्यक्ति हैं और किनारे उनके कनेक्शन हैं। उदाहरण के लिए, यदि दो नोड्स एक किनारे से जुड़े हुए हैं तो इसका मतलब है कि वे "दोस्त" हैं या एक दूसरे के साथ किसी प्रकार का संपर्क है। यह संपर्क बीमारी फैलाने का एक तरीका है। यही कारण है कि हमने अपनी अवधारणा को मॉडल करने के लिए ग्राफ सिद्धांत का इस्तेमाल किया क्योंकि हम यह देखना चाहते थे कि आबादी में जुड़े व्यक्तियों में बीमारी कैसे फैलती है।

हमारी परियोजना में मोंटे कार्लो विधि भी शामिल है। मोंटे कार्लो विधि एल्गोरिदम हैं जो संख्यात्मक परिणाम प्राप्त करने के लिए बार-बार यादृच्छिक नमूना बनाते हैं। हमारी परियोजना में, हम अपने सिमुलेशन को चलाने के लिए इस पद्धति का उपयोग कई बार प्रारंभिक असंक्रमित प्रतिशत को बदलने के लिए करते हैं ताकि यह देखा जा सके कि लोग किस दर से संक्रमित होते हैं।

सभी प्रोजेक्ट कोड नीचे लिंक किए गए हैं!

पीसी क्रेडिट:

मैटलैब ग्राफ थ्योरी का लिंक:

चरण 1: एडजेंसी मैट्रिक्स बनाएं

एक नई स्क्रिप्ट बनाएं। हम अपने 'संक्रमणSim.m' को बुलाने जा रहे हैं।

हम एक वेरिएबल 'NUMOFPEOPLE' बनाने जा रहे हैं। आप इसे किसी भी पूर्णांक मान पर असाइन कर सकते हैं। यह आपकी आबादी में लोगों की संख्या का प्रतिनिधित्व करेगा।

अब से हम यह मानेंगे कि

NUMOFPEOPLE = 20;

सबसे पहले एक अप्रत्यक्ष ग्राफ के लिए मैटलैब के ग्राफ सिद्धांत कार्यों का उपयोग करके शुरू करें।

यदि आप और अधिक सीखने में रुचि रखते हैं, तो इसके बारे में और अधिक गहराई से पढ़ने के लिए यहां एक लिंक दिया गया है।

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

एक आसन्न मैट्रिक्स बनाया।

adjMatrix = शून्य (NUMOFPEOPLE);

यह 0s का एक वर्ग मैट्रिक्स बनाएगा। मैट्रिक्स में प्रत्येक पंक्ति एक व्यक्ति है। मैट्रिक्स में प्रत्येक कॉलम एक व्यक्ति या मित्र है जिससे व्यक्ति पूरे दिन मिलता है।

20 लोगों के लिए adjMatrix कैसा दिखता है, इसकी कल्पना करने में सहायता के लिए चित्र 100 (ऊपर) देखें।

**इस बिंदु से हम मान लेंगे कि NUMOFPEOPLE 20 के बराबर है।**

आप इस आसन्न मैट्रिक्स की साजिश रचने का प्रयास कर सकते हैं। इस प्रकार के आव्यूहों को आलेखित करने के बारे में यहां थोड़ी अधिक जानकारी दी गई है।

नोट: आसन्न मैट्रिक्स कैसे काम करता है।

भूतपूर्व:

% आसन्न मैट्रिक्स बनाना

ए = [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]% प्लॉटिंग जी = ग्राफ (ए); % ग्राफ़ फ़ंक्शन (ग्राफ़ सिद्धांत) का उपयोग करके चित्र(1); एच = प्लॉट (जी);

"नोट" में कोड का उपयोग करके, आसन्न मैट्रिक्स में किनारों को जोड़ने का तरीका देखने के लिए चित्र 1 (ऊपर) देखें।

चरण 2: संबंध बनाएं।

अब जब लोग (कोने या नोड्स) बन गए हैं, तो हमें संबंधों का एक नेटवर्क (ग्राफ की रेखाएं या किनारे) बनाने की जरूरत है। यह अनुकरण करेगा कि लोग पूरे दिन अन्य लोगों से कैसे बातचीत करते हैं और मिलते हैं।

यह कई तरह से किया जा सकता है। इस कार्य को पूरा करने का एक तरीका यह है कि पहले प्रत्येक व्यक्ति को यह निर्धारित करने के लिए एक यादृच्छिक संख्या निर्दिष्ट करें कि प्रत्येक व्यक्ति एक दिन में कितने लोगों के साथ बातचीत करेगा।

numOfFriendsMatrix = Randi ([LeastFriendsPersonCanHave, mostFriendsPersonCanHave], 1, NUMOFPEOPLE);

यह यादृच्छिक पूर्णांकों का 1 से 20 मैट्रिक्स बनाता है जो प्रत्येक व्यक्ति के एक दिन में होने वाले इंटरैक्शन की संख्या का प्रतिनिधित्व करता है। इस मैट्रिक्स के कॉलम प्रत्येक व्यक्ति के अनुरूप संख्या होगी। उदाहरण के लिए यदि हम कम से कम फ्रेंड्सपर्सनकैनहैव = 2 और मोस्टफ्रेंड्सपर्सनकैनहैव = 5 असाइन करते हैं, तो हमें 2 और 5 के बीच यादृच्छिक मान प्राप्त होंगे।

रैंडी () से परेशानी हो रही है? टर्मिनल में, टाइप करें

मदद रंडी

इसके बाद, हम एक यादृच्छिक मैट्रिक्स (जिसे "allFriendsmatrix" कहा जाता है) बनाते हैं कि कैसे आबादी में प्रत्येक व्यक्ति आबादी के भीतर जुड़ा/बातचीत करता है।

टेम्पमैट्रिक्स = ;

गिनती = 0; ऑलफ्रेंड्समैट्रिक्स = ; k = 1: NUMOFPEOPLE जबकि लंबाई (tempMatrix) ~ = numOfFriendsMatrix (k) गिनती = गिनती +1; अस्थायी = रैंडी ([1, NUMOFPEOPLE]); टेम्पमैट्रिक्स (गिनती) = अस्थायी; लंबाई (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; एंड ऑलफ्रेंड्समैट्रिक्स = [ऑलफ्रेंड्समैट्रिक्स; टेम्पमैट्रिक्स]; टेम्पमैट्रिक्स = ; गिनती = 0; समाप्त

कोड की गहराई से व्याख्या में:

पहले हम प्रत्येक व्यक्ति के दोस्तों/बातचीत सूची को रखने के लिए एक खाली अस्थायी मैट्रिक्स बनाते हैं। हम गिनती को भी इनिशियलाइज़ करते हैं, जो सिर्फ इस बात का ट्रैक रखता है कि टेम्पमैट्रिक्स में नए रैंडम कनेक्शन को कहाँ चिपकाना है। लूप के लिए 20 बार चलते हैं ताकि आबादी में प्रत्येक व्यक्ति के लिए ऐसा हो। पहली बार लूप तब तक चलता है जब तक कि प्रत्येक व्यक्ति का tempMatrix यादृच्छिक रूप से असाइन किए गए इंटरैक्शन की संख्या की समान लंबाई न हो। इस लूप में, जनसंख्या में व्यक्ति के अनुरूप एक यादृच्छिक संख्या उत्पन्न होती है और उसे tempMatrix में रखा जाता है। चूंकि प्रत्येक tempMatrixes की लंबाई अलग-अलग होती है, इसलिए हमें कुछ NaN मान बनाने की आवश्यकता होती है ताकि हम इन सभी tempMaticies को एक मैट्रिक्स ('allFriendsMatrix') में जोड़ सकें। दूसरा जबकि लूप प्रत्येक tempMatrix में NaN जोड़कर इस समस्या को हल करता है। जबकि लूप को 9 बार चलाने के लिए सेट किया गया था क्योंकि यह 5 से अधिक की संख्या है, जो एक व्यक्ति को असाइन किए जा सकने वाले दोस्तों की ऊपरी सीमा थी। मान '9' परिवर्तनशील है और 'mostFriendsPersonCanHave' 9 से अधिक होने पर इसे बदला जा सकता है/बदला जाना चाहिए। कोड की अंतिम तीन पंक्तियाँ (अंत को छोड़कर) tempMatrix को 'allFriendsMatrix' की अगली पंक्ति में जोड़ती हैं। फिर यह tempMatrix को साफ़ करता है और अगले व्यक्ति के लिए गिनती करता है।

उत्पादन

लूप (अंतिम तीन पंक्तियों से पहले) के माध्यम से पहली बार चलाने के लिए आउटपुट इस तरह दिखना चाहिए।

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

AllFriendsMatrix =

16 8 17 16 13 नैन नैन नन नैन 8 8 2 7 11 नैन नैन नैन नैन 10 13 नं न न न न न न न नन 11 17 2 नं न न न न न नान नं 10 12 नान नान न नान नान नं 4 13 2 12 नान नैन नन नन नन १७ १० ९ ३ १ नान नान नान नान १६ १६ ६ नान नान नान नान नान ३ ८ १७ १७ 14 नान न नान नान २० १९ ३ नान नान न नान नान नान १३ १० नान नान नान नान नान नान २ । १८ १० १६ नैन नं नन नं नन २ ६ १४ ३ १३ नैन नैन नैन ८ १६ १४ ८ नान नैन नं न नान ७ ७ नान न नान न नान न नान ९ १० ९ नान नान न नान न नान १० १९ नान न नान नान १० ९ नैन नान नान नं नन नं ५ १८ नण नं न नान नं न नान १ ७ नान नान नान नान नान नान १६ ७ १३ १० १ नान न नान नान ।

इसके बाद, इन संबंधों को adjMatrix में जोड़ें।

प्रत्येक पंक्ति के लिए = 1:NUMOFPEOPLE

प्रत्येक कॉल के लिए = 1:9 यदि इस्नान (सभी फ्रेंड्समैट्रिक्स (प्रत्येक पंक्ति, प्रत्येक कॉल)) == 0 adjMatrix (allFriendsMatrix (प्रत्येक पंक्ति, प्रत्येक कोल), प्रत्येक पंक्ति) = 1; अंत अंत अंत

कोड स्पष्टीकरण

लूप के लिए यह डबल 'allFriendsMatrix' की प्रत्येक पंक्ति और कॉलम के माध्यम से जाता है। if कथन उन सभी मानों के लिए चलेगा जो 'NaN' नहीं हैं। मूल रूप से यह ग्राफ के किनारों या रेखाओं का निर्माण करेगा। तो पहली पंक्ति यह बनाएगी व्यक्ति १ से व्यक्ति १६ और व्यक्ति १६ से व्यक्ति १। क्योंकि यह अप्रत्यक्ष है, १ को दोनों के लिए बदला जाना चाहिए! हमारे पास केवल 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

'adjMatrix' का ग्राफ देखने के लिए चित्र 2 देखें।

चरण 3: रोग सांख्यिकी जोड़ें।

अब जब आपका प्रोग्राम यादृच्छिक लोगों के एक समूह के साथ एक ग्राफ़ बना सकता है और यादृच्छिक संबंध बना सकता है, तो हमें यह देखने के लिए रोग की जानकारी या आँकड़ों को इनपुट करने की आवश्यकता है कि आबादी के भीतर ये बातचीत कैसे संक्रमण को बढ़ा या घटा सकती है।

ये चर बनाएं:

unvacc% प्रकार: डबल; अशिक्षित लोगों को बीमारी न होने की प्रतिशत संभावना

vacc% प्रकार: डबल; टीकाकृत लोगों को बीमारी न होने की प्रतिशत संभावना unvacc_perc %type: double; प्रतिशत आबादी का टीकाकरण नहीं हुआ init_infect %type: int; प्रतिशत आबादी का टीकाकरण

आगे हमें कुछ गणना करने की आवश्यकता है।

हम एक 'infectionMat' बनाने जा रहे हैं जो एक 3*NUMOFPEOPLE मैट्रिक्स है।

vacc_perc = 1-unvacc_perc;

संक्रमणमैट = नैन (3, NUMOFPEOPLE); संख्या = गोल (vacc_perc * NUMOFPEOPLE); संक्रमणमैट(1, 1:संख्या) = vacc; संक्रमणमैट (1, संख्या + 1: अंत) = अनवैक; संक्रमणमैट (2, 1: अंत) = 0; संक्रमणमैट (2, 1: init_infect) = 1;

कोड स्पष्टीकरण

पंक्ति 1: बिना टीकाकरण की गणना की गई जनसंख्या का प्रतिशत

पंक्ति 2: लोगों की एक 3*N संख्या मैट्रिक्स बनाएं

पंक्ति 3: टीकाकरण प्रतिशत से टीकाकरण करने वाले लोगों की संख्या ज्ञात कीजिए

पंक्ति ४: टीका लगाए गए लोगों के लिए, उन्हें टीका लगवाने से जुड़ी प्रतिरक्षा दें। यह मान रोग के बारे में शोध के आधार पर निर्धारित किया गया है।

पंक्ति ५: शेष आबादी (बिना टीकाकरण वाले व्यक्तियों) के लिए, उन्हें प्रतिशत प्रतिरक्षा दें। यह मान रोग के बारे में शोध के आधार पर निर्धारित किया गया है।

लाइन 6: शुरू में सभी लोगों को संक्रमित न होने के लिए सेट करें।

पंक्ति ७: शुरू में संक्रमित लोगों की संख्या के लिए, तदनुसार पहले दो कॉलम भरें।

अब जब हमने रोग सिमुलेशन के लिए सभी पैरामीटर सेट कर दिए हैं, तो हम इस संभावना को यादृच्छिक बनाने जा रहे हैं कि क्या व्यक्ति (टीकाकृत और असंक्रमित दोनों) संक्रमित हो जाता है। यह अगले चरण में इस 'संक्रमण मैट' की तीसरी पंक्ति में प्रत्येक व्यक्ति को 0 और 1 के बीच यादृच्छिक मान निर्दिष्ट करके किया जाता है।

चरण 4: एक टीकाकृत और असंक्रमित व्यक्ति के संक्रमित होने की संभावना को यादृच्छिक बनाएं।

इसके बाद, प्रत्येक व्यक्ति को एक यादृच्छिक संख्या निर्दिष्ट करें, इसका उपयोग बाद में यह निर्धारित करने के लिए किया जाएगा कि व्यक्ति संक्रमित है या नहीं।

डब्ल्यू = 1: लंबाई (संक्रमणमैट) के लिए

संक्रमणमैट(3, डब्ल्यू) = रैंड; समाप्त

कोड स्पष्टीकरण

यह लूप के लिए अंतिम चरण में बनाई गई 'संक्रमण मैट' की तीसरी पंक्ति से संबंधित है। 'रैंड' पंक्ति 3 के प्रत्येक सूचकांक के लिए 0 और 1 के बीच का मान निर्दिष्ट करता है।

उत्पादन

संक्रमणमैट अब पूरा हो गया है! यह १००% टीकाकरण वाली आबादी के साथ था और १ व्यक्ति शुरू में संक्रमित था।

संक्रमणमैट =

कॉलम 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.0869 0.5489 0.3177 0.9927 0.7236 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: प्रारंभिक जानकारी से असंक्रमित और संक्रमित लोगों के मैट्रिसेस बनाएं।

"matrixUnvacc" और "matrixInfected" नामक 2 मैट्रिक्स बनाएं जो सभी संक्रमित लोगों को संक्रमण से संग्रहीत करता है। इसका उपयोग इसलिए किया जाएगा ताकि हम उन लोगों के ग्राफ को कलर-कोड कर सकें जो संक्रमित हैं, टीकाकरण नहीं कराया गया है, या टीका लगाया गया है, जिससे टीकाकरण रहित बनाम टीकाकरण वाले व्यक्तियों के प्रभाव की कल्पना करने में मदद मिलती है।

प्रत्येक को साफ़ करें

मैट्रिक्स संक्रमित = ; मैट्रिक्स यूएनवासीसी = ; एच = 1 के लिए: लंबाई (संक्रमणमैट) यदि संक्रमणमैट (1, एच) == अनवैक मैट्रिक्स यूएनवासीसी = [मैट्रिक्स यूएनवासीसी, एच]; व्यक्ति के लिए अंत अंत = 1: NUMOFPEOPLE यदि संक्रमणमैट (2, व्यक्ति) == 1 मैट्रिक्स संक्रमित = [मैट्रिक्स संक्रमित, व्यक्ति]; अंत अंत

कोड स्पष्टीकरण

उन लोगों की संख्या को स्टोर करने के लिए दो खाली मैट्रिसेस बनाएं, जिनका टीकाकरण नहीं हुआ है और जो संक्रमित हैं। दोनों लूप के लिए 20 बार चलते हैं और यदि कथन संतुष्ट है, तो संख्या सही मैट्रिक्स में जोड़ दी जाती है।

उत्पादन

मैट्रिक्स यूएनवीएसीसी =

मैट्रिक्स संक्रमित =

[1]

चरण 6: प्रारंभिक ग्राफ प्लॉट करें।

आगे हम आसन्न मैट्रिक्स की साजिश रचने जा रहे हैं।

जी = ग्राफ (adjMatrix);

आकृति (1) पी = प्लॉट (जी, 'नोडकलर', 'बी', 'मार्करसाइज', 7); हाइलाइट (पी, मैट्रिक्स यूएनवासीसी, 'नोडकोलर', 'जी') शीर्षक (['बिना टीकाकरण वाले लोगों का प्रतिशत:', num2str(title_unvacc), '%']); विराम (गति)

कोड स्पष्टीकरण

मैटलैब में ग्राफ सिद्धांत कार्यों में बनाया गया है। जब हम ग्राफ़ () फ़ंक्शन का उपयोग करते हैं, तो हम 'adjMatrix' को एक वास्तविक अप्रत्यक्ष ग्राफ़ में अनुवाद करने में सक्षम होते हैं। फिर हमें वास्तव में यह देखने के लिए कि यह कैसा दिखता है, प्लॉट () फ़ंक्शन का उपयोग करके एक प्लॉट बनाना होगा। हम इस प्लॉट () को एक वेरिएबल में सेट करते हैं ताकि हम पूरे सिमुलेशन में प्लॉट के रंगों में हेरफेर कर सकें और आसानी से बदल सकें। सभी लोगों (या नोड्स) को शुरू में 'नीला' रंग में सेट किया गया है। इसके बाद, सभी गैर-टीकाकरण वाले लोगों को 'हरा' रंग में सेट किया जाता है। संक्रमित लोगों को फिर 'लाल' रंग में सेट किया जाता है। शीर्षक परीक्षण किए जा रहे गैर-टीकाकरण वाले लोगों के निश्चित प्रतिशत मूल्य के अनुसार निर्धारित किया गया है। पॉज़ () फ़ंक्शन अस्थायी रूप से MatLab निष्पादन को रोकता है। हम चर गति से गुजरते हैं जो कि फैली हुई है जिसकी गणना सेकंड में की जाती है।

एक यादृच्छिक रंग कोडित ग्राफ देखने के लिए चित्र (ऊपर) देखें।

MatLab में हाइलाइट () फ़ंक्शन के बारे में और जानें।

चरण 7: संक्रमण की प्रगति का अनुकरण करें।

आगे हमें यह पता लगाने की जरूरत है कि बातचीत के बाद कौन संक्रमित हो जाता है (adjMatrix में दर्ज) और जब कोई संक्रमित हो जाता है तो ग्राफ अपडेट करें।

एक दिन में लोगों के साथ बातचीत के बाद कौन से लोग संक्रमित हैं, यह निर्धारित करने के लिए adjMatrix का उपयोग करें।

प्रत्येक पंक्ति के लिए = 1: लंबाई (adjMatrix)

यदि संक्रमणमैट (2, प्रत्येक पंक्ति) == 1 प्रत्येक कर्नल के लिए = 1: लंबाई (adjMatrix) यदि adjMatrix (प्रत्येक पंक्ति, प्रत्येक कॉल) == 1% प्रत्येक पंक्ति = व्यक्ति% प्रत्येक कर्नल = उसका मित्र% प्रत्येक व्यक्ति का मित्र और देखें कि क्या वे संक्रमित हैं. अगर संक्रमणमैट(3, प्रत्येककॉल)>संक्रमणमैट(1,प्रत्येककॉल)संक्रमणमैट(2,प्रत्येककॉल) = 1; हाइलाइट (पी, प्रत्येककॉल, 'नोडकोलर', 'आर') रोकें (गति) अंत अंत अंत अंत अंत

लूप के लिए प्रत्येक व्यक्ति के माध्यम से लूप होता है। यह जाँच करता है कि यदि व्यक्ति संक्रमित है, तो यह उन सभी लोगों/मित्रों की जाँच करेगा जिनके साथ उन्होंने बातचीत की और जाँच की कि क्या मित्र की प्रतिरक्षा का स्तर रोग की ताकत से अधिक था। यह वह जगह है जहां हमने पहले बनाया 'संक्रमण मैट' चलन में आता है। मित्र के प्रत्येक स्तंभ की पहली और तीसरी पंक्ति की तुलना की जाती है और यदि तीसरी पंक्ति बड़ी है, तो इसका मतलब है कि मित्र में रोग से बचने के लिए पर्याप्त प्रतिरक्षा नहीं थी और अंततः संक्रमित हो जाता है। यदि वे संक्रमित हो जाते हैं तो हम हाइलाइट () का उपयोग करके लाल रंग में भी बदल जाते हैं।

अब अनुकरण के लिए आपका कोड काम करना चाहिए! और किसी भी आकार की आबादी के लिए, बस NUMOFPEOPLE बदलें!

चरण 8: मोंटे कार्लो थ्योरी का प्रयोग करें।

इसे एक कदम आगे ले जाने के लिए और अपने सिम्युलेटर ('संक्रमणसिम.एम') से डेटा निकालने के लिए, हम संक्रमित हुए लोगों के प्रतिशत और संक्रमित होने वाले टीकाकरण वाले लोगों के प्रतिशत में प्रवृत्ति की गणना और ग्राफ करना चाहते थे। हम अनुमान लगाते हैं कि संक्रमित होने वाले टीकाकरण वाले लोगों का प्रतिशत संक्रमित होने वाले लोगों के प्रतिशत से बहुत कम होना चाहिए।

चरण 9: फ़ाइल ('संक्रमणSim.m') को सिमुलेशन के साथ एक फ़ंक्शन में बनाएं।

मोंटे कार्लो को चलाने के लिए, हम कई बार सिमुलेशन चलाना चाहते हैं और डेटा जमा करना चाहते हैं ताकि हम इसका उपयोग संक्रमित लोगों के प्रतिशत का ग्राफ बनाने के लिए कर सकें।

समारोह इस तरह स्थापित किया जा सकता है:

फ़ंक्शन आउटपुट = संक्रमण सिम (अनवैक, वैक, NUMOFPEOPLE, unvacc_perc, init_infect, गति)

अपने सिमुलेशन में चरों पर टिप्पणी करें क्योंकि अब आप इन्हें मुख्य फ़ाइल के माध्यम से पास कर रहे हैं (हम इसे चरण 12 में लिखना शुरू करेंगे):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

नया चर

स्पीड

मुख्य फ़ाइल (Monte_Carlo.m) में असाइन किया जाएगा।

नोट: फ़ंक्शन को समाप्त करने के लिए फ़ंक्शन फ़ाइल के निचले भाग में अंत को न भूलें!

चरण 10: संक्रमित और टीकाकृत लोगों के प्रतिशत की गणना करें जो संक्रमित हो गए हैं।

यह असंक्रमित लोगों के प्रतिशत की गणना करता है जो संक्रमित हो गए। यह कोड 'infectionSim.m' फ़ाइल के निचले भाग में जाता है।

number_of_unvacc = 0;

number_of_infec_unvacc = 0; % गैर-टीकाकरण वाले लोगों के प्रतिशत की गणना करता है जो x = 1: लंबाई (संक्रमणमैट) के लिए संक्रमित हो गए हैं यदि संक्रमणमैट (1, x) == unvacc number_of_unvacc = number_of_unvacc+1; अंत अगर संक्रमणमैट(1, एक्स) == unvacc और संक्रमणमैट (2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; अंत अंत प्रतिशत_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

कोड स्पष्टीकरण

लूप के लिए, यह NUMOFPEOPLE से अधिक बार लूप करेगा। हर बार जब संक्रमण मैट की संख्या अनवैक संख्या (यानी 0.95 == 0.95) से मेल खाती है, तो गैर-टीकाकरण वाले लोगों की संख्या में 1 की वृद्धि की जाएगी। संक्रमित और गैर-टीकाकरण वाले लोगों की संख्या में 1 की वृद्धि होती है। अंतिम पंक्ति संक्रमित, गैर-टीकाकरण वाले लोगों की संख्या को बिना टीकाकरण वाले लोगों की कुल संख्या से विभाजित करती है। फिर इसी से प्रतिशत की गणना की जाती है।

चुनौती:

संक्रमित होने वाले लोगों के टीकाकरण के प्रतिशत की गणना करने का प्रयास करें! (संकेत: यह इस उपरोक्त कोड के समान है, हालांकि कुछ चर बदल दिए गए हैं और नाम समायोजित कर दिए गए हैं।)

इसके बाद कुल जनसंख्या के आधार पर संक्रमित लोगों के प्रतिशत की गणना की जाती है:

pre_per_infect = कमसम (संक्रमणमैट (2,:));

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

कोड स्पष्टीकरण

संचयी योग की गणना संक्रमण की दूसरी पंक्ति का उपयोग करके की जाती है, जो 1s और 0s को संग्रहीत करता है, यह निर्भर करता है कि व्यक्ति संक्रमित है या नहीं।चूंकि कमसम () फ़ंक्शन एक मैट्रिक्स वापस देता है, हम मैट्रिक्स ('pre_per_infect(1, NUMOFPEOPLE)') में अंतिम मान लेते हैं, जो कि 'infectionMat(2,:)' से सभी मानों का वास्तविक योग होना चाहिए। NUMOFPEOPLE द्वारा योग को विभाजित करके और इसे 100 से गुणा करके, हमें कुल जनसंख्या में संक्रमितों का अंतिम प्रतिशत मिलता है।

चरण 11: अपने फ़ंक्शन 'infectionSim.m' में एक आउटपुट वेरिएबल बनाएं

आउटपुट = [प्रति_संक्रमण, प्रतिशत_ऑफ_अनवैक_और_इनफेक, प्रतिशत_ऑफ_वैक_और_इनफेक];

कोड स्पष्टीकरण

इस जानकारी को आउटपुट में संग्रहीत करें, जिसे फ़ंक्शन को कॉल करने और चलने पर वापस मुख्य (Monte_Carlo.m) में भेजा जाएगा। इस डेटा का उपयोग उन लोगों के प्रतिशत के अंक को ग्राफ करने के लिए किया जाता है जिन्हें टीका लगाया गया है और जिनका टीकाकरण नहीं हुआ है।

आपका 'infectionSim.m' फंक्शन अब हो जाना चाहिए! हालाँकि, यह नहीं चलेगा क्योंकि हमें अभी भी मुख्य लिखना है!

चरण 12: उपयोगकर्ता से सिमुलेशन की प्रारंभिक शर्तें प्राप्त करने के लिए एक मेनू बनाएं।

याद रखें कि हमने वेरिएबल कैसे कहा

स्पीड

मुख्य समारोह के माध्यम से बनाया और पारित किया जाएगा? हमें फ़ंक्शन को पास करने के लिए मान प्राप्त करने की आवश्यकता है। ध्यान दें, फ़ंक्शन को कॉल करते समय मानों का क्रम मायने रखता है!

उपयोगकर्ता को टर्मिनल में कुछ उत्तर टाइप करने के लिए कहकर प्रारंभ करें।

> एक बीमारी उठाओ। ध्यान दें कि यह केस सेंसिटिव है >> पर्टुसिस >> फ्लू >> खसरा >> रोग चुना गया: फ्लू >> जनसंख्या का आकार चुनें। >> 20 >> 200 >> चुनी गई जनसंख्या: 20 >> सिमुलेशन की गति चुनें। >> तेज >> धीमी >> गति चुनी गई: तेज

नीचे दिया गया यह कोड उपयोगकर्ता से पूछता है कि वे किस बीमारी को देखना चाहते हैं।

disp ('एक बीमारी चुनें। ध्यान दें कि यह केस सेंसिटिव है')

fprintf('पर्टुसिस\nफ्लू\nखसरा\n') रोग = इनपुट ('बीमारी चुनी गई:', 's'); अगर बराबर (बीमारी, 'पर्टुसिस') vacc =.85; रोग होने की %15 प्रतिशत संभावना अवैतनिक =.20; बीमारी होने का %80 प्रतिशत मौका अगर बराबर है (बीमारी, 'फ्लू') vacc =.75; रोग होने का %25 प्रतिशत मौका अवैतनिक =.31; रोग होने की ६९ प्रतिशत संभावना यदि बराबर है (बीमारी, 'खसरा') vacc =.97; रोग होने की %3 प्रतिशत संभावना असावधान =.10; रोग समाप्त होने की 90% संभावना

कोड स्पष्टीकरण:

डिस्प () फ़ंक्शन स्क्रीन पर स्टेटमेंट को प्रिंट करता है और यह विभिन्न विकल्पों को प्रिंट भी करता है। रोग तदनुसार सौंपा जाएगा। यह संस्करण वर्तमान में अमान्य इनपुट के लिए जिम्मेदार नहीं है। अमान्य इनपुट एक त्रुटि उत्पन्न करेगा और प्रोग्राम को पूरी तरह से रोक देगा। प्रत्येक रोग के साथ जुड़े vacc और unvacc मान होते हैं। ये मान यादृच्छिक नहीं हैं। हमें ये मूल्य बीमारियों के बारे में शोध के आंकड़ों से मिले हैं।

इसके बाद, हमें उपयोगकर्ता से पूछना होगा कि क्या वे अपनी चुनी हुई बीमारी के लिए बड़े या छोटे आकार का परीक्षण करना चाहते हैं।

disp ('जनसंख्या का आकार चुनें।')

fprintf('20\n200\n') गति = इनपुट ('जनसंख्या चुनी गई:', 's'); अगर बराबर (गति, '20') जनसंख्या_साइज = 20; अन्य समान (गति, '200') जनसंख्या_साइज़ = 200; समाप्त

कोड स्पष्टीकरण

यह उपयोगकर्ता को एक बयान प्रिंट करता है और उपयोगकर्ता को यह दर्ज करने के लिए कहता है कि वह किस आकार की आबादी का परीक्षण करना चाहता है। यह संस्करण वर्तमान में अमान्य इनपुट के लिए जिम्मेदार नहीं है। अमान्य इनपुट एक त्रुटि उत्पन्न करेगा और प्रोग्राम को पूरी तरह से रोक देगा। 20 को इसलिए चुना गया क्योंकि यह एक छोटा नमूना आकार है जो अभी भी एक अच्छा विचार देता है कि एक छोटी आबादी में संक्रमण कैसे फैलता है। 200 लोगों को बड़े विकल्प के रूप में चुना गया था क्योंकि ग्राफ़ पर प्लॉट किए गए 200 बिंदुओं में बिंदुओं का कोई ओवरलैप नहीं था, इसलिए सब कुछ आसानी से देखा जा सकता था और एक दूसरे से अलग किया जा सकता था।

अगला, हमें सिमुलेशन की गति खोजने की आवश्यकता है।

disp ('सिमुलेशन की गति चुनें।')

fprintf ('फास्ट / n धीमी / n') गति = इनपुट ('चुनी गई गति:', 's'); अगर बराबर (गति, 'तेज़') sim_speed = 0; अन्य बराबर (गति, 'धीमी') sim_speed = 0.25; समाप्त

कोड स्पष्टीकरण

यह प्रक्रिया बीमारी के प्रकार और जनसंख्या के आकार को प्राप्त करने के समान थी। उपवास के लिए कोई विराम नहीं होगा। और धीमी गति के लिए, सिमुलेशन चलाते समय लूप के लिए 0.25 सेकंड का अंतराल होगा।

महान! अब हमारे पास उस उपयोगकर्ता के सभी इनपुट हैं जिनकी हमें आवश्यकता है! आइए अलग-अलग प्रतिशत लोगों के लिए डेटा एकत्र करने के लिए आगे बढ़ें, जिनका टीकाकरण नहीं हुआ है।

चरण 13: बिना टीकाकरण वाले लोगों का एक% चुनें और चुने हुए प्रतिशत के लिए असंक्रमित और संक्रमित लोगों के औसत की गणना करें।

यह कोड 0% अशिक्षित लोगों के लिए है।

% ------- %0 टीकाकरण रहित ------------

per_infect_av_0 = ; प्रतिशत_ऑफ_अनवैक_और_इनफेक_एवी_0 = ; i के लिए = १:२० आउट = इंफेक्शनसिम (अनवैक, वैक, जनसंख्या_साइज, ०, १, सिम_स्पीड); per_infect_av_0 = [per_infect_av_0, out(1, 1)]; प्रतिशत_ओफ़_अनवैक_और_इनफेक_एवी_0 = [प्रतिशत_ऑफ_अनवैक_और_इनफेक_एवी_0, आउट(1, 2)]; अंत औसत_संक्रमित_0 = माध्य (per_infect_av_0); औसत_unvacc_and_infected_0 = माध्य (प्रतिशत_of_unvacc_and_infec_av_0);

कोड स्पष्टीकरण:

लूप के लिए 20 बार चलाया जाता है। फ़ंक्शन से आउटपुट, संक्रमणसिम (), बाहर में संग्रहीत है। हर बार जब लूप चलता है, तो कुल जनसंख्या में संक्रमितों का प्रतिशत मैट्रिक्स, 'per_infect_av_0' में जुड़ जाता है। इसके अतिरिक्त, हर बार 'प्रतिशत_of_unvacc_and_infec_av_0' मैट्रिक्स में असंक्रमित और संक्रमित का प्रतिशत भी जोड़ा जाता है। अंतिम दो पंक्तियों में, इन दो, उपर्युक्त मैट्रिक्स को तब औसत किया जाता है और चर में संग्रहीत किया जाता है। योग करने के लिए, प्रतिशत प्रत्येक सिमुलेशन, औसत और रेखांकन के लिए संग्रहीत किए जाते हैं। मोंटे कार्लो का उपयोग सिमुलेशन चलाने और परिणाम दिखाने के औसत मूल्य को दिखाने के लिए किया जाता है। अपने प्रयोगात्मक उद्देश्यों के लिए, हम सिमुलेशन को 20 बार चलाने और उन मानों को औसत करने का विकल्प चुनते हैं।

चुनौती:

उन सभी प्रतिशतों के लिए दोहराएं जिनका आप परीक्षण करना चाहते हैं! यह प्रतिशत संख्याओं के अनुसार परिवर्तनीय नामों को बदलकर किया जा सकता है। हमने 0%, 5%, 10%, 20%, 30% और 50% के लिए परीक्षण किया।

संकेत:

एकमात्र पंक्ति जिसे वास्तविक कोड में बदला जाना चाहिए, वह है

बाहर = संक्रमणसिम (अनवैक, वैक, जनसंख्या_साइज, 0, 1, सिम_स्पीड);

दशमलव रूप में शून्य को प्रतिशत में बदलें। उदाहरण के लिए, 5% गैर-टीकाकरण सिमुलेशन के लिए, 0 को 0.5 से बदला जाना चाहिए।

चरण 14: ग्राफ: 'बिना टीकाकरण बनाम संक्रमण का रुझान। विशिष्ट रोग के लिए टीकाकरण'

यह गैर-टीकाकृत व्यक्तियों बनाम गैर-टीकाकरण वाले व्यक्तियों में संक्रमण की प्रवृत्ति का ग्राफ बनाने के लिए कोड है।

ग्राफ_मैट_वाई = [औसत_संक्रमित_0, औसत_संक्रमित_5, औसत_संक्रमित_10, औसत_संक्रमित_20, औसत_संक्रमित_30, औसत_संक्रमित_50];

ग्राफ_मैट_एक्स = [०, ५, १०, २०, ३०, ५०]; ढलान = (औसत_संक्रमित_5-औसत_संक्रमित_0)/5; line_y = [औसत_संक्रमित_0, (ढलान*50)+औसत_संक्रमित_0]; लाइन_एक्स = [0, ५०]; फिगर (2) प्लॉट (ग्राफ_मैट_एक्स, ग्राफ_मैट_वाई); लाइन (लाइन_एक्स, लाइन_वाई, 'कलर', 'रेड', 'लाइन स्टाइल', '--'); शीर्षक (['ट्रेंड इन अनवैक्सीनेशन फॉर', बीमारी]); xlabel ('प्रारंभिक टीकाकरण का प्रतिशत'); ylabel('अंतिम संक्रमितों का प्रतिशत')

कोड स्पष्टीकरण

पंक्ति 1: संक्रमित प्रतिशत के औसत के लिए y मान असाइन किया गया

पंक्ति २: असाइन किए गए x मान प्रारंभिक प्रतिशत के प्रतिशत के लिए असंबद्ध

पंक्ति 3: 0% और 5% की ढलान की गणना करें

पंक्ति 4: पंक्ति के y मानों को संग्रहीत करें। यह 0% से 5% खंड की निरंतरता है।

पंक्ति 5: लाइन के y मानों को संग्रहीत करें। यह रेखा ग्राफ की लंबाई तक फैली हुई है।

पंक्ति 6: आकृति बनाएं

पंक्ति 7: संक्रमित प्रतिशत के ग्राफ x और y मानों को आलेखित करें, जो टीकाकरण से वंचित हैं।

लाइन 8: लाइन को प्लॉट करें। इसका उपयोग यह दिखाने के लिए किया जाता है कि यह रैखिक रूप से नहीं, बल्कि घातीय रूप से बढ़ता है।

पंक्ति 9: ग्राफ़ के लिए शीर्षक सेट करें।

लाइन 10-11: ग्राफ के लिए x और y लेबल सेट करें।

अब आपको यह देखने में सक्षम होना चाहिए कि जनसंख्या का जितना अधिक प्रतिशत असंक्रमित होता है, उतनी ही अधिक मात्रा में संक्रमण होता है। आप यह भी देखेंगे कि अधिकांश बिंदु जो लाल हो जाते हैं वे हरे रंग के बिंदु होते हैं, यह दर्शाता है कि टीका कुछ हद तक मदद करता है! आशा है आपको यह ट्यूटोरियल पसंद आया होगा। कोई सवाल हो तो कमेंट करे !

चरण 15: अंतिम उत्पाद: सिमुलेशन कैसा दिखता है

सभी कोड यहां देखे जा सकते हैं