You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
349 lines
39 KiB
349 lines
39 KiB
# कार्टपोल स्केटिंग
|
|
|
|
पिछली पाठ में हमने जो समस्या हल की थी, वह एक खिलौना समस्या लग सकती है, जो वास्तविक जीवन के परिदृश्यों के लिए वास्तविक रूप से लागू नहीं होती। ऐसा नहीं है, क्योंकि कई वास्तविक दुनिया की समस्याएँ भी इस परिदृश्य को साझा करती हैं - जिसमें शतरंज या गो खेलना भी शामिल है। ये समान हैं, क्योंकि हमारे पास एक बोर्ड होता है जिसमें दिए गए नियम होते हैं और एक **अवकलित स्थिति** होती है।
|
|
|
|
## [पूर्व-व्याख्यान क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## परिचय
|
|
|
|
इस पाठ में हम Q-लर्निंग के समान सिद्धांतों को एक ऐसी समस्या पर लागू करेंगे जिसमें **सतत स्थिति** होती है, अर्थात ऐसी स्थिति जो एक या अधिक वास्तविक संख्याओं द्वारा दी जाती है। हम निम्नलिखित समस्या से निपटेंगे:
|
|
|
|
> **समस्या**: यदि पीटर भालू से बचना चाहता है, तो उसे तेज़ चलना होगा। हम देखेंगे कि कैसे पीटर Q-लर्निंग का उपयोग करके स्केट करना सीख सकता है, खासकर संतुलन बनाए रखना।
|
|
|
|
|
|
|
|
> पीटर और उसके दोस्त भालू से बचने के लिए रचनात्मक हो जाते हैं! छवि द्वारा [Jen Looper](https://twitter.com/jenlooper)
|
|
|
|
हम संतुलन बनाए रखने के एक सरल संस्करण का उपयोग करेंगे जिसे **कार्टपोल** समस्या के रूप में जाना जाता है। कार्टपोल दुनिया में, हमारे पास एक क्षैतिज स्लाइडर होता है जो बाएं या दाएं स्थानांतरित हो सकता है, और लक्ष्य स्लाइडर के शीर्ष पर एक ऊर्ध्वाधर पोल का संतुलन बनाए रखना होता है।
|
|
|
|
<img alt="a cartpole" src="../../../../translated_images/hi/cartpole.b5609cc0494a14f7.webp" width="200"/>
|
|
|
|
## पूर्वापेक्षाएं
|
|
|
|
इस पाठ में, हम विभिन्न **परिसरों** का अनुकरण करने के लिए **OpenAI Gym** नामक पुस्तकालय का उपयोग करेंगे। आप इस पाठ के कोड को स्थानीय रूप से चला सकते हैं (उदा. Visual Studio Code से), उस स्थिति में अनुकरण एक नई विंडो में खुलेगा। ऑनलाइन कोड चलाते समय, आपको कोड में कुछ समायोजन करने पड़ सकते हैं, जैसा कि [यहाँ](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7) वर्णित है।
|
|
|
|
## OpenAI Gym
|
|
|
|
पिछली पाठ में, खेल के नियम और स्थिति `Board` वर्ग द्वारा दी गई थी जिसे हमने स्वयं परिभाषित किया था। यहाँ हम एक विशेष **अनुकरण पर्यावरण** का उपयोग करेंगे, जो संतुलन पोल के पीछे की भौतिकी का अनुकरण करेगा। प्रशिक्षण सुदृढीकरण लर्निंग एल्गोरिदम के लिए सबसे लोकप्रिय अनुकरण परिवेशों में से एक [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()
|
|
```
|
|
|
|
आपको कुछ ऐसा देखना चाहिए:
|
|
|
|
|
|
|
|
1. अनुकरण के दौरान, हमें निर्णय लेने के लिए अवलोकन प्राप्त करना होता है। वास्तव में, step फ़ंक्शन वर्तमान अवलोकन, पुरस्कार फ़ंक्शन, और done फ़्लैग लौटाता है जो बताता है कि अनुकरण जारी रखना समझदारी है या नहीं: (कोड ब्लॉक 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 प्राप्त करने में सक्षम हैं तो CartPole अनुकरण को हल माना जाता है।
|
|
|
|
## स्थिति का वर्गीकरण
|
|
|
|
Q-लर्निंग में, हमें Q-टेबल बनाना होता है जो प्रत्येक स्थिति में क्या करना है यह परिभाषित करता है। ऐसा करने के लिए, हमें स्थिति को **अवकलित** (Discreet) होना चाहिए, अर्थात इसे सीमित संख्या में वर्गीकृत मानों से बनाना होगा। इसलिए हमें किसी तरह हमारे अवलोकनों को **वर्गीकृत** करना होगा, जिससे वे सीमित राज्य सेट में मैप हो जाएं।
|
|
|
|
हम इसे करने के कुछ तरीके हैं:
|
|
|
|
- **बिन्स में विभाजित करें**। यदि हमें किसी मान के अंतराल का पता है, तो हम इस अंतराल को कई **बिन्स** में विभाजित कर सकते हैं, और फिर मान को उस बिन नंबर से बदल सकते हैं जिसमें वह आता है। यह numpy के [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html) मेथड का उपयोग करके किया जा सकता है। इस मामले में, हमें स्थिति का आकार ठीक से पता होगा, क्योंकि यह उन बिन्स की संख्या पर निर्भर करेगा जो हम डिजिटलीकरण के लिए चुनते हैं।
|
|
|
|
✅ हम मानों को एक सीमित अंतराल (जैसे, -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-आधारित है। इसलिए 0 के आसपास के इनपुट मानों के लिए यह मध्य अंतराल (10) का नंबर लौटाता है। वहीं discretize में हमने आउटपुट मानों की सीमा की परवाह नहीं की, जिससे मान नकारात्मक भी हो सकते हैं, इसलिए स्थिति मान विस्थापित नहीं होते और 0 का मतलब 0 होता है। (कोड ब्लॉक 8)
|
|
|
|
```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-टेबल को 8x8x2 आकार के numpy टेन्सर द्वारा दर्शाना सुविधाजनक था। यदि हम बिन्स वर्गीकरण का उपयोग करें, तो हमारे स्थिति वेक्टर का आकार भी ज्ञात होगा, इसलिए हम इसी दृष्टिकोण का उपयोग कर सकते हैं और 20x20x10x10x2 आकार के एरे से स्थिति को दर्शा सकते हैं (यहाँ 2 क्रिया स्थान का आयाम है, और पहली आयाम पर्यवेक्षण स्थान के प्रत्येक पैरामीटर के लिए चुने गए बिन्स की संख्या के अनुरूप हैं)।
|
|
|
|
हालाँकि, कई बार अवलोकन स्थान के सटीक आयाम ज्ञात नहीं होते। `discretize` फ़ंक्शन के मामले में, हम कभी सुनिश्चित नहीं हो सकते कि हमारी स्थिति निश्चित सीमाओं के भीतर रहती है या नहीं, क्योंकि कुछ मूल मानों पर कोई सीमा नहीं है। इसलिए, हम एक थोड़ा भिन्न दृष्टिकोण अपनाएंगे और Q-टेबल को एक शब्दकोश द्वारा दर्शाएंगे।
|
|
|
|
1. * (स्थिति, क्रिया)* जोड़ी को शब्दकोश की कुंजी के रूप में उपयोग करें, और मान 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-टेबल के वर्तमान मानों को कितना समायोजित करना चाहिए। पिछली पाठ में हमने इसे 1 से शुरू किया था, और प्रशिक्षण के दौरान `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()<epsilon:
|
|
# शोषण - Q-टेबल संभावनाओं के अनुसार क्रिया चुनें
|
|
v = probs(np.array(qvalues(s)))
|
|
a = random.choices(actions,weights=v)[0]
|
|
else:
|
|
# अन्वेषण - यादृच्छिक रूप से क्रिया चुनें
|
|
a = np.random.randint(env.action_space.n)
|
|
|
|
obs, rew, done, info = env.step(a)
|
|
cum_reward+=rew
|
|
ns = discretize(obs)
|
|
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
|
|
cum_rewards.append(cum_reward)
|
|
rewards.append(cum_reward)
|
|
# == समय-समय पर परिणाम मुद्रित करें और औसत पुरस्कार की गणना करें ==
|
|
if epoch%5000==0:
|
|
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
|
|
if np.average(cum_rewards) > Qmax:
|
|
Qmax = np.average(cum_rewards)
|
|
Qbest = Q
|
|
cum_rewards=[]
|
|
```
|
|
|
|
आप इन परिणामों से क्या नोटिस कर सकते हैं:
|
|
|
|
- **हमारे लक्ष्य के करीब**। हम उन 100+ लगातार अनुकरणों में 195 संचयी पुरस्कार प्राप्त करने के लक्ष्य के बहुत करीब हैं, या हो सकता है कि वास्तव में इसे हासिल कर भी लिया हो! भले ही हमें छोटे अंक मिलें, हमें अभी नहीं पता क्योंकि हम 5000 रन के औसत ले रहे हैं, और केवल 100 रन की औपचारिक आवश्यकता है।
|
|
|
|
- **पुरस्कार गिरना शुरू हो जाता है**। कभी-कभी पुरस्कार गिरना शुरू हो जाता है, जिसका अर्थ है कि हम पहले से सीखे गए मानों को Q-टेबल में खराब मानों से "बर्बाद" कर सकते हैं।
|
|
|
|
यह अवलोकन प्रशिक्षण प्रगति की प्लॉटिंग में अधिक स्पष्ट रूप से दिखाई देता है।
|
|
|
|
## प्रशिक्षण प्रगति का प्लॉटिंग
|
|
|
|
प्रशिक्षण के दौरान, हमने प्रत्येक पुनरावृत्ति पर संचयी पुरस्कार मान `rewards` वेक्टर में संग्रहित किया। जब हम इसे पुनरावृत्ति संख्या के विरुद्ध प्लॉट करते हैं तो यह इस प्रकार दिखता है:
|
|
|
|
```python
|
|
plt.plot(rewards)
|
|
```
|
|
|
|
|
|
|
|
इस ग्राफ से कुछ कहना संभव नहीं है, क्योंकि यादृच्छिक प्रशिक्षण प्रक्रिया की प्रकृति के कारण प्रशिक्षण सत्रों की लंबाई बहुत भिन्न होती है। इस ग्राफ को समझने के लिए, हम कई प्रयोगों पर चलती औसत (running average) निकाल सकते हैं, मान लें 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))
|
|
```
|
|
|
|
|
|
|
|
## हाइपरपैरामीटर में परिवर्तन
|
|
|
|
सीखने को अधिक स्थिर बनाने के लिए, प्रशिक्षण के दौरान हमारे कुछ हाइपरपैरामीटर को समायोजित करना समझदारी होगी। विशेष रूप से:
|
|
|
|
- **लर्निंग रेट** `alpha` के लिए, हम लगभग 1 के मान के साथ शुरू कर सकते हैं, और फिर इस पैरामीटर को निरंतर कम करते रह सकते हैं। समय के साथ, हम Q-टेबल में अच्छे प्रायिकता मान प्राप्त करेंगे, इसलिए हमें इन्हें थोड़ा समायोजित करना चाहिए, और पूरी तरह से नए मानों से अधिलेखित नहीं करना चाहिए।
|
|
|
|
- **epsilon बढ़ाएँ**। हम `epsilon` को धीरे-धीरे बढ़ा सकते हैं, ताकि कम अन्वेषण और अधिक शोषण हो सके। शायद यह समझदारी होगी कि हम `epsilon` को कम मान से शुरू करें, और लगभग 1 तक बढ़ाएँ।
|
|
|
|
> **कार्य 1**: हाइपरपैरामीटर मानों के साथ प्रयोग करें और देखें कि क्या आप उच्च संचयी पुरस्कार प्राप्त कर सकते हैं। क्या आप 195 से ऊपर पहुँच रहे हैं?
|
|
|
|
|
|
> **कार्य 2**: समस्या को औपचारिक रूप से हल करने के लिए, आपको 100 लगातार प्रयासों में 195 औसत इनाम प्राप्त करना होगा। प्रशिक्षण के दौरान इसका मापन करें और सुनिश्चित करें कि आपने समस्या को औपचारिक रूप से हल कर लिया है!
|
|
|
|
## परिणाम को क्रियाशील रूप में देखना
|
|
|
|
यह वास्तव में दिलचस्प होगा कि प्रशिक्षित मॉडल कैसे व्यवहार करता है। आइए सिमुलेशन चलाते हैं और प्रशिक्षण के दौरान इसी क्रिया चयन रणनीति का पालन करें, Q-टेबल में प्रायिकता वितरण के अनुसार सैंपलिंग करते हुए: (कोड ब्लॉक 13)
|
|
|
|
```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()
|
|
```
|
|
|
|
आपको कुछ इस तरह दिखाई देना चाहिए:
|
|
|
|
|
|
|
|
---
|
|
|
|
## 🚀चुनौती
|
|
|
|
> **कार्य 3**: यहां, हम Q-टेबल की अंतिम प्रति का उपयोग कर रहे थे, जो संभवतः सबसे अच्छी प्रति नहीं हो सकती। याद रखें कि हमने सर्वश्रेष्ठ प्रदर्शन करने वाली Q-टेबल को `Qbest` नामक वेरिएबल में संग्रहीत किया है! `Qbest` को `Q` पर कॉपी करके उसी उदाहरण को सर्वश्रेष्ठ प्रदर्शन करने वाली Q-टेबल के साथ आजमाएं और देखें कि क्या आपको कोई अंतर महसूस होता है।
|
|
|
|
> **कार्य 4**: यहाँ हम प्रत्येक कदम पर हमेशा सबसे अच्छी क्रिया का चयन नहीं कर रहे थे, बल्कि संबंधित प्रायिकता वितरण के अनुसार सैंपलिंग कर रहे थे। क्या हमेशा सबसे अच्छी क्रिया का चयन करना, जिसमें सबसे उच्च Q-टेबल मान होता है, अधिक समझदारी होगी? इसे करने के लिए `np.argmax` फ़ंक्शन का उपयोग करें ताकि उच्चतम Q-टेबल मान के अनुरूप क्रिया संख्या पता चल सके। इस रणनीति को कार्यान्वित करें और देखें कि क्या इससे संतुलन में सुधार होता है।
|
|
|
|
## [पाठ के बाद क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## असाइनमेंट
|
|
[माउंटेन कार को प्रशिक्षित करें](assignment.md)
|
|
|
|
## निष्कर्ष
|
|
|
|
हमने अब यह सीख लिया है कि कैसे एजेंटों को एक ऐसा इनाम फंक्शन प्रदान करके जो खेल की इच्छित स्थिति को परिभाषित करता है, और उन्हें खोज क्षेत्र का बुद्धिमानी से अन्वेषण करने का अवसर देकर अच्छे परिणाम हासिल करने के लिए प्रशिक्षित किया जा सकता है। हमने Q-लर्निंग एल्गोरिदम को सफलतापूर्वक लागू किया है, जो डिसक्रेट और कंटीन्यूअस पर्यावरणों के मामलों में था, लेकिन डिसक्रेट क्रियाओं के साथ।
|
|
|
|
यह भी महत्वपूर्ण है कि हम उन स्थितियों का अध्ययन करें जहां क्रिया स्थिति भी कंटीन्यूअस हो, और जब प्रेक्षण स्थान अधिक जटिल हो, जैसे कि अटारी गेम स्क्रीन की छवि। उन समस्याओं में हमें अक्सर बेहतर परिणाम प्राप्त करने के लिए अधिक शक्तिशाली मशीन लर्निंग तकनीकों, जैसे कि न्यूरल नेटवर्क्स का उपयोग करना पड़ता है। ये अधिक उन्नत विषय हमारे आगामी अधिक उन्नत AI पाठ्यक्रम का विषय हैं।
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**अस्वीकरण**:
|
|
इस दस्तावेज़ का अनुवाद AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके किया गया है। जबकि हम सटीकता के लिए प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवादों में त्रुटियाँ या अशुद्धियाँ हो सकती हैं। मूल दस्तावेज़ अपनी मूल भाषा में ही प्रामाणिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |