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

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

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.

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!