L'apprentissage par renforcement est cool, n'est-ce pas? Cette fois, j'ai joué avec "Mountain Car" de l'environnement python "OpenAI Gym", je vais donc le présenter. Au fait, j'utilise Google Colab </ font>.
J'ai beaucoup parlé de cet article. Introduction à OpenAI Gym
Retour sur l'apprentissage Q en tant que méthode d'apprentissage. Peu importe ce que! Si tel est le cas, veuillez l'ignorer.
Dans l'apprentissage Q, $ Q \ left (s_ {t}, a_ {t} \ right) $ est appelé state action value </ font>, et dans un certain état $ st $, action $ Représente la valeur de prendre a_ {t} $. La notation $ t $ utilisée ici ne signifie pas le temps, mais un seul état d'un état. La valeur ici n'est pas la récompense temporaire que vous recevrez lorsque vous changez d'état, mais la récompense cumulative que vous recevrez lorsque vous aurez terminé l'épisode jusqu'à la fin.
Par conséquent, comme mesure, vous devez sélectionner $ a $ qui devient $ \ max_ {a \ in At} (Q (s_ {t}, a)) $ dans un certain état $ s_ {t} $. Sera.
En général, la méthode de mise à jour de la valeur de comportement d'état est exprimée comme suit.
C'est cet apprentissage $ Q $ qui met à jour cette fonction de valeur d'état en répétant des épisodes (jeux) et cherche la stratégie optimale.
Dans cet environnement, le jeu se termine lorsque la position de la voiture atteint la position du drapeau à droite. À moins que vous ne l'atteigniez, vous obtiendrez une récompense de -1 pour chaque action que vous effectuez. Si vous n'atteignez pas l'objectif après 200 actions, le jeu est terminé. Dans ce cas, vous avez reçu une récompense de -200. En d'autres termes, vous serez formé pour obtenir une récompense supérieure à -200.
Les actions sont limitées à trois: se déplacer vers la gauche: 0, ne pas bouger: 1, se déplacer vers la droite: 2.
J'ai mis diverses choses dans Google Colab pour décrire l'état, mais au final, il ne me reste plus qu'à me mettre en gym.
bash
#installation de gym
$ pip install gym
#Non requis(Recommandé lors de l'utilisation de colab)
$apt update
$apt install xvfb
$apt-get -qq -y install libcusparse8.0 libnvrtc8.0 $ibnvtoolsext1 > /dev/null
$ln -snf /usr/lib/x86_64-linux-gnu/libnvrtc-builtins.so.8.0 /usr/lib/x86_64-linux-gnu/libnvrtc-builtins.so
$apt-get -qq -y install xvfb freeglut3-dev ffmpeg> /dev/null
$pip install pyglet
$pip install pyopengl
$pip install pyvirtualdisplay
Certains d'entre eux ne sont pas nécessaires, vous pouvez donc les choisir comme il convient.
import gym
from gym import logger as gymlogger
from gym.wrappers import Monitor
gymlogger.set_level(40) #error only
import tensorflow as tf
import numpy as np
import random
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
import math
import glob
import io
import base64
from IPython.display import HTML
Je me réfère à github pour les types d'actions et comment utiliser l'environnement. GitHub MountainCar
class Q:
def __init__(self, env):
self.env = env
self.env_low = self.env.observation_space.low #Position et vitesse minimales
self.env_high = self.env.observation_space.high #Position et vitesse maximales
self.env_dx = (self.env_high - self.env_low) / 40 #Divisez en 50 parties égales
self.q_table = np.zeros((40,40,3))
def get_status(self, _observation):
position = int((_observation[0] - self.env_low[0])/self.env_dx[0])
velocity = int((_observation[1] - self.env_low[1])/self.env_dx[1])
return position, velocity
def policy(self, s, epsilon = 0.1):
if np.random.random() <= epsilon:
return np.random.randint(3)
else:
p, v = self.get_status(s)
if self.q_table[p][v][0] == 0 and self.q_table[p][v][1] == 0 and self.q_table[p][v][2] == 0:
return np.random.randint(3)
else:
return np.argmax(self.q_table[p][v])
def learn(self, time = 5000, alpha = 0.4, gamma = 0.99):
log = []
for j in range(time):
total = 0
s = self.env.reset()
done = False
while not done:
a = self.policy(s)
next_s, reward, done, _ = self.env.step(a)
total += reward
p, v = self.get_status(next_s)
G = reward + gamma * max(self.q_table[p][v])
p,v = self.get_status(s)
self.q_table[p][v][a] += alpha*(G - self.q_table[p][v][a])
s = next_s
log.append(total)
if j %100 == 0:
print(str(j) + " ===total reward=== : " + str(total))
return plt.plot(log)
def show(self):
s = self.env.reset()
img = plt.imshow(env.render('rgb_array'))
done = False
while not done:
p, v = self.get_status(s)
s, _, done, _ = self.env.step(self.policy(s))
display.clear_output(wait=True)
img.set_data(env.render('rgb_array'))
plt.axis('off')
display.display(plt.gcf())
self.env.close()
L'état de gestion $ s $ comprend la position actuelle de la voiture (position) et la vitesse actuelle (vitesse). Comme les deux ont des valeurs continues, ils sont définis sur des valeurs discrètes (40, 40) avec la fonction get_status. q_table est l'emplacement de stockage de la fonction de valeur d'état, qui est le produit de chacun des états (40, 40) par le type d'action, (3).
env = gym.make('MountainCar-v0')
agent = Q(env)
agent.learn()
Après avoir appris environ 5 000 fois, le nombre de fois où je peux atteindre mon objectif a augmenté.
Au fait, si vous voulez vérifier l'animation avec google colab,
from IPython import display
from pyvirtualdisplay import Display
import matplotlib.pyplot as plt
d = Display()
d.start()
agent.show()
Vous pouvez le voir dans.
Cette fois, l'explication est assez compliquée, je vais donc la mettre à jour progressivement. Nous continuerons à diffuser des informations tout en jouant avec Gym plus. à plus!
Recommended Posts