परिचय या जैसा कि मैंने अपना पहला AI लिखा

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



तब यह एक नियतात्मक एल्गोरिथ्म था, अर्थात एक एल्गोरिथ्म क्रियाओं के स्पष्ट अनुक्रम के साथ, जब प्रत्येक चरण पर आप सटीक रूप से कह सकते हैं कि आगे क्या होगा। कुछ ऐसा दिख रहा था (छद्म कोड):

 rwarn = 0 // दाईं ओर सांप को खतरा
 lwarn = 0 // बाईं ओर सांप को खतरा
 सभी विरोधियों के लिए सेशन {
	 यदि बिंदु सांप के अर्धवृत्त के भीतर प्रतिद्वंद्वी की हड्डी सेशन का केंद्र है, तो {
		 यदि बिंदु सांप के दाईं ओर स्थित है, तो
			 रावर ++;
		 यदि बिंदु सांप के बाईं ओर स्थित है, तो
			 lwarn ++;
	 }
	 यदि हम किसी दिए गए निर्देशांक (x या y) में से किसी एक की गति के अधिकतम विचलन के साथ दी गई दीवारों के समानांतर किसी एक से अधिक दूरी पर चलते हैं, तो {{
		 यदि दीवार साँप के दाईं ओर है, तो
			 rwarn + = 100;
		 यदि दीवार साँप के बाईं ओर है, तो
			 lwarn + = 100;
	 }
	 यदि रवन्! = ० और लवन! = ०, तो !!
		 यदि rwarn> lwarn, तो बाएँ मुड़ें।  अन्यथा, सही करने के लिए।
	 }
 } // सभी विरोधियों सेशन के लिए

यानी यह एआई हमेशा सांपों के दिए गए स्थानों के लिए एक ही काम करता है: यह उस तरफ मुड़ता है जहां कम सांप और / या दीवारें होती हैं। हां, हां, मैंने जादू की संख्या "100" का संकेत दिया, जो दीवार होने पर खतरे को बढ़ाता है। मैजिक नंबर एक खराब प्रोग्रामिंग शैली है, लेकिन उस समय यह बहाना था। मैंने ऐसा इसलिए किया है कि सांप अधिक बार दीवारों की तुलना में अन्य सांपों में दुर्घटनाग्रस्त हो जाते हैं, हालांकि यह स्थिति काफी सापेक्ष है: यदि सांप के अर्धवृत्त के भीतर अन्य सांपों की 100 से अधिक हड्डियां (= भाग) हैं, तो एल्गोरिथ्म दीवार में दुर्घटनाग्रस्त हो जाएगा। इसके बावजूद, एल्गोरिथ्म ने काफी अच्छी तरह से काम किया: एआई ने सांपों को अलग-अलग कोणों पर परिक्रमा की, दीवारों की परिक्रमा की (यह कभी भी उनमें दुर्घटनाग्रस्त नहीं हुई जब तक कि अन्य सांपों ने इसे मजबूर नहीं किया), और दीवार और सांप के बीच संतुलित भी जब ऐसा करना आवश्यक था।
हालाँकि, उनकी 2 कमियां थीं:
1) जब साँप दीवार के पास सवार हुआ, और AI दीवार और साँप के बीच में था, तब भी अगर कहीं जाना था, तो समय-समय पर निम्न उत्पन्न हुए: AI उलझन में आ गया, चिकोटी - बाईं ओर से थोड़ी, दाईं ओर, थोड़ी-थोड़ी बाईं ओर, ... और मर गया।
2) सांप से एक ही पूर्व निर्धारित दूरी पर, एआई ने हमेशा एक मोड़ शुरू किया। यदि यह पता चला कि सांप एआई से अधिक दूरी पर था, और थोड़ी देर बाद - बहुत कम दूरी पर (तेजी से एआई की ओर मुड़ गया), तो एआई दुर्घटनाग्रस्त हो गया। बशर्ते कि वह पहले से मुड़ सकता है, या कम से कम मुड़ना शुरू कर सकता है। मैं एक बड़े दायरे के साथ एक और अर्धवृत्त शुरू करने के बारे में सोच रहा था - जिसके लिए मुझे "थोड़ा" चालू करने की आवश्यकता है। तब मैंने अपने आप को रोक लिया, क्योंकि एल्गोरिथ्म बन रहा था, यह मुझे लगता है, बहुत जटिल है। यदि जटिल हो, तो निश्चित रूप से वेपाइंट दर्ज करें - मैंने सोचा।
इन दो कमियों को एक शब्द में वर्णित किया जा सकता है - कुछ मामलों में सांप "चिकोटी" था और इस वजह से समय-समय पर उसकी मृत्यु हो गई।
अब, जब 5 साल बाद, मैंने नागिन के पागलपन को एंड्रॉइड पर पोर्ट किया, तो मैंने फैसला किया कि इस कमी से लड़ा जाना चाहिए। और "फजी लॉजिक" ने मेरी मदद की। मैं एल्गोरिथ्म में हमारे "फजी" तर्क देने के लिए एक उपकरण के रूप में फजी लॉजिक को समझता हूं। तो, आइए एक नए दृष्टिकोण से कार्य पर एक नज़र डालें।

सिद्धांत

मेरे सर्प के पागलपन के खेल में साँप बाएँ, दाएँ, या आगे बढ़ सकता है। वह बिल्कुल नहीं चल सकती। इस प्रकार, AI में निम्नलिखित आउटपुट होंगे:
1) बाएं मुड़ें
2) दाएं मुड़ें
3) आगे बढ़ें
इसके अनुसार, हम भाषाई चर के साथ एक तालिका प्रस्तुत करते हैं - चर जो प्राकृतिक या कृत्रिम भाषा से वाक्यांशों का अर्थ ले सकते हैं।

	सांपों से दूरी	साँप का घनत्व	दीवारों की दूरी	कोने को मारो
बाईं ओर
दाईं ओर
आगे

कोशिकाओं में शब्द होंगे। शब्द से मेरा अभिप्राय चर (भाषाई) के वाक्यांश से है।
दूर, बस करीब - जब यह दूरी की बात आती है (कॉलम 1 और 3)
नहीं, छोटा, मध्यम, बहुत - जब यह साँपों के घनत्व की बात आती है (स्तंभ 2)
नहीं, शायद यह सुनिश्चित करने के लिए - जब यह एक कोने (कॉलम 4) में आने की बात करता है

प्रत्येक पद के लिए, सदस्यता कार्यों को परिभाषित किया गया है। अर्थ के संदर्भ में, ये 0 से 1 तक "खतरे के कार्य" होंगे, मूल्य जितना अधिक होगा, किसी दिशा में यात्रा करने का खतरा उतना अधिक होगा।
प्रत्येक पंक्ति i के लिए, हम कोशिकाओं m (i) में अधिकतम मानों की गणना करते हैं। तो मान लीजिए कि किसी दिए गए दिशा में मापदंडों के संदर्भ में अधिकतम खतरा है। फिर ऐसे सभी मी (i) से हम न्यूनतम पाते हैं। कम से कम इस सवाल का जवाब होगा - क्या करना है, बाएं / दाएं मुड़ें या सीधे जाएं।

नीचे कुछ उदाहरण दिए गए हैं। मैं इस तथ्य पर ध्यान आकर्षित करता हूं कि संख्यात्मक व्याख्या केवल एक उदाहरण के रूप में दी गई है। दरअसल, विकसित प्रणाली में, अन्य मूल्य हो सकते हैं।

उदाहरण संख्या १

	सांपों से दूरी	साँप का घनत्व	दीवारों की दूरी	कोने को मारो
बाईं ओर	बस सही है	कुछ	नहीं	नहीं
दाईं ओर	बहुत दूर	नहीं	बस सही है	यकीन के लिए
आगे	पास	एक बहुत	बहुत दूर	नहीं

परिणाम को बाएं मुड़ने का निर्णय होना चाहिए।
गणना से क्या प्राप्त होता है:
न्यूनतम (अधिकतम (0.5, 0.33, 0, 0), अधिकतम (0, 0, 0.5, 1), अधिकतम (1, 1, 0, 0)) = मिनट (0.5, 1, 1) = 0.5 = बारी बाएँ

उदाहरण संख्या 2

	सांपों से दूरी	साँप का घनत्व	दीवारों की दूरी	कोने को मारो
बाईं ओर	पास	माध्यमिक	बहुत दूर	नहीं
दाईं ओर	बहुत दूर	नहीं	बहुत दूर	नहीं
आगे	पास	माध्यमिक	बहुत दूर	नहीं

परिणाम सही होने का निर्णय होना चाहिए।
न्यूनतम (अधिकतम (1, 0.75, 0, 0), अधिकतम (1, 0.75, 0, 0), अधिकतम (0,0,0,0) = मिनट (1,1,0) = 0 = दाईं ओर मुड़ें

उदाहरण संख्या 3

	सांपों से दूरी	साँप का घनत्व	दीवारों की दूरी	कोने को मारो
बाईं ओर	पास	माध्यमिक	बहुत दूर	नहीं
दाईं ओर	बहुत दूर	नहीं	पास	नहीं
आगे	पास	माध्यमिक	बहुत दूर	नहीं

परिणामी निर्णय करना मुश्किल है - हर जगह आसन्न मौत का खतरा है।
सांप क्या फैसला करता है:
न्यूनतम (अधिकतम (1, 0.75, 0,0), अधिकतम (1, 0.75, 0, 0), (0,0, 1, 0)) = मिनट (1,1,1) = 1 = बाएँ मुड़ें

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

कम्प्यूटिंग के लिए नियम

विकास करते समय, मैं निम्नलिखित बिंदुओं पर ध्यान दूंगा। वे सीपीयू समय बचाते हैं।
1) यदि अधिकतम फ़ंक्शन के लिए शब्द की गणना और 1 के बराबर है, तो बाकी की गणना करने का कोई मतलब नहीं है, अधिकतम 1 देगा।
2) यदि मिनिमम फंक्शन की अवधि की गणना की जाती है और 0 के बराबर है, तो यह बाकी की गणना करने के लिए कोई मतलब नहीं है, मिनट 0 देगा।

चित्रमय व्याख्या

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

क्षेत्र के क्षेत्र और जिम्मेदारियां

सर्कल सेक्टर क्लास सर्कलसेक्टर
व्यवहार:
1) देखें कि बिंदु सेक्टर का है
2) चौराहे को आयत के साथ खोजें (0 से 4 अंक तक), यह ध्यान में रखते हुए कि सेक्टर हमेशा आयत के अंदर केंद्रित है
3) साँप की हड्डियों और दीवारों के अनुसार प्रारंभिक (ऊपर के तरीकों का उपयोग करके)
4) मिनट का पता लगाएं। सांप से दूरी (भाषा) चर 1)
5) सांपों के घनत्व का पता लगाएं (भाषा। ट्रांस। 2)
6) मि। दीवारों की दूरी (लिंग। ट्रांस। 3)
7) कोने से टकराने की डिग्री का पता लगाएं
8) अधिकतम खतरे की डिग्री का पता लगाएं
4 से 7 तक - सदस्यता कार्यों का कार्यान्वयन।
8 - अधिकतम 4-7 की तलाश में।
क्षेत्रों:
बिंदु - साँप की हड्डियों के निर्देशांक (केंद्र)
अंक - दीवार खंडों के निर्देशांक (0, 2, 3 (कोण), 4)

परिवर्तन कर रहा है

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

जावा और Android एसडीके लिस्टिंग (v2.1)

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

package com.iz.serpents.tools; import java.util.Collections; import java.util.LinkedList; import java.util.List; import android.graphics.RectF; import com.iz.serpents.model.Movement; import com.iz.serpents.model.Serpent; import com.iz.serpents.model.SerpentCollidable; /** * @author Deepscorn * There are three sectors, which in sum gives us one half of circle, * these sectors corresponds to aim, specified in constructor. * Each sector (LEFT, RIGHT, FORWARD) is 60 degrees. * So, sector is 1/6 of circle square. * */ public class CircleSector { /* * Checks if circle sector has the given point. * Algorithm is: * 1) check distance < radius * 2) check point is to the left of the first line * 3) check point is to the right of the second line */ public boolean hasPoint(Vector pt) { return (pt.qdist(O) < rad && pt.isOnLine(O, A)<0 && pt.isOnLine(O, B)>0); } /* * Creates sector * @param movementType - one of Movement.*, used in sector creation, different * movementTypes means different sectors * Note, that FORWARD sector will have radius greater, than specified in circleRadius. */ public CircleSector(float circleRadius, int movementType, Vector aim, Vector circleCenter) { if(movementType == Movement.FORWARD) rad = circleRadius * 1.1f; else rad = circleRadius; O = circleCenter; type = movementType; _ptBones = new LinkedList<Vector>(); _ptWalls = new LinkedList<Vector>(); Vector ortAim = (Vector) aim.clone(); ortAim.normalize(); Vector vC = ortAim.mul(rad); Vector vAC = null, vCB = null; if(type == Movement.LEFT || type == Movement.FORWARD) { vAC = (Vector) vC.clone(); vAC.qrotate(30, Movement.LEFT); } if(type == Movement.FORWARD || type == Movement.RIGHT) { vCB = (Vector) vC.clone(); vCB.qrotate(30, Movement.RIGHT); } switch(type) { case Movement.LEFT: Vector lo = (Vector) ortAim.clone(); lo.leftOrtogonalRotate(); A = O.add( lo.mul(rad) ); B = O.add(vAC); break; case Movement.FORWARD: A = O.add(vAC); B = O.add(vCB); break; case Movement.RIGHT: Vector ro = (Vector) ortAim.clone(); ro.rightOrtogonalRotate(); A = O.add(vCB); B = O.add( ro.mul(rad) ); break; } possibleBonesInside = (int) ((rad*rad)/ (6f*Serpent.boneRad()*Serpent.boneRad())); } /* * Fills sector with content */ public void addBones(List<? extends Serpent> serpents, int indAI) { _indAI = indAI; for(int j = 0;j<serpents.size();j++) { Serpent s = serpents.get(j); int start = 0; if(j==indAI) start = SerpentCollidable.afterNeckInd; for(int i=start;i<s.numBones();i++) { if(hasPoint(s.bone(i))) _ptBones.add(s.bone(i)); } } } /* * Gets number of bones in sector */ public int getNumBones() { return _ptBones.size(); } /* * Fills sector with content */ public void addWalls(RectF walls) { List<Vector> walls_points = new LinkedList<Vector>(); walls_points.add(Vector.create(walls.left, walls.top)); walls_points.add(Vector.create(walls.right, walls.top)); walls_points.add(Vector.create(walls.right, walls.bottom)); walls_points.add(Vector.create(walls.left, walls.bottom)); walls_points.add(Vector.create(walls.left, walls.top)); for(int i=0;i<walls_points.size()-1;i++) { Vector common; //left common = Vector.intersect(walls_points.get(i), walls_points.get(i+1), O, A); if(common!=null) _ptWalls.add(common); //right common = Vector.intersect(walls_points.get(i), walls_points.get(i+1), O, B); if(common!=null) _ptWalls.add(common); //forward common = Vector.intersect(walls_points.get(i), walls_points.get(i+1), A, B); if(common!=null) _ptWalls.add(common); //corner if(_ptWalls.size()==1) _ptWalls.add(walls_points.get(i+1)); } } /* * Gets number of wall's ends in sector: * 0 - no walls * 2 - one wall * 3 - two walls (corner) * 4 - two walls * wall is a line with two (!) ends */ public int getNumWallEnds() { return _ptWalls.size(); } /* * Gets distance to closest serpent in range [0;rad] * Attention! Distance = rad, when there actually * no serpents! */ public float distToClosestSerpent() { float res = rad; for(int i=0;i<_ptBones.size();i++) { float dist = _ptBones.get(i).qdist(O); if(dist < res) res = dist; } return res; } /* * Gets distance to closest wall in range [0;rad] * Attention! Distance = rad, when there actually * no walls! */ public float distToClosestWall() { float res = rad; for(int i=0;i<_ptWalls.size();i++) { float dist = _ptWalls.get(i).qdist(O); if(dist < res) res = dist; } return res; } //RELATION FUNCTIONS// //all relation functions returns value in ragne [0;1], //where 1 - is "the worst" or "the biggest" threat //and 0 - means no threat at all public float rel_distToClosestSerpent() { return 1 - distToClosestSerpent()/rad; } public float rel_serpentsStrength() { return ((float)getNumBones())/possibleBonesInside; } public float rel_distToClosestWall() { return 1 - distToClosestWall()/rad; } public float rel_inCorner() { float res = 0; if(getNumWallEnds()==4) res = 0.5f; if(getNumWallEnds()==3) res = 1f; return res; } public float rel_max_threat() { return Math.max( Math.max(rel_distToClosestSerpent(), rel_serpentsStrength()), Math.max(rel_distToClosestWall(), rel_inCorner())); } /* * Finds minimal threat and returns index of the element. * Keep in mind, that if all threats are equal, than the first * sector will be returned. */ public static int findMinThreatReturnIndex(ICircleSectorReadable sector[]) { float min = sector[0].rel_max_threat(); int result = 0; for(int i=1;i<sector.length;i++) { float cur = sector[i].rel_max_threat(); if(min>cur) { result = i; min = cur; } } return result; } //RELATION FUNCTIONS END// //sector geometry private Vector O; private Vector A; private Vector B; private final float rad; private final int type; private final int possibleBonesInside; //sector is presented as two lines: (O,A) - left line, (0,B) - right line, //O - is center of circle, which sector it is //rad - radius of circle, which sector it is //type is one of Movement.*, used in sector creation, different //movementTypes means different sectors //when working with walls there used triangular instead of circle center - for //performance reasons //initialed if necessary: //sector content private List<Vector> _ptBones = null; private List<Vector> _ptWalls = null; //sector owner private int _indAI; } 

परिणाम

नीचे एअर डीबग मोड में सर्प के पागलपन से स्क्रीनशॉट हैं।
सफेद क्षेत्रों की सीमाओं को इंगित करता है - त्रिकोण (दीवारों के लिए, हड्डियों के लिए - यह कल्पना करना आसान है)।

सेक्टर में हड्डियों को पीले रंग में हाइलाइट किया गया है।

और लाल रंग में - सेक्टर में दीवारें।

कभी-कभी वे टकराते हैं। जैसा कि मैंने ऊपर लिखा है, यह बढ़ते क्षेत्रों द्वारा समाप्त हो गया है। लेकिन खेल के हिस्से के रूप में, एक अजेय AI की जरूरत नहीं थी।

लेकिन कुल मिलाकर, AI महान है:

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