മുൻപത്തെ പാഠത്തിൽ നാം പരിഹരിച്ച പ്രശ്നം ഒരു കളിപ്പാട്ട പ്രശ്നം പോലെ തോന്നാം, യഥാർത്ഥ ജീവിത സാഹചര്യങ്ങൾക്ക് യോജിച്ചില്ലാത്തതായിരിക്കാം. എന്നാൽ ഇത് സത്യമായിട്ടില്ല, കാരണം പല യഥാർത്ഥ ലോക പ്രശ്നങ്ങളും ഈ സാഹചര്യത്തെ പങ്കുവെക്കുന്നു - ചെസ് അല്ലെങ്കിൽ ഗോ കളിക്കുന്നത് ഉൾപ്പെടെ. അവ സമാനമാണ്, കാരണം നമുക്ക് ഒരു ബോർഡ് ഉണ്ട്, നിശ്ചിത നിയമങ്ങളോടുകൂടി, കൂടാതെ ഒരു വ്യത്യസ്തമായ അവസ്ഥ ഉണ്ട്.
ഈ പാഠത്തിൽ നാം Q-ലേണിങ്ങിന്റെ സമാന സിദ്ധാന്തങ്ങൾ നിരന്തര അവസ്ഥ ഉള്ള ഒരു പ്രശ്നത്തിൽ പ്രയോഗിക്കും, അതായത്, ഒരു അല്ലെങ്കിൽ കൂടുതൽ യഥാർത്ഥ സംഖ്യകളാൽ നൽകിയ ഒരു അവസ്ഥ. നാം താഴെ പറയുന്ന പ്രശ്നം കൈകാര്യം ചെയ്യും:
പ്രശ്നം: പീറ്റർ വംശജനെ നിന്ന് രക്ഷപ്പെടാൻ, അവൻ വേഗത്തിൽ ചലിക്കാൻ കഴിയണം. പീറ്റർ എങ്ങനെ സ്കേറ്റ് ചെയ്യാൻ പഠിക്കാമെന്ന് നാം കാണും, പ്രത്യേകിച്ച്, ബാലൻസ് നിലനിർത്താൻ, Q-ലേണിംഗ് ഉപയോഗിച്ച്.
പീറ്ററും അവന്റെ സുഹൃത്തുക്കളും വംശജനെ നിന്ന് രക്ഷപ്പെടാൻ സൃഷ്ടിപരമായ മാർഗങ്ങൾ കണ്ടെത്തുന്നു! ചിത്രം ജെൻ ലൂപ്പർ എന്നവരുടെ.
നാം ബാലൻസിംഗ് എന്നത് ലളിതമാക്കിയ ഒരു പതിപ്പ് ഉപയോഗിക്കും, ഇത് കാർട്ട്പോൾ പ്രശ്നമായി അറിയപ്പെടുന്നു. കാർട്ട്പോൾ ലോകത്ത്, ഒരു ഹോരിസോണ്ടൽ സ്ലൈഡർ ഇടത്തോ വലത്തോ ചലിക്കാൻ കഴിയും, ലക്ഷ്യം സ്ലൈഡറിന്റെ മുകളിൽ ഒരു വെർട്ടിക്കൽ പോൾ ബാലൻസ് ചെയ്യുകയാണ്.
ഈ പാഠത്തിൽ, നാം OpenAI Gym എന്ന ലൈബ്രറി ഉപയോഗിച്ച് വ്യത്യസ്ത പരിസ്ഥിതികൾ സിമുലേറ്റ് ചെയ്യും. നിങ്ങൾക്ക് ഈ പാഠത്തിന്റെ കോഡ് ലോക്കലായി (ഉദാ. Visual Studio Code-ൽ) ഓടിക്കാം, അപ്പോൾ സിമുലേഷൻ പുതിയ വിൻഡോയിൽ തുറക്കും. ഓൺലൈനിൽ കോഡ് ഓടിക്കുമ്പോൾ, ചില മാറ്റങ്ങൾ ആവശ്യമായേക്കാം, ഇവിടെ വിവരിച്ചിരിക്കുന്നതുപോലെ.
മുൻപത്തെ പാഠത്തിൽ, ഗെയിമിന്റെ നിയമങ്ങളും അവസ്ഥയും നാം നിർവചിച്ച Board ക്ലാസ്സിലൂടെ നൽകിയിരുന്നു. ഇവിടെ നാം ഒരു പ്രത്യേക സിമുലേഷൻ പരിസ്ഥിതി ഉപയോഗിക്കും, ഇത് ബാലൻസിംഗ് പോളിന്റെ ഫിസിക്സ് സിമുലേറ്റ് ചെയ്യും. റീൻഫോഴ്സ്മെന്റ് ലേണിംഗ് ആൽഗോരിതങ്ങൾ പരിശീലിപ്പിക്കാൻ ഏറ്റവും പ്രശസ്തമായ സിമുലേഷൻ പരിസ്ഥിതികളിൽ ഒന്നാണ് Gym, ഇത് OpenAI സംരക്ഷിക്കുന്നു. ഈ ജിം ഉപയോഗിച്ച് നാം കാർട്ട്പോൾ സിമുലേഷനിൽ നിന്ന് അറ്റാരി ഗെയിമുകൾ വരെ വ്യത്യസ്ത പരിസ്ഥിതികൾ സൃഷ്ടിക്കാം.
കുറിപ്പ്: OpenAI Gym-ൽ ലഭ്യമായ മറ്റ് പരിസ്ഥിതികൾ ഇവിടെ കാണാം.
ആദ്യം, ജിം ഇൻസ്റ്റാൾ ചെയ്ത് ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യാം (കോഡ് ബ്ലോക്ക് 1):
import sys
!{sys.executable} -m pip install gym
import gym
import matplotlib.pyplot as plt
import numpy as np
import randomകാർട്ട്പോൾ ബാലൻസിംഗ് പ്രശ്നം കൈകാര്യം ചെയ്യാൻ, അനുയോജ്യമായ പരിസ്ഥിതി ആരംഭിക്കണം. ഓരോ പരിസ്ഥിതിക്കും ഒരു:
-
അവലോകന സ്ഥലം ഉണ്ട്, ഇത് പരിസ്ഥിതിയിൽ നിന്ന് ലഭിക്കുന്ന വിവരങ്ങളുടെ ഘടന നിർവചിക്കുന്നു. കാർട്ട്പോൾ പ്രശ്നത്തിൽ, നാം പോളിന്റെ സ്ഥാനം, വേഗത, മറ്റ് ചില മൂല്യങ്ങൾ സ്വീകരിക്കുന്നു.
-
പ്രവർത്തന സ്ഥലം ഉണ്ട്, ഇത് സാധ്യമായ പ്രവർത്തനങ്ങൾ നിർവചിക്കുന്നു. നമ്മുടെ കേസിൽ പ്രവർത്തന സ്ഥലം വ്യത്യസ്തമാണ്, രണ്ട് പ്രവർത്തനങ്ങളടങ്ങിയതാണ് - ഇടത്തേക്ക്യും വലത്തേക്ക്യും. (കോഡ് ബ്ലോക്ക് 2)
-
ആരംഭിക്കാൻ, താഴെ കൊടുത്ത കോഡ് ടൈപ്പ് ചെയ്യുക:
env = gym.make("CartPole-v1") print(env.action_space) print(env.observation_space) print(env.action_space.sample())
പരിസ്ഥിതി എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണാൻ, 100 ഘട്ടങ്ങൾക്കുള്ള ഒരു ചെറിയ സിമുലേഷൻ ഓടിക്കാം. ഓരോ ഘട്ടത്തിലും, എടുക്കേണ്ട പ്രവർത്തനങ്ങളിൽ ഒന്നിനെ നാം നൽകും - ഈ സിമുലേഷനിൽ നാം action_space-ൽ നിന്നു യാദൃച്ഛികമായി ഒരു പ്രവർത്തനം തിരഞ്ഞെടുക്കുന്നു.
-
താഴെ കൊടുത്ത കോഡ് ഓടിച്ച് ഫലം കാണുക.
✅ ഈ കോഡ് ലോക്കൽ പൈത്തൺ ഇൻസ്റ്റലേഷനിൽ ഓടിക്കുന്നത് മുൻഗണന നൽകുക! (കോഡ് ബ്ലോക്ക് 3)
env.reset() for i in range(100): env.render() env.step(env.action_space.sample()) env.close()
നിങ്ങൾക്ക് ഈ ചിത്രത്തോട് സാമ്യമുള്ള ഒന്നും കാണാം:
-
സിമുലേഷനിൽ, പ്രവർത്തിക്കാൻ തീരുമാനിക്കാൻ അവലോകനങ്ങൾ ലഭിക്കണം. സ്റ്റെപ്പ് ഫംഗ്ഷൻ നിലവിലെ അവലോകനങ്ങൾ, ഒരു റിവാർഡ് ഫംഗ്ഷൻ, സിമുലേഷൻ തുടരേണ്ടതുണ്ടോ എന്ന സൂചിപ്പിക്കുന്ന ഡൺ ഫ്ലാഗ് എന്നിവ തിരികെ നൽകുന്നു: (കോഡ് ബ്ലോക്ക് 4)
env.reset() done = False while not done: env.render() obs, rew, done, info = env.step(env.action_space.sample()) print(f"{obs} -> {rew}") env.close()
നിങ്ങൾക്ക് നോട്ട്ബുക്കിന്റെ ഔട്ട്പുട്ടിൽ ഇങ്ങനെ ഒന്നും കാണാം:
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0 [ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0 [ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0 [ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0 [ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0 ... [ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0 [ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0സിമുലേഷന്റെ ഓരോ ഘട്ടത്തിലും തിരികെ ലഭിക്കുന്ന അവലോകന വെക്ടറിൽ താഴെ പറയുന്ന മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു:
- കാർട്ടിന്റെ സ്ഥാനം
- കാർട്ടിന്റെ വേഗത
- പോളിന്റെ കോണം
- പോളിന്റെ റൊട്ടേഷൻ നിരക്ക്
-
ആ സംഖ്യകളുടെ കുറഞ്ഞതും പരമാവധി മൂല്യവും കണ്ടെത്തുക: (കോഡ് ബ്ലോക്ക് 5)
print(env.observation_space.low) print(env.observation_space.high)
ഓരോ സിമുലേഷൻ ഘട്ടത്തിലും റിവാർഡ് മൂല്യം എല്ലായ്പ്പോഴും 1 ആണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കാം. കാരണം നമ്മുടെ ലക്ഷ്യം όσο സാധ്യമായും ദൈർഘ്യമേറിയ കാലം പോളിനെ ശരിയായ നിലയിൽ നിലനിർത്തിയാണ്.
✅ യഥാർത്ഥത്തിൽ, കാർട്ട്പോൾ സിമുലേഷൻ 100 തുടർച്ചയായ പരീക്ഷണങ്ങളിൽ ശരാശരി 195 റിവാർഡ് നേടുമ്പോൾ പരിഹരിച്ചതായി കണക്കാക്കുന്നു.
Q-ലേണിങ്ങിൽ, ഓരോ അവസ്ഥയിലും എന്ത് ചെയ്യണമെന്ന് നിർവചിക്കുന്ന Q-ടേബിൾ നിർമ്മിക്കണം. ഇത് സാധ്യമാക്കാൻ, അവസ്ഥ വ്യത്യസ്തമായ (discrete) ആയിരിക്കണം, അതായത് പരിമിതമായ വ്യത്യസ്ത മൂല്യങ്ങൾ അടങ്ങിയിരിക്കണം. അതിനാൽ, നാം നമ്മുടെ അവലോകനങ്ങളെ വ്യത്യസ്തമാക്കണം, അവയെ പരിമിതമായ അവസ്ഥകളുടെ സെറ്റിലേക്ക് മാപ്പ് ചെയ്യണം.
ഇതിന് ചില മാർഗ്ഗങ്ങൾ ഉണ്ട്:
- ബിൻസായി വിഭജിക്കുക. ഒരു മൂല്യത്തിന്റെ ഇടവേള അറിയാമെങ്കിൽ, ആ ഇടവേളയെ പല ബിൻസായി വിഭജിച്ച്, മൂല്യം അതിന്റെ ബിൻ നമ്പറിലൂടെ മാറ്റാം. ഇത് numpy-യുടെ
digitizeമെത്തഡ് ഉപയോഗിച്ച് ചെയ്യാം. ഈ രീതിയിൽ, നാം തിരഞ്ഞെടുക്കുന്ന ബിൻസിന്റെ എണ്ണം അനുസരിച്ച് അവസ്ഥയുടെ വലുപ്പം കൃത്യമായി അറിയാം.
✅ നാം ലീനിയർ ഇന്റർപൊളേഷൻ ഉപയോഗിച്ച് മൂല്യങ്ങളെ ഒരു പരിമിത ഇടവേളയിലേക്ക് (ഉദാ. -20 മുതൽ 20 വരെ) കൊണ്ടുവരാം, പിന്നെ സംഖ്യകളെ റൗണ്ടുചെയ്ത് പൂർണ്ണസംഖ്യകളാക്കി മാറ്റാം. ഇത് അവസ്ഥയുടെ വലുപ്പത്തെ കുറച്ച് കുറച്ച് നിയന്ത്രണം നൽകുന്നു, പ്രത്യേകിച്ച് ഇൻപുട്ട് മൂല്യങ്ങളുടെ കൃത്യമായ പരിധികൾ അറിയാത്തപ്പോൾ. ഉദാഹരണത്തിന്, നമ്മുടെ കേസിൽ 4 മൂല്യങ്ങളിൽ 2-ന് മുകളിൽ/താഴെ പരിധി ഇല്ല, അതിനാൽ അവസ്ഥകളുടെ അനന്തമായ എണ്ണം ഉണ്ടാകാം.
നമ്മുടെ ഉദാഹരണത്തിൽ, നാം രണ്ടാം സമീപനം സ്വീകരിക്കും. പിന്നീട് നിങ്ങൾ ശ്രദ്ധിക്കാം, നിർവചിക്കപ്പെട്ട മുകളിൽ/താഴെ പരിധികൾ ഇല്ലെങ്കിലും, ആ മൂല്യങ്ങൾ സാധാരണയായി ചില പരിമിത ഇടവേളകൾക്കുള്ളിൽ മാത്രമേ വരൂ, അതിനാൽ അത്യന്തം മൂല്യങ്ങളുള്ള അവസ്ഥകൾ വളരെ അപൂർവമാണ്.
-
ഇവിടെ ഒരു ഫംഗ്ഷൻ ഉണ്ട്, ഇത് നമ്മുടെ മോഡലിൽ നിന്നുള്ള അവലോകനം സ്വീകരിച്ച് 4 പൂർണ്ണസംഖ്യകളുടെ ട്യൂപ്പിൾ നൽകും: (കോഡ് ബ്ലോക്ക് 6)
def discretize(x): return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
-
ബിൻസുകൾ ഉപയോഗിച്ച് മറ്റൊരു വ്യത്യസ്തീകരണ രീതി പരിശോധിക്കാം: (കോഡ് ബ്ലോക്ക് 7)
def create_bins(i,num): return np.arange(num+1)*(i[1]-i[0])/num+i[0] print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10)) ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # ഓരോ പാരാമീറ്ററിനും മൂല്യങ്ങളുടെ ഇടവേളകൾ nbins = [20,20,10,10] # ഓരോ പാരാമീറ്ററിനും ബിൻസുകളുടെ എണ്ണം bins = [create_bins(ints[i],nbins[i]) for i in range(4)] def discretize_bins(x): return tuple(np.digitize(x[i],bins[i]) for i in range(4))
-
ഇപ്പോൾ ഒരു ചെറിയ സിമുലേഷൻ ഓടിച്ച് ആ വ്യത്യസ്ത പരിസ്ഥിതി മൂല്യങ്ങൾ കാണാം.
discretizeഉംdiscretize_binsഉം രണ്ടും പരീക്ഷിച്ച് വ്യത്യാസമുണ്ടോ എന്ന് നോക്കാം.✅ discretize_bins ബിൻ നമ്പർ (0-ആധാരിതം) തിരികെ നൽകുന്നു. അതിനാൽ ഇൻപുട്ട് മൂല്യങ്ങൾ 0-നു സമീപം ഉള്ളപ്പോൾ ഇടവേളയുടെ മധ്യത്തിലെ നമ്പർ (10) നൽകും. discretize-ൽ, ഔട്ട്പുട്ട് മൂല്യങ്ങളുടെ പരിധി പരിഗണിച്ചില്ല, അവ നെഗറ്റീവ് ആകാമെന്ന് അനുവദിച്ചു, അതിനാൽ അവസ്ഥ മൂല്യങ്ങൾ മാറ്റം വരുത്തിയിട്ടില്ല, 0 0-നു തുല്യമാണ്. (കോഡ് ബ്ലോക്ക് 8)
env.reset() done = False while not done: #env.render() obs, rew, done, info = env.step(env.action_space.sample()) #print(discretize_bins(obs)) print(discretize(obs)) env.close()
✅ പരിസ്ഥിതി എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് കാണാൻ env.render ആരംഭിക്കുന്ന വരി അൺകമ്മന്റ് ചെയ്യാം. അല്ലെങ്കിൽ ഇത് പശ്ചാത്തലത്തിൽ ഓടിക്കാം, അത് വേഗമാണ്. നാം Q-ലേണിംഗ് പ്രക്രിയയിൽ ഈ "അദൃശ്യ" പ്രവർത്തനം ഉപയോഗിക്കും.
മുൻപത്തെ പാഠത്തിൽ, അവസ്ഥ 0 മുതൽ 8 വരെ ഉള്ള ലളിതമായ സംഖ്യകളുടെ ജോഡിയായിരുന്നു, അതിനാൽ 8x8x2 ആകൃതിയിലുള്ള numpy ടെൻസർ ഉപയോഗിച്ച് Q-ടേബിൾ പ്രതിനിധാനം ചെയ്യുന്നത് സൗകര്യപ്രദമായിരുന്നു. ബിൻസുകൾ ഉപയോഗിച്ച വ്യത്യസ്തീകരണം ഉപയോഗിച്ചാൽ, അവസ്ഥ വെക്ടറിന്റെ വലുപ്പവും അറിയാം, അതിനാൽ 20x20x10x10x2 ആകൃതിയിലുള്ള അറേ ഉപയോഗിച്ച് അവസ്ഥ പ്രതിനിധാനം ചെയ്യാം (ഇവിടെ 2 പ്രവർത്തന സ്ഥലം ഡൈമെൻഷനാണ്, ആദ്യ ഡൈമെൻഷനുകൾ അവലോകന സ്ഥലത്തിലെ ഓരോ പാരാമീറ്ററിനും തിരഞ്ഞെടുക്കപ്പെട്ട ബിൻസുകളുടെ എണ്ണം).
എങ്കിലും, ചിലപ്പോൾ അവലോകന സ്ഥലത്തിന്റെ കൃത്യമായ അളവുകൾ അറിയാത്തതായിരിക്കും. discretize ഫംഗ്ഷന്റെ കേസിൽ, ചില മൂല്യങ്ങൾക്ക് പരിധി ഇല്ലാത്തതിനാൽ, നമ്മുടെ അവസ്ഥ നിശ്ചിത പരിധികളിൽ തന്നെ ഉണ്ടാകുമെന്ന് ഉറപ്പില്ല. അതിനാൽ, നാം Q-ടേബിൾ ഒരു ഡിക്ഷണറിയായി പ്രതിനിധാനം ചെയ്യാം.
-
(state,action) എന്ന ജോഡി ഡിക്ഷണറി കീ ആയി ഉപയോഗിക്കുക, മൂല്യം Q-ടേബിൾ എൻട്രി മൂല്യമായി. (കോഡ് ബ്ലോക്ക് 9)
Q = {} actions = (0,1) def qvalues(state): return [Q.get((state,a),0) for a in actions]
ഇവിടെ
qvalues()എന്ന ഫംഗ്ഷനും നിർവചിച്ചിരിക്കുന്നു, ഇത് ഒരു നൽകിയ അവസ്ഥയ്ക്കുള്ള എല്ലാ സാധ്യമായ പ്രവർത്തനങ്ങൾക്കുള്ള Q-ടേബിൾ മൂല്യങ്ങളുടെ പട്ടിക തിരികെ നൽകുന്നു. എൻട്രി Q-ടേബിളിൽ ഇല്ലെങ്കിൽ, നാം 0 ഡിഫോൾട്ട് ആയി നൽകും.
ഇപ്പോൾ പീറ്ററിനെ ബാലൻസ് ചെയ്യാൻ പഠിപ്പിക്കാൻ തയ്യാറാണ്!
-
ആദ്യം, ചില ഹൈപ്പർപാരാമീറ്ററുകൾ സജ്ജമാക്കാം: (കോഡ് ബ്ലോക്ക് 10)
# ഹൈപ്പർപാരാമീറ്ററുകൾ alpha = 0.3 gamma = 0.9 epsilon = 0.90
ഇവിടെ,
alphaഎന്നത് ലേണിംഗ് റേറ്റ് ആണ്, ഓരോ ഘട്ടത്തിലും Q-ടേബിളിലെ നിലവിലെ മൂല്യങ്ങൾ എത്രമാത്രം ക്രമീകരിക്കണമെന്ന് നിർവചിക്കുന്നു. മുൻപത്തെ പാഠത്തിൽ നാം 1-ൽ ആരംഭിച്ച് പരിശീലനത്തിനിടെalphaകുറച്ചു. ഈ ഉദാഹരണത്തിൽ, ലളിതത്വത്തിനായി ഇത് സ്ഥിരമായി വയ്ക്കും, പിന്നീട്alphaക്രമീകരിച്ച് പരീക്ഷിക്കാം.gammaഎന്നത് ഡിസ്കൗണ്ട് ഫാക്ടർ ആണ്, ഭാവിയിലെ റിവാർഡിനെ നിലവിലെ റിവാർഡിനേക്കാൾ എത്രമാത്രം മുൻഗണന നൽകണമെന്ന് കാണിക്കുന്നു.epsilonഎന്നത് എക്സ്പ്ലോറേഷൻ/എക്സ്പ്ലോയിറ്റേഷൻ ഫാക്ടർ ആണ്, എക്സ്പ്ലോറേഷൻ (പുതിയ കാര്യങ്ങൾ പരീക്ഷിക്കൽ) മുൻഗണന നൽകണോ എക്സ്പ്ലോയിറ്റേഷൻ (ഇപ്പോൾ അറിയുന്ന മികച്ച പ്രവർത്തനം തിരഞ്ഞെടുക്കൽ) മുൻഗണന നൽകണോ എന്ന് നിർവചിക്കുന്നു. നമ്മുടെ ആൽഗോരിതത്തിൽ,epsilonശതമാനത്തിൽ നാം Q-ടേബിൾ മൂല്യങ്ങൾ അനുസരിച്ച് പ്രവർത്തനം തിരഞ്ഞെടുക്കും, ബാക്കി സമയങ്ങളിൽ യാദൃച്ഛിക പ്രവർത്തനം നടത്തും. ഇതിലൂടെ നാം മുമ്പ് കാണാത്ത തിരയൽ പ്രദേശങ്ങൾ പരിശോധിക്കാം.✅ ബാലൻസിംഗിന്റെ കാര്യത്തിൽ - യാദൃച്ഛിക പ്രവർത്തനം (എക്സ്പ്ലോറേഷൻ) തെറ്റായ ദിശയിൽ ഒരു പഞ്ച് പോലെയാണ്, പോൾ അവിടെ നിന്നു ബാലൻസ് വീണ്ടെടുക്കാൻ പഠിക്കണം.
മുൻപത്തെ പാഠത്തിലെ ആൽഗോരിതത്തിൽ നാം രണ്ട് മെച്ചപ്പെടുത്തലുകൾ ചെയ്യാം:
-
ശരാശരി സമാഹാര റിവാർഡ് കണക്കാക്കുക, പല സിമുലേഷനുകളിലായി. ഓരോ 5000 ഇറ്ററേഷനിലും പുരോഗതി പ്രിന്റ് ചെയ്യും, ആ കാലയളവിൽ സമാഹാര റിവാർഡ് ശരാശരി കണക്കാക്കും. 195-ൽ കൂടുതൽ പോയിന്റ് കിട്ടിയാൽ പ്രശ്നം പരിഹരിച്ചതായി കണക്കാക്കാം, ആവശ്യത്തിനേക്കാൾ ഉയർന്ന ഗുണമേന്മയോടെ.
-
പരമാവധി ശരാശരി സമാഹാര ഫലം
Qmaxകണക്കാക്കുക, ആ ഫലത്തിന് അനുയോജ്യമായ Q-ടേബിൾ സൂക്ഷിക്കുക. പരിശീലനത്തിൽ ചിലപ്പോൾ ശരാശരി ഫലം കുറയാൻ തുടങ്ങും, അതിനാൽ മികച്ച മോഡലിന്റെ Q-ടേബിൾ മൂല്യങ്ങൾ സൂക്ഷിക്കണം.
-
ഓരോ സിമുലേഷനിലും സമാഹാര റിവാർഡുകൾ
rewardsവെക്ടറിൽ ശേഖരിക്കുക, പിന്നീട് പ്ലോട്ടിംഗിനായി. (കോഡ് ബ്ലോക്ക് 11)def probs(v,eps=1e-4): v = v-v.min()+eps v = v/v.sum() return v Qmax = 0 cum_rewards = [] rewards = [] for epoch in range(100000): obs = env.reset() done = False cum_reward=0 # == സിമുലേഷൻ നടത്തുക == while not done: s = discretize(obs) if random.random()<epsilon: # ഉപയോഗം - Q-ടേബിൾ സാധ്യതകൾ അനുസരിച്ച് പ്രവർത്തനം തിരഞ്ഞെടുക്കുക v = probs(np.array(qvalues(s))) a = random.choices(actions,weights=v)[0] else: # അന്വേഷണശീലനം - യാദൃച്ഛികമായി പ്രവർത്തനം തിരഞ്ഞെടുക്കുക a = np.random.randint(env.action_space.n) obs, rew, done, info = env.step(a) cum_reward+=rew ns = discretize(obs) Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns))) cum_rewards.append(cum_reward) rewards.append(cum_reward) # == കാലക്രമേണ ഫലങ്ങൾ പ്രിന്റ് ചെയ്ത് ശരാശരി പ്രതിഫലം കണക്കാക്കുക == if epoch%5000==0: print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}") if np.average(cum_rewards) > Qmax: Qmax = np.average(cum_rewards) Qbest = Q cum_rewards=[]
ഈ ഫലങ്ങളിൽ നിന്നു നിങ്ങൾ ശ്രദ്ധിക്കാവുന്ന കാര്യങ്ങൾ:
-
ലക്ഷ്യത്തിന് അടുത്ത്. 100+ തുടർച്ചയായ സിമുലേഷനുകളിൽ 195 സമാഹാര റിവാർഡ് നേടാനുള്ള ലക്ഷ്യത്തിന് വളരെ അടുത്ത് നാം എത്തി, അല്ലെങ്കിൽ അത് നേടിയിട്ടുണ്ടാകാം! ചെറിയ സംഖ്യകൾ കിട്ടിയാലും, നാം 5000 റൺസിന്റെ ശരാശരി കണക്കാക്കുന്നു, ഔദ്യോഗിക മാനദണ്ഡം 100 റൺസ് മാത്രം ആവശ്യമാണ്.
-
റിവാർഡ് കുറയാൻ തുടങ്ങുന്നു. ചിലപ്പോൾ റിവാർഡ് കുറയാൻ തുടങ്ങും, അതായത് നാം Q-ടേബിളിലെ പഠിച്ച മൂല്യങ്ങളെ "നശിപ്പിച്ച്" അവസ്ഥ മോശമാക്കുന്ന മൂല്യങ്ങൾ ചേർക്കുന്നു.
ഈ നിരീക്ഷണം പരിശീലന പുരോഗതി പ്ലോട്ട് ചെയ്താൽ കൂടുതൽ വ്യക്തമായി കാണാം.
പരിശീലനത്തിനിടെ, ഓരോ ഇറ്ററേഷനിലും സമാഹാര റിവാർഡ് മൂല്യം rewards വെക്ടറിൽ ശേഖരിച്ചിട്ടുണ്ട്. ഇറ്ററേഷൻ നമ്പറിനോട് താരതമ്യം ചെയ്ത് പ്ലോട്ട് ചെയ്താൽ ഇങ്ങനെ കാണാം:
plt.plot(rewards)
ഈ ഗ്രാഫിൽ ഒന്നും വ്യക്തമാക്കാൻ കഴിയില്ല, കാരണം സ്റ്റോക്കാസ്റ്റിക് പരിശീലന പ്രക്രിയയുടെ സ്വഭാവം മൂലം പരിശീലന സെഷനുകളുടെ ദൈർഘ്യം വളരെ വ്യത്യാസപ്പെടുന്നു. ഈ ഗ്രാഫിന്റെ അർത്ഥം മനസ്സിലാക്കാൻ, നാം 100 പരീക്ഷണങ്ങളുടെ റണ്ണിംഗ് ശരാശരി കണക്കാക്കാം. ഇത് np.convolve ഉപയോഗിച്ച് എളുപ്പത്തിൽ ചെയ്യാം: (കോഡ് ബ്ലോക്ക് 12)
def running_average(x,window):
return np.convolve(x,np.ones(window)/window,mode='valid')
plt.plot(running_average(rewards,100))
പഠനം കൂടുതൽ സ്ഥിരതയുള്ളതാക്കാൻ, പരിശീലനത്തിനിടെ ചില ഹൈപ്പർപാരാമീറ്ററുകൾ ക്രമീകരിക്കുന്നത് ഉചിതമാണ്. പ്രത്യേകിച്ച്:
-
ലേണിംഗ് റേറ്റ്
alpha-യെ 1-നു സമീപം ആരംഭിച്ച് പിന്നീട് കുറയ്ക്കാം. സമയം കഴിഞ്ഞ് Q-ടേബിളിൽ നല്ല സാധ്യത മൂല്യങ്ങൾ ലഭിക്കും, അതിനാൽ അവയെ ചെറിയ തോതിൽ ക്രമീകരിക്കണം, പൂർണ്ണമായും മാറ്റരുത്. -
epsilon വർദ്ധിപ്പിക്കുക. കുറച്ച് എക്സ്പ്ലോറേഷൻ കുറച്ച് എക്സ്പ്ലോയിറ്റേഷൻ കൂടുതൽ ആക്കാൻ
epsilonമന്ദഗതിയിൽ വർദ്ധിപ്പിക്കാം. കുറഞ്ഞ മൂല്യത്തിൽ ആരംഭിച്ച് ഏകദേശം 1 വരെ എത്തിക്കുക ഉചിതമാണ്.
ടാസ്ക് 1: ഹൈപ്പർപാരാമീറ്റർ മൂല്യങ്ങളുമായി പരീക്ഷിച്ച് ഉയർന്ന സമാഹാര റിവാർഡ് നേടാമോ എന്ന് നോക്കുക. 195-ൽ മുകളിൽ എത്തുന്നുണ്ടോ? ടാസ്ക് 2: പ്രശ്നം ഔപചാരികമായി പരിഹരിക്കാൻ, 100 തുടർച്ചയായ റൺസിൽ ശരാശരി 195 റിവാർഡ് നേടണം. പരിശീലനത്തിനിടെ അത് അളക്കുകയും പ്രശ്നം ഔപചാരികമായി പരിഹരിച്ചതായി ഉറപ്പാക്കുകയും ചെയ്യുക!
പരിശീലിച്ച മോഡൽ എങ്ങനെ പെരുമാറുന്നു എന്ന് യഥാർത്ഥത്തിൽ കാണുന്നത് രസകരമായിരിക്കും. സിമുലേഷൻ നടത്തുകയും പരിശീലനത്തിനിടെ ഉപയോഗിച്ച പ്രവർത്തന തിരഞ്ഞെടുപ്പ് തന്ത്രം പിന്തുടരുകയും ചെയ്യാം, Q-ടേബിളിലെ പ്രൊബബിലിറ്റി വിതരണത്തിന് അനുസരിച്ച് സാമ്പിൾ ചെയ്യുക: (കോഡ് ബ്ലോക്ക് 13)
obs = env.reset()
done = False
while not done:
s = discretize(obs)
env.render()
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
obs,_,done,_ = env.step(a)
env.close()നിങ്ങൾക്ക് ഇങ്ങനെ ഒന്നൊന്നായി കാണാം:
ടാസ്ക് 3: ഇവിടെ, നാം Q-ടേബിളിന്റെ അന്തിമ പകർപ്പ് ഉപയോഗിച്ചിരുന്നു, അത് ഏറ്റവും മികച്ചതായിരിക്കണമെന്നില്ല. നാം മികച്ച പ്രകടനം കാഴ്ചവച്ച Q-ടേബിൾ
Qbestവേരിയബിളിൽ സൂക്ഷിച്ചിട്ടുണ്ടെന്ന് ഓർക്കുക!Qbest-നെQ-ലേക്ക് പകർത്തി ഏറ്റവും മികച്ച Q-ടേബിൾ ഉപയോഗിച്ച് അതേ ഉദാഹരണം പരീക്ഷിച്ച് വ്യത്യാസം ശ്രദ്ധിക്കുക.
ടാസ്ക് 4: ഇവിടെ നാം ഓരോ ഘട്ടത്തിലും ഏറ്റവും മികച്ച പ്രവർത്തനം തിരഞ്ഞെടുക്കുന്നില്ല, മറിച്ച് അനുയോജ്യമായ പ്രൊബബിലിറ്റി വിതരണത്തിന് അനുസരിച്ച് സാമ്പിൾ ചെയ്യുന്നു. ഏറ്റവും ഉയർന്ന Q-ടേബിൾ മൂല്യമുള്ള ഏറ്റവും മികച്ച പ്രവർത്തനം എപ്പോഴും തിരഞ്ഞെടുക്കുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടുള്ളതായിരിക്കും? ഇത്
np.argmaxഫംഗ്ഷൻ ഉപയോഗിച്ച് ഏറ്റവും ഉയർന്ന Q-ടേബിൾ മൂല്യത്തിന് അനുയോജ്യമായ പ്രവർത്തന നമ്പർ കണ്ടെത്തി ചെയ്യാം. ഈ തന്ത്രം നടപ്പിലാക്കി ബാലൻസിംഗ് മെച്ചപ്പെടുന്നുണ്ടോ എന്ന് നോക്കുക.
നാം ഇപ്പോൾ ഏജന്റുകളെ മികച്ച ഫലങ്ങൾ നേടാൻ പരിശീലിപ്പിക്കുന്നത് എങ്ങനെ എന്നത് പഠിച്ചു, അത് ഗെയിമിന്റെ ആഗ്രഹിക്കുന്ന അവസ്ഥ നിർവചിക്കുന്ന റിവാർഡ് ഫംഗ്ഷൻ നൽകിയും, തിരയൽ സ്ഥലം ബുദ്ധിമുട്ടോടെ അന്വേഷിക്കാൻ അവസരം നൽകിയും ആണ്. നാം Q-ലേണിംഗ് ആൽഗോരിതം ഡിസ്ക്രീറ്റ്, തുടർച്ചയായ പരിസ്ഥിതികളിൽ വിജയകരമായി പ്രയോഗിച്ചു, പക്ഷേ ഡിസ്ക്രീറ്റ് പ്രവർത്തനങ്ങളോടെയാണ്.
പ്രവർത്തനാവസ്ഥയും തുടർച്ചയായതായ സാഹചര്യങ്ങളും, അതുപോലെ ആറ്റാരി ഗെയിം സ്ക്രീനിലെ ചിത്രം പോലുള്ള കൂടുതൽ സങ്കീർണ്ണമായ നിരീക്ഷണ സ്ഥലം ഉള്ള സാഹചര്യങ്ങളും പഠിക്കുന്നത് പ്രധാനമാണ്. അത്തരത്തിലുള്ള പ്രശ്നങ്ങളിൽ നല്ല ഫലങ്ങൾ നേടാൻ നാം സാധാരണയായി ന്യുറൽ നെറ്റ്വർക്കുകൾ പോലുള്ള ശക്തമായ മെഷീൻ ലേണിംഗ് സാങ്കേതികവിദ്യകൾ ഉപയോഗിക്കേണ്ടിവരും. ആധികാരികമായ ഈ വിഷയങ്ങൾ നമ്മുടെ വരാനിരിക്കുന്ന കൂടുതൽ ആധുനിക AI കോഴ്സിന്റെ വിഷയം ആണ്.
അസൂയാപത്രം:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ വ്യാഖ്യാനക്കേടുകൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.