चींटी को दौड़ाओ। Daud

यह लेख सिमुलेशन वातावरण "एनलोगिक" में एक चींटी कॉलोनी के व्यवहार के सिमुलेशन मॉडल ( विकिपीडिया पर पढ़ा जा सकता है ) बनाने की प्रक्रिया पर चर्चा करता है यह लेख व्यावहारिक है। यह ट्रैवलिंग सेल्समैन समस्या को हल करने के लिए चींटी एल्गोरिदम के उपयोग पर विचार करेगा (आप यहां पढ़ सकते हैं )।



संक्षेप में सार के बारे में


ट्रैवलिंग सेल्समैन की समस्या का सार यह है कि ट्रैवलिंग सेल्समैन (विक्रेता) को प्रत्येक छोटे मार्ग के साथ केवल एक बार एन शहरों का दौरा करना चाहिए। चूंकि यह कार्य एनपी-कॉम्प्लेक्स है और एन शहरों के बीच सभी संभावित मार्गों की संख्या की गणना "एन!" के रूप में की जाती है, सबसे छोटा मार्ग खोज समय एल्गोरिदम का उपयोग करते हुए एन में वृद्धि के साथ तेजी से बढ़ेगा। सबसे छोटा मार्ग (समाधान) खोज "व्यापक खोज" (जो एक सटीक समाधान देता है) शहरों की संख्या के साथ N> 16 तेजी से बढ़ता है (घातीय है)। इसलिए, हम लंबाई में सबसे छोटे मार्ग की खोज नहीं करेंगे, लेकिन "डिजिटल एल्गोरिथ्म" का उपयोग करके एक परिमित समय में इसे बंद (तर्कसंगत) कर सकते हैं।

AnyLogic के बारे में कुछ शब्द एक शक्तिशाली उपकरण है जो आपको अलग-अलग जटिलता के सिमुलेशन मॉडल बनाने की अनुमति देता है। यह अनुकरण के विभिन्न तरीकों को लागू करता है। हम केवल एक दृष्टिकोण का विश्लेषण करेंगे, जिसका नाम है, "एजेंट" मॉडलिंग। यह जावा प्रोग्रामिंग भाषा में कार्यान्वित किया जाता है, जो मौजूदा टूल को पूरक करता है। "AnyLogic" का मुख्य नुकसान निर्मित एजेंटों की संख्या पर मुक्त संस्करण की सीमा है; उनकी संख्या 50,000 से अधिक नहीं हो सकती। "एजेंट" AnyLogic सिमुलेशन सिस्टम की मूल इकाई है। अधिक जानकारी वेबसाइट www.anylogic.ru पर देखी जा सकती है

उपकरण


1. Anylogic - यहाँ से मुफ्त संस्करण डाउनलोड करें www.anylogic.ru/downloads
AnyLogic प्रारंभिक परिचित:

AnyLogic इंटरफ़ेस चित्र 1 में दिखाया गया है। इसमें शामिल हैं:
  • हरा क्षेत्र उस एजेंट का स्थान है जिसमें हम निर्माण करेंगे;
  • लाल क्षेत्र - ऑब्जेक्ट का गुण जो फ़ोकस में है;
  • पैलेट - उपकरण जो आप मॉडल बनाते समय उपयोग कर सकते हैं;
  • परियोजनाओं - विकसित मॉडल की संरचना।



अंजीर। 1- AnyLogic पॉपअप विंडो

परियोजना निर्माण


यहां सब कुछ सरल है। "बनाएँ" और फिर "मॉडल" के बगल में "फ़ाइल" मेनू आइटम पर क्लिक करें, मॉडल नाम दर्ज करें और "समाप्त" बटन (छवि। 2) पर क्लिक करें।


अंजीर। 2- एक मॉडल बनाना

शहर बनाएं


अच्छा, चलिए शुरू करते हैं। पहली चीज जो हम करेंगे वह तथाकथित शहरों (ग्राफ के सबसे ऊपर) का निर्माण करेगा जो चींटी का दौरा करेगा। हम पैलेट में "एजेंट" टैब क्यों खोलते हैं और छोटे आदमी के साथ लाल सर्कल को "मेन" एजेंट में खींचें, जैसा कि चित्र 3 में दिखाया गया है।


अंजीर। 3- शहर बनाना

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


अंजीर। 4- शहर बनाना

निम्नलिखित संवाद बॉक्स प्रकट होता है (चरण 2) जहां आपको नए एजेंट प्रकार का नाम और एजेंट आबादी का नाम दर्ज करना होगा। टाइप करें "रिश्तेदार" और जनसंख्या का नाम "myTown" और "नेक्स्ट" बटन पर क्लिक करें।


अंजीर। 4a - नए एजेंट का नाम दर्ज करें

फिर निम्न विंडो दिखाई देगी (चरण 4)। यहां हम "2D एजेंट एनीमेशन" और शिलालेख "प्लांट" वाले आइकन का चयन करते हैं और "फिनिश" बटन (चित्र 5) पर क्लिक करते हैं।


अंजीर। 5- एजेंट के लिए एनीमेशन जोड़ें

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


अंजीर। 6- एक वैरिएबल बनाना

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


अंजीर। 7 - "मायटाउन" आबादी के गुणों को बदलना अगला,

हम एक यादृच्छिक स्थान पर "मुख्य" एजेंट में हमारे शहरों का निष्कर्ष निकालेंगेअंतरिक्ष 400x400 पिक्सेल के एक वर्ग तक सीमित है। "प्रोजेक्ट्स" टैब में, माउस के साथ "मुख्य" एजेंट का चयन करें और "प्रॉपर्टीज़" टैब में, "स्टार्टअप" फ़ील्ड में, निम्न जावा कोड (चित्र 7 ए) जोड़ें:
for (int i=0; i<myTowns.size(); i++) {
	myTowns.get(i).setXY(uniform(0,400), uniform(0,400));
}

कहाँ पे:
  • myTowns.size () - बनाए गए शहरों की संख्या;
  • myTowns.get (i) .setXY (यूनिफ़ॉर्म (0.400), यूनिफ़ॉर्म (0.400)) - i-th शहर के लिए X और Y निर्देशांक सेट करें;
  • समरूप (0,400) - एक फ़ंक्शन जो किसी यादृच्छिक चर के समान रूप से संभावित वितरण कानून के अनुसार 0 से 400 तक की सीमा में एक यादृच्छिक संख्या देता है। AnyLogic वातावरण में यादृच्छिक चर के विभिन्न वितरणों के साथ काम करने के लिए एक व्यापक टूलकिट है। संभाव्यता वितरण का एक अंतर्निहित निर्माण है, यह टूलबार में उपलब्ध है।

कहाँ पे:
  • myTowns.size () - बनाए गए शहरों की संख्या;
  • myTowns.get (i) .setXY (यूनिफ़ॉर्म (0.400), यूनिफ़ॉर्म (0.400)) - i-th शहर के लिए X और Y निर्देशांक सेट करें;
  • uniform(0,400) – , 0 400 . AnyLogic . .



अंजीर। 7a - हम शहरों की व्यवस्था करते हैं।

फिर हम पहले ही देख सकते हैं कि हमने क्या किया और अपना मॉडल शुरू किया। ऐसा करने के लिए, "F5" कुंजी का उपयोग करें, इसे क्लिक करें और प्रयोग शुरू करने के लिए विंडो को चित्रा 8 में दिखाया गया


है। 8 - प्रयोग शुरू करें

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


है। अंजीर। 9 - प्रयोग का परिणाम

तो, इस कदम पर हमने 10 शहरों का निर्माण किया और उन्हें हमारी स्क्रीन पर एक यादृच्छिक (स्टोचस्टिक) स्थान पर रखा। अब चलो हमारे "चींटियों" के निर्माण के लिए आगे बढ़ें

एक चींटी बनाएँ


तो, हमारे मॉडल की मुख्य मुकाबला इकाई एक चींटी होगी। हमें, सबसे पहले, इसे बनाना होगा, और फिर इसके व्यवहार को मॉडल करना होगा।

एक चींटी का निर्माण एक शहर बनाने के समान है। "पैलेट" में "एजेंट" चुनें और इसे "मुख्य" पर खींचें। "एजेंटों की जनसंख्या" का चयन करें, फिर "मैं एक नए प्रकार का एजेंट बनाना चाहता हूं", फिर "नए प्रकार का नाम" और "जनसंख्या का नाम" "MyAnt" "myAnts" दर्ज करें और "अगला" पर क्लिक करें। उसके बाद हम "2D" एनीमेशन का चयन करते हैं और, उदाहरण के लिए, शिलालेख "लड़ाकू" के साथ आइकन "फिनिश" दबाएं और इसे चित्र 10 में दिखाया गया


है। 10 - चींटियां बनाएं

सहमत हूं, हवाई जहाज एक चींटी की तरह नहीं दिखता है, इसलिए हम इसे ठीक कर देंगे। हम एक खोज इंजन में जाते हैं जो एक चित्र की तलाश करता है जो एक चींटी को चित्रित करता है और विमान को एक चींटी में बदल देता है। हम "myAnts" के पास लाल सर्कल पर डबल-क्लिक क्यों करते हैं। उसके बाद "myAnt" टैब खुल जाएगा जहां आपको विमान को हटाने और चींटी को उसके स्थान पर रखने की आवश्यकता है (चित्र 11)।


अंजीर। 11 - MyAnt टैब

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


अंजीर। 12 - एंटे के साथ MyAnt टैब और पहले से ही एक हवाई जहाज के बिना

आगे बढ़ो। चींटी को खदेड़ें और उसे उस स्थान पर ले जाएँ जहाँ विमान हुआ करता था। यह चित्रा 12 ए में दिखाया गया है। ये सभी ऑपरेशन माउस का उपयोग करके किए जाते हैं।


अंजीर। 12a - एंट के साथ MyAnt टैब

हम चींटी को पुनर्जीवित करते हैं


अब हमें शहरों के बीच क्रॉल करने के लिए अपने हौसले से पके हुए चींटी को सिखाने की जरूरत है। सच है, अब तक गणितीय मॉडल को ध्यान में रखे बिना, लेकिन फिर भी इसे चलने दें। और इसलिए, "पैलेट" में "राज्य आरेख" आरेख खोलें और आगे बढ़ें। हम निम्नलिखित ब्लॉकों को स्थानांतरित करते हैं और उन्हें एक साथ जोड़ते हैं:
  • राज्य आरेख की शुरुआत हमारे चींटी के जीवन चक्र का प्रारंभिक बिंदु है;
  • राज्य - यह ब्लॉक हमारे चींटी के जीवन चक्र की स्थिति को चिह्नित करेगा। टुकड़ों में ऐसे ब्लॉक की आवश्यकता होती है।
  • संक्रमण - एक तीर जो हमारे "राज्यों" को एक दूसरे से जोड़ेगा और कुछ शर्तों के तहत एक "राज्य" से दूसरे "राज्य" में संक्रमण करेगा।

नतीजतन, यह जैसा चित्र 13.


अंजीर में दिखाया गया है, उसे कुछ बाहर करना चाहिए 13 - चींटी

के व्यवहार का तर्क अब चींटी आरेख के प्रारंभिक तर्क को लिखें। हम माउस का चयन उस तीर के साथ करते हैं, जो "Select City" नाम के तहत ब्लॉक से बाहर निकलता है और "गुण" टैब (चित्र 14) में "एक्शन" फ़ील्ड में निम्न कोड जोड़ता है।
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.5)) {
		this.moveTo(main.myTowns.get(i));
		break;
	} 
}

यहां, सब कुछ बहुत सरल है, हम सभी शहरों में चक्र के माध्यम से जाते हैं और एक सिक्का टॉस करते हैं (हम संभावना के साथ एक यादृच्छिक चर उत्पन्न करते हैं। 0.5) यदि इसका मूल्य सही है (ईगल), तो हम चींटी को इस शहर को छोड़कर चक्र भेजते हैं। अभिव्यक्ति "this.moveTo (main.myTowns.get (i))" एक फ़ंक्शन है जो एक एजेंट को दूसरे को भेजता है।


अंजीर। 14 - चींटी के आंदोलन के शुरुआती तर्क को सेट करें।

इसके बाद, "मोशन" फ़ील्ड में "मोशन" ब्लॉक और "गुण" टैब को छोड़ने वाले तीर पर क्लिक करें, "संदेश प्राप्त होने पर" मान सेट करें और "ऑकवर्ड" फ़ील्ड में "निर्दिष्ट संदेश के प्राप्त होने पर" चुनें। »चित्र 15 में दिखाया गया है।


अंजीर। 15 - "आंदोलन" और "सब कुछ समाप्त" के बीच संक्रमण के लिए तर्क सेट करें

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


है। अंजीर। 16 - ब्लॉक के बीच कॉन्फ़िगर किए गए बदलावों के साथ राज्य आरेख

, तो आइए देखें कि चींटी व्यवहार के "स्टेट आरेख" कैसे काम करते हैं:
  1. पहला राज्य जो चींटी में गिरता है, वह "व्यबोर_सिटी" है, अब तक इस पर कोई कार्रवाई नहीं हुई है।
  2. फिर वह संक्रमण होने पर अगली अवस्था में चला जाता है। इस परिवर्तन में, हमने एक कोड जोड़ा जो सभी पहाड़ों के माध्यम से एक चक्र शुरू करता है और चींटियों को शहरों के आसपास चलाता है।
  3. "मूवमेंट" ब्लॉक वह जगह है जहां चींटी पहले से चयनित शहर में आने तक स्थित है।
  4. इसके अलावा, उसके पास दो तरीके हैं। सबसे पहले, वह "City_Choice" ब्लॉक पर वापस लौटता है और सब कुछ फिर से दोहराया जाता है। दूसरे रास्ते पर उसे जाना होगा जब वह पहले से ही सभी शहरों का दौरा कर चुका होगा। अब तक, दूसरा रास्ता हमारे साथ स्थापित नहीं है। हम उनसे थोड़ी देर बाद निपटेंगे।



अंजीर। 17 - राज्य आरेख का संचालन

अब हम "F5" को दबाकर देख सकते हैं कि क्या हुआ (चित्र 18)।


अंजीर। 18 - चींटियों का पुनरुद्धार

मानदंडों को परिभाषित करें


तो, ये मानदंड (नियम) क्या हैं:
  1. एक चींटी को एक बार ही प्रत्येक शहर का दौरा करना चाहिए।
  2. चींटी, जब वह सभी शहरों का दौरा करती थी तो अंतिम शहर में अपना आंदोलन समाप्त कर देती थी।

ये मानदंड हमें यात्रा सेल्समैन समस्या की स्थिति से निर्धारित किए जाते हैं। प्रत्येक चींटी हमारे साथ एक तरह का ट्रैवलिंग सेल्समैन होगा जो शहरों से होकर जाता है।

आइए चींटी को इन नियमों का पालन करना सिखाएं। क्यों, "पैलेट" से, "एजेंट" टैब, "संग्रह" और "चर" को "MyAnt" टैब पर स्थानांतरित करें और उन्हें पहले के रूप में "प्रतिष्ठित" और दूसरे को "दूरी" के रूप में कहें। पहला उन शहरों को ध्यान में रखेगा जिन्हें हम पहले ही देख चुके हैं, और दूसरी दूरी जो चींटी द्वारा तय की गई है।


अंजीर। 19 - वैरिएबल्स जोड़ें

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


अंजीर। 20 - प्रकार का संग्रह "int"

अब "City_block" ब्लॉक छोड़ने वाले तीर का चयन करें और नीचे "एक्शन" फ़ील्ड में कोड बदलें:
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.9) && isVisited.indexOf(i)==-1) {
		this.moveTo(main.myTowns.get(i));
		distance=distance+this.distanceTo(main.myTowns.get(i));
		isVisited.add(i);
		break;
	} 
}

ऊपर दिए गए कोड में, हमने उन शहरों के लिए एक चेक जोड़ा है जिसमें हम पहले से ही यात्रा करने में कामयाब रहे हैं, और उन शहरों को ध्यान में रखते हुए जो हम गए थे, और यात्रा की गई दूरी पर भी विचार करें। कोड काफी सरल है, मुझे लगता है कि इसे समझना आपके लिए मुश्किल नहीं होगा।

आप हमारे मॉडल को "F5" लॉन्च करने का प्रयास कर सकते हैं और देख सकते हैं कि क्या हुआ। अब चींटियां केवल एक बार सभी शहरों से गुजरेंगी और ब्लॉक में अपना आंदोलन पूरा करेंगी।

चींटियों के शुरुआती स्थान को बदलें


इस चरण में, हम प्रत्येक चींटी के लिए निर्धारित करेंगे जिसे हम बेतरतीब ढंग से एक शहर चुनेंगे जहाँ से वह अपनी यात्रा शुरू करेगा। "प्रोजेक्ट्स" टैब पर, माउस के साथ "मुख्य" एजेंट का चयन करें और फिर "गुण" टैब में "स्टार्टअप" फ़ील्ड (छवि 20 ए) के लिए निम्न कोड जोड़ें:
for (int i=0; i<myAnts.size(); i++) {
	//        
	int startTown = uniform_discr(0,myTowns-1);
	//     
	myAnts.get(i).setPosition(myTowns.get(startTown));
	//      
	myAnts.get(i).isVisited.add(startTown);
}



अंजीर। 20 ए - शहर द्वारा चींटियों की व्यवस्था करना

मैंने प्रारंभिक शहर का एक यादृच्छिक चयन लागू किया। आप शुरू में केवल एक शहर में सभी चींटियों की पहचान कर सकते हैं।

चींटियों को अप्रत्याशित बनाना


आइए हम अपने मॉडल में निम्नलिखित सूत्र को प्रस्तुत करते हैं:



जहां पाई i-th पथ के पथ के साथ संक्रमण की संभावना है, ली i-th संक्रमण की लंबाई है, फाई i-th संक्रमण में फेरोमोन की मात्रा है, q वह मान है जो एल्गोरिथ्म, पी के "लालच" को निर्धारित करता है - मान जो एल्गोरिथ्म के "झुंड" को निर्धारित करता है, q + p = 1 के साथ।

मैंने साइट से यह फॉर्मूला उधार लिया है

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

अब हमें कई चर जोड़ने की जरूरत है जिसके बिना हम नहीं कर सकते। "मुख्य" टैब पर वापस क्यों जाएं, यह आंकड़ा 21


है। अंजीर। 21 - टैब "मुख्य"

तो, हम चर "संख्याअन" जोड़ते हैं, जिसमें हम चींटी कॉलोनी के आकार को संग्रहीत करेंगे। हम इसके प्रकार को "int" पर सेट करते हैं और प्रारंभिक मूल्य 100


है। अंजीर। 21 - परिवर्तनीय "नंबरऑन"

अगला, जनसंख्या "मायएनेट्स" का चयन करें और फ़ील्ड "संख्याओं की प्रारंभिक संख्या" को "नंबरऑन" पर सेट करें।

चर "पी", जो एल्गोरिथ्म के झुंड का निर्धारण करेगा। इसका प्रकार दोहरा है और प्रारंभिक मूल्य 0.5 है।

चर "क्ष", जो एल्गोरिथ्म के लालच को निर्धारित करेगा। इसका प्रकार दोहरा है और प्रारंभिक मूल्य 0.5 है।


अंजीर। 22 - चर "q और p"

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


अंजीर। 23 - एक दो आयामी सरणी "मैट्रिक्सएफ" बनाना। फेरोमोन मैट्रिक्स

नेक्स्ट, हमें इस मैट्रिक्स को इनिशियलाइज़ करना होगा। दूसरे शब्दों में, इसे यादृच्छिक मूल्यों से भरें। हम फेरोमोन मान को 0.1 से लेकर
1. तक सीमा में बेतरतीब ढंग से लेते हैं । इसके लिए "प्रोजेक्ट्स" टैब पर, माउस के साथ "मेन" एजेंट का चयन करें और फिर "प्रॉपर्टीज" टैब में निम्न कोड को "स्टार्टअप" फ़ील्ड (छवि 23 ए) में जोड़ें।
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=uniform(0.1,1);
	}
} 



अंजीर। 23a - फेरोमोन मैट्रिक्स का प्रारंभ कोड

अब हम "MyAnt" टैब पर लौटते हैं और उपरोक्त सूत्र के अनुसार संक्रमण संभावना की गणना करने के लिए आगे बढ़ते हैं। "City_Choice" और "Motion" के बीच संक्रमण का चयन करें और क्रिया फ़ील्ड में कोड को निम्न में बदलें (चित्र 24:
//       
double denominator=0; 
//          
for (int i=0; i<main.myTowns.size(); i++) {
	if (isVisited.indexOf(i)==-1) {	//     
	    //  i   
		denominator=denominator+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p));
	} 
}
//      i 
double Pi=0;
//    
double probility=uniform(0,1);
for (int i=0; i<main.myTowns.size(); i++) {
	//        Pi
	if (isVisited.indexOf(i)==-1) {
		//     i-      
		Pi=Pi+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p))/denominator;
	}
	//      Pi      probility
	if (probility<Pi && isVisited.indexOf(i)==-1) {
		//       i  
		this.moveTo(main.myTowns.get(i));
		//     
		distance=distance+this.distanceTo(main.myTowns.get(i));
		//           
		isVisited.add(i);
		break;
	} 
}



अंजीर। 24 - हम उपरोक्त की विश्लेषणात्मक अभिव्यक्ति के आधार पर चींटी के व्यवहार को निर्धारित करते हैं।

इसलिए अब मैं थोड़ा समझाऊंगा कि क्या है:
  • ली - this.distanceTo (main.myTowns.get (i)), चींटी की मौजूदा स्थिति और "i" शहर के बीच की लंबाई मान;
  • Fi - main.matrixF [currentPos] [i], वर्तमान शहर और शहर "i" के बीच फेरोमोन स्तर का मान;
  • भाजक - भाजक + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.matrixF [currentPos] [i], main.p)), भाजक; अनुकरणीय
  • Pi - Pi + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.myTowns.get (i) .f, main.p)) (भाजक), वर्तमान शहर से शहर में जाने वाले चींटी की संभावना "i"।

अगला, हम माउस के साथ "मोशन" और "ऑल-बाईपास" ब्लॉक के बीच संक्रमण का चयन करते हैं और "ऑक्यूर्स" फ़ील्ड में "जब शर्त पूरी हो जाती है" का चयन करते हैं, और स्थिति क्षेत्र में हम चींटी को रोकने के लिए स्थिति लिखते हैं। (अंजीर। 25)।


अंजीर। 25 - चींटी को रोकने के लिए शर्तें निर्धारित करें।

फिर आप "F5" मॉडल चला सकते हैं और देख सकते हैं कि क्या हुआ। चींटियां उपरोक्त विश्लेषणात्मक अभिव्यक्ति के अनुसार गणना की संभावना वाले शहरों के बीच यात्रा करेंगी।

फेरोमोन के मूल्य को अद्यतन करना


अब दो काम करते हैं। पहली कार्रवाई उन शहरों के बीच किनारे पर फेरोमोन मान बढ़ाने के लिए है जिनके साथ चींटी पारित हुई थी। दूसरा शहरों के बीच किनारों पर फेरोमोन का वाष्पीकरण है, जिसमें सिमुलेशन समय के सापेक्ष फेरोमोन के मूल्य को कम करना शामिल है।

तो, पहली कार्रवाई के साथ शुरू करने के लिए, हम उस शहर के बीच रिब के फेरोमोन के मूल्य को अपडेट करेंगे जिसमें चींटी स्थित है और जिसमें वह जाएगा। जिस मूल्य से हम शहरों के बीच फेरोमोन किनारों के वर्तमान मूल्य में वृद्धि करेंगे, उसकी गणना बहुत सरल होगी। हम फेरोमोन मूल्य = 1 घन का अपना अधिकतम प्रारंभिक मूल्य लेते हैं और इसे उस शहर के बीच की दूरी से विभाजित करें जिसमें चींटी स्थित है और वह शहर जहां वह जाने वाला है। तदनुसार, शहरों के बीच की दूरी जितनी छोटी होगी, मूल्य उतना अधिक होगा जिससे रिब के फेरोमोन का स्तर बढ़ेगा। हम प्रोजेक्ट टैब में MyAnt एजेंट का चयन क्यों करते हैं, "City_title" और "Movement" ब्लॉकों के बीच संक्रमण का चयन करने के लिए माउस का उपयोग करें और निम्नलिखित कोड को एक्शन फ़ील्ड में जोड़ें: "main.matrixF [currentPos] [i] = main.matrixF [currentPos] [i] ] + 1 / this.distanceTo (main.myTowns.get (i); ”)।परिणाम चित्र 26 में दिखाया गया है


अंजीर। 26 - पसलियों के फेरोमोन के स्तर के मूल्य को अद्यतन करना जिसके साथ चींटी पारित हुई

अब हम कार्रवाई नंबर 2 पर जाते हैं और एक ऐसी घटना बनाते हैं जो शहरों के बीच किनारों पर फेरोमोन के वाष्पीकरण का अनुकरण करेगा। क्यों, परियोजनाओं के टैब में, "मुख्य" एजेंट का चयन करें और वहां कुछ और चर बनाएं। पहला "तीव्रता" है - यह फेरोमोन वाष्पीकरण की दर (तीव्रता) (प्रारंभिक मूल्य "0.5", प्रकार "डबल") निर्धारित करेगा। दूसरा "भाग" - उस अंश को चिह्नित करेगा जिसके द्वारा किनारे पर फेरोमोन का मूल्य घट जाएगा (प्रारंभिक मूल्य "0.9", "डबल" टाइप करें)।


अंजीर। 27 - चर "तीव्रता" और "भाग" बनाएँ

अगला, हम "एजेंट" टैब के "पैलेट" से "इवेंट" तत्व लेते हैं और इसे "मुख्य" एजेंट को स्थानांतरित करते हैं और इसे "वाष्पीकरण" कहते हैं - यह तत्व किनारों पर फेरोमोन के वाष्पीकरण का अनुकरण करेगा। हम उस पर माउस से क्लिक करते हैं और "गुण" में "इवेंट टाइप" फ़ील्ड में, "तीव्रता" फ़ील्ड में दिए गए "एक तीव्रता के साथ" मान का चयन करें, "तीव्रता" मान को संग्रहीत करने वाले चर का नाम लिखें। प्रतिक्रिया समय सेकंड है। अगला, कार्रवाई के नीचे कोड जोड़ें:
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=matrixF[i][j]*Part;
		if (matrixF[i][j]<0.1) matrixF[i][j]=0.1;
	}
}

जब "वाष्पीकरण" घटना शुरू हो जाती है, तो मैट्रिक्सएफ मैट्रिक्स में फेरोमोन का स्तर अपडेट किया जाएगा। परिणामस्वरूप, आपको चित्र 28 में दिखाए गए अनुसार करना चाहिए।


अंजीर। 28 - "वाष्पीकरण" घटना बनाएँ

विजेता का निर्धारण करें


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


अंजीर। 29 - वेरिएबल्स की एक घटना बनाएं

अगला, हम एक फ़ंक्शन बनाते हैं, जो सभी चींटियों को खत्म करने के बाद, शहरों के बीच सबसे अच्छा मार्ग की लाइनें खींचेगा। क्यों "पैलेट" से हम एजेंट "मेन" नाम के फ़ंक्शन के साथ एक तत्व में खींचते हैं। फ़ंक्शन नाम को ड्रापथ पर सेट करें, और गुण टैब में, फ़ंक्शन बॉडी फ़ील्ड में, निम्न कोड जोड़ें:
//        
for (int i=0; i<myAnts.get(bestAnt).isVisited.size()-1; i++) {
	//    
	ShapeLine myLine = new ShapeLine();
	//            i
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getY());
	//            i+1
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getY());
	//    ""
	myLine.setColor(blue);
	//   
	myLine.setLineStyle(LINE_STYLE_SOLID );
	//   
	myLine.setLineWidth(1);
	//    
	presentation.add(myLine);	
}
	//           
	ShapeLine myLine = new ShapeLine();
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getY());
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getY());
	myLine.setColor(blue);
	myLine.setLineStyle(LINE_STYLE_SOLID );
	myLine.setLineWidth(1);
	presentation.add(myLine);

नतीजतन, आपको चित्र 29 ए में दिखाए गए अनुसार करने में सक्षम होना चाहिए।


अंजीर। 29a - "ड्रापथ" फ़ंक्शन बनाएं

अब हम अपनी चींटियों पर वापस जाते हैं और एक कोड जोड़ते हैं जो विजेता की चींटी, सबसे अच्छे मार्ग की लंबाई निर्धारित करेगा और शहरों के बीच इस मार्ग को आकर्षित करेगा। "प्रोजेक्ट्स" टैब में, "MyAnt" एजेंट का चयन करें, फिर "सभी बायपास" ब्लॉक का चयन करें और निम्न कोड को "लॉगऑन एक्शन" फ़ील्ड में जोड़ें:
//    
main.numberFinish++;
//      
if (main.bestDistance>distance) {
	//           
	//      
	main.bestDistance=distance;
	//    
	main.bestAnt = this.getIndex();
}
//         Main   
if (main.numberFinish==main.myAnts.size()) main.drawPath();

इसे चित्रा 30 में दिखाया गया


है। 30 - "ऑल बाईपास" ब्लॉक में तर्क जोड़ना।

फिर आप "F5" दबा सकते हैं और मॉडल चला सकते हैं। चींटियां मार्गों की तलाश में चारों ओर दौड़ेंगी, और जब शहर खत्म हो जाएंगे, तो नीली रेखा जुड़ जाएगी, जो सबसे अच्छा मार्ग है।

मॉडल में एक हिस्टोग्राम जोड़ें


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

इसे चित्र 31 में दिखाया गया है


। 31 - एक शेड्यूल बनाना

जिसके बाद हमें फिर से अपनी चींटी के पास लौटना होगा और मार्ग की लंबाई के मूल्यों के साथ इसे "हिस्टोग्राम" भरना होगा। क्यों, प्रोजेक्ट टैब में, एजेंट "MyAnt" का चयन करें और उसके स्थान पर जाएं। अगला, "ऑल बाईपास" ब्लॉक चुनें और इसमें एक लाइन जोड़ें "main.data.add (दूरी);"। यह चित्र 32 में दिखाया गया


है। 32 - एक ग्राफ का निर्माण

अगला, "F5" दबाएं और चींटी एल्गोरिदम के व्यवहार का अध्ययन करने के लिए आगे बढ़ें। यह चित्र 33 में दिखाया गया है, जैसे कुछ को बाहर करना चाहिए


33 - मॉडलिंग

निष्कर्ष


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


अंजीर। 34 - यादृच्छिक रन बनाना

आपके ध्यान के लिए धन्यवाद! स्रोत कोड GitHub से डाउनलोड किया जा सकता है

All Articles