मूर्खों के लिए एक खेल (नहीं)। हम "द फ़ूल" के लिए AI लिखते हैं (भाग 1)

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

लेख का उद्देश्य खेल के लिए एक सरल एआई लिखना है। "सरल" शब्द का अर्थ निम्नलिखित है:

• एक सहज ज्ञान युक्त निर्णय लेने वाला एल्गोरिथ्म (जो कि, परिणामस्वरूप कोई मशीन सीखना नहीं है जिसमें यह एल्गोरिथ्म "हूड के तहत" गहराई से छिपा हुआ है);
• राज्य की कमी (अर्थात, एल्गोरिथ्म केवल वर्तमान समय में डेटा द्वारा निर्देशित होता है, दूसरे शब्दों में, इसे कुछ भी याद नहीं है (उदाहरण के लिए, यह कार्ड को "गिनती" नहीं करता है जो खेल को छोड़ दिया है)।

(सख्ती से बोलते हुए, पहला पैराग्राफ अब इस तरह के एआई को आर्टिफिशियल इंटेलिजेंस कहलाने के लिए नहीं बनाता है , बल्कि केवल एक छद्म एआई है। लेकिन गेम डेवलपमेंट में ऐसी शब्दावली स्थापित की गई है, इसलिए हमने इसे नहीं बदला है।)

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

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

• इक्का (ए) - +600 अंक,
• राजा (के) - +500,
• महिला (Q) - +400,
• जैक (J) - +300,
• दस (10) - +200,
• नौ (9) - +100,
• आठ (8) - 0,
• सात (7) - -100,
• छह (6) - -200,
• पांच (5) - -300,
• चार (4) - -400,
• तीन (3) - -500,
• और अंत में, ड्यूस (2) - -600 अंक।

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

ट्रम्प कार्ड किसी भी साधारण कार्ड की तुलना में अधिक मूल्यवान हैं (यहां तक ​​कि ट्रम्प ड्यूस एक "साधारण" इक्का है), और ट्रम्प सूट में पदानुक्रम समान है, इसलिए उनका मूल्यांकन करने के लिए हम केवल "आधार" मान में 1300 जोड़ते हैं - फिर, उदाहरण के लिए, ट्रम्प ड्यूस की लागत 600 होगी। + 1300 = 700 अंक (यानी, एक एकल ट्रम्प कार्ड से थोड़ा अधिक)।

कोड में (लेख में सभी कोड उदाहरण relativaCardValue() में होंगे), यह कुछ इस तरह दिखता है ( relativaCardValue() फ़ंक्शन एक ही अनुमान लौटाता है, और RANK_MULTIPLIER 100 के बराबर एक गुणांक है):

 for (c in hand) { val r = c.rank val s = c.suit res += ((relativeCardValue(r.value)) * RANK_MULTIPLIER).toInt() if (s === trumpSuit) res += 13 * RANK_MULTIPLIER //   ,    } 

काश, यह सब नहीं होता। निम्नलिखित मूल्यांकन नियमों पर विचार करना भी महत्वपूर्ण है:

• एक ही मूल्य के कई कार्ड रखने के लिए फायदेमंद है - न केवल इसलिए कि वे प्रतिद्वंद्वी को "भर" सकते हैं, बल्कि आसानी से हमले को दोहरा सकते हैं (विशेषकर यदि कार्ड उच्च मूल्य के हैं)। उदाहरण के लिए, खेल के अंत में, एक हाथ (सादगी के लिए, हम मानते हैं कि बाद में ट्रेंबाइन हैं)

  $$$ $ प्रदर्शन $ $ \ क्लब सूट 2 \ spadesuit 2 \ हीरे हीरे क्यू \ दिल सूट क्यू \ क्लब सूट Q \ spadesuit Q $ $ प्रदर्शन $ $ लगभग सही (निश्चित रूप से, अगर विरोधी आपके साथ राजाओं या इक्के के तहत नहीं जाता है): आपको महिलाओं द्वारा पीटा जाएगा, जिसके बाद प्रतिद्वंद्वियों को लटकाओ उसे एक जोड़ी दें।

  
  एक ही (बेशक, गैर-ट्रम्प) सूट के कई कार्ड, इसके विपरीत, एक नुकसान है - वे एक-दूसरे के साथ "हस्तक्षेप" करेंगे। उदाहरण के लिए, हाथ

  $$$ $ प्रदर्शन $ $ \ _ हुकुम ५ \ _ हुकुम बहुत असफल - भले ही प्रतिद्वंद्वी पहले कदम के साथ आपके ट्रम्प कार्ड को "नॉक आउट" न करे और पीक सूट के कार्ड के साथ जाता है, तो अन्य सभी फेंके गए कार्ड अन्य सूट के होंगे, और उन्हें ट्रम्प कार्ड देना होगा। इसके अलावा, एक उच्च संभावना है कि पांच भीड़ लावारिस रहेगी - आपके पास सभी ट्रम्प कार्ड हैं जिनकी गरिमा पांच से अधिक है, इसलिए किसी भी परिस्थिति में (जब तक, निश्चित रूप से, आपने शुरू में कार्ड युवा के साथ प्रवेश किया था) आप इसे किसी अन्य कार्ड के साथ कवर नहीं कर पाएंगे - यह बहुत संभावना है। उच्च। दूसरी ओर, हम हुकुम के जैक को दस क्लबों से और ट्रम्प छह को ट्रिपल के साथ बदलते हैं:

  $$$ $ प्रदर्शन $ $ \ _ हुकुम ५ \ क्लब सूट १० \ इस तथ्य के बावजूद कि हमने कार्ड को युवा लोगों के साथ बदल दिया, ऐसा हाथ बहुत बेहतर है - सबसे पहले, आपको कार्ड के सूट पर एक ट्रम्प कार्ड नहीं देना होगा (और यह हुकुम के इक्का का उपयोग करने की अधिक संभावना होगी), और दूसरी बात, यदि आप किसी को हराते हैं फिर आपके ट्रम्प तीन के साथ एक कार्ड, एक मौका है कि कोई आपको तीन हुकुम फेंक देगा (क्योंकि आमतौर पर इस तरह के कार्ड को धारण करने का कोई मतलब नहीं है), और आप "पांचों" को पकड़ लेंगे।

  
  
  
  

  इन रणनीतियों को लागू करने के लिए, हम अपने एल्गोरिथ्म को संशोधित करते हैं: यहां हम प्रत्येक सूट और लाभ के कार्ड की संख्या पर विचार करते हैं ...

  
  

   /*          - ,      -     ,   ,    4    1.25 */ val bonuses = doubleArrayOf(0.0, 0.0, 0.5, 0.75, 1.25) var res = 0 val countsByRank = IntArray(13) val countsBySuit = IntArray(4) for (c in hand) { val r = c.rank val s = c.suit res += ((relativeCardValue(r.value)) * RANK_MULTIPLIER).toInt() if (s === trumpSuit) res += 13 * RANK_MULTIPLIER countsByRank[r.value - 1]++ countsBySuit[s.value]++ } 

  
  

  ... यहां हम उनके लिए बोनस जोड़ते हैं ( Math.max कॉल की आवश्यकता है ताकि कम कार्ड के लिए नकारात्मक बोनस प्राप्त न हो - क्योंकि इस मामले में यह फायदेमंद भी है) ...

  
  

   for (i in 1..13) { res += (Math.max(relativeCardValue(i), 1.0) * bonuses[countsByRank[i - 1]]).toInt() } 

  
  

  ... और यहाँ, इसके विपरीत, हम सूट में असंतुलित एक सूट के लिए ठीक है (मूल्य UNBALANCED_HAND_PENALTY प्रयोगात्मक रूप से 200 पर सेट है):

  
  

   //      ... var avgSuit = 0.0 for (c in hand) { if (c.suit !== trumpSuit) avgSuit++ } avgSuit /= 3.0 for (s in Suit.values()) { if (s !== trumpSuit) { //              val dev = Math.abs((countsBySuit[s.value] - avgSuit) / avgSuit) res -= (UNBALANCED_HAND_PENALTY * dev).toInt() } } 

  
  

  अंत में, हम हाथ में कार्ड की संख्या के रूप में इस तरह के एक भड़काऊ बात को ध्यान में रखते हैं। वास्तव में, खेल की शुरुआत में 12 अच्छे कार्ड होना बहुत अच्छा है (खासकर जब से उन्हें अब भी 6 से अधिक नहीं फेंका जा सकता है), लेकिन गेम के अंत में, जब आपके अलावा केवल 2 कार्ड बचे हैं, तो यह बिल्कुल भी नहीं है।

  
  

   //       (      ) var cardsInPlay = cardsRemaining for (p in playerHands) cardsInPlay += p cardsInPlay -= hand.size // ,      ,     ( MANY_CARDS_PENALTY = 600) val cardRatio = if (cardsInPlay != 0) (hand.size / cardsInPlay).toDouble() else 10.0 res += ((0.25 - cardRatio) * MANY_CARDS_PENALTY).toInt() return res 

  
  

  हम संक्षेप में कहते हैं - पूर्ण रूप से, मूल्यांकन कार्य इस तरह दिखता है:

  
  

   private fun handValue(hand: ArrayList<Card>, trumpSuit: Suit, cardsRemaining: Int, playerHands: Array<Int>): Int { if (cardsRemaining == 0 && hand.size == 0) { return OUT_OF_PLAY } val bonuses = doubleArrayOf(0.0, 0.0, 0.5, 0.75, 1.25) // for cards of same rank var res = 0 val countsByRank = IntArray(13) val countsBySuit = IntArray(4) for (c in hand) { val r = c.rank val s = c.suit res += ((relativeCardValue(r.value)) * RANK_MULTIPLIER).toInt() if (s === trumpSuit) res += 13 * RANK_MULTIPLIER countsByRank[r.value - 1]++ countsBySuit[s.value]++ } for (i in 1..13) { res += (Math.max(relativeCardValue(i), 1.0) * bonuses[countsByRank[i - 1]]).toInt() } var avgSuit = 0.0 for (c in hand) { if (c.suit !== trumpSuit) avgSuit++ } avgSuit /= 3.0 for (s in Suit.values()) { if (s !== trumpSuit) { val dev = Math.abs((countsBySuit[s.value] - avgSuit) / avgSuit) res -= (UNBALANCED_HAND_PENALTY * dev).toInt() } } var cardsInPlay = cardsRemaining for (p in playerHands) cardsInPlay += p cardsInPlay -= hand.size val cardRatio = if (cardsInPlay != 0) (hand.size / cardsInPlay).toDouble() else 10.0 res += ((0.25 - cardRatio) * MANY_CARDS_PENALTY).toInt() return res } 

  
  

  इसलिए, हमारे पास मूल्यांकन कार्य तैयार है। अगले भाग में, एक और दिलचस्प कार्य का वर्णन करने की योजना है - इस तरह के मूल्यांकन के आधार पर निर्णय लेना।

  
  

  ध्यान देने के लिए आप सभी का धन्यवाद!

  
  

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