a Obtenu une solution simple de travail:

$ xvfb-run -s "-screen 0 1400x900x24" jupyter notebook

import matplotlib.pyplot as plt
%matplotlib inline
from IPython import display

def show_state(env, step=0, info=""):
    plt.figure(3)
    plt.clf()
    plt.imshow(env.render(mode='rgb_array'))
    plt.title("%s | Step: %d %s" % (env._spec.id,step, info))
    plt.axis('off')

    display.clear_output(wait=True)
    display.display(plt.gcf())

Note: si votre environnement n'est pas unwrapped , passez env.env à show_state .

j'ai rencontré ça moi-même. L'utilisation de xvfb comme serveur X se heurte d'une manière ou d'une autre aux pilotes Nvidia. Mais finalement ce poteau m'a pointé dans la bonne direction. Xvfb fonctionne sans aucun problème si vous installez le pilote Nvidia avec l'option -no-opengl-files et CUDA avec l'option --no-opengl-libs . Si vous savez cela, il doit travailler. Mais comme il m'a fallu un certain temps jusqu'à ce que je m'en rende compte et il semble que je ne suis pas le seul à rencontrer des problèmes avec xvfb et le nvidia pilote.

j'ai noté toutes les étapes nécessaires pour tout mettre en place sur une instance AWS EC2 avec Ubuntu 16.04 LTS ici.

ce GitHub numéro a donné une réponse qui a fonctionné très bien pour moi. C'est bien parce qu'il ne nécessite pas de dépendances supplémentaires (je suppose que vous avez déjà matplotlib ) ou de configuration du serveur.

il suffit d'exécuter, par exemple:

import gym
import matplotlib.pyplot as plt
%matplotlib inline

env = gym.make('Breakout-v0') # insert your favorite environment
render = lambda : plt.imshow(env.render(mode='rgb_array'))
env.reset()
render()

en utilisant mode='rgb_array' vous donne en retour un numpy.ndarray avec les valeurs RGB pour chaque position, et matplotlib 's imshow (ou d'autres méthodes) affiche ces bien.

notez que si vous faites plusieurs fois dans la même cellule, Cette solution tracera une image séparée à chaque fois. Ce n'est probablement pas ce que vous voulez. Je vais essayer de mettre à jour si je l'ai trouver une bonne solution pour cela.

mise à Jour pour rendre plusieurs fois dans une cellule

basé sur ce réponse StackOverflow, voici un extrait de travail (Notez qu'il peut y avoir plus des façons efficaces de le faire avec une intrigue interactive; cette façon semble un peu lente sur ma machine):

import gym
from IPython import display
import matplotlib.pyplot as plt
%matplotlib inline

env = gym.make('Breakout-v0')
env.reset()
for _ in range(100):
    plt.imshow(env.render(mode='rgb_array'))
    display.display(plt.gcf())
    display.clear_output(wait=True)
    action = env.action_space.sample()
    env.step(action)

mise à jour pour augmenter l'efficacité

sur ma machine, c'était environ 3x plus rapide. La différence est qu'au lieu d'appeler imshow chaque fois que nous rendons, nous changeons simplement les données RGB sur le tracé original.

import gym
from IPython import display
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

env = gym.make('Breakout-v0')
env.reset()
img = plt.imshow(env.render(mode='rgb_array')) # only call this once
for _ in range(100):
    img.set_data(env.render(mode='rgb_array')) # just update the data
    display.display(plt.gcf())
    display.clear_output(wait=True)
    action = env.action_space.sample()
    env.step(action)

j'ai réussi à exécuter et à rendre openai/gym (même avec mujoco) à distance sur un serveur sans tête.

# Install and configure X window with virtual screen
sudo apt-get install xserver-xorg libglu1-mesa-dev freeglut3-dev mesa-common-dev libxmu-dev libxi-dev
# Configure the nvidia-x
sudo nvidia-xconfig -a --use-display-device=None --virtual=1280x1024
# Run the virtual screen in the background (:0)
sudo /usr/bin/X :0 &
# We only need to setup the virtual screen once

# Run the program with vitural screen
DISPLAY=:0 <program>

# If you dont want to type `DISPLAY=:0` everytime
export DISPLAY=:0

Utilisation:

DISPLAY=:0 ipython2

exemple:

import gym
env = gym.make('Ant-v1')
arr = env.render(mode='rgb_array')
print(arr.shape)
# plot or save wherever you want
# plt.imshow(arr) or scipy.misc.imsave('sample.png', arr)

il y a aussi cette solution en utilisant pyvirtualdisplay (une enveloppe Xvfb). Une chose que j'aime dans cette solution est que vous pouvez le lancer à partir de l'intérieur de votre script, au lieu d'avoir à l'envelopper au lancement:

from pyvirtualdisplay import Display
display = Display(visible=0, size=(1400, 900))
display.start()

j'ai eu le même problème et I_like_foxes solution pour réinstaller les pilotes nvidia sans correction d'opengl. Voici les commandes que J'ai utilisées pour Ubuntu 16.04 et GTX 1080ti https://gist.github.com/8enmann/931ec2a9dc45fde871d2139a7d1f2d78

j'ai évité les problèmes avec l'utilisation de matplotlib en utilisant simplement PIL, Python Image Library:

import gym, PIL
env = gym.make('SpaceInvaders-v0')
array = env.reset()
PIL.Image.fromarray(env.render(mode='rgb_array'))

j'ai trouvé que je n'avais pas besoin de régler le tampon du XV frame.

je pense que nous devrions simplement capturer rend la vidéo en utilisant OpenAI salle de sport wrappers.Monitor et puis l'afficher à l'intérieur de l'ordinateur Portable.

exemple:

dépendances

!apt install python-opengl
!apt install ffmpeg
!apt install xvfb
!pip3 install pyvirtualdisplay

# Virtual display
from pyvirtualdisplay import Display

virtual_display = Display(visible=0, size=(1400, 900))
virtual_display.start()

Capture en vidéo

import gym
from gym import wrappers

env = gym.make("SpaceInvaders-v0")
env = wrappers.Monitor(env, "/tmp/SpaceInvaders-v0")

for episode in range(2):
    observation = env.reset()
    step = 0
    total_reward = 0

    while True:
        step += 1
        env.render()
        action = env.action_space.sample()
        observation, reward, done, info = env.step(action)
        total_reward += reward
        if done:
            print("Episode: {0},\tSteps: {1},\tscore: {2}"
                  .format(episode, step, total_reward)
            )
            break
env.close()

Afficher dans le bloc de 151990920"

import os
import io
import base64
from IPython.display import display, HTML

def ipython_show_video(path):
    """Show a video at `path` within IPython Notebook
    """
    if not os.path.isfile(path):
        raise NameError("Cannot access: {}".format(path))

    video = io.open(path, 'r+b').read()
    encoded = base64.b64encode(video)

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

ipython_show_video("/tmp/SpaceInvaders-v0/openaigym.video.4.10822.video000000.mp4")

j'espère que ça aidera. ;)

dans mon environnement IPython, la solution D'Andrew Schreiber ne peut pas tracer l'image en douceur. Voici ma solution:

si sur un serveur linux, ouvrez jupyter avec

$ xvfb-run -s "-screen 0 1400x900x24" jupyter notebook

Dans Jupyter

import matplotlib.pyplot as plt
%matplotlib inline
%matplotlib notebook
from IPython import display

affichage itération:

done = False
obs = env.reset()

fig = plt.figure()
ax = fig.add_subplot(111)
plt.ion()

fig.show()
fig.canvas.draw()

while not done:
    # action = pi.act(True, obs)[0] # pi means a policy which produces an action, if you have
    # obs, reward, done, info = env.step(action) # do action, if you have
    env_rnd = env.render(mode='rgb_array')
    ax.clear()
    ax.imshow(env_rnd)
    fig.canvas.draw()
    time.sleep(0.01)

je cherchais une solution qui fonctionne en laboratoire et a fini avec ce

from IPython import display
import numpy as np
import time

import gym
env = gym.make('SpaceInvaders-v0')
env.reset()

import PIL.Image
import io


def showarray(a, fmt='png'):
    a = np.uint8(a)
    f = io.BytesIO()
    ima = PIL.Image.fromarray(a).save(f, fmt)
    return f.getvalue()

imagehandle = display.display(display.Image(data=showarray(env.render(mode='rgb_array')), width=450), display_id='gymscr')

while True:
    time.sleep(0.01)
    env.step(env.action_space.sample()) # take a random action
    display.update_display(display.Image(data=showarray(env.render(mode='rgb_array')), width=450), display_id='gymscr')

Afficher dans le Colaboratory