माउंटेन कार: सुदृढीकरण प्रशिक्षण के साथ क्लासिक चुनौती का समाधान

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

अपने बारे में

मेरा नाम ओलेग Svidchenko है, अब मैं सेंट पीटर्सबर्ग एचएसई के शारीरिक, गणितीय और कंप्यूटर विज्ञान के स्कूल में पढ़ रहा हूं, इससे पहले मैंने तीन साल के लिए सेंट पीटर्सबर्ग विश्वविद्यालय में अध्ययन किया था। मैं एक शोधकर्ता के रूप में जेटब्रेन्स रिसर्च में भी काम करता हूं। विश्वविद्यालय में प्रवेश करने से पहले, मैंने मॉस्को स्टेट यूनिवर्सिटी के एसएससी में अध्ययन किया और मॉस्को टीम के हिस्से के रूप में कंप्यूटर विज्ञान में स्कूली बच्चों के ऑल-रूसी ओलंपियाड का विजेता बन गया।

हमें क्या चाहिए?

यदि आप सुदृढीकरण प्रशिक्षण की कोशिश करने में रुचि रखते हैं, तो माउंटेन कार चुनौती इसके लिए महान है। आज हमें स्थापित जिम और प्योरटेक पुस्तकालयों के साथ-साथ तंत्रिका नेटवर्क के बुनियादी ज्ञान के साथ अजगर की आवश्यकता है।

कार्य विवरण

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

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

सिद्धांत की बिट

Habré पर पहले से ही DQN के बारे में एक लेख था जिसमें लेखक ने सभी आवश्यक सिद्धांत का अच्छी तरह से वर्णन किया था। फिर भी, पढ़ने में आसानी के लिए, मैं इसे और अधिक औपचारिक रूप में यहां दोहराऊंगा।

सुदृढीकरण सीखने का कार्य राज्य अंतरिक्ष एस, एक्शन स्पेस ए, गुणांक के एक सेट द्वारा परिभाषित किया गया है $$$गामा$, ट्रांज़िशन फ़ंक्शंस T और रिवार्ड फ़ंक्शंस R. सामान्य तौर पर, ट्रांज़िशन फ़ंक्शन और रिवॉर्ड फ़ंक्शन यादृच्छिक चर हो सकते हैं, लेकिन अब हम एक सरल संस्करण पर विचार करेंगे जिसमें वे विशिष्ट रूप से परिभाषित हैं। लक्ष्य संचयी पुरस्कार को अधिकतम करना है। $$$\ sum_ {t = 0} ^ {T} r_ {t} \ cdot \ Gamma ^ {t}$, जहां t माध्यम में चरण संख्या है, और T प्रकरण में चरणों की संख्या है।

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

व्यवहार में, हम वास्तविक क्यू-फ़ंक्शन को नहीं जानते हैं, लेकिन हम इसे विभिन्न तरीकों से अनुमानित कर सकते हैं। ऐसी ही एक तकनीक है डीप क्यू नेटवर्क (DQN)। उनका विचार है कि प्रत्येक क्रिया के लिए हम एक तंत्रिका नेटवर्क का उपयोग करते हुए क्यू-फ़ंक्शन का अनुमान लगाते हैं।

पर्यावरण

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

import gym env = gym.make("MountainCar-v0") 

विस्तृत प्रलेखन यहाँ पाया जा सकता है , और पर्यावरण का विवरण यहाँ पाया जा सकता है ।
आइए हम और अधिक विस्तार से विचार करें कि हमारे द्वारा बनाए गए पर्यावरण के साथ हम क्या कर सकते हैं:

• env.reset() - वर्तमान एपिसोड को समाप्त करता है और एक नई शुरुआत करता है। प्रारंभिक अवस्था लौटाता है।
• env.step(action) - निर्दिष्ट क्रिया करता है। एक नया राज्य लौटाता है, एक इनाम, चाहे एपिसोड समाप्त हो गया हो और अतिरिक्त जानकारी जो डीबग के लिए उपयोग की जा सकती है।
• env.seed(seed) - यादृच्छिक बीज सेट करता है। यह इस बात पर निर्भर करता है कि env.reset () के दौरान प्रारंभिक स्थिति कैसे उत्पन्न होगी।
• env.render() - पर्यावरण की वर्तमान स्थिति को प्रदर्शित करता है।

हमें DQN का एहसास है

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

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

 import torch.nn as nn model = nn.Sequential( nn.Linear(2, 32), nn.ReLU(), nn.Linear(32, 32), nn.ReLU(), nn.Linear(32, 3) ) target_model = copy.deepcopy(model) #    def init_weights(layer): if type(layer) == nn.Linear: nn.init.xavier_normal(layer.weight) model.apply(init_weights) 

चूँकि हम GPU पर तंत्रिका नेटवर्क को प्रशिक्षित करेंगे, इसलिए हमें अपना नेटवर्क वहाँ लोड करना होगा:

 #     CPU,  “cuda”    “cpu” device = torch.device("cuda") model.to(device) target_model.to(device) 

डिवाइस चर वैश्विक होगा, क्योंकि हमें डेटा लोड करने की भी आवश्यकता होगी।

हमें एक ऑप्टिमाइज़र को भी परिभाषित करने की आवश्यकता है जो क्रमिक वंश का उपयोग करके मॉडल भार को अपडेट करेगा। हां, एक से बढ़कर एक हैं।

 optimizer = optim.Adam(model.parameters(), lr=0.00003) 

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

 state, action, reward, next_state, done = batch #       state = torch.tensor(state).to(device).float() next_state = torch.tensor(next_state).to(device).float() reward = torch.tensor(reward).to(device).float() action = torch.tensor(action).to(device) done = torch.tensor(done).to(device) 

अगला, हमें क्यू-फ़ंक्शन के वास्तविक मूल्यों की गणना करने की आवश्यकता है, हालांकि, चूंकि हम उन्हें नहीं जानते हैं, हम निम्नलिखित राज्य के लिए मूल्यों के माध्यम से उनका मूल्यांकन करेंगे:

 target_q = torch.zeros(reward.size()[0]).float().to(device) with torch.no_grad(): #     Q-function    target_q = target_model(next_state).max(1)[0].view(-1) target_q[done] = 0 target_q = reward + target_q * gamma 

और वर्तमान भविष्यवाणी:

 q = model(state).gather(1, action.unsqueeze(1)) 

Target_q और q का उपयोग करते हुए, हम नुकसान फ़ंक्शन की गणना करते हैं और मॉडल को अपडेट करते हैं:

 loss = F.smooth_l1_loss(q, target_q.unsqueeze(1)) #      optimizer.zero_grad() #     loss.backward() #   . ,       for param in model.parameters(): param.grad.data.clamp_(-1, 1) #    optimizer.step() 

चूंकि मॉडल केवल क्यू-फ़ंक्शन पर विचार करता है, और क्रियाएं नहीं करता है, हमें फ़ंक्शन को निर्धारित करने की आवश्यकता है जो यह तय करेगा कि एजेंट कौन से कार्य करेगा। निर्णय लेने वाले एल्गोरिथ्म के रूप में, हम लेते हैं $$$\ _ varepsilon$-विभिन्न राजनीति। उनका विचार है कि एजेंट आमतौर पर लालच से क्रिया करता है, क्यू-फ़ंक्शन का अधिकतम चयन करता है, लेकिन संभावना के साथ $$$\ _ varepsilon$वह एक यादृच्छिक कार्रवाई करेगा। यादृच्छिक क्रियाओं की आवश्यकता होती है ताकि एल्गोरिथ्म उन कार्यों की जांच कर सके कि यह केवल एक लालची नीति द्वारा निर्देशित नहीं किया गया था - इस प्रक्रिया को अन्वेषण कहा जाता है।

 def select_action(state, epsilon, model): if random.random() < epsilon: return random.randint(0, 2) return model(torch.tensor(state).to(device).float().unsqueeze(0))[0].max(0)[1].view(1, 1).item() 

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

 class Memory: def __init__(self, capacity): self.capacity = capacity self.memory = [] self.position = 0 def push(self, element): """    """ if len(self.memory) < self.capacity: self.memory.append(None) self.memory[self.position] = element self.position = (self.position + 1) % self.capacity def sample(self, batch_size): """    """ return list(zip(*random.sample(self.memory, batch_size))) def __len__(self): return len(self.memory) 

अच्छा निर्णय

सबसे पहले, स्थिरांक घोषित करें जिसे हम सीखने की प्रक्रिया में उपयोग करेंगे, और एक मॉडल बनाएंगे:

 #  model   target model target_update = 1000 #  ,      batch_size = 128 #   max_steps = 100001 #  exploration max_epsilon = 0.5 min_epsilon = 0.1 #    memory = Memory(5000) model, target_model, optimizer = create_new_model() 

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

आइए अधिक विस्तार से बात करें कि सीखने का एक चरण यहां कैसा दिखता है। हम मान लेते हैं कि अब हम कदम-दर-कदम कदम बढ़ा रहे हैं। फिर साथ क्रिया करना $$$\ _ varepsilon$लालची नीतियां इस तरह दिखेंगी:

 epsilon = max_epsilon - (max_epsilon - min_epsilon)* step / max_steps action = select_action(state, epsilon, model) new_state, reward, done, _ = env.step(action) 

तुरंत प्राप्त अनुभव को मेमोरी में जोड़ें और यदि वर्तमान में समाप्त हो गया है तो एक नया एपिसोड शुरू करें:

 memory.push((state, action, reward, new_state, done)) if done: state = env.reset() done = False else: state = new_state 

और हम ढाल वंश का कदम उठाएंगे (यदि, ज़ाहिर है, हम पहले से ही कम से कम एक बैच एकत्र कर सकते हैं):

 if step > batch_size: fit(memory.sample(batch_size), model, target_model, optimizer) 

अब यह target_model को अपडेट करने के लिए बना हुआ है:

 if step % target_update == 0: target_model = copy.deepcopy(model) 

हालाँकि, हम सीखने की प्रक्रिया का भी पालन करना चाहेंगे। ऐसा करने के लिए, हम epsilon = 0 के साथ target_model के प्रत्येक अपडेट के बाद एक अतिरिक्त एपिसोड खेलेंगे, जिससे पुरस्कार में कुल पुरस्कार_बीज_टार्गेट_अपडेट्स बफर जमा हो जाता है:

 if step % target_update == 0: target_model = copy.deepcopy(model) state = env.reset() total_reward = 0 while not done: action = select_action(state, 0, target_model) state, reward, done, _ = env.step(action) total_reward += reward done = False state = env.reset() rewards_by_target_updates.append(total_reward) 

इस कोड को चलाएं और इस ग्राफ़ की तरह कुछ प्राप्त करें:

क्या गलत हुआ?

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

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

तेजी से अभिसरण

हमारा सहज ज्ञान हमें बताता है कि पहाड़ी को चलाने के लिए आपको तेजी लाने की आवश्यकता है। उच्च गति, समस्या को हल करने के लिए एजेंट के करीब। आप उसे इस बारे में बता सकते हैं, उदाहरण के लिए, इनाम के लिए एक निश्चित गुणांक के साथ गति मॉड्यूल जोड़कर:

  संशोधित_रूप = इनाम + 10 * एब्स (new_state [1]) 

तदनुसार, फ़ंक्शन में एक पंक्ति फिट होती है

  मेमोरी। पश (राज्य, क्रिया, इनाम, new_state, किया हुआ)) 

द्वारा प्रतिस्थापित किया जाना चाहिए

  मेमोरी। पप (राज्य, क्रिया, संशोधित_आग, new_state, किया)) 

अब नए चार्ट को देखें (यह बिना संशोधनों के मूल पुरस्कार प्रस्तुत करता है):


यहां आरएस रिवॉर्ड शेपिंग के लिए छोटा है।

क्या ऐसा करना अच्छा है?

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

शुरू करने के लिए, हम समझते हैं कि हमारे मामले में "अच्छाई" का क्या मतलब है। समस्या को हल करते हुए, हम इष्टतम नीति खोजने की कोशिश कर रहे हैं - एक जो एपिसोड के लिए कुल इनाम को अधिकतम करता है। इस मामले में, हम शब्द "अच्छा" को "इष्टतम" शब्द से बदल सकते हैं, क्योंकि हम इसकी तलाश कर रहे हैं। हम आशावादी रूप से यह भी आशा करते हैं कि जितनी जल्दी या बाद में हमारा DQN संशोधित समस्या के लिए इष्टतम समाधान ढूंढेगा, और एक स्थानीय अधिकतम पर अटक न जाए। तो, इस प्रश्न को निम्नानुसार सुधार किया जा सकता है: यदि इनाम के कार्य को बदलते हुए, हमने समस्या को स्वयं भी बदल दिया, तो क्या नई समस्या का इष्टतम समाधान हमें पुरानी समस्या के लिए इष्टतम होगा?

जैसा कि यह पता चला है, हम सामान्य मामले में ऐसी गारंटी नहीं दे सकते। उत्तर इस बात पर निर्भर करता है कि हमने इनाम के कार्य को वास्तव में कैसे बदला, यह पहले कैसे व्यवस्थित किया गया था और पर्यावरण स्वयं कैसे व्यवस्थित किया गया था। सौभाग्य से, एक लेख है जिसके लेखकों ने जांच की कि इनाम के कार्य को बदलने से समाधान की इष्टतमता को कैसे प्रभावित किया जाता है।

सबसे पहले, उन्हें "सुरक्षित" परिवर्तनों की एक पूरी कक्षा मिली जो संभावित विधि पर आधारित हैं: $$$R '= R + (\ gamma \ cdot \ Phi (new \ _state) - \ Phi (राज्य))$जहाँ $$$\ Phi$- क्षमता, जो केवल राज्य पर निर्भर करती है। इस तरह के कार्यों के लिए, लेखक यह साबित करने में सक्षम थे कि यदि नई समस्या का समाधान इष्टतम है, तो पुरानी समस्या के लिए भी यह इष्टतम है।

दूसरे, लेखकों ने दिखाया कि किसी भी अन्य के लिए $$$R '= R + F (s)$इस तरह की एक समस्या है, आर रिवार्ड फंक्शन और बदली हुई समस्या का इष्टतम समाधान, कि यह समस्या मूल समस्या के लिए इष्टतम नहीं है। इसका मतलब यह है कि हम उस समाधान की अच्छाई की गारंटी नहीं दे सकते हैं जो हमने पाया है कि हम एक बदलाव का उपयोग करते हैं जो कि संभावित पद्धति पर आधारित नहीं है।

इस प्रकार, इनाम फ़ंक्शन को संशोधित करने के लिए संभावित कार्यों का उपयोग केवल एल्गोरिथ्म के अभिसरण दर को बदल सकता है, लेकिन अंतिम समाधान को प्रभावित नहीं करता है।

अभिसरण को सही ढंग से गति दें

अब जब हम जानते हैं कि इनाम को सुरक्षित रूप से कैसे बदलना है, तो आइए, भोले उत्तराधिकारियों के बजाय संभावित विधि का उपयोग करके, कार्य को फिर से संशोधित करने का प्रयास करें:

  संशोधित_रूप = इनाम + 300 * (गामा * एब्स (new_state [1]) - एब्स (राज्य [1])) 

आइए मूल पुरस्कार के कार्यक्रम को देखें:



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

अंतभाषण

अंत तक पढ़ने के लिए धन्यवाद! मुझे आशा है कि आपने इस छोटे से अभ्यास उन्मुख भ्रमण को प्रबलित शिक्षा में आनंद लिया। यह स्पष्ट है कि माउंटेन कार एक "खिलौना" कार्य है, हालांकि, जैसा कि हम ध्यान देने में सक्षम थे, एक एजेंट को सिखाने के लिए मानव दृष्टिकोण से भी ऐसा प्रतीत होता है कि सरल कार्य करना मुश्किल हो सकता है।