एक आवर्ती तंत्रिका नेटवर्क (भाग 2) के आधार पर AI मिनी कप 2018 में भाग लेने के लिए एक बॉट बनाना

यह लेख के पहले भाग की निरंतरता है।

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

और यहाँ पहली तस्वीर है:

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

महत्वपूर्ण नोट: तंत्रिका नेटवर्क के साथ काम करने के लिए बड़ी संख्या में तैयार समाधान (चौखटे) हैं:

ये सभी पैकेज तंत्रिका नेटवर्क के डेवलपर के लिए मुख्य कार्यों को हल करते हैं: एनएन का निर्माण और प्रशिक्षण या "इष्टतम" वज़न की खोज। और इस खोज का मुख्य तरीका Backpropagation है । पिछली शताब्दी के 70 के दशक में इसका आविष्कार किया गया था, जैसा कि उपरोक्त लिंक पर लेख द्वारा दर्शाया गया है, इस समय के दौरान, जहाज के नीचे के रूप में, इसने विभिन्न सुधार हासिल किए हैं, लेकिन सार एक ही है: प्रशिक्षण उदाहरणों के आधार के साथ वजन गुणांक ढूंढना और यह अत्यधिक वांछनीय है कि हर कोई इन उदाहरणों में एक तंत्रिका नेटवर्क के आउटपुट सिग्नल के रूप में एक तैयार-निर्मित उत्तर था। पाठक को आपत्ति हो सकती है। विभिन्न वर्गों और सिद्धांतों के स्व-शिक्षण नेटवर्क का आविष्कार पहले ही हो चुका है, लेकिन जहां तक ​​मैं समझता हूं, वहां सब कुछ सुचारू रूप से नहीं चल रहा है। बेशक, इस चिड़ियाघर का और अधिक विस्तार से अध्ययन करने की योजना है, लेकिन मुझे लगता है कि मुझे ऐसे दिमाग वाले लोग मिलेंगे जो एक DIY-निर्मित साइकिल, यहां तक ​​कि सबसे अधिक घुमावदार, एक आदर्श साइकिल के कन्वेयर क्लोन की तुलना में निर्माता के दिल के करीब है।
यह समझते हुए कि गेम सर्वर की सबसे अधिक संभावना इन पुस्तकालयों और आयोजकों द्वारा आवंटित कंप्यूटिंग शक्ति के रूप में नहीं होगी क्योंकि 1 प्रोसेसर कोर स्पष्ट रूप से भारी ढांचे के लिए पर्याप्त नहीं है, लेखक ने अपनी बाइक बनाने के लिए आगे बढ़े। इस पर एक महत्वपूर्ण टिप्पणी समाप्त हुई।

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

आइए इस तंत्रिका नेटवर्क (छद्मकोश) का वर्णन करने का प्रयास करें:
हम नेटवर्क टोपोलॉजी को एक सरणी के रूप में पेश करते हैं, जहां प्रत्येक तत्व परत से मेल खाता है और इसमें न्यूरॉन्स की संख्या:

int array Topology= { 1, 1, 1}
हमें अपने नेटवर्क पर विचार करते हुए, "नेटवर्क फॉरवर्ड न्यूरल नेटवर्क (FF या FFNN)" पर विचार करते हुए तंत्रिका नेटवर्क W के वजन की एक फ्लोट सरणी की आवश्यकता होती है, जहां वर्तमान परत का प्रत्येक न्यूरॉन अगली परत के प्रत्येक न्यूरॉन से जुड़ा होता है, हमें सरणी W [परतों की संख्या] का आयाम मिलता है। परत में न्यूरॉन्स की संख्या, परत में न्यूरॉन्स की संख्या]। काफी इष्टतम एन्कोडिंग नहीं है, लेकिन पाठ में बहुत करीब से GPU की गर्म सांस को देखते हुए, यह समझ में आता है।
neuroncount न्यूरॉन्स की संख्या और dendritecount न्यूरल नेटवर्क में उनके कनेक्शन की संख्या की गणना के लिए एक छोटी CalculateSize प्रक्रिया, मुझे लगता है कि लेखक को इन कनेक्शनों की प्रकृति के बारे में बेहतर समझा जाएगा:

 void CalculateSize(array int Topology, int neuroncount, int dendritecount) { for (int i : Topology) // i         neuroncount += i; for (int layer = 0, layer <Topology.Length - 1, layer++) //   for (int i = 0, i < Topology[layer] + 1, i++) //   for (int j = 0, j < Topology[layer + 1], j++) //   dendritecount++; } 

मेरा पाठक, जो पहले से ही यह सब जानता है, लेखक पहले लेख में इस राय पर आया था, निश्चित रूप से नहीं पूछेगा: क्यों तीसरे नेस्टेड लूप टोपोलॉजी [लेयर 1 + 1] में टोपोलॉजी [लेयर 1] के बजाय, जो नेटवर्क टोपोलॉजी की तुलना में न्यूरॉन को अधिक देता है । मैंने जवाब नहीं दिया। पाठक के लिए गृहकार्य पूछना भी उपयोगी है।

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

इसलिए यहां हमारे पास न्यूरॉन सक्रियण कार्य हैं (वे चित्र में मौजूद हैं, इसके निचले हिस्से में)

 float Sigmoid(float x) { if (x < -10.0f) return 0.0f; else if (x > 10.0f) return 1.0f; return (float)(1.0f / (1.0f + expf(-x))); } 

सिगमॉइड 0 से 1 से मान लौटाता है।

 float Tanh(float x) { if (x < -10.0f) return -1.0f; else if (x > 10.0f) return 1.0f; return (float)(tanhf(x)); } 

स्पर्शरेखा 1 से 1 तक मान लौटाता है।

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

एक बार फिर, हम इनपुट एनएन को एक संकेत भेजते हैं, लहर परतों के माध्यम से चलती है और आउटपुट परत पर हम प्राप्त मूल्य को हटा देते हैं।

यहां, पाठक के स्वाद से, यह संभव है कि रिकार्शन का उपयोग करके या लेखक की तरह केवल एक ट्रिपल चक्र को हल किया जाए (गणनाओं को गति देने के लिए, आपको वस्तुओं को न्यूरॉन्स और उनके कनेक्शन और अन्य ओओपी के रूप में बाड़ लगाने की आवश्यकता नहीं है। फिर, यह करीबी GPU गणनाओं की भावना के कारण है, और GPUs पर, जन समानता के उनके स्वभाव के कारण, OOP थोड़ा रुकता है, यह c # और C ++ के सापेक्ष है।

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

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

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

एक आवर्तक न्यूरॉन में एक अतिरिक्त राज्य सी होता है, जो समय पर न्यूरॉन, टिक + 0 के माध्यम से सिग्नल के पहले पारित होने के बाद बनता है। सरल शब्दों में, यह एक न्यूरॉन के आउटपुट सिग्नल की एक प्रति है। दूसरे चरण में, टिक + 1 पढ़ें (चूंकि नेटवर्क गेम बॉट और सर्वर की आवृत्ति पर संचालित होता है), मान C अतिरिक्त वजन के माध्यम से तंत्रिका परत के इनपुट पर लौटता है और इस तरह संकेत के गठन में भाग लेता है, लेकिन पहले से ही टिक + 1 बार।

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

आरटीएन को बॉट कोड में बनाने के लिए, हम टोपोलॉजी में एक अतिरिक्त एरे को पेश करते हैं, जहां प्रत्येक तत्व परत से मेल खाता है और इसमें तंत्रिका राज्यों की संख्या है:

int array TopologyNN= { numberofSensors, 16, 8, 4}
int array TopologyRNN= { 0, 16, 0, 0 }

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

हमारे तंत्रिका नेटवर्क में कनेक्शन की गिनती थोड़ी बदल जाएगी:

 for (int layer = 0, layer < TopologyNN.Length - 1, layer++) for (int i = 0, i < TopologyNN[layer] + 1, i++) for (int j = 0, j < TopologyNN[layer + 1] , j++) dendritecount++; for (int layer = 0, layer < TopologyRNN.Length - 1, layer++) for (int i = 0, i< TopologyRNN[layer] + 1 , i++) for (int j = 0, j< TopologyRNN[layer], j++) dendritecount++; 

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

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

आनुवंशिक एल्गोरिथ्म के सिद्धांतों के बारे में एक चित्र तैयार किया:

तो आनुवंशिक एल्गोरिथ्म ।

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

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

अब एक आक्षेप हो जाएगा। हम मानेंगे कि बॉट जीनोम की लंबाई (आकार) तंत्रिका नेटवर्क टोपोलॉजीएनएन की गति की कुल लंबाई के बराबर होगी। लघुरूप + टोपोलोजीआरएनएन। कुछ भी नहीं है कि लेखक ने तंत्रिका कनेक्शन की गिनती के लिए प्रक्रिया पर पाठक का समय बिताया।

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

और चूंकि हमने एनएन को यादृच्छिक चर के साथ आरंभीकृत किया था, इसलिए हमने जीनोम को प्रारंभिक रूप दिया। रिवर्स प्रक्रिया भी संभव है: यादृच्छिक चर द्वारा जीनोटाइप की शुरुआत और तंत्रिका भार में इसकी बाद की नकल। दूसरा विकल्प आम है। चूंकि कार्यक्रम में आनुवंशिक एल्गोरिथ्म अक्सर सार से अलग मौजूद होता है और केवल जीनोम डेटा और फिटनेस फ़ंक्शन के मूल्य से जुड़ा होता है ... स्टॉप, स्टॉप, पाठक कहेंगे, चित्र स्पष्ट रूप से आबादी को दर्शाता है और व्यक्तिगत जीनोम के बारे में एक शब्द भी नहीं।

ठीक है, पाठक के मन भट्टी में कुछ चित्र जोड़ें:

चूंकि लेखक ने लेख का पाठ लिखने से पहले चित्रों को चित्रित किया है, वे पाठ का समर्थन करते हैं, लेकिन वर्तमान कहानी के पत्र के अक्षर का पालन नहीं करते हैं।

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

लेकिन लेखक ने पहले से ही इस लेख के इस हिस्से को क्या करने में कामयाब रहा है, बॉट्स की आबादी बनाने के लिए।
आइए इसे सॉफ्टवेयर की ओर से देखें:

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

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

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

फोटो पर ध्यान दें: समय के साथ, पैटर्न एक समाधान के प्रभुत्व की दिशा में बदल जाता है, ऊर्ध्वाधर धारियां सामान्य जीनोटाइप जीन हैं।

इसलिए, हमारे पास जीनोटाइप में 1000 जीन हैं और प्रतियोगिता के आयोजकों से गेम वर्ल्ड सिम्युलेटर कार्यक्रम में अधिकतम चार बॉट हैं। कितनी बार आपको बॉट्स की लड़ाई के सिमुलेशन को चलाने की आवश्यकता है ताकि जानवर बल से, यहां तक ​​कि सबसे चतुर, "प्रभावी" की तलाश में करीब हो जाएं
जीनोटाइप, तंत्रिका कनेक्शन के "प्रभावी" संयोजन को पढ़ें, बशर्ते कि प्रत्येक तंत्रिका कनेक्शन चरणों में -1 से 1 तक भिन्न हो, और कौन सा कदम? आरंभीकरण यादृच्छिक फ्लोट था, यह 15 दशमलव स्थान है। कदम अभी हमारे लिए स्पष्ट नहीं है। तंत्रिका भार के संयोजन के कई प्रकारों पर, लेखक मानता है कि यह एक अनंत संख्या है, जब एक निश्चित चरण आकार का चयन किया जाता है, शायद एक परिमित संख्या, लेकिन किसी भी मामले में, ये संख्या सिम्युलेटर में 4 से अधिक स्थानों पर होती है, यहां तक ​​कि बॉट की कतार से क्रमिक लॉन्च पर विचार करना और साथ ही साथ आधिकारिक सिमुलेटरों की एक साथ समानांतर लॉन्च, 10 तक की शुरुआत। एक कंप्यूटर पर (पुरानी प्रोग्रामिंग के प्रशंसकों के लिए: कंप्यूटर)।

मुझे उम्मीद है कि चित्र पाठक की मदद करेंगे।

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

उन्होंने दाढ़ी वाले मजाक को याद किया:

बड़ा संगठन।
समय 18.00, सभी कर्मचारी एक के रूप में काम करते हैं। अचानक, कर्मचारियों में से एक कंप्यूटर बंद कर देता है, कपड़े पहने और निकल जाता है।
हर कोई उसे सरप्राइज लुक के साथ फॉलो करता है।
अगले दिन। 18.00 बजे समान कर्मचारी कंप्यूटर बंद कर देता है और निकल जाता है। हर कोई काम करना जारी रखता है और नाराजगी में कानाफूसी शुरू कर देता है।
अगले दिन। 18.00 बजे उसी कर्मचारी ने कंप्यूटर बंद कर दिया ...
एक सहकर्मी उससे संपर्क करता है:
-जैसे कि आप शर्मिंदा न हों, हम काम कर रहे हैं, तिमाही का अंत हो रहा है, इसलिए कई रिपोर्ट्स, हम भी समय पर घर प्राप्त करना चाहते हैं और आप ऐसे व्यक्ति हैं ...
- दोस्तों, मैं आमतौर पर VACATION पर हूँ!

... जारी रखा जाए।

हां, मैं आरएनएन गणना प्रक्रिया कोड संलग्न करना लगभग भूल गया, यह वैध है और स्वतंत्र रूप से लिखा गया है, इसलिए शायद इसमें त्रुटियां हैं। प्रवर्धन के लिए, मैं इसे वैसा ही लाऊंगा जैसा कि यह C ++ में लागू है जैसा कि CUDA (GPU पर गणना के लिए एक पुस्तकालय) पर लागू होता है।

नोट: बहुआयामी सरणियों को GPU पर अच्छी तरह से नहीं मिलता है, बेशक बनावट और मैट्रिक्स की गणना होती है, लेकिन वे एक-आयामी सरणियों का उपयोग करने की सलाह देते हैं।

एक उदाहरण [i, j] डायमेंशन M का j, फॉर्म की एक सरणी में बदल जाता है [i * M + j]।

 __global__ void cudaRNN(Bot *bot, argumentsRNN *RNN, ConstantStruct *Const, int *Topology, int *TopologyRNN, int numElements, int gameTick) { int tid = blockIdx.x * blockDim.x + threadIdx.x; int threadN = gridDim.x * blockDim.x; int TopologySize = Const->TopologySize; for (int pos = tid; pos < numElements; pos += threadN) { const int ii = pos; const int iiA = pos*Const->ArrayDim; int ArrayDim = Const->ArrayDim; const int iiAT = ii*TopologySize*ArrayDim; if (bot[pos].TTF != 0 && bot[pos].Mass>0) { RNN->outputs[iiA + Topology[0]] = 1.f; //bias int neuroncount7 = Topology[0]; neuroncount7++; for (int layer1 = 0; layer1 < TopologySize - 1; layer1++) { for (int j4 = 0; j4 < Topology[layer1 + 1]; j4++) { for (int i5 = 0; i5 < Topology[layer1] + 1; i5++) { RNN->sums[iiA + j4] = RNN->sums[iiA + j4] + RNN->outputs[iiA + i5] * RNN->NNweights[((ii*TopologySize + layer1)*ArrayDim + i5)*ArrayDim + j4]; } } if (TopologyRNN[layer1] > 0) { for (int j14 = 0; j14 < Topology[layer1]; j14++) { for (int i15 = 0; i15 < Topology[layer1]; i15++) { RNN->sumsContext[iiA + j14] = RNN->sumsContext[iiA + j14] + RNN->neuronContext[iiAT + ArrayDim * layer1 + i15] * RNN->MNweights[((ii*TopologySize + layer1)*ArrayDim + i15)*ArrayDim + j14]; } RNN->sumsContext[iiA + j14] = RNN->sumsContext[iiA + j14] + 1.0f* RNN->MNweights[((ii*TopologySize + layer1)*ArrayDim + Topology[layer1])*ArrayDim + j14]; //bias=1 } for (int t = 0; t < Topology[layer1 + 1]; t++) { RNN->outputs[iiA + t] = Tanh(RNN->sums[iiA + t] + RNN->sumsContext[iiA + t]); RNN->neuronContext[iiAT + ArrayDim * layer1 + t] = RNN->outputs[iiA + t]; } //SoftMax /* double sum = 0.0; for (int k = 0; k <ArrayDim; ++k) sum += exp(RNN->outputs[iiA + k]); for (int k = 0; k < ArrayDim; ++k) RNN->outputs[iiA + k] = exp(RNN->outputs[iiA + k]) / sum; */ } else { for (int i1 = 0; i1 < Topology[layer1 + 1]; i1++) { RNN->outputs[iiA + i1] = Sigmoid(RNN->sums[iiA + i1]); //sigma } } if (layer1 + 1 != TopologySize - 1) { RNN->outputs[iiA + Topology[layer1 + 1]] = 1.f; } for (int i2 = 0; i2 < ArrayDim; i2++) { RNN->sums[iiA + i2] = 0.f; RNN->sumsContext[iiA + i2] = 0.f; } } } } }