👩🏾‍🤝‍👩🏼 🤚🏻 🎃 एक गेम खेलने के लिए आर्टिफिशियल इंटेलिजेंस सीखें 🖕🏿 🕜 🛄

शुभ दिन, प्रिय पाठक!

इस लेख में, हम एक तंत्रिका नेटवर्क विकसित करेंगे जो विशेष रूप से अच्छे स्तर पर इसके लिए बनाए गए खेल को पारित कर सकता है।

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

प्रारंभ: खेल के नियमों का वर्णन

लक्ष्य लाल के साथ हलकों से बचने के रूप में संभव के रूप में एक हरे रंग की रिम के साथ कई हलकों को पकड़ने के लिए है।

नियम और शर्तें:

दो बार हरे घेरे के रूप में कई लाल घेरे मैदान पर उड़ते हैं;
हरे घेरे मैदान के भीतर बने रहते हैं, लाल घेरे खेत से बाहर निकल जाते हैं और खत्म हो जाते हैं;
हरे और लाल घेरे अपनी तरह से टकरा सकते हैं और फटकार सकते हैं;
खिलाड़ी - स्क्रीन पर एक पीले रंग की गेंद, क्षेत्र के भीतर स्थानांतरित कर सकते हैं।

छूने के बाद गेंद गायब हो जाती है, और खिलाड़ी को संबंधित बिंदुओं से सम्मानित किया जाता है।

अगला: ऐ डिजाइनिंग

रिसेप्टर्स

एआई के लिए यह तय करने में सक्षम होने के लिए कि खिलाड़ी को कहां स्थानांतरित करना है, आपको पहले पर्यावरणीय डेटा प्राप्त करने की आवश्यकता है। ऐसा करने के लिए, विशेष स्कैनर बनाएं जो सीधी रेखाएं हैं। पहला स्कैनर क्षेत्र की निचली सीमा के संबंध में 180 डिग्री के कोण पर स्थित है।

68 होंगे: पहले 32 - बम (लाल घेरे) पर प्रतिक्रिया, अगले 32 - सेब (हरे घेरे) पर प्रतिक्रिया, और अंतिम 4 - खिलाड़ी के सापेक्ष क्षेत्र की सीमाओं के स्थान पर डेटा प्राप्त करते हैं। आइए हम इन 68 स्कैनर को भविष्य के तंत्रिका नेटवर्क (रिसेप्टर परत) के इनपुट न्यूरॉन्स कहते हैं।

पहले 64 स्कैनर की लंबाई 1000 पीएक्स है, शेष 4 उसी समरूपता चेहरे के अनुसार क्षेत्र को आधे में विभाजित करने के लिए

एआई स्कोप (1/4)

आकृति में: स्कैन न्यूरॉन्स स्कैनर से मान प्राप्त करते हैं
स्कैनर पर मान सामान्यीकृत हैं, अर्थात सीमा [0, 1] तक कम हो जाती है, और स्कैनर को पार करने वाली वस्तु के जितना करीब होता है, उतना ही अधिक मूल्य स्कैनर में प्रेषित होता है।

स्कैनर्स द्वारा डेटा प्राप्त करने और जेएस पर इसके कार्यान्वयन के लिए एल्गोरिदम

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

यहाँ से हमें रेखा का निर्देशन वेक्टर मिलता है, जिसका अर्थ है कि हम इस रेखा के समीकरण के विहित रूप का निर्माण कर सकते हैं।

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

यदि हम इस प्रतिस्थापन को एक सामान्य रूप में लाते हैं, तो हम क्रमशः, बी, और सी के संबंध में एक पैरामीट्रिक समीकरण प्राप्त करते हैं, जहां ये चर वर्ग से शुरू होने वाले द्विघात समीकरण के गुणांक हैं।

हम रेखीय बीजगणित की सरल परिभाषाओं का उपयोग करके पाठक को इस एल्गोरिथम के साथ परिचित करने के लिए आमंत्रित करते हैं
नीचे स्कैनर्स का कोड है

Ball.scaners: { // length: 1000, i: [], //   get_data: function(){ //Ball.scaners.get_data /     var angl = 0; var x0 = Ball.x, var y0 = Ball.y; var l = Ball.scaners.length; for(let k = 0; k < 32; k++){ x1 = l*Math.cos(angl), y1 = l*Math.sin(angl); Ball.scaners.i[k] = 0; for(i = 0; i < bombs.length; i++){ if(((k >= 0) && (k <= 8) && (bombs[i].x < x0) && (bombs[i].y < y0)) || ((k >= 8) && (k <= 16) && (bombs[i].x > x0) && (bombs[i].y < y0)) || ((k >= 16) && (k <= 24) && (bombs[i].x > x0) && (bombs[i].y > y0)) || ((k >= 24) && (k <= 32) && (bombs[i].x < x0) && (bombs[i].y > y0))){ //    var x2 = bombs[i].x, y2 = bombs[i].y; var p = true; //    var pt = true; //     var t1, t2; var a = x1*x1 + y1*y1, b = 2*(x1*(x0 - x2) + y1*(y0 - y2)), c = (x0 - x2)*(x0 - x2) + (y0 - y2)*(y0 - y2) - bombs[i].r*bombs[i].r; //------------------------------    if((a == 0) && (b != 0)){ t = -c/b; pt = false; } if((a == 0) && (b == 0)){ p = false; } if((a != 0) && (b != 0) && (c == 0)){ t1 = 0; t2 = b/a; } if((a != 0) && (b == 0) && (c == 0)){ t1 = 0; pt = false; } if((a != 0) && (b == 0) && (c != 0)){ t1 = Math.sqrt(c/a); t2 = -Math.sqrt(c/a); } if((a != 0) && (b != 0) && (c != 0)){ var d = b*b - 4*a*c; if(d > 0){ t1 = (-b + Math.sqrt(d))/(2*a); t2 = (-b - Math.sqrt(d))/(2*a); } if(d == 0){ t1 = -b/(2*a); } if(d < 0){ p = false; } } //----------------------------------- if(p == true){ if(pt == true){ let x = t1*x1 + x0; let y = t1*y1 + y0; let l1 = Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2); x = t2*x1 + x0; y = t2*y1 + y0; let l2 = Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2); if(l1 <= l2){ Ball.scaners.i[k] += 1 - l1/(l*l); }else{ Ball.scaners.i[k] += 1 - l2/(l*l); } }else{ let x = t1*x1 + x0; let y = t1*y1 + y0; Ball.scaners.i[k] += 1 - (Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2))/(l*l); } }else{ Ball.scaners.i[k] += 0; } }else{ continue; } } angl += Math.PI/16; } //!---------------  for(k = 32; k < 64; k++){ x1 = l*Math.cos(angl), y1 = l*Math.sin(angl); Ball.scaners.i[k] = 0; for(i = 0; i < apples.length; i++){ if(((k >= 32) && (k <= 40) && (apples[i].x < x0) && (apples[i].y < y0)) || ((k >= 40) && (k <= 48) && (apples[i].x > x0) && (apples[i].y < y0)) || ((k >= 48) && (k <= 56) && (apples[i].x > x0) && (apples[i].y > y0)) || ((k >= 56) && (k <= 64) && (apples[i].x < x0) && (apples[i].y > y0))){ var x2 = apples[i].x, var y2 = apples[i].y; var p = true; //    var pt = true; //     var t1, t2; var a = x1*x1 + y1*y1, b = 2*(x1*(x0 - x2) + y1*(y0 - y2)), c = (x0 - x2)*(x0 - x2) + (y0 - y2)*(y0 - y2) - apples[i].r*apples[i].r; //------------------------------    if((a == 0) && (b != 0)){ t = -c/b; pt = false; } if((a == 0) && (b == 0)){ p = false; } if((a != 0) && (b != 0) && (c == 0)){ t1 = 0; t2 = b/a; } if((a != 0) && (b == 0) && (c == 0)){ t1 = 0; pt = false; } if((a != 0) && (b == 0) && (c != 0)){ t1 = Math.sqrt(c/a); t2 = -Math.sqrt(c/a); } if((a != 0) && (b != 0) && (c != 0)){ var d = b*b - 4*a*c; if(d > 0){ t1 = (-b + Math.sqrt(d))/(2*a); t2 = (-b - Math.sqrt(d))/(2*a); } if(d == 0){ t1 = -b/(2*a); } if(d < 0){ p = false; } } //----------------------------------- if(p == true){ if(pt == true){ let x = t1*x1 + x0; let y = t1*y1 + y0; let l1 = Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2); x = t2*x1 + x0; y = t2*y1 + y0; let l2 = Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2); if(l1 <= l2){ Ball.scaners.i[k] += 1 - l1/(l*l); }else{ Ball.scaners.i[k] += 1 - l2/(l*l); } }else{ let x = t1*x1 + x0; let y = t1*y1 + y0; Ball.scaners.i[k] += 1 - (Math.pow((x - Ball.x), 2)+Math.pow((y - Ball.y), 2))/(l*l); } }else{ Ball.scaners.i[k] += 0; } }else{ continue; } } angl += Math.PI/16; } Ball.scaners.i[64] = (1000 - Ball.x) / 1000; //  Ball.scaners.i[65] = Ball.x / 1000; //  Ball.scaners.i[66] = (500 - Ball.y) / 500; //  Ball.scaners.i[67] = Ball.y / 500; //  } }

तंत्रिका नेटवर्क डिजाइन

इसलिए, एनएस प्रशिक्षण के लिए ट्रेसिंग (संदर्भ पथ) के एल्गोरिथ्म का उपयोग करने के लिए प्रथागत था।
नोट: सीखने की प्रक्रिया को सरल बनाने के लिए, मेट्रिसेस के निर्माण को छोड़ दिया गया है।

आइए शुरू:

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

उपरोक्त एल्गोरिथ्म को पूरा करने के बाद, हम नीचे दिए गए चित्र में दिखाए गए तंत्रिका नेटवर्क को प्राप्त करते हैं

* लेकिन यह सब नहीं है। परिणाम की सही व्याख्या करना महत्वपूर्ण है, (Y आउटपुट न्यूरॉन्स की एक सरणी है):

  Ball.vx = -(Y[0] - Y[4]) + (-(Y[1] - Y[5]) + (Y[3] - Y[6]))*0.5; Ball.vy = -(Y[2] - Y[6]) + (-(Y[3] - Y[7]) + (Y[5] - Y[1]))*0.5;

इस प्रकार, हमने आलेख के शीर्ष पर gif पर खिलाड़ी के AI को रेखांकित करने वाले तंत्रिका नेटवर्क को स्वचालित रूप से बनाया और प्रशिक्षित किया

कोड लिंक पर उपलब्ध है (गेम और AI का कार्यान्वयन): लिंक को github Ivan753 / Learning

वह सब है। आपका ध्यान के लिए धन्यवाद!

एक गेम खेलने के लिए आर्टिफिशियल इंटेलिजेंस सीखें

प्रारंभ: खेल के नियमों का वर्णन

अगला: ऐ डिजाइनिंग

रिसेप्टर्स

तंत्रिका नेटवर्क डिजाइन

More articles: