प्रश्न की प्रकृति के कारण, मुझे बहुत सारी पृष्ठभूमि की जानकारी शामिल करनी है (क्योंकि मेरा प्रश्न है: मैं इसे कैसे संकीर्ण कर सकता हूं?) उन्होंने कहा, इसे संक्षेप में (मेरे ज्ञान के सर्वोत्तम) के रूप में किया जा सकता है:
बहुत बड़े कॉम्बीनेटरियल सर्च स्पेस पर स्थानीय अनुकूलन खोजने के लिए क्या तरीके मौजूद हैं?
पृष्ठभूमि
टूल-असिस्टेड सुपरप्ले समुदाय में हम वीडियो गेम कंसोल या एमुलेटर पर विशेष रूप से तैयार किए गए (वास्तविक समय में उत्पन्न नहीं) इनपुट प्रदान करते हैं ताकि कुछ लागत (आमतौर पर समय से पूरा होने) को कम से कम किया जा सके। जिस तरह से यह वर्तमान में किया जाता है वह गेम फ्रेम-बाय-फ्रेम खेलने और प्रत्येक फ्रेम के लिए इनपुट निर्दिष्ट करने के लिए होता है, अक्सर रन के कुछ हिस्सों को कई बार फिर से करना (उदाहरण के लिए, हाल ही में प्रकाशित द लीजेंड ऑफ ज़ेल्डा: ओकारिना ऑफ़ टाइम के लिए प्रकाशित किया गया है) कुल 198,590 रिट्रीज)।
इन रनों को बनाने से उनका लक्ष्य आमतौर पर दो मुख्य कारकों में बदल जाता है: मार्ग-नियोजन और ट्रैवर्सल। पूर्ववर्ती उत्तरार्द्ध की तुलना में बहुत अधिक "रचनात्मक" है।
रूट-प्लानिंग यह निर्धारित कर रही है कि खिलाड़ी को खेल को पूरा करने के लिए किस तरह से नेविगेट करना चाहिए, और अक्सर रन का सबसे महत्वपूर्ण हिस्सा होता है। उदाहरण के लिए किस छँटाई विधि का उपयोग करने के लिए यह अनुरूप है। दुनिया में सबसे अच्छा बुलबुला सॉर्ट बस 1 लाख तत्वों पर एक त्वरित-सॉर्ट करने के लिए नहीं जा रहा है।
पूर्णता की इच्छा में, हालांकि, ट्रैवर्सल (मार्ग कैसे किया जाता है) भी एक बहुत बड़ा कारक है। सादृश्य को जारी रखते हुए, यह है कि छंटाई एल्गोरिथ्म कैसे लागू किया जाता है। कुछ मार्गों को इनपुट के बहुत विशिष्ट फ्रेम के बिना भी नहीं किया जा सकता है। यह टूल-असिस्टिंग की सबसे थकाऊ प्रक्रिया है और यह वह है जो एक पूर्ण किए गए रन के उत्पादन में महीनों या वर्षों तक लगता है। यह एक कठिन प्रक्रिया नहीं है (एक मानव के लिए) क्योंकि यह एक ही विचार के विभिन्न रूपों की कोशिश करने के लिए नीचे आता है जब तक कि सबसे अच्छा नहीं समझा जाता है, लेकिन मनुष्य केवल अपने ध्यान-अवधि में बहुत सारे बदलावों की कोशिश कर सकते हैं। इस कार्य के लिए मशीनों का अनुप्रयोग यहाँ उचित लगता है।
मेरा लक्ष्य अब निंटेंडो 64 प्रणाली के लिए सामान्य रूप से ट्रैवर्सल प्रक्रिया को स्वचालित करने का प्रयास करना है । खोज इस समस्या के लिए जगह नहीं है अब तक भी एक जानवर बल दृष्टिकोण के साथ हमला करने के लिए बड़े। एक N64 रन की एक n फ्रेम खंड 2 है 30N संभव आदानों, इनपुट के एक मात्र 30 फ्रेम (30fps पर एक दूसरे) 2 है, जिसका अर्थ 900 संभव आदानों; इन संभावित समाधानों का परीक्षण करना असंभव होगा, पूरे दो घंटे चलने वालों को अकेले रहने दें।
हालाँकि, मैं एक पूर्ण रन के कुल वैश्विक अनुकूलन के प्रयास में दिलचस्पी नहीं रखता (या बल्कि, मैं प्रयास करने की कोशिश भी नहीं कर रहा हूँ)। बल्कि, मैं एक आरंभिक इनपुट को देखते हुए, एक रन के किसी विशेष खंड के लिए स्थानीय इष्टतम (या निकटतम वैश्विक अनुकूलन के लिए निकटतम n स्थानीय ऑप्टिमम) को पसंद करूंगा । अर्थात्, एक मार्ग और उस मार्ग का एक प्रारंभिक ट्रैवर्सल: लागत को कम करने के लिए उस ट्रैवर्सल के पड़ोसियों की खोज करें, लेकिन उन सभी मामलों की कोशिश करने में पतित न हों जो समस्या को हल कर सकते थे।
इसलिए मेरे कार्यक्रम को एक प्रारंभिक अवस्था, एक इनपुट स्ट्रीम, एक मूल्यांकन कार्य करना चाहिए, और मूल्यांकन के परिणाम को न्यूनतम करके स्थानीय इष्टतम का उत्पादन करना चाहिए।
वर्तमान स्थिति
वर्तमान में मेरे पास सभी ढांचे का ध्यान रखा गया है। इसमें एमुलेटर, सेटअप और फाड़, कॉन्फ़िगरेशन, आदि के हेरफेर के माध्यम से एक इनपुट स्ट्रीम का मूल्यांकन करना शामिल है और एक प्लेसहोल्डर के रूप में, ऑप्टिमाइज़र एक बहुत ही बुनियादी आनुवंशिक एल्गोरिथ्म है। यह बस इनपुट स्ट्रीम की एक आबादी का मूल्यांकन करता है, विजेता को बदलता है / बदलता है, और विजेता स्ट्रीम को म्यूट करके एक नई आबादी उत्पन्न करता है। यह प्रक्रिया तब तक जारी रहती है जब तक कि कुछ मनमाने मापदंड पूरे नहीं हो जाते, जैसे समय या पीढ़ी संख्या।
ध्यान दें कि इस कार्यक्रम का सबसे धीमा हिस्सा एक इनपुट स्ट्रीम का मूल्यांकन होगा । ऐसा इसलिए है क्योंकि इसमें n फ्रेम के लिए गेम का अनुकरण करना शामिल है । (यदि मेरे पास समय होता तो मैं अपना खुद का एमुलेटर लिखता जो इस तरह के सामान में हुक प्रदान करता था, लेकिन अब मैं संदेशों को संश्लेषित करने और किसी अन्य प्रक्रिया से मौजूदा एमुलेटर के लिए मेमोरी को संशोधित करने के लिए छोड़ दिया गया हूं।) मेरे मुख्य कंप्यूटर पर, जो। काफी आधुनिक है, 200 फ्रेम का मूल्यांकन करने में लगभग 14 सेकंड लगते हैं। जैसे, मैं एक एल्गोरिथम (पसंद को देखते हुए) पसंद करूँगा जो फ़ंक्शन मूल्यांकन की संख्या को कम करता है।
मैंने फ्रेमवर्क में एक सिस्टम बनाया है जो एमुलेटर को समवर्ती रूप से प्रबंधित करता है। जैसे कि मैं एक रैखिक प्रदर्शन पैमाने के साथ कई धाराओं का मूल्यांकन कर सकता हूं , लेकिन व्यावहारिक रूप से बोलने वाले एमुलेटर की संख्या केवल 8 से 32 हो सकती है (और 32 वास्तव में इसे धक्का दे रही है) सिस्टम प्रदर्शन बिगड़ने से पहले। इसका मतलब है (पसंद को देखते हुए), एक एल्गोरिथ्म जो एक मूल्यांकन करते समय प्रसंस्करण कर सकता है, अत्यधिक फायदेमंद होगा, क्योंकि यह एक मूल्यांकन पर इंतजार करते समय ऑप्टिमाइज़र कुछ भारी-भार उठा सकता है।
एक परीक्षण के रूप में, मेरा मूल्यांकन कार्य (गेम बैंजो काजू के लिए ) योग, प्रति फ्रेम, खिलाड़ी से लक्ष्य बिंदु तक की दूरी थी। इसका मतलब यह था कि इष्टतम समाधान उस बिंदु के जितना जल्दी हो सके उतना जल्दी प्राप्त करना था। केवल एनालॉग स्टिक में उत्परिवर्तन को सीमित करने में, एक ठीक समाधान प्राप्त करने में एक दिन लगा । (इससे पहले कि मैंने कंसीडर को लागू किया था।)
संगामिति जोड़ने के बाद, मैंने A बटन प्रेस के म्यूटेशन को सक्षम किया और एक ऐसे क्षेत्र में एक ही मूल्यांकन कार्य किया जिसे कूदना आवश्यक था। 24 एमुलेटर के साथ इसे शुरू में खाली इनपुट स्ट्रीम से लक्ष्य तक पहुंचने में लगभग 1 घंटे का समय लगता था, लेकिन संभवत: किसी भी चीज को इष्टतम के करीब पहुंचने के लिए कुछ दिनों तक चलाना होगा।
मुसीबत
मैं जिस समस्या का सामना कर रहा हूं, वह यह है कि मैं गणितीय अनुकूलन क्षेत्र के बारे में पर्याप्त नहीं जानता कि मैं अपनी अनुकूलन समस्या को कैसे ठीक से मॉडल करूं ! मैं उदाहरण के लिए विकिपीडिया पर वर्णित कई एल्गोरिदम के वैचारिक विचार का अनुसरण कर सकता हूं, लेकिन मुझे नहीं पता कि मैं अपनी समस्या को कैसे वर्गीकृत करूं या उस श्रेणी के लिए अत्याधुनिक एल्गोरिदम का चयन करूं।
जो मैं बता सकता हूं, उससे मुझे एक बहुत बड़े पड़ोस के साथ जुझारू समस्या है । उसके शीर्ष पर, मूल्यांकन कार्य अत्यंत असंतुलित है, कोई ढाल नहीं है, और कई पठार हैं । इसके अलावा, कई अड़चनें नहीं हैं, हालांकि मैं ख़ुशी से उन्हें व्यक्त करने की क्षमता जोड़ दूंगा अगर यह समस्या को हल करने में मदद करता है; मैं यह निर्दिष्ट करने की अनुमति देना चाहूंगा कि प्रारंभ बटन का उपयोग नहीं किया जाना चाहिए, उदाहरण के लिए, लेकिन यह सामान्य मामला नहीं है।
सवाल
तो मेरा सवाल है: मैं इसे कैसे मॉडल करूं? मैं किस प्रकार की अनुकूलन समस्या को हल करने की कोशिश कर रहा हूं? मैं किस एल्गोरिथ्म का उपयोग करने के लिए लगता हूं? मैं शोध पत्र पढ़ने से नहीं डरता इसलिए मुझे पता होना चाहिए कि मुझे क्या पढ़ना चाहिए!
वास्तव में, एक आनुवंशिक एल्गोरिथ्म सबसे अच्छा नहीं हो सकता है, क्योंकि यह वास्तव में सीखना प्रतीत नहीं होता है। उदाहरण के लिए, यदि प्रारंभ करना दबाने से लगता है कि मूल्यांकन हमेशा खराब होता है (क्योंकि यह खेल को विराम देता है), किसी प्रकार का डिज़ाइनर या मस्तिष्क होना चाहिए जो सीखता है: "किसी भी बिंदु पर प्रारंभ को दबाना बेकार है।" लेकिन फिर भी इस लक्ष्य को नहीं के रूप में तुच्छ के रूप में यह लग रहा है, क्योंकि कभी-कभी दबाने शुरुआत है है ऐसे तथाकथित रूप में "को थामने के पिछड़े-लंबी छलांग" में, इष्टतम सुपर मारियो 64 ! यहां मस्तिष्क को बहुत अधिक जटिल पैटर्न सीखना होगा: "प्रारंभ को छोड़कर बेकार है जब खिलाड़ी इस बहुत विशिष्ट स्थिति में है और बटन प्रेस के कुछ संयोजन के साथ जारी रहेगा ।"
ऐसा लगता है कि मुझे चाहिए (या मशीन सीख सकती थी) कुछ और फैशन में इनपुट का प्रतिनिधित्व करें जो संशोधन के अनुकूल हो। प्रति-फ्रेम इनपुट बहुत दानेदार लगता है, क्योंकि जो वास्तव में आवश्यक है वह "क्रियाएं" हैं, जो कई फ़्रेमों को फैला सकती हैं ... फिर भी कई खोज एक फ्रेम-बाय-फ्रेम आधार पर की जाती हैं, इसलिए मैं इसे पूरी तरह से नियमबद्ध नहीं कर सकता ( पूर्वोक्त ठहराव पीछे की ओर लंबी-कूद के लिए फ्रेम-स्तर की सटीकता की आवश्यकता होती है)। यह भी इस तथ्य की तरह लगता है कि इनपुट को संसाधित किया जाता है क्रमिक रूप से कुछ ऐसा होना चाहिए जिस पर पूंजी लगाई जा सकती है, लेकिन मुझे यकीन नहीं है कि कैसे।
वर्तमान में मैं (रिएक्टिव) तबू सर्च के बारे में पढ़ रहा हूं, बहुत बड़े पैमाने पर पड़ोस की खोज, शिक्षण-शिक्षण-आधारित अनुकूलन और चींटी कॉलोनी अनुकूलन।
क्या यह समस्या बस यादृच्छिक आनुवंशिक एल्गोरिदम के अलावा किसी भी चीज़ से निपटने के लिए बहुत कठिन है? या यह वास्तव में एक तुच्छ समस्या है जो बहुत पहले हल हो गई थी? पढ़ने के लिए धन्यवाद और किसी भी प्रतिक्रिया के लिए अग्रिम धन्यवाद।
