Policy Network विस्तृत विश्लेषण

गो की किसी भी स्थिति में, वैध चालों की औसत संख्या 250 है। यदि कंप्यूटर को यादृच्छिक रूप से चुनने दें, तो वह कभी भी अच्छी चाल नहीं चल पाएगा।

AlphaGo की सफलता इसमें है: उसने "एक नज़र में बोर्ड देखकर, यह जानना सीख लिया कि कौन सी स्थितियाँ विचार करने योग्य हैं"।

यह क्षमता Policy Network (रणनीति नेटवर्क) से आती है।

---

Policy Network क्या है?

मुख्य कार्य

Policy Network एक गहन convolutional neural network है, इसका कार्य है:

वर्तमान बोर्ड स्थिति दी गई, प्रत्येक स्थिति की चाल संभावना आउटपुट करें

गणितीय रूप में:

p = f_θ(s)

जहाँ:

• s: वर्तमान बोर्ड स्थिति (19×19 बोर्ड + अन्य विशेषताएँ)
• f_θ: Policy Network (θ नेटवर्क पैरामीटर हैं)
• p: 361 स्थितियों की संभावना वितरण (pass सहित)

सहज समझ

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

Policy Network इसी प्रक्रिया का अनुकरण कर रहा है।

載入中...

ऊपर का हीट मैप Policy Network का आउटपुट दिखाता है। जितना चमकीला रंग, उतना ही मॉडल उस स्थिति को महत्वपूर्ण मानता है।

Policy Network की आवश्यकता क्यों?

गो का खोज स्थान बहुत बड़ा है। यदि सभी संभावित चालों को बिना फ़िल्टर किए खोजें:

रणनीति	प्रति चाल विचारित चालें	10 चालों की खोज में नोड संख्या
सभी पर विचार	361	361^10 ≈ 10^25
Policy Network फ़िल्टर	~20	20^10 ≈ 10^13

Policy Network खोज स्थान को 10^12 गुना (एक ट्रिलियन गुना) कम कर देता है।

---

नेटवर्क वास्तुकला

समग्र संरचना

AlphaGo का Policy Network गहन convolutional neural network (CNN) वास्तुकला अपनाता है:

इनपुट परत → Convolutional परत ×12 → आउटपुट Convolutional परत → Softmax
   ↓         ↓            ↓           ↓
19×19×48   19×19×192   19×19×1     362 संभावनाएँ

इनपुट परत

इनपुट एक 19×19×48 विशेषता tensor है:

• 19×19: बोर्ड आकार
• 48: 48 विशेषता प्लेन (विवरण के लिए इनपुट विशेषता डिज़ाइन देखें)

ये 48 प्लेन में शामिल हैं:

• काले पत्थरों की स्थिति, सफेद पत्थरों की स्थिति
• हाल की 8 चालों का इतिहास
• साँसें, अतारी, लैडर आदि विशेषताएँ
• वैधता (कहाँ चाल चल सकते हैं)

Convolutional परतें

नेटवर्क में 12 convolutional परतें हैं, प्रत्येक परत की कॉन्फ़िगरेशन:

पैरामीटर	मान	विवरण
फ़िल्टर संख्या	192	प्रत्येक परत 192 विशेषता मैप आउटपुट करती है
कर्नेल आकार	3×3 (पहली परत 5×5)	हर बार 3×3 क्षेत्र देखें
पैडिंग विधि	same	19×19 आकार बनाए रखें
सक्रियण फ़ंक्शन	ReLU	max(0, x)

192 फ़िल्टर क्यों?

यह एक अनुभवजन्य मान है। बहुत कम मॉडल क्षमता को सीमित करेगा, बहुत अधिक गणना लागत और overfitting जोखिम बढ़ाएगा। DeepMind टीम ने प्रयोगों द्वारा 192 को एक अच्छा संतुलन बिंदु निर्धारित किया।

3×3 convolutional कर्नेल क्यों?

3×3 convolutional neural networks में सबसे आम आकार है, कारण:

1. स्थानीय पैटर्न पकड़ने के लिए पर्याप्त: गो में आँख, कनेक्ट, कट सभी 3×3 सीमा में हैं
2. गणना दक्षता: बड़े कर्नेल की तुलना में, 3×3 में कम पैरामीटर हैं
3. स्टैक करने योग्य: कई 3×3 convolutions बड़े receptive field प्राप्त कर सकते हैं

पहली परत 5×5 क्यों?

पहली परत बड़ा 5×5 convolutional कर्नेल उपयोग करती है, इनपुट परत पर ही थोड़े बड़े पैटर्न (जैसे छोटी उड़ान, कूद) पकड़ने के लिए। यह एक डिज़ाइन विकल्प है, बाद के AlphaGo Zero ने एकीकृत रूप से 3×3 उपयोग किया।

ReLU सक्रियण फ़ंक्शन

प्रत्येक convolutional परत के बाद ReLU (Rectified Linear Unit) सक्रियण फ़ंक्शन:

ReLU(x) = max(0, x)

ReLU क्यों?

1. सरल गणना: केवल अधिकतम लेना, sigmoid से बहुत तेज़
2. ग्रेडिएंट vanishing कम करना: सकारात्मक क्षेत्र में ग्रेडिएंट हमेशा 1
3. विरल सक्रियण: ऋणात्मक मान शून्य हो जाते हैं, विरल प्रतिनिधित्व उत्पन्न

आउटपुट परत

अंतिम परत एक विशेष convolutional परत है:

19×19×192 → Convolution(1×1, 1 फ़िल्टर) → 19×19×1 → समतल → 362 आयामी वेक्टर → Softmax

1×1 Convolution

आउटपुट परत 1×1 convolution उपयोग करती है, 192 चैनलों को 1 में संपीड़ित करने के लिए। यह प्रत्येक स्थिति के 192-आयामी विशेषता पर रैखिक संयोजन के बराबर है।

Softmax आउटपुट

362-आयामी वेक्टर (361 बोर्ड स्थितियाँ + 1 pass) Softmax फ़ंक्शन से गुज़रता है:

Softmax(z_i) = exp(z_i) / Σ_j exp(z_j)

Softmax सुनिश्चित करता है कि आउटपुट वैध संभावना वितरण है:

• सभी मान 0 और 1 के बीच
• सभी मानों का योग 1

पैरामीटर संख्या

नेटवर्क की कुल पैरामीटर संख्या की गणना करें:

परत	गणना	पैरामीटर संख्या
पहली convolutional परत	5×5×48×192 + 192	230,592
मध्य convolutional परतें ×11	(3×3×192×192 + 192) × 11	3,633,792
आउटपुट convolutional परत	1×1×192×1 + 1	193
कुल		~3.9M

लगभग 3.9 मिलियन पैरामीटर, आज के मानकों से एक छोटा नेटवर्क।

---

प्रशिक्षण उद्देश्य और विधि

प्रशिक्षण डेटा

Policy Network सुपरवाइज्ड लर्निंग का उपयोग करता है, मानव गेम रिकॉर्ड से सीखता है।

डेटा स्रोत:

• KGS Go Server: शौकिया और पेशेवर खिलाड़ियों के खेल
• लगभग 30 मिलियन स्थितियाँ: 160,000 खेलों से नमूने
• लेबल: प्रत्येक स्थिति के लिए मानव की अगली चाल

Cross-Entropy हानि फ़ंक्शन

प्रशिक्षण का उद्देश्य मानव चाल की भविष्यवाणी संभावना को अधिकतम करना है। Cross-entropy हानि फ़ंक्शन का उपयोग:

L(θ) = -Σ log p_θ(a | s)

जहाँ:

• s: बोर्ड स्थिति
• a: मानव की वास्तविक चाल स्थिति
• p_θ(a | s): मॉडल द्वारा उस स्थिति की भविष्यवाणी संभावना

सहज समझ

Cross-entropy हानि का एक सरल अर्थ है:

जब मॉडल सही स्थिति की संभावना जितनी अधिक भविष्यवाणी करता है, हानि उतनी कम

यदि मानव K10 पर चला, और मॉडल K10 को संभावना देता है:

• 0.9 → हानि = -log(0.9) ≈ 0.1 (बहुत कम, अच्छा)
• 0.1 → हानि = -log(0.1) ≈ 2.3 (बहुत अधिक, खराब)
• 0.01 → हानि = -log(0.01) ≈ 4.6 (बहुत अधिक, बहुत खराब)

प्रशिक्षण प्रक्रिया

# छद्म कोड
for epoch in range(num_epochs):
    for batch in dataloader:
        states, actions = batch

        # फॉरवर्ड पास
        policy = network(states)  # 361 आयामी संभावना वेक्टर

        # हानि गणना (cross-entropy)
        loss = cross_entropy(policy, actions)

        # बैकवर्ड पास
        loss.backward()
        optimizer.step()

प्रशिक्षण विवरण:

• ऑप्टिमाइज़र: SGD with momentum
• लर्निंग रेट: प्रारंभिक 0.003, धीरे-धीरे कम
• बैच आकार: 16
• प्रशिक्षण समय: लगभग 3 सप्ताह (50 GPUs)

डेटा संवर्धन

गो बोर्ड में 8 समरूपताएँ हैं (4 रोटेशन × 2 मिरर)। प्रत्येक प्रशिक्षण नमूने को 8 समतुल्य नमूनों में बदला जा सकता है:

मूल → 90° रोटेशन → 180° रोटेशन → 270° रोटेशन
  ↓       ↓         ↓          ↓
क्षैतिज फ्लिप → ...

इससे प्रभावी प्रशिक्षण डेटा 8 गुना बढ़ जाता है, और सुनिश्चित होता है कि मॉडल द्वारा सीखे गए पैटर्न दिशा पर निर्भर न हों।

---

प्रशिक्षण परिणाम

57% सटीकता

प्रशिक्षण के बाद, Policy Network 57% top-1 सटीकता प्राप्त करता है।

इसका अर्थ है: किसी भी स्थिति में, मॉडल के पास 57% संभावना है कि वह वही चाल भविष्यवाणी करे जो मानव विशेषज्ञ ने वास्तव में चली।

क्या यह सटीकता उच्च है?

यह देखते हुए कि प्रत्येक स्थिति में औसतन 250 वैध चालें हैं, यादृच्छिक अनुमान की सटीकता केवल 0.4% है।

विधि	Top-1 सटीकता
यादृच्छिक अनुमान	0.4%
पिछला सबसे मजबूत कंप्यूटर गो	~44%
AlphaGo Policy Network	57%

13 प्रतिशत अंक की वृद्धि, ज्यादा नहीं लगती, लेकिन महत्वपूर्ण है।

खेल शक्ति में वृद्धि

केवल Policy Network (बिना खोज के) से खेलने पर, कौन सी शक्ति प्राप्त होती है?

कॉन्फ़िगरेशन	Elo रेटिंग	लगभग स्तर
पिछला सबसे मजबूत प्रोग्राम (Pachi)	2,500	शौकिया 4-5 दान
केवल Policy Network	2,800	शौकिया 6-7 दान
+ MCTS 1600 सिमुलेशन	3,200+	पेशेवर स्तर

अकेला Policy Network पहले से शौकिया उच्च दान है, MCTS जोड़ने पर पेशेवर स्तर पर पहुँच जाता है।

केवल 57% क्यों?

मानव गेम रिकॉर्ड की निम्न विशेषताएँ सटीकता को सीमित करती हैं:

1. कई अच्छी चालें

कई स्थितियों में कई चालें अच्छी हैं। उदाहरण के लिए "अप्रोच" और "डिफेंड कॉर्नर" दोनों सही विकल्प हो सकते हैं। मॉडल ने दूसरी अच्छी चाल चुनी, तो "गलत" गिनी जाएगी।

2. शैली अंतर

अलग-अलग खिलाड़ियों की अलग शैली होती है। आक्रामक और स्थिर खिलाड़ी एक ही स्थिति में अलग चाल चल सकते हैं। मॉडल "औसत" शैली सीखता है।

3. मानव भी गलती करते हैं

KGS डेटा में शौकिया खिलाड़ियों के खेल शामिल हैं, उनके विकल्प हमेशा सर्वोत्तम नहीं होते। मॉडल कुछ "गलतियाँ" सीखना सामान्य है।

---

MCTS में भूमिका

Policy Network AlphaGo के MCTS में दो महत्वपूर्ण भूमिकाएँ निभाता है:

1. खोज दिशा निर्देशित करना

MCTS के Selection चरण में, Policy Network का आउटपुट UCB (Upper Confidence Bound) गणना के लिए उपयोग होता है:

UCB(s, a) = Q(s, a) + c_puct × P(s, a) × √(N(s)) / (1 + N(s, a))

जहाँ P(s, a) Policy Network द्वारा दी गई संभावना है।

इसका अर्थ है:

• उच्च संभावना वाली चालें पहले खोजी जाती हैं
• कम संभावना वाली चालों को भी खोजने का अवसर (अन्वेषण पद के कारण)

2. नोड विस्तार के लिए प्रायर

जब MCTS एक नया नोड विस्तारित करता है, Policy Network सभी चाइल्ड नोड्स के लिए प्रायर संभावना प्रदान करता है।

नोड s विस्तारित करें:
  for each action a:
    child = Node()
    child.prior = policy_network(s)[a]  # प्रायर संभावना
    child.value = 0
    child.visits = 0

ये प्रायर संभावनाएँ MCTS को "जानने" देती हैं कि कौन से चाइल्ड नोड अधिक खोजने योग्य हैं, भले ही उन्हें अभी तक विज़िट नहीं किया गया हो।

---

लाइटवेट vs पूर्ण संस्करण

AlphaGo में वास्तव में दो Policy Network हैं:

पूर्ण संस्करण (SL Policy Network)

• वास्तुकला: 13 परत CNN, 192 filters
• सटीकता: 57%
• इनफरेंस समय: लगभग 3 मिलीसेकंड/स्थिति
• उपयोग: MCTS में Selection और Expansion

लाइटवेट संस्करण (Rollout Policy Network)

• वास्तुकला: लीनियर मॉडल + हस्तनिर्मित विशेषताएँ
• सटीकता: 24%
• इनफरेंस समय: लगभग 2 माइक्रोसेकंड/स्थिति (1500 गुना तेज़)
• उपयोग: तेज़ सिमुलेशन (rollout)

लाइटवेट संस्करण की आवश्यकता क्यों?

MCTS के Simulation चरण में, वर्तमान नोड से खेल समाप्त होने तक चलना होता है, जिसमें 100+ चालें लग सकती हैं। यदि प्रत्येक चाल के लिए पूर्ण Policy Network उपयोग करें, तो बहुत धीमा।

लाइटवेट संस्करण की सटीकता केवल 24% है, लेकिन 1500 गुना तेज़ है। Rollout में, गति सटीकता से अधिक महत्वपूर्ण है।

लाइटवेट संस्करण की विशेषताएँ

लाइटवेट संस्करण हस्तनिर्मित विशेषताएँ उपयोग करता है, जिसमें शामिल हैं:

विशेषता प्रकार	उदाहरण
स्थानीय पैटर्न	3×3 क्षेत्र में पत्थर कॉन्फ़िगरेशन
वैश्विक विशेषताएँ	कॉर्नर में है या नहीं, बड़ा बिंदु
रणनीतिक विशेषताएँ	अतारी, लैडर, कनेक्शन

इन विशेषताओं को एक लीनियर मॉडल (बिना छिपी परत) में इनपुट किया जाता है, गणना बहुत तेज़।

AlphaGo Zero का सुधार

बाद के AlphaGo Zero ने लाइटवेट संस्करण और rollout को पूर्णतः त्याग दिया। यह सीधे Value Network से लीफ नोड मूल्यांकन करता है, तेज़ सिमुलेशन की आवश्यकता नहीं। यह एक बड़ा सरलीकरण है।

---

रीइन्फोर्समेंट लर्निंग फाइन-ट्यूनिंग (RL Policy Network)

सुपरवाइज्ड लर्निंग की सीमाएँ

सुपरवाइज्ड लर्निंग से प्रशिक्षित Policy Network में एक मूलभूत समस्या है:

यह "मानव की नकल" सीखता है, "जीतना" नहीं

इसका अर्थ है यह मानव की बुरी आदतें सीखेगा, और उन स्थितियों में खराब प्रदर्शन करेगा जो मानव ने कभी नहीं देखीं।

सेल्फ-प्ले रीइन्फोर्समेंट

DeepMind का समाधान Policy Gradient विधि से रीइन्फोर्समेंट लर्निंग है:

1. Policy Network को स्वयं से खेलने दें
2. प्रत्येक खेल की सभी चालें रिकॉर्ड करें
3. जीत-हार के अनुसार पैरामीटर समायोजित करें:
   - जीता → इन चालों की संभावना बढ़ाएँ
   - हारा → इन चालों की संभावना घटाएँ

REINFORCE एल्गोरिथम

विशेष रूप से REINFORCE एल्गोरिथम उपयोग:

∇J(θ) = E[Σ_t ∇log π_θ(a_t | s_t) × z]

जहाँ:

• z: इस खेल का परिणाम (+1 जीत, -1 हार)
• π_θ(a_t | s_t): स्थिति s_t पर क्रिया a_t चुनने की संभावना

परिणाम

लगभग 1 दिन की सेल्फ-प्ले प्रशिक्षण (1.28 मिलियन खेल) के बाद, RL Policy Network:

मेट्रिक	SL Policy	RL Policy
SL Policy के खिलाफ	50%	80%
Elo वृद्धि	-	+100

सटीकता थोड़ी कम हो सकती है (क्योंकि अब पूर्णतः मानव की नकल नहीं), लेकिन वास्तविक जीत दर बहुत बढ़ जाती है।

"नकल" से "नवाचार" तक

रीइन्फोर्समेंट लर्निंग Policy Network को कुछ ऐसी चालें सिखाती है जो मानव ने कभी नहीं सोचीं। ये चालें प्रशिक्षण डेटा में कभी नहीं दिखीं, लेकिन प्रभावी हैं।

इसीलिए AlphaGo "दिव्य चाल" चल सकता है—यह मानव अनुभव से सीमित नहीं है।

---

विज़ुअल विश्लेषण

विभिन्न स्थितियों का संभावना वितरण

आइए देखें Policy Network विभिन्न स्थितियों में क्या आउटपुट देता है:

ओपनिंग (फुसेकी चरण)

載入中...

ओपनिंग में, संभावना मुख्य रूप से केंद्रित है:

• कॉर्नर में (कॉर्नर लेना)
• किनारे पर (अप्रोच, डिफेंड कॉर्नर)
• "बड़े बिंदु" स्थितियों पर

यह गो के मूल सिद्धांत से मेल खाता है: गोल्डन कॉर्नर, सिल्वर एज, ग्रास बेली।

लड़ाई की स्थिति

載入中...

लड़ाई में, संभावना केंद्रित है:

• महत्वपूर्ण कट बिंदुओं पर
• अतारी, कनेक्शन पर
• आँख बनाना, आँख तोड़ना

यह दिखाता है मॉडल ने स्थानीय रणनीति सीखी।

योसे चरण

載入中...

योसे में, संभावना विभिन्न योसे बिंदुओं पर फैली होती है, सटीक अंक गणना की आवश्यकता।

छिपी परतें क्या सीखती हैं?

Convolutional परत आउटपुट को विज़ुअलाइज़ करके, हम मॉडल द्वारा सीखी गई "विशेषताएँ" देख सकते हैं:

• निचली परतें: मूल आकार (आँख, कट बिंदु)
• मध्य परतें: रणनीतिक पैटर्न (अतारी, लैडर)
• ऊपरी परतें: वैश्विक अवधारणाएँ (प्रभाव, मोटाई)

यह गो को समझने की मानव संज्ञानात्मक पदानुक्रम से बहुत मिलता है।

---

कार्यान्वयन बिंदु

PyTorch कार्यान्वयन

यहाँ एक सरलीकृत Policy Network कार्यान्वयन है:

import torch
import torch.nn as nn
import torch.nn.functional as F

class PolicyNetwork(nn.Module):
    def __init__(self, input_channels=48, num_filters=192, num_layers=12):
        super().__init__()

        # पहली convolutional परत (5×5)
        self.conv1 = nn.Conv2d(input_channels, num_filters,
                               kernel_size=5, padding=2)

        # मध्य convolutional परतें (3×3)×11
        self.conv_layers = nn.ModuleList([
            nn.Conv2d(num_filters, num_filters,
                     kernel_size=3, padding=1)
            for _ in range(num_layers - 1)
        ])

        # आउटपुट convolutional परत (1×1)
        self.conv_out = nn.Conv2d(num_filters, 1, kernel_size=1)

    def forward(self, x):
        # x: (batch, 48, 19, 19)

        # पहली परत
        x = F.relu(self.conv1(x))

        # मध्य परतें
        for conv in self.conv_layers:
            x = F.relu(conv(x))

        # आउटपुट परत
        x = self.conv_out(x)  # (batch, 1, 19, 19)

        # समतल + Softmax
        x = x.view(x.size(0), -1)  # (batch, 361)
        x = F.softmax(x, dim=1)

        return x

प्रशिक्षण लूप

def train_step(model, optimizer, states, actions):
    """
    states: (batch, 48, 19, 19) - बोर्ड विशेषताएँ
    actions: (batch,) - मानव की चाल स्थिति (0-360)
    """
    # फॉरवर्ड पास
    policy = model(states)  # (batch, 361)

    # Cross-entropy हानि
    loss = F.cross_entropy(
        torch.log(policy + 1e-8),  # log(0) रोकें
        actions
    )

    # बैकवर्ड पास
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # सटीकता गणना
    predictions = policy.argmax(dim=1)
    accuracy = (predictions == actions).float().mean()

    return loss.item(), accuracy.item()

इनफरेंस समय ध्यान देने योग्य बातें

वास्तविक खेल में, ध्यान देना चाहिए:

1. अवैध चालें फ़िल्टर करें: अवैध स्थितियों की संभावना 0 करें, फिर पुनः सामान्यीकरण
2. तापमान समायोजन: तापमान पैरामीटर से संभावना वितरण की "तीक्ष्णता" नियंत्रित करें
3. बैच इनफरेंस: MCTS में कई स्थितियों को एक साथ प्रोसेस करें

def get_move_probabilities(model, state, legal_moves, temperature=1.0):
    """वैध चालों की संभावना वितरण प्राप्त करें"""
    policy = model(state)  # (361,)

    # केवल वैध चालें रखें
    mask = torch.zeros(361)
    mask[legal_moves] = 1
    policy = policy * mask

    # तापमान समायोजन
    if temperature != 1.0:
        policy = policy ** (1 / temperature)

    # पुनः सामान्यीकरण
    policy = policy / policy.sum()

    return policy

---

एनिमेशन संदर्भ

इस लेख की मुख्य अवधारणाएँ और एनिमेशन नंबर:

नंबर	अवधारणा	भौतिकी/गणित संदर्भ
🎬 E1	Policy Network	संभावना क्षेत्र
🎬 D9	CNN विशेषता निष्कर्षण	फ़िल्टर प्रतिक्रिया
🎬 D3	सुपरवाइज्ड लर्निंग	अधिकतम संभावना अनुमान
🎬 H4	Policy Gradient	स्टोकेस्टिक ऑप्टिमाइज़ेशन

---

आगे पढ़ें

• अगला लेख: Value Network विस्तृत विश्लेषण — AlphaGo स्थिति का मूल्यांकन कैसे करता है
• संबंधित विषय: इनपुट विशेषता डिज़ाइन — 48 विशेषता प्लेन विस्तृत विश्लेषण
• गहन सिद्धांत: CNN और गो का संयोजन — Convolutional neural network बोर्ड के लिए क्यों उपयुक्त

---

मुख्य बिंदु

1. Policy Network संभावना वितरण जनरेटर है: बोर्ड इनपुट करें, 361 स्थितियों की संभावना आउटपुट
2. 13 परत CNN + Softmax: गहन convolution विशेषता निष्कर्षण, Softmax संभावना आउटपुट
3. 57% सटीकता: पिछले कंप्यूटर गो प्रोग्राम से बहुत आगे
4. दो संस्करण: पूर्ण संस्करण MCTS निर्णय के लिए, लाइटवेट संस्करण तेज़ सिमुलेशन के लिए
5. रीइन्फोर्समेंट लर्निंग फाइन-ट्यूनिंग: "मानव की नकल" से "जीत की खोज" तक

Policy Network AlphaGo की "सहज बुद्धि" है—यह AI को मानव की तरह, जल्दी से विचार करने योग्य चालें पहचानने देता है।

---

संदर्भ

1. Silver, D., et al. (2016). "Mastering the game of Go with deep neural networks and tree search." Nature, 529, 484-489.
2. Maddison, C. J., et al. (2014). "Move Evaluation in Go Using Deep Convolutional Neural Networks." arXiv:1412.6564.
3. Sutton, R. S., & Barto, A. G. (2018). Reinforcement Learning: An Introduction. MIT Press.
4. LeCun, Y., Bengio, Y., & Hinton, G. (2015). "Deep learning." Nature, 521, 436-444.