|
|
# റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗിനും ക്യൂ-ലേണിംഗിനും പരിചയം
|
|
|
|
|
|
|
|
|
> സ്കെച്ച്നോട്ട് [Tomomi Imura](https://www.twitter.com/girlie_mac) tarafından
|
|
|
|
|
|
റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗ് മൂന്ന് പ്രധാന ആശയങ്ങൾ ഉൾക്കൊള്ളുന്നു: ഏജന്റ്, ചില സ്റ്റേറ്റുകൾ, ഓരോ സ്റ്റേറ്റിനും ഒരു ക്രമീകരിച്ച പ്രവർത്തനസമൂഹം. ഒരു നിശ്ചിത സ്റ്റേറ്റിൽ ഒരു പ്രവർത്തനം നടപ്പിലാക്കുമ്പോൾ, ഏജന്റിന് ഒരു റിവാർഡ് ലഭിക്കും. വീണ്ടും കമ്പ്യൂട്ടർ ഗെയിം സൂപ്പർ മാരിയോയെ കണക്കിലെടുക്കുക. നിങ്ങൾ മാരിയോയാണ്, നിങ്ങൾ ഒരു ഗെയിം ലെവലിൽ, ഒരു കുന്നിന്റെ അരികിൽ നിൽക്കുന്നു. നിങ്ങളുടെ മുകളിൽ ഒരു നാണയം ഉണ്ട്. നിങ്ങൾ മാരിയോ ആയതിനാൽ, ഒരു ഗെയിം ലെവലിൽ, ഒരു പ്രത്യേക സ്ഥാനത്ത് ... അത് നിങ്ങളുടെ സ്റ്റേറ്റ് ആണ്. വലത്തേക്ക് ഒരു പടി നീങ്ങുന്നത് (ഒരു പ്രവർത്തനം) നിങ്ങളെ അരികിൽ കൊണ്ടുപോകും, അത് കുറഞ്ഞ സംഖ്യാത്മക സ്കോർ നൽകും. എന്നാൽ, ജമ്പ് ബട്ടൺ അമർത്തുന്നത് നിങ്ങൾക്ക് ഒരു പോയിന്റ് നേടാൻ അനുവദിക്കും, നിങ്ങൾ ജീവിച്ചിരിക്കും. അത് ഒരു പോസിറ്റീവ് ഫലം ആണ്, അതിനാൽ നിങ്ങൾക്ക് പോസിറ്റീവ് സംഖ്യാത്മക സ്കോർ ലഭിക്കണം.
|
|
|
|
|
|
റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗ് ഉപയോഗിച്ച് ഒരു സിമുലേറ്റർ (ഗെയിം) ഉപയോഗിച്ച്, നിങ്ങൾ ഗെയിം കളിക്കാൻ പഠിച്ച് റിവാർഡ് പരമാവധി നേടാൻ കഴിയും, അതായത് ജീവിച്ചിരിക്കുക, കൂടുതൽ പോയിന്റുകൾ നേടുക.
|
|
|
|
|
|
[](https://www.youtube.com/watch?v=lDq_en8RNOo)
|
|
|
|
|
|
> 🎥 മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്ത് ഡ്മിത്രി റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗ് ചർച്ച ചെയ്യുന്നത് കേൾക്കുക
|
|
|
|
|
|
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## മുൻപരിചയങ്ങളും സജ്ജീകരണവും
|
|
|
|
|
|
ഈ പാഠത്തിൽ, നാം പൈത്തൺ കോഡിൽ ചില പരീക്ഷണങ്ങൾ നടത്തും. നിങ്ങൾക്ക് ഈ പാഠത്തിലെ 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) ഫയൽ കൂടി ഡൗൺലോഡ് ചെയ്ത് നോട്ട്ബുക്കിന്റെ സമാന ഡയറക്ടറിയിൽ ചേർക്കണം.
|
|
|
|
|
|
## പരിചയം
|
|
|
|
|
|
ഈ പാഠത്തിൽ, നാം **[പീറ്ററും വുൾഫും](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** എന്ന ലോകം അന്വേഷിക്കും, റഷ്യൻ സംഗീതസംവിധായകൻ [സെർഗെയ് പ്രൊകോഫിയേവ്](https://en.wikipedia.org/wiki/Sergei_Prokofiev) രചിച്ച സംഗീതപരമായ ഒരു ഫെയറി ടെയിൽ പ്രചോദനമായി. നാം **റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗ്** ഉപയോഗിച്ച് പീറ്റർ തന്റെ പരിസരം അന്വേഷിക്കുകയും, രുചികരമായ ആപ്പിളുകൾ ശേഖരിക്കുകയും, വുൾഫിനെ കാണാതിരിക്കുകയും ചെയ്യും.
|
|
|
|
|
|
**റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗ്** (RL) ഒരു പഠന സാങ്കേതിക വിദ്യയാണ്, ഇത് ഏജന്റിന്റെ ഒരു **പരിസരത്തിൽ** ഏറ്റവും ഉത്തമമായ പെരുമാറ്റം പഠിക്കാൻ അനുമതിയുള്ളതാണ്, പല പരീക്ഷണങ്ങൾ നടത്തിക്കൊണ്ട്. ഈ പരിസരത്തിലെ ഏജന്റിന് ഒരു **ലക്ഷ്യം** ഉണ്ടാകണം, അത് ഒരു **റിവാർഡ് ഫംഗ്ഷൻ** വഴി നിർവചിക്കപ്പെടുന്നു.
|
|
|
|
|
|
## പരിസരം
|
|
|
|
|
|
സൗകര്യത്തിന്, പീറ്ററിന്റെ ലോകം `width` x `height` വലിപ്പമുള്ള ഒരു ചതുര് ബോർഡ് ആണെന്ന് കരുതാം, ഇങ്ങനെ:
|
|
|
|
|
|
|
|
|
|
|
|
ഈ ബോർഡിലെ ഓരോ സെല്ലും താഴെ പറയുന്നവയിൽ ഒന്നായിരിക്കും:
|
|
|
|
|
|
* **നിലം**, പീറ്ററും മറ്റ് ജീവികളും നടക്കാൻ കഴിയുന്ന സ്ഥലം.
|
|
|
* **വെള്ളം**, ഇവിടെ നിങ്ങൾ നടക്കാൻ കഴിയില്ല.
|
|
|
* **മരം** അല്ലെങ്കിൽ **പുല്ല്**, വിശ്രമിക്കാൻ കഴിയുന്ന സ്ഥലം.
|
|
|
* **ആപ്പിൾ**, പീറ്റർ കണ്ടെത്താൻ ആഗ്രഹിക്കുന്ന ഭക്ഷണം.
|
|
|
* **വുൾഫ്**, അപകടകരമായത്, ഒഴിവാക്കേണ്ടത്.
|
|
|
|
|
|
[`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()) }
|
|
|
```
|
|
|
|
|
|
സംക്ഷേപിച്ച്, ഈ സീനാരിയോയുടെ തന്ത്രവും ലക്ഷ്യവും ഇപ്രകാരം ആണ്:
|
|
|
|
|
|
- **തന്ത്രം**, നമ്മുടെ ഏജന്റ് (പീറ്റർ) നിർവചിക്കുന്നത് ഒരു **നയം** (policy) എന്ന ഫംഗ്ഷൻ വഴി ആണ്. ഒരു നയം ഏതെങ്കിലും സ്റ്റേറ്റിൽ പ്രവർത്തനം തിരികെ നൽകുന്ന ഫംഗ്ഷനാണ്. നമ്മുടെ പ്രശ്നത്തിലെ സ്റ്റേറ്റ് ബോർഡും കളിക്കാരന്റെ നിലവിലെ സ്ഥാനവും ഉൾക്കൊള്ളുന്നു.
|
|
|
|
|
|
- **ലക്ഷ്യം**, റീഇൻഫോഴ്സ്മെന്റ് ലേണിംഗിന്റെ ലക്ഷ്യം നല്ല ഒരു നയം പഠിച്ച് പ്രശ്നം ഫലപ്രദമായി പരിഹരിക്കുക ആണ്. എന്നാൽ അടിസ്ഥാനമായി, ഏറ്റവും ലളിതമായ നയം **റാൻഡം വാക്ക്** എന്നതാണ്.
|
|
|
|
|
|
## റാൻഡം വാക്ക്
|
|
|
|
|
|
ആദ്യം നാം റാൻഡം വാക്ക് തന്ത്രം നടപ്പിലാക്കി പ്രശ്നം പരിഹരിക്കാം. റാൻഡം വാക്കിൽ, അനുവദിച്ച പ്രവർത്തനങ്ങളിൽ നിന്ന് അടുത്ത പ്രവർത്തനം യാദൃച്ഛികമായി തിരഞ്ഞെടുക്കും, ആപ്പിൾ കണ്ടെത്തുന്നത് വരെ (കോഡ് ബ്ലോക്ക് 3).
|
|
|
|
|
|
1. താഴെ കൊടുത്ത കോഡ് ഉപയോഗിച്ച് റാൻഡം വാക്ക് നടപ്പിലാക്കുക:
|
|
|
|
|
|
```python
|
|
|
def random_policy(m):
|
|
|
return random.choice(list(actions))
|
|
|
|
|
|
def walk(m,policy,start_position=None):
|
|
|
n = 0 # ചുവടുകളുടെ എണ്ണം
|
|
|
# പ്രാരംഭ സ്ഥാനം സജ്ജമാക്കുക
|
|
|
if start_position:
|
|
|
m.human = start_position
|
|
|
else:
|
|
|
m.random_start()
|
|
|
while True:
|
|
|
if m.at() == Board.Cell.apple:
|
|
|
return n # വിജയം!
|
|
|
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
|
|
|
return -1 # വൃക്കയാൽ കഴിക്കപ്പെട്ടു അല്ലെങ്കിൽ മുങ്ങി
|
|
|
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) # യഥാർത്ഥ നീക്കം ചെയ്യുക
|
|
|
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
|
|
|
```
|
|
|
|
|
|
റിവാർഡ് ഫംഗ്ഷനുകളുടെ ഒരു രസകരമായ കാര്യം, പലപ്പോഴും *നമുക്ക് ഗെയിം അവസാനത്തിൽ മാത്രമേ വലിയ റിവാർഡ് ലഭിക്കൂ* എന്നതാണ്. അതായത്, നമ്മുടെ ആൽഗോരിതം "നല്ല" പടികൾ ഓർമ്മിച്ച് അവയുടെ പ്രാധാന്യം വർദ്ധിപ്പിക്കണം. അതുപോലെ, മോശം ഫലങ്ങളിലേക്കുള്ള എല്ലാ ചലനങ്ങളും നിരുത്സാഹപ്പെടുത്തണം.
|
|
|
|
|
|
## ക്യൂ-ലേണിംഗ്
|
|
|
|
|
|
നാം ഇവിടെ ചർച്ച ചെയ്യാൻ പോകുന്ന ആൽഗോരിതം **ക്യൂ-ലേണിംഗ്** എന്നാണ്. ഈ ആൽഗോരിതത്തിൽ, നയം ഒരു ഫംഗ്ഷൻ (അഥവാ ഡാറ്റാ സ്ട്രക്ചർ) ആയ **ക്യൂ-ടേബിൾ** എന്നതിലൂടെ നിർവചിക്കപ്പെടുന്നു. ഇത് ഓരോ സ്റ്റേറ്റിലെയും പ്രവർത്തനങ്ങളുടെ "നല്ലത്വം" രേഖപ്പെടുത്തുന്നു.
|
|
|
|
|
|
ഇത് ക്യൂ-ടേബിൾ എന്ന് വിളിക്കുന്നത്, സാധാരണയായി ഒരു ടേബിൾ അല്ലെങ്കിൽ ബഹുമാനസമമായ അറേ ആയി പ്രതിനിധാനം ചെയ്യുന്നത് സൗകര്യമുള്ളതിനാൽ ആണ്. നമ്മുടെ ബോർഡിന് `width` x `height` അളവുകൾ ഉള്ളതിനാൽ, നാം ക്യൂ-ടേബിൾ numpy അറേ ആയി പ്രതിനിധാനം ചെയ്യാം, ആകൃതി `width` x `height` x `len(actions)`: (കോഡ് ബ്ലോക്ക് 6)
|
|
|
|
|
|
```python
|
|
|
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
|
|
|
```
|
|
|
|
|
|
നാം ക്യൂ-ടേബിളിലെ എല്ലാ മൂല്യങ്ങളും സമാനമായ മൂല്യത്തോടെ, നമ്മുടെ കേസിൽ 0.25, ആരംഭിക്കുന്നു. ഇത് "റാൻഡം വാക്ക്" നയത്തിന് പൊരുത്തപ്പെടുന്നു, കാരണം ഓരോ സ്റ്റേറ്റിലും എല്ലാ ചലനങ്ങളും സമാനമായി നല്ലതാണ്. നാം `plot` ഫംഗ്ഷനിലേക്ക് ക്യൂ-ടേബിൾ പാസ്സ് ചെയ്ത് ബോർഡിൽ ടേബിൾ ദൃശ്യവൽക്കരിക്കാം: `m.plot(Q)`.
|
|
|
|
|
|
|
|
|
|
|
|
ഓരോ സെല്ലിന്റെ മദ്ധ്യത്തിൽ ഒരു "അറ" കാണിക്കുന്നു, അത് പ്രിയപ്പെട്ട ചലന ദിശ സൂചിപ്പിക്കുന്നു. എല്ലാ ദിശകളും സമാനമായതിനാൽ, ഒരു ഡോട്ട് പ്രദർശിപ്പിക്കുന്നു.
|
|
|
|
|
|
ഇപ്പോൾ നാം സിമുലേഷൻ നടത്തണം, പരിസരം അന്വേഷിച്ച്, ക്യൂ-ടേബിൾ മൂല്യങ്ങളുടെ മികച്ച വിതരണവും പഠിക്കണം, ഇത് ആപ്പിള് കണ്ടെത്താനുള്ള പാത വേഗത്തിൽ കണ്ടെത്താൻ സഹായിക്കും.
|
|
|
|
|
|
## ക്യൂ-ലേണിംഗിന്റെ സാരാംശം: ബെൽമാൻ സമവാക്യം
|
|
|
|
|
|
നാം ചലനം ആരംഭിക്കുമ്പോൾ, ഓരോ പ്രവർത്തനത്തിനും അനുയോജ്യമായ റിവാർഡ് ഉണ്ടാകും, അതായത് നാം തിയറിയിൽ ഏറ്റവും ഉയർന്ന തൽസമയ റിവാർഡിന്റെ അടിസ്ഥാനത്തിൽ അടുത്ത പ്രവർത്തനം തിരഞ്ഞെടുക്കാം. എന്നാൽ, പല സ്റ്റേറ്റുകളിലും, ആ ചലനം ആപ്പിള് കണ്ടെത്താനുള്ള ലക്ഷ്യം നേടില്ല, അതിനാൽ ഏത് ദിശ മികച്ചതാണെന്ന് ഉടൻ തീരുമാനിക്കാൻ കഴിയില്ല.
|
|
|
|
|
|
> ഉടൻ ഫലം പ്രധാനമല്ല, സിമുലേഷൻ അവസാനം ലഭിക്കുന്ന അന്തിമ ഫലമാണ് പ്രധാനമെന്ന് ഓർക്കുക.
|
|
|
|
|
|
ഈ വൈകിയ റിവാർഡ് പരിഗണിക്കാൻ, നാം **[ഡൈനാമിക് പ്രോഗ്രാമിംഗ്](https://en.wikipedia.org/wiki/Dynamic_programming)** ന്റെ സിദ്ധാന്തങ്ങൾ ഉപയോഗിക്കണം, ഇത് പ്രശ്നത്തെ പുനരാവർത്തനമായി ചിന്തിക്കാൻ സഹായിക്കുന്നു.
|
|
|
|
|
|
നമുക്ക് ഇപ്പോൾ സ്റ്റേറ്റ് *s* ൽ ഉണ്ടെന്ന് കരുതുക, അടുത്ത സ്റ്റേറ്റ് *s'* ലേക്ക് പോകാൻ ആഗ്രഹിക്കുന്നു. അങ്ങനെ ചെയ്താൽ, നാം റിവാർഡ് ഫംഗ്ഷൻ നിർവചിക്കുന്ന തൽസമയ റിവാർഡ് *r(s,a)* ലഭിക്കും, കൂടാതെ ഭാവി റിവാർഡ് കൂടി. നമ്മുടെ ക്യൂ-ടേബിൾ ഓരോ പ്രവർത്തനത്തിന്റെ "ആകർഷകത" ശരിയായി പ്രതിഫലിപ്പിക്കുന്നുവെന്ന് കരുതിയാൽ, സ്റ്റേറ്റ് *s'* ൽ ഏറ്റവും ഉയർന്ന മൂല്യമുള്ള *Q(s',a')* പ്രവർത്തനം *a* തിരഞ്ഞെടുക്കും. അതിനാൽ, സ്റ്റേറ്റ് *s* ൽ ലഭിക്കാവുന്ന മികച്ച ഭാവി റിവാർഡ് `max`<sub>a'</sub>*Q(s',a')* ആയി നിർവചിക്കാം (max എല്ലാ പ്രവർത്തനങ്ങൾക്കുമുള്ളതാണ്).
|
|
|
|
|
|
ഇത് സ്റ്റേറ്റ് *s* ൽ പ്രവർത്തനം *a* നുള്ള ക്യൂ-ടേബിൾ മൂല്യം കണക്കാക്കാനുള്ള **ബെൽമാൻ ഫോർമുല** നൽകുന്നു:
|
|
|
|
|
|
<img src="../../../../translated_images/ml/bellman-equation.7c0c4c722e5a6b7c.webp"/>
|
|
|
|
|
|
ഇവിടെ γ എന്നത് **ഡിസ്കൗണ്ട് ഫാക്ടർ** ആണ്, ഇത് നിലവിലെ റിവാർഡ് ഭാവി റിവാർഡിനേക്കാൾ എത്രമാത്രം മുൻഗണന നൽകണമെന്ന് നിർണ്ണയിക്കുന്നു.
|
|
|
|
|
|
## പഠന ആൽഗോരിതം
|
|
|
|
|
|
മുകളിൽ നൽകിയ സമവാക്യം അടിസ്ഥാനമാക്കി, നാം പഠന ആൽഗോരിതത്തിനുള്ള പseudo-കോഡ് എഴുതാം:
|
|
|
|
|
|
* എല്ലാ സ്റ്റേറ്റുകളിലും പ്രവർത്തനങ്ങളിലും സമാന സംഖ്യകൾ ഉപയോഗിച്ച് ക്യൂ-ടേബിൾ Q ആരംഭിക്കുക
|
|
|
* പഠന നിരക്ക് α ← 1 ആയി സജ്ജമാക്കുക
|
|
|
* സിമുലേഷൻ പല തവണ ആവർത്തിക്കുക
|
|
|
1. യാദൃച്ഛിക സ്ഥാനത്ത് ആരംഭിക്കുക
|
|
|
1. ആവർത്തിക്കുക
|
|
|
1. സ്റ്റേറ്റ് *s* ൽ പ്രവർത്തനം *a* തിരഞ്ഞെടുക്കുക
|
|
|
2. പ്രവർത്തനം നടപ്പിലാക്കി പുതിയ സ്റ്റേറ്റ് *s'* ലേക്ക് പോകുക
|
|
|
3. ഗെയിം അവസാന സ്ഥിതി കണ്ടാൽ അല്ലെങ്കിൽ മൊത്തം റിവാർഡ് വളരെ കുറവായാൽ സിമുലേഷൻ അവസാനിപ്പിക്കുക
|
|
|
4. പുതിയ സ്റ്റേറ്റിൽ റിവാർഡ് *r* കണക്കാക്കുക
|
|
|
5. ബെൽമാൻ സമവാക്യം അനുസരിച്ച് Q-ഫംഗ്ഷൻ അപ്ഡേറ്റ് ചെയ്യുക: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
|
|
|
6. *s* ← *s'*
|
|
|
7. മൊത്തം റിവാർഡ് അപ്ഡേറ്റ് ചെയ്ത് α കുറയ്ക്കുക.
|
|
|
|
|
|
## എക്സ്പ്ലോയിറ്റ് vs. എക്സ്പ്ലോർ
|
|
|
|
|
|
മുകളിൽ നൽകിയ ആൽഗോരിതത്തിൽ, 2.1 ഘട്ടത്തിൽ പ്രവർത്തനം എങ്ങനെ തിരഞ്ഞെടുക്കണമെന്ന് വ്യക്തമാക്കിയിട്ടില്ല. പ്രവർത്തനം യാദൃച്ഛികമായി തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ, നാം പരിസരം യാദൃച്ഛികമായി **അന്വേഷിക്കും**; പലപ്പോഴും മരിക്കുകയും സാധാരണ പോകാത്ത പ്രദേശങ്ങൾ പരിശോധിക്കുകയും ചെയ്യും. മറ്റൊരു മാർഗം, നാം ഇതിനകം അറിയുന്ന ക്യൂ-ടേബിൾ മൂല്യങ്ങൾ **ഉപയോഗിച്ച്** (എക്സ്പ്ലോയിറ്റ് ചെയ്ത്) ഏറ്റവും നല്ല പ്രവർത്തനം (കൂടുതൽ Q-മൂല്യമുള്ളത്) തിരഞ്ഞെടുക്കുക ആണ്. എന്നാൽ ഇത് മറ്റ് സ്റ്റേറ്റുകൾ പരിശോധിക്കുന്നത് തടയും, അതിനാൽ ഏറ്റവും ഉത്തമ പരിഹാരം കണ്ടെത്താൻ കഴിയാതെ പോകാം.
|
|
|
|
|
|
അതിനാൽ, ഏറ്റവും നല്ല മാർഗം എക്സ്പ്ലോറേഷനും എക്സ്പ്ലോയിറ്റേഷനും ഇടയിൽ സമതുലനം പുലർത്തുകയാണ്. ഇത് സ്റ്റേറ്റ് *s* ൽ പ്രവർത്തനം തിരഞ്ഞെടുക്കുമ്പോൾ ക്യൂ-ടേബിളിലെ മൂല്യങ്ങളുടെ അനുപാതത്തിൽ സാധ്യതകൾ ഉപയോഗിച്ച് ചെയ്യാം. തുടക്കത്തിൽ, ക്യൂ-ടേബിൾ മൂല്യങ്ങൾ എല്ലാം സമാനമായതിനാൽ ഇത് യാദൃച്ഛിക തിരഞ്ഞെടുപ്പായി കാണപ്പെടും, എന്നാൽ പരിസരം കൂടുതൽ പഠിക്കുമ്പോൾ, ഏജന്റ് ചിലപ്പോൾ പരീക്ഷിക്കാത്ത പാത തിരഞ്ഞെടുക്കാൻ അനുവദിച്ച്, ഏറ്റവും ഉത്തമ മാർഗം പിന്തുടരാൻ സാധ്യത കൂടുതലാകും.
|
|
|
|
|
|
## പൈത്തൺ നടപ്പാക്കൽ
|
|
|
|
|
|
ഇപ്പോൾ നാം പഠന ആൽഗോരിതം നടപ്പിലാക്കാൻ തയ്യാറാണ്. അതിന് മുമ്പ്, ക്യൂ-ടേബിളിലെ യാദൃച്ഛിക സംഖ്യകൾ പ്രവർത്തനങ്ങൾക്ക് അനുയോജ്യമായ സാധ്യതാ വെക്ടറായി മാറ്റുന്ന ഒരു ഫംഗ്ഷൻ വേണം.
|
|
|
|
|
|
1. `probs()` എന്ന ഫംഗ്ഷൻ സൃഷ്ടിക്കുക:
|
|
|
|
|
|
```python
|
|
|
def probs(v,eps=1e-4):
|
|
|
v = v-v.min()+eps
|
|
|
v = v/v.sum()
|
|
|
return v
|
|
|
```
|
|
|
|
|
|
തുടക്കത്തിൽ വെക്ടറിലെ എല്ലാ ഘടകങ്ങളും സമാനമായതിനാൽ 0-ൽ വിഭജിക്കൽ ഒഴിവാക്കാൻ കുറച്ച് `eps` ചേർക്കുന്നു.
|
|
|
|
|
|
5000 പരീക്ഷണങ്ങൾ (എപ്പോക്കുകൾ) വഴി പഠന ആൽഗോരിതം ഓടിക്കുക: (കോഡ് ബ്ലോക്ക് 8)
|
|
|
```python
|
|
|
for epoch in range(5000):
|
|
|
|
|
|
# പ്രാരംഭ ബിന്ദു തിരഞ്ഞെടുക്കുക
|
|
|
m.random_start()
|
|
|
|
|
|
# യാത്ര ആരംഭിക്കുക
|
|
|
n=0
|
|
|
cum_reward = 0
|
|
|
while True:
|
|
|
x,y = m.human
|
|
|
v = probs(Q[x,y])
|
|
|
a = random.choices(list(actions),weights=v)[0]
|
|
|
dpos = actions[a]
|
|
|
m.move(dpos,check_correctness=False) # കളിക്കാരന് ബോർഡിന് പുറത്തേക്ക് നീങ്ങാൻ അനുവദിക്കുന്നു, ഇത് എപ്പിസോഡ് അവസാനിപ്പിക്കുന്നു
|
|
|
r = reward(m)
|
|
|
cum_reward += r
|
|
|
if r==end_reward or cum_reward < -1000:
|
|
|
lpath.append(n)
|
|
|
break
|
|
|
alpha = np.exp(-n / 10e5)
|
|
|
gamma = 0.5
|
|
|
ai = action_idx[a]
|
|
|
Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max())
|
|
|
n+=1
|
|
|
```
|
|
|
|
|
|
ഈ ആൽഗോരിതം നടപ്പിലാക്കിയ ശേഷം, ക്യൂ-ടേബിൾ ഓരോ ഘട്ടത്തിലും വിവിധ പ്രവർത്തനങ്ങളുടെ ആകർഷകത നിർവചിക്കുന്ന മൂല്യങ്ങളാൽ അപ്ഡേറ്റ് ചെയ്യപ്പെടും. നാം ക്യൂ-ടേബിൾ ദൃശ്യവൽക്കരിക്കാൻ ഓരോ സെല്ലിലും ഒരു വെക്ടർ വരയ്ക്കാം, അത് ആഗ്രഹിക്കുന്ന ചലന ദിശ കാണിക്കും. ലളിതത്വത്തിന്, അറിന്റെ തലക്കെട്ട് പകരം ചെറിയ വൃത്തം വരയ്ക്കുന്നു.
|
|
|
|
|
|
<img src="../../../../translated_images/ml/learned.ed28bcd8484b5287.webp"/>
|
|
|
|
|
|
## നയം പരിശോധിക്കൽ
|
|
|
|
|
|
ക്യൂ-ടേബിൾ ഓരോ സ്റ്റേറ്റിലും ഓരോ പ്രവർത്തനത്തിന്റെ "ആകർഷകത" പട്ടികയാക്കുന്നതിനാൽ, ഇത് ഉപയോഗിച്ച് നമ്മുടെ ലോകത്ത് ഫലപ്രദമായ നാവിഗേഷൻ നിർവചിക്കുക എളുപ്പമാണ്. ലളിതമായ സാഹചര്യത്തിൽ, ഏറ്റവും ഉയർന്ന ക്യൂ-ടേബിൾ മൂല്യമുള്ള പ്രവർത്തനം തിരഞ്ഞെടുക്കാം: (കോഡ് ബ്ലോക്ക് 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` ലൂപ്പിംഗ് തടയും, എങ്കിലും ഏജന്റ് രക്ഷപ്പെടാൻ കഴിയാത്ത ഒരു സ്ഥലത്ത് "പിടിച്ചുപോകാൻ" സാധ്യതയുണ്ട്.
|
|
|
|
|
|
## നാവിഗേഷൻ
|
|
|
|
|
|
പരിശീലന സമയത്ത് ഉപയോഗിച്ച നാവിഗേഷൻ നയം മെച്ചപ്പെട്ടതാണ്, ഇത് എക്സ്പ്ലോയിറ്റേഷൻ (exploitation) ഉം എക്സ്പ്ലോറേഷൻ (exploration) ഉം സംയോജിപ്പിക്കുന്നു. ഈ നയത്തിൽ, Q-ടേബിളിലെ മൂല്യങ്ങൾക്ക് അനുപാതമായി ഓരോ ആക്ഷനും ഒരു നിശ്ചിത സാധ്യതയോടെ തിരഞ്ഞെടുക്കപ്പെടും. ഈ തന്ത്രം ഏജന്റ് മുമ്പ് പരിശോധിച്ച സ്ഥാനത്തേക്ക് തിരികെ പോകാൻ ഇടയുണ്ടാക്കാം, പക്ഷേ താഴെ കൊടുത്ത കോഡിൽ കാണുന്നതുപോലെ, ഇത് ആഗ്രഹിച്ച സ്ഥലത്തേക്ക് വളരെ ചെറുതായ ശരാശരി പാത നൽകുന്നു (`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 പരിധിയിൽ ലഭിക്കണം.
|
|
|
|
|
|
## പഠന പ്രക്രിയ പരിശോധിക്കൽ
|
|
|
|
|
|
പഠന പ്രക്രിയ പ്രശ്നത്തിന്റെ ഘടനയെക്കുറിച്ചുള്ള അറിവ് കണ്ടെത്തലും പരീക്ഷണവും തമ്മിലുള്ള സമതുല്യമാണ്. പഠന ഫലങ്ങൾ (ഏജന്റിന് ലക്ഷ്യത്തിലേക്ക് ചെറുതായ പാത കണ്ടെത്താൻ സഹായിക്കുന്ന കഴിവ്) മെച്ചപ്പെട്ടതായി കാണാം, എന്നാൽ പഠന പ്രക്രിയയിൽ ശരാശരി പാത നീളം എങ്ങനെ പെരുമാറുന്നു എന്ന് നിരീക്ഷിക്കാനും താൽപര്യമുണ്ട്:
|
|
|
|
|
|
<img src="../../../../translated_images/ml/lpathlen1.0534784add58d4eb.webp"/>
|
|
|
|
|
|
പഠനങ്ങൾ ചുരുക്കി പറയാം:
|
|
|
|
|
|
- **ശരാശരി പാത നീളം വർദ്ധിക്കുന്നു**. ആദ്യം ശരാശരി പാത നീളം വർദ്ധിക്കുന്നതായി കാണുന്നു. ഇത് പരിസ്ഥിതി കുറിച്ച് ഒന്നും അറിയാത്തപ്പോൾ, മോശം സ്റ്റേറ്റുകളിൽ, വെള്ളത്തിൽ അല്ലെങ്കിൽ വംശഹത്യയിൽ കുടുങ്ങാനുള്ള സാധ്യത കൂടുതലായതിനാലാണ്. കൂടുതൽ പഠിച്ച് അറിവ് ഉപയോഗിക്കാൻ തുടങ്ങുമ്പോൾ, പരിസ്ഥിതിയെ കൂടുതൽ കാലം പരിശോധിക്കാം, പക്ഷേ ആപ്പിളുകൾ എവിടെ എന്നറിയില്ല.
|
|
|
|
|
|
- **പാത നീളം കുറയുന്നു, കൂടുതൽ പഠിക്കുമ്പോൾ**. മതിയായ പഠനം കഴിഞ്ഞാൽ, ഏജന്റിന് ലക്ഷ്യം നേടാൻ എളുപ്പമാകും, പാത നീളം കുറയാൻ തുടങ്ങും. എങ്കിലും പരീക്ഷണത്തിന് തുറന്നിരിക്കുകയാണെങ്കിൽ, ഏറ്റവും നല്ല പാതയിൽ നിന്ന് പലപ്പോഴും വ്യത്യസ്തമായി പുതിയ ഓപ്ഷനുകൾ പരിശോധിച്ച് പാത നീളം പരമാവധി ആയേക്കാം.
|
|
|
|
|
|
- **നീളം അപ്രതീക്ഷിതമായി വർദ്ധിക്കുന്നു**. ഈ ഗ്രാഫിൽ മറ്റൊരു ശ്രദ്ധേയമായ കാര്യം, ചിലപ്പോൾ പാത നീളം അപ്രതീക്ഷിതമായി വർദ്ധിക്കുന്നതാണ്. ഇത് പ്രക്രിയയുടെ സ്ടോക്കാസ്റ്റിക് സ്വഭാവം സൂചിപ്പിക്കുന്നു, പുതിയ മൂല്യങ്ങൾ കൊണ്ട് Q-ടേബിള് കോഫിഷ്യന്റുകൾ മറച്ചുവെക്കപ്പെടാൻ സാധ്യതയുണ്ട്. ഇത് കുറയ്ക്കാൻ പഠന നിരക്ക് കുറയ്ക്കണം (ഉദാഹരണത്തിന്, പരിശീലനത്തിന്റെ അവസാനം Q-ടേബിള് മൂല്യങ്ങൾ ചെറിയ മൂല്യത്തോടെ മാത്രം ക്രമീകരിക്കുക).
|
|
|
|
|
|
മൊത്തത്തിൽ, പഠന പ്രക്രിയയുടെ വിജയം, ഗുണമേന്മ എന്നിവ പഠന നിരക്ക്, പഠന നിരക്ക് കുറവ്, ഡിസ്കൗണ്ട് ഫാക്ടർ പോലുള്ള പാരാമീറ്ററുകളിൽ ആശ്രയിച്ചിരിക്കുന്നു. ഇവയെ സാധാരണയായി **ഹൈപ്പർപാരാമീറ്ററുകൾ** എന്ന് വിളിക്കുന്നു, പരിശീലന സമയത്ത് ഞങ്ങൾ മെച്ചപ്പെടുത്തുന്ന **പാരാമീറ്ററുകൾ** (ഉദാഹരണത്തിന്, Q-ടേബിള് കോഫിഷ്യന്റുകൾ) എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമാണ്. മികച്ച ഹൈപ്പർപാരാമീറ്റർ മൂല്യങ്ങൾ കണ്ടെത്തുന്ന പ്രക്രിയ **ഹൈപ്പർപാരാമീറ്റർ ഓപ്റ്റിമൈസേഷൻ** എന്ന് വിളിക്കുന്നു, ഇത് ഒരു പ്രത്യേക വിഷയം ആണ്.
|
|
|
|
|
|
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## അസൈൻമെന്റ്
|
|
|
[ഒരു കൂടുതൽ യാഥാർത്ഥ്യപരമായ ലോകം](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**അസൂയാ**:
|
|
|
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
