I want to play with the OpenAI gyms in a notebook, with the gym being rendered inline.
Here's a basic example:
import matplotlib.pyplot as plt
import gym
from IPython import display
%matplotlib inline
env = gym.make('CartPole-v0')
env.reset()
for i in range(25):
plt.imshow(env.render(mode='rgb_array'))
display.display(plt.gcf())
display.clear_output(wait=True)
env.step(env.action_space.sample()) # take a random action
env.close()
This works, and I get see the gym in the notebook:
But! it also opens an interactive window that shows precisely the same thing. I don't want this window to be open:
I made a working example here that you can fork: https://kyso.io/eoin/openai-gym-jupyter with two examples of rendering in Jupyter - one as an mp4, and another as a realtime gif.
The .mp4 example is quite simple.
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()
Then in a new 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')))
I just found a pretty nice work-around for this. This will work for environments that support the rgb_array render mode. Then we can use matplotlib's imshow with a quick replacement to show the animation. The following should work inside one cell of a jupyter notebook.
import os
import gym
import matplotlib.pyplot as plt
os.environ["SDL_VIDEODRIVER"] = "dummy"
from IPython.display import clear_output
env = gym.make("LunarLander-v2")#, render_mode="human")
env.action_space.seed(42)
observation, info = env.reset(seed=42, return_info=True)
for _ in range(1000):
observation, reward, done, info = env.step(env.action_space.sample())
if done:
observation, info = env.reset(return_info=True)
clear_output(wait=True)
plt.imshow( env.render(mode='rgb_array') )
plt.show()
env.close()
This worked for me in Ubuntu 18.04 LTS, to render gym locally. But, I believe it will work even in remote Jupyter Notebook servers.
First, run the following installations in Terminal:
pip install gym
python -m pip install pyvirtualdisplay
pip3 install box2d
sudo apt-get install xvfb
That's just it. Use the following snippet to configure how your matplotlib should render :
import matplotlib.pyplot as plt
from pyvirtualdisplay import Display
display = Display(visible=0, size=(1400, 900))
display.start()
is_ipython = 'inline' in plt.get_backend()
if is_ipython:
from IPython import display
plt.ion()
# Load the gym environment
import gym
import matplotlib.pyplot as plt
%matplotlib inline
env = gym.make('LunarLander-v2')
env.seed(23)
# Let's watch how an untrained agent moves around
state = env.reset()
img = plt.imshow(env.render(mode='rgb_array'))
for j in range(200):
# action = agent.act(state)
action = random.choice(range(4))
img.set_data(env.render(mode='rgb_array'))
plt.axis('off')
display.display(plt.gcf())
display.clear_output(wait=True)
state, reward, done, _ = env.step(action)
if done:
break
env.close()
Related
Below is the sample code for simulation of atari games:
import numpy as np
import matplotlib.pyplot as plt
import gym
import time
env =gym.make('BreakoutNoFrameskip-v4')
print("Observation Space :",env.observation_space)
print("Action Space :",env.action_space)
env.reset()
for i in range(1000):
action =env.action_space.sample()
obs,reward,done,info =env.step(action)
env.render()
time.sleep(0.01)
if done :
env.reset()
env.close()
plt.show()
The question:
Is it possible to create a simple video from the render? So my question is whether it is possible to convert render to mp4 format?
This saves a video of every video_every'th episode to the folder "video" while maintaining rendering to screen functionality from your post.
import gym
import time
env = gym.make('BreakoutNoFrameskip-v4')
video_every = 1
env = gym.wrappers.Monitor(env, "./video", video_callable=lambda episode_id: (episode_id%video_every)==0, force=True)
print("Observation Space :",env.observation_space)
print("Action Space :",env.action_space)
env.reset()
for i in range(1000):
action =env.action_space.sample()
obs,reward,done,info =env.step(action)
env.render()
time.sleep(0.01)
if done :
env.reset()
env.close()
I`m making a 'Rolling Dice' project with Plotly. before that, I install Plotly using the command:
$ python -m pip install --user plotly
When I run 'from plotly.gragh_objs import Bar, layout', I got the error message:
'ModuleNotFoundError: No module named 'plotly.gragh_objs''
I try to upgrade pip, but it doesn`t work. anyone know where are the problems.
My code as follow:
from plotly.gragh_objs import Bar, Layout
from ploty import offline
from dice import Die
die = Die()
results = []
for roll_num in range(1000):
result = die.roll()
results.append(result)
frequencies = []
for value in range(1, die.num_sides+1):
frequency = results.count(value)
frequencies.append(frequency)
x_values = list(range(1, die.num_sides+1))
data = [Bar(x=x_values, y=frequencies)]
x_axis_config = {'title':'Result'}
y_axis_config = {'title':'Frequency of Result'}
my_layout = Layout(title='Results of rolling one D6 1000 times',
xaxis=x_axis_config, yaxis=y_axis_config)
offline.plot({'data':data, 'layout':my_layout}, filename='d6.html')
The import code should be as follows:
from plotly.graph_objects import Bar, Layout
from plotly import offline
I am following a python tutorial about the use of plotly.
Here are some commands I have to run to import functions and methods I will use
import plotly.plotly as py
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
However, when I run commands on my jupyter nootbook, it says the use of plotly is deprecated and it recommends me to use the module chart_studio instead (error points to line import plotly.plotly as py):
ImportError: The plotly.plotly module is deprecated, please install
the chart-studio package and use the chart_studio.plotly module
instead.
So I run
pip install chart_studio
and try to replace the line above with functions and methods coming from the chart_studio module.
Here is my code:
import chart_studio.plotly as py
import plotly.graph_objects as go
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
data = dict(type= 'cloropleth',
locations = ['AZ','CA','NY'],
locationmode = 'USA-states',
colorscale = 'Portland',
text = ['text 1','text 2','text 3'],
z = [1,2,3],
colorbar = {'Title':'Colorbar title goes here'})
mylayout = dict(geo={'scope':'usa'})
choromap = go.Figure(data = [data], layout=mylayout, skip_invalid=True)
iplot(choromap)
The problem is that, when running the final line iplot(choromap), I get this empty graph
While in the tutorial this other graph appears
What is wrong?
Please note that I installed cufflinks-0.17.3 plotly-4.5.4
Did you try to cleanly install plotly?
Uninstall plotly using pip
!pip uninstall plotly
Then uninstall plotly using conda
!conda uninstall plotly
After that, install the last version using pip
!pip install plotly
check Plotly version
import plotly
plotly.__version__
SOLVED
In my code there were 2 errors:
at line
type= 'cloropleth',
I had the mispelled value 'cloropleth', where the correct value is 'choropleth',
and then at line
colorbar = {'Title':'Colorbar title goes here'})
I had 'Title', where the correct key is 'title' (lowercase).
Fixed them and now the map is correctly displayed.
Also, it was not necessary to install chart_studio.
So in the end the correct code is:
import plotly.graph_objects as go
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
data = dict(type= 'choropleth',
locations = ['AZ','CA','NY'],
locationmode = 'USA-states',
colorscale = 'Portland',
text = ['text 1','text 2','text 3'],
z = [1,2,3],
colorbar = {'title':'Colorbar title goes here'})
mylayout = dict(geo={'scope':'usa'})
choromap = go.Figure(data = [data], layout=mylayout)
iplot(choromap)
I have trained a CNN using fastai on Kaggle and also on my local machine. After calling learn.fit_one_cycle(1) on Kaggle I get the following table as output:
I executed the exact same code on my local machine (with Spyder ide and Python 3.7) and everything works, but I cannot see that output table. How can I display it?
This is the complete code:
from fastai import *
from fastai.vision import *
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
bs = 32
path = 'C:\\DB\\UCMerced_LandUse\\UCMerced_LandUse\\Unfoldered_Images'
pat = r"([^/\d]+)[^/]*$"
fnames = get_image_files(path)
data = ImageDataBunch.from_name_re(path, fnames, pat, ds_tfms=get_transforms(),
size = 224, bs = bs, num_workers = 0).normalize(imagenet_stats)
learn = cnn_learner(data, models.resnet34, metrics=[accuracy])
learn.fit_one_cycle(1)
The problem was that the console in Spyder was set to 'execute in current console' which doesn't seem to be able to displaye the result table. Setting it to 'execute in an external system terminal' solved the problem.
I am currently trying to generate a heatmap in python from a text file, using R commands (with rpy2). It works fine in R, but when I take it to python, the Quartz interface displays quickly and then closes. I would like either to be able to save the quartz display to a file, or directly save my heatmap to a file without displaying it.
Here is the code I have been using:
import rpy2.robjects as robjects
robjects.r('''
library("gplots")
data = read.csv("/Users/.../Heatmap_data.txt")
DF = data.frame(data)
MD = data.matrix(DF,rownames.force=NA)
heatmap.2(MD, scale="none", col=redgreen(100), cexRow=0.1, key=FALSE, symkey=FALSE, trace="none", Colv=FALSE)
''')
I'm using python 2.7, on OS X Yosemite.
Thank you for any help.
import numpy as np
import rpy2.robjects as ro
import rpy2.robjects.numpy2ri
ro.numpy2ri.activate()
R = ro.r
data = np.random.random((10, 10))
R.png(file='/tmp/out.png')
R.heatmap(data)
R("dev.off()")
writes to the file /tmp/out.png without displaying the image:
.
Preventing the displayed image from immediately closing can be done like this:
script.py:
import numpy as np
import rpy2.robjects as ro
import rpy2.robjects.numpy2ri
import rpy2.rinterface as rinterface
import time
import threading
ro.numpy2ri.activate()
R = ro.r
def ion():
def r_refresh(interval = 0.03):
while True:
rinterface.process_revents()
time.sleep(interval)
t = threading.Thread(target=r_refresh)
t.daemon = True
t.start()
ion()
data = np.random.random((10, 10))
R.heatmap(data)
R("dev.copy(png,'/tmp/out2.png')")
R("dev.off()")
try:
# for Python2
raw_input()
except NameError:
# for Python3
input()
The raw_input or input call prevents the Python interpreter from exiting, thus allowing the window to stay open, until the user presses Enter.
The ion function calls rinterface.process_revents() periodically so the
displayed window will react to GUI events such as resizing or being closed.
dev.copy(png,'/tmp/out2.png') saves the already-displayed image to a
file.