கணினிக்கோ அல்லது கணினியால் உருவாக்கப்பட்ட கருவிக்கோ ஒரு விஷயத்தை திரும்பத் திரும்பச் சொல்லிக் கொடுப்பதன் மூலம் அதனைப் பயிற்றுவிக்க முயலும் முறைக்கு ‘Reinforcement Learning’ என்று பெயர். சுயமாக ஓடக்கூடிய மகிழ் ஊர்தி(self-driving cars), கணினியோடு மக்களை விளையாடச் செய்யும் gaming industry போன்றவற்றில் ஒரு கருவிக்குத் திறம்பட பயிற்சி அளிக்க இத்தகைய முறை பயன்படுத்தப்படுகிறது. சமீபத்தில் உருவாக்கப்பட்ட ‘Deepmind’ என்பது இதற்கு ஒரு சிறந்த உதாரணம் ஆகும். இத்தகைய Reinforcement Learning எவ்வாறு நடைபெறுகிறது என்பது பற்றி இப்பகுதியில் விளக்கமாகக் காணலாம்.
பொதுவாக ஒருசில விஷயங்களை குழந்தைக்கு நாம் ஒருமுறை சொல்லிக்கொடுத்தால் போதும். அது சுலபமாகக் கற்றுக் கொண்டு விடும். இதனை சாதாரணமாக learning என்று அழைக்கலாம். ஆனால் புரிந்து கொள்வதற்குச் சற்றுக் கடினமான விஷயங்களை திரும்பத் திரும்பச் சொல்லிக்கொடுப்பதன் மூலமே ஒரு குழந்தைக்கு நாம் புரிய வைக்க முடியும். இவ்வாறு திரும்பத் திரும்பச் சொல்லிக் கொடுக்கும் முயற்சியில், ஒவ்வொரு முறையும் குழந்தையின் புரிதலுக்கு ஏற்றவாறு நாம் அடுத்தடுத்து சொல்லிக்கொடுக்க முயல்வதே ‘Reinforcement Learning’ எனப்படும். எடுத்துக்காட்டாக ஒரு குழந்தைக்கு கடிகார முள்ளைப் பார்த்து மணி கண்டுபிடிக்க கற்றுக் கொடுக்கும் செயலை reinforcement learning-ல் வைத்துப் பொருத்திப் பார்ப்போம். இதில் பயன்படுத்தப்படும் முக்கிய வார்த்தைகளான Agent, Environment, State, Action, Reward, Penalty, Policy ஆகியவற்றை இச்செயலில் வைத்துப் பொருத்திப் பார்த்து நாம் புரிந்து கொள்ள முயல்வோம்.
1. முதலில் ஒன்றுமே தெரியாமல் ஆரம்பித்து கடைசியில் கடிகார முள்ளைப் பார்த்து மணி சொல்ல கற்றுக்கொள்ளும் குழந்தைதான் இங்கு ‘Agent’ என்ற பெயரில் அழைக்கப்படுகிறது. அதாவது எதற்கு நாம் கற்றுக்கொடுக்க முயல்கிறோமோ அதுவே ‘Agent’ ஆகும்.
2. அடுத்து எதைப் பற்றிக் கற்றுக்கொடுக்க முயல்கிறோமோ அதுவே ‘Environment’ என்ற பெயரில் அழைக்கப்படுகிறது. கடிகாரம், அதில் உள்ள 60 சின்னஞ்சிறிய கோடுகள், முட்கள் உள்ள திசை, அது குறிக்கின்ற எண்கள் ஆகியவையே இங்கு environment ஆகும்.
3. Environment-க்குள் எந்த நிலையிலிருந்து நமது கற்பித்தலைத் தொடங்குகிறோமோ அதுவே ‘state’ என்று அழைக்கப்படும். கடிகாரத்தில் முட்கள் இருக்கும் தற்போதைய நிலைக்கு ‘state’ என்று பெயர். அதைப்பார்த்து மணியைக் கணக்கிட்டு சொல்லும் செயலுக்கு ‘action’ என்று பெயர். அதாவது environment-ல் உள்ள state-க்கு ஏற்றவாறு, agent தன்னுடைய action-ஐ வெளிப்படுத்தும்.
4. Agent வெளிப்படுத்திய action சரியாக அமையும்பட்சத்தில் reward-ம், தவறாக அமையும்பட்சத்தில் penalty-ம் கிடைக்கும். அதாவது ‘ஊக்கப்படுத்துதல்’ மற்றும் ‘தண்டனையளித்தல்’ எனும் பொருளில் இவை இங்கு பயன்படுத்தப்படுகின்றன. கடிகார முள்ளைத் திருப்பித் திருப்பி ஒவ்வொரு முறை குழந்தையை மணி கேட்கும்போதும் சரியாகச் சொன்னால் ஒரு மிட்டாயைக் கொடுத்து ஊக்கமளிப்பது, தவறாகச் சொன்னால் அதனிடம் உள்ள மிட்டாய்களில் ஒன்றைப் பிடுங்கிக் கொள்வது போன்ற செயல்களே இங்கு ‘reward’ அல்லது ‘penalty’ என்று அழைக்கப்படுகிறது. மிட்டாய் கிடைத்தால் தான் கற்றுக்கொண்டது சரி என்றும், மிட்டாயை இழந்தால் தான் கற்றுக்கொண்டது தவறு என்றும் குழந்தை புரிந்துகொள்ளும். எனவே அடுத்தடுத்த முறைகளில் அதிக மிட்டாய்களைப் பெறும் ஆர்வத்திலும், ஏற்கெனவே பெற்றுக்கொண்ட மிட்டாய்களை இழந்து விடக்கூடாது என்ற பயத்திலும் தனக்குக் கிடைத்த அனுபவத்தை வைத்து சரியாக மணி சொல்ல முயற்சிக்கும்.
5. சரியான மணியைக் கணக்கிட குழந்தை இதுவரை பல்வேறு வழிவகைகளைக் கண்டுபிடித்து வைத்திருக்கும். கடிகாரத்தில் உள்ள ஒவ்வொரு சின்னஞ்சிறிய கோடுகளையும் கணக்கிட்டுக் கூறுவது ஒரு வகை. 5-ம் வாய்ப்பாட்டைப் பயன்படுத்திக் கணக்கிடுவது சற்று தேர்ந்த வகை. இதுபோன்று ஒரு விஷயத்தை நடத்தப் பயன்படுத்தும் பல்வேறு வழிவகைகளே ‘strategies’ என்ற பெயரில் அழைக்கப்படுகின்றன. இதில் சிறந்த optimized strategy-ஐத் தேர்வு செய்து Agent தான் நிகழ்த்த வேண்டிய செயலை நிகழ்த்தும். இத்தகைய பல்வேறு strategies-ஐ உள்ளடக்கியதே ‘Policy’ ஆகும்.
இதுபோன்ற ‘Reinforcement Learning’ என்பது supervised மற்றும் Unsupervised என்ற இரண்டுக்கும் மத்தியில் அமையும். ஏனெனில் முதலில் unsupervised முறையில் ஆரம்பித்து, பின்னர் agent-ன் செயலைப் பொறுத்து அதனைத் தொடர்ச்சியாகத் திருத்துவதன் மூலம் supervised முறையில் தொடர்கிறது. கணினியுடன் நாம் விளையாடுகின்ற சீட்டுக்கட்டு விளையாட்டு,, Chess விளையாட்டு, கார் பந்தயம் போன்றவற்றில் நம்முடைய எதிரணியாக இருக்கும் கணினிக்குப் பயிற்றுவிக்க இத்தகைய reinforcement தத்துவங்களே பயன்படுகின்றன. முதலில் கணினியானது அதற்குத் தெரிந்த வகையில் நம்மோடு விளையாடத் தொடங்கினாலும், பின்னர் நம்முடைய நடவடிக்கைகளுக்கு ஏற்றார் போன்று, அதனுடைய விளையாட்டுப் போக்கை மாற்றிக் கொண்டு வெற்றி பெற முயலும். எனவே அனைத்திற்கும் பொருந்தும் வகையில் இத்தத்துவங்களின் சுருக்கங்களைப் பரவலாகப் பின்வருமாறு அமைக்கலாம்.
• சூழ்நிலையைக் கண்காணித்தல் (Observation of Environment)
• சூழ்நிலையில் உள்ள தற்போதைய நிலைக்கு ஏற்றவாறு Agent தன்னுடைய அடுத்த செயலைத் தொடர்த்தல் (Act according to the current state)
• தன்னுடைய செயலுக்கான ஊக்க மதிப்பு அல்லது தண்டனைத் தொகையைப் பெற்றுக் கொள்ளுதல் (Getting reward or penalty)
• Agent தான் பெற்றுக்கொண்ட மதிப்பிற்கு ஏற்றவாறு தன்னுடைய செயலையும், புரிதலையும் மாற்றிக் கொள்ளுதல் (Finding a strategy from experiences)
• Agent நிகழ்த்தும் action என்பது சூழ்நிலையை ஒரு நிலையிலிருந்து அடுத்த நிலைக்கு மாற்றும். இப்போது சூழ்நிலையில் ஏற்பட்டுள்ள மாற்ற நிலைக்கு ஏற்றவாறு agent மேற்கண்ட செயல்களை மீண்டும் மீண்டும் செய்து பல்வேறு சுழற்சிகளை உருவாக்கும். சுழற்சிகளின் முடிவில், அது பெற்றுள்ள reward அல்லது penalty மதிப்பைப் பொறுத்து சரியான வழிமுறையைக் கண்டுபிடிக்கும். (Iterate until finding a best strategy)
தொடக்க நிலை சுழற்சிகளில் Agent-க்கு தொடர்ச்சியாக ஊக்க மதிப்புகளே கிடைக்கும்பட்சத்தில் அது சரியாகப் புரிந்து கொண்டுவிட்டது என நினைத்து சுழற்சிகளை துவக்கத்திலேயே நிறுத்தி விடக்கூடாது. (Don’t be greedy). அதிக பட்ச சுழற்சிகளை நிகழ்த்தி அதில் தோராயமாக ஊக்கமதிப்புகள் கிடைத்துள்ளதா அல்லது தண்டனைத்தொகை கிடைத்துள்ளதா என்பதைப் பொறுத்தே சரியான தீர்மானத்தை மேற்கொள்ள வேண்டும். இந்தத் தீர்மானமானது வெறும் ஒரு நிலையைப் பொறுத்து அமையாமல், பல்வேறு காலங்களில் அமைந்த பல்வேறு நிலைகளின் தொடர்ச்சியாக அமையும். (sequence of states according to time)
அடுத்ததாக ஒரு ஊர்தியை தன்னிச்சையாக இயங்க வைக்க reinforcement learning மூலம் எவ்வாறு பயிற்சி அளிப்பது என்பதை கீழ்க்கண்ட எடுத்துக்காட்டில் காணலாம். இத்தகைய பயிற்சியின் போது பயனர்களை எங்கிருந்து ஏற்ற வேண்டும், எங்கு இறக்க வேண்டும், இடைப்பட்ட தூரத்தை குறைந்த அளவு நேரத்தில் சரியான திசை நோக்கி எவ்வாறு கடந்து செல்வது போன்ற பல்வேறு விஷயங்களை நாம் கற்றுத்தரப் போகிறோம். ஒரு பயனரை சரியான இடத்தில் கொண்டு சேர்க்கும் செயலுக்கு அதிக அளவு வெகுமதிகளையும், ஒவ்வொரு முறை தவறான திசை நோக்கித் திரும்பும்போதும் சற்றுக் குறைந்த தண்டனை மதிப்புகளை அளித்துத் திருத்துவதன் மூலம் ஊர்திக்குக் கற்றுத் தர முடியும். இதற்குத் தகுந்த மாதிரியான தரவுகளை Gym எனும் module -க்குள் காணலாம். இதனைப் பயன்படுத்தி மேற்கண்ட விஷயங்களை செய்வதற்கான நிரலும் அதற்கான விளக்கமும் பின்வருமாறு.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import gym | |
| import numpy as np | |
| import random | |
| e = gym.make("Taxi-v3").env | |
| e.render() | |
| e.reset() | |
| e.render() | |
| print (e.action_space) | |
| print (e.observation_space) | |
| e.s = e.encode(3, 1, 2, 0) # (taxi row, taxi column, passenger index, destination index) | |
| e.render() | |
| print (e.s) | |
| print (e.P[328]) | |
| epochs, penalties, reward = 0, 0, 0 | |
| while not reward == 20: | |
| action = e.action_space.sample() | |
| state, reward, done, info = e.step(action) # (284, -1, False, {'prob': 1.0}) | |
| if reward == -10: | |
| penalties += 1 | |
| epochs += 1 | |
| print("Timesteps taken:",epochs) | |
| print("Penalties incurred:",penalties) | |
| q_table = np.zeros([e.observation_space.n, e.action_space.n]) | |
| print (q_table[328]) | |
| total_epochs, total_penalties = 0, 0 | |
| for i in range(1, 100): | |
| state = e.reset() | |
| epochs, penalties, reward, = 0, 0, 0 | |
| done = False | |
| while not done: | |
| if random.uniform(0, 1) < 0.1: | |
| action = e.action_space.sample() # Explore action space | |
| else: | |
| action = np.argmax(q_table[state]) # Exploit learned values | |
| next_state, reward, done, info = e.step(action) | |
| old_value = q_table[state, action] | |
| next_max = np.max(q_table[next_state]) | |
| new_value = (1 – 0.1) * old_value + 0.1 * (reward + 0.6 * next_max) | |
| q_table[state, action] = new_value | |
| if reward == -10: | |
| penalties += 1 | |
| state = next_state | |
| epochs += 1 | |
| total_penalties += penalties | |
| total_epochs += epochs | |
| print (q_table[328]) | |
| print("Timesteps taken:",epochs) | |
| print("Penalties incurred:",penalties) | |
| print("Average timesteps per episode:",(total_epochs / 100)) | |
| print("Average penalties per episode",(total_penalties / 100)) |
நிரலுக்கான விளக்கம் மற்றும் வெளியீடு:
1. gym.make(“Taxi-v3”).env எனக் கொடுப்பதன் மூலம் பயிற்சி அளிப்பதற்குத் தகுந்த சூழ்நிலை உருவாக்கப்பட்டுவிடும். இதன்மீது செயல்படும் render() மற்றும் reset() ஆகியவை சூழ்நிலையை வெளிக்காட்டுதல் மற்றும் சூழ்நிலையில் ஊர்தி உள்ள இடத்தை தோராயமாக மாற்றி அமைத்தல் போன்ற வேலைகளைச் செய்யும். இது பின்வருமாறு காணப்படும்.
• Agent : இதில் காணப்படும் சிறிய மஞ்சள் நிறப் பெட்டிதான் Agent. அதாவது இதுதான் தன்னிச்சையாக இயங்கி பயனர்களை அவரவர்குரிய இடத்தில் சென்று சேர்க்க கற்றுக் கொள்ளப்போகும் ஊர்தி.
• Environment : இச்சூழ்நிலையானது எளிய 5*5 வடிவ அணி போன்ற அமைப்புடன் உருவகம் செய்யப்படும். எனவே இதில் உள்ள ஒவ்வொரு சின்ன சின்ன பகுதியையும் அணியில் பயன்படுத்தப்படும் இட மதிப்புகளை வைத்து எளிதாக அணுகலாம். அதாவது R, G, Y, B ஆகியவையே பயனர்களை ஏற்றி இறக்குவதற்கான இடங்கள். இவைகள் முறையே (0,0) , (0,4) , (4,0) , (4,3) என்று அணுகப்படும்.
• Episode : இதில் சூழ்நிலைக்கு ஏற்ப Agent செலுத்தும் ‘Action’ என்பது பல்வேறு action-களின் தொடர்ச்சியாக அமையும். Agent-ன் ஒவ்வொரு செயலும் சூழ்நிலையில் மாற்றத்தை ஏற்படுத்தும். பின்னர் மாற்றப்பட்ட ஒவ்வொரு சூழ்நிலைக்கும் ஏற்ப Agent தனது செயலை நிகழ்த்தும். இதே முறையில் தொடர்ந்து செயல்பட்டு கடைசியில் பயனரை அவருக்குரிய இடத்தில் சென்று சேர்க்கும் செயலானது ஒரு ‘episode’ என்று அழைக்கப்படுகிறது.
• Action Space : ஊர்தியின் செயல்பாடுகள் பின்வரும் 6 செயல்களில் ஒன்றாக அமையும். ஊர்தியை தெற்கு, வடக்கு, கிழக்கு, மேற்கு ஆகிய திசைகளில் திருப்புவது முறையே 0,1,2,3 எனவும், ஊர்தியைத் துவக்கும் செயலும், நிறுத்தும் செயலும் முறையே 4, 5 எனவும் குறிக்கப்படும். இம்மதிப்புகளே ‘Action Space’ என்று அழைக்கப்படுகின்றன. print (e.action_space) என்பது 6 எனும் மதிப்பினை வெளிப்படுத்துவதைக் காணலாம்.
• State Space : சூழ்நிலையில் உள்ள ஒரு நிலைக்கு ஏற்றவாறே Agent தன்னுடைய செயலைத் தொடங்கும் என்று அறிவோம். மொத்தம் எத்தனை நிலைகள் இந்தச் சூழ்நிலையில் அமையலாம் என்பதே ‘ State Space’ எனப்படும். ஒவ்வொரு பயனரையும் உள் அழைத்துக் கொள்வது ஒரு நிலை. ஆகவே 5 பயனர்களுக்கு 5 நிலைகள் (R, G, Y, B ஆகிய இடங்களிலிருந்து உள் அழைத்துக் கொள்ளும் பயனர்கள் தவிர ஏற்கெனவே காருக்குள் ஒரு பயனர் இருப்பதாகக் கணக்கில் கொண்டு 5 பயனர் என்கிறோம்). அடுத்ததாக ஒவ்வொரு பயனரையும் அவரவருக்குரிய இடத்தில் சென்று சேர்ப்பது அடுத்த நிலை. 4 நிறுத்தத்திற்கான இடங்களும் 4 நிலைகள் ஆகும். கடைசியாக 5*5 வடிவமைப்பைக் கொண்ட சூழ்நிலையில் கார் திரும்பும் ஒவ்வொரு திசையும் ஒவ்வொரு நிலையைக் குறிக்கும். எனவே மொத்தம் 25 திசைகளில் கார் திரும்ப வாய்ப்பு உள்ளதால், 25 நிலைகள் உருவாகும். மேற்கூறிய 5 பயனிகள், 4 நிறுத்தங்கள், 25 திசைகள் ஆகிய அனைத்தையும் சேர்த்து state space 500 ( 5 * 4 * 25) என அமையும். print (e.observation_space) என்பது 500 எனும் மதிப்பை வெளிப்படுத்துவதைக் காணலாம்.
2. இப்போது நாமாக ஒரு நிலையை உருவாக்கிக் கொடுத்து, அதனடிப்படையில் ஊர்தியைக் கற்றுக் கொள்ளச் செய்யப் போகிறோம். e.s = e.encode(3, 1, 2, 0) என்பது கொடுக்கப்பட்ட சூழ்நிலையில் ஊர்த்தியை (3,1) எனுமிடத்தில் வைக்கும். அடுத்து தரப்பட்டுள்ள 2, 0 எனும் எண்கள் passenger index மற்றும் destination index-ஐக் குறிக்கும். e.render() என்பது இந்தப் புதிய நிலையை பின்வருமாறு வெளிக்காட்டும்.
3. print (e.s) என்பது 328 எனும் எண்ணை வெளிப்படுத்தும். அதாவது கொடுக்கப்பட்ட 500 நிலைகளில் இது 328-வது நிலை என்று அர்த்தம். இந்த நிலைக்குரிய வெகுமதிக்கான அட்டவணை பின்வருமாறு அமையும் print (e.P[328]).
{0: [(1.0, 428, -1, False)],
1: [(1.0, 228, -1, False)],
2: [(1.0, 348, -1, False)],
3: [(1.0, 328, -1, False)],
4: [(1.0, 328, -10, False)],
5: [(1.0, 328, -10, False)]}
இதன் வடிவமைப்பு {action1: [(probability, nextstate, reward, done)]} எனும் அமைப்பில் இருக்கும்.
இதில் உள்ள 0,1,2,3,4,5 ஆகியவை Agent நிகழ்த்தும் அனைத்து வகையான செயல்களையும் குறிக்கிறது. அடுத்து உள்ள 1.0 என்பது Agent ஒவ்வொரு செயலையும் நிகழ்த்துவதற்கான probability-ஐக் குறிக்கிறது. அனைத்து செயல்களும் நடைபெறுவதற்கான வாய்ப்பு சமமாகவே இருக்குமாதலால் இதன் மதிப்பு எப்போதும் 1 என அமையும். அடுத்து உள்ள 428, 228, 348…போன்ற எண்கள் Agent அக்குறிப்பிட்ட செயலை நிகழ்த்தினால் சென்றடையும் அடுத்த நிலைக்கான எண்ணைக் குறிக்கும். எனவே தான் 3 எனுமிடத்தில் ஏற்கெனவே ஊர்தி வைக்கப்பட்டுள்ளதாலும், 4, 5 ஆகியவை பயனரை ஏற்றி இறக்குவதற்கான செயல்கள் மட்டுமே என்பதாலும் 328 நிலையில் மாற்றம் ஏற்படாமல் அதே எண்ணை வெளிப்படுத்தியுள்ளது. அடுத்து உள்ள -1, -10 ஆகியவை ஒவ்வொரு செயலுக்குமான வெகுமதி மதிப்புகள் ஆகும். கடைசி செயலுக்கான வெகுமதி மதிப்பு மட்டும், அதனையடுத்து உள்ள மதிப்பு True என மாறும்போது 20 என அமையும். அதாவது கடைசியில் உள்ள False என்பது பயனரை இன்னும் அவருக்கான இடத்தில் இறக்கிவிடவில்லை என்பதைக் குறிக்கிறது. அவரை வெற்றிகரமாக இறக்கிவிட்டபின், இம்மதிப்பு Trueஎனவும், கடைசி செயலுக்கான வெகுமதி மதிப்பு 20 எனவும் மாறிவிடும். இதுவே ஒரு ‘Episode’ நிறைவுற்றத்தைக் குறிக்கும்.
4. இப்போது RL-க்கான எந்த ஒரு algorithm-ஐயும் பின்பற்றாமல், random-ஆக ஊர்தியை அடுத்தடுத்த திசை நோக்கி நகர வைப்பதற்கான loop பின்வருமாறு அமையும். இது கடைசி செயலான drop-off க்குக் கிடைக்கின்ற வெகுமதி மதிப்பு 20 என அமையாத வரை ஊர்தியை தொடர்ந்து destination-ஐ நோக்கிப் பயணிக்க வைக்கின்ற while not loop ஆகும். e.action_space.sample() என்பது மொத்த செயல்களில் இருந்து random-ஆக ஒரு செயலை எடுத்து நிகழ்த்தும். e.step(action) என்பது அச்செயலை நிகழ்த்துவதால் வருகின்ற அடுத்த நிலைக்கான மதிப்பு, அச்செயலுக்குப் பெறுகின்ற வெகுமதி மதிப்பு, அச்செயலால் காரியம் முற்றுப்பெற்றதா இல்லையா என்பதை (284, -1, False, {‘prob’: 1.0}) என்ற வடிவில் வெளிப்படுத்தும். இதில் முதல் மூன்று மதிப்புகளே state, reward, done போன்ற variables-ல் சேமிக்கப்படுகின்றன. ஒவ்வொரு முறை தவறாகப் பயனரை இறக்கிவிடும்போதும், penalty மதிப்புடன் 1 கூட்டப்படுகிறது. கடைசியாகப் பயனரை அவருக்குரிய சரியான இடத்தில் இறக்கிவிடும்போது வெகுமதி மதிப்பு 20 என மாறி loop-ஐ விட்டு வெளியேறுகிறது. பின்னர் ஒரு episodeஐ முடிப்பதற்கு மொத்தம் எத்தனை முறை நகர்ந்துள்ளது என்பதையும், எத்தனை முறை பயனரை தவறான இடத்தில் இறக்கி penalties வாங்கியுள்ளது என்பதையும் வெளிப்படுத்துகிறது.
epochs, penalties, reward = 0, 0, 0
while not reward == 20:
action = e.action_space.sample()
state, reward, done, info = e.step(action)
if reward == -10:
penalties += 1
epochs += 1
Timesteps taken: 1485
Penalties incurred: 473
5. Q-Learning Algorithm: மேற்கண்ட படியில் மொத்தம் 1485 முறை நகர்ந்துள்ளதையும், 473 முறை தவறாக இறக்கி penalties வாங்கியுள்ளதையும் காணலாம். இப்போது Q-Learning எனும் RL-க்கான algorithm-ஐப் பயன்படுத்தும்போது, இம்மதிப்புகள் குறைவதைக் காணலாம். ஒரு Agent சூழ்நிலையில் தன்னுடைய செயலுக்கு ஏற்றபடி கிடைக்கின்ற வெகுமதி மதிப்புகளை நினைவில் வைத்துக் கொண்டு அதன்படி அடுத்தடுத்து செயல்படுவதன் மூலம் தவறுகளைக் குறைக்க முடியும். இதுபோன்ற memory-ஐ Agent-க்கு வழங்க இந்த algorithm பயன்படுத்துவதே Q-tableஆகும். இதில் ஒவ்வொரு நிலைக்குமான பல்வேறு செயல்களின் தாக்கங்கள் எந்த அளவுக்கு அமைகின்றன எனும் மதிப்பு சேமிக்கப்படுகிறது. இதுவே Q மதிப்பு ஆகும். இது ஒவ்வொரு செயலின் தரத்தையும் உணர்த்தக் கூடியது.
Q-table என்பது State * Action எனும் அணி வடிவ அமைப்பில் அமையும். அதாவது மொத்தம் உள்ள 500 நிலைகளும் states ஆகவும், ஒவ்வொரு நிலைக்குமான 6 செயல்களின் மதிப்புகளும் columns-ஆகவும் அமையும். இதனடிப்படையில்தான் Q மதிப்புகள் சேமிக்கப்படுகின்றன. ஒவ்வொரு நிலைக்கும் எந்த செயலுக்கான Q மதிப்பு அதிகமாக உள்ளதோ அதுவே பொருத்தமான செயலாகக் கணக்கில் கொள்ளப்படும் .
6. நம்முடைய நிரலில் முதலில் 0 மதிப்பினைப் பெற்று விளங்கும் Q-table உருவாக்கப்படுகிறது. இதன் dimension 500 * 6 என இருக்கும்படி பின்வருமாறு அமைக்கப்படுகிறது. இப்போது 328-வது நிலைக்கான அனைத்து செயல்களும் 0 எனும் துவக்க மதிப்புகளைப் பெற்றுள்ளத்தைக் காணலாம்.
q_table = np.zeros([e.observation_space.n, e.action_space.n])
print (q_table[328])
[0. 0. 0. 0. 0. 0.]
இம்மதிப்புகளை update செய்யும் நிகழ்வானது 100 முறை for loop மூலம் நிகழ்த்தப்படுகிறது. அதாவது 100 முறை பயனர்களைச் சரியாகக் கொண்டு சேர்க்கப் பயன்படுத்திய Q மதிப்புகள் ஒவ்வொரு முறையும் இதில் update செய்யப்படும். ஒவ்வொரு செயலும் அதற்கு முன்னர் அதிக Q மதிப்பைப் பெற்று அமைந்த செயலின்படி வழிநடத்தப்படும். இவ்வாறாக 100 episodes நிறைவுற்ற பின்னர் அதே நிலைக்கான Q மதிப்பு பின்வருமாறு அமைவதைக் காணலாம்.
[-1.12496344 -1.12745359 -1.09896023 -1.0872184 -2.80419013 -2.78076376]
இம்மதிப்புகளை வைத்துப் பார்க்கும்போது அதிக மதிப்பைப் (-1.0872184 )பெற்று விளங்கும் 3-வது செயலை இந்நிலைக்குப் பொருத்தமான செயலாக எடுத்துக் கொள்ளலாம். ஆனால் இதுபோன்ற குறைந்த episodes-ஐ நிகழ்த்தி ஒரு முடிவுக்கு வரக்கூடாது. இதையே learning by greedyஎன்போம். குறைந்த பட்சம் பல லட்சம் சுழற்சிகளையாவது நிகழ்த்திய பின்னரே எச்செயல் பொருத்தமானதாக அமையும் என்ற முடிவுக்கு நம்மால் வர முடியும். இதன் பின்னர் கடைசி 100-வது episode-ல் ஊர்தியின் நகர்வு எண்ணிக்கையும், வாங்கிய penalty மதிப்பும் வெளிப்படுத்தப்பட்டுள்ளது. மேலும் சராசரியாக ஒரு episode-க்கு இத்தகைய மதிப்புகள் என்னென்ன என்பதும் வெளிப்படுத்தப்பட்டுள்ளது. இம்மதிப்புகள் இதற்கு முன்னர் வெளிப்படுத்திய மதிப்புகளை விடக் குறைவாக அமைவதைக் காணலாம். இதுவே ஊர்தி Q-algorithm மூலம் சிறப்பாக செயல்படக் கற்றுக் கொண்டு விட்டதை உறுதிப்படுத்தும்.
Timesteps taken: 331
Penalties incurred: 16
Average timesteps per episode: 452.2
Average penalties per episode 24.67
7. ஒவ்வொரு சுழற்சியிலும் Q-Table ஐ மேம்படுத்தும் நிகழ்வானது பின்வரும் சமன்பாட்டின் படி நடைபெறும்.
new_value = (1 – alpha) * old_value + alpha * (reward + gamma * next_max)
இதில் alpha, gamma ஆகியவை hyperparameters . Alpha என்பது ஒவ்வொரு சுழற்சியிலும் பயன்படுத்தப்படும் learning rate-ஐக் குறிக்கும். இது 0.1 என அமைந்துள்ளது .
gamma என்பது 0 முதல் 1 வரை அமைந்த மதிப்பைப் பெற்றிருக்கும். இங்கு 0.6 என அமைந்துள்ளது . இதன் மதிப்பை 0 -க்கு நெருக்கத்தில் அமைக்கும்போது, quick rewards-ஐ வைத்து அதிக பொருத்தமான செயலைத் தேர்ந்தெடுக்கும். 1-க்கு அருகில் அமைக்கும்போது, long-term rewards-ஐ வைத்து தேர்ந்தெடுக்கும்.
மேலும் epsilon எனும் ஒரு parameter இங்கு overfitting-ஐத் தடுக்கப் பயன்படுகிறது. for loop-ன் துவக்கத்தில், இந்த மதிப்பைப் பொறுத்தே ஆக ஒரு செயலை random-ஆகத் தேர்ந்தெடுக்க வேண்டுமா அல்லது அதிக Q மதிப்பைப் பெற்ற ஒரு செயலைத் தேர்ந்தெடுக்க வேண்டுமா என்பதை முடிவு செய்யும். ஏனெனில் ஒவ்வொரு முறையும் அதிக Qமதிப்பைப் பெற்ற செயல்களே திரும்பத் திரும்பத் தேர்ந்தெடுக்கப்படும்போது over fitting ஏற்பட வாய்ப்பு உள்ளது. ஆகவே இதனைத் தவிர்க்க epsilon-க்கு ஒரு மதிப்பினை வரையறுத்து அதனடிப்படையில் சிலசமயம் random-ஆகவும், சில சமயம் அதிக Q மதிப்பு கொண்ட செயலும் தேர்ந்தெடுக்கப்படுகிறது.