Получил простое решение:

$ 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())

Примечание: если ваша среда не unwrapped, передайте env.env в show_state.

Эта проблема GitHub дала ответ, который мне очень понравился. Это приятно, потому что не требует дополнительных зависимостей (я полагаю, у вас уже есть matplotlib) или конфигурации сервера.

Просто запустите, например:

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()

Использование mode='rgb_array' возвращает numpy.ndarray со значениями RGB для каждой позиции, и imshow imshow (или другие методы) matplotlib прекрасно их отображают.

Обратите внимание, что если вы отрисовываете несколько раз в одной и той же ячейке, это решение будет каждый раз строить отдельное изображение. Вероятно, это не то, что вам нужно. Я постараюсь обновить это, если найду способ обходного пути.

Обновите, чтобы отображать несколько раз в одной ячейке

На основе этот ответ StackOverflow, вот рабочий фрагмент (обратите внимание, что могут быть более эффективные способы сделать это с помощью интерактивного сюжета; этот способ кажется немного запаздывающим на моей машине):

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)

Обновление для повышения эффективности

На моей машине это было примерно в 3 раза быстрее. Разница в том, что вместо вызова imshow каждый раз при рендеринге мы просто изменяем данные RGB на исходном графике.

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)

Мне удалось запустить и визуализировать openai / gym (даже с mujoco) удаленно на безголовом сервере.

# 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

Использование:

DISPLAY=:0 ipython2

Пример:

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)

Я думаю, нам следует просто записывать рендеры в виде видео с помощью OpenAI Gym wrappers.Monitor, а затем отображать их в Блокноте.

Пример:

Зависимости

!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()

Захватить как видео

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()

Отображение в блокноте

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")

Я надеюсь, что это помогает. ;)

Также существует это решение, использующее pyvirtualdisplay (оболочку Xvfb). Что мне нравится в этом решении, так это то, что вы можете запускать его изнутри вашего скрипта, вместо того, чтобы оборачивать его при запуске:

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

Я сам с этим столкнулся. Использование xvfb в качестве X-сервера как-то конфликтует с драйверами Nvidia. Но, наконец, этот пост указал мне правильное направление. Xvfb работает без проблем, если вы устанавливаете драйвер Nvidia с параметром -no-opengl-files и CUDA с параметром --no-opengl-libs. Если вы это знаете, это должно сработать. Но так как мне потребовалось некоторое время, чтобы понять это, похоже, что я не единственный, кто сталкивается с проблемами с xvfb и драйверами nvidia.

Я записал все необходимые шаги для настройки всего на экземпляре AWS EC2 с Ubuntu 16.04 LTS здесь.

Я избежал проблем с использованием matplotlib, просто используя PIL, Python Image Library:

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

Я обнаружил, что мне не нужно устанавливать буфер кадра XV.

Я искал решение, которое работает в Colaboratory, и в итоге получил

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')

ИЗМЕНИТЬ 1:

Вы можете использовать xvfbwrapper для среды Cartpole.

from IPython import display
from xvfbwrapper import Xvfb
import numpy as np
import time
import pyglet
import gym
import PIL.Image
import io    

vdisplay = Xvfb(width=1280, height=740)
vdisplay.start()

env = gym.make('CartPole-v0')
env.reset()

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')


for _ in range(1000):
  time.sleep(0.01)
  observation, reward, done, info = 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')


vdisplay.stop()

Если вы работаете со стандартным Jupyter, есть лучшее решение. Вы можете использовать CommManager для отправки сообщений с обновленными URL-адресами данных в ваш HTML-вывод.

Пример встроенного экрана IPython

В Colab CommManager недоступен. В более ограниченном модуле вывода есть метод eval_js (), который кажется медленным.

Ссылаясь на мой другой ответ здесь: Отображать тренажерный зал OpenAI только в ноутбуке Jupyter < / а>

Я сделал здесь быстрый рабочий пример, который вы можете разветвить: https://kyso.io/eoin/openai-gym-jupyter с двумя примерами рендеринга в Jupyter: один как mp4, а другой как gif в реальном времени.

Пример .mp4 довольно прост.

import gym
from gym import wrappers

env = gym.make('SpaceInvaders-v0')
env = wrappers.Monitor(env, "./gym-results", force=True)
env.reset()
for _ in range(1000):
    action = env.action_space.sample()
    observation, reward, done, info = env.step(action)
    if done: break
env.close()

Затем в новую ячейку Jupyter cell, либо загрузите ее с сервера в какое-нибудь место, где вы сможете просмотреть видео.

import io
import base64
from IPython.display import HTML

video = io.open('./gym-results/openaigym.video.%s.video000000.mp4' % env.file_infix, 'r+b').read()
encoded = base64.b64encode(video)
HTML(data='''
    <video width="360" height="auto" alt="test" controls><source src="data:video/mp4;base64,{0}" type="video/mp4" /></video>'''
.format(encoded.decode('ascii')))

Если вы используете сервер с общедоступным доступом, вы можете запустить python -m http.server в папке с результатами в спортзале и просто смотреть видео там.

Я столкнулся с той же проблемой и нашел здесь ответы. Их смешивание помогло мне решить проблему.

Вот пошаговое решение:

Установите следующее:

apt-get install -y python-opengl xvfb

Запустите записную книжку jupyter с помощью следующей команды:

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

Внутри записной книжки:

import gym
import matplotlib.pyplot as plt
%matplotlib inline

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

Теперь вы можете поместить одно и то же в цикл, чтобы отображать его несколько раз.

from IPython import display

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)

Надеюсь, это сработает для всех, кто все еще сталкивается с проблемой. Благодаря Эндрюсу и Натану за их ответы.

У меня была такая же проблема и решение I_like_foxes для переустановки драйверов nvidia без каких-либо исправлений opengl. Вот команды, которые я использовал для Ubuntu 16.04 и GTX 1080ti https://gist.github.com/8enmann/931ec2a9dc45fde871d2139a7d1f2d78

Возможно, это полный обходной путь, но я использовал образ докера с окружением рабочего стола, и он отлично работает. Образ докера находится по адресу https://hub.docker.com/r/dorowu/ubuntu-desktop-lxde-vnc/

Команда для запуска:

docker run -p 6080:80 dorowu/ubuntu-desktop-lxde-vnc

Затем просмотрите http://127.0.0.1:6080/, чтобы получить доступ к рабочему столу Ubuntu.

Ниже приведена гифка, показывающая, как работает и визуализируется тренажерный зал братьев Марио. Как видите, он довольно отзывчивый и плавный.

Я создал этот мини-пакет, который позволяет отображать вашу среду в браузере, просто добавив одну строку в ваш код.

Поместите свой код в функцию и замените обычный env.render() на yield env.render(mode='rgb_array'). Инкапсулируйте эту функцию с помощью декоратора render_browser.

import gym
from render_browser import render_browser

@render_browser
def test_policy(policy):
    # Your function/code here.
    env = gym.make('Breakout-v0')
    obs = env.reset()

    while True:
        yield env.render(mode='rgb_array')
        # ... run policy ...
        obs, rew, _, _ = env.step(action)

test_policy(policy)    

Когда вы посещаете your_ip:5000 в своем браузере, будет вызван test_policy(), и вы сможете увидеть визуализированную среду в окне браузера.

В моей среде IPython решение Эндрю Шрайбера не может отображать изображение плавно. Вот мое решение:

Если на сервере Linux, откройте jupyter с помощью

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

В Jupyter

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

Итерация отображения:

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)