|
|
# ரீன்போர்ஸ்மென்ட் லெர்னிங் மற்றும் Q-லெர்னிங் அறிமுகம்
|
|
|
|
|
|
|
|
|
> ஸ்கெட்ச் நோட்: [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
|
|
|
|
|
ரீன்போர்ஸ்மென்ட் லெர்னிங்கில் மூன்று முக்கியமான கருத்துகள் உள்ளன: ஏஜென்ட், சில நிலைகள், மற்றும் ஒவ்வொரு நிலைக்கும் ஒரு செயல்களின் தொகுப்பு. குறிப்பிட்ட நிலையில் ஒரு செயலைச் செயல்படுத்துவதன் மூலம், ஏஜென்டுக்கு ஒரு பரிசு வழங்கப்படும். மீண்டும் Super Mario என்ற கணினி விளையாட்டை நினைவில் கொள்ளுங்கள். நீங்கள் Mario, நீங்கள் ஒரு விளையாட்டு நிலைமையில், ஒரு பாறையின் விளிம்புக்கு அருகில் நிற்கிறீர்கள். உங்களுக்குப் மேலே ஒரு நாணயம் உள்ளது. நீங்கள் Mario, ஒரு விளையாட்டு நிலைமையில், ஒரு குறிப்பிட்ட இடத்தில்... அதுதான் உங்கள் நிலை. வலதுபுறம் ஒரு படி நகர்வது (ஒரு செயல்) உங்களை விளிம்புக்கு மேலே கொண்டு செல்லும், இது உங்களுக்கு குறைந்த எண் மதிப்பை வழங்கும். ஆனால், ஜம்ப் பொத்தானை அழுத்துவது உங்களுக்கு ஒரு புள்ளியைப் பெற அனுமதிக்கும் மற்றும் நீங்கள் உயிருடன் இருப்பீர்கள். இது ஒரு நேர்மறை முடிவாகும், இது உங்களுக்கு ஒரு நேர்மறை எண் மதிப்பை வழங்க வேண்டும்.
|
|
|
|
|
|
ரீன்போர்ஸ்மென்ட் லெர்னிங் மற்றும் ஒரு சிமுலேட்டரை (விளையாட்டு) பயன்படுத்தி, நீங்கள் உயிருடன் இருக்கவும், அதிக புள்ளிகளைப் பெறவும் விளையாட்டை விளையாடுவது எப்படி என்பதை கற்றுக்கொள்ளலாம்.
|
|
|
|
|
|
[](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) கோப்பையும் பெற வேண்டும், இது நோட்புக் குறியீட்டில் பயன்படுத்தப்படுகிறது. இதை நோட்புக்குடன் ஒரே அடைவில் சேர்க்கவும்.
|
|
|
|
|
|
## அறிமுகம்
|
|
|
|
|
|
இந்த பாடத்தில், ரஷியன் இசையமைப்பாளர் [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev) எழுதிய ஒரு இசை கதை மூலம் **[Peter and the Wolf](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)** உலகத்தை ஆராயப் போகிறோம். **ரீன்போர்ஸ்மென்ட் லெர்னிங்**-ஐப் பயன்படுத்தி Peter தனது சூழலை ஆராய்ந்து, சுவையான ஆப்பிள்களை சேகரித்து, ஓநாயை சந்திக்காமல் தவிர்க்க உதவுவோம்.
|
|
|
|
|
|
**ரீன்போர்ஸ்மென்ட் லெர்னிங்** (RL) என்பது ஒரு **ஏஜென்ட்** ஒரு **சூழலில்** பல பரிசோதனைகளை இயக்குவதன் மூலம் ஒரு சிறந்த நடத்தை கற்றுக்கொள்ள அனுமதிக்கும் ஒரு கற்றல் தொழில்நுட்பமாகும். இந்த சூழலில் ஒரு ஏஜென்டுக்கு **பரிசு செயல்பாடு** மூலம் வரையறுக்கப்பட்ட ஒரு **நோக்கம்** இருக்க வேண்டும்.
|
|
|
|
|
|
## சூழல்
|
|
|
|
|
|
எளிமைக்காக, Peter-ன் உலகத்தை `width` x `height` அளவுடைய ஒரு சதுர பலகையாகக் கருதுவோம், இது இவ்வாறு இருக்கும்:
|
|
|
|
|
|
|
|
|
|
|
|
இந்த பலகையின் ஒவ்வொரு செல்:
|
|
|
|
|
|
* **தரை**, Peter மற்றும் பிற உயிரினங்கள் நடக்கக்கூடிய இடம்.
|
|
|
* **நீர்**, இதில் நடக்க முடியாது.
|
|
|
* ஒரு **மரம்** அல்லது **புல்**, ஓய்வெடுக்கக்கூடிய இடம்.
|
|
|
* ஒரு **ஆப்பிள்**, Peter-க்கு உணவாக தேவைப்படும் ஒன்று.
|
|
|
* ஒரு **ஓநாய்**, இது ஆபத்தானது மற்றும் தவிர்க்கப்பட வேண்டும்.
|
|
|
|
|
|
இந்த சூழலுடன் வேலை செய்ய 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()
|
|
|
```
|
|
|
|
|
|
இந்த குறியீடு மேலே உள்ள சூழலின் படத்தை அச்சிட வேண்டும்.
|
|
|
|
|
|
## செயல்கள் மற்றும் கொள்கை
|
|
|
|
|
|
எங்கள் உதாரணத்தில், Peter-ன் நோக்கம் ஆப்பிளை கண்டுபிடிக்க வேண்டும், ஓநாய் மற்றும் பிற தடைகளை தவிர்க்க வேண்டும். இதைச் செய்ய, அவர் ஆப்பிளை கண்டுபிடிக்கும் வரை சுற்றி நடக்க முடியும்.
|
|
|
|
|
|
எனவே, எந்த இடத்திலும், அவர் கீழே உள்ள செயல்களில் ஒன்றைத் தேர்வு செய்ய முடியும்: மேலே, கீழே, இடது மற்றும் வலது.
|
|
|
|
|
|
இந்த செயல்களை ஒரு அகராதியாக வரையறுத்து, தொடர்புடைய கோஆர்டினேட் மாற்றங்களுடன் இணைப்போம். உதாரணமாக, வலதுபுறம் நகர்வது (`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()) }
|
|
|
```
|
|
|
|
|
|
இந்த சூழலின் **கொள்கை** மற்றும் **நோக்கம்** கீழே உள்ளவாறு:
|
|
|
|
|
|
- **கொள்கை**, எங்கள் ஏஜென்ட் (Peter) ஒரு **கொள்கை** மூலம் வரையறுக்கப்படுகிறது. கொள்கை என்பது எந்த நிலையிலும் செயலைத் திருப்பும் ஒரு செயல்பாடு. எங்கள் உதாரணத்தில், பிரச்சனையின் நிலை பலகை மற்றும் வீரரின் தற்போதைய நிலையை உள்ளடக்கியது.
|
|
|
|
|
|
- **நோக்கம்**, ரீன்போர்ஸ்மென்ட் லெர்னிங் ஒரு நல்ல கொள்கையை கற்றுக்கொள்வது, இது பிரச்சனையை திறமையாக தீர்க்க அனுமதிக்கும். ஆனால், அடிப்படையாக, **சீரற்ற நடை** என்ற எளிய கொள்கையைப் பரிசீலிக்கலாம்.
|
|
|
|
|
|
## சீரற்ற நடை
|
|
|
|
|
|
முதலில், சீரற்ற நடை கொள்கையை செயல்படுத்தி எங்கள் பிரச்சனையைத் தீர்ப்போம். சீரற்ற நடை மூலம், அனுமதிக்கப்பட்ட செயல்களில் இருந்து அடுத்த செயலை சீரற்ற முறையில் தேர்வு செய்வோம், ஆப்பிளை அடையும் வரை (குறியீடு தொகுதி 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 படிகள் என்பதைக் கருத்தில் கொண்டால் மிகவும் அதிகமாகும்.
|
|
|
|
|
|
Peter-ன் சீரற்ற நடை எப்படி தோன்றுகிறது என்பதை நீங்கள் காணலாம்:
|
|
|
|
|
|
|
|
|
|
|
|
## பரிசு செயல்பாடு
|
|
|
|
|
|
எங்கள் கொள்கையை மேலும் புத்திசாலியாக மாற்ற, எந்த நகர்வுகள் "சிறந்தவை" என்பதைப் புரிந்துகொள்ள வேண்டும். இதைச் செய்ய, எங்கள் நோக்கத்தை வரையறுக்க வேண்டும்.
|
|
|
|
|
|
நோக்கம் ஒரு **பரிசு செயல்பாடு** மூலம் வரையறுக்கப்படலாம், இது ஒவ்வொரு நிலைக்கும் ஒரு மதிப்பெண் மதிப்பைத் திருப்பும். எண் அதிகமாக இருக்கும், பரிசு செயல்பாடு சிறந்ததாக இருக்கும். (குறியீடு தொகுதி 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` பரிமாணங்களைக் கொண்டதால், `width` x `height` x `len(actions)` வடிவத்துடன் numpy வரிசையைப் பயன்படுத்தி Q-டேபிளை பிரதிநிதித்துவப்படுத்தலாம்: (குறியீடு தொகுதி 6)
|
|
|
|
|
|
```python
|
|
|
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
|
|
|
```
|
|
|
|
|
|
Q-டேபிளின் அனைத்து மதிப்புகளையும் சமமான மதிப்புடன் ஆரம்பிக்கிறோம், எங்கள் வழக்கில் - 0.25. இது "சீரற்ற நடை" கொள்கைக்கு இணங்கும், ஏனெனில் ஒவ்வொரு நிலையிலும் அனைத்து நகர்வுகளும் சமமாக நல்லவை. `m.plot(Q)` என்ற செயல்பாட்டிற்கு Q-டேபிளை அனுப்பி, பலகையில் டேபிளை காட்சிப்படுத்தலாம்.
|
|
|
|
|
|
|
|
|
|
|
|
ஒவ்வொரு செல் மையத்திலும், நகர்வின் விருப்பமான திசையை குறிக்கும் ஒரு "அம்பு" உள்ளது. அனைத்து திசைகளும் சமமாக இருப்பதால், ஒரு புள்ளி காட்டப்படுகிறது.
|
|
|
|
|
|
இப்போது, சிமுலேஷனை இயக்கி, எங்கள் சூழலை ஆராய்ந்து, Q-டேபிள் மதிப்புகளின் ஒரு சிறந்த விநியோகத்தை கற்றுக்கொள்ள வேண்டும், இது ஆப்பிளை அடைய மிகவும் வேகமாக உதவும்.
|
|
|
|
|
|
## Q-லெர்னிங் சாரம்: Bellman சமன்பாடு
|
|
|
|
|
|
நாம் நகரத் தொடங்கியவுடன், ஒவ்வொரு செயலுக்கும் தொடர்புடைய பரிசு இருக்கும், அதாவது, அதிகபட்ச உடனடி பரிசின் அடிப்படையில் அடுத்த செயலைத் தேர்வு theoretically செய்யலாம். ஆனால், பெரும்பாலான நிலைகளில், நகர்வு எங்கள் நோக்கமான ஆப்பிளை அடைய முடியாது, எனவே எந்த திசை சிறந்தது என்பதை உடனடியாக முடிவு செய்ய முடியாது.
|
|
|
|
|
|
> உடனடி முடிவே முக்கியமல்ல, ஆனால் சிமுலேஷன் முடிவில் பெறப்படும் இறுதி முடிவே முக்கியம் என்பதை நினைவில் கொள்ளுங்கள்.
|
|
|
|
|
|
இந்த தாமதமான பரிசை கணக்கில் கொள்ள, **[dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming)**-ன் கொள்கைகளைப் பயன்படுத்த வேண்டும், இது எங்கள் பிரச்சனையை recursive முறையில் சிந்திக்க அனுமதிக்கும்.
|
|
|
|
|
|
நாம் தற்போது *s* என்ற நிலையில் இருக்கிறோம் என்று கருதுங்கள், மற்றும் அடுத்த நிலையான *s'*-க்கு நகர விரும்புகிறோம். இதைச் செய்வதன் மூலம், பரிசு செயல்பாட்டால் வரையறுக்கப்பட்ட உடனடி பரிசு *r(s,a)* பெறுவோம், மேலும் சில எதிர்கால பரிசு கிடைக்கும். எங்கள் Q-டேபிள் ஒவ்வொரு செயலின் "ஆக்ரமத்துவத்தை" சரியாக பிரதிபலிக்கிறது என்று கருதினால், *s'* நிலையில் *a* செயலை தேர்வு செய்வோம், இது *Q(s',a')*-ன் அதிகபட்ச மதிப்புக்கு இணங்கும். எனவே, *s'* நிலையில் அனைத்து செயல்களுக்கும் *a'* அதிகபட்ச மதிப்பை கணக்கிடுவதன் மூலம், *s* நிலையில் பெறக்கூடிய சிறந்த எதிர்கால பரிசு வரையறுக்கப்படும்.
|
|
|
|
|
|
இது *s* நிலையில் *a* செயலுக்கான Q-டேபிள் மதிப்பை கணக்கிட **Bellman சமன்பாட்டை** வழங்குகிறது:
|
|
|
|
|
|
<img src="../../../../translated_images/ta/bellman-equation.7c0c4c722e5a6b7c.webp"/>
|
|
|
|
|
|
இங்கே γ என்பது **discount factor** என்று அழைக்கப்படுகிறது, இது தற்போதைய பரிசை எதிர்கால பரிசுக்கு முன்னுரிமை கொடுக்க வேண்டும் என்பதைத் தீர்மானிக்கிறது.
|
|
|
|
|
|
## கற்றல் அல்காரிதம்
|
|
|
|
|
|
மேலே உள்ள சமன்பாட்டின் அடிப்படையில், எங்கள் கற்றல் அல்காரிதத்திற்கான பseudo-code எழுதலாம்:
|
|
|
|
|
|
* அனைத்து நிலைகள் மற்றும் செயல்களுக்கான சமமான எண்ணங்களுடன் Q-டேபிள் Q-ஐ ஆரம்பிக்கவும்
|
|
|
* கற்றல் வீதத்தை α ← 1 என அமைக்கவும்
|
|
|
* சிமுலேஷனை பல முறை மீண்டும் செய்யவும்
|
|
|
1. சீரற்ற இடத்தில் தொடங்கவும்
|
|
|
1. மீண்டும் செய்யவும்
|
|
|
1. *s* நிலையில் *a* செயலைத் தேர்வு செய்யவும்
|
|
|
2. புதிய நிலையான *s'*-க்கு நகர்வதன் மூலம் செயலைச் செயல்படுத்தவும்
|
|
|
3. விளையாட்டு முடிவு நிலைமையை சந்திக்கிறோம் அல்லது மொத்த பரிசு மிகவும் குறைவாக இருந்தால் - சிமுலேஷனை நிறுத்தவும்
|
|
|
4. புதிய நிலையில் பரிசு *r*-ஐ கணக்கிடவும்
|
|
|
5. Bellman சமன்பாட்டின் படி Q-செயல்பாட்டை புதுப்பிக்கவும்: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ max<sub>a'</sub>Q(s',a'))*
|
|
|
6. *s* ← *s'* என மாற்றவும்
|
|
|
7. மொத்த பரிசை புதுப்பித்து α-ஐ குறைக்கவும்.
|
|
|
|
|
|
## Exploit vs. explore
|
|
|
|
|
|
மேலே உள்ள அல்காரிதத்தில், படி 2.1-இல் செயலைத் தேர்வு செய்யும் முறை குறிப்பிடப்படவில்லை. செயலை சீரற்ற முறையில் தேர்வு செய்தால், சூழலை சீரற்ற முறையில் **ஆராய** முடியும், மேலும் நாம் அடிக்கடி இறக்கவும், வழக்கமாக செல்லாத பகுதிகளை ஆராயவும் வாய்ப்பு உள்ளது. மாற்று அணுகுமுறை, நாம் ஏற்கனவே அறிந்த Q-டேபிள் மதிப்புகளை **பயன்படுத்த** முடியும், மேலும் *s* நிலையில் அதிக Q-டேபிள் மதிப்புடன் சிறந்த செயலைத் தேர்வு செய்யலாம். இது, மற்ற நிலைகளை ஆராய்வதைத் தடுக்கும், மேலும் நாம் சிறந்த தீர்வை கண்டுபிடிக்க முடியாமல் போகலாம்.
|
|
|
|
|
|
எனவே, ஆராய்ச்சி மற்றும் பயன்பாட்டுக்கு இடையில் சமநிலையை அமைப்பதே சிறந்த அணுகுமுறை. இது *s* நிலையில் Q-டேபிள் மதிப்புகளுக்கு நிகரமான சாத்தியக்கூறுகளுடன் செயலைத் தேர்வு செய்வதன் மூலம் செய்ய முடியும். ஆரம்பத்தில், Q-டேபிள் மதிப்புகள் அனைத்தும் ஒரே மாதிரியானவை, இது சீரற்ற தேர்வுக்கு இணங்கும், ஆனால் சூழலைப் பற்றி மேலும் கற்றுக்கொண்டபோது, சிறந்த பாதையை பின்பற்றுவதற்கான வாய்ப்பு அதிகமாக இருக்கும், மேலும் ஏஜென்ட்டை ஒரு முறை ஆராயாத பாதையைத் தேர்வு செய்ய அனுமதிக்கும்.
|
|
|
|
|
|
## Python செயல்பாடு
|
|
|
|
|
|
இப்போது, கற்றல் அல்காரிதத்தை செயல்படுத்த தயாராக உள்ளோம். அதைச் செய்வதற்கு முன், Q-டேபிளில் உள்ள எண்ணங்களை தொடர்புடைய செயல்களுக்கான சாத்தியக்கூறுகளின் வெகுஜனமாக மாற்றும் ஒரு செயல்பாடு தேவை.
|
|
|
|
|
|
1. `probs()` என்ற செயல்பாட்டை உருவாக்கவும்:
|
|
|
|
|
|
```python
|
|
|
def probs(v,eps=1e-4):
|
|
|
v = v-v.min()+eps
|
|
|
v = v/v.sum()
|
|
|
return v
|
|
|
```
|
|
|
|
|
|
ஆரம்ப நிலைமையில் அனைத்து கூறுகளும் ஒரே மாதிரியானவை என்றால், 0-ஆல் வகுத்தலைத் தவிர்க்க சில `eps`-ஐ அசல் வெகுஜனத்தில் சேர்க்கிறோம்.
|
|
|
|
|
|
5000 பரிசோதனைகள், **epochs** என்று அழைக்கப்படும், மூலம் கற்றல் அல்காரிதத்தை இயக்கவும்: (குறியீடு தொகுதி 8)
|
|
|
```python
|
|
|
for epoch in range(5000):
|
|
|
|
|
|
# Pick initial point
|
|
|
m.random_start()
|
|
|
|
|
|
# Start travelling
|
|
|
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) # we allow player to move outside the board, which terminates episode
|
|
|
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
|
|
|
```
|
|
|
|
|
|
இந்த அல்காரிதத்தை செயல்படுத்திய பிறகு, Q-டேபிள் ஒவ்வொரு நிலையிலும் ஒவ்வொரு செயலின் "ஆக்ரமத்துவத்தை" வரையறுக்கும் மதிப்புகளுடன் புதுப்பிக்கப்படும். Q-டேபிளை காட்சிப்படுத்த முயற்சிக்கலாம், ஒவ்வொரு செல்லிலும் நகர்வின் விருப்பமான திசையை குறிக்கும் ஒரு வெகுஜனத்தை வரைந்து. எளிமைக்காக, அம்பு தலைவிடமாற்றாக ஒரு சிறிய வட்டத்தை வரைகிறோம்.
|
|
|
|
|
|
<img src="../../../../translated_images/ta/learned.ed28bcd8484b5287.webp"/>
|
|
|
|
|
|
## கொள்கையைச் சரிபார
|
|
|
> நீங்கள் மேலே கொடுத்துள்ள குறியீட்டை பல முறை முயற்சித்தால், சில நேரங்களில் அது "நிறுத்தி விடும்" என்பதை கவனிக்கலாம், மேலும் அதை நிறுத்த நொட்புக்-இல் STOP பொத்தானை அழுத்த வேண்டும். இது நிகழ்வதற்கான காரணம், சில நேரங்களில் இரண்டு நிலைகள் ஒருவருக்கொருவர் சிறந்த Q-Value அடிப்படையில் "சுட்டிக்காட்டும்" சூழ்நிலைகள் இருக்கலாம், அப்போது முகவர் அந்த நிலைகளுக்கு இடையில் முடிவில்லாமல் நகர்ந்து கொண்டிருப்பார்.
|
|
|
|
|
|
## 🚀சவால்
|
|
|
|
|
|
> **பணி 1:** `walk` செயல்பாட்டை மாற்றி பாதையின் அதிகபட்ச நீளத்தை ஒரு குறிப்பிட்ட எண் (உதாரணமாக, 100) படிகளால் வரையறுக்கவும், மேலும் மேலே கொடுக்கப்பட்ட குறியீடு இந்த மதிப்பை சில நேரங்களில் திருப்பி தருவதை கவனிக்கவும்.
|
|
|
|
|
|
> **பணி 2:** `walk` செயல்பாட்டை மாற்றி, அது ஏற்கனவே சென்ற இடங்களுக்கு திரும்பாமல் இருக்கச் செய்யவும். இது `walk`-ஐ மடக்காமல் தடுக்கும், ஆனால் முகவர் ஒரு இடத்தில் "சிக்கி" விடும், அங்கிருந்து வெளியேற முடியாமல் போகும்.
|
|
|
|
|
|
## வழிசெலுத்தல்
|
|
|
|
|
|
பயிற்சியின் போது நாம் பயன்படுத்திய வழிசெலுத்தல் கொள்கை சிறந்ததாக இருக்கும், இது சுரண்டல் மற்றும் ஆராய்ச்சி ஆகியவற்றை இணைக்கிறது. இந்த கொள்கையில், Q-Table-இல் உள்ள மதிப்புகளின் சாத்தியக்கூறுகளின் அடிப்படையில் ஒவ்வொரு செயலையும் தேர்ந்தெடுப்போம். இந்த உத்தி, முகவர் ஏற்கனவே ஆராய்ந்த இடத்திற்கு திரும்புவதற்கான வாய்ப்பை இன்னும் ஏற்படுத்தலாம், ஆனால், கீழே கொடுக்கப்பட்டுள்ள குறியீட்டிலிருந்து நீங்கள் காணலாம், இது குறிக்கோளிடம் செல்ல மிகவும் குறுகிய சராசரி பாதையை உருவாக்குகிறது (நினைவில் கொள்ளுங்கள் `print_statistics` சிமுலேஷனை 100 முறை இயக்குகிறது): (code block 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/ta/lpathlen1.0534784add58d4eb.webp"/>
|
|
|
|
|
|
கற்றலின் முக்கிய அம்சங்கள்:
|
|
|
|
|
|
- **சராசரி பாதை நீளம் அதிகரிக்கிறது**. முதலில், சராசரி பாதை நீளம் அதிகரிக்கிறது என்பதை நாம் காண்கிறோம். இது, சூழலின் பற்றிய எதுவும் தெரியாதபோது, மோசமான நிலைகள், தண்ணீர் அல்லது ஓநாய் போன்றவற்றில் சிக்கி விடுவதற்கான வாய்ப்பு அதிகமாக இருக்கும் என்பதற்கான காரணமாக இருக்கலாம். நாம் மேலும் கற்றுக்கொண்டு இந்த அறிவைப் பயன்படுத்தத் தொடங்கும்போது, சூழலை நீண்ட நேரம் ஆராய முடியும், ஆனால் ஆப்பிள்கள் எங்கு உள்ளன என்பதை இன்னும் நன்றாக அறியவில்லை.
|
|
|
|
|
|
- **பாதை நீளம் குறைகிறது, மேலும் கற்றுக்கொண்டால்**. நாம் போதுமான அளவு கற்றுக்கொண்ட பிறகு, முகவருக்கு குறிக்கோளை அடைய எளிதாக ஆகிறது, மேலும் பாதை நீளம் குறையத் தொடங்குகிறது. ஆனால், நாம் இன்னும் ஆராய்ச்சிக்கு திறந்துள்ளோம், எனவே நாம் சிறந்த பாதையிலிருந்து விலகி, புதிய விருப்பங்களை ஆராய often செய்கிறோம், இது பாதையை சிறந்ததாக இல்லாமல் நீண்டதாக ஆக்குகிறது.
|
|
|
|
|
|
- **நீளம் திடீரென அதிகரிக்கிறது**. இந்த வரைபடத்தில் நாம் காணும் மற்றொரு அம்சம், ஒரு கட்டத்தில் நீளம் திடீரென அதிகரிக்கிறது. இது செயல்முறையின் சோம்பேறித்தன்மையை குறிக்கிறது, மேலும் ஒரு கட்டத்தில் Q-Table குணாதிசயங்களை புதிய மதிப்புகளால் மீண்டும் எழுதுவதன் மூலம் "கெடுக்க" முடியும். இது கற்றல் விகிதத்தை குறைப்பதன் மூலம் குறைக்கப்பட வேண்டும் (உதாரணமாக, பயிற்சியின் இறுதியில், Q-Table மதிப்புகளை ஒரு சிறிய மதிப்பால் மட்டுமே சரிசெய்வோம்).
|
|
|
|
|
|
மொத்தத்தில், கற்றல் செயல்முறையின் வெற்றி மற்றும் தரம் கற்றல் விகிதம், கற்றல் விகிதம் குறைவு, மற்றும் தள்ளுபடி காரணி போன்ற அளவுகோள்களால் முக்கியமாக பாதிக்கப்படுகிறது. இவை **அதிக அளவுகோள்கள்** என்று அழைக்கப்படுகின்றன, **அளவுகோள்கள்**-இலிருந்து வேறுபடுத்த, அவற்றை பயிற்சியின் போது நாங்கள் மேம்படுத்துகிறோம் (உதாரணமாக, Q-Table குணாதிசயங்கள்). சிறந்த அதிக அளவுகோள்களின் மதிப்புகளை கண்டுபிடிக்கும் செயல்முறையை **அதிக அளவுகோள் மேம்பாடு** என்று அழைக்கப்படுகிறது, மேலும் இது தனி தலைப்புக்கு உரியதாகும்.
|
|
|
|
|
|
## [பாடத்திற்குப் பிந்தைய வினாடி வினா](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## பணிக்கட்டளை
|
|
|
[ஒரு மேலும் யதார்த்தமான உலகம்](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
**அறிவிப்பு**:
|
|
|
இந்த ஆவணம் [Co-op Translator](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையை பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சிக்கிறோம், ஆனால் தானியங்கி மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்கக்கூடும் என்பதை தயவுசெய்து கவனத்தில் கொள்ளவும். அதன் சொந்த மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்களுக்கும் அல்லது தவறான விளக்கங்களுக்கும் நாங்கள் பொறுப்பல்ல. |
