[Renforcer l'apprentissage] Comment dessiner OpenAI Gym sur Google Corab (version 2020.6)

0. Introduction

J'ai vérifié comment dessiner OpenAI Gym sur Google Colab, alors prenez note.

Sites référencés

1. Défis

J'obtiens une erreur NoSuchDisplayException lorsque j'essaye d'afficher l'environnement avec la méthode render () de gym.Env.

import gym
env = gym.make('CartPole-v1')
env.reset()
env.render()
NoSuchDisplayException                    Traceback (most recent call last)
<ipython-input-3-74ea9519f385> in <module>()
      2 env = gym.make('CartPole-v1')
      3 env.reset()
----> 4 env.render()

2. Contre-mesures

D'après mes recherches, j'ai trouvé qu'il y avait trois façons d'utiliser la fonction de dessin de Gym sur Colab. Chaque méthode a des avantages et des inconvénients, et je ne pourrais pas me limiter à une seule, je décrirai donc les trois types.

2.1 Préparation commune

Les trois méthodes utilisent l'affichage virtuel X11 Xvfb. installer.

!apt update
!apt install xvfb

(Lors du démarrage indépendant de Jupyter Notebook avec Image Docker etc., OpenGL est également requis, donc ʻapt install python-opengl`. )

De plus, pour utiliser Xvfb de Google Colab (Jupyter Notebook), utilisez PyVirtualDisplay.

!pip install pyvirtualdisplay

from pyvirtualdisplay import Display

d = Display()
d.start()

Il y avait une description que {numéro d'affichage}. {Numéro d'écran} a été défini dans la variable d'environnement " DISPLAY ", mais [l'auteur de PyVirtualDisplay m'a dit que ce n'était pas nécessaire](https: // github.com/ponty/PyVirtualDisplay/issues/54).

Selon lui, le numéro d'écran est une valeur utilisée dans la situation où il y a plusieurs affichages, et comme PyVirtualDisplay ne génère qu'un seul écran, il est fixé à «0», et si le numéro d'écran n'est pas écrit, il est automatiquement interprété comme «0». À cause de ça. (Voir Stack Overflow)

En d'autres termes, puisque la variable d'environnement est définie dans pyvirtualdisplay.Display.start (), il n'est pas nécessaire de la changer de l'extérieur. (Au moins confirmé dans 1.3.2, la dernière version au 18 juin 2020)

2.2 Méthode 1

La première consiste simplement à dessiner les données de l'écran avec matplotlib et à répéter l'effacement.

L'inconvénient est qu'il n'est pas très rapide et n'est affiché qu'une seule fois, mais c'est une méthode qui peut gérer même si les données de dessin deviennent longues car elle continue d'écraser sans conserver les données de dessin.

import gym
from IPython import display
from pyvirtualdisplay import Display
import matplotlib.pyplot as plt

d = Display()
d.start()

env = gym.make('CartPole-v1')

o = env.reset()

img = plt.imshow(env.render('rgb_array'))
for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN

    display.clear_output(wait=True)
    img.set_data(env.render('rgb_array'))
    plt.axis('off')
    display.display(plt.gcf())

    if d:
        env.reset()

2.3 Méthode 2

La seconde consiste à utiliser matplotlib.animation.FuncAnimation pour afficher l'animation.

L'écran de dessin peut être affiché à plusieurs reprises et la vitesse d'affichage de chaque image peut être réglée librement, mais comme il est nécessaire de conserver les données de dessin, une grande quantité de mémoire est nécessaire et la taille de l'écran à afficher et le nombre d'affichages doivent être ajustés. Peut provoquer une erreur de mémoire. (Si vous obtenez une erreur lors d'une longue étude ...)

import gym
from IPython import display
from pyvirtualdisplay import Display
import matplotlib.pyplot as plt
from matplotlib import animation


d = Display()
d.start()

env = gym.make('CartPole-v1')

o = env.reset()

img = []
for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN

    display.clear_output(wait=True)
    img.append(env.render('rgb_array'))

    if d:
        env.reset()

dpi = 72
interval = 50 # ms

plt.figure(figsize=(img[0].shape[1]/dpi,img[0].shape[0]/dpi),dpi=dpi)
patch = plt.imshow(img[0])
plt.axis=('off')
animate = lambda i: patch.set_data(img[i])
ani = animation.FuncAnimation(plt.gcf(),animate,frames=len(img),interval=interval)
display.display(display.HTML(ani.to_jshtml()))

2.4 Méthode 3

La dernière méthode consiste à enregistrer les données du dessin sous forme de film en utilisant gym.wrappers.Monitor. La méthode render () n'est pas requise et est automatiquement enregistrée lorsque la méthode step (action) est appelée.

import base64
import io
import gym
from gym.wrappers import Monitor
from IPython import display
from pyvirtualdisplay import Display

d = Display()
d.start()

env = Monitor(gym.make('CartPole-v1'),'./')

o = env.reset()

for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN

    if d:
        env.reset()

for f in env.videos:
    video = io.open(f[0], 'r+b').read()
    encoded = base64.b64encode(video)

    display.display(display.HTML(data="""
        <video alt="test" controls>
        <source src="data:video/mp4;base64,{0}" type="video/mp4" />
        </video>
        """.format(encoded.decode('ascii'))))

3. Bibliothèque: Gym-Notebook-Wrapper

Comme il est difficile d'écrire la méthode ci-dessus à chaque fois, je l'ai transformée en bibliothèque.

3.1 Installation

Puisqu'il est publié sur PyPI, il peut être installé avec pip install gym-notebook-wrapper.

!apt update && apt install xvfb
!pip install gym-notebook-wrapper

Bien sûr, il peut être utilisé autrement que Google Colab, mais Linux est une condition préalable à l'utilisation de Xvfb.

3.2 Comment utiliser

Le wrapper gym-notebook-a un long trait d'union (-), donc le nom du module qui peut être importé est gnwrapper.

3.2.1 gnwrapper.Animation (= 2.2 Méthode 1)

import gnwrapper
import gym

env = gnwrapper.Animation(gym.make('CartPole-v1')) #Xvfb est démarré

o = env.reset()

for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN
    env.render() #Ici, le dessin précédent est effacé et une nouvelle étape est dessinée.
    if d:
        env.reset()

3.2.2 gnwrapper.LoopAnimation (= 2.3 Méthode 2)

import gnwrapper
import gym

env = gnwrapper.LoopAnimation(gym.make('CartPole-v1')) #Xvfb est démarré

o = env.reset()

for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN
    env.render() #Maintenant, enregistrez les données de dessin
    if d:
        env.reset()

env.display() #Ici, les données de dessin enregistrées sont affichées sous forme d'animation.

3.2.3 gnwrapper.Monitor (= 2.4 Méthode 3)

import gnwrapper
import gym

env = gnwrapper.Monitor(gym.make('CartPole-v1'),directory="./") #Xvfb est démarré

o = env.reset()

for _ in range(100):
    o, r, d, i = env.step(env.action_space.sample()) #En fait, mettez l'action de DNN
    if d:
        env.reset()

env.display() #Ici, les données de dessin enregistrées sous forme de vidéo sont affichées.

4. Enfin

J'ai organisé diverses informations sur le net et résumé trois façons de dessiner OpenAI Gym sur Google Colab. Cela devrait être le code que j'ai effectivement exécuté et confirmé plusieurs fois, mais je suis désolé si j'ai fait une copie de pemis.

Gym-Notebook-Wrapper est encore difficile et peut avoir des bugs, alors n'hésitez pas à configurer issue si vous avez des questions. Je suis content si vous comprenez.

Recommended Posts

[Renforcer l'apprentissage] Comment dessiner OpenAI Gym sur Google Corab (version 2020.6)
Comment utiliser l'Assistant Google sur Windows 10
[Version 2020] Comment installer Python3 sur EC2 d'AWS
Renforcer l'apprentissage 3 Installation d'OpenAI
Comment utiliser Django avec Google App Engine / Python
Essayez de faire une stratégie de blackjack en renforçant l'apprentissage (③ Renforcer l'apprentissage dans votre propre environnement OpenAI Gym))
Comment dessiner facilement la structure d'un réseau de neurones sur Google Colaboratory à l'aide de "convnet-tiroir"
Apprentissage par renforcement dans les plus brefs délais avec Keras avec OpenAI Gym
[Google Colab] Comment interrompre l'apprentissage, puis le reprendre
Renforcer l'apprentissage 28 collaboratif + OpenAI + chainerRL
Comment installer Tabpy 1.0 (version 2020-01)
Comment s'inscrire auprès de pypi
Comment changer la version de Python
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Comment utiliser Google Colaboratory
Comment mettre à jour la version Python de Cloud Shell dans GCP
Comment installer mysql-connector-python sur Mac
Comment utiliser Dataiku sous Windows
Remarques sur l'utilisation de pywinauto
Comment installer Graph-Tool sur macOS
Comment installer VMware-Tools sur Linux
Comment installer pycrypto sur Windows
Comment déployer django-compresseur sous Windows
Comment obtenir la version Python
Remarques sur l'utilisation des featuretools
Comment exécuter matplotlib sur heroku
Comment installer PyPy sur CentOS
Comment utiliser l'homebrew dans Debian
[Mémo] Comment utiliser Google MµG
Malentendu sur la façon de connecter CNN
Comment installer TensorFlow sur CentOS 7
Comment vérifier la version du système d'exploitation Linux
Comment installer Maven sur CentOS
Remarques sur la rédaction de requirements.txt
Comment installer Music 21 sur Windows
Comment collecter des données d'apprentissage automatique
Comment étudier pour le test G de Deep Learning Association (pour les débutants) [version 2020]
Comment installer le framework Deep Learning Caffe sur un Mac en mode CPU
Comment dessiner une ligne verticale sur une carte de chaleur dessinée avec Python Seaborn