Le simulateur Gym

Gym c’est une boite à outil qui propose plusieurs environnements de simulation pour des algorithmes de renforcement et d’apprentissage.

Gym propose plusieurs types d’environnement qui sont les suivants :

• Algorithms
• Atari
• Box2D
• Classic control
• MuJoCo
• Robotics
• Toy text

Pour des raisons de compatibilités avec l’algorithme d’apprentissage que nous avions, notre intérêt c’est porté sur les environnements Box2D et MuJoCo.

Gym est simplement une librairie python qui offre des fonctionnalités. Ainsi, sont installations est simple :

pip install gym

Une seconde méthode existe en installant directement le package via git

git clone https://github.com/openai/gym
cd gym
pip install -e .

Une fois que l’installation est fait, on peut commencer à s’amuser avec des fonctionnalités de base :

gym.make(“environment name”) : retourne l’environnement dont le nom a été passé en paramètre

env.reset() : reset l’environnement, retourne l’observation initiale

env.render() : permet d’afficher la fenêtre de simulation.

env.step() : exécute une action et retourne 4 paramètres (observation, reward, done, info)

La fonction env.step() prend en paramètre une action et retourne les 4 paramètres suivants :

observation : un objet spécifique à l’environnement représentant une observation

reward : un nombre de récompense obtenu par l’action précédente

done : une valeur booléenne qui indique si il faut reset l’environnement ou non

info : des informations de diagnostic utile pour le débuggage

Il est important de noter que ces informations dépendent de l’environnement dans lequel elles sont définies.

Gym propose plusieurs type d’environnement et plusieurs environnements par type. Au début, notre choix était porté vers l’environnement CarRacing-v0, avec la vue de dessus mais il c’est avéré que les observations retournés étaient au format image avec un tableau 96x96x3 de nombre correspondant à des couleurs

Une autre solution était l’installation de MuJoCo, mais cette dernière à posé des soucis et n’as pas pu être faite sur les machines de l’école.

Donc au final, l’environnement le plus adapté suivant toutes nos contraintes était l'environnement BipedalWalker-v2, malgré le fait que la vue soit de côté, les observations conviennent bien à l’algorithme d’apprentissage.

Pour le code, nous avons chacun développez un code qui fait l’interface entre l’algorithme d’apprentissage et le simulateur. Pour avoir une interface commune nous avons créez une classe abstraite dont nous héritons et implémentons les méthodes. De ce fait, nous utilisons les mêmes noms de méthodes pour chaque simulateur mais leur implémentations est différentes

La difficulté a été de trouver les points qu’on pouvait mettre en commun entre les différents simulateurs, au niveau des fonctionnalités disponibles des simulateurs et des valeurs d’entrées et de sorties des méthodes.

Au final, concernant Gym, j’ai réussi à convertir l’environnement et ses données, en type Entity et ses Property, comme voulu à la base.

class Environment() : Cette classe hérite de notre interface commune et implémente ses méthodes

def loadEnvironment() : Cette méthode charge l’environnement dont le nom a été spécifié dans le constructeur de la classe et retourne un objet de type environment correspondant

def startSimulation(): lance une simulation avec 100 timesteps par défaut

def resetSimulation(): termine la simulation prématurément

def getListObject(): affiche la liste des propriétés de l’entité

def getSimulationTime() : Affiche le temps passer depuis le lancement du script

class GymSimulator(): classe héritant de la classe Entity et par conséquent, implémente ses méthodes

def getFormat(): affiche les formats de données des actions et des observations

class BipedalWalker(): classe fille de GymSimulator() pour l’environnement BidepalWalker

class CarRacing(): classe fille de GymSimulator() pour l’environnement CarRacing

def move(): envoie une action au simulateur et retourne les résultats de cette action

if main==”main”:

Fonction d’exemple d’utilisation avec l’environnement BipedalWalker, 100 timesteps, une affiche de l’environnement dans une fenêtre et toutes les actions effectués d’un coup.

Pour avoir un mode interactif action par action, passer le paramètre self.interactiveMode à True ligne 16

Pour avoir un mode sans l’affichage de la fenêtre, passer le paramètre self.displayMode à False ligne 75

Pour changer le nombre de Timesteps changer la valeur de n, ligne 28.

Exemple de code

#!/usr/bin/env python
# coding: utf-8

#import des librairies nécessaires
import gym
import re
from gym import envs
from random import randint

#Récupération de l'environnement
#Ici on récupère l’environnement CarRacing-v0
env = gym.make('CarRacing-v0')

#Liste les environnements disponibles
for i in envs.registry.all():
           print(i)

#Récupération des formats de données de action et observation
print("Actions : "+str(self.env.action_space))
print("Observations : "+str(self.env.observation_space))

#Remise à zéro de l'environnement
env.reset()

#Pour 1000 timesteps
for t in range(1000):
            #on affiche la fenêtre de simulation
       env.render()
            #on récupère une action aléatoire possible pour l’environnement
       action = env.action_space.sample()       
       #on exécute l’action et on récupère les informations
       observation, reward, done, info = env.step(action)
             #on affiche les informations
       print("action : "+str(action))
       print("reward : "+str(reward))
       print("done : "+str(done))
       print("info : "+str(info))
             #si il y a une réussite ou une erreur, on arrête la simulation
       if (done == 1):
                    break

Ci-dessous notre classe abstraite :

class scene:
    #Gasebo param is null
    #Vrep param is the port connection
    #Gym  param is the name of the environment loaded
    def __init__(self, param = None):
        pass
    def startSimulation(self):
        pass
    def pauseSimulation(self):
        pass
    def resetSimulation(self, onlyWorld = None):
        pass
    def getListObject(self):
        pass
    #Vrep param is the path to find the scene
    #Gym  param is null
    def loadEnvironment(self, param = None):
        pass
    def getSimulationTime(self):
        pass

Le simulateur Gym est dépendant des environnements qui existent, si vous ne trouvez pas d’environnements qui vous conviennent, il est possible de créer son propre environnement. Je n’ai pas eu l’occasion d'approfondir cette partie donc voici la documentation associé : https://github.com/openai/gym/tree/master/gym/envs#how-to-create-new-environments-for-gym

Documentation de gym : https://gym.openai.com/docs/ Code de car_racing.py : https://github.com/openai/gym/blob/master/gym/envs/box2d/car_racing.py Git de gym : https://github.com/openai/gym