Chapitre 4 Explorer la liste des environnements et la nomenclature

Explorez l'environnement

Commençons par choisir un environnement et comprendre l'interface Gym. Vous connaissez peut-être déjà les appels de fonction de base utilisés pour créer l'environnement Gym dans les chapitres précédents.Dans les chapitres précédents, nous avons utilisé ces appels de fonction pour tester notre installation. Ici, nous le referons officiellement.

Nous pouvons maintenant utiliser la méthode gym.make pour créer un environnement à partir de la liste des environnements disponibles. Vous pouvez demander comment trouver une liste des environnements Gym disponibles sur votre système. Nous allons créer un petit script utilitaire pour générer la liste d'environnement afin que vous puissiez vous y référer ultérieurement si vous en avez besoin. Créons un script nommé list_gym_envs.py dans le répertoire ~ / rl_gym_book / ch4 avec le contenu suivant:

from gym import envs
env_names = [spec.id for spec in envs.registry.all()]
for name in sorted(env_names):
    print(name)

Ce script imprimera les noms de tous les environnements disponibles dans l'installation Gym par ordre alphabétique. Vous pouvez exécuter ce script avec la commande suivante pour afficher les noms des environnements installés et disponibles dans le système.
Vous obtiendrez une sortie comme celle-ci. Notez que seuls les premiers noms d'environnement sont affichés.

Nomenclature

La présence du mot ram dans le nom de l'environnement signifie que les observations renvoyées par l'environnement sont le contenu de la mémoire vive (RAM, Random Access Memory) de l'hôte Atari, et le jeu tourne sur cet hôte.

Le mot «déterministe» dans le nom de l'environnement signifie que l'action envoyée par l'agent à l'environnement est répétée dans un certain temps / fixe de quatre trames, puis l'état du résultat est renvoyé.

L'existence du mot NoFrameskip signifie que l'opération envoyée par l'agent à l'environnement n'est exécutée qu'une seule fois, et le statut du résultat est renvoyé immédiatement, sans sauter de trame.

Par défaut, si le nom de l'environnement ne contient pas de déterminisme et NoFrameskip, l'action envoyée à l'environnement sera répétée pour n images, où n est uniformément échantillonné à partir de {2,3,4}.

La lettre v dans le nom de l'environnement suivie d'un nombre indique la version de l'environnement. Ceci permet de garantir que toutes les modifications apportées à l'environnement sont reflétées dans son nom afin que les résultats obtenus par un algorithme / agent dans l'environnement puissent être comparés aux résultats obtenus par un autre algorithme / agent sans aucune différence.

• Alien-ram-v0 : L'observation est le contenu de la RAM de la machine Atari. La taille totale est de 128 octets. Les actions envoyées à l'environnement sont répétées pour n trames, où n est uniformément échantillonné à partir de {2,3,4}.
• Alien-ram-v4 : L'observation est que la taille totale du contenu RAM de la machine Atari est de 128 octets et l'action est envoyée à l'exécution répétée de l'environnement Alien-ram-v4 pour n trames, où n est de { 2,3,4} Échantillonner uniformément. Par rapport à la v0, il y a quelques modifications dans l'environnement.
• Alien- ramDeterministic-v0 : L'observation est le contenu RAM de la machine Atari, la taille totale est de 128 octets, et l'action envoyée à l'environnement est répétée pour la durée de quatre trames.
• AlienramNoFrameskip-v0 : L'observation est le contenu RAM de la machine Atari, la taille totale est de 128 octets, l'action envoyée à l'environnement est appliquée et l'état du résultat est renvoyé immédiatement sans sauter de trame.

La présentation de cet article devrait vous aider à comprendre la nomenclature de l'environnement, qui est généralement applicable à tous les environnements. La RAM peut être spécifique à l'environnement Atari, mais maintenant vous savez déjà ce qui se passe lorsque vous voyez plusieurs noms d'environnement associés.

Explorez l'environnement Gym

Afin que nous puissions visualiser à quoi ressemble l'environnement ou quelles sont ses tâches, nous utiliserons un script simple qui peut démarrer n'importe quel environnement et utiliser des opérations échantillonnées au hasard pour exécuter progressivement l'environnement. Vous pouvez télécharger ce script depuis la base de code de ce livre sous ch4, ou créer un fichier nommé run_gym_env.py sous ~ / rl_gym_book / ch4 avec le contenu suivant:

import gym
import sys

def run_gym_env(argv):
    env = gym.make(argv[1]) # Name of the environment supplied as 1st argument
    env.reset()
    for _ in range(int(argv[2])): # Number of steps to be run supplied as 2nd argument
        env.render()
        env.step(env.action_space.sample())
    env.close()
    
if __name__ == "__main__":
    run_gym_env(sys.argv)

Le script utilisera le nom d'environnement fourni comme premier paramètre de ligne de commande et le nombre d'étapes à exécuter. Par exemple, nous pouvons exécuter le script comme ceci:

:~/rl_gym_book/ch4$python run_gym_env.py Alien-ram-v0 2000

Cette commande démarrera l'environnement Alien-ram-v0 et y effectuera 2000 opérations pas à pas en utilisant des opérations aléatoires échantillonnées à partir de l'espace d'exploitation de l'environnement.
Vous verrez une fenêtre pop-up avec l'environnement Alien-ram-v0, comme ceci:

Comprendre l'interface Gym

Continuons notre exploration du Gym en comprenant l'interface entre l'environnement du Gym et les facteurs que nous allons développer. Pour nous aider, jetons un coup d'œil à l'image que nous avons vue dans le chapitre 2 «Apprentissage par renforcement et apprentissage par renforcement profond». À ce moment-là, nous discutions des bases de l'apprentissage par renforcement:

cette image vous donne-t-elle une idée de l'agent et l'environnement? Inter-interface? Nous nous assurerons de votre compréhension en parcourant la description de l'interface.
Après l'importation de gym , nous utilisons le code suivant pour créer un environnement:

env = gym.make("ENVIRONMENT_NAME")

Ici, ENVIRONMENT_NAME est le nom de l'environnement souhaité, sélectionné dans la liste des environnements installés sur le système. De la figure précédente, nous pouvons voir que la première flèche vient de l'environnement vers l'agent, et elle est nommée Observation. Dans le chapitre 2, Apprentissage par renforcement et apprentissage par renforcement profond, nous comprenons la différence entre un environnement partiellement observable et un environnement entièrement observable, ainsi que la différence entre l'état et l'observation dans chaque cas. Nous obtenons la première observation de l'environnement en appelant env.reset (). Utilisons le code suivant pour stocker le résultat de l'observation dans une variable nommée obs:

obs = env.reset()

Maintenant, l'agent a reçu l'observation (la fin de la première flèche). Il est maintenant temps pour l'agent de prendre une action et d'envoyer cette action à l'environnement pour voir ce qui s'est passé. C'est essentiellement le problème que l'algorithme que nous développons pour l'agent doit résoudre! Dans les chapitres suivants, nous développerons divers algorithmes de pointe pour développer l'agent. Continuons le voyage de compréhension de l'interface Gym.

Une fois l'action à entreprendre déterminée, nous l'envoyons à l'environnement en utilisant la méthode env.step () (la deuxième flèche de la figure), qui renverra 4 valeurs dans l'ordre suivant: next_state, récompense, done et info:

• next_state est l'état de résultat de l'environnement après avoir effectué une opération dans l'état précédent
• La récompense (la troisième flèche de la figure) est renvoyée par l'environnement.
• La variable done est une valeur booléenne (vrai ou faux), si le tracé est terminé / fini (il est donc temps de réinitialiser l'environnement), la valeur de cette variable est vraie, sinon elle est fausse. Cela aidera l'agent à savoir quand un événement se termine ou quand l'environnement sera réinitialisé à un état initial.
• La variable info renvoyée est une variable facultative et certains environnements peuvent renvoyer des informations supplémentaires. Normalement, l'agent ne l'utilisera pas pour décider de l'action à entreprendre.

Assemblons toutes les parties et voyons en un seul endroit:

import gym env = gym.make("ENVIRONMENT_NAME") 
obs = env.reset() # The first arrow in the picture 
# Inner loop (roll out) 
action = agent.choose_action(obs) # The second arrow in the picture 
next_state, reward, done, info = env.step(action) # The third arrow (and more) 
obs = next_state 
# Repeat Inner loop (roll out)

J'espère que vous avez une bonne compréhension du cycle d'interaction entre l'environnement et l'agent. Ce processus continuera à se répéter jusqu'à ce que nous décidions de terminer la boucle après un certain nombre de séries ou d'étapes. Regardons maintenant un exemple complet. Dans un environnement Qbert-v0, la boucle interne exécute MAX_STEPS_PER_EPISODE et la boucle externe exécute MAX_NUM_EPISODES:

import gym
env = gym.make("Qbert-v0")
MAX_NUM_EPISODES = 10
MAX_STEPS_PER_EPISODE = 500
for episode in range(MAX_NUM_EPISODES):
    obs = env.reset()
    for step in range(MAX_STEPS_PER_EPISODE):
        env.render()
        action = env.action_space.sample()# Sample random action. This will be replaced by our agent's action when we start developing the agent algorithms
        next_state, reward, done, info = env.step(action) # Send the action to the environment and receive the next_state, reward and whether done or not
        obs = next_state

        if done is True:
            print("\n Episode #{} ended in {} steps.".format(episode, step+1))
            break

Lorsque vous exécutez ce script, vous remarquerez qu'un écran Qbert apparaît. Qbert effectue des actions aléatoires et gagne des points, comme indiqué ci-dessous:

Vous verrez également les instructions d'impression suivantes sur la console, selon le moment où l'événement se termine. Notez que le nombre d'étapes que vous obtenez peut être différent car les actions sont aléatoires:

Pour résumer

Dans ce chapitre, nous avons exploré la liste des environnements Gym disponibles sur le système installé dans le chapitre précédent, puis compris la convention de dénomination ou la nomenclature de ces environnements. Ensuite, nous avons revisité le diagramme d'interaction agent-environnement (cycle RL) et compris comment l'environnement Gym fournit une interface correspondant à chaque flèche que nous voyons dans le diagramme. Ensuite, nous avons visualisé le résumé récapitulatif des quatre valeurs renvoyées par la méthode step () de l'environnement Gym sous forme de tableau facile à comprendre pour renforcer votre compréhension de leur signification! Nous avons également discuté en détail des différents champs utilisés pour les espaces d'observation et d'action du gymnase Types d'espaces et utilisation de scripts pour imprimer l'espace utilisé par l'environnement afin de mieux comprendre l'interface de l'environnement du stade. Dans notre prochain chapitre, nous allons consolider tout l'apprentissage jusqu'à présent et développer notre premier agent d'intelligence artificielle! Excité?! Passons maintenant au chapitre suivant.