def __init__(self, env_name, env_args, termination_time, thread_index): environment.Environment.__init__(self) try: self.last_state = None self.last_action = 0 self.last_reward = 0 self.prev_state = None self.prev_action = 0 self.prev_reward = 0 simargs = sim_config.get(env_name) simargs['id'] = 'sim%02d' % thread_index simargs['logdir'] = os.path.join(IndoorEnvironment.get_log_dir(), simargs['id']) # Merge in extra env args if env_args is not None: simargs.update(env_args) simargs["measure_fun"].termination_time = termination_time self.termination_time = termination_time # try: self._sim = RoomSimulator(simargs) self._sim_obs_space = self._sim.get_observation_space( simargs['outputs']) self.reset() except Exception as e: print("Error in indoor_env init():", str(e)) #, flush=True) raise Exception
def configure(self, sim_args): self._sim = RoomSimulator(sim_args) self._sim_obs_space = self._sim.get_observation_space(sim_args['outputs']) #self.action_space = spaces.Discrete(self._sim.num_buttons) self.action_space = spaces.MultiBinary(self._sim.num_buttons) self.screen_height = self._sim_obs_space['color'].shape[1] self.screen_width = self._sim_obs_space['color'].shape[0] self.observation_space = spaces.Box(low=0, high=255, shape=(self.screen_height, self.screen_width, 3))
def __init__(self, env_name, env_args, thread_index): environment.Environment.__init__(self) self.last_state = None self.last_action = 0 self.last_reward = 0 simargs = sim_config.get(env_name) simargs['id'] = 'sim%02d' % thread_index simargs['logdir'] = os.path.join(IndoorEnvironment.get_log_dir(), simargs['id']) # Merge in extra env args if env_args is not None: simargs.update(env_args) self._sim = RoomSimulator(simargs) self._sim_obs_space = self._sim.get_observation_space(simargs['outputs']) self.reset()
def __init__(self, all_args): self.num_simulators = len(all_args) self.simulators = [] self.simulator_type = all_args[0]['simulator'] for args in all_args: if self.simulator_type == 'room_simulator': self.simulators.append(RoomSimulator(args)) else: self.simulators.append(DoomSimulator(args)) self.modalities = all_args[0]['modalities'] # TODO: outputs=modalities+rewards+terminals, needs to match observations (refactor to ensure consistency) self.outputs = all_args[0]['outputs'] self.resolution = self.simulators[0].resolution self.num_channels = self.simulators[0].num_channels self.num_meas = self.simulators[0].num_meas self.action_len = self.simulators[0].num_buttons self.config = all_args[0]['config'] self.maps = all_args[0]['maps'] self.continuous_controls = self.simulators[0].continuous_controls self.discrete_controls = self.simulators[0].discrete_controls
def main(): parser = argparse.ArgumentParser(description='MINOS gym wrapper') args = parse_sim_args(parser) sim = RoomSimulator(args) common.attach_exit_handler(sim.sim) try: print('Starting RoomSimulator...') sim.init() print('RoomSimulator started.') interactive_loop(sim, args) except: traceback.print_exc() print('Error running simulator. Aborting.') if sim is not None: sim.close_game() del sim
def main(): parser = argparse.ArgumentParser(description='MINOS gym wrapper') add_sim_args_basic(parser) parser.add_argument('--env_config', default='objectgoal_suncg_sf', help='Environment configuration file') args = parser.parse_args() sim_args = sim_config.get(args.env_config, vars(args)) sim = RoomSimulator(sim_args) common.attach_exit_handler(sim.sim) try: print('Starting RoomSimulator...') sim.init() print('RoomSimulator started.') interactive_loop(sim, args) except: traceback.print_exc() print('Error running simulator. Aborting.') if sim is not None: sim.close_game() del sim
class IndoorEnvironment(environment.Environment): ACTION_LIST = [ [1,0,0], [0,1,0], [0,0,1] ] @staticmethod def get_action_size(env_name): return len(IndoorEnvironment.ACTION_LIST) @staticmethod def get_objective_size(env_name): simargs = sim_config.get(env_name) return simargs.get('objective_size', 0) def __init__(self, env_name, env_args, thread_index): environment.Environment.__init__(self) self.last_state = None self.last_action = 0 self.last_reward = 0 simargs = sim_config.get(env_name) simargs['id'] = 'sim%02d' % thread_index simargs['logdir'] = os.path.join(IndoorEnvironment.get_log_dir(), simargs['id']) # Merge in extra env args if env_args is not None: simargs.update(env_args) self._sim = RoomSimulator(simargs) self._sim_obs_space = self._sim.get_observation_space(simargs['outputs']) self.reset() def reset(self): result = self._sim.reset() self._episode_info = result.get('episode_info') self._last_full_state = result.get('observation') obs = self._last_full_state['observation']['sensors']['color']['data'] objective = self._last_full_state.get('measurements') state = { 'image': self._preprocess_frame(obs), 'objective': objective } self.last_state = state self.last_action = 0 self.last_reward = 0 def stop(self): if self._sim is not None: self._sim.close_game() def _preprocess_frame(self, image): if len(image.shape) == 2: # assume gray image = np.dstack([image, image, image]) else: # assume rgba image = image[:, :, :-1] image = image.astype(np.float32) image = image / 255.0 return image def process(self, action): real_action = IndoorEnvironment.ACTION_LIST[action] full_state = self._sim.step(real_action) self._last_full_state = full_state # Last observed state obs = full_state['observation']['sensors']['color']['data'] reward = full_state['rewards'] terminal = full_state['terminals'] objective = full_state.get('measurements') if not terminal: state = { 'image': self._preprocess_frame(obs), 'objective': objective } else: state = self.last_state pixel_change = self._calc_pixel_change(state['image'], self.last_state['image']) self.last_state = state self.last_action = action self.last_reward = reward return state, reward, terminal, pixel_change def is_all_scheduled_episodes_done(self): return self._sim.is_all_scheduled_episodes_done()
class IndoorEnv(gym.Env): metadata = {'render.modes': ['human', 'rgb_array']} def __init__(self): self._last_state = None self._sim = None self.viewer = None def configure(self, sim_args): self._sim = RoomSimulator(sim_args) #signal.signal(signal.SIGINT, self.signal_handler) self._sim_obs_space = self._sim.get_observation_space(sim_args['outputs']) #self.action_space = spaces.Discrete(self._sim.num_buttons) self.action_space = spaces.MultiBinary(self._sim.num_buttons) self.screen_height = self._sim_obs_space['color'].shape[1] self.screen_width = self._sim_obs_space['color'].shape[0] self.observation_space = spaces.Box(low=0, high=255, shape=(self.screen_height, self.screen_width, 3)) # TODO: have more complex observation space with additional modalities and measurements # obs_space = self._sim.get_observation_space #self.observation_space = spaces.Dict({"images": ..., "depth": ...}) @property def simulator(self): return self._sim.sim def _seed(self, seed=0xA3C): """Sets the seed for this env's random number generator(s). Note: Some environments use multiple pseudorandom number generators. We want to capture all such seeds used in order to ensure that there aren't accidental correlations between multiple generators. Returns: list<bigint>: Returns the list of seeds used in this env's random number generators. The first value in the list should be the "main" seed, or the value which a reproducer should pass to 'seed'. Often, the main seed equals the provided 'seed', but this won't be true if seed=None, for example. """ # TODO: generate another seed for use in simulator? # What happens to this seed? self.np_random, seed = seeding.np_random(seed) return [seed] def _reset(self): """Resets the state of the environment and returns an initial observation. Returns: observation (object): the initial observation of the space. """ res = self._sim.reset() return res.get('observation') def _step(self, action): """Run one timestep of the environment's dynamics. When end of episode is reached, you are responsible for calling `reset()` to reset this environment's state. Accepts an action and returns a tuple (observation, reward, done, info). Args: action (object): an action provided by the environment Returns: observation (object): agent's observation of the current environment reward (float) : amount of reward returned after previous action done (boolean): whether the episode has ended, in which case further step() calls will return undefined results info (dict): contains auxiliary diagnostic information (helpful for debugging, and sometimes learning) """ ## a = [0]*self._sim.num_buttons ## a[action] = 1 state = self._sim.step(action) self._last_state = state # Last observed state observation = {k:v for k,v in state.items() if k not in ['rewards','terminals']} info = state['info'] return observation, state['rewards'], state['terminals'], info def _render(self, mode='human', close=False): """Renders the environment. The set of supported modes varies per environment. (And some environments do not support rendering at all.) By convention, if mode is: - human: render to the current display or terminal and return nothing. Usually for human consumption. - rgb_array: Return an numpy.ndarray with shape (x, y, 3), representing RGB values for an x-by-y pixel image, suitable for turning into a video. - ansi: Return a string (str) or StringIO.StringIO containing a terminal-style text representation. The text can include newlines and ANSI escape sequences (e.g. for colors). Note: Make sure that your class's metadata 'render.modes' key includes the list of supported modes. It's recommended to call super() in implementations to use the functionality of this method. Args: mode (str): the mode to render with close (bool): close all open renderings """ if close: if self.viewer is not None: self.viewer.close() self.viewer = None # If we don't None out this reference pyglet becomes unhappy return if self._last_state is not None: img = self._last_state['observation']['sensors']['color']['data'] if len(img.shape) == 2: # assume gray img = np.dstack([img, img, img]) else: # assume rgba img = img[:, :, :-1] img = img.reshape((img.shape[1], img.shape[0], img.shape[2])) if mode == 'human': from gym.envs.classic_control import rendering if self.viewer is None: if self.viewer is None: self.viewer = rendering.SimpleImageViewer() self.viewer.imshow(img) elif mode == 'rgb_array': return img def _close(self): if self._sim is not None: self._sim.close_game()
class IndoorEnvironment(environment.Environment): ACTION_LIST = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] @staticmethod def get_action_size(env_name): return len(IndoorEnvironment.ACTION_LIST) @staticmethod def get_objective_size(env_name): simargs = sim_config.get(env_name) return simargs.get('objective_size', 0) def __init__(self, env_name, env_args, termination_time, thread_index): environment.Environment.__init__(self) try: self.last_state = None self.last_action = 0 self.last_reward = 0 self.prev_state = None self.prev_action = 0 self.prev_reward = 0 simargs = sim_config.get(env_name) simargs['id'] = 'sim%02d' % thread_index simargs['logdir'] = os.path.join(IndoorEnvironment.get_log_dir(), simargs['id']) # Merge in extra env args if env_args is not None: simargs.update(env_args) simargs["measure_fun"].termination_time = termination_time self.termination_time = termination_time # try: self._sim = RoomSimulator(simargs) self._sim_obs_space = self._sim.get_observation_space( simargs['outputs']) self.reset() except Exception as e: print("Error in indoor_env init():", str(e)) #, flush=True) raise Exception def reset(self): result = self._sim.reset() self._episode_info = result.get('episode_info') self._last_full_state = result.get('observation') img = self._last_full_state['observation']['sensors']['color']['data'] objective = self._last_full_state.get( 'measurements') # with measure function! state = {'image': self._preprocess_frame(img), 'objective': objective} object_type = self._last_full_state["observation"]["sensors"].get( "objectType", None) if object_type is not None: object_type = object_type["data"][:, :, 2] state.update( {'objectType': self._preprocess_frame(object_type, "segm")}) # print(object_type.shape) self.last_state = state self.last_action = 0 self.last_reward = 0 self.prev_state = None self.prev_action = 0 self.prev_reward = 0 def stop(self): if self._sim is not None: self._sim.close_game() def _preprocess_frame(self, image, mode="segm"): if len(image.shape) == 2: # assume object_type or depth image = image.reshape((image.shape[1], image.shape[0])) if "segm" in mode: image[image == 255] = 0 return image.astype(np.int32) #image = np.dstack([image, image, image]) else: # assume rgba image = image[:, :, :-1] image = image.reshape((image.shape[1], image.shape[0], image.shape[2])) #print(image.shape) #Reshape is essential, when non-square image from simulator! image = image.astype(np.float32) image = image / 255.0 return image def process(self, action, flag=1): real_action = IndoorEnvironment.ACTION_LIST[action] full_state = self._sim.step(real_action, flag=flag) #print("Step made") self._last_full_state = full_state # Last observed state obs = full_state['observation']['sensors']['color']['data'] reward = full_state[ 'rewards'] / self.termination_time # reward clipping terminal = full_state['terminals'] objective = full_state.get('measurements') object_type = self._last_full_state["observation"]["sensors"].get( "objectType", None) if not terminal: state = { 'image': self._preprocess_frame(obs), 'objective': objective } if object_type is not None: object_type = object_type["data"][:, :, 2] state.update({ 'objectType': self._preprocess_frame(object_type, "segm") }) else: state = self.last_state pixel_change = None if object_type is None: pixel_change = self._calc_pixel_change(state['image'], self.last_state['image']) self.prev_state = self.last_state self.prev_action = self.last_action self.prev_reward = self.last_reward self.last_state = state self.last_action = action self.last_reward = reward return state, reward, terminal, pixel_change def is_all_scheduled_episodes_done(self): return self._sim.is_all_scheduled_episodes_done()
class IndoorEnvironment(environment.Environment): ACTION_LIST = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] @staticmethod def get_action_size(env_name): return len(IndoorEnvironment.ACTION_LIST) @staticmethod def get_objective_size(env_name): simargs = sim_config.get(env_name) return simargs.get('objective_size', 0) def __init__(self, env_name, env_args, thread_index): environment.Environment.__init__(self) self.i_episode = 0 self.last_state = None self.last_action = 0 self.last_reward = 0 simargs = sim_config.get(env_name) simargs['id'] = 'sim%02d' % thread_index simargs['logdir'] = os.path.join(IndoorEnvironment.get_log_dir(), simargs['id']) self.viewer = rendering.SimpleImageViewer() # Merge in extra env args if env_args is not None: simargs.update(env_args) print(simargs) self._sim = RoomSimulator(simargs) self._sim_obs_space = self._sim.get_observation_space( simargs['outputs']) self.reset() def render(self, img): img = img[:, :, :-1] img = img.reshape((img.shape[1], img.shape[0], img.shape[2])) img = cv2.resize(img, (512, 512), cv2.INTER_CUBIC) self.viewer.imshow(img) time.sleep(.1) def reset(self): result = self._sim.reset() self._episode_info = result.get('episode_info') self._last_full_state = result.get('observation') obs = self._last_full_state['observation']['sensors']['color']['data'] # self.render(obs) objective = self._last_full_state.get('measurements') state = {'image': self._preprocess_frame(obs), 'objective': objective} self.last_state = state self.last_action = 0 self.last_reward = 0 # self.i_episode = self.i_episode + 1 # print("Saving episode {}".format(self.i_episode)) # self.directory = "./{}".format(self.i_episode) # os.mkdir(self.directory) # with open(os.path.join(self.directory, "episode_info.txt"), "w") as outfile: # json.dump(self._episode_info, outfile, indent=4, cls=NumpyEncoder) # self.i = 0 def stop(self): if self._sim is not None: self._sim.close_game() def _preprocess_frame(self, image): if len(image.shape) == 2: # assume gray image = np.dstack([image, image, image]) else: # assume rgba image = image[:, :, :-1] image = image.astype(np.float32) image = image / 255.0 return image def process(self, action): real_action = IndoorEnvironment.ACTION_LIST[action] full_state = self._sim.step(real_action) self._last_full_state = full_state # Last observed state obs = full_state['observation']['sensors']['color']['data'] # self.render(obs) # depth = full_state['observation']['sensors']['depth']['data'] # Image.fromarray(obs.astype('uint8')).save(os.path.join(self.directory, 'color{}.png'.format(self.i))) # Image.fromarray(depth, 'L').save(os.path.join(self.directory, 'depth{}.png'.format(self.i))) # self.i+=1 reward = full_state['rewards'] terminal = full_state['terminals'] success = full_state['success'] objective = full_state.get('measurements') if not terminal: state = { 'image': self._preprocess_frame(obs), 'objective': objective } else: state = self.last_state pixel_change = self._calc_pixel_change(state['image'], self.last_state['image']) self.last_state = state self.last_action = action self.last_reward = reward return state, reward, terminal, pixel_change, success def is_all_scheduled_episodes_done(self): return self._sim.is_all_scheduled_episodes_done()