J'ai vérifié comment dessiner OpenAI Gym sur Google Colab, alors prenez note.
Sites référencés
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()
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.
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)
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()
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()))
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'))))
Comme il est difficile d'écrire la méthode ci-dessus à chaque fois, je l'ai transformée en bibliothèque.
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.
Le wrapper gym-notebook-a un long trait d'union (-), donc le nom du module qui peut être importé est gnwrapper.
gnwrapper.Animationgnwrapper.LoopAnimationgnwrapper.Monitorgnwrapper.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()
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.
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.
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