def render(self, player=-1):
if player == -1:
return self.env.render()
else:
if not self.viewer:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = [SimpleImageViewer(), SimpleImageViewer()]
return self.viewer[player].imshow(self.crop(self.env.img, player))
def render(self, mode: str = 'human'):
"""
Render the current screen using the given mode.
Args:
mode: the mode to render the screen using
- 'human': render in a window using GTK
- 'rgb_array': render in the back-end and return a matrix
Returns:
None if mode is 'human' or a matrix if mode is 'rgb_array'
"""
# if the mode is RGB, return the screen as a NumPy array
if mode == 'rgb_array':
return self.game.screen
# if the mode is human, create a viewer and display the screen
elif mode == 'human':
from pyglet.window import Window
from gym.envs.classic_control.rendering import SimpleImageViewer
if self.viewer is None:
self.viewer = SimpleImageViewer()
self.viewer.window = Window(
width=SCREEN_WIDTH,
height=SCREEN_HEIGHT,
caption=self.spec.id,
)
self.viewer.imshow(self.game.screen)
return self.viewer.isopen
# otherwise the render mode is not supported, raise an error
else:
raise ValueError('unsupported render mode: {}'.format(repr(mode)))
def render(self, mode='human'):
"""Render the board to an image viewer or an np.array.
Args:
mode: One of the following modes:
- 'human': render to an image viewer.
- 'rgb_array': render to an RGB np.array (np.uint8)
Returns:
3D np.array (np.uint8) or a `viewer.isopen`.
"""
img = self._empty_board
if self._last_observations:
img = self._last_observations.board
layers = self._last_observations.layers
if self._colors:
img = self._paint_board(layers)
else:
assert img is not None, '`board` must not be `None`.'
img = _repeat_axes(img, self.resize_scale, axis=[0, 1])
if len(img.shape) != 3:
img = np.repeat(img[..., None], 3, axis=-1)
img = img.astype(np.uint8)
if mode == 'rgb_array':
return img
elif mode == 'human':
if self.viewer is None:
from gym.envs.classic_control.rendering import (
SimpleImageViewer)
self.viewer = SimpleImageViewer()
self.viewer.imshow(img)
time.sleep(self.delay / 1e3)
return self.viewer.isopen
def main():
with tf.Session() as sess:
print('Creating environment...')
env = TFBatchedEnv(sess, Pong(), 1)
env = BatchedFrameStack(env)
print('Creating model...')
model = CNN(sess,
gym_space_distribution(env.action_space),
gym_space_vectorizer(env.observation_space))
print('Creating roller...')
roller = TruncatedRoller(env, model, 1)
print('Initializing variables...')
sess.run(tf.global_variables_initializer())
if os.path.exists('params.pkl'):
print('Loading parameters...')
with open('params.pkl', 'rb') as in_file:
params = pickle.load(in_file)
for var, val in zip(tf.trainable_variables(), params):
sess.run(tf.assign(var, val))
else:
print('Warning: parameter file does not exist!')
print('Running agent...')
viewer = SimpleImageViewer()
while True:
for obs in roller.rollouts()[0].step_observations:
viewer.imshow(obs[..., -3:])
def venn(self):
if not hasattr(self, 'viewer'):
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
fig, ax = plt.subplots()
canvas = FigureCanvas(fig)
A_and_not_B = len(
set(self.archives['Alice'].keys()).difference(
set(self.archives['Bob'].keys())))
B_and_not_A = len(
set(self.archives['Bob'].keys()).difference(
set(self.archives['Alice'].keys())))
A_and_B = len(
set(self.archives['Alice'].keys()).intersection(
set(self.archives['Bob'].keys())))
v = venn2(subsets=(A_and_not_B, B_and_not_A, A_and_B),
set_labels=self.people)
c = venn2_circles(subsets=(A_and_not_B, B_and_not_A, A_and_B),
linestyle='dotted',
lw=1.0)
ax.set_title('Agents')
fig.canvas.draw()
venn = np.array(canvas.renderer._renderer)[:, :, :3]
obs = cv2.resize(self.finalobs, (480, 480),
interpolation=cv2.INTER_AREA)
venn = np.concatenate((venn, obs), axis=1)
self.viewer.imshow(venn)
def render(self, mode='rgb_array', close=False):
"""Render the board to an image viewer or an np.array.
Args:
mode: One of the following modes:
- 'human': render to an image viewer.
- 'rgb_array': render to an RGB np.array (np.uint8)
Returns:
3D np.array (np.uint8) or a `viewer.isopen`.
"""
img = self._empty_uncropped_board
if self._last_uncropped_observations:
img = self._last_uncropped_observations.board
layers = self._last_uncropped_observations.layers
if self._colors:
img = self._paint_board(layers, cropped=False)
else:
assert img is not None, '`board` must not be `None`.'
img = self.resize(img)
if mode == 'rgb_array':
return img
elif mode == 'human':
if self.viewer is None:
from gym.envs.classic_control.rendering import (
SimpleImageViewer)
self.viewer = SimpleImageViewer()
self.viewer.imshow(img)
time.sleep(self.delay / 1e3)
return self.viewer.isopen
def render(self):
if self.simple_image_viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.simple_image_viewer = SimpleImageViewer()
im_obs = self.get_img_obs()
self.simple_image_viewer.imshow(im_obs)
time.sleep(0.075)
def render(self, mode='human'):
if self.viewer is None:
self.viewer = SimpleImageViewer()
rimg_i = self.road_img(self.cars[0].py - 0.5, SWD, SHD)[0]
img = np.transpose(
np.stack([((1.0 - rimg_i) * 255).astype(np.uint8)] * 3, axis=2),
(1, 0, 2))[::-1, :, :]
self.viewer.imshow(img)
def render(self, mode: str = 'human') -> Optional[ndarray]:
if mode == 'human':
arr = self._env.render('rgb_array')
if self.viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
self.viewer.imshow(arr) # type: ignore
return None
else:
return self._env.render(mode)
def render(self, mode='human', close=False):
if mode == 'human':
# the following is copied from gym's AtariEnv
if self.viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
self.viewer.imshow(self.toybox.get_rgb_frame())
return self.viewer.isopen
elif mode == 'rgb_array':
return self.toybox.get_rgb_frame()
def main():
global restart, action
parser = argparse.ArgumentParser()
parser.add_argument("--bot", type=int, default=0,
help="Number of bot cars_full in environment.")
parser.add_argument("--track", type=int, default=0,
help="Track for agents cars_full in environment.")
parser.add_argument("--discrete", type=int, default=1, help="Apply discrete wrapper?")
parser.add_argument("--sleep", type=float, default=None, help="time in s between actions")
parser.add_argument("--debug", action='store_true', default=False, help="debug mode")
parser.add_argument(
"--env-settings",
type=str,
default='envs/gym_car_intersect_fixed/settings_sets/env_settings__basic_small_rotation.json',
help="debug mode"
)
args = parser.parse_args()
env = CarRacingHackatonContinuousFixed(args.env_settings)
env = DiscreteWrapper(env)
env.reset()
time.sleep(3.0)
viewer = SimpleImageViewer()
viewer.imshow(env.get_true_picture())
viewer.window.on_key_press = key_press
viewer.window.on_key_release = key_release
# while True:
env.reset()
total_reward = 0.0
steps = 0
restart = False
while True:
s = None
done = None
info = {}
for _ in range(1):
s, r, done, info = env.step(action)
total_reward += r
print("\naction " + str(action))
print("step {} total_reward {:+0.2f}".format(steps, total_reward))
print(info)
steps += 1
viewer.imshow(env.get_true_picture())
if done or restart or 'need_restart' in info.keys():
print('restart')
break
def __init__(self, env, model, num_steps, discount_rate, summary_frequency,
performance_num_episodes, summary_log_dir):
self.env = env
self.model = model
self.discount_rate = discount_rate
self.observation = env.reset()
self.num_steps = num_steps
self.stats_recorder = StatsRecorder(
summary_frequency=summary_frequency,
performance_num_episodes=performance_num_episodes,
summary_log_dir=summary_log_dir,
save=True)
self.viewer = SimpleImageViewer()
def render(self, mode='human', close=False):
if close:
if self.viewer:
self.viewer.close()
return
if mode == "rgb_array":
return self.em.get_screen() if self.img is None else self.img
elif mode == "human":
if self.viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
self.viewer.imshow(self.img)
return self.viewer.isopen
def post_act(self):
try:
if self.render_fn is not None:
self.render_fn()
elif self.image_getter is not None:
if self.viewer is None:
self.viewer = SimpleImageViewer()
img = self.image_getter()
self.viewer.imshow(img)
elif self.plotfig_getter is not None:
if self.viewer is None:
self.viewer = SimpleImageViewer()
fig = self.plotfig_getter() # type: Figure
data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8)
img = data.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
self.viewer.imshow(img)
else:
self.env.render()
except Exception:
logging.getLogger(__name__).exception(
f'{self.name}: Unable to render. Disabling agent!')
self.disable()
def __init__(self,
file_name="map1.txt",
fail_rate=0.0,
terminal_reward=1.0,
move_reward=0.0,
bump_reward=-0.5,
bomb_reward=-1.0):
self.viewer = SimpleImageViewer()
self.n = None
self.m = None
self.bombs = []
self.walls = []
self.goals = []
self.start = None
this_file_path = os.path.dirname(os.path.realpath(__file__))
file_name = os.path.join(this_file_path, file_name)
with open(file_name, "r") as f:
for i, row in enumerate(f):
row = row.rstrip('\r\n')
if self.n is not None and len(row) != self.n:
raise ValueError(
"Map's rows are not of the same dimension...")
self.n = len(row)
for j, col in enumerate(row):
if col == "x" and self.start is None:
self.start = self.n * i + j
elif col == "x" and self.start is not None:
raise ValueError(
"There is more than one starting position in the map..."
)
elif col == "G":
self.goals.append(self.n * i + j)
elif col == "B":
self.bombs.append(self.n * i + j)
elif col == "1":
self.walls.append(self.n * i + j)
self.m = i + 1
if len(self.goals) == 0:
raise ValueError("At least one goal needs to be specified...")
self.n_states = self.n * self.m
self.n_actions = 4
self.fail_rate = fail_rate
self.state = self.start
self.terminal_reward = terminal_reward
self.move_reward = move_reward
self.bump_reward = bump_reward
self.bomb_reward = bomb_reward
self.action_space = spaces.Discrete(4)
self.observation_space = spaces.Discrete(self.n_states)
self.done = False
def __init__(self,
file_name="mmap1.txt",
catch_level=2,
terminal_reward=10.0,
ontarget_reward=1.0,
move_reward=0.0,
bump_reward=-0.2):
self.viewer = SimpleImageViewer()
self.n = None
self.m = None
self.catch_level = catch_level
self.walls = []
self.init_evaders = []
self.init_pursuers = []
this_file_path = os.path.dirname(os.path.realpath(__file__))
file_name = os.path.join(this_file_path, file_name)
with open(file_name, "r") as f:
for i, row in enumerate(f):
row = row.rstrip('\r\n')
if self.n is not None and len(row) != self.n:
raise ValueError(
"Map's rows are not of the same dimension...")
self.n = len(row)
for j, col in enumerate(row):
if col == "P":
self.init_pursuers.append(self.n * i + j)
elif col == "E":
self.init_evaders.append(self.n * i + j)
elif col == "1":
self.walls.append(self.n * i + j)
self.m = i + 1
if self.m < 3 or self.n < 3:
raise ValueError("Map too small...")
if len(self.init_pursuers) < self.catch_level:
raise ValueError(
"At least a sufficient number of pursuers needs to be specified..."
)
if len(self.init_evaders) == 0:
raise ValueError("At least one evaders needs to be specified...")
self.evaders = copy.copy(self.init_evaders)
self.pursuers = copy.copy(self.init_pursuers)
self.n_states = self.n * self.m
self.n_actions = 5**len(self.init_pursuers)
self.terminal_reward = terminal_reward
self.ontarget_reward = ontarget_reward
self.move_reward = move_reward
self.bump_reward = bump_reward
self.action_space = spaces.Box(0, 4, (len(self.init_pursuers), ))
self.observation_space = spaces.Box(-1, 3, (3, 3))
self.done = False
def main():
args = arg_parser().parse_args()
conn = redis.StrictRedis(host=args.redis_host, port=args.redis_port)
pubsub = conn.pubsub()
pubsub.subscribe(args.channel + ':state:' + args.env_id)
viewer = SimpleImageViewer()
for msg in pubsub.listen():
if msg['type'] != 'message':
continue
img = np.frombuffer(msg['data'][:3 * (args.obs_size**2)],
dtype='uint8')
img = img.reshape([args.obs_size] * 2 + [3])
viewer.imshow(img)
def render(self, mode='human', max_width=500):
img = self.get_image()
img = np.asarray(img).astype(np.uint8)
img_height, img_width = img.shape[:2]
ratio = max_width / img_width
#img = Image.fromarray(img).resize([int(ratio * img_width), int(ratio * img_height)])
img = np.asarray(img)
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control.rendering import SimpleImageViewer
if self.viewer is None:
self.viewer = SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def _get_simple_image_viewer(self):
"""Maybe construct a SimpleImageViewer instance for episode rendering."""
# Try to render the env, if required.
if not self._render:
return None
try:
from gym.envs.classic_control.rendering import SimpleImageViewer
return SimpleImageViewer()
except (ImportError, ModuleNotFoundError):
self._render = False # disable rendering
logger.warning("Could not import gym.envs.classic_control."
"rendering! Try `pip install gym[all]`.")
return None
def render(self, mode: str = "rgb_array") -> np.ndarray:
observations = self._current_batch[0]
if isinstance(observations, Observations):
image_batch = observations.x
else:
assert isinstance(observations, Tensor)
image_batch = observations
if isinstance(image_batch, Tensor):
image_batch = image_batch.cpu().numpy()
if self.batch_size:
image_batch = tile_images(image_batch)
image_batch = Transforms.channels_last_if_needed(image_batch)
assert image_batch.shape[-1] in {3, 4}
if image_batch.dtype == np.float32:
assert (0 <= image_batch).all() and (image_batch <= 1).all()
image_batch = (256 * image_batch).astype(np.uint8)
assert image_batch.dtype == np.uint8
if mode == "rgb_array":
# NOTE: Need to create a single image, channels_last format, and
# possibly even of dtype uint8, in order for things like Monitor to
# work.
return image_batch
if mode == "human":
# return plt.imshow(image_batch)
if self.viewer is None:
display = None
# TODO: There seems to be a bit of a bug, tests sometime fail because
# "Can't connect to display: None" etc.
try:
from gym.envs.classic_control.rendering import SimpleImageViewer
except Exception:
from pyvirtualdisplay import Display
display = Display(visible=0, size=(1366, 768))
display.start()
from gym.envs.classic_control.rendering import SimpleImageViewer
finally:
self.viewer = SimpleImageViewer(display=display)
self.viewer.imshow(image_batch)
return self.viewer.isopen
raise NotImplementedError(f"Unsuported mode {mode}")
def render(self, mode='human', close=False): #*args, **kwargs):
env = self.conopt_env
if close:
if 'viewer' in env.__dict__:
env.viewer.close()
del env.viewer
else:
img = env.world.model.render(np.expand_dims(env.x, 0))[0]
if mode == 'human':
#import cv2
#img = cv2.resize(img, (50, 50))
if not 'viewer' in env.__dict__:
from gym.envs.classic_control.rendering import SimpleImageViewer
env.viewer = SimpleImageViewer()
env.viewer.imshow(img)
return img
else:
return img
def render(self, mode: str='human'):
"""
Render the current screen using the given mode.
Args:
mode: the mode to render the screen using
- 'human': render in a window using GTK
- 'rgb_array': render in the back-end and return a matrix
Returns:
None if mode is 'human' or a matrix if mode is 'rgb_array'
"""
if mode == 'human':
if self.viewer is None:
self.viewer = SimpleImageViewer()
self.viewer.imshow(self.screen)
elif mode == 'rgb_array':
return self.screen
def _render(self, mode='human', close=False):
img = Image.new('RGB', (RENDER_HEIGHT, RENDER_WIDTH), WHITE)
draw = ImageDraw.Draw(img)
for i in range(self.num_agents):
agent = self.state.agent_states[i]
self._render_object(draw, agent, RED)
self._render_object(draw, self.state.target_state, BLUE)
self._render_objective(draw, GREEN)
self._render_bounds(draw, BLACK)
del draw
if mode == 'human':
if (self.viewer is None):
# don't import SimpleImageViewer by default because even importing
# it requires a display
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
self.viewer.imshow(np.asarray(img))
elif mode == 'rgb_array':
return np.asarray(img)
def __init__(self, height=5, width=5, n_buttons=3, button_pos=None, pixels_per_tile=10, seed=None,
obs_dtype='bool'):
"""
:param height: height of the world (in tiles)
:param width: width of the world (in tiles)
:param n_buttons: number of buttons
:param button_pos: (optional) list of (2,) numpy arrays - positions of the buttons
:param pixels_per_tile: height/width of a tile for rendering
:param seed: if specified, sets this seed to numpy random
:param obs_dtype: 'bool' or 'int' observation format. 'bool' for agent + one-hot encoding of buttons,
'int' for one integer for each tile
"""
self.action_space = spaces.Discrete(5)
if obs_dtype == 'bool':
self.observation_space = spaces.Box(low=0, high=1, shape=(2 * n_buttons + 1, height, width), dtype=int)
else:
self.observation_space = spaces.Box(low=0, high=2 * (2 * n_buttons + 1), dtype=int)
self.height = height
self.width = width
self.n_buttons = n_buttons
self.button_pos = button_pos
if seed is not None:
np.random.seed(seed)
if self.button_pos is None:
self.button_pos = []
idx = np.random.choice(height * width, n_buttons, replace=False)
for index in idx:
self.button_pos.append(np.array([index // width, index % width], dtype=int))
self.button_idx = tuple(idx)
else:
self.button_idx = tuple(a * width + b for (a, b) in button_pos)
if obs_dtype not in ['bool', 'int']:
raise ValueError('obs_type should be "bool" or "int"')
self.obs_dtype = obs_dtype
self.next_button = None
self.pos = None
self.viewer = SimpleImageViewer()
self.pixels_per_tile = pixels_per_tile
def test():
with open(os.path.join("demo", "Pong.demo"), "rb") as f:
dat = pickle.load(f)
viewer = SimpleImageViewer()
env = gym.make('PongNoFrameskip-v4')
checkpoint = dat['checkpoints'][18]
checkpoint_action_nr = dat['checkpoint_action_nr'][18]
env.reset()
env.unwrapped.restore_state(checkpoint)
t = 0
while True:
print("t ", t)
action = dat['actions'][checkpoint_action_nr + t]
observation, reward, done, _ = env.step(action)
viewer.imshow(observation)
if reward != 0:
print("*** reset ***")
env.reset()
break
time.sleep(0.5)
t += 1
def render(self, mode="human"):
"""Render the board to an image viewer.
Args:
mode: One of the following modes:
- "human": render to an image viewer.
Returns:
3D np.array (np.uint8) or a `viewer.isopen`.
"""
img = self._get_obs().numpy()
img = np.abs(img)
img = _repeat_axes(img, factor=50, axis=[0, 1])
img *= 255
img = img.astype(np.uint8)
if mode == "human":
if self.viewer is None:
self.viewer = SimpleImageViewer()
self.viewer.imshow(img)
time.sleep(self.delay)
return self.viewer.isopen
def render(self, mode: str = 'human', env: Optional[int] = None) -> Any:
if self.viewer is None and mode == 'human':
# Lazy importing because this breaks EC2 instances that don't have a screen/viewing device
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer(maxwidth=1080)
img = self._get_env_images()
img = build_render_rgb(img=img,
num_envs=self.num_envs,
env_height=self.height,
env_width=self.width,
env=env,
num_rows=self.render_args['num_rows'],
num_cols=self.render_args['num_cols'],
render_size=self.render_args['size'])
if mode == 'human':
self.viewer.imshow(img)
return self.viewer.isopen
elif mode == 'rgb_array':
return img
else:
raise ValueError('Render mode not recognised.')
def watch_random(env, frame_rate=60.0):
"""
Watch random agent play an environment.
"""
init_state = env.reset(1)
states = tf.placeholder(init_state.dtype, shape=init_state.get_shape())
actions = tf.random_uniform(shape=[1],
minval=0,
maxval=env.num_actions,
dtype=tf.int32)
new_states, rews, dones = env.step(states, actions)
image = env.observe_visual(states)
viewer = SimpleImageViewer()
with tf.Session() as sess:
cur_states = sess.run(init_state)
while True:
cur_states, cur_rews, cur_dones = sess.run(
[new_states, rews, dones], feed_dict={states: cur_states})
cur_image = sess.run(image, feed_dict={states: cur_states})
viewer.imshow(cur_image[0])
if cur_dones[0]:
print('done with reward: %f' % cur_rews[0])
time.sleep(1.0 / frame_rate)
def render(self, mode='human', **kwargs):
if mode == 'encoding':
if not 'encoder' in kwargs:
raise TypeError('Expected an encoder model `encoder`')
if not 'observation' in kwargs:
raise TypeError('Expected previous observation `observation`')
encoder = kwargs['encoder']
observation = kwargs['observation']
encoding = encoder.predict(np.expand_dims(observation, axis=0))[0]
encoding = (encoding - encoding.min()) / (encoding.max() -
encoding.min())
image = np.repeat(np.expand_dims(encoding, axis=-1), 3, axis=-1)
image = np.uint8(image * 255)
image = cv2.resize(image, (210, 210), interpolation=cv2.INTER_AREA)
image = np.concatenate((observation, image), axis=1)
if self.viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer()
self.viewer.imshow(image)
else:
return self.env.render(mode, **kwargs)
def render(self, mode='human', close=False):
# Mimics functionality of parent render method, but adds lowres overlay
if close:
if self.viewer:
self.viewer.close()
return
# Get game and overlay screens
game_img = RetroEnv.get_screen(self)
game_img_shape = game_img.shape
lowres_overhead = self.get_screen()
lowres_shape = lowres_overhead.shape
# Extend the image
actual_game_image = np.concatenate((game_img,np.zeros((game_img_shape[0], lowres_shape[1], 3))), axis=1)
actual_game_image[0:lowres_shape[0],
game_img_shape[1]:game_img_shape[1] + lowres_shape[1],
:] = lowres_overhead
actual_game_image = actual_game_image.astype("uint8")
# Scale
scale_percent = 400
width = int(actual_game_image.shape[1] * scale_percent / 100)
height = int(actual_game_image.shape[0] * scale_percent / 100)
dim = (width, height)
# resize image
actual_game_image = cv2.resize(actual_game_image, dim, interpolation=cv2.INTER_AREA)
if mode == "rgb_array":
return actual_game_image
elif mode == "human":
if self.viewer is None:
from gym.envs.classic_control.rendering import SimpleImageViewer
self.viewer = SimpleImageViewer(maxwidth=width)
self.viewer.imshow(actual_game_image)
return self.viewer.isopen
