38 KiB

Raw Permalink Blame History

కార్ట్‌పోల్ స్కేటింగ్

మునుపటి పాఠంలో మేము పరిష్కరించిన సమస్య ఒక ఆటపాట సమస్యగా అనిపించవచ్చు, నిజ జీవిత పరిస్థితులకు అన్వయించదగినది కాదు అనిపించవచ్చు. ఇది నిజం కాదు, ఎందుకంటే అనేక నిజ ప్రపంచ సమస్యలు కూడా ఈ పరిస్థితిని పంచుకుంటాయి - చెస్ లేదా గో ఆడటం సహా. అవి సమానమైనవి, ఎందుకంటే మాకు కూడా ఒక బోర్డు మరియు ఇచ్చిన నియమాలు మరియు ఒక విభిన్న స్థితి ఉంటుంది.

పూర్వ-పాఠం క్విజ్

పరిచయం

ఈ పాఠంలో మేము Q-లెర్నింగ్ యొక్క అదే సూత్రాలను సతత స్థితి ఉన్న సమస్యకు వర్తింపజేస్తాము, అంటే ఒకటి లేదా ఎక్కువ వాస్తవ సంఖ్యల ద్వారా ఇచ్చిన స్థితి. మేము క్రింది సమస్యను పరిష్కరిస్తాము:

సమస్య: పీటర్ నక్క నుండి తప్పించుకోవాలంటే, అతను వేగంగా కదలగలగాలి. పీటర్ ఎలా స్కేట్ చేయాలో, ముఖ్యంగా, సమతుల్యతను ఎలా ఉంచాలో Q-లెర్నింగ్ ఉపయోగించి నేర్చుకోవడం ఎలా అనేది మేము చూడబోతున్నాము.

పీటర్ మరియు అతని స్నేహితులు నక్క నుండి తప్పించుకోవడానికి సృజనాత్మకత చూపుతున్నారు! చిత్రం Jen Looper ద్వారా

మేము సమతుల్యతను సాధించడానికి సులభీకరించిన వెర్షన్ అయిన కార్ట్‌పోల్ సమస్యను ఉపయోగిస్తాము. కార్ట్‌పోల్ ప్రపంచంలో, మాకు ఎడమ లేదా కుడి వైపు కదలగల ఒక ఆడంబరమైన స్లైడర్ ఉంటుంది, మరియు లక్ష్యం స్లైడర్ పై ఒక నిలువెత్తు కాండాన్ని సమతుల్యం చేయడం.

ముందస్తు అవగాహన

ఈ పాఠంలో, మేము OpenAI Gym అనే లైబ్రరీని వాడి వివిధ పరిసరాలను అనుకరించబోతున్నాము. మీరు ఈ పాఠం కోడ్‌ను స్థానికంగా (ఉదా: Visual Studio Code నుండి) నడపవచ్చు, అప్పుడు అనుకరణ కొత్త విండోలో తెరుస్తుంది. ఆన్‌లైన్‌లో కోడ్ నడిపేటప్పుడు, మీరు కొంత మార్పులు చేయవలసి ఉండవచ్చు, వివరాలు ఇక్కడ ఉన్నాయి.

OpenAI Gym

మునుపటి పాఠంలో, ఆట నియమాలు మరియు స్థితి మేము నిర్వచించిన 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 నుండి ఒక చర్యను ఎంచుకుంటాము.

క్రింది కోడ్ నడపండి మరియు దాని ఫలితాన్ని చూడండి.

✅ గమనించండి, ఈ కోడ్ స్థానిక Python ఇన్‌స్టాలేషన్‌లో నడపడం మంచిది! (కోడ్ బ్లాక్ 3)
```
env.reset()

for i in range(100):
   env.render()
   env.step(env.action_space.sample())
env.close()
```
మీరు ఈ చిత్రానికి సమానమైన దృశ్యాన్ని చూడవచ్చు:
సిమ్యులేషన్ సమయంలో, చర్య తీసుకోవడానికి ఎలా నిర్ణయించాలో తెలుసుకోవడానికి పరిశీలనలు పొందాలి. వాస్తవానికి, step ఫంక్షన్ ప్రస్తుత పరిశీలనలు, రివార్డ్ ఫంక్షన్, మరియు సిమ్యులేషన్ కొనసాగించవలసినదో లేదో సూచించే done ఫ్లాగ్‌ను తిరిగి ఇస్తుంది: (కోడ్ బ్లాక్ 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-టేబుల్ నిర్మించాలి. దీని కోసం, స్థితి విభిన్నమైన ఉండాలి, అంటే పరిమిత సంఖ్యలో విభిన్న విలువలు ఉండాలి. అందువల్ల, మేము పరిశీలనలను విభజించాలి, వాటిని పరిమిత స్థితుల సమూహానికి మ్యాప్ చేయాలి.

ఇది చేయడానికి కొన్ని మార్గాలు ఉన్నాయి:

బిన్లుగా విభజించండి. ఒక విలువ యొక్క పరిధి తెలిసినట్లయితే, ఆ పరిధిని కొన్ని బిన్లుగా విభజించి, ఆ విలువను ఆ బిన్ సంఖ్యతో మార్చవచ్చు. ఇది 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-లెర్నింగ్ ప్రక్రియలో మేము ఈ "అదృశ్య" అమలును ఉపయోగిస్తాము.

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 తిరిగి ఇస్తాము.

Q-లెర్నింగ్ ప్రారంభిద్దాం

ఇప్పుడు పీటర్‌కు సమతుల్యత నేర్పడానికి సిద్ధంగా ఉన్నాము!

ముందుగా, కొన్ని హైపర్‌పారామీటర్లను సెట్ చేద్దాం: (కోడ్ బ్లాక్ 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 ను మెల్లగా పెంచాలని కోరుకోవచ్చు, తద్వారా తక్కువ అన్వేషణ మరియు ఎక్కువ ఉపయోగం జరుగుతుంది. సాధారణంగా తక్కువ epsilon విలువతో ప్రారంభించి దాన్ని సుమారు 1 వరకు పెంచడం మంచిది.

పని 1: హైపర్‌పారామీటర్ విలువలతో ఆడండి మరియు మీరు ఎక్కువ సమ్మిళిత రివార్డ్ సాధించగలరా చూడండి. మీరు 195 కంటే ఎక్కువ పొందుతున్నారా? Task 2: సమస్యను అధికారికంగా పరిష్కరించడానికి, మీరు 100連続 రన్స్‌లో సగటు 195 రివార్డు పొందాలి. శిక్షణ సమయంలో దాన్ని కొలవండి మరియు మీరు అధికారికంగా సమస్యను పరిష్కరించారని నిర్ధారించుకోండి!

ఫలితాన్ని చర్యలో చూడటం

శిక్షణ పొందిన మోడల్ ఎలా ప్రవర్తిస్తుందో నిజంగా చూడటం ఆసక్తికరం. సిమ్యులేషన్‌ను నడిపించి, శిక్షణ సమయంలో ఉపయోగించిన అదే చర్య ఎంపిక వ్యూహాన్ని అనుసరించండి, Q-టేబుల్‌లోని probability distribution ప్రకారం నమూనా తీసుకోండి: (కోడ్ బ్లాక్ 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()

మీకు ఇలాంటిది కనిపించాలి:

🚀సవాలు

Task 3: ఇక్కడ, మేము Q-టేబుల్ యొక్క తుది కాపీని ఉపయోగిస్తున్నాము, అది ఉత్తమమైనది కాకపోవచ్చు. మేము ఉత్తమ ప్రదర్శన Q-టేబుల్‌ను Qbest వేరియబుల్‌లో నిల్వ చేశామని గుర్తుంచుకోండి! Qbest ను Q పై కాపీ చేసి అదే ఉదాహరణను ప్రయత్నించి తేడా గమనించండి.

Task 4: ఇక్కడ మేము ప్రతి దశలో ఉత్తమ చర్యను ఎంచుకోలేదు, కానీ సంబంధిత probability distribution ప్రకారం నమూనా తీసుకున్నాము. ఎప్పుడూ అత్యధిక Q-టేబుల్ విలువ కలిగిన ఉత్తమ చర్యను ఎంచుకోవడం మరింత అర్థవంతమా? ఇది np.argmax ఫంక్షన్ ఉపయోగించి అత్యధిక Q-టేబుల్ విలువకు సంబంధించిన చర్య సంఖ్యను కనుగొనడం ద్వారా చేయవచ్చు. ఈ వ్యూహాన్ని అమలు చేసి బ్యాలెన్సింగ్ మెరుగవుతుందో చూడండి.

పోస్ట్-లెక్చర్ క్విజ్

అసైన్‌మెంట్

Train a Mountain Car

ముగింపు

మేము ఇప్పుడు ఏజెంట్లను శిక్షణ ఇచ్చి మంచి ఫలితాలు సాధించడానికి ఎలా చేయాలో నేర్చుకున్నాము, కేవలం వారికి గేమ్ యొక్క కావలసిన స్థితిని నిర్వచించే రివార్డు ఫంక్షన్ ఇవ్వడం ద్వారా, మరియు వారు తెలివిగా శోధన స్థలాన్ని అన్వేషించడానికి అవకాశం ఇవ్వడం ద్వారా. మేము విజయవంతంగా Q-లెర్నింగ్ అల్గోరిథమ్‌ను డిస్క్రీట్ మరియు కంటిన్యూయస్ వాతావరణాలలో, కానీ డిస్క్రీట్ చర్యలతో, వర్తింపజేశాము.

చర్య స్థితి కూడా కంటిన్యూయస్ అయిన సందర్భాలు మరియు పరిశీలన స్థలం మరింత క్లిష్టమైనప్పుడు, ఉదాహరణకు అటారి గేమ్ స్క్రీన్ నుండి చిత్రం వంటి సందర్భాలు కూడా అధ్యయనం చేయడం ముఖ్యం. ఆ సమస్యలలో మంచి ఫలితాలు సాధించడానికి మేము తరచుగా న్యూరల్ నెట్‌వర్క్‌ల వంటి శక్తివంతమైన మెషీన్ లెర్నింగ్ సాంకేతికతలను ఉపయోగించాల్సి ఉంటుంది. ఆ అధునాతన విషయాలు మా రాబోయే అధునాతన AI కోర్సు విషయాలు.

అస్పష్టత:
ఈ పత్రాన్ని AI అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.

38 KiB Raw Permalink Blame History