# कार्टपोल स्केटिंग मागील धड्यात आपण ज्या समस्येचे समाधान करत होतो ती एक खेळणी समस्या वाटू शकते, जी खरोखरच वास्तव जीवनातील परिस्थितीसाठी लागू नाही असे वाटू शकते. असे नाही, कारण अनेक वास्तविक जगातील समस्या देखील हीच परिस्थिती सामायिक करतात - ज्यामध्ये चेस किंवा गो खेळणे देखील आहे. त्या सारखा आहेत, कारण आपल्याकडे एक फळीपाटी असून विशिष्ट नियमांसह एका **विभाजित स्थिती** असते. ## [पूर्व व्याख्यान क्विझ](https://ff-quizzes.netlify.app/en/ml/) ## परिचय या धड्यात आपण Q-लर्निंगचे तुमचेच तत्त्वज्ञान सतत असलेल्या अवस्थेशी लागू करू, म्हणजे एक स्थिती जी एका किंवा अधिक वास्तविक संख्या द्वारे दिली जाते. आपण पुढील समस्येवर काम करू: > **समस्या**: जर पीटरला लांडग्यापासून दूर जायचे असेल, तर त्याला वेगाने हालचाल करता येणे आवश्यक आहे. आपण पाहू की पीटर कसे स्केट करू शकतो, विशेषत: संतुलन टिकवण्यासाठी Q-लर्निंग वापरून. ![महान पलायन!](../../../../translated_images/mr/escape.18862db9930337e3.webp) > पीटर आणि त्याचे मित्र लांडग्यापासून दूर जाण्यासाठी सर्जनशील होतात! छायाचित्र [जेन लूपर](https://twitter.com/jenlooper) यांचे. आपण संतुलनाचे एक सोप्या रूप म्हणून **कार्टपोल** समस्या वापरणार आहोत. कार्टपोल जगात, आपल्याकडे एक आडवी स्लायडर आहे जी डावीकडे किंवा उजवीकडे हलू शकते, आणि उद्दिष्ट स्लायडरच्या वर एका उभ्या पोलला संतुलित ठेवणे आहे. a cartpole ## पूर्वअटी या धड्यात, आपण **OpenAI Gym** नावाची लायब्ररी वापरणार आहोत वेगवेगळ्या **परिस्थितींचा** अनुकरण करण्यासाठी. आपण हा धडा स्थानिकरित्या चालवू शकता (उदा. Visual Studio Code वरून), त्या स्थितीत अनुकरण नवीन विंडोमध्ये उघडेल. ऑनलाईन कोड चालवताना, कधीकधी आपल्याला कोडमध्ये काही बदल करावे लागू शकतात, जसे [येथे](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7) दिले आहे. ## OpenAI Gym मागील धड्यात, खेळाचे नियम आणि स्थिती आपण `Board` वर्गाच्या साहाय्याने निश्चित केले आहे. येथे आपण एक विशेष **सिम्युलेशन पर्यावरण** वापरणार आहोत, जे संतुलन पोलच्या भौतिकशास्त्राचे अनुकरण करेल. Q-लर्निंग अल्गोरिदमसाठी प्रशिक्षणासाठी सर्वात लोकप्रिय सिम्युलेशन पर्यावरणांपैकी एक म्हणजे [Gym](https://gym.openai.com/), जे [OpenAI](https://openai.com/) द्वारे राखले जाते. या जिमचा वापर करून आपण कार्टपोल सिम्युलेशनपासून अटारी गेम्सपर्यंतचे वेगळे **पर्यावरण** तयार करू शकतो. > **टीप**: आपण OpenAI Gym कडून उपलब्ध असलेली इतर पर्यावरणे [येथे](https://gym.openai.com/envs/#classic_control) पाहू शकता. प्रथम, जिम स्थापित करू आणि आवश्यक लायब्ररी आयात करू (कोड ब्लॉक 1): ```python import sys !{sys.executable} -m pip install gym import gym import matplotlib.pyplot as plt import numpy as np import random ``` ## सराव - कार्टपोल पर्यावरण प्रारंभ करा कार्टपोल संतुलन समस्येसाठी काम करण्यासाठी, आपल्याला संबंधित पर्यावरण सुरू करणे आवश्यक आहे. प्रत्येक पर्यावरणाला जोडलेले असते: - **निरीक्षण अवकाश** जे पर्यावरणाकडून मिळालेल्या माहितीच्या रचनेची व्याख्या करते. कार्टपोल समस्येसाठी, आपल्याला पोलची स्थिती, वेग आणि काही अन्य मूल्ये मिळतात. - **कार्यान्वयन अवकाश** जे शक्य त्या क्रियांची व्याख्या करते. आपल्या बाबतीत, कार्यान्वयन अवकाश विभाजित आहे, आणि दोन क्रियांचा समावेश आहे - **डावा** आणि **उजवा**. (कोड ब्लॉक 2) 1. प्रारंभ करण्यासाठी, खालील कोड टाइप करा: ```python env = gym.make("CartPole-v1") print(env.action_space) print(env.observation_space) print(env.action_space.sample()) ``` पर्यावरण कसे कार्य करते हे पाहण्यासाठी, आपण 100 चरणांसाठी एक छोटा सिम्युलेशन चालवू. प्रत्येक टप्प्यावर, आपण घ्यायची एक क्रिया प्रदान करतो - या सिम्युलेशनमध्ये आपण `action_space` मधून यादृच्छिक क्रिया निवडतो. 1. खालील कोड चालवा आणि त्याचे परिणाम पहा. ✅ लक्षात ठेवा की हा कोड स्थानिक Python इंस्टॉलेशनवर चालवणे प्राधान्य दिले जाते! (कोड ब्लॉक 3) ```python env.reset() for i in range(100): env.render() env.step(env.action_space.sample()) env.close() ``` आपण या प्रतिमेसारखे काहीतरी पाहू शकता: ![संतुलन न राखणारा कार्टपोल](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif) 1. सिम्युलेशन दरम्यान, आपल्याला निरीक्षणे मिळवणे आवश्यक आहे ज्यावरून आपण निर्णय घेतो की कसे वागायचे. प्रत्यक्षात, step फंक्शन वर्तमान निरीक्षण, एक बक्षीस फंक्शन, आणि समाप्ती चिन्ह परत करते, जे सूचित करते की सिम्युलेशन चालू ठेवणे कारणीयर आहे की नाही: (कोड ब्लॉक 4) ```python env.reset() done = False while not done: env.render() obs, rew, done, info = env.step(env.action_space.sample()) print(f"{obs} -> {rew}") env.close() ``` आपण नोटबुक आउटपुटमध्ये अशा प्रकारचे काही पाहाल: ```text [ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0 [ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0 [ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0 [ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0 [ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0 ... [ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0 [ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0 ``` प्रत्येक सिम्युलेशन टप्प्यावर परत करण्यात येणारा निरीक्षण व्हेक्टर या मूल्यांचा समावेश करतो: - कार्टची स्थिती - कार्टचा वेग - पोलचा कोन - पोलचा फिरण्याचा दर 1. त्या संख्यांचे किमान व कमाल मूल्य मिळवा: (कोड ब्लॉक 5) ```python print(env.observation_space.low) print(env.observation_space.high) ``` आपण हे देखील नोटिस करू शकता की प्रत्येक सिम्युलेशन टप्प्यावर बक्षीस मूल्य नेहमी 1 असते. कारण आपला उद्दिष्ट जितकं शक्य तितकं टिकून राहाणे आहे, म्हणजे पोलला दीर्घकाळ उभं ठेवणे. ✅ प्रत्यक्षात, कार्टपोल सिम्युलेशन 100 सलग चाचण्यांवर 195 ची सरासरी बक्षीस मिळाल्यास तो सोडवलेला समजला जातो. ## स्थितीचे विभाजन Q-लर्निंगमध्ये, आपल्याला Q-टेबल तयार करणे आवश्यक आहे जे प्रत्येक स्थितीवर काय करावे हे घोषित करते. हे करण्यासाठी, आपल्याला स्थिती **विभाजित** करणे आवश्यक आहे, म्हणजे ती एका समाप्त संख्या असलेल्या विभाजित मूल्यांचे संच असावी. त्यामुळे आपल्याला आपल्या निरीक्षणांचे कसे तरी विभाजन करावे लागेल, ज्यामुळे त्यांना स्थितींच्या समाप्त संचाशी नकाशा करता येईल. हे करण्यासाठी काही मार्ग आहेत: - **बिन्समध्ये विभाजित करा**. जर आपल्याला एखाद्या मूल्याचा अंतर माहित असेल, तर आपण त्या अंतराला काही **बिन्स** मध्ये विभाजित करू शकतो, आणि नंतर मूल्याला त्या बिन क्रमांकाने बदलू शकतो. हे numpy च्या [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) पद्धतीने केले जाऊ शकते. या प्रकरणी, आपण अचूकपणे स्थितीचा आकार जाणून घेऊ, कारण तो आपण निवडलेल्या बिन्सच्या संख्येवर अवलंबून असेल. ✅ आपण linear interpolation वापरू शकतो ज्यामुळे मूल्ये काही समाप्त अंतरात (उदा. -20 ते 20) आणता येतात, आणि नंतर संख्या पूर्णांकांमध्ये वळवता येतात. हे आपल्याला स्थितीच्या आकारावर थोडेसेच नियंत्रण देते, विशेषतः जर आपण इनपुट मूल्यांची अचूक रेंज न जाणा तर. उदा. आपल्या प्रकरणी 4 पैकी 2 मूल्यांना वर/खाली मर्यादा नाही, ज्यामुळे अनंत स्थिती संभवतात. आमच्या उदाहरणात, आपण दुसरा दृष्टिकोन वापरणार आहोत. तुम्हाला नंतर दिसेल की, अपरिभाषित वर/खाली मर्यादा असूनही, त्या मूल्ये क्वचितच निश्चित समाप्त अंतराच्या बाहेर जातात, त्यामुळे अत्यधिक मूल्यांच्या त्या स्थिती फार क्वचितच होतात. 1. ही फंक्शन आहे जी आपल्या मॉडेलकडून निरीक्षण घेते आणि 4 पूर्णांकांच्या ट्युपलची निर्मिती करते: (कोड ब्लॉक 6) ```python def discretize(x): return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int)) ``` 1. आणखी एक बिन्सचा वापर करून विभाजन पद्धत पाहूया: (कोड ब्लॉक 7) ```python def create_bins(i,num): return np.arange(num+1)*(i[1]-i[0])/num+i[0] print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10)) ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # प्रत्येक पॅरामीटरसाठी मूल्यांच्या अंतराल nbins = [20,20,10,10] # प्रत्येक पॅरामीटरसाठी बिनची संख्या bins = [create_bins(ints[i],nbins[i]) for i in range(4)] def discretize_bins(x): return tuple(np.digitize(x[i],bins[i]) for i in range(4)) ``` 1. आता एक छोटा सिम्युलेशन चालवू आणि त्या विभाजित पर्यावरण मूल्यानिरीक्षण करू. तुम्ही या दोन्ही `discretize` आणि `discretize_bins` वापरून पहा आणि फरक आहे का ते बघा. ✅ discretize_bins बिन क्रमांक परत करते, जो 0-आधारित आहे. म्हणून इनपुट चलाच्या जवळच्या मूल्यांसाठी तो मध्यभागी असलेल्या संख्या (10) परत करतो. discretize मध्ये, आपण output मूल्या-च्या श्रेणीकडे लक्ष दिले नाही, त्यामुळे ते नकारात्मक देखील असू शकतात, परिणामी स्थिती मूल्ये हलवलेली नाहीत, आणि 0 म्हणजे 0. ```python env.reset() done = False while not done: #env.render() obs, rew, done, info = env.step(env.action_space.sample()) #print(discretize_bins(obs)) print(discretize(obs)) env.close() ``` ✅ env.render ने सुरू होणारी ओळ अनकमेंट करा जर तुम्हाला पर्यावरण कसे कार्य करते हे पाहायचे असेल. अन्यथा तुम्ही त्याला पार्श्वभूमीत चालवू शकता, जे जलद आहे. आपला Q-लर्निंग प्रक्रियेदरम्यान आपण या "अदृश्य" कार्यान्वयनाचा वापर करू. ## Q-टेबलची रचना मागील धड्यात, स्थिती साधी 0 ते 8 मधील दोन संख्यांचा जोडी होती, त्यामुळे Q-टेबल numpy टेन्सर म्हणून 8x8x2 च्या आकारात सादर करणे सोयीचे होते. जर आपण बिन्स विभाजन वापरले, तर स्थिती व्हेक्टरचा आकार देखील ज्ञात असतो, त्यामुळे आपण त्याच पद्धतीने स्थिती 20x20x10x10x2 आकाराच्या अ‍ॅरेने सादर करू शकतो (इथे 2 म्हणजे क्रियाविशिष्ट अवकाशाचा आकार, आणि पहिल्या परिमाणे निरीक्षण अवकाशातील प्रत्येक पॅरामीटरसाठी निवडलेल्या बिन्सची संख्या). परंतु, कधी कधी निरीक्षण अवकाशाच्या अचूक परिमाणांचा माहित नसतो. `discretize` फंक्शनच्या बाबतीत, आपल्याला कधीही खात्री नसू शकते की आपली स्थिती ठराविक मर्यादेत राहील, कारण काही मूळ मूल्ये मर्यादित नाहीत. म्हणून, आपण थोडे वेगळे दृष्टीकोन वापरू आणि Q-टेबल डिक्शनरीच्या स्वरूपात सादर करू. 1. *(state, action)* या जोडीला डिक्शनरी की म्हणून वापरा, आणि मूल्य Q-टेबलमधील नोंदाशी जुळत असेल. (कोड ब्लॉक 9) ```python Q = {} actions = (0,1) def qvalues(state): return [Q.get((state,a),0) for a in actions] ``` येथे आपल्याला `qvalues()` फंक्शन सुध्दा ठरवायचे आहे, जे दिलेल्या स्थितीसाठी शक्य क्रियांसाठी Q-टेबलमधील मूल्यांची यादी परत करते. जर की Q-टेबल मध्ये उपस्थित नसेल तर आपण 0 परत करू. ## चला Q-लर्निंग सुरू करूया आता आपण पीटरला संतुलन शिकवायला तयार आहोत! 1. प्रथम, काही हायपरपॅरामीटर सेट करूया: (कोड ब्लॉक 10) ```python # हायपरपॅरामिटर्स alpha = 0.3 gamma = 0.9 epsilon = 0.90 ``` येथे, `alpha` म्हणजे **लर्निंग दर** जो ठरवतो की प्रत्येक टप्प्यावर Q-टेबलमधील विद्यमान मूल्ये कितपत बदलावीत. मागील धड्यात आपण १ ने सुरुवात केली आणि नंतर प्रशिक्षणादरम्यान `alpha` कमी केलं. या उदाहरणात आपण सोपेपणासाठी ते स्थिर ठेवणार आहोत, आणि तुम्ही नंतर `alpha` मूल्यांवर प्रयोग करू शकता. `gamma` म्हणजे **डिस्काउंट घटक** जो दर्शवतो की भविष्यातील बक्षीसाला वर्तमान बक्षीसापेक्षा किती प्राधान्य द्यायचे. `epsilon` म्हणजे **अन्वेषण/उत्पादनाचा घटक** जो ठरवतो की आपल्याला अन्वेषण प्राधान्य द्यायचा की उत्पादन. आमच्या अल्गोरिदममध्ये, `epsilon` प्रमाणे आपण Q-टेबल घटकांनुसार क्रिया निवडू, आणि उर्वरित प्रसंगी यादृच्छिक क्रिया करतो. यामुळे आपण अशा शोध क्षेत्रांचा अन्वेषण करू शकू जे पूर्वी कधीच पाहिलेले नाहीत. ✅ संतुलनाच्या दृष्टीने - यादृच्छिक क्रिया निवडण्याने (अन्वेषण) चुकीच्या दिशेने एक पंच मारण्यासारखे होईल, आणि पोलला त्या "चुकांवरून" संतुलन पुन्हा कसे मिळवायचे ते शिकावे लागेल. ### अल्गोरिदम सुधारणा आपण मागील धड्यातील आपल्या अल्गोरिदममध्ये दोन सुधारणा करू शकतो: - **सरासरी संचयी बक्षीस मोजा**, अनेक सिम्युलेशन्सवर. आपण प्रत्येक 5000 पुनरावृत्तीवर प्रगती छापू आणि त्या कालावधीत संचयी बक्षीसाचा सरासरी काढू. म्हणजे जर 195 पेक्षा अधिक गुण मिळाले तर आपण समस्या सोडवलेली मानू, अगदी अधिक गुणवत्ता प्राप्त केली तरी. - **कमाल सरासरी संचयी निकाल मोजा**, `Qmax`, आणि त्या निकालाशी संबंधित Q-टेबल जतन करा. जेव्हा आपण प्रशिक्षण चालवता, तेव्हा कधीकधी सरासरी संचयी निकाल कमी होऊ लागतो, आणि आपण सर्वोत्कृष्ट मॉडेलसाठी Q-टेबलची मूल्ये जपू इच्छितो. 1. प्रत्येक सिम्युलेशनच्या संचयी बक्षीस `rewards` व्हेक्टरमध्ये एकत्र करा पुढील प्लॉटिंगसाठी. (कोड ब्लॉक 11) ```python def probs(v,eps=1e-4): v = v-v.min()+eps v = v/v.sum() return v Qmax = 0 cum_rewards = [] rewards = [] for epoch in range(100000): obs = env.reset() done = False cum_reward=0 # == सिम्युलेशन करा == while not done: s = discretize(obs) if random.random() Qmax: Qmax = np.average(cum_rewards) Qbest = Q cum_rewards=[] ``` तुम्हाला त्या निकालांमधून काय दिसू शकते: - **आपल्या उद्दिष्टाजवळ**. आपण 195 संचयी बक्षीस 100+ सलग सिम्युलेशन्समध्ये मिळवण्याच्या उद्दिष्टाजवळ आहोत किंवा कदाचित मिळवले आहे! कमी नंबर आले तरी फरक पडत नाही कारण आपण 5000 रनवर सरासरी काढली आहे, आणि अधिकृत निकषांनुसार फक्त 100 रन आवश्यक आहेत. - **बक्षीस कमी होणे सुरू होते**. कधीकधी बक्षीस कमी होण्यासाठी सुरुवात होते, याचा अर्थ असा की आपण आधीच शिकलेल्या Q-टेबलच्या मूल्यांना तशाप्रकारे बदलू शकतो जे परिस्थिती वाईट करतात. या निरीक्षणांचे स्पष्ट दर्शन प्रशिक्षण प्रगतीचे प्लॉटिंग केल्यावर होते. ## प्रशिक्षण प्रगतीचे प्लॉटिंग प्रशिक्षणादरम्यान, आपल्याला प्रत्येक पुनरावृत्तीवरील संचयी बक्षीस मूल्य `rewards` व्हेक्टरमध्ये जमा केले आहे. येथे आपण ते पुनरावृत्ती क्रमांकाशी कसे प्लॉट करू: ```python plt.plot(rewards) ``` ![ताजी प्रगती](../../../../translated_images/mr/train_progress_raw.2adfdf2daea09c59.webp) या ग्राफमधून काहीही सांगणे शक्य नाही, कारण यादृच्छिक प्रशिक्षण प्रक्रियेच्या निसर्गामुळे प्रशिक्षण सत्रांच्या लांबीत मोठा बदल असतो. या ग्राफचा अधिक अर्थ लावण्यासाठी, आपण 100 प्रयोगांच्या मालिकेवरील **रेल चालणारी सरासरी** काढू शकतो. हे `np.convolve` वापरून सोप्या प्रकारे करता येते: (कोड ब्लॉक 12) ```python def running_average(x,window): return np.convolve(x,np.ones(window)/window,mode='valid') plt.plot(running_average(rewards,100)) ``` ![प्रशिक्षण प्रगती](../../../../translated_images/mr/train_progress_runav.c71694a8fa9ab359.webp) ## हायपरपॅरामिटर्सचा बदल शिक्षण अधिक स्थिर करण्यासाठी, आपल्याला प्रशिक्षणादरम्यान काही हायपरपॅरामिटर्स समायोजित करणे उचित वाटते. विशेषतः: - **लर्निंग दरासाठी**, `alpha`, आपल्याला 1 च्या जवळील मूल्यांपासून सुरुवात करावी आणि नंतर ते कमी करत रहावे. काळाच्या ओघात, आपण Q-टेबलमधील चांगले शक्यतामान मिळवू, आणि त्यानुसार आपण त्यांना थोड्या प्रमाणात सुधारणा करावी जेणेकरून ते नवीन मूल्यांनी पूर्णपणे पुनर्लेखन होणार नाहीत. - **epsilon वाढवा**. आपल्याला `epsilon` हळूहळू वाढवायचा असू शकतो, ज्यामुळे अन्वेषण कमी होईल आणि उत्पादन अधिक होईल. कदाचित कमी `epsilon` ने सुरुवात करून जवळपास 1 पर्यंत वाढवणे उचित आहे. > **कार्य 1**: हायपरपॅरामिटर्समधील मूल्यांशी प्रयोग करा आणि पहा की तुम्ही जास्त संचयी बक्षीस मिळवू शकता काय. तुम्ही 195 पेक्षा जास्त मिळवत आहात का? > **कार्य २**: समस्येचे औपचारिकपणे निराकरण करण्यासाठी, तुम्हाला १०० सलग चाचण्यांमध्ये सरासरी १९५ बक्षीस मिळवणे आवश्यक आहे. प्रशिक्षणादरम्यान त्याचे मापन करा आणि खात्री करा की तुम्ही औपचारिकपणे समस्या सोडवली आहे! ## कृतीत निकाल पाहणे प्रशिक्षित मॉडेल कसे वागते हे प्रत्यक्ष पाहणे मनोरंजक ठरेल. चला सिम्युलेशन चालवूया आणि प्रशिक्षणादरम्यान वापरल्या गेलेल्या क्रिया निवड धोरणाचे पालन करूया, Q-टेबलमधील संभाव्यता वितरणानुसार नमुना घेऊन: (कोड ब्लॉक १३) ```python obs = env.reset() done = False while not done: s = discretize(obs) env.render() v = probs(np.array(qvalues(s))) a = random.choices(actions,weights=v)[0] obs,_,done,_ = env.step(a) env.close() ``` तुम्हाला असे काहीतरी दिसायला हवे: ![एक संतुलित कार्टपोल](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif) --- ## 🚀आव्हान > **कार्य ३**: येथे आपण Q-टेबलची अंतिम प्रती वापरत होतो, जी कदाचित सर्वोत्तम नसावी. लक्षात ठेवा की आम्ही सर्वोत्तम कामगिरी करणारा Q-टेबल `Qbest` या चलमध्ये साठवला आहे! `Qbest` कॉपी करून `Q` मध्ये ठेवून त्याच उदाहरणाचा प्रयत्न करा आणि फरक लक्षात येतो का ते पहा. > **कार्य ४**: येथे आम्ही प्रत्येक टप्प्यावर सर्वोत्तम क्रिया निवडत नव्हतो, पण संबंधित संभाव्यता वितरणानुसार नमुना घेत होतो. नेहमी सर्वोत्तम क्रिया, म्हणजे जास्तीत जास्त Q-टेबल मूल्य असलेली क्रिया, निवडल्यास अधिक अर्थ निर्माण होतो का? हे `np.argmax` फंक्शन वापरून जास्तीत जास्त Q-टेबल मूल्याशी संबंधित क्रियेचा क्रमांक शोधून करता येते. हे धोरण अंमलात आणा आणि ते संतुलन सुधारते का ते पाहा. ## [लक्ष्योपचारानंतरची चाचणी](https://ff-quizzes.netlify.app/en/ml/) ## घरकाम [माउंटन कारचे प्रशिक्षण](assignment.md) ## निष्कर्ष आम्ही आता शिकले आहे की एजंट्सना केवळ त्यांना हवा असलेला गेम स्थिती निर्दिष्ट करणारी बक्षीस कार्ये प्रदान करून, आणि शोध जागा बुद्धिमत्तेने शोधण्यासाठी संधी देऊन चांगले निकाल मिळवण्यासाठी प्रशिक्षण देणे कसे असते. आम्ही यशस्वीरित्या Q-लर्निंग अल्गोरिदम डिस्क्रीट आणि सलग वातावरणांमध्ये, पण डिस्क्रीट क्रियांसह, लागू केले आहे. हे देखील महत्त्वाचे आहे की, क्रिया स्थिती सलग असलेल्या स्थितींचा अभ्यास करणे, आणि निरीक्षण जागा जास्त गुंतागुंतीची असलेली, जसे की अटारी गेम स्क्रीनमधील प्रतिमा. अशा समस्यांमध्ये चांगले निकाल मिळवण्यासाठी आपल्याला अधिक शक्तिशाली मशीन लर्निंग तंत्रे, जसे की न्यूरल नेटवर्क्स वापरणे आवश्यक असते. ही अधिक प्रगत विषय आपल्या आगामी अधिक प्रगत AI कोर्सची विषयं आहेत. --- **अस्वीकरण**: हा दस्तऐवज AI भाषांतर सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) चा वापर करून अनुवादित केला आहे. जरी आम्ही अचूकतेसाठी प्रयत्न करतो, तरी कृपया लक्षात घ्या की स्वयंचलित भाषांतरांमध्ये त्रुटी किंवा अचूकतेची कमतरता असू शकते. मूळ दस्तऐवज त्याच्या मूळ भाषेत अधिकृत स्रोत मानला पाहिजे. महत्त्वाची माहिती असल्यास, व्यावसायिक मानवी भाषांतराची शिफारस केली जाते. या भाषांतराच्या वापरामुळे उद्भवणाऱ्या कोणत्याही गैरसमज किंवा चुकीच्या अर्थलावणीसाठी आम्ही जबाबदार नाही.