def make_orb_config(): baseline_config = get_config("configs/tasks/pointnav_rgbd.yaml") config = habitat.get_config("configs/tasks/pointnav_rgbd.yaml") config.defrost() baseline_config.defrost() config.TASK_CONFIG = baseline_config.TASK_CONFIG config.ORBSLAM2 = baseline_config.ORBSLAM2 config.ORBSLAM2.SLAM_VOCAB_PATH = "data/ORBvoc.txt" config.ORBSLAM2.SLAM_SETTINGS_PATH = "configs/orbslam2/mp3d3_small1k.yaml" config.ORBSLAM2.DIST_TO_STOP = 0.2 config.ORBSLAM2.MAP_CELL_SIZE = 0.10 config.SIMULATOR.AGENT_0.SENSORS = [ "RGB_SENSOR", "DEPTH_SENSOR", ] config.SIMULATOR.RGB_SENSOR.WIDTH = 256 config.SIMULATOR.RGB_SENSOR.HEIGHT = 256 config.SIMULATOR.DEPTH_SENSOR.WIDTH = 256 config.SIMULATOR.DEPTH_SENSOR.HEIGHT = 256 config.ORBSLAM2.CAMERA_HEIGHT = config.SIMULATOR.DEPTH_SENSOR.POSITION[1] config.ORBSLAM2.H_OBSTACLE_MIN = 0.3 * config.ORBSLAM2.CAMERA_HEIGHT config.ORBSLAM2.H_OBSTACLE_MAX = 1.0 * config.ORBSLAM2.CAMERA_HEIGHT config.ORBSLAM2.MIN_PTS_IN_OBSTACLE = config.SIMULATOR.DEPTH_SENSOR.WIDTH / 2.0 config.freeze() baseline_config.freeze() return config
def main(): HabitatSimActions.extend_action_space("STRAFE_LEFT") HabitatSimActions.extend_action_space("STRAFE_RIGHT") config = habitat.get_config(config_paths="configs/tasks/pointnav.yaml") config.defrost() config.TASK.POSSIBLE_ACTIONS = config.TASK.POSSIBLE_ACTIONS + [ "STRAFE_LEFT", "STRAFE_RIGHT", ] config.TASK.ACTIONS.STRAFE_LEFT = habitat.config.Config() config.TASK.ACTIONS.STRAFE_LEFT.TYPE = "StrafeLeft" config.TASK.ACTIONS.STRAFE_RIGHT = habitat.config.Config() config.TASK.ACTIONS.STRAFE_RIGHT.TYPE = "StrafeRight" config.SIMULATOR.ACTION_SPACE_CONFIG = "NoNoiseStrafe" config.freeze() with habitat.Env(config=config) as env: env.reset() env.step("STRAFE_LEFT") env.step("STRAFE_RIGHT") config.defrost() config.SIMULATOR.ACTION_SPACE_CONFIG = "NoiseStrafe" config.freeze() with habitat.Env(config=config) as env: env.reset() env.step("STRAFE_LEFT") env.step("STRAFE_RIGHT")
def _generate_fn(scene): cfg = habitat.get_config() cfg.defrost() cfg.SIMULATOR.SCENE = scene cfg.SIMULATOR.AGENT_0.SENSORS = [] cfg.freeze() sim = habitat.sims.make_sim("Sim-v0", config=cfg.SIMULATOR) dset = habitat.datasets.make_dataset("PointNav-v1") dset.episodes = list( generate_pointnav_episode( sim, NUM_EPISODES_PER_SCENE, is_gen_shortest_path=False ) ) for ep in dset.episodes: ep.scene_id = ep.scene_id[len("./data/scene_datasets/") :] scene_key = scene.split("/")[-1].split(".")[0] out_file = ( f"./data/datasets/pointnav/gibson/v2/train_large/content/" f"{scene_key}.json.gz" ) os.makedirs(osp.dirname(out_file), exist_ok=True) with gzip.open(out_file, "wt") as f: f.write(dset.to_json())
def shortest_path_example(mode): config = habitat.get_config(config_paths="configs/tasks/pointnav.yaml") config.TASK.MEASUREMENTS.append("TOP_DOWN_MAP") config.TASK.SENSORS.append("HEADING_SENSOR") env = SimpleRLEnv(config=config) goal_radius = env.episodes[0].goals[0].radius if goal_radius is None: goal_radius = config.SIMULATOR.FORWARD_STEP_SIZE follower = ShortestPathFollower(env.habitat_env.sim, goal_radius, False) follower.mode = mode print("Environment creation successful") for episode in range(3): env.reset() dirname = os.path.join( IMAGE_DIR, "shortest_path_example", mode, "%02d" % episode ) if os.path.exists(dirname): shutil.rmtree(dirname) os.makedirs(dirname) print("Agent stepping around inside environment.") images = [] while not env.habitat_env.episode_over: best_action = follower.get_next_action( env.habitat_env.current_episode.goals[0].position ) observations, reward, done, info = env.step(best_action.value) im = observations["rgb"] top_down_map = draw_top_down_map( info, observations["heading"], im.shape[0] ) output_im = np.concatenate((im, top_down_map), axis=1) images.append(output_im) images_to_video(images, dirname, "trajectory") print("Episode finished")
def generate_sampled_train(config_path="datasets/pointnav/gibson.yaml", num_episodes=1000): config = habitat.get_config(config_path, config_dir="habitat-api/configs") config.defrost() config.DATASET.SPLIT = "train" config.freeze() print("Dataset is loading.") dataset = habitat.make_dataset(id_dataset=config.DATASET.TYPE, config=config.DATASET) print(config.DATASET.SPLIT + ": Len episodes: ", len(dataset.episodes)) dataset.episodes = random.sample(dataset.episodes, num_episodes) print("Average geo distance: ", get_avg_geo_dist(dataset)) json_str = str(dataset.to_json()) output_dir = "data/datasets/pointnav/gibson/v1/{}_small_2/".format( config.DATASET.SPLIT) if not os.path.exists(output_dir): os.mkdir(output_dir) main_dataset_file = "{}/{}_small_2.json.gz".format(output_dir, config.DATASET.SPLIT) with gzip.GzipFile(main_dataset_file, 'wb') as f: f.write(json_str.encode("utf-8")) print("Dataset file: {}".format(main_dataset_file))
def test_ppo_agents(): agent_config = ppo_agents.get_default_config() agent_config.MODEL_PATH = "" agent_config.defrost() config_env = habitat.get_config(config_paths=CFG_TEST) if not os.path.exists(config_env.SIMULATOR.SCENE): pytest.skip("Please download Habitat test data to data folder.") benchmark = habitat.Benchmark(config_paths=CFG_TEST) for input_type in ["blind", "rgb", "depth", "rgbd"]: for resolution in [256, 384]: config_env.defrost() config_env.SIMULATOR.AGENT_0.SENSORS = [] if input_type in ["rgb", "rgbd"]: config_env.SIMULATOR.AGENT_0.SENSORS += ["RGB_SENSOR"] agent_config.RESOLUTION = resolution config_env.SIMULATOR.RGB_SENSOR.WIDTH = resolution config_env.SIMULATOR.RGB_SENSOR.HEIGHT = resolution if input_type in ["depth", "rgbd"]: config_env.SIMULATOR.AGENT_0.SENSORS += ["DEPTH_SENSOR"] agent_config.RESOLUTION = resolution config_env.SIMULATOR.DEPTH_SENSOR.WIDTH = resolution config_env.SIMULATOR.DEPTH_SENSOR.HEIGHT = resolution config_env.freeze() del benchmark._env benchmark._env = habitat.Env(config=config_env) agent_config.INPUT_TYPE = input_type agent = ppo_agents.PPOAgent(agent_config) habitat.logger.info(benchmark.evaluate(agent, num_episodes=10))
def example_get_topdown_map(): config = habitat.get_config(config_file="tasks/pointnav.yaml") dataset = habitat.make_dataset( id_dataset=config.DATASET.TYPE, config=config.DATASET ) env = habitat.Env(config=config, dataset=dataset) env.reset() top_down_map = maps.get_topdown_map(env.sim, map_resolution=(5000, 5000)) recolor_map = np.array( [[255, 255, 255], [128, 128, 128], [0, 0, 0]], dtype=np.uint8 ) range_x = np.where(np.any(top_down_map, axis=1))[0] range_y = np.where(np.any(top_down_map, axis=0))[0] padding = int(np.ceil(top_down_map.shape[0] / 125)) range_x = ( max(range_x[0] - padding, 0), min(range_x[-1] + padding + 1, top_down_map.shape[0]), ) range_y = ( max(range_y[0] - padding, 0), min(range_y[-1] + padding + 1, top_down_map.shape[1]), ) top_down_map = top_down_map[ range_x[0] : range_x[1], range_y[0] : range_y[1] ] top_down_map = recolor_map[top_down_map] imageio.imsave(os.path.join(IMAGE_DIR, "top_down_map.png"), top_down_map)
def shortest_path_example(mode): config = habitat.get_config(config_file="tasks/pointnav.yaml") env = habitat.Env(config=config) goal_radius = env.episodes[0].goals[0].radius if goal_radius is None: goal_radius = config.SIMULATOR.FORWARD_STEP_SIZE follower = ShortestPathFollower(env.sim, goal_radius, False) follower.mode = mode print("Environment creation successful") for episode in range(3): observations = env.reset() dirname = os.path.join(IMAGE_DIR, "shortest_path_example", mode, "%02d" % episode) if os.path.exists(dirname): shutil.rmtree(dirname) os.makedirs(dirname) print("Agent stepping around inside environment.") count_steps = 0 while not env.episode_over: best_action = follower.get_next_action( env.current_episode.goals[0].position) observations = env.step(SIM_NAME_TO_ACTION[best_action.value]) count_steps += 1 im = observations["rgb"] imageio.imsave(os.path.join(dirname, "%03d.jpg" % count_steps), im) print("Episode finished after {} steps.".format(count_steps))
def __init__(self, env_config_file): threading.Thread.__init__(self) self.env = habitat.Env(config=habitat.get_config(env_config_file)) # always assume height equals width self._sensor_resolution = { "RGB": self.env._sim.config["RGB_SENSOR"]["HEIGHT"], "DEPTH": self.env._sim.config["DEPTH_SENSOR"]["HEIGHT"], "BC_SENSOR": self.env._sim.config["BC_SENSOR"]["HEIGHT"], } self.env._sim._sim.agents[ 0].move_filter_fn = self.env._sim._sim._step_filter self.observations = self.env.reset() self.env._sim._sim.agents[0].state.velocity = np.float32([0, 0, 0]) self.env._sim._sim.agents[0].state.angular_velocity = np.float32( [0, 0, 0]) self._pub_rgb = rospy.Publisher("~rgb", numpy_msg(Floats), queue_size=1) self._pub_depth = rospy.Publisher("~depth", numpy_msg(Floats), queue_size=1) # additional RGB sensor I configured self._pub_bc_sensor = rospy.Publisher("~bc_sensor", numpy_msg(Floats), queue_size=1) self._pub_depth_and_pointgoal = rospy.Publisher("depth_and_pointgoal", numpy_msg(Floats), queue_size=1) print("created habitat_plant succsefully")
def test_task_actions(): config = habitat.get_config(config_paths=CFG_TEST) config.defrost() config.TASK.POSSIBLE_ACTIONS = config.TASK.POSSIBLE_ACTIONS + ["TELEPORT"] config.freeze() env = habitat.Env(config=config) env.reset() env.step( action={ "action": "TELEPORT", "action_args": { "position": TELEPORT_POSITION, "rotation": TELEPORT_ROTATION, }, } ) agent_state = env.sim.get_agent_state() assert np.allclose( np.array(TELEPORT_POSITION, dtype=np.float32), agent_state.position ), "mismatch in position after teleport" assert np.allclose( np.array(TELEPORT_ROTATION, dtype=np.float32), np.array([*agent_state.rotation.imag, agent_state.rotation.real]), ), "mismatch in rotation after teleport" env.step("TURN_RIGHT") env.close()
def get_topdown_map(config_paths, map_name): config = habitat.get_config(config_paths=config_paths) dataset = habitat.make_dataset(id_dataset=config.DATASET.TYPE, config=config.DATASET) env = habitat.Env(config=config, dataset=dataset) env.reset() square_map_resolution = 5000 top_down_map = maps.get_topdown_map(env.sim, map_resolution=(square_map_resolution, square_map_resolution)) # Image containing 0 if occupied, 1 if unoccupied, and 2 if border (if # the flag is set) top_down_map[np.where(top_down_map == 0)] = 125 top_down_map[np.where(top_down_map == 1)] = 255 top_down_map[np.where(top_down_map == 2)] = 0 imageio.imsave(os.path.join(MAP_DIR, map_name + ".pgm"), top_down_map) complete_name = os.path.join(MAP_DIR, map_name + ".yaml") f = open(complete_name, "w+") f.write("image: " + map_name + ".pgm\n") f.write("resolution: " + str((COORDINATE_MAX - COORDINATE_MIN) / square_map_resolution) + "\n") f.write("origin: [" + str(-1) + "," + str(-1) + ", 0.000000]\n") f.write("negate: 0\noccupied_thresh: 0.65\nfree_thresh: 0.196") f.close()
def main(): # Get the default config node config = habitat.get_config(config_paths="configs/tasks/pointnav.yaml") config.defrost() # Add things to the config to for the measure config.task.episode_info_example = habitat.config() # The type field is used to look-up the measure in the registry. # By default, the things are registered with the class name config.TASK.EPISODE_INFO_EXAMPLE.TYPE = "EpisodeInfoExample" config.TASK.EPISODE_INFO_EXAMPLE.VALUE = 5 # Add the measure to the list of measures in use config.TASK.MEASUREMENTS.append("EPISODE_INFO_EXAMPLE") # Now define the config for the sensor config.TASK.AGENT_POSITION_SENSOR = habitat.Config() # Use the custom name config.TASK.AGENT_POSITION_SENSOR.TYPE = "my_supercool_sensor" config.TASK.AGENT_POSITION_SENSOR.ANSWER_TO_LIFE = 42 # Add the sensor to the list of sensors in use config.TASK.SENSORS.append("AGENT_POSITION_SENSOR") config.freeze() with habitat.Env(config=config) as env: print(env.reset()["agent_position"]) print(env.get_metrics()["episode_info"]) print(env.step("MOVE_FORWARD")["agent_position"]) print(env.get_metrics()["episode_info"])
def main(): habitat.SimulatorActions.extend_action_space("NOISY_LEFT") habitat.SimulatorActions.extend_action_space("NOISY_RIGHT") habitat.SimulatorActions.extend_action_space("NOISY_FORWARD") config = habitat.get_config( config_paths="../habitat-api/configs/tasks/pointnav.yaml") config.defrost() config.SIMULATOR.ACTION_SPACE_CONFIG = "NoNoisyMove" config.DATASET.DATA_PATH = "../habitat-api/" + config.DATASET.DATA_PATH config.SIMULATOR.SCENE = '../habitat-api/' + config.SIMULATOR.SCENE config.freeze() env = habitat.Env(config=config) env.reset() env.step(habitat.SimulatorActions.NOISY_LEFT) env.step(habitat.SimulatorActions.NOISY_RIGHT) env.step(habitat.SimulatorActions.NOISY_FORWARD) env.close() config.defrost() config.SIMULATOR.ACTION_SPACE_CONFIG = "NoisyMove" config.freeze() env = habitat.Env(config=config) env.reset() env.step(habitat.SimulatorActions.NOISY_LEFT) env.step(habitat.SimulatorActions.NOISY_RIGHT) env.step(habitat.SimulatorActions.NOISY_FORWARD) env.close()
def __init__(self, env_config_file): threading.Thread.__init__(self) self.env = habitat.Env(config=habitat.get_config(env_config_file)) # always assume height equals width self._sensor_resolution = { "RGB": self.env._sim.config["RGB_SENSOR"]["HEIGHT"], "DEPTH": self.env._sim.config["DEPTH_SENSOR"]["HEIGHT"], "BC_SENSOR": self.env._sim.config["BC_SENSOR"]["HEIGHT"], } self.env._sim._sim.agents[ 0].move_filter_fn = self.env._sim._sim._step_filter self.observations = self.env.reset() # add a sphere # load some object templates from configuration files sphere_template_id = self.env._sim._sim.load_object_configs( str("/home/eric/habitat-sim-may-2020/habitat-sim/data/test_assets/objects/sphere" ))[0] id_sphere = self.env._sim._sim.add_object(sphere_template_id) self.env._sim._sim.set_translation(np.array([-2.63, 0.114367, 19.3]), id_sphere) # load and initialize the lobot_merged asset locobot_template_id = self.env._sim._sim.load_object_configs( "/home/eric/habitat-sim-may-2020/habitat-sim/data/objects/locobot_merged" )[0] # print("locobot_template_id is " + str(locobot_template_id)) # add robot object to the scene with the agent/camera SceneNode attached self.id_agent_obj = self.env._sim._sim.add_object( locobot_template_id, self.env._sim._sim.agents[0].scene_node) # print("id of agent object is " + str(self.id_agent_obj)) # set the agent's body to dynamic self.env._sim._sim.set_object_motion_type( hsim.physics.MotionType.DYNAMIC, self.id_agent_obj) self.env._sim._sim.agents[0].state.velocity = np.float32([0, 0, 0]) self.env._sim._sim.agents[0].state.angular_velocity = np.float32( [0, 0, 0]) self.vel_control = self.env._sim._sim.get_object_velocity_control( self.id_agent_obj) self.env._sim._sim.set_translation( np.array([-1.7927, 0.114367, 19.1552]), self.id_agent_obj) self._pub_rgb = rospy.Publisher("~rgb", numpy_msg(Floats), queue_size=1) self._pub_depth = rospy.Publisher("~depth", numpy_msg(Floats), queue_size=1) # additional RGB sensor I configured self._pub_bc_sensor = rospy.Publisher("~bc_sensor", numpy_msg(Floats), queue_size=1) self._pub_depth_and_pointgoal = rospy.Publisher("depth_and_pointgoal", numpy_msg(Floats), queue_size=1) print("created habitat_plant succsefully")
def get_config(training: bool = False, top_down_map: bool = False, max_steps: Optional[Union[int, float]] = None, task: str = 'pointnav', train_dataset: str = 'habitat_test', train_split: str = 'train', eval_dataset: str = 'habitat_test', eval_split: str = 'val', gpu_id: int = 0, image_key: str = 'rgb', goal_key: str = 'pointgoal_with_gps_compass', depth_key: Optional[str] = None, reward_function: RewardFunction = gin.REQUIRED, eval_episodes_per_scene: int = 3) -> Dict[str, Any]: mode = 'train' if training else 'eval' dataset = train_dataset if training else eval_dataset split = train_split if training else eval_split opts = ['SIMULATOR.HABITAT_SIM_V0.GPU_DEVICE_ID', gpu_id] if max_steps: opts += ['ENVIRONMENT.MAX_EPISODE_STEPS', int(max_steps)] opts += ['DATASET.SPLIT', split] if not training: opts += ['ENVIRONMENT.ITERATOR_OPTIONS.SHUFFLE', False] opts += [ 'ENVIRONMENT.ITERATOR_OPTIONS.MAX_SCENE_REPEAT_EPISODES', eval_episodes_per_scene ] if not task.endswith('.yaml'): task = f'{get_config_dir()}/habitat/tasks/{task}.yaml' if not dataset.endswith('.yaml'): dataset = f'{get_config_dir()}/habitat/datasets/{dataset}.yaml' task_file = Path(wandb.run.dir) / 'task.yaml' dataset_file = Path(wandb.run.dir) / f'{mode}_dataset.yaml' copyfile(task, task_file) copyfile(dataset, dataset_file) wandb.save(str(task_file)) wandb.save(str(dataset_file)) if not HabitatSimActions.has_action('TURN_ANGLE'): HabitatSimActions.extend_action_space('TURN_ANGLE') config = habitat.get_config([task, dataset], opts) config.defrost() config.TASK.SUCCESS = habitat.Config() config.TASK.SUCCESS.TYPE = 'Success' config.TASK.SUCCESS.SUCCESS_DISTANCE = config.TASK.SUCCESS_DISTANCE config.TASK.MEASUREMENTS.append('SUCCESS') config.TASK.ACTIONS.TURN_ANGLE = habitat.Config() config.TASK.ACTIONS.TURN_ANGLE.TYPE = 'TurnAngleAction' config.TASK.POSSIBLE_ACTIONS = ['STOP', 'MOVE_FORWARD', 'TURN_ANGLE'] if top_down_map and 'TOP_DOWN_MAP' not in config.TASK.MEASUREMENTS: # Top-down map is expensive to compute, so we only enable it when needed. config.TASK.MEASUREMENTS.append('TOP_DOWN_MAP') config.freeze() return { 'config': config, 'image_key': image_key, 'goal_key': goal_key, 'depth_key': depth_key, 'reward_function': reward_function }
def agent_demo(): config = habitat.get_config( "habitat/habitat-api/configs/tasks/pointnav.yaml") config.defrost() config.DATASET.DATA_PATH = ( "habitat/habitat-api/data/datasets/pointnav/gibson/v1/train/train.json.gz" ) config.DATASET.SCENES_DIR = "habitat/habitat-api/data/scene_datasets/" config.SIMULATOR.HABITAT_SIM_V0.GPU_DEVICE_ID = 0 config.SIMULATOR.TURN_ANGLE = 45 config.freeze() env = habitat.Env(config=config) print("Environment creation successful") observations = env.reset() cv2.imshow("RGB", transform_rgb_bgr(observations["rgb"])) print("Agent stepping around inside environment.") count_steps = 0 while not env.episode_over: keystroke = cv2.waitKey(0) if keystroke == ord(FORWARD_KEY): action = 1 print("action: FORWARD") elif keystroke == ord(LEFT_KEY): action = 2 print("action: LEFT") elif keystroke == ord(RIGHT_KEY): action = 3 print("action: RIGHT") elif keystroke == ord(FINISH): action = 0 print("action: FINISH") else: print("INVALID KEY") continue observations = env.step(action) count_steps += 1 print("Position:", env.sim.get_agent_state().position) print("Quaternions:", env.sim.get_agent_state().rotation) quat = Quaternion(env.sim.get_agent_state().rotation.components) print(quat.radians) cv2.imshow("RGB", transform_rgb_bgr(observations["rgb"])) print("Episode finished after {} steps.".format(count_steps)) if action == habitat.SimulatorActions.STOP and observations["pointgoal"][ 0] < 0.2: print("you successfully navigated to destination point") else: print("your navigation was unsuccessful")
def reference_path_example(mode): """ Saves a video of a shortest path follower agent navigating from a start position to a goal. Agent follows the ground truth reference path by navigating to intermediate viewpoints en route to goal. Args: mode: 'geodesic_path' or 'greedy' """ config = habitat.get_config( config_paths="configs/test/habitat_r2r_vln_test.yaml") config.defrost() config.TASK.MEASUREMENTS.append("TOP_DOWN_MAP") config.TASK.SENSORS.append("HEADING_SENSOR") config.freeze() with SimpleRLEnv(config=config) as env: follower = ShortestPathFollower(env.habitat_env.sim, goal_radius=0.5, return_one_hot=False) follower.mode = mode print("Environment creation successful") for episode in range(3): env.reset() print(env.habitat_env.current_episode) episode_id = env.habitat_env.current_episode.episode_id print( f"Agent stepping around inside environment. Episode id: {episode_id}" ) dirname = os.path.join(IMAGE_DIR, "vln_reference_path_example", mode, "%02d" % episode) if os.path.exists(dirname): shutil.rmtree(dirname) os.makedirs(dirname) images = [] steps = 0 reference_path = env.habitat_env.current_episode.reference_path + [ env.habitat_env.current_episode.goals[0].position ] for point in reference_path: done = False while not done: best_action = follower.get_next_action(point) print(best_action) if best_action == None or best_action == 0: break observations, reward, done, info = env.step(best_action) save_map(observations, info, images) steps += 1 print(f"Navigated to goal in {steps} steps.") images_to_video(images, dirname, str(episode_id)) images = []
def example(): # Note: Use with for the example testing, doesn't need to be like this on the README config = habitat.get_config( "habitat-lab/configs/tasks/objectnav_mp3d.yaml") with habitat.Env(config=config) as env: print("Environment creation successful") observations = env.reset() # noqa: F841 print(observations) while not env.episode_over: observations = env.step(env.action_space.sample()) # noqa: F841 print("Episode finished")
def test_demo_notebook(): config = habitat.get_config("configs/tasks/pointnav_mp3d.yaml") config.defrost() config.DATASET.SPLIT = "val" if not PointNavDatasetV1.check_config_paths_exist(config.DATASET): pytest.skip( "Please download the Matterport3D PointNav val dataset and Matterport3D val scenes" ) else: pytest.main(["--nbval-lax", "notebooks/habitat-api-demo.ipynb"])
def example(): env = habitat.Env(config=habitat.get_config("configs/tasks/vln_r2r.yaml")) print("Environment creation successful") observations = env.reset() print("Agent stepping around inside environment.") count_steps = 0 while not env.episode_over: observations = env.step(env.action_space.sample()) count_steps += 1 print("Episode finished after {} steps.".format(count_steps))
def test_demo_notebook(): config = habitat.get_config("configs/tasks/pointnav_rgbd.yaml") config.defrost() config.DATASET.SPLIT = "val" if not PointNavDatasetV1.check_config_paths_exist(config.DATASET): pytest.skip("Please download the habitat test scenes") else: pytest.main([ "--nbval-lax", "notebooks/relative_camera_views_transform_and_warping_demo.ipynb", ])
def example_get_topdown_map(): config = habitat.get_config(config_paths="configs/tasks/pointnav.yaml") dataset = habitat.make_dataset(id_dataset=config.DATASET.TYPE, config=config.DATASET) with habitat.Env(config=config, dataset=dataset) as env: env.reset() top_down_map = maps.get_topdown_map_from_sim(env.sim, map_resolution=1024) recolor_map = np.array([[255, 255, 255], [128, 128, 128], [0, 0, 0]], dtype=np.uint8) top_down_map = recolor_map[top_down_map] imageio.imsave(os.path.join(IMAGE_DIR, "top_down_map.png"), top_down_map)
def example(): # Note: Use with for the example testing, doesn't need to be like this on the README with habitat.Env( config=habitat.get_config("configs/tasks/pointnav.yaml")) as env: print("Environment creation successful") observations = env.reset() # noqa: F841 print("Agent stepping around inside environment.") count_steps = 0 while not env.episode_over: observations = env.step(env.action_space.sample()) # noqa: F841 count_steps += 1 print("Episode finished after {} steps.".format(count_steps))
def example(): trajectory_directory = 'trajectories/Adrian/' config = habitat.get_config(config_file='datasets/pointnav/gibson.yaml') config.defrost() config.DATASET.SPLIT = 'train_mini' config.freeze() env = habitat.Env(config=config) action_list = [] position_list = [] print("Environment creation successful") observations = env.reset() position_list.append(env.sim.get_agent_state().position) fig = plt.figure(frameon=False) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) ax.imshow(observations["rgb"]) plt.show(block=False) fig.savefig(trajectory_directory+'images/'+str(0)+'.png') #cv2.imshow("RGB", transform_rgb_bgr(observations["rgb"])) print("Agent stepping around inside environment.") count_steps = 0 while not env.episode_over: input_text = input("Enter the action ... ") if input_text == FORWARD_KEY: action = 0 elif input_text == LEFT_KEY: action = 1 elif input_text == RIGHT_KEY: action = 2 elif input_text == FINISH_KEY: action = 3 else: print('Invalid action') continue action_list.append(action) observations = env.step(action) position_list.append(env.sim.get_agent_state().position) count_steps += 1 ax.imshow(observations["rgb"]) plt.show(block=False) fig.savefig(trajectory_directory+'/images/'+str(count_steps)+'.png') #cv2.imshow("RGB", transform_rgb_bgr(observations["rgb"])) np.array(action_list).dump(open(trajectory_directory+'actions.npy', 'wb')) np.array(position_list).dump(open(trajectory_directory+'positions.npy', 'wb')) print("Episode finished after {} steps.".format(count_steps))
def __init__(self, forward_step, angle_step, is_blind=False, sensors=["RGB_SENSOR"]): config = habitat.get_config() log_mesg("env: forward_step: {}, angle_step: {}".format( forward_step, angle_step)) config.defrost() config.PYROBOT.SENSORS = sensors config.PYROBOT.RGB_SENSOR.WIDTH = 256 config.PYROBOT.RGB_SENSOR.HEIGHT = 256 config.PYROBOT.DEPTH_SENSOR.WIDTH = 256 config.PYROBOT.DEPTH_SENSOR.HEIGHT = 256 config.PYROBOT.DEPTH_SENSOR.MAX_DEPTH = 10 config.PYROBOT.DEPTH_SENSOR.MIN_DEPTH = 0.3 config.freeze() self._reality = make_sim(id_sim="PyRobot-v0", config=config.PYROBOT) self._angle = (angle_step / 180) * np.pi self._pointgoal_key = "pointgoal_with_gps_compass" self.is_blind = is_blind if not is_blind: sensors_dict = { **self._reality.sensor_suite.observation_spaces.spaces } else: sensors_dict = {} sensors_dict[self._pointgoal_key] = spaces.Box( low=np.finfo(np.float32).min, high=np.finfo(np.float32).max, shape=(2, ), dtype=np.float32, ) self.observation_space = SpaceDict(sensors_dict) self.action_space = spaces.Discrete(4) self._actions = { "forward": [forward_step, 0, 0], "left": [0, 0, self._angle], "right": [0, 0, -self._angle], "stop": [0, 0, 0], } self._process = None self._last_time = -1
def main(): config = habitat.get_config(config_paths="/home/rene/catkin_ws/src/habitat-api/configs/tasks/pointnav_rgbd.yaml") config.defrost() # Add things to the config to for the measure config.TASK.EPISODE_INFO = habitat.Config() # The type field is used to look-up the measure in the registry. # By default, the things are registered with the class name config.TASK.EPISODE_INFO.TYPE = "EpisodeInfo" config.TASK.EPISODE_INFO.VALUE = 5 # Now define the config for the sensor config.TASK.AGENT_POSITION_SENSOR = habitat.Config() # Use the custom name config.TASK.AGENT_POSITION_SENSOR.TYPE = "my_supercool_sensor" # Add the sensor to the list of sensors in use config.TASK.SENSORS.append("AGENT_POSITION_SENSOR") # Now define the config for the sensor config.TASK.SEMANTIC_SEGMENTATION_MASK_SENSOR = habitat.Config() # Use the custom name config.TASK.SEMANTIC_SEGMENTATION_MASK_SENSOR.TYPE = "semantic_segmentation_mask" # Add the sensor to the list of sensors in use config.TASK.SENSORS.append("SEMANTIC_SEGMENTATION_MASK_SENSOR") config.freeze() my_env = sim_env(config) # start the thread that publishes sensor readings my_env.start() rospy.Subscriber("/cmd_vel", Twist, callback, (my_env), queue_size=1) # define a list capturing how long it took # to update agent orientation for past 3 instances # TODO modify dt_list to depend on r1 dt_list = [0.009, 0.009, 0.009] while not rospy.is_shutdown(): start_time = time.time() # cv2.imshow("bc_sensor", my_env.observations['bc_sensor']) # cv2.waitKey(100) # time.sleep(0.1) my_env.update_orientation() dt_list.insert(0, time.time() - start_time) dt_list.pop() my_env.set_dt(sum(dt_list) / len(dt_list))
def main(): parser = argparse.ArgumentParser() parser.add_argument("--evaluation", type=str, required=True, choices=["local", "remote"]) args = parser.parse_args() config_paths = os.environ["CHALLENGE_CONFIG_FILE"] config = habitat.get_config(config_paths) agent = RandomAgent(task_config=config) if args.evaluation == "local": challenge = habitat.Challenge(eval_remote=False) else: challenge = habitat.Challenge(eval_remote=True) challenge.submit(agent)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--task-config", type=str, default="tasks/pointnav.yaml") parser.add_argument("--agent_class", type=str, default="GoalFollower") args = parser.parse_args() agent = get_agent_cls(args.agent_class)(habitat.get_config( args.task_config)) benchmark = habitat.Benchmark(args.task_config) metrics = benchmark.evaluate(agent) for k, v in metrics.items(): habitat.logger.info("{}: {:.3f}".format(k, v))
def __init__(self): super().__init__() self.TRAIN_SCENES = ( "habitat/habitat-api/data/datasets/pointnav/gibson/v1/train/train.json.gz" ) self.VALID_SCENES = ( "habitat/habitat-api/data/datasets/pointnav/gibson/v1/val/val.json.gz" ) self.TEST_SCENES = ( "habitat/habitat-api/data/datasets/pointnav/gibson/v1/test/test.json.gz" ) self.NUM_PROCESSES = 80 self.CONFIG = habitat.get_config("configs/gibson.yaml") self.CONFIG.defrost() self.CONFIG.NUM_PROCESSES = self.NUM_PROCESSES self.CONFIG.SIMULATOR_GPU_IDS = [0, 1, 2, 3, 4, 5, 6, 7] self.CONFIG.DATASET.SCENES_DIR = "habitat/habitat-api/data/scene_datasets/" self.CONFIG.DATASET.POINTNAVV1.CONTENT_SCENES = ["*"] self.CONFIG.DATASET.DATA_PATH = self.TRAIN_SCENES self.CONFIG.SIMULATOR.AGENT_0.SENSORS = ["RGB_SENSOR"] self.CONFIG.SIMULATOR.RGB_SENSOR.WIDTH = self.CAMERA_WIDTH self.CONFIG.SIMULATOR.RGB_SENSOR.HEIGHT = self.CAMERA_HEIGHT self.CONFIG.SIMULATOR.DEPTH_SENSOR.WIDTH = self.CAMERA_WIDTH self.CONFIG.SIMULATOR.DEPTH_SENSOR.HEIGHT = self.CAMERA_HEIGHT self.CONFIG.SIMULATOR.TURN_ANGLE = self.ROTATION_DEGREES self.CONFIG.SIMULATOR.FORWARD_STEP_SIZE = self.STEP_SIZE self.CONFIG.ENVIRONMENT.MAX_EPISODE_STEPS = self.MAX_STEPS self.CONFIG.TASK.TYPE = "Nav-v0" self.CONFIG.TASK.SUCCESS_DISTANCE = self.DISTANCE_TO_GOAL self.CONFIG.TASK.SENSORS = ["POINTGOAL_WITH_GPS_COMPASS_SENSOR"] self.CONFIG.TASK.POINTGOAL_WITH_GPS_COMPASS_SENSOR.GOAL_FORMAT = "POLAR" self.CONFIG.TASK.POINTGOAL_WITH_GPS_COMPASS_SENSOR.DIMENSIONALITY = 2 self.CONFIG.TASK.GOAL_SENSOR_UUID = "pointgoal_with_gps_compass" self.CONFIG.TASK.MEASUREMENTS = ["DISTANCE_TO_GOAL", "SPL"] self.CONFIG.TASK.SPL.TYPE = "SPL" self.CONFIG.TASK.SPL.SUCCESS_DISTANCE = self.DISTANCE_TO_GOAL self.CONFIG.MODE = "train" self.TRAIN_GPUS = [0, 1, 2, 3, 4, 5, 6, 7] self.VALIDATION_GPUS = [7] self.TESTING_GPUS = [7] self.TRAIN_CONFIGS = None self.TEST_CONFIGS = None self.SENSORS = None
def test_demo_notebook(): config = habitat.get_config("configs/tasks/pointnav_mp3d.yaml") config.defrost() config.DATASET.SPLIT = "val" if not PointNavDatasetV1.check_config_paths_exist(config.DATASET): pytest.skip( "Please download the Matterport3D PointNav val dataset and Matterport3D val scenes" ) else: pytest.main(["--nbval-lax", "notebooks/habitat-api-demo.ipynb"]) # NB: Force a gc collect run as it can take a little bit for # the cleanup to happen after the notebook and we get # a double context crash! gc.collect()