def action_space(self) -> Space: return ActionSpace( { action_name: action_instance.action_space for action_name, action_instance in self.actions.items() } )
def action_space(self): return ActionSpace({ "linear_velocity": spaces.Box( low=np.array([self.min_lin_vel]), high=np.array([self.max_lin_vel]), dtype=np.float32, ), "angular_velocity": spaces.Box( low=np.array([self.min_ang_vel]), high=np.array([self.max_ang_vel]), dtype=np.float32, ), })
def _worker_fn(world_rank: int, world_size: int, port: int, unused_params: bool): device = (torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")) tcp_store = distrib.TCPStore( # type: ignore "127.0.0.1", port, world_size, world_rank == 0) distrib.init_process_group("gloo", store=tcp_store, rank=world_rank, world_size=world_size) config = get_config("habitat_baselines/config/test/ppo_pointnav_test.yaml") obs_space = gym.spaces.Dict({ IntegratedPointGoalGPSAndCompassSensor.cls_uuid: gym.spaces.Box( low=np.finfo(np.float32).min, high=np.finfo(np.float32).max, shape=(2, ), dtype=np.float32, ) }) action_space = ActionSpace({"move": EmptySpace()}) actor_critic = PointNavBaselinePolicy.from_config(config, obs_space, action_space) # This use adds some arbitrary parameters that aren't part of the computation # graph, so they will mess up DDP if they aren't correctly ignored by it if unused_params: actor_critic.unused = nn.Linear(64, 64) actor_critic.to(device=device) ppo_cfg = config.RL.PPO agent = DDPPO( actor_critic=actor_critic, clip_param=ppo_cfg.clip_param, ppo_epoch=ppo_cfg.ppo_epoch, num_mini_batch=ppo_cfg.num_mini_batch, value_loss_coef=ppo_cfg.value_loss_coef, entropy_coef=ppo_cfg.entropy_coef, lr=ppo_cfg.lr, eps=ppo_cfg.eps, max_grad_norm=ppo_cfg.max_grad_norm, use_normalized_advantage=ppo_cfg.use_normalized_advantage, ) agent.init_distributed() rollouts = RolloutStorage( ppo_cfg.num_steps, 2, obs_space, action_space, ppo_cfg.hidden_size, num_recurrent_layers=actor_critic.net.num_recurrent_layers, is_double_buffered=False, ) rollouts.to(device) for k, v in rollouts.buffers["observations"].items(): rollouts.buffers["observations"][k] = torch.randn_like(v) # Add two steps so batching works rollouts.advance_rollout() rollouts.advance_rollout() # Get a single batch batch = next(rollouts.recurrent_generator(rollouts.buffers["returns"], 1)) # Call eval actions through the internal wrapper that is used in # agent.update value, action_log_probs, dist_entropy, _ = agent._evaluate_actions( batch["observations"], batch["recurrent_hidden_states"], batch["prev_actions"], batch["masks"], batch["actions"], ) # Backprop on things (value.mean() + action_log_probs.mean() + dist_entropy.mean()).backward() # Make sure all ranks have very similar parameters for param in actor_critic.parameters(): if param.grad is not None: grads = [param.grad.detach().clone() for _ in range(world_size)] distrib.all_gather(grads, grads[world_rank]) for i in range(world_size): assert torch.isclose(grads[i], grads[world_rank]).all()
def __init__(self, config: Config, dataset: Optional[Dataset] = None): self.noise = NOISY print('[VisTargetNavEnv] NOISY ACTUATION : ', self.noise) if hasattr(config, 'AGENT_TASK'): self.agent_task = config.AGENT_TASK else: self.agent_task = 'search' if self.agent_task == 'homing': self.num_goals = 2 else: self.num_goals = config.NUM_GOALS task_config = config.TASK_CONFIG task_config.defrost() #task_config.TASK.TOP_DOWN_MAP.MAP_RESOLUTION = 1250 task_config.TASK.TOP_DOWN_MAP.DRAW_SOURCE = True task_config.TASK.TOP_DOWN_MAP.DRAW_SHORTEST_PATH = True task_config.TASK.TOP_DOWN_MAP.FOG_OF_WAR.VISIBILITY_DIST = 2.0 task_config.TASK.TOP_DOWN_MAP.FOG_OF_WAR.FOV = 360 task_config.TASK.TOP_DOWN_MAP.FOG_OF_WAR.DRAW = True task_config.TASK.TOP_DOWN_MAP.DRAW_VIEW_POINTS = False task_config.TASK.TOP_DOWN_MAP.DRAW_GOAL_POSITIONS = True task_config.TASK.TOP_DOWN_MAP.DRAW_GOAL_AABBS = False if ('GMT' in config.POLICY or 'NTS' in config.POLICY) and RENDER: task_config.TASK.TOP_DOWN_GRAPH_MAP = config.TASK_CONFIG.TASK.TOP_DOWN_MAP.clone( ) if 'GMT' in config.POLICY: task_config.TASK.TOP_DOWN_GRAPH_MAP.TYPE = "TopDownGraphMap" elif 'NTS' in config.POLICY: task_config.TASK.TOP_DOWN_GRAPH_MAP.TYPE = 'NTSGraphMap' task_config.TASK.TOP_DOWN_GRAPH_MAP.MAP_RESOLUTION = 4000 task_config.TASK.TOP_DOWN_GRAPH_MAP.NUM_TOPDOWN_MAP_SAMPLE_POINTS = 20000 task_config.TASK.MEASUREMENTS += ['TOP_DOWN_GRAPH_MAP'] if 'TOP_DOWN_MAP' in config.TASK_CONFIG.TASK.MEASUREMENTS: task_config.TASK.MEASUREMENTS = [ k for k in task_config.TASK.MEASUREMENTS if 'TOP_DOWN_MAP' != k ] task_config.SIMULATOR.ACTION_SPACE_CONFIG = "CustomActionSpaceConfiguration" task_config.TASK.POSSIBLE_ACTIONS = task_config.TASK.POSSIBLE_ACTIONS + [ 'NOISY_FORWARD', 'NOISY_RIGHT', 'NOISY_LEFT' ] task_config.TASK.ACTIONS.NOISY_FORWARD = habitat.config.Config() task_config.TASK.ACTIONS.NOISY_FORWARD.TYPE = "NOISYFORWARD" task_config.TASK.ACTIONS.NOISY_RIGHT = habitat.config.Config() task_config.TASK.ACTIONS.NOISY_RIGHT.TYPE = "NOISYRIGHT" task_config.TASK.ACTIONS.NOISY_LEFT = habitat.config.Config() task_config.TASK.ACTIONS.NOISY_LEFT.TYPE = "NOISYLEFT" task_config.TASK.MEASUREMENTS = [ 'GOAL_INDEX' ] + task_config.TASK.MEASUREMENTS + ['SOFT_SPL'] task_config.TASK.DISTANCE_TO_GOAL.TYPE = 'Custom_DistanceToGoal' if self.agent_task != 'search': task_config.TASK.SPL.TYPE = 'Custom_SPL' task_config.TASK.SOFT_SPL.TYPE = 'Custom_SoftSPL' task_config.TASK.GOAL_INDEX = task_config.TASK.SPL.clone() task_config.TASK.GOAL_INDEX.TYPE = 'GoalIndex' task_config.freeze() self.config = config self._core_env_config = config.TASK_CONFIG self._reward_measure_name = config.REWARD_METHOD self._success_measure_name = config.SUCCESS_MEASURE self.success_distance = config.SUCCESS_DISTANCE self._previous_measure = None self._previous_action = -1 self.time_t = 0 self.stuck = 0 self.follower = None if 'NOISY_FORWARD' not in HabitatSimActions: HabitatSimActions.extend_action_space("NOISY_FORWARD") HabitatSimActions.extend_action_space("NOISY_RIGHT") HabitatSimActions.extend_action_space("NOISY_LEFT") if 'STOP' in task_config.TASK.POSSIBLE_ACTIONS: self.action_dict = { 0: HabitatSimActions.STOP, 1: "NOISY_FORWARD", 2: "NOISY_LEFT", 3: "NOISY_RIGHT" } else: self.action_dict = { 0: "NOISY_FORWARD", 1: "NOISY_LEFT", 2: "NOISY_RIGHT" } super().__init__(self._core_env_config, dataset) act_dict = { "MOVE_FORWARD": EmptySpace(), 'TURN_LEFT': EmptySpace(), 'TURN_RIGHT': EmptySpace() } if 'STOP' in task_config.TASK.POSSIBLE_ACTIONS: act_dict.update({'STOP': EmptySpace()}) self.action_space = ActionSpace(act_dict) obs_dict = { 'panoramic_rgb': self.habitat_env._task.sensor_suite.observation_spaces. spaces['panoramic_rgb'], 'panoramic_depth': self.habitat_env._task.sensor_suite.observation_spaces. spaces['panoramic_depth'], 'target_goal': self.habitat_env._task.sensor_suite.observation_spaces. spaces['target_goal'], 'step': Box(low=np.array(0), high=np.array(500), dtype=np.float32), 'prev_act': Box(low=np.array(-1), high=np.array(self.action_space.n), dtype=np.int32), 'gt_action': Box(low=np.array(-1), high=np.array(self.action_space.n), dtype=np.int32), 'position': Box(low=-np.Inf, high=np.Inf, shape=(3, ), dtype=np.float32), 'target_pose': Box(low=-np.Inf, high=np.Inf, shape=(3, ), dtype=np.float32), 'distance': Box(low=-np.Inf, high=np.Inf, shape=(1, ), dtype=np.float32), } if 'GMT' in config.POLICY and RENDER: self.mapper = self.habitat_env.task.measurements.measures[ 'top_down_map'] #obs_dict.update({'unexplored':Box(low=0, high=1, shape=(self.mapper.delta,), dtype=np.int32), # 'neighbors': Box(low=0, high=1, shape=(self.mapper.delta,), dtype=np.int32),}) else: self.mapper = None if 'aux' in self.config.POLICY: self.return_have_been = True self.return_target_dist_score = True obs_dict.update({ 'have_been': Box(low=0, high=1, shape=(1, ), dtype=np.int32), 'target_dist_score': Box(low=0, high=1, shape=(1, ), dtype=np.float32), }) else: self.return_have_been = False self.return_target_dist_score = False self.observation_space = SpaceDict(obs_dict) if config.DIFFICULTY == 'easy': self.habitat_env.difficulty = 'easy' self.habitat_env.MIN_DIST, self.habitat_env.MAX_DIST = 1.5, 3.0 elif config.DIFFICULTY == 'medium': self.habitat_env.difficulty = 'medium' self.habitat_env.MIN_DIST, self.habitat_env.MAX_DIST = 3.0, 5.0 elif config.DIFFICULTY == 'hard': self.habitat_env.difficulty = 'hard' self.habitat_env.MIN_DIST, self.habitat_env.MAX_DIST = 5.0, 10.0 elif config.DIFFICULTY == 'random': self.habitat_env.difficulty = 'random' self.habitat_env.MIN_DIST, self.habitat_env.MAX_DIST = 3.0, 10.0 else: raise NotImplementedError self.habitat_env._num_goals = self.num_goals self.habitat_env._agent_task = self.agent_task print('current task : %s' % (self.agent_task)) print('current difficulty %s, MIN_DIST %f, MAX_DIST %f - # goals %d' % (config.DIFFICULTY, self.habitat_env.MIN_DIST, self.habitat_env.MAX_DIST, self.habitat_env._num_goals)) self.min_measure = self.habitat_env.MAX_DIST self.reward_method = config.REWARD_METHOD if self.reward_method == 'progress': self.get_reward = self.get_progress_reward elif self.reward_method == 'milestone': self.get_reward = self.get_milestone_reward elif self.reward_method == 'coverage': self.get_reward = self.get_coverage_reward self.run_mode = 'RL' self.number_of_episodes = 1000 self.need_gt_action = False self.has_log_info = None
def test_action_space(): space = ActionSpace( { "move": gym.spaces.Dict( { "position": gym.spaces.Discrete(2), "velocity": gym.spaces.Discrete(3), } ), "move_forward": EmptySpace(), } ) assert space.contains(space.sample()) assert space.contains( {"action": "move", "action_args": {"position": 0, "velocity": 1}} ) assert space.contains({"action": "move_forward"}) assert not space.contains([0, 1, 2]) assert not space.contains({"zero": None}) assert not space.contains({"action": "bad"}) assert not space.contains({"action": "move"}) assert not space.contains( {"action": "move", "action_args": {"position": 0}} ) assert not space.contains( {"action": "move_forward", "action_args": {"position": 0}} )