python - कैसे सर्वर पर OpenAI जिम.render() चलाएं




jupyter-notebook pyglet (8)

एक सरल समाधान काम कर रहा है:

यदि एक लिनक्स सर्वर पर, के साथ ज्यूपिटर खोलें
$ 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())

नोट: यदि आपका वातावरण env.env नहीं है, तो env.env में show_state पास करें।

मैं ज्यूपिटर (उबंटू 14.04) के माध्यम से एक p2.xlarge AWS सर्वर पर 2.7 स्क्रिप्ट चला रहा हूं। मैं अपने सिमुलेशन को प्रस्तुत करने में सक्षम होना चाहता हूं।

न्यूनतम काम करने का उदाहरण

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

env.render() बनाता है (अन्य बातों के अलावा) निम्नलिखित त्रुटियां:

...
HINT: make sure you have OpenGL install. On Ubuntu, you can run 
'apt-get install python-opengl'. If you're running on a server, 
you may need a virtual frame buffer; something like this should work: 
'xvfb-run -s \"-screen 0 1400x900x24\" python <your_script.py>'")
...
NoSuchDisplayException: Cannot connect to "None"

मैं चाहूंगा कि कुछ लोग सिमुलेशन को कैसे देख पाएंगे। यह आदर्श होगा यदि मैं इसे इनलाइन कर सकता हूं, लेकिन कोई भी प्रदर्शन विधि अच्छी होगी।

संपादित करें : यह केवल कुछ वातावरण के साथ एक मुद्दा है, जैसे क्लासिक नियंत्रण।

अपडेट I

इससे प्रेरित होकर मैंने xvfb-run -s \"-screen 0 1400x900x24\" python <your_script.py> बजाय निम्नलिखित प्रयास किया xvfb-run -s \"-screen 0 1400x900x24\" python <your_script.py> (जो मुझे काम नहीं मिल सका)।

xvfb-run -a jupyter notebook

मूल स्क्रिप्ट चलाने के बजाय अब मुझे मिलता है

GLXInfoException: pyglet requires an X server with GLX

अपडेट II

अंक #154 प्रासंगिक लगता है। मैंने पॉप-अप को अक्षम करने और सीधे RGB रंग बनाने की कोशिश की

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

img = env.render(mode='rgb_array', close=True)  
print(type(img)) # <--- <type 'NoneType'>

img = env.render(mode='rgb_array', close=False) # <--- ERROR
print(type(img)) 

मुझे ImportError: cannot import name gl_info मिलती है ImportError: cannot import name gl_info

अद्यतन III

@ Torxed से प्रेरणा लेकर मैंने एक वीडियो फ़ाइल बनाने की कोशिश की, और फिर इसे (पूरी तरह से संतोषजनक समाधान) प्रदान किया।

' रिकॉर्डिंग और अपलोडिंग परिणाम ' से कोड का उपयोग करना

import gym

env = gym.make('CartPole-v0')
env.monitor.start('/tmp/cartpole-experiment-1', force=True)
observation = env.reset()
for t in range(100):
#    env.render()
    print(observation)
    action = env.action_space.sample()
    observation, reward, done, info = env.step(action)
    if done:
        print("Episode finished after {} timesteps".format(t+1))
        break

env.monitor.close()

मैंने आपके सुझावों पर अमल करने की कोशिश की, लेकिन ImportError: cannot import name gl_info env.monitor.start(... चलाते समय ImportError: cannot import name gl_info

मेरी समझ से समस्या यह है कि OpenAI pyglet का उपयोग करता है, और pyglet 'स्क्रीन' की जरूरत है ताकि छवि के RGB रंगों की गणना की जा सके। इसलिए यह सोचना जरूरी है कि अजगर को धोखा देने के लिए यह सोचना चाहिए कि एक मॉनिटर जुड़ा हुआ है

अद्यतन IV

FYI करें भौंरा का उपयोग करके ऑनलाइन समाधान हैं जो काम करने लगते हैं। सर्वर पर नियंत्रण होने पर यह काम करना चाहिए, लेकिन जब से वीएम में AWS चलता है मुझे नहीं लगता कि आप इसका उपयोग कर सकते हैं।

अद्यतन V

बस अगर आपको यह समस्या है, और पता नहीं है कि मुझे क्या करना है (मेरी तरह) अधिकांश वातावरण की स्थिति इतनी सरल है कि आप अपना रेंडरिंग तंत्र बना सकते हैं। बहुत संतोषजनक नहीं, लेकिन .. आप जानते हैं।


मुझे लगता है कि हमें सिर्फ OpenAI जिम रैपर.मोनिटर का उपयोग करके वीडियो के रूप में रेंडर कैप्चर करना चाहिए और फिर इसे नोटबुक के भीतर प्रदर्शित करना चाहिए।

उदाहरण:

निर्भरता

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

मुझे उम्मीद है यह मदद करेगा। ;)


मेरे अन्य उत्तर को यहां देखें: केवल जूपाइटर नोटबुक में ओपनएआईआई जिम प्रदर्शित करें

मैंने यहां एक त्वरित काम करने का उदाहरण दिया, जिसे आप कांटा कर सकते हैं: https://kyso.io/eoin/openai-gym-jupyter साथ जुपिटर में रेंडरिंग के दो उदाहरण हैं - एक mp4 के रूप में, और दूसरा एक रियलटाइम बिफ के रूप में।

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

फिर एक नए सेल ज्यूपिटर सेल में, या सर्वर से इसे किसी ऐसे स्थान पर डाउनलोड करें जहां आप वीडियो देख सकते हैं।

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 चला सकते हैं और वहां वीडियो देखें।


मेरे पास एक ही समस्या थी और I_like_foxes nvidia ड्राइवरों को पुनर्स्थापित करने के लिए समाधान, जिसमें कोई भी ओपेंगल फिक्स्ड चीजें नहीं थीं। यहाँ मैं उबंटू 16.04 और GTX 1080ti https://gist.github.com/8enmann/931ec2a9dc45fde871d2139a7d1f2d78 लिए उपयोग किए जाने वाले आदेश हैं


मैं एक हेडलेस सर्वर पर दूरस्थ रूप से ओपनाई / जिम (यहां तक ​​कि मुजोको के साथ) चलाने और सौंपने में कामयाब रहा।

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

मैं खुद इस में भाग गया। Xvfb को एक्स-सर्वर के रूप में उपयोग करने से एनवीडिया ड्राइवरों के साथ किसी तरह की झड़प होती है। लेकिन आखिरकार this पोस्ट ने मुझे सही दिशा में आने का इशारा किया। Xvfb किसी भी समस्या के बिना काम करता है यदि आप -no -no-opengl-files विकल्प के साथ Nvidia ड्राइवर स्थापित करते हैं और CUDA --no-opengl-libs विकल्प के साथ। यदि आप यह जानते हैं, तो यह काम करना चाहिए। लेकिन जब तक मुझे यह पता चला, तब तक मुझे काफी समय लग गया और ऐसा लगता है कि मैं xvfb और एनवीडिया ड्राइवरों के साथ समस्याओं में चलने वाला अकेला नहीं हूं।

मैंने here. Ubuntu 16.04 LTS के साथ AWS EC2 उदाहरण पर सब कुछ सेट करने के लिए सभी आवश्यक कदम नीचे लिखे here.


यह पूरी तरह से वर्कअराउंड हो सकता है, लेकिन मैंने डेस्कटॉप वातावरण के साथ डॉकटर छवि का उपयोग किया, और यह बहुत अच्छा काम करता है। डॉक की छवि https://hub.docker.com/r/dorowu/ubuntu-desktop-lxde-vnc/

चलाने की आज्ञा है

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

फिर Ubuntu डेस्कटॉप तक पहुंचने के लिए http://127.0.0.1:6080/ ब्राउज़ करें।

नीचे एक gif दिखाया जा रहा है जो मारियो bros जिम वातावरण को चला रहा है और प्रदान किया जा रहा है। जैसा कि आप देख सकते हैं, यह काफी संवेदनशील और चिकनी है।


वहाँ भी इस समाधान pyvirtualdisplay (एक Xvfb आवरण) का उपयोग कर रहा है। इस समाधान के बारे में एक बात मुझे पसंद है कि आप इसे अपनी स्क्रिप्ट के अंदर से लॉन्च करने के बजाय इसे लॉन्च कर सकते हैं:

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




openai-gym