चालों के बीच शतरंज के इंजन पहले से विश्लेषण किए गए सभी पदों को संग्रहीत करते हैं

Question

मैं शतरंज के इंजनों के साथ खेलना शुरू कर रहा हूं। मुझे लगता है कि सबसे अच्छा शतरंज इंजन को स्थानांतरित होने में कई मिनट लग सकते हैं। मैं सोच रहा हूँ क्यों। प्रत्येक चाल से पहले इंजन सभी कानूनी भविष्य की चालों की गहराई से जांच करता है। हालाँकि यह तब अगले कदम के लिए इस अभ्यास को दोहराने के लिए लगता है। यह देखते हुए कि पिछले चाल को पहले से ही चालित वृक्षों में शामिल किया गया था, क्या यह अक्षम नहीं है? या मुझे गलत समझा है?

[संपादित करें: मैं मान रहा हूं कि मूव एनालिसिस का कारण कैश नहीं है, यह कंप्यूटर की कुछ मेमोरी सीमाओं के कारण है जो अभी विश्लेषण को फिर से शुरू करने के लिए तेज करते हैं]

Answer 1

शतरंज इंजनों का प्रोग्रामिंग बहुत जटिल क्षेत्र है, इसलिए ठीक सामने मैं आपको शतरंज प्रोग्रामिंग विकी के बारे में बताता हूं , जिसमें इस विषय पर बहुत अधिक जानकारी है।

पृष्ठभूमि

शतरंज की गणना (और इसी तरह की कई चीजें) आमतौर पर "गेम ट्री" या " डिसीजन ट्री " के रूप में की जाती हैं। मोटे तौर पर, यह पेड़ एक निर्देशित ग्राफ है, जिसके शीर्ष पर एक नोड (वर्तमान स्थिति) है, जिससे प्रत्येक संभव चाल के लिए एक नोड होता है, जिनमें से प्रत्येक प्रत्येक अगले अगले कदम के लिए अधिक नोड की ओर जाता है , और इसी तरह।

उनके सबसे सरल, ब्रूट-फोर्स फॉर्म में, शतरंज इंजन इस पेड़ पर कुछ गहराई सीमा ("प्लाई") तक सभी स्थिति उत्पन्न करते हैं, कुछ जटिल मानदंडों ^{1 के} आधार पर प्रत्येक परिणामी स्थिति का मूल्यांकन करते हैं । फिर यह उस चाल को निभाता है जो सबसे अच्छे परिणाम की ओर ले जाता है। आजकल, बहुत सी जटिल तकनीकों को विकसित किया गया है कि इंजन को देखने के लिए कितने पदों को सीमित करना है, लेकिन मैं इस उत्तर के उद्देश्य के लिए उन लोगों को अनदेखा करने जा रहा हूं, क्योंकि वे वास्तविक मुद्दे को बदलते नहीं हैं हाथ।

गणित स्पर्शक

प्रत्येक चाल पर विचार करने के लिए आमतौर पर इंजन की समान मात्रा के बारे में जो मूल कारण होता है, वह यह है कि निर्णय वृक्ष का आकार गहराई ( k) के साथ तेजी से बढ़ता है ।

प्रारंभिक स्थिति पर विचार करें। पेड़ का शीर्ष ( k=0) एक नोड है। व्हाइट के लिए बीस संभव पहली चालें हैं, इसलिए गहराई पर बीस नोड हैं k=1। फिर, ब्लैक के पास व्हाइट के प्रत्येक विकल्प के लिए बीस उपलब्ध चालें हैं: इसलिए k=2, 20 * 20 = 400संभावित स्थान हैं! और यह केवल खराब हो जाता है क्योंकि खिलाड़ी अपने टुकड़ों को विकसित करते हैं!

उदाहरण के लिए, आइए दिखाते हैं कि किसी भी समय ² पर प्रत्येक खिलाड़ी के लिए हमेशा बीस संभव चालें हैं । आप कंप्यूटर को प्रत्येक खिलाड़ी (दस प्लाई) के लिए पाँच चालों को देखने का निर्देश देते हैं। आइए प्रत्येक स्तर पर जानवर बल के पेड़ के आकार को देखें। मज़े के लिए, हम पेड़ में कुल पदों की संख्या (ऊपर से दिए गए स्तर तक) को देखेंगे।

Ply |    Positions   |  Total Tree Size
----------------------------------------
 0  | 1              | 1
 1  | 20             | 21
 2  | 400            | 421
 3  | 8000           | 8421
 4  | 160000         | 168421
 5  | 3200000        | 3368421
 6  | 64000000       | 67368421
 7  | 1280000000     | 1347368421
 8  | 25600000000    | 26947368421
 9  | 512000000000   | 538947368421
10  | 10240000000000 | 10778947368421

प्रत्येक स्तर के पिछले स्तर की तुलना में तेजी से बड़ा होने का परिणाम यह है कि पूरे पेड़ का आकार नीचे के स्तर पर हावी है । ऊपर दिए गए उदाहरण पर विचार करें: अकेले अंतिम स्तर में दस ट्रिलियन नोड्स होते हैं। पूरे पेड़ में केवल पाँच सौ बिलियन होते हैं। दसवें प्लाई में पूरे पेड़ में लगभग 95% नोड्स होते हैं (यह वास्तव में प्रत्येक स्तर पर सच है)। व्यवहार में, इसका मतलब यह है कि सभी खोज समय "अंतिम" चाल का मूल्यांकन करने में बिताया जाता है।

उत्तर

तो यह आपके प्रश्न से कैसे संबंधित है? ठीक है, मान लें कि कंप्यूटर दस प्लाई पर सेट है, जैसा कि ऊपर है, और आगे यह अपने मूल्यांकन के परिणामों को "याद" करता है। यह एक चाल की गणना करता है, इसे खेलता है, और फिर आप एक चाल बनाते हैं। अब दो चालें बनाई गई हैं, इसलिए यह चाल से संबंधित मेमोरी से सभी पदों को चुभता है जो कि नहीं हुआ, और एक पेड़ के साथ छोड़ दिया जाता है जो शेष आठ चालों से नीचे चला जाता है जो पहले से ही गणना करता है: 26,947,368,421 स्थिति!

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

---

सरलीकरण अस्वीकरण

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

---

¹ मैं यहाँ हेयूरिस्टिक फ़ंक्शंस में नहीं जा रहा हूँ, क्योंकि यह अपना खुद का अविश्वसनीय जटिल क्षेत्र है, लेकिन अक्सर कुछ ऐसे लाभ होते हैं जिन्हें यहाँ स्थिति कैशिंग योजनाओं के माध्यम से भी प्राप्त किया जा सकता है।

² 20 की औसत ब्रांचिंग फैक्टर शायद बहुत कम है ।

Comments

बहुत दिलचस्प है, यह बताता है कि जब मेरे इंजन के साथ मैं गहराई से विश्लेषण कर रहा हूं तो मेरी रैम लगभग गिर गई है (एक रहस्य जो मुझे पिछले कुछ समय से खराब कर दिया था)।

— पाब्लो एस। ओकल

धन्यवाद! बहुत ही रोचक। मुझे शतरंज इंजन विकि चर्चा आकर्षक लगी।

— डोम

Answer 2

एक विशिष्ट शतरंज इंजन कुछ स्थान और उनके ब्रैकेटिंग अल्फा-बीटा स्कोर को एक ट्रांसपोज़न टेबल में संग्रहीत करेगा, जिसे बाद की खोजों के दौरान परामर्श दिया जा सकता है। इस तालिका में सीधे अगले कदम का चयन करने के लिए सलाह नहीं ली गई है, लेकिन यह उस खोज को दो तरीकों से अधिक कुशल बनाता है।

1. खोज ट्री में एक स्थिति का कई बार सामना किया जाएगा, जो चालों के अनुक्रम के ट्रांसपोज़िशन या क्रमपरिवर्तन द्वारा पहुँचा जा सकता है। क्योंकि तालिका से परामर्श किया जा सकता है, इस स्थिति को केवल दर्जनों बार (विभिन्न निश्चित खोज गहराई के लिए) मूल्यांकन करने की आवश्यकता हो सकती है, क्योंकि दर्जनों बार स्थिति का दौरा किया गया और फिर से देखा गया।

2. अल्फा-बीटा खोजों के लिए एक मानक तकनीक पुनरावृत्ति गहनता का उपयोग करना है , बार-बार पेड़ को अधिक से अधिक खोज गहराई पर जांचना जब तक टर्मिनल गहराई तक नहीं पहुंच जाता। पहले पुनरावृत्तियों में गणना किए गए मूल्यांकन स्कोर का उपयोग बाद के पुनरावृत्तियों में खोजे गए चालों को क्रम में करने के लिए किया जाता है। अल्फा-बीटा को बेहतर प्रदर्शन करने के लिए जाना जाता है (यानी खोज पेड़ की अधिकता) यदि खराब चाल से पहले अच्छी चालें खोजी जाती हैं।

Answer 3

इंजन की मेमोरी का उदाहरण देने वाला उदाहरण:

उन पदों पर विचार करें जहां गहरी सैद्धांतिक सस्ता माल की खोज की जाती है, विशेष रूप से कारुआना बनाम टोपालोव ने इस साल खेला है। जब आप इंजन को 12 या उससे कम समय के लिए स्थानांतरित करने के बाद स्थिति का विश्लेषण करते हैं (10-15 मिनट कहते हैं) आप सुझाए गए चालों की जांच कर सकते हैं और देख सकते हैं कि टीएन ( 13.Re2!) उनके बीच दिखाई नहीं देता है। अपने आप को चाल का परिचय दें, एक चाल वापस जाएँ और इंजन को कम से कम उसी समय के लिए फिर से उसी स्थिति का विश्लेषण करने दें। हैरानी की बात है, कुछ सोच के बाद, अब इंजन TN को सर्वश्रेष्ठ चालों में से मानता है और इसे मंजूरी देता है।

EDIT: मूल उत्तर (नीचे रखा गया) गलत है, हालांकि, यह इंजन की मेमोरी का एक उपयोगी उदाहरण प्रदान करता है, जिसे शीर्ष पर उद्धृत किया गया है।

जहां तक ​​मुझे पता है, वे नहीं करते हैं, अर्थात्, वे हर कदम पर खरोंच से लगभग पेड़ की खोज शुरू करते हैं।

हालाँकि, उनके पास किसी प्रकार का फ़ंक्शन होना चाहिए जो प्रत्येक चाल के लिए मूल्यों को महसूस करता है, और इस फ़ंक्शन में निश्चित रूप से कुछ अल्पकालिक मेमोरी है। कुछ उदाहरण ऐसे स्थान हैं जहां गहरी सैद्धांतिक सस्ता माल की खोज की जाती है, विशेष रूप से कारुआना बनाम टोपालोव ने इस साल खेला है। जब आप इंजन को 12 या उससे कम समय के लिए स्थानांतरित करने के बाद स्थिति का विश्लेषण करते हैं (10-15 मिनट कहते हैं) आप सुझाए गए चालों की जांच कर सकते हैं और देख सकते हैं कि टीएन ( 13.Re2!) उनके बीच दिखाई नहीं देता है। अपने आप को चाल का परिचय दें, एक चाल वापस जाएँ और इंजन को कम से कम उसी समय के लिए फिर से उसी स्थिति का विश्लेषण करने दें। हैरानी की बात है, कुछ सोच के बाद, अब इंजन TN को सर्वश्रेष्ठ चालों में से मानता है और इसे मंजूरी देता है।

मैं शतरंज सॉफ्टवेयर का कोई विशेषज्ञ नहीं हूं, लेकिन ऐसा होता है। यह कम से कम आंशिक रूप से समझाया जा सकता है यदि (जैसा कि कहा गया है) कि स्थिति के लिए चाल का मूल्यांकन करने वाले फ़ंक्शन में कुछ मेमोरी है।

Comments

नहीं इंजन खरोंच से पेड़ की खोज शुरू नहीं करते हैं। मेरे उत्तर का संदर्भ लें।

— हैलोवर्ल्ड

क्षमा करें, लेकिन मुझे लगता है कि आपका उत्तर थोड़ा भ्रामक है

— ब्लूट्रिन

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

— पाब्लो एस। ओकल

@ पाब्लो, आपका उदाहरण ठीक है। मेमोरी है क्योंकि पहली बार जब आप खोज चलाते हैं, तो इंजन एक टेबल में स्थिति मूल्यांकन संग्रहीत करता है। जब आप फिर से उसी स्थिति को खोजते हैं, तो इंजन बहुत तेजी से खोज करने में सक्षम होगा। इसलिए यह आपको एक अलग परिणाम देगा।

— हेलोवर्ल्ड

वह अंतिम संपादन @BlueTrin के लिए था, जिसने सोचा कि यह भ्रामक था।

— पाब्लो एस। ओकल

Answer 4

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

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

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

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

हमारे पास पदों को संग्रहीत करने के लिए अनंत स्मृति नहीं है। हमें एक हैशिंग एल्गोरिथ्म को परिभाषित करने की आवश्यकता होगी। Zobrist हैशिंग एल्गोरिथ्म हमें एक छद्म यादृच्छिक वितरण देता है, लेकिन जल्दी या बाद में हमें अभी भी कुछ मौजूदा प्रविष्टियों को बदलना होगा।

Answer 5

प्रत्येक इंजन की अपनी समय प्रबंधन योजना होती है। कुछ इंजन और GUI आपको उस गति को निर्धारित करने देते हैं जिस पर इंजन खेलेंगे। इंजन हमेशा गणना / मूल्यांकन / कम से कम उतना ही करते हैं जितना वे समय प्रबंधन उप-नियम या उपयोगकर्ता सेटिंग्स द्वारा लगाए गए अवरोधों को दे सकते हैं। यदि कोई इंजन लंबे समय तक सोचता है, तो यह संभव है क्योंकि खेल के लिए समय नियंत्रण एक धीमा है, या उपयोगकर्ता ने इसे धीरे-धीरे खेलने के लिए सेट किया है।

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

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

चूँकि हैश की मात्रा परिमित है, इसलिए एक इंजन को यह भी निर्णय लेना होता है कि वह अपने हैश से कौन सी सूचना हटाए क्योंकि यह नई जानकारी जोड़ता है। इंजन को पहले से पता नहीं है कि कौन सी चालें खेली जाएंगी, इसलिए यह अनजाने में उन जानकारियों को हटा सकती है जो उपयोगी होती क्योंकि यह नया डेटा जोड़ता है।

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