Je veux escalader une montagne avec l'apprentissage par renforcement

51988414-脳のギア。ai-人工知能の概念。.jpg

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

Apprentissage fluide Q

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.

Mise à jour de la valeur de l'action d'état

En général, la méthode de mise à jour de la valeur de comportement d'état est exprimée comme suit.

$\begin{aligned}Q\left( s_{t},a_{t}\right) \\ \leftarrow Q\left( s_{t},a_{t}\right) \\ +\alpha \left( G_{t}-Q\left( s_{t},a_{t}\right) \right) \end{aligned}$ Ici, dans le cas de l'apprentissage Q, $ G_ {t} $ est

$G_{t}=r_{t+1}+\gamma\max_{a\in At}[Q(s_{t+1},a)]$ Vous pouvez voir qu'il considère l'état suivant au lieu de l'état actuel, tel que $ s_ {t + 1} $. Vous pouvez voir que cela prend également en compte les récompenses qui seront obtenues à l'avenir. $ r_ {t + 1} $ s'appelle récompense immédiate </ font>, et la récompense que vous obtenez immédiatement après la transition, $ \ alpha $ est taux d'apprentissage < Appelé / font>, il détermine à quel point la valeur est mise à jour dans un apprentissage. $ \ Gamma $ est appelé taux de remise </ font> et détermine combien vous souhaitez faire référence aux récompenses futures.

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.

Règles de Mountain Car

スクリーンショット 2020-09-10 22.31.19.png

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.

Préparation

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

Importation de bibliothèque

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

Mise en œuvre de l'apprentissage Q

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()

スクリーンショット 2020-09-10 22.38.42.png

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. 車を走らせる.gif

Impressions

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