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.
258 lines
31 KiB
258 lines
31 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "911efd5e595089000cb3c16fce1beab8",
|
|
"translation_date": "2025-09-06T06:39:07+00:00",
|
|
"source_file": "8-Reinforcement/1-QLearning/README.md",
|
|
"language_code": "ne"
|
|
}
|
|
-->
|
|
# परिचय: रिइन्फोर्समेन्ट लर्निङ र 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। यसले "र्यान्डम वाक" नीतिलाई प्रतिनिधित्व गर्दछ, किनभने प्रत्येक अवस्थामा सबै चालहरू समान रूपमा राम्रो छन्। हामी बोर्डमा तालिका देखाउन `plot` कार्यमा Q-टेबल पास गर्न सक्छौं: `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) प्रयोग गरेर अनुवाद गरिएको छ। हामी शुद्धताको लागि प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छ। यसको मूल भाषा मा रहेको मूल दस्तावेज़लाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुने छैनौं। |