मेमोरी के साथ मॉड्यूलर चींटी बॉट

एक ऐसी परियोजना जिसे मैंने लंबे समय से लागू करने का सपना देखा था, वह थी मेमोरी के साथ मॉड्यूलर टास्क बॉट्स। परियोजना का अंतिम लक्ष्य स्वतंत्र और सामूहिक रूप से अभिनय करने में सक्षम प्राणियों के साथ एक दुनिया बनाना था।

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

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

मेरे सिस्टम में, सिमुलेशन में तीन घटक होते हैं: दुनिया, जनसंख्या और उन्हें जोड़ने वाले कार्यों का एक समूह। इसलिए, मुझे तीन मॉडल बनाने की आवश्यकता थी, जिसके बारे में मैं इस लेख में चर्चा करूंगा।

कठिनाई बढ़ाने के लिए, मैं चाहता था कि अभिनेता दुनिया के साथ पिछले अनुभवों के बारे में जानकारी रखें और भविष्य के कार्यों में इन इंटरैक्शन के बारे में ज्ञान का उपयोग करें।

दुनिया का एक मॉडल बनाते समय, मैंने एक सरल रास्ता चुना और इसे पानी की सतह पर रखने के लिए पेरलिन शोर का इस्तेमाल किया। दुनिया में अन्य सभी वस्तुएं बिल्कुल बेतरतीब ढंग से स्थित थीं।

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

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


नमूना नक्शा। पानी ने पूरी तरह से अनायास ही नदी का रूप ले लिया। अन्य सभी तत्व बेतरतीब ढंग से स्थित हैं, जिनमें एंथिल भी शामिल है, जो इस बीज में बहुत दूर किनारे पर स्थानांतरित हो जाता है (लेकिन नदी दिखती है)।

मैंने तय किया कि घास एकत्र करने वाली पत्तियों में चींटियों का एक झुंड एक अच्छा परीक्षण मॉडल होगा जो बुनियादी कार्यों के कार्यान्वयन की विश्वसनीयता की गारंटी देता है (और संपूर्ण के रूप में कार्य कतार प्रणाली) और मेमोरी लीक को रोकता है (कई थे)।

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

सामान्य संरचना

मैंने इस सिमुलेशन को C ++ में लिखा था, और प्रतिपादन के लिए SDL2 का उपयोग किया (मैंने पहले ही SLD2 के लिए एक छोटी प्रस्तुति कक्षा लिखी थी)। मैंने ए * कार्यान्वयन (थोड़ा संशोधित) का भी उपयोग किया जो मुझे जीथब पर मिला क्योंकि मेरा कार्यान्वयन निराशाजनक रूप से धीमा था और मुझे समझ नहीं आ रहा था कि क्यों।

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

जनसंख्या

बॉट्स एक वर्ग में थे जो एक ही प्राणी का वर्णन करने वाले गुणों के साथ थे। उनमें से कुछ कॉस्मेटिक थे, दूसरों ने कार्यों के निष्पादन को प्रभावित किया (उदाहरण के लिए, उड़ान भरने की क्षमता, दृष्टि की सीमा, यह क्या खाती है और प्राणी क्या पहन सकता है)।

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

मेमोरी कतार

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

यदि बॉट स्मृति से जानकारी को वापस बुलाना चाहता था, तो उसने एक मेमोरी ऑब्जेक्ट (अनुरोध) बनाया और इसकी तुलना स्मृति में क्या थी के साथ की। फिर याद किए गए फ़ंक्शन ने क्वेरी में निर्दिष्ट किसी भी या सभी मानदंडों से मेल खाती यादों का एक वेक्टर लौटा दिया।

class Memory{ public: //Recall Score int recallScore = 1; //Memory Queryable? Array bool queryable[4] = {false, false, false, false}; //Memory Attributes std::string object; std::string task; Point location; bool reachable; 

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

मेमोरी कतार

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

 void Bot::updateMemory(Memory &query, bool all, Memory &memory){ //Loop through all existing Memories //"memories" queue is a member of Bot for(unsigned int i = 0; i < memories.size(); i++){ //If all matches are required and we have all matches if(all && (memories[i] == query)){ //We have a memory that needs to be updated memories[i] = memory; continue; } //If not all matches are required and any query elements are contained else if(!all && (memories[i] || query)){ //When overwriting, only overwrite specified quantities memories[i] = memory; continue; } } } 

इस प्रणाली के लिए कोड बनाने की प्रक्रिया में, मैंने बहुत कुछ सीखा।

कार्य प्रणाली

गेम लूप या रेंडरिंग की प्रकृति यह है कि प्रत्येक माप में समान कार्य दोहराए जाते हैं, हालांकि, मैं अपने बॉट्स में गैर-चक्रीय व्यवहार को लागू करना चाहता था।

इस खंड में, मैं इस आशय का मुकाबला करने के लिए डिज़ाइन किए गए कार्य प्रणाली की संरचना पर दो दृष्टिकोण बताऊंगा।

नीचे-ऊपर की संरचना

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

ऐसे आदिम कार्यों के उदाहरण:

 //Primitives bool wait(Garden &garden, Population &population, int (&arguments)[10]); bool look(Garden &garden, Population &population, int (&arguments)[10]); bool step(Garden &garden, Population &population, int (&arguments)[10]); bool swap(Garden &garden, Population &population, int (&arguments)[10]); bool store(Garden &garden, Population &population, int (&arguments)[10]); bool consume(Garden &garden, Population &population, int (&arguments)[10]); bool move(Garden &garden, Population &population, int (&arguments)[10]); //Continue with secondaries here... 

ध्यान दें कि इन क्रियाओं में दुनिया और जनसंख्या दोनों के संदर्भ हैं, जिससे आप उन्हें बदल सकते हैं।

• इंतजार इस पाश में कुछ भी नहीं करने के लिए जीव का कारण बनता है।
• देखो पर्यावरण को खुश करता है और नई यादों को कतारबद्ध करता है।
• स्वैप प्राणी के हाथ में एक वस्तु लेता है और उसे जमीन पर झूठ बोलने के साथ बदल देता है।
• खपत प्राणी के हाथ में आइटम को नष्ट कर देता है।
• कदम वर्तमान गणना पथ को गंतव्य तक ले जाता है और एक कदम (त्रुटि जांच का एक गुच्छा के साथ) करता है।
• ... और इसी तरह।

सभी कार्य कार्य मेरे कार्य वर्ग के सदस्य हैं; कठोर परीक्षण के बाद, उन्होंने अपनी विश्वसनीयता और अधिक जटिल कार्यों में संयोजन करने की क्षमता साबित कर दी है।

 //Secondaries bool walk(Garden &garden, Population &population, int (&arguments)[10]); bool idle(Garden &garden, Population &population, int (&arguments)[10]); bool search(Garden &garden, Population &population, int (&arguments)[10]); bool forage(Garden &garden, Population &population, int (&arguments)[10]); bool take(Garden &garden, Population &population, int (&arguments)[10]); //Species Masters bool Ant(Garden &garden, Population &population, int (&arguments)[10]); bool Bee(Garden &garden, Population &population, int (&arguments)[10]); }; 

इन द्वितीयक कार्यों में, हम अन्य कार्यों को सरलता से करके कार्यों का निर्माण करते हैं:

• वॉक कार्य केवल कुछ चरणों (त्रुटि से निपटने) के साथ है
• टेक टास्क लुक और स्वैप टास्क है (चींटी मेमोरी प्रोसेसिंग के कारण इसकी जरूरत है, जिसे मैं बाद में समझाऊंगा)
• निष्क्रिय कार्य एक यादृच्छिक स्थान का चयन करना और वहां चलना (चलना का उपयोग करना) है, कई चक्रों की प्रतीक्षा करें (प्रतीक्षा का उपयोग करके), और दिए गए कई बार के लिए इस चक्र को दोहराएं
• ... और इसी तरह

अन्य कार्य अधिक जटिल हैं। खोज कार्य "खाद्य" ऑब्जेक्ट (इस प्रकार के बॉट के लिए खाद्य) युक्त स्थानों की किसी भी यादों को खोजने के लिए एक मेमोरी क्वेरी निष्पादित करता है। वह इन यादों को डाउनलोड करती है और उन सभी के आसपास जाती है, "भोजन की तलाश" (चींटियों के मामले में, यह घास है)। यदि कोई भोजन की यादें नहीं हैं, तो कार्य प्राणी को बेतरतीब ढंग से घूमता है और चारों ओर देखता है। देखने और अध्ययन करने से (viewRadius = 1 के साथ एक "लुक" करके; अर्थात, केवल टाइल को नीचे की ओर देखते हुए), जीव अपने परिवेश के बारे में जानकारी के साथ अपनी स्मृति को अपडेट कर सकता है, बुद्धिमानी से और उद्देश्यपूर्ण रूप से भोजन की खोज कर सकता है।

एक अधिक सामान्यीकृत फोरेज कार्य में भोजन ढूंढना, भोजन उठाना, निरीक्षण करना (स्मृति को अद्यतन करने और पड़ोस में भोजन खोजने के लिए) होता है, घर लौटकर भोजन का भंडारण होता है।


आप देख सकते हैं कि चींटियाँ एंथिल से बाहर निकलती हैं और भोजन को उद्देश्यपूर्ण रूप से देखती हैं। आरंभीकरण के कारण, चींटियों का प्रारंभिक मार्ग एक यादृच्छिक बिंदु पर निर्देशित होता है, क्योंकि टी = 0 पर उनकी मेमोरी खाली है। फिर उन्हें फ़ॉरेस्ट कार्य में भोजन लेने का आदेश दिया जाता है, और वे चारों ओर देखते हैं, यह सुनिश्चित करते हुए कि कोई और भोजन नहीं है। समय-समय पर वे भटकना शुरू कर देते हैं, क्योंकि वे उन स्थानों से बाहर निकलते हैं जिनमें उन्होंने भोजन (अशुभ लघुदृष्टि) देखा था।

और अंत में, बॉट में एक "दृश्य" होता है जो निर्धारित करता है कि उसे किस प्रकार का AI सौंपा गया है। प्रत्येक दृश्य एक नियंत्रण कार्य के साथ जुड़ा हुआ है जो उसके सभी व्यवहार को परिभाषित करता है: इसमें तेजी से छोटे कार्यों का एक झरना होता है, आसानी से स्मृति कतारों और आदिम कार्यों के एक सेट द्वारा निर्धारित किया जाता है। ये चींटी और मधुमक्खी जैसे कार्य हैं।

ऊपर से नीचे की संरचना

यदि आप ऊपर से नीचे तक देखते हैं, तो सिस्टम में एक टास्क-मास्टर वर्ग होता है जो मानचित्र पर प्रत्येक व्यक्ति बॉट के लिए नियंत्रण कार्यों और उनके निष्पादन का समन्वय करता है।

टास्कमास्टर के पास नियंत्रण कार्यों का एक वेक्टर है, जिनमें से प्रत्येक एक बॉट से जुड़ा हुआ है। प्रत्येक नियंत्रण कार्य, बदले में, उप-टास्क की एक कतार होती है जो संबंधित कार्य फ़ंक्शन के साथ कार्य ऑब्जेक्ट के पहले आरंभीकरण के दौरान लोड होती है।

 class Task{ public: //Members std::stack<Task> queue; bool initFlag = true; int args[10]; bool (Task::*handle)(Garden&, Population&, int (&)[10]); int botID; std::string name; //Constructor Task(std::string taskName, int taskBotID, bool (Task::*taskHandle)(Garden&, Population&, int (&)[10])){ name = taskName; botID = taskBotID; handle = taskHandle; } //Launch a Task bool perform(Garden &garden, Population &population); //Continue with primitives here... 

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

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

 //Execute Task Function bool Task::perform(Garden &garden, Population &population){ //Debug Message if(debug){std::cout<<"Bot with ID: "<<botID<<" performing task: "<<name<<std::endl;} //Change the Name and Execute the Task population.bots[botID].task = name; return (*this.*handle)(garden, population, args); } 

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

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

अंत में, नियंत्रण कार्य एक सरल संरचना का उपयोग करते हैं - उन्हें प्रत्येक चक्र में कहा जाता है, कार्य को केवल तभी लोड करें जब वे खाली हों, और अन्यथा उनकी कतार में लोड किए गए कार्य करें।

 //Species Functions bool Task::Ant(Garden &garden, Population &population, int (&arguments)[10]){ //Initial Condition if(initFlag){ Task forage("Search for Food", botID, &Task::forage); forage.args[0] = population.bots[botID].forage; //What are we looking for? queue.push(forage); initFlag = false; } //Queue Loop if(!queue.empty()){ //Get the Top Task Task newtask = queue.top(); queue.pop(); //If our new Task is not performed successfully if(!newtask.perform(garden, population)){ queue.push(newtask); return false; } //If it was successful, we leave it off return false; } //Return Case for Mastertask initFlag = true; return false; } 

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

परिणाम

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

 //Anthill General Configuration File debug = true; //World Generation Parameters seed = 15; water = true; //Species that the simulation recognizes Species: { //Ant Species Ant: { masterTask = "Ant"; color = (0, 0, 0); viewDistance = 2; memorySize = 5; forage = 2; trail = true; fly = false; } Bee: { masterTask = "Bee"; color = (240, 210, 30); viewDistance = 4; memorySize = 30; forage = 4; trail = false; fly = true; } Worm: { masterTask = "Bee"; color = (255, 154, 171); viewDistance = 1; memorySize = 5; forage = 3; trail = true; fly = false; } } Population: ( {species = "Ant"; number = 40;}//, //{species = "Bee"; number = 12;}, //{species = "Worm"; number = 5;} ) 

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


एक ही समय में 40 चींटियों का घास इकट्ठा करना। रेत में वे रास्ते बनाते हैं जो "अनिर्दिष्ट" भूमि को सौंपे गए वजन के कारण होते हैं। यह विशेषता "चींटी राजमार्गों के निर्माण की ओर जाता है।" उन्हें फेरोमोन के रूप में भी व्याख्या किया जा सकता है, लेकिन यह सच की तरह अधिक होगा यदि चींटियों ने वास्तव में यादों का आदान-प्रदान किया।

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

चींटी यादों को डिबग करना

जटिल कार्यों और स्मृति की संरचना ने अप्रत्याशित कठिनाइयों और अपवादों को संभालने की आवश्यकता को जन्म दिया है।

यहाँ तीन विशेष रूप से जटिल मेमोरी बग हैं जिन्होंने मुझे सब-सिस्टम को फिर से बनाया है:

एक वृत्त में चींटियाँ

पहली बार जो मुझे सामना करना पड़ा, उनमें से एक: चींटियों ने नंगे जमीन पर घास की तलाश में चौकोर में संलग्न पैटर्न के साथ पागलपन से भाग लिया। यह समस्या इसलिए उत्पन्न हुई क्योंकि उस समय मैंने अभी तक मेमोरी अपडेट लागू नहीं किया था। चींटियों को भोजन के स्थान की यादें थीं, और जैसे ही उन्होंने घास को उठाया और फिर से चारों ओर देखा, नई यादें बनीं।

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

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

चींटियाँ अन्य चींटियों के नीचे की वस्तुओं को उठाती हैं

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

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

अगम्य स्थान

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

भोजन की खोज के लिए एक अनुरोध प्रेषित करते समय, चींटियों के पास अक्सर उन जगहों की यादें होती थीं जो वे वास्तव में नहीं पहुंच सकते थे (उन्होंने पानी के ऊपर घास देखी और पागलपन से इसे इकट्ठा करना चाहते थे)। यदि यह उनकी स्मृति में चिह्नित नहीं किया गया था (उदाहरण के लिए, बूलियन चर "पहुंच योग्य"), तो वे इसे याद करते रहे और कतार में लिखते रहे जब तक कि यह क्रिया केवल एक ही नहीं थी। इसने गंभीर निषेध का कारण बना, क्योंकि उन्होंने लगातार प्रत्येक उपाय में पथ खोज संचालन किया, वहां पहुंचने की कोशिश की, और असफल रहे ।

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

सामान्य तौर पर प्रणाली

सामान्य तौर पर, मैं कहना चाहता हूं - हां, मुझे अफसोस है कि मैंने अपने जीवन का एक सप्ताह एक प्रोग्रामिंग मैराथन पर बिताया क्योंकि मुझे बॉट्स बनाने के लिए प्रेरित किया गया था जो मैं उन्हें बताता हूं (और यह भी कि वे क्या करना चाहते हैं!)। मुझे कुछ ट्रिक्स करनी थीं और बहुत कुछ सीखा।

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

सुधार

मुझे लगता है कि अधिक जटिल प्राणियों की अधिक जटिल यादों को अनुकरण करने के लिए महत्वपूर्ण सुधार की आवश्यकता है।

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

भविष्य के लिए, मैं तीन विशिष्ट योगों की योजना बना रहा हूं:

• इंटरप्ट हैंडलिंग और कार्य प्राथमिकता को जोड़ें
• संस्थाओं के बीच संचार जोड़ें
• एक समूह संरचना जोड़ें ताकि इकाइयां औपचारिक रूप से एक दूसरे की पहचान कर सकें

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

संस्थाओं के बीच संचार में संभवतः यादों के आदान-प्रदान या अन्य बॉट की यादों के लिए अनुरोध करने के लिए एक या दो आदिम कार्य होते हैं (उदाहरण के लिए, "कहते हैं" या "पूछें")। इस तरह, भोजन या अन्य संसाधनों के स्थान जैसी जानकारी प्रेषित की जा सकती है।

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

भविष्य

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

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

, ( ), .

निष्कर्ष में

. , , ( ).

. , ; .


seed, . , . , , .

… - Bee Task:

 bool Task::Bee(Garden &garden, Population &population, int (&arguments)[10]){ //Just Search for Flowers if(initFlag){ //Define our Tasks Task take("Take Food", botID, &Task::take); Task eat("Eat Food", botID, &Task::consume); Task search("Locate Food", botID, &Task::search); search.args[0] = population.bots[botID].forage; queue.push(eat); queue.push(take); queue.push(search); initFlag = false; } //Work off our allocated queue. if(!queue.empty()){ //Get the Top Task Task newtask = queue.top(); queue.pop(); //If our new Task is not performed successfully if(!newtask.perform(garden, population)){ //Put the Task back on queue.push(newtask); } //If it was successful, we leave it off return false; } initFlag = true; return true; }