🛌🏼 🐴 👲 हम तंत्रिका नेटवर्क को "स्नेक" खेलने के लिए प्रशिक्षित करते हैं और प्रतियोगिता के लिए एक सर्वर लिखते हैं 🌮 🐿️ 🕯️

इस बार खेल "साँप" चुना गया है।
गो नेटवर्क के लिए एक पुस्तकालय बनाया गया है।
सीखने का सिद्धांत, स्मृति की "गहराई" के आधार पर पाया जाता है।
डेवलपर्स के बीच गेम के लिए एक सर्वर लिखा जाता है।

खेल का सार

शायद बहुत से लोग खेल "स्नेक" को याद करते हैं, जो नोकिया फोन पर एक मानक अनुप्रयोग था। इसका सार यह है: एक साँप पूरे क्षेत्र में घूमता है, जो भोजन नहीं मिलने पर घटता है, या यदि वह पाता है तो बढ़ जाता है। यदि कोई सांप बाधा में गिर जाता है, तो वह मर जाता है।

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

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

साइबर जीवविज्ञानी मिखाइल सार्ककोव के सांपों के साथ प्रयोग को आधार के रूप में लिया गया है।

तंत्रिका नेटवर्क

कार्य के भाग के रूप में, तंत्रिका नेटवर्क के लिए एक पुस्तकालय को गो भाषा में लिखा गया था। तंत्रिका नेटवर्क के काम का अध्ययन, मैं foo52ru वीडियो डायरी और तारिक रशीद की पुस्तक का उपयोग करता हूं - एक तंत्रिका नेटवर्क बनाएं।

CreateLayer(L []int) फ़ंक्शन CreateLayer(L []int) परतों और उनके आकार की आवश्यक संख्या के साथ एक तंत्रिका नेटवर्क बनाता है। प्रत्येक परत पर, अंतिम को छोड़कर, एक विस्थापन न्यूरॉन जोड़ा जाता है। हम पहली परत को डेटा खिलाते हैं, और हम अंतिम परत से परिणाम प्राप्त करते हैं।

एक उदाहरण:

 CreateLayer([]int{9, 57, 3, 1})

यहां हमने नौ इनपुट के साथ एक न्यूरल नेटवर्क बनाया। परिणाम प्राप्त करने के लिए 57 और 3 न्यूरॉन्स और एक न्यूरॉन की दो छिपी हुई परतें। विस्थापन न्यूरॉन्स स्वचालित रूप से उन लोगों द्वारा जोड़ दिए जाते हैं जो हम सेट करते हैं।

पुस्तकालय आपको इसकी अनुमति देता है:

नेटवर्क इनपुट के लिए डेटा जमा करें।
अंतिम परत तक पहुंचकर परिणाम प्राप्त करें।
सही उत्तर पूछें और संबंधों के भार को समायोजित करके प्रशिक्षण का संचालन करें।

प्रारंभिक बांड वजन शून्य के करीब यादृच्छिक मूल्यों द्वारा दिया जाता है। सक्रियण के लिए, हमने लॉजिस्टिक फ़ंक्शन का उपयोग किया।

बॉट ट्रेनिंग

बॉट प्रवेश द्वार पर एक 9x9 वर्ग क्षेत्र प्राप्त करता है, जिसके बीच में एक सांप का सिर है। तदनुसार, हमारे तंत्रिका नेटवर्क में 81 इनपुट होंगे। इनपुट को खिलाए गए कोशिकाओं का क्रम मायने नहीं रखता है। प्रशिक्षण के दौरान, नेटवर्क "यह पता लगाएगा" स्वयं, जहां क्या स्थित है।

बाधाओं और अन्य सांपों को इंगित करने के लिए, मैंने -1 से 0 तक के मूल्यों का उपयोग किया (समावेशी नहीं)। खाली कोशिकाओं को 0.01, और भोजन 0.99 के मान के साथ नामित किया गया था।

तंत्रिका नेटवर्क के उत्पादन में, कार्यों के लिए 5 न्यूरॉन्स का उपयोग किया गया था:

एक्स अक्ष के साथ छोड़ दिया चाल;
दाईं ओर;
y अक्ष;
नीचे;
आधे में विभाजित।

बॉट का आंदोलन न्यूरॉन द्वारा निर्धारित किया गया था, जिसका आउटपुट पर सबसे बड़ा मूल्य है।

चरण 0. रैंडमाइज़र

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

चरण 1. स्मृति के बिना सीखना

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

प्रशिक्षण के लिए निम्नलिखित मूल्य दिए गए थे:

पाया गया भोजन: 0.99
किसी भी दिशा में एक आंदोलन बनाया: 0.5
बिना भोजन पाए शरीर की कोशिका को खो दिया (10 चालें इसके लिए दी गई हैं): 0.2
अभी भी खड़ा है (एक बाधा मारा या अटक): 0.1
अभी भी खड़ा है, शरीर की एक कोशिका: 0.01

इस तरह के प्रशिक्षण के बाद, बॉट्स ने रैंडमाइज़र को पीटना शुरू कर दिया, और मैंने कार्य निर्धारित किया: बॉट्स बनाने के लिए जो इन को हरा देगा।

ए / बी परीक्षण

इस कार्य को पूरा करने के लिए, एक प्रोग्राम बनाया गया था जो तंत्रिका नेटवर्क के विन्यास के आधार पर सांपों को दो भागों में विभाजित करता है। मैदान पर, प्रत्येक कॉन्फ़िगरेशन के 20 सांपों का उत्पादन किया गया था।

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

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

चरण 2. स्मृति के साथ सीखना

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

जैसी कि उम्मीद थी, मेमोरी बॉट्स ने बोट्स को जल्दी से पीटना शुरू कर दिया जो बिना मेमोरी के प्रशिक्षित थे।

चरण 3. स्मृति की गहराई के आधार पर सुधार गुणांक में कमी

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

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

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

सुधार गुणांक में एक लघुगणकीय कमी के साथ बॉट एक रैखिक संबंध के साथ बॉट्स को हराने के लिए शुरू किया।

बॉट के लिए सर्वर

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

प्रोटोकॉल

प्राधिकरण के लिए, आपको "गेम" निर्देशिका में एक GET अनुरोध भेजने और उपयोगकर्ता नाम निर्दिष्ट करने की आवश्यकता है, उदाहरण के लिए:

 .../game/?user=masterdak

"..." के बजाय आपको साइट पता और पोर्ट निर्दिष्ट करने की आवश्यकता है जहां सर्वर तैनात है।

अगला, सर्वर सत्र को इंगित करने वाले JSON प्रारूप में एक प्रतिक्रिया जारी करेगा:

 {"answer":"Hellow, masterdak!","session":"f4f559d1d2ed97e0616023fb4a84f984"}

उसके बाद, आप अनुरोध पर एक सत्र जोड़ते हुए, नक्शे और सांप के निर्देशांक को क्षेत्र पर अनुरोध कर सकते हैं:

 .../game/?user=masterdak&session=f4f559d1d2ed97e0616023fb4a84f984

सर्वर कुछ इस तरह प्रदर्शित होगा:

 { "answer": "Sent game data.", "data": { "area": [ ["...  ..."] ], "snakes": [ { "num": 0, "body": [ { "x": 19, "y": 24 }, { "x": 19, "y": 24 }, { "x": 19, "y": 24 } ], "energe": 4, "dead": false } ] } }

क्षेत्र फ़ील्ड निम्न मानों के साथ खेल मैदान की स्थिति को इंगित करेगा:

 0 //  -1 // -2 // 2 //  1 //

इसके बाद सांपों के साथ एक सरणी होगी जो आपके नियंत्रण में है।

सांप का शरीर बॉडी ऐरे में है। जैसा कि आप शुरुआत में सांप के पूरे शरीर (सिर सहित - पहली कोशिका) को एक ही स्थिति में देख सकते हैं "x": 19, "y": 24। यह इस तथ्य के कारण है कि खेल की शुरुआत में सांप छेद से बाहर निकलते हैं, जिसे मैदान पर एक सेल द्वारा परिभाषित किया गया है। । इसके अलावा, शरीर और सिर के निर्देशांक अलग-अलग होंगे।

निम्नलिखित संरचनाएं (गो में एक उदाहरण) सभी सर्वर प्रतिक्रिया विकल्पों को परिभाषित करती हैं:

 type respData struct { Answer string Session string Data struct { Area [][]int Snakes []struct { Num int Body []Cell Energe int Dead bool } } } type Cell struct { X int Y int }

इसके बाद, आपको उस कदम को भेजने की ज़रूरत है जो साँप जीईटी अनुरोध में कदम जोड़कर करता है, उदाहरण के लिए:

 ...&move=u

यू - का मतलब है कमान;
डी - नीचे;
एल - बाईं ओर;
आर - सही करने के लिए;
/ - पड़ाव।

कई साँपों के लिए कमांड (उदाहरण के लिए, सात के लिए) इस तरह दिखेगा:

 ...&move=ud/urld

एक चरित्र - एक टीम। उत्तर में उन सभी साँपों के लिए एक कमांड होनी चाहिए जो आपके नियंत्रण में हैं। अन्यथा, कुछ सांपों को एक आदेश प्राप्त नहीं हो सकता है और पुरानी कार्रवाई जारी रहेगी।

फ़ील्ड को 150 ms के अंतराल पर अद्यतन किया जाता है। यदि 60 सेकंड के भीतर कोई कमांड प्राप्त नहीं होती है, तो सर्वर कनेक्शन बंद कर देगा।

संदर्भ

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

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

युपीडी
सर्वर आईपी पते को अस्थायी रूप से अपलोड करें । अब केवल एक बॉट रैंडमाइज़र (स्नेकबोट 0) वहां लॉन्च किया गया है। मुझे उम्मीद है कि सर्वर इतनी तेजी से क्रैश नहीं होगा।

हम तंत्रिका नेटवर्क को "स्नेक" खेलने के लिए प्रशिक्षित करते हैं और प्रतियोगिता के लिए एक सर्वर लिखते हैं