def __init__( self, object_types: List[str], target_to_detector_map: Optional[Dict[str, str]] = None, detector_types: Optional[List[str]] = None, uuid: str = "goal_object_type_ind", **kwargs: Any ): self.ordered_object_types = list(object_types) assert self.ordered_object_types == sorted( self.ordered_object_types ), "object types input to goal object type sensor must be ordered" if target_to_detector_map is None: self.object_type_to_ind = { ot: i for i, ot in enumerate(self.ordered_object_types) } observation_space = gym.spaces.Discrete(len(self.ordered_object_types)) else: assert ( detector_types is not None ), "Missing detector_types for map {}".format(target_to_detector_map) self.target_to_detector = target_to_detector_map self.detector_types = detector_types detector_index = {ot: i for i, ot in enumerate(self.detector_types)} self.object_type_to_ind = { ot: detector_index[self.target_to_detector[ot]] for ot in self.ordered_object_types } observation_space = gym.spaces.Discrete(len(self.detector_types)) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, action_space: gym.spaces.Discrete, observation_space: gym.spaces.Dict, rgb_uuid: str, unshuffled_rgb_uuid: str, in_walkthrough_phase_uuid: str, is_walkthrough_phase_embedding_dim: int, done_action_index: int, walkthrougher_should_ignore_action_mask: Optional[ Sequence[float]] = None, prev_action_embedding_dim: int = 32, hidden_size=512, num_rnn_layers=1, rnn_type="GRU", ): """A CNN->RNN for joint training of the Walkthrough and Unshuffle tasks that expects ResNet features instead of RGB images. Nearly identical to `TwoPhaseRearrangeActorCriticSimpleConvRNN` but `rgb_uuid` should now be the unique id of the ResNetPreprocessor used to featurize RGB images using a pretrained ResNet before they're passed to this model. """ self.visual_attention: Optional[nn.Module] = None super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, use_normalization: bool = False, mean: Optional[np.ndarray] = np.array([[0.5]], dtype=np.float32), stdev: Optional[np.ndarray] = np.array([[0.25]], dtype=np.float32), height: Optional[int] = None, width: Optional[int] = None, uuid: str = "depth", output_shape: Optional[Tuple[int, ...]] = None, output_channels: int = 1, unnormalized_infimum: float = 0.0, unnormalized_supremum: float = 5.0, scale_first: bool = True, **kwargs: Any): """Initializer. # Parameters config : If `config["use_normalization"]` is `True` then the depth images will be normalized with mean 0.5 and standard deviation 0.25. If both `config["height"]` and `config["width"]` are non-negative integers then the depth image returned from the environment will be rescaled to have shape (config["height"], config["width"]) using bilinear sampling. args : Extra args. Currently unused. kwargs : Extra kwargs. Currently unused. """ if not use_normalization: mean, stdev = None, None super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, uuid: str = "relative_current_obj_state", **kwargs: Any): observation_space = gym.spaces.Box( low=-100, high=100, shape=(6, ), dtype=np.float32 ) # (low=-1.0, high=2.0, shape=(3, 4), dtype=np.float32) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, action_space: gym.spaces.Discrete, observation_space: SpaceDict, num_objects: int, num_colors: int, num_states: int, object_embedding_dim: int = 8, **kwargs, ): super().__init__(**prepare_locals_for_super(locals())) agent_view_x, agent_view_y, view_channels = observation_space[ "minigrid_ego_image"].shape self.actor_critic = LinearActorCritic( self.ac_key, action_space=action_space, observation_space=SpaceDict({ self.ac_key: gym.spaces.Box( low=np.float32(-1.0), high=np.float32(1.0), shape=(self.object_embedding_dim * agent_view_x * agent_view_y * view_channels, ), ) }), ) self.memory_key = None self.train()
def __init__(self, uuid: str = "target_coordinates_ind", **kwargs: Any): observation_space = gym.spaces.Box( low=np.finfo(np.float32).min, high=np.finfo(np.float32).max, shape=(2,), dtype=np.float32, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, coordinate_dims: int, uuid: str = "target_coordinates_ind", **kwargs: Any ): self.coordinate_dims = coordinate_dims observation_space = self._get_observation_space() super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, uuid: str = "missing_action_mask", **kwargs: Any ) -> None: observation_space = self._get_observation_space() super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, uuid: str = "rel_position", **kwargs: Any): observation_space = gym.spaces.Box( low=np.array([-np.inf, -np.inf, -360], dtype=np.float32), high=np.array([-np.inf, -np.inf, 360], dtype=np.float32), shape=(3, ), dtype=np.float32, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, *, # Disables positional arguments. Please provide arguments as keyword arguments. loss_names: List[str], max_stage_steps: Union[int, Callable], loss_weights: Optional[Sequence[float]] = None, loss_update_repeats: Optional[Sequence[int]] = None, teacher_forcing: Optional[LinearDecay] = None, offpolicy_component: Optional[OffPolicyPipelineComponent] = None, early_stopping_criterion: Optional[EarlyStoppingCriterion] = None, num_mini_batch: Optional[int] = None, update_repeats: Optional[int] = None, max_grad_norm: Optional[float] = None, num_steps: Optional[int] = None, gamma: Optional[float] = None, use_gae: Optional[bool] = None, gae_lambda: Optional[float] = None, advance_scene_rollout_period: Optional[int] = None, save_interval: Optional[int] = None, metric_accumulate_interval: Optional[int] = None, ): self._update_repeats: Optional[int] = None # Populate TrainingSettings members super().__init__(**prepare_locals_for_super(locals())) self.loss_names = loss_names self.max_stage_steps = max_stage_steps self.loss_weights = loss_weights self.loss_update_repeats = loss_update_repeats assert self.loss_weights is None or len(self.loss_weights) == len( self.loss_names ) assert self.loss_update_repeats is None or ( len(self.loss_update_repeats) == len(self.loss_names) and self._update_repeats is None ) self.teacher_forcing = teacher_forcing self.offpolicy_component = offpolicy_component self.early_stopping_criterion = early_stopping_criterion self.steps_taken_in_stage: int = 0 self.rollout_count = 0 self.early_stopping_criterion_met = False self.named_losses: Optional[Dict[str, AbstractActorCriticLoss]] = None self._named_loss_weights: Optional[Dict[str, float]] = None self._named_loss_update_repeats: Optional[Dict[str, float]] = None self.offpolicy_memory = Memory() self.offpolicy_epochs: Optional[int] = None self.offpolicy_named_losses: Optional[Dict[str, AbstractOffPolicyLoss]] = None self._offpolicy_named_loss_weights: Optional[Dict[str, float]] = None self.offpolicy_steps_taken_in_stage: int = 0
def __init__(self, nactions: int, uuid: str = "expert_policy", expert_args: Optional[Dict[str, Any]] = None, **kwargs: Any) -> None: self.nactions = nactions self.expert_args: Dict[str, Any] = expert_args or {} super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, named_losses: Dict[str, Union[Loss, Builder[Loss]]], pipeline_stages: List[PipelineStage], optimizer_builder: Builder[optim.Optimizer], # type: ignore num_mini_batch: int, update_repeats: Optional[int], max_grad_norm: float, num_steps: int, gamma: float, use_gae: bool, gae_lambda: float, advance_scene_rollout_period: Optional[int], save_interval: Optional[int], metric_accumulate_interval: int, should_log: bool = True, lr_scheduler_builder: Optional[Builder[optim.lr_scheduler._LRScheduler]] = None, # type: ignore ): """Initializer. See class docstring for parameter definitions. """ all_vars = prepare_locals_for_super(locals()) # Populate TrainingSettings members super().__init__(**all_vars) self.optimizer_builder = optimizer_builder self.lr_scheduler_builder = lr_scheduler_builder self.named_losses = named_losses self.should_log = should_log self.pipeline_stages = pipeline_stages if len(self.pipeline_stages) > len(set(id(ps) for ps in pipeline_stages)): raise RuntimeError( "Duplicate `PipelineStage` object instances found in the pipeline stages input" " to `TrainingPipeline`. `PipelineStage` objects are not immutable, if you'd" " like to have multiple pipeline stages of the same type, please instantiate" " multiple separate instances." ) self._current_stage: Optional[PipelineStage] = None for sit, stage in enumerate(self.pipeline_stages): # Forward all global `TrainingSettings` to all `PipelineStage`s unless overridden: for var in _TRAINING_SETTINGS_NAMES: if getattr(stage, var) is None: setattr(stage, var, getattr(self, var)) assert ( stage.num_steps <= self.num_steps ), f"Stage {sit} has `num_steps` {stage.num_steps} > {self.num_steps} in pipeline." self.rollout_count = 0 self.off_policy_epochs = None self._refresh_current_stage(force_stage_search_from_start=True)
def __init__(self, uuid="agent_pose"): observation_space = gym.spaces.Box( low=-360, high=360, shape=(6,), dtype=np.float32, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, uuid: str = "human_poses", use_gesture: bool = True, **kwargs: Any): self.use_gesture = use_gesture observation_space = self._get_observation_space() super().__init__(**prepare_locals_for_super(locals())) return
def __init__( self, action_space: Optional[Union[gym.Space, int]] = None, uuid: str = "expert_policy", expert_args: Optional[Dict[str, Any]] = None, nactions: Optional[int] = None, use_dict_as_groups: bool = True, **kwargs: Any, ) -> None: super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, action_space: Optional[Union[gym.Space, int]] = None, uuid: str = "expert_sensor_type_uuid", expert_args: Optional[Dict[str, Any]] = None, nactions: Optional[int] = None, use_dict_as_groups: bool = True, **kwargs: Any, ) -> None: """Initialize an `ExpertSensor`. # Parameters action_space : The action space of the agent. This is necessary in order for this sensor to know what its output observation space is. uuid : A string specifying the unique ID of this sensor. expert_args : This sensor obtains an expert action from the task by calling the `query_expert` method of the task. `expert_args` are any keyword arguments that should be passed to the `query_expert` method when called. nactions : [DEPRECATED] The number of actions available to the agent, corresponds to an `action_space` of `gym.spaces.Discrete(nactions)`. use_dict_as_groups : Whether to use the top-level action_space of type `gym.spaces.Dict` as action groups. """ if isinstance(action_space, int): action_space = gym.spaces.Discrete(action_space) elif action_space is None: assert ( nactions is not None ), "One of `action_space` or `nactions` must be not `None`." get_logger().warning( "The `nactions` parameter to `AbstractExpertSensor` is deprecated and will be removed, please use" " the `action_space` parameter instead." ) action_space = gym.spaces.Discrete(nactions) self.action_space = action_space self.use_groups = ( isinstance(action_space, gym.spaces.Dict) and use_dict_as_groups ) self.group_spaces = ( self.action_space if self.use_groups else OrderedDict([(self._NO_GROUPS_LABEL, self.action_space,)]) ) self.expert_args: Dict[str, Any] = expert_args or {} assert ( "expert_sensor_group_name" not in self.expert_args ), "`expert_sensor_group_name` is reserved for `AbstractExpertSensor`" observation_space = self._get_observation_space() super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, height: Optional[int] = None, width: Optional[int] = None, uuid="frame"): observation_space = gym.spaces.Box( low=0, high=1, shape=(height, width, 3), dtype=np.float64, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, objectTypes, uuid="object_action_mask"): self.objectTypes = objectTypes observation_space = gym.spaces.Box( low=0, high=1, shape=(len(objectTypes), 1), dtype=np.float32, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, input_uuids: List[str], output_uuid: str, input_height: int, input_width: int, max_dets: int, detector_spatial_res: int, detector_thres: float, device: Optional[torch.device] = None, device_ids: Optional[List[torch.device]] = None, **kwargs: Any, ): self.input_height = input_height self.input_width = input_width self.max_dets = max_dets self.detector_spatial_res = detector_spatial_res self.detector_thres = detector_thres self.device = torch.device("cpu") if device is None else device self.device_ids = device_ids or cast( List[torch.device], list(range(torch.cuda.device_count()))) self.frcnn: BatchedFasterRCNN = BatchedFasterRCNN( thres=self.detector_thres, maxdets=self.max_dets, res=self.detector_spatial_res, ) spaces: OrderedDict[str, gym.Space] = OrderedDict() shape = (self.max_dets, self.detector_spatial_res, self.detector_spatial_res) spaces["frcnn_classes"] = gym.spaces.Box( low=0, # 0 is bg high=len(self.COCO_INSTANCE_CATEGORY_NAMES) - 1, shape=shape, dtype=np.int64, ) shape = ( self.max_dets * 5, self.detector_spatial_res, self.detector_spatial_res, ) spaces["frcnn_boxes"] = gym.spaces.Box(low=-np.inf, high=np.inf, shape=shape) assert ( len(input_uuids) == 1 ), "fasterrcnn preprocessor can only consume one observation type" observation_space = SpaceDict(spaces=spaces) super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, uuid: str = "gestures", add_intervention: bool = False, use_gesture: bool = True, **kwargs: Any): self.add_intervention = add_intervention self.use_gesture = use_gesture observation_space = self._get_observation_space() super().__init__(**prepare_locals_for_super(locals())) return
def __init__(self, objectTypes, uuid="class_segmentation"): self.objectTypes = objectTypes self.sorted_objectTypes = sorted(list(objectTypes)) observation_space = gym.spaces.Box( low=-10, high=10, shape=(len(objectTypes), 8, 3), dtype=np.float32, ) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, x_display: Optional[str] = None, docker_enabled: bool = False, local_thor_build: Optional[str] = None, visibility_distance: float = VISIBILITY_DISTANCE, fov: float = FOV, player_screen_width: int = 224, player_screen_height: int = 224, quality: str = "Very Low", restrict_to_initially_reachable_points: bool = False, make_agents_visible: bool = True, object_open_speed: float = 1.0, simplify_physics: bool = False, verbose: bool = False, env_args=None, ) -> None: """Initializer. # Parameters x_display : The x display into which to launch ai2thor (possibly necessarily if you are running on a server without an attached display). docker_enabled : Whether or not to run thor in a docker container (useful on a server without an attached display so that you don't have to start an x display). local_thor_build : The path to a local build of ai2thor. This is probably not necessary for your use case and can be safely ignored. visibility_distance : The distance (in meters) at which objects, in the viewport of the agent, are considered visible by ai2thor and will have their "visible" flag be set to `True` in the metadata. fov : The agent's camera's field of view. width : The width resolution (in pixels) of the images returned by ai2thor. height : The height resolution (in pixels) of the images returned by ai2thor. quality : The quality at which to render. Possible quality settings can be found in `ai2thor._quality_settings.QUALITY_SETTINGS`. restrict_to_initially_reachable_points : Whether or not to restrict the agent to locations in ai2thor that were found to be (initially) reachable by the agent (i.e. reachable by the agent after resetting the scene). This can be useful if you want to ensure there are only a fixed set of locations where the agent can go. make_agents_visible : Whether or not the agent should be visible. Most noticable when there are multiple agents or when quality settings are high so that the agent casts a shadow. object_open_speed : How quickly objects should be opened. High speeds mean faster simulation but also mean that opening objects have a lot of kinetic energy and can, possibly, knock other objects away. simplify_physics : Whether or not to simplify physics when applicable. Currently this only simplies object interactions when opening drawers (when simplified, objects within a drawer do not slide around on their own when the drawer is opened or closed, instead they are effectively glued down). """ self._verbose = verbose self.env_args = env_args del verbose del env_args super(ManipulaTHOREnvironment, self).__init__(**prepare_locals_for_super(locals()))
def __init__(self, objectTypes, height: Optional[int] = None, width: Optional[int] = None, uuid="seg"): self.objectTypes = sorted(list(objectTypes)) observation_space = gym.spaces.Box( low=0, high=1, shape=(height, width, len(objectTypes)), dtype=np.float64, ) super().__init__(**prepare_locals_for_super(locals()))
def train_task_sampler_args( self, process_ind: int, total_processes: int, devices: Optional[List[int]] = None, seeds: Optional[List[int]] = None, deterministic_cudnn: bool = False, ) -> Dict[str, Any]: kwargs = super( ObjectNavRoboThorBaseConfig, self).train_task_sampler_args(**prepare_locals_for_super(locals())) if self.randomize_train_materials: kwargs["env_args"][ "commit_id"] = self.THOR_COMMIT_ID_FOR_RAND_MATERIALS return kwargs
def __init__( self, input_uuids: List[str], output_uuid: str, input_height: int, input_width: int, output_height: int, output_width: int, output_dims: int, pool: bool, torchvision_resnet_model: Callable[..., models.ResNet] = models.resnet18, device: Optional[torch.device] = None, device_ids: Optional[List[torch.device]] = None, **kwargs: Any ): def f(x, k): assert k in x, "{} must be set in ResNetPreprocessor".format(k) return x[k] def optf(x, k, default): return x[k] if k in x else default self.input_height = input_height self.input_width = input_width self.output_height = output_height self.output_width = output_width self.output_dims = output_dims self.pool = pool self.make_model = torchvision_resnet_model self.device = torch.device("cpu") if device is None else device self.device_ids = device_ids or cast( List[torch.device], list(range(torch.cuda.device_count())) ) self._resnet: Optional[ResNetEmbedder] = None low = -np.inf high = np.inf shape = (self.output_dims, self.output_height, self.output_width) assert ( len(input_uuids) == 1 ), "resnet preprocessor can only consume one observation type" observation_space = gym.spaces.Box(low=low, high=high, shape=shape) super().__init__(**prepare_locals_for_super(locals()))
def __init__(self, use_resnet_normalization: bool = False, mean: Optional[Union[np.ndarray, Sequence[float]]] = (0.485, 0.456, 0.406), stdev: Optional[Union[np.ndarray, Sequence[float]]] = (0.229, 0.224, 0.225), height: Optional[int] = None, width: Optional[int] = None, uuid: str = "rgb", output_shape: Optional[Tuple[int, ...]] = None, output_channels: int = 3, unnormalized_infimum: float = 0.0, unnormalized_supremum: float = 1.0, scale_first: bool = True, **kwargs: Any): """Initializer. # Parameters use_resnet_normalization : Whether to apply image normalization with the given `mean` and `stdev`. mean : The images will be normalized with the given mean if `use_resnet_normalization` is True (default `[0.485, 0.456, 0.406]`, i.e. the standard resnet normalization mean). stdev : The images will be normalized with the given standard deviation if `use_resnet_normalization` is True (default `[0.229, 0.224, 0.225]`, i.e. the standard resnet normalization standard deviation). height: If it's a non-negative integer and `width` is also non-negative integer, the image returned from the environment will be rescaled to have `height` rows and `width` columns using bilinear sampling. width: If it's a non-negative integer and `height` is also non-negative integer, the image returned from the environment will be rescaled to have `height` rows and `width` columns using bilinear sampling. uuid: The universally unique identifier for the sensor. output_shape: Optional observation space shape (alternative to `output_channels`). output_channels: Optional observation space number of channels (alternative to `output_shape`). unnormalized_infimum: Lower limit(s) for the observation space range. unnormalized_supremum: Upper limit(s) for the observation space range. scale_first: Whether to scale image before normalization (if needed). kwargs : Extra kwargs. Currently unused. """ if not use_resnet_normalization: mean, stdev = None, None if isinstance(mean, tuple): mean = np.array(mean, dtype=np.float32).reshape(1, 1, len(mean)) if isinstance(stdev, tuple): stdev = np.array(stdev, dtype=np.float32).reshape(1, 1, len(stdev)) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, action_space: gym.spaces.Discrete, observation_space: SpaceDict, num_objects: int, num_colors: int, num_states: int, object_embedding_dim: int = 8, hidden_size=512, num_layers=1, rnn_type="GRU", head_type: Callable[ ..., ActorCriticModel[CategoricalDistr] ] = LinearActorCritic, **kwargs, ): super().__init__(**prepare_locals_for_super(locals())) self._hidden_size = hidden_size agent_view_x, agent_view_y, view_channels = observation_space[ "minigrid_ego_image" ].shape self.actor_critic = RNNActorCritic( input_uuid=self.ac_key, action_space=action_space, observation_space=SpaceDict( { self.ac_key: gym.spaces.Box( low=np.float32(-1.0), high=np.float32(1.0), shape=( self.object_embedding_dim * agent_view_x * agent_view_y * view_channels, ), ) } ), hidden_size=hidden_size, num_layers=num_layers, rnn_type=rnn_type, head_type=head_type, ) self.memory_key = "rnn" self.train()
def __init__(self, use_normalization: bool = False, mean: Optional[Union[np.ndarray, float]] = 0.5, stdev: Optional[Union[np.ndarray, float]] = 0.25, height: Optional[int] = None, width: Optional[int] = None, uuid: str = "depth", output_shape: Optional[Tuple[int, ...]] = None, output_channels: int = 1, unnormalized_infimum: float = 0.0, unnormalized_supremum: float = 5.0, scale_first: bool = True, **kwargs: Any): """Initializer. # Parameters config : If `config["use_normalization"]` is `True` then the depth images will be normalized with mean 0.5 and standard deviation 0.25. If both `config["height"]` and `config["width"]` are non-negative integers then the depth image returned from the environment will be rescaled to have shape (config["height"], config["width"]) using bilinear sampling. use_normalization : Whether to apply image normalization with the given `mean` and `stdev`. mean : The images will be normalized with the given mean if `use_normalization` is True (default 0.5). stdev : The images will be normalized with the given standard deviation if `use_normalization` is True (default 0.25). height: If it's a non-negative integer and `width` is also non-negative integer, the image returned from the environment will be rescaled to have `height` rows and `width` columns using bilinear sampling. width: If it's a non-negative integer and `height` is also non-negative integer, the image returned from the environment will be rescaled to have `height` rows and `width` columns using bilinear sampling. uuid: The universally unique identifier for the sensor. output_shape: Optional observation space shape (alternative to `output_channels`). output_channels: Optional observation space number of channels (alternative to `output_shape`). unnormalized_infimum: Lower limit(s) for the observation space range. unnormalized_supremum: Upper limit(s) for the observation space range. scale_first: Whether to scale image before normalization (if needed). kwargs : Extra kwargs. Currently unused. """ if not use_normalization: mean, stdev = None, None if isinstance(mean, float): mean = np.array(mean, dtype=np.float32).reshape(1, 1) if isinstance(stdev, float): stdev = np.array(stdev, dtype=np.float32).reshape(1, 1) super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, use_resnet_normalization: bool = False, mean: Optional[np.ndarray] = np.array([[[0.485, 0.456, 0.406]]], dtype=np.float32), stdev: Optional[np.ndarray] = np.array([[[0.229, 0.224, 0.225]]], dtype=np.float32), height: Optional[int] = None, width: Optional[int] = None, uuid: str = "rgb", output_shape: Optional[Tuple[int, ...]] = None, output_channels: int = 3, unnormalized_infimum: float = 0.0, unnormalized_supremum: float = 1.0, scale_first: bool = True, **kwargs: Any): super().__init__(**prepare_locals_for_super(locals()))
def __init__( self, fov: float, vision_range_in_cm: int, map_size_in_cm: int, resolution_in_cm: int, map_range_sensor: Sensor, height_bins: Sequence[float] = (0.02, 2), ego_only: bool = True, uuid: str = "binned_pc_map", **kwargs: Any, ): self.fov = fov self.vision_range_in_cm = vision_range_in_cm self.map_size_in_cm = map_size_in_cm self.resolution_in_cm = resolution_in_cm self.height_bins = height_bins self.ego_only = ego_only self.binned_pc_map_builder = BinnedPointCloudMapBuilder( fov=fov, vision_range_in_cm=vision_range_in_cm, map_size_in_cm=map_size_in_cm, resolution_in_cm=resolution_in_cm, height_bins=height_bins, ) map_space = gym.spaces.Box( low=0, high=np.inf, shape=self.binned_pc_map_builder.binned_point_cloud_map.shape, dtype=np.float32, ) space_dict = { "egocentric_update": map_space, } if not ego_only: space_dict["allocentric_update"] = copy.deepcopy(map_space) space_dict["map"] = copy.deepcopy(map_space) observation_space = gym.spaces.Dict(space_dict) super().__init__(**prepare_locals_for_super(locals())) self.map_range_sensor = map_range_sensor