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.
256 lines
32 KiB
256 lines
32 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "911efd5e595089000cb3c16fce1beab8",
|
|
"translation_date": "2025-09-06T06:18:51+00:00",
|
|
"source_file": "8-Reinforcement/1-QLearning/README.md",
|
|
"language_code": "mr"
|
|
}
|
|
-->
|
|
# रिइन्फोर्समेंट लर्निंग आणि Q-लर्निंगची ओळख
|
|
|
|
|
|
> स्केच नोट [Tomomi Imura](https://www.twitter.com/girlie_mac) यांच्याकडून
|
|
|
|
रिइन्फोर्समेंट लर्निंगमध्ये तीन महत्त्वाचे संकल्पना असतात: एजंट, काही स्टेट्स, आणि प्रत्येक स्टेटसाठी अ‍ॅक्शनचा सेट. एका विशिष्ट स्टेटमध्ये अ‍ॅक्शन पार पाडून एजंटला एक रिवॉर्ड दिला जातो. पुन्हा सुपर मारिओ गेमची कल्पना करा. तुम्ही मारिओ आहात, तुम्ही गेमच्या एका लेव्हलमध्ये आहात, एका कड्याच्या जवळ उभे आहात. तुमच्या वर एक नाणे आहे. तुम्ही मारिओ आहात, एका गेम लेव्हलमध्ये, एका विशिष्ट ठिकाणी ... हे तुमचे स्टेट आहे. उजवीकडे एक पाऊल टाकणे (एक अ‍ॅक्शन) तुम्हाला कड्यावरून खाली नेईल, आणि त्यामुळे तुम्हाला कमी संख्यात्मक स्कोअर मिळेल. परंतु, जंप बटण दाबल्यास तुम्हाला एक पॉइंट मिळेल आणि तुम्ही जिवंत राहाल. हे एक सकारात्मक परिणाम आहे आणि त्यामुळे तुम्हाला सकारात्मक संख्यात्मक स्कोअर मिळायला हवा.
|
|
|
|
रिइन्फोर्समेंट लर्निंग आणि सिम्युलेटर (गेम) वापरून, तुम्ही गेम खेळण्याची पद्धत शिकू शकता ज्यामुळे तुम्हाला जास्तीत जास्त रिवॉर्ड मिळेल, म्हणजे जिवंत राहणे आणि जास्तीत जास्त पॉइंट्स मिळवणे.
|
|
|
|
[](https://www.youtube.com/watch?v=lDq_en8RNOo)
|
|
|
|
> 🎥 वर दिलेल्या प्रतिमेवर क्लिक करा आणि Dmitry यांच्याकडून रिइन्फोर्समेंट लर्निंगबद्दल ऐका
|
|
|
|
## [पूर्व-व्याख्यान क्विझ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## पूर्वतयारी आणि सेटअप
|
|
|
|
या धड्यात, आपण Python मध्ये काही कोडसह प्रयोग करणार आहोत. तुम्ही तुमच्या संगणकावर किंवा क्लाउडमध्ये या धड्याचा Jupyter Notebook कोड चालवू शकता.
|
|
|
|
तुम्ही [धड्याचा नोटबुक](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) उघडू शकता आणि या धड्याचा अभ्यास करून तयार करू शकता.
|
|
|
|
> **टीप:** जर तुम्ही क्लाउडमधून हा कोड उघडत असाल, तर तुम्हाला [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py) फाईल देखील मिळवावी लागेल, जी नोटबुक कोडमध्ये वापरली जाते. ती नोटबुकसह त्याच डिरेक्टरीमध्ये जोडा.
|
|
|
|
## ओळख
|
|
|
|
या धड्यात, आपण **[Peter and the Wolf](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** च्या जगाचा अभ्यास करणार आहोत, जो एका रशियन संगीतकार [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev) यांच्या संगीत परीकथेतून प्रेरित आहे. आपण **रिइन्फोर्समेंट लर्निंग** वापरून पीटरला त्याचे वातावरण एक्सप्लोर करायला, स्वादिष्ट सफरचंद गोळा करायला आणि लांडग्याला टाळायला शिकवणार आहोत.
|
|
|
|
**रिइन्फोर्समेंट लर्निंग** (RL) ही एक शिकण्याची तंत्र आहे जी आपल्याला अनेक प्रयोग चालवून **एजंट**च्या **वातावरणात** एक आदर्श वर्तन शिकण्याची परवानगी देते. या वातावरणातील एजंटकडे काही **उद्दिष्ट** असावे, जे **रिवॉर्ड फंक्शन**द्वारे परिभाषित केले जाते.
|
|
|
|
## वातावरण
|
|
|
|
सोप्या पद्धतीने, पीटरच्या जगाला `width` x `height` आकाराच्या चौकोनी बोर्ड मानूया, असे:
|
|
|
|
|
|
|
|
या बोर्डमधील प्रत्येक सेल खालीलपैकी एक असू शकतो:
|
|
|
|
* **जमीन**, ज्यावर पीटर आणि इतर प्राणी चालू शकतात.
|
|
* **पाणी**, ज्यावर चालणे शक्य नाही.
|
|
* **झाड** किंवा **गवत**, जिथे तुम्ही विश्रांती घेऊ शकता.
|
|
* **सफरचंद**, जे पीटरला स्वतःला खायला मिळाल्यास आनंद होईल.
|
|
* **लांडगा**, जो धोकादायक आहे आणि टाळला पाहिजे.
|
|
|
|
एक स्वतंत्र Python मॉड्यूल आहे, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), ज्यामध्ये या वातावरणाशी संबंधित कोड आहे. कारण हा कोड आपले संकल्पना समजून घेण्यासाठी महत्त्वाचा नाही, आपण मॉड्यूल आयात करू आणि नमुना बोर्ड तयार करण्यासाठी वापरू (कोड ब्लॉक 1):
|
|
|
|
```python
|
|
from rlboard import *
|
|
|
|
width, height = 8,8
|
|
m = Board(width,height)
|
|
m.randomize(seed=13)
|
|
m.plot()
|
|
```
|
|
|
|
हा कोड वरील चित्रासारखे वातावरण प्रिंट करेल.
|
|
|
|
## अ‍ॅक्शन आणि पॉलिसी
|
|
|
|
आपल्या उदाहरणात, पीटरचे उद्दिष्ट सफरचंद शोधणे असेल, लांडगा आणि इतर अडथळ्यांना टाळून. हे करण्यासाठी, तो मूलतः चालत राहू शकतो जोपर्यंत त्याला सफरचंद सापडत नाही.
|
|
|
|
म्हणून, कोणत्याही स्थितीत, तो खालील अ‍ॅक्शनपैकी एक निवडू शकतो: वर, खाली, डावीकडे आणि उजवीकडे.
|
|
|
|
आपण त्या अ‍ॅक्शनला डिक्शनरी म्हणून परिभाषित करू आणि त्यांना संबंधित समन्वय बदलांच्या जोड्यांशी नकाशा करू. उदाहरणार्थ, उजवीकडे जाणे (`R`) `(1,0)` जोड्याशी संबंधित असेल. (कोड ब्लॉक 2):
|
|
|
|
```python
|
|
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
|
|
action_idx = { a : i for i,a in enumerate(actions.keys()) }
|
|
```
|
|
|
|
या परिस्थितीचा सारांश देण्यासाठी, रणनीती आणि उद्दिष्ट खालीलप्रमाणे आहेत:
|
|
|
|
- **रणनीती**, आपल्या एजंटची (पीटरची) **पॉलिसी**द्वारे परिभाषित केली जाते. पॉलिसी ही एक फंक्शन आहे जी कोणत्याही दिलेल्या स्थितीत अ‍ॅक्शन परत करते. आपल्या प्रकरणात, समस्येची स्थिती बोर्डद्वारे दर्शविली जाते, ज्यामध्ये खेळाडूची वर्तमान स्थिती समाविष्ट आहे.
|
|
|
|
- **उद्दिष्ट**, रिइन्फोर्समेंट लर्निंगचे अंतिम उद्दिष्ट म्हणजे एक चांगली पॉलिसी शिकणे जी आपल्याला समस्या कार्यक्षमतेने सोडवण्यास अनुमती देईल. तथापि, बेसलाइन म्हणून, आपण **रँडम वॉक** नावाची सर्वात सोपी पॉलिसी विचारात घेऊया.
|
|
|
|
## रँडम वॉक
|
|
|
|
आपल्या समस्येचे निराकरण प्रथम रँडम वॉक रणनीती अंमलात आणून करूया. रँडम वॉकसह, आपण परवानगी दिलेल्या अ‍ॅक्शनमधून पुढील अ‍ॅक्शन निवडू, जोपर्यंत आपण सफरचंदापर्यंत पोहोचत नाही (कोड ब्लॉक 3).
|
|
|
|
1. खालील कोडसह रँडम वॉक अंमलात आणा:
|
|
|
|
```python
|
|
def random_policy(m):
|
|
return random.choice(list(actions))
|
|
|
|
def walk(m,policy,start_position=None):
|
|
n = 0 # number of steps
|
|
# set initial position
|
|
if start_position:
|
|
m.human = start_position
|
|
else:
|
|
m.random_start()
|
|
while True:
|
|
if m.at() == Board.Cell.apple:
|
|
return n # success!
|
|
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
|
|
return -1 # eaten by wolf or drowned
|
|
while True:
|
|
a = actions[policy(m)]
|
|
new_pos = m.move_pos(m.human,a)
|
|
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
|
|
m.move(a) # do the actual move
|
|
break
|
|
n+=1
|
|
|
|
walk(m,random_policy)
|
|
```
|
|
|
|
`walk` कॉल संबंधित मार्गाची लांबी परत करेल, जी एका रनपासून दुसऱ्या रनपर्यंत बदलू शकते.
|
|
|
|
1. वॉक प्रयोग अनेक वेळा चालवा (म्हणजे, 100 वेळा), आणि परिणामी आकडेवारी प्रिंट करा (कोड ब्लॉक 4):
|
|
|
|
```python
|
|
def print_statistics(policy):
|
|
s,w,n = 0,0,0
|
|
for _ in range(100):
|
|
z = walk(m,policy)
|
|
if z<0:
|
|
w+=1
|
|
else:
|
|
s += z
|
|
n += 1
|
|
print(f"Average path length = {s/n}, eaten by wolf: {w} times")
|
|
|
|
print_statistics(random_policy)
|
|
```
|
|
|
|
लक्षात घ्या की मार्गाची सरासरी लांबी सुमारे 30-40 पायऱ्या आहे, जी खूप जास्त आहे, दिलेल्या तथ्यामुळे की सरासरी अंतर जवळच्या सफरचंदापर्यंत सुमारे 5-6 पायऱ्या आहे.
|
|
|
|
तुम्ही पीटरच्या रँडम वॉक दरम्यानच्या हालचाली कशा दिसतात हे देखील पाहू शकता:
|
|
|
|
|
|
|
|
## रिवॉर्ड फंक्शन
|
|
|
|
आपली पॉलिसी अधिक बुद्धिमान बनवण्यासाठी, आपल्याला समजून घ्यावे लागेल की कोणते हालचाल "चांगले" आहेत. हे करण्यासाठी, आपल्याला आपले उद्दिष्ट परिभाषित करावे लागेल.
|
|
|
|
उद्दिष्ट **रिवॉर्ड फंक्शन**च्या स्वरूपात परिभाषित केले जाऊ शकते, जे प्रत्येक स्थितीसाठी काही स्कोअर मूल्य परत करेल. संख्या जितकी जास्त असेल, तितके रिवॉर्ड फंक्शन चांगले. (कोड ब्लॉक 5)
|
|
|
|
```python
|
|
move_reward = -0.1
|
|
goal_reward = 10
|
|
end_reward = -10
|
|
|
|
def reward(m,pos=None):
|
|
pos = pos or m.human
|
|
if not m.is_valid(pos):
|
|
return end_reward
|
|
x = m.at(pos)
|
|
if x==Board.Cell.water or x == Board.Cell.wolf:
|
|
return end_reward
|
|
if x==Board.Cell.apple:
|
|
return goal_reward
|
|
return move_reward
|
|
```
|
|
|
|
रिवॉर्ड फंक्शनबद्दल एक मनोरंजक गोष्ट म्हणजे बहुतेक प्रकरणांमध्ये, *आपल्याला गेमच्या शेवटीच महत्त्वपूर्ण रिवॉर्ड दिला जातो*. याचा अर्थ असा की आपला अल्गोरिदम "चांगल्या" पायऱ्यांना लक्षात ठेवावा लागेल ज्यामुळे शेवटी सकारात्मक रिवॉर्ड मिळतो, आणि त्यांचे महत्त्व वाढवावे लागेल. त्याचप्रमाणे, सर्व हालचाली ज्यामुळे वाईट परिणाम होतात त्यांना हतोत्साहित केले पाहिजे.
|
|
|
|
## Q-लर्निंग
|
|
|
|
आपण येथे चर्चा करणार असलेला अल्गोरिदम **Q-लर्निंग** म्हणून ओळखला जातो. या अल्गोरिदममध्ये, पॉलिसी एका फंक्शन (किंवा डेटा स्ट्रक्चर)द्वारे परिभाषित केली जाते ज्याला **Q-टेबल** म्हणतात. ते दिलेल्या स्थितीत प्रत्येक अ‍ॅक्शनच्या "चांगुलपणाची" नोंद ठेवते.
|
|
|
|
याला Q-टेबल म्हणतात कारण ते टेबल किंवा मल्टी-डायमेन्शनल अ‍ॅरे म्हणून सादर करणे सोयीचे असते. कारण आपला बोर्ड `width` x `height` परिमाणांचा आहे, आपण Q-टेबलला `width` x `height` x `len(actions)` आकाराच्या numpy अ‍ॅरेद्वारे सादर करू शकतो: (कोड ब्लॉक 6)
|
|
|
|
```python
|
|
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
|
|
```
|
|
|
|
लक्षात घ्या की आपण Q-टेबलच्या सर्व मूल्यांना समान मूल्याने प्रारंभ करतो, आपल्या प्रकरणात - 0.25. हे "रँडम वॉक" पॉलिसीशी संबंधित आहे, कारण प्रत्येक स्थितीत सर्व हालचाली समान चांगल्या आहेत. आपण Q-टेबल बोर्डवर व्हिज्युअलाइझ करण्यासाठी `plot` फंक्शनला पास करू शकतो: `m.plot(Q)`.
|
|
|
|
|
|
|
|
प्रत्येक सेलच्या मध्यभागी एक "बाण" आहे जो हालचालीच्या प्राधान्य दिलेल्या दिशेची सूचना करतो. कारण सर्व दिशे समान आहेत, एक बिंदू दर्शविला जातो.
|
|
|
|
आता आपल्याला सिम्युलेशन चालवावे लागेल, आपले वातावरण एक्सप्लोर करावे लागेल, आणि Q-टेबल मूल्यांचे चांगले वितरण शिकावे लागेल, ज्यामुळे आपल्याला सफरचंदापर्यंत पोहोचण्याचा मार्ग खूप वेगाने सापडेल.
|
|
|
|
## Q-लर्निंगचा सार: बेलमन समीकरण
|
|
|
|
एकदा आपण हालचाल सुरू केली की प्रत्येक अ‍ॅक्शनला संबंधित रिवॉर्ड मिळेल, म्हणजे आपण सैद्धांतिकदृष्ट्या सर्वोच्च तात्काळ रिवॉर्डच्या आधारावर पुढील अ‍ॅक्शन निवडू शकतो. तथापि, बहुतेक स्थितीत, हालचाल आपले सफरचंद गाठण्याचे उद्दिष्ट साध्य करणार नाही, आणि त्यामुळे आपण तात्काळ निर्णय घेऊ शकत नाही की कोणती दिशा चांगली आहे.
|
|
|
|
> लक्षात ठेवा की तात्काळ परिणाम महत्त्वाचा नाही, तर अंतिम परिणाम महत्त्वाचा आहे, जो आपल्याला सिम्युलेशनच्या शेवटी मिळेल.
|
|
|
|
या विलंबित रिवॉर्डचा विचार करण्यासाठी, आपल्याला **[डायनॅमिक प्रोग्रामिंग](https://en.wikipedia.org/wiki/Dynamic_programming)** च्या तत्त्वांचा वापर करावा लागेल, ज्यामुळे आपल्याला आपली समस्या पुनरावृत्तीने विचार करता येईल.
|
|
|
|
समजा आपण आता स्थिती *s* वर आहोत, आणि आपण पुढील स्थिती *s'* वर जाण्यास इच्छुक आहोत. असे केल्याने, आपल्याला तात्काळ रिवॉर्ड *r(s,a)* मिळेल, जो रिवॉर्ड फंक्शनद्वारे परिभाषित केला जातो, तसेच काही भविष्यातील रिवॉर्ड मिळेल. जर आपण मानले की आपला Q-टेबल प्रत्येक अ‍ॅक्शनची "आकर्षकता" योग्य प्रकारे प्रतिबिंबित करतो, तर स्थिती *s'* वर आपण *a'* अ‍ॅक्शन निवडू, जो *Q(s',a')* च्या जास्तीत जास्त मूल्याशी संबंधित आहे. त्यामुळे, स्थिती *s* वर आपल्याला मिळणारा सर्वोत्तम संभाव्य भविष्यातील रिवॉर्ड परिभाषित केला जाईल म्हणून `max`
|
|
|
|
## धोरण तपासणे
|
|
|
|
Q-Table प्रत्येक स्थितीतील प्रत्येक क्रियेच्या "आकर्षकतेची" यादी देते, त्यामुळे आपल्या जगात कार्यक्षम नेव्हिगेशन परिभाषित करण्यासाठी ते वापरणे सोपे आहे. सर्वात सोप्या प्रकरणात, आपण Q-Table मधील सर्वाधिक मूल्याशी संबंधित क्रिया निवडू शकतो: (कोड ब्लॉक 9)
|
|
|
|
```python
|
|
def qpolicy_strict(m):
|
|
x,y = m.human
|
|
v = probs(Q[x,y])
|
|
a = list(actions)[np.argmax(v)]
|
|
return a
|
|
|
|
walk(m,qpolicy_strict)
|
|
```
|
|
|
|
> वरील कोड काही वेळा चालवून पाहिल्यास, कधीकधी तो "अडकतो" असे तुम्हाला जाणवेल, आणि तुम्हाला नोटबुकमधील STOP बटण दाबून तो थांबवावा लागतो. असे होण्याचे कारण म्हणजे काहीवेळा दोन स्थिती "ऑप्टिमल Q-Value" च्या दृष्टीने एकमेकांकडे "दर्शवतात", अशा परिस्थितीत एजंट त्या स्थितींमध्ये सतत फिरत राहतो.
|
|
|
|
## 🚀चॅलेंज
|
|
|
|
> **कार्य 1:** `walk` फंक्शनमध्ये बदल करून पथाची जास्तीत जास्त लांबी एका विशिष्ट टप्प्यांपर्यंत (उदा. 100) मर्यादित करा आणि वरील कोड कधीकधी ही मूल्ये परत करत असल्याचे पाहा.
|
|
|
|
> **कार्य 2:** `walk` फंक्शनमध्ये बदल करून असे करा की ते आधीच भेट दिलेल्या ठिकाणी परत जाऊ शकणार नाही. यामुळे `walk` लूप होण्यापासून रोखले जाईल, परंतु एजंट अजूनही अशा ठिकाणी "अडकू" शकतो जिथून तो बाहेर पडू शकत नाही.
|
|
|
|
## नेव्हिगेशन
|
|
|
|
प्रशिक्षणादरम्यान वापरलेले धोरण अधिक चांगले नेव्हिगेशन धोरण ठरेल, जे शोषण आणि अन्वेषण यांचे संयोजन करते. या धोरणात, आम्ही Q-Table मधील मूल्यांच्या प्रमाणात प्रत्येक क्रिया निवडू. ही रणनीती अजूनही एजंटला आधीच शोधलेल्या स्थानावर परत येण्याची शक्यता ठेवते, परंतु, खालील कोडमधून तुम्ही पाहू शकता की, ती इच्छित स्थानापर्यंत पोहोचण्यासाठी खूपच कमी सरासरी पथ लांबी देते (लक्षात ठेवा की `print_statistics` सिम्युलेशन 100 वेळा चालवते): (कोड ब्लॉक 10)
|
|
|
|
```python
|
|
def qpolicy(m):
|
|
x,y = m.human
|
|
v = probs(Q[x,y])
|
|
a = random.choices(list(actions),weights=v)[0]
|
|
return a
|
|
|
|
print_statistics(qpolicy)
|
|
```
|
|
|
|
हा कोड चालवल्यानंतर, तुम्हाला आधीच्या तुलनेत खूपच कमी सरासरी पथ लांबी मिळेल, साधारणतः 3-6 च्या दरम्यान.
|
|
|
|
## शिकण्याच्या प्रक्रियेचा अभ्यास
|
|
|
|
जसे आपण नमूद केले आहे, शिकण्याची प्रक्रिया ही अन्वेषण आणि समस्या जागेच्या संरचनेबद्दल मिळालेल्या ज्ञानाच्या अन्वेषण यामधील संतुलन आहे. आपण पाहिले आहे की शिकण्याचे परिणाम (एजंटला लक्ष्यापर्यंत पोहोचण्यासाठी लहान पथ शोधण्यात मदत करण्याची क्षमता) सुधारली आहे, परंतु शिकण्याच्या प्रक्रियेदरम्यान सरासरी पथ लांबी कशी वागते हे पाहणे देखील मनोरंजक आहे:
|
|
|
|
## शिकवणुकीचा सारांश
|
|
|
|
- **सरासरी पथ लांबी वाढते**. सुरुवातीला, सरासरी पथ लांबी वाढते असे दिसते. याचे कारण असे असू शकते की जेव्हा आपल्याला वातावरणाबद्दल काहीच माहिती नसते, तेव्हा आपण वाईट स्थितींमध्ये, जसे की पाणी किंवा लांडगा, अडकण्याची शक्यता असते. जसजसे आपण अधिक शिकतो आणि हे ज्ञान वापरतो, तसतसे आपण वातावरणाचा अधिक वेळ अन्वेषण करू शकतो, परंतु तरीही आपल्याला सफरचंद कुठे आहेत याची फारशी माहिती नसते.
|
|
|
|
- **पथ लांबी कमी होते, जसजसे आपण अधिक शिकतो**. एकदा आपण पुरेसे शिकलो की, एजंटसाठी लक्ष्य साध्य करणे सोपे होते, आणि पथ लांबी कमी होऊ लागते. परंतु, आपण अजूनही अन्वेषणासाठी खुले असतो, त्यामुळे आपण अनेकदा सर्वोत्तम पथापासून दूर जातो आणि नवीन पर्यायांचा शोध घेतो, ज्यामुळे पथ लांब होतो.
|
|
|
|
- **लांबी अचानक वाढते**. या ग्राफवर आपण हे देखील पाहतो की, एका टप्प्यावर लांबी अचानक वाढली. याचा अर्थ प्रक्रियेचा अनिश्चित स्वभाव आहे, आणि कधीकधी आपण Q-Table गुणांक नवीन मूल्यांसह अधिलेखित करून "बिघडवू" शकतो. हे आदर्शतः शिकण्याचा दर कमी करून (उदाहरणार्थ, प्रशिक्षणाच्या शेवटी, आपण Q-Table मूल्ये फक्त लहान मूल्याने समायोजित करतो) कमी केले पाहिजे.
|
|
|
|
एकूणच, हे लक्षात ठेवणे महत्त्वाचे आहे की शिकण्याच्या प्रक्रियेचे यश आणि गुणवत्ता शिकण्याचा दर, शिकण्याचा दर घट, आणि सवलत घटक यासारख्या पॅरामीटर्सवर मोठ्या प्रमाणात अवलंबून असते. यांना **हायपरपॅरामीटर्स** म्हणतात, जे **पॅरामीटर्स** पासून वेगळे आहेत, जे आपण प्रशिक्षणादरम्यान ऑप्टिमाइझ करतो (उदाहरणार्थ, Q-Table गुणांक). सर्वोत्तम हायपरपॅरामीटर मूल्ये शोधण्याच्या प्रक्रियेस **हायपरपॅरामीटर ऑप्टिमायझेशन** म्हणतात, आणि यासाठी स्वतंत्र विषय आवश्यक आहे.
|
|
|
|
## [व्याख्यानानंतरचा क्विझ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## असाइनमेंट
|
|
[एक अधिक वास्तववादी जग](assignment.md)
|
|
|
|
---
|
|
|
|
**अस्वीकरण**:
|
|
हा दस्तऐवज AI भाषांतर सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) चा वापर करून भाषांतरित करण्यात आला आहे. आम्ही अचूकतेसाठी प्रयत्नशील असलो तरी, कृपया लक्षात घ्या की स्वयंचलित भाषांतरांमध्ये त्रुटी किंवा अचूकतेचा अभाव असू शकतो. मूळ भाषेतील मूळ दस्तऐवज हा अधिकृत स्रोत मानला जावा. महत्त्वाच्या माहितीसाठी व्यावसायिक मानवी भाषांतराची शिफारस केली जाते. या भाषांतराचा वापर केल्यामुळे उद्भवणाऱ्या कोणत्याही गैरसमज किंवा चुकीच्या अर्थासाठी आम्ही जबाबदार राहणार नाही. |