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, 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 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)
class SimpleRenderAgent(RL.Agent): def __init__(self, plotfig_getter=None, image_getter=None, render_fn=None) -> None: self.render_fn = render_fn self.image_getter = image_getter self.plotfig_getter = plotfig_getter self.viewer = None 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 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:])
class Runner: 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): columns = [] for i in range(80): rows = [] for j in range(80): if self.observation[i][j] == 1: rows.append([255, 255, 255]) else: rows.append([0, 0, 0]) columns.append(rows) self.viewer.imshow(np.asarray(columns, dtype=np.uint8)) def run(self): observations = [] rewards = [] actions = [] terminals = [] values = [] for _ in range(self.num_steps): action_index, value = self.model.predict([self.observation]) observations.append(self.observation) action = action_with_index(action_index) values.append(value) self.observation, reward, terminal = self.env.step(action) self.stats_recorder.after_step(reward=reward, terminal=terminal) rewards.append(reward) actions.append(action_index) terminals.append(terminal) if terminal: self.observation = self.env.reset() if terminals[-1] == 0: next_value = self.model.predict_value([self.observation])[0] discounted_rewards = discount(rewards + [next_value], terminals + [False], self.discount_rate)[:-1] else: discounted_rewards = discount(rewards, terminals, self.discount_rate) self.model.train(observations, discounted_rewards, actions, values)
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)
class PyBullet(EnvExt): def __init__( self, name: str = 'Hopper', add_timestep: bool = False, nosuffix: bool = False ) -> None: self.name = name try: import pybullet_envs # noqa except ImportError: raise ImportError('pybullet is not installed') if not nosuffix: name += 'BulletEnv-v0' env = gym.make(name) if add_timestep: env = AddTimeStep(env) super().__init__(RewardMonitor(env)) self.viewer = None self.spec.use_reward_monitor = True 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'): 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, 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') -> 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 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 __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()
class BaseEnv(gym.Env, ABC): metadata = { 'render.modes': ['human', 'rgb_array'], 'video.frames_per_second': 3 } reward_range = (-float('inf'), float('inf')) def __init__(self): self.viewer = None self.seed() @abstractmethod def step(self, action): pass def seed(self, seed=None): self.np_random, seed = seeding.np_random(seed) return [seed] @abstractmethod def reset(self): pass @abstractmethod def get_image(self): pass def render(self, mode='rgb_array', max_width=20): 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': # img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 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 close(self): if self.viewer is not None: self.viewer.close() self.viewer = None
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 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 __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 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 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: 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)
class SpecialWrapper(gym.Wrapper): metadata = {'render.modes': ['human', 'rgb_array', 'encoding']} def __init__(self, env, terminal_condition=None): super(SpecialWrapper, self).__init__(env) self.terminal_condition = terminal_condition def reset(self): return self.env.reset() def step(self, action): observation, reward, terminal, info = self.env.step(action) if not terminal and not self.terminal_condition is None: terminal = self.terminal_condition.isterminal( reward, terminal, info) return observation, reward, terminal, info 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 __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', 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