def __init__(self, game_id, player_name, is_not_tcp): self.game_id = game_id self.player_name = player_name self.is_my_turn = False self.winner_status = GameWinnerStatus.NoWinner self.last_turn_illegal = False self.action_options = [] self.winning_points_dim = np.zeros(shape=(9, 9), dtype=int) # join_game(self.game_id, self.player_name) if not is_not_tcp: self.tcp = TCP(game_id, player_name, self.on_recieved) self.wait_for_my_turn() self.action_space = spaces.Discrete(Global.num_of_actions) self.observation_space = spaces.Tuple(( spaces.MultiBinary([9, 9]), spaces.MultiBinary([9, 9]), spaces.MultiBinary([9, 9]), spaces.MultiBinary([9, 9]), spaces.MultiBinary([9, 9]) )) self.seed()
def __init__(self, agent_ids): self.round = 0 self.running = False self.agents = {} self.agents_last_obs = {} self.phase = 0 self.observation_space = spaces.Tuple( (spaces.Box(low=0, high=1, shape=(15, 15, 9)), spaces.Box(low=0, high=1, shape=(4, )), spaces.MultiBinary(3), spaces.Box(low=0, high=1, shape=(1, )), spaces.MultiBinary(len(self.available_actions)))) # spaces.Dict({'walls': spaces.MultiBinary(tiles), # 'free': spaces.MultiBinary(tiles), # 'crates': spaces.MultiBinary(tiles), # 'player': spaces.MultiBinary(tiles), # 'opponents': spaces.MultiBinary(tiles), # 'coins': spaces.MultiBinary(tiles), # 'bombs': spaces.Box(low=0, high=4, shape=(17, 17)), # 'explosions': spaces.Box(low=0, high=2, shape=(17, 17)), # 'scores' : spaces.Box(low=0, high=1, shape=(4,)), # 'current_round': spaces.Box(low=0, high=1, shape=(1,)) # }) # spaces.Box(low=0, high=4, shape=(17,17,8)) self.action_space = spaces.Discrete(6) for i in agent_ids: #agent_id = f'agent_{i}' # _{uuid.uuid1()}' self.agents[i] = Agent(i) self.new_round()
def __init__(self, n_bits=10, continuous=False, max_steps=None): super(BitFlippingEnv, self).__init__() # The achieved goal is determined by the current state # here, it is a special where they are equal self.observation_space = spaces.Dict({ 'observation': spaces.MultiBinary(n_bits), 'achieved_goal': spaces.MultiBinary(n_bits), 'desired_goal': spaces.MultiBinary(n_bits) }) if continuous: self.action_space = spaces.Box(-1, 1, shape=(n_bits, ), dtype=np.float32) else: self.action_space = spaces.Discrete(n_bits) self.continuous = continuous self.state = None self.desired_goal = np.ones((n_bits, )) if max_steps is None: max_steps = n_bits self.max_steps = max_steps self.current_step = 0 self.reset()
def __init__(self, text, *, seed=None, goal: int = None): model = parse(text) self.seed(seed) if model.values == 'cost': raise ValueError('Unsupported `cost` values.') self.model = model self.discount = model.discount self.state_space = spaces.MultiBinary(len(model.states)) self.action_space = spaces.Discrete(len(model.actions)) self.observation_space = observation = spaces.MultiBinary( len(self.model.states)) self.goal = None self.reward_range = model.R.min(), model.R.max() self.rewards_dict = {r: i for i, r in enumerate(np.unique(model.R))} if model.start is None: self.start = np.full(self.state_space.n, 1 / self.state_space.n) else: self.start = model.start self.T = model.T.transpose(1, 0, 2).copy() # self.R = model.R.transpose(1, 0, 2, 3).copy() self.R = model.R.transpose(1, 0, 2).copy() if goal is None: raise NotImplementedError("Need a goal") self.goal = np.zeros(len(self.model.states)) self.goal[goal] = 1 #self.state = -1 self.state = np.zeros(len(model.states), dtype=np.int)
def __init__(self): # There shall be two teams to begin with self.nbTeamMembers = 5 self.observation_size = 7 # This is what the agents will be allowed to see each turn --> The observation space # Documentation hardly exists, # from reading the code I'll just align binary, event if that seems like a sub-optimal solution # self.observation_space = spaces.Box( # low=0, # high=1, # # //!!\\ Temporary fix : # # openAI baselines don't like multi dimensional input spaces so we're attempting 1d which will be hell to interpret. # # should revert asap # shape=( # self.observation_size # * self.observation_size # * self.nbTeamMembers # * 2 # * 4, # ), # dtype=np.int64, # ) self.observation_space = spaces.MultiBinary(self.observation_size * self.observation_size * self.nbTeamMembers * 2 * 4) # self.action_space = spaces.Box( # low=0, high=1, shape=(2 * self.nbTeamMembers * 5,), dtype=np.int64 # ) self.action_space = spaces.MultiBinary(2 * self.nbTeamMembers * 5) self.np_random = None self.seed() self.reset()
def __init__( self, size, max_episode_length, name, uav_observation_noise=0.3, target_observation_noise=0.5, listen_noise_reduction=0.1, reward_scale=1.): self.n = 2 self._grid_size = size self.max_episode_length = max_episode_length self.agents = [UAVAgent(i, i == 0) for i in range(self.n)] self.t = 0 self.reward_range = reward_scale self.num_targets = 1 self.random = np.random.RandomState() self._locations = [(None, None), (None, None)] # The target may move to any adjacent or diagonally adjacent location or stay still. # The UAV may move in any cardinal direction {N, E, S, W} or stay still and listen. self.action_space = [ spaces.Discrete(9), spaces.Discrete(5) ] self.observation_space = [ spaces.MultiBinary(2 * np.sum(size)), spaces.MultiBinary(2 * np.sum(size)) ] self.observation_noise = [ target_observation_noise, uav_observation_noise ] self._listen_noise_red = listen_noise_reduction self.name = name
def __init__(self, user_params=None): """Initializes the College Admissions environment with initial params. Args: user_params: Dict. Any params not passed will take default values in Params. Raise: ValueError: If provided params not as expected. """ # TODO(): make parameter handling consistent across environments. # Called env_params unlike in other environments because this environment # incorporates params with the default to get the comprehensive environment # params. env_params = Params() if user_params is not None: env_params = Params(**user_params) # The jury's action is a dict containing the threshold which specifies a 1D # threshold on scores above which applicants will be admitted and an epsilon # probability value, which specifies the probability value for an # epsilon greedy agent and is 0 by default. self.action_space = spaces.Dict({ "threshold": spaces.Box( low=env_params.score_params.min, high=env_params.score_params.max, dtype=np.float32, shape=(), ), "epsilon_prob": spaces.Box(low=0, high=1, dtype=np.float32, shape=()), }) # type: spaces.Space # The observations include test scores, [0, 1], eligibility of selected # applicants, ground truth for selected candidates and applicant group ids. self.observable_state_vars = { "test_scores_y": spaces.Box( low=env_params.score_params.min, high=env_params.score_params.max, dtype=np.float32, shape=(env_params.num_applicants, ), ), "selected_applicants": spaces.MultiBinary(env_params.num_applicants), "selected_ground_truth": spaces.MultiDiscrete([3] * env_params.num_applicants), "applicant_groups": spaces.MultiBinary(env_params.num_applicants), } # type: Dict[Text, spaces.Space] super(CollegeAdmissionsEnv, self).__init__(env_params) if env_params.gaming_control != np.inf and ( env_params.gaming_control > 1 or env_params.gaming_control < 0): raise ValueError("Gaming control needs to be in [0, 1]") if env_params.noise_dist not in ["gaussian", "beta"]: raise ValueError("Undefined noise distribution.") self._state_init()
def __init__(self, bits): self.action_space = spaces.Discrete(bits) self.max_steps = bits self.observation_space = spaces.MultiBinary(bits) self.goal_space = spaces.MultiBinary(bits) self.bits = bits self.state = torch.zeros((self.bits, )) self.goal = torch.zeros((self.bits, )) self.reset()
def get_space(): from gym import spaces return spaces.Dict( dict(UI=spaces.Box(low=0, high=1, dtype=np.float, shape=(SCREEN_H, SCREEN_W, 3)), permissions=spaces.MultiBinary(len(INTERESTED_PERMISSIONS)), receivers=spaces.MultiBinary(len(INTERESTED_BROADCASTS)), APIs=spaces.MultiBinary(len(INTERESTED_APIS))))
def observation_space(self) -> spaces.Dict: if self._observation_space is None: self._observation_space = spaces.Dict([ ('occupied', spaces.MultiBinary(28)), ('player_owned', spaces.MultiBinary(28)), ('piece_type', spaces.MultiDiscrete([3] * 28)), ('player_captures', spaces.MultiDiscrete([3, 3, 3])), ('opponent_captures', spaces.MultiDiscrete([3, 3, 3])), ]) return self._observation_space
def test_bernoulli_kl(): """ distribution test """ logits_0 = torch.from_numpy(np.random.randn(100, 8, 5)) logits_1 = torch.from_numpy(np.random.randn(100, 8, 5)) dist_0 = BernoulliProbabilityDistribution( logits=logits_0, action_space=spaces.MultiBinary(5)) dist_1 = BernoulliProbabilityDistribution( logits=logits_1, action_space=spaces.MultiBinary(5)) assert dist_0.kl(dist_1).numpy().ndim == 2 assert dist_0.kl(dist_1).numpy().shape == (100, 8)
def __init__(self, n_bits=8): self.n_actions = n_bits self.action_space = spaces.Discrete(n_bits) self.d_observations = n_bits self.d_goals = n_bits self.observation_space = spaces.Dict({ "observation": spaces.MultiBinary(n_bits), "desired_goal": spaces.MultiBinary(n_bits), "achieved_goal": spaces.MultiBinary(n_bits), }) self.max_episode_steps = n_bits
def _observationSpace(self): #### Observation vector ### X Y Z Q1 Q2 Q3 Q4 R P Y VX VY VZ WR WP WY P0 P1 P2 P3 obs_lower_bound = np.array([-np.inf, -np.inf, 0., -1., -1., -1., -1., -np.pi, -np.pi, -np.pi, -np.inf, -np.inf, -np.inf, -np.inf, -np.inf, -np.inf, 0., 0., 0., 0.]) obs_upper_bound = np.array([np.inf, np.inf, np.inf, 1., 1., 1., 1., np.pi, np.pi, np.pi, np.inf, np.inf, np.inf, np.inf, np.inf, np.inf, self.MAX_RPM, self.MAX_RPM, self.MAX_RPM, self.MAX_RPM]) return spaces.Dict({str(i): spaces.Dict({"state": spaces.Box(low=obs_lower_bound, high=obs_upper_bound, dtype=np.float32 ), "neighbors": spaces.MultiBinary(self.NUM_DRONES), "rgb": spaces.Box(low=0, high=255, shape=(self.IMG_RES[1], self.IMG_RES[0], 4), dtype=np.uint8 ), "dep": spaces.Box(low=.01, high=1000., shape=(self.IMG_RES[1], self.IMG_RES[0]), dtype=np.float32 ), "seg": spaces.Box(low=0, high=100, shape=(self.IMG_RES[1], self.IMG_RES[0]), dtype=np.int ) }) for i in range(self.NUM_DRONES)})
def action_space(self): action_space = copy.deepcopy(self.state_space) action_space["gripper_force"] = spaces.Box(low=0, high=self.MAX_FORCES, shape=(1, )) action_space["wait"] = spaces.MultiBinary(n=1) return action_space
def observation_space(self): """ Return observation space in gym box :return: """ obs = dict( # number of days passed day=spaces.Discrete(self.max_days), # idx is agent id_, value is boll for agent alive status_map=spaces.MultiBinary(self.num_players), # number in range number of phases [com night, night, com day, day] phase=spaces.Discrete(4), # targets is now a vector, having an element outputted from each agent targets=gym.spaces.Box(low=-1, high=self.num_players, shape=(self.num_players, ), dtype=np.int32), # own id own_id=gym.spaces.Discrete(self.num_players), ) # add signal if the required if self.signal_length > 0: # signal is a matrix of dimension [num_player, signal_range] signal = dict(signal=gym.spaces.Box(low=-1, high=self.signal_range - 1, shape=(self.num_players, self.signal_length), dtype=np.int32)) obs.update(signal) obs = gym.spaces.Dict(obs) return obs
def __init__(self,n=10,space_seed=0): self.n=n self.action_space = spaces.Discrete(self.n +1) #there is an option NOT to flip any bit( index = n) self.observation_space = spaces.MultiBinary(self.n) self.state_space = spaces.MultiBinary(self.n) self.reward_range = (-1,0) spaces.seed(space_seed) self.space_seed = space_seed self.initial_state = self.sample_state() self.goal = self.sample_state() self.state = self.initial_state self.envstepcount = 0 self.seed() self.reward_max = -np.sum(np.bitwise_xor(self.initial_state,self.goal))+1 if(np.array_equal(self.goal,self.initial_state)): self.reward_max = 0
def __init__(self, config): """ Args: puzzle_name: Name of the puzzle to run. Choices: "zigzag", "cross", "monolith", "stairs" """ self.config = config self.board = puzzles.maps[config.puzzle_name] self.map = self.board["map"] self.extract_map_features() self.action_space = spaces.Discrete(5) self.raw_observation_space = spaces.Dict({ "coords": spaces.Tuple(( spaces.Discrete(self.board_size[1]), spaces.Discrete(self.board_size[0]), )), "height": spaces.Discrete(self.max_height), "direction": spaces.Discrete(4), "light_idx": spaces.Discrete(self.num_lights), "lights_on": spaces.MultiBinary(self.num_lights), }) # Seed is not needed because the environment is deterministic self.set_reward_fn(*[float(x) for x in config.reward_fn.split(",")]) self.state = self.reset()
def __init__(self, *args, **kwargs): super(TestConverters, self).__init__(*args, **kwargs) self.space_d = spaces.Discrete(4) self.gym_out_d = 2 self.rf_out_d = [0, 0, 1, 0] self.space_c = spaces.Box(-1, 1, [2, 4]) self.gym_out_c = np.random.uniform(low=-1, high=1, size=(2, 4)) self.rf_out_c = self.gym_out_c self.space_b = spaces.MultiBinary(4) self.gym_out_b = [0, 1, 0, 1] self.rf_out_b = [[1, 0], [0, 1], [1, 0], [0, 1]] self.space_t = spaces.Tuple((self.space_d, self.space_c, self.space_b, spaces.Tuple( (self.space_d, self.space_c)))) self.gym_out_t = tuple([ self.gym_out_d, self.gym_out_c, self.gym_out_b, tuple([self.gym_out_d, self.gym_out_c]) ]) self.rf_out_t = tuple([ self.rf_out_d, self.rf_out_c, self.rf_out_b, tuple([self.rf_out_d, self.rf_out_c]) ])
def __init__(self, params=None): params = (self.default_param_builder() if params is None else params ) # type: lending_params.Params # The action space of the agent is Accept/Reject. self.action_space = spaces.Discrete(2) # Bank's cash is a scalar and cannot be negative. bank_cash_space = spaces.Box(low=0, high=params.max_cash, shape=(), dtype=np.float32) # Two-dimensional observation space describes each loan applicant. loan_applicant_space = spaces.Box( params.min_observation, params.max_observation, dtype=np.float32, shape=(params.applicant_distribution.dim, )) group_space = spaces.MultiBinary(params.num_groups) self.observable_state_vars = { 'bank_cash': bank_cash_space, 'applicant_features': loan_applicant_space, 'group': group_space } super(BaseLendingEnv, self).__init__(params) self._state_init()
def __init__(self, venv: VecEnv): super(ObsDictWrapper, self).__init__(venv, venv.observation_space, venv.action_space) self.venv = venv self.spaces = list(venv.observation_space.spaces.values()) # get dimensions of observation and goal if isinstance(self.spaces[0], spaces.Discrete): self.obs_dim = 1 self.goal_dim = 1 else: self.obs_dim = venv.observation_space.spaces["observation"].shape[0] self.goal_dim = venv.observation_space.spaces["achieved_goal"].shape[0] # new observation space with concatenated observation and (desired) goal # for the different types of spaces if isinstance(self.spaces[0], spaces.Box): low_values = np.concatenate( [venv.observation_space.spaces["observation"].low, venv.observation_space.spaces["desired_goal"].low] ) high_values = np.concatenate( [venv.observation_space.spaces["observation"].high, venv.observation_space.spaces["desired_goal"].high] ) self.observation_space = spaces.Box(low_values, high_values, dtype=np.float32) elif isinstance(self.spaces[0], spaces.MultiBinary): total_dim = self.obs_dim + self.goal_dim self.observation_space = spaces.MultiBinary(total_dim) elif isinstance(self.spaces[0], spaces.Discrete): dimensions = [venv.observation_space.spaces["observation"].n, venv.observation_space.spaces["desired_goal"].n] self.observation_space = spaces.MultiDiscrete(dimensions) else: raise NotImplementedError(f"{type(self.spaces[0])} space is not supported")
def __init__(self): DATAPATH = os.path.abspath("/home/pycrysfml/hklgen/examples/sxtal") observedFile = os.path.join(DATAPATH, r"prnio.int") infoFile = os.path.join(DATAPATH, r"prnio.cfl") #Read data self.spaceGroup, self.crystalCell, self.atomList = H.readInfo(infoFile) #Return wavelength, refList, sfs2, error, two-theta, and four-circle parameters wavelength, refList, sfs2, error = S.readIntFile(observedFile, kind="int", cell=self.crystalCell) self.wavelength = wavelength self.refList = refList self.sfs2 = sfs2 self.error = error self.tt = [ H.twoTheta(H.calcS(self.crystalCell, ref.hkl), wavelength) for ref in refList ] self.backg = None self.exclusions = [] self.observation_space = spaces.MultiBinary(len(self.refList)) self.action_space = spaces.Discrete(len(self.refList)) self.episodeNum = 0 self.reset()
def __init__(self, level): self.previous_level = -1 self.level = level self.game = DoomGame() self.loader = Loader() self.doom_dir = os.path.dirname(os.path.abspath(__file__)) self._mode = 'algo' # 'algo' or 'human' self.no_render = False # To disable double rendering in human mode self.viewer = None self.is_initialized = False # Indicates that reset() has been called self.curr_seed = 0 self.lock = (DoomLock()).get_lock() # self.action_space = spaces.Discrete(43) # used to be in the old code self.action_space = spaces.MultiBinary(NUM_ACTIONS) self.allowed_actions = list(range(NUM_ACTIONS)) self.screen_height = 120 self.screen_width = 160 self.screen_resolution = ScreenResolution.RES_160X120 self.observation_space = spaces.Box(low=0, high=255, shape=(self.screen_height, self.screen_width, 3), dtype=np.uint8) self.seed() self._configure()
def __init__(self, size=15): self.n_squares_height = size self.n_squares_width = size self.OBJECT_TO_IDX = { 'goal': 1, 'wall': 2, 'other_agents': 3, 'my_agent': 4 } self.action_space = spaces.Discrete(4) self.observation_space = spaces.MultiBinary( (len(self.OBJECT_TO_IDX), self.n_squares_height, self.n_squares_width)) self.seed() self.viewer = None self.state = None self.steps_beyond_done = None self.players = [] self.players_in_game = [] self.agent_cols = []
def get_spaces(self, n_historical_events): observation_space = spaces.MultiBinary(self.n_experts + 2 * n_historical_events) action_space = spaces.Discrete(4) return observation_space, action_space
def make_observation_space(self, obs_sample): """ make per agent observation space from a given sample compatible with original mpe and mpe_hierarchy """ if isinstance(obs_sample, np.ndarray): # for original mpe obs_dim = len(obs_sample) obs_space = spaces.Box(low=-np.inf, high=+np.inf, shape=(obs_dim, ), dtype=np.float32) elif isinstance(obs_sample, dict): # for mpe_hierarchy obs_space = {} for k, v in obs_sample.items(): if k == "masks": n = len(v) space = spaces.MultiBinary(n) elif k == "states": assert len(v) > 0 n, state_dim = len(v), len(v[0]) space = spaces.Tuple((spaces.Box(low=-np.inf, high=+np.inf, shape=(state_dim, ), dtype=np.float32) for _ in range(n))) obs_space[k] = space obs_space = spaces.Dict(spaces=obs_space) else: # default to an empty obs space obs_sapce = spaces.Box(low=-np.inf, high=+np.inf, shape=(1, ), dtype=np.float32) return obs_space
def _observationSpace(self): """Returns the observation space of the environment. Returns ------- dict[str, dict[str, ndarray]] A Dict with NUM_DRONES entries indexed by Id in string format, each a Dict in the form {Box(20,), MultiBinary(NUM_DRONES)}. """ #### Observation vector ### X Y Z Q1 Q2 Q3 Q4 R P Y VX VY VZ WX WY WZ P0 P1 P2 P3 obs_lower_bound = np.array([ -np.inf, -np.inf, 0., -1., -1., -1., -1., -np.pi, -np.pi, -np.pi, -np.inf, -np.inf, -np.inf, -np.inf, -np.inf, -np.inf, 0., 0., 0., 0. ]) obs_upper_bound = np.array([ np.inf, np.inf, np.inf, 1., 1., 1., 1., np.pi, np.pi, np.pi, np.inf, np.inf, np.inf, np.inf, np.inf, np.inf, self.MAX_RPM, self.MAX_RPM, self.MAX_RPM, self.MAX_RPM ]) return spaces.Dict({ str(i): spaces.Dict({ "state": spaces.Box(low=obs_lower_bound, high=obs_upper_bound, dtype=np.float32), "neighbors": spaces.MultiBinary(self.NUM_DRONES) }) for i in range(self.NUM_DRONES) })
def __init__(self, shape=(22, 10), possible_bricks=bricks.BRICKS): self.shape = shape self.height = shape[0] self.width = shape[1] self.bricks = possible_bricks self.n_bricks = len(self.bricks) self.brick_probabilities = [1. / self.n_bricks for b in self.bricks] self.brick_height = [b.shape.shape[0] for b in self.bricks] self.brick_vpad = [ max(self.brick_height) - h for h in self.brick_height ] self.max_brick_dim = max(max(b.shape.shape) for b in self.bricks) self.board_space = spaces.MultiBinary(self.shape) self.brick_space = spaces.Discrete(self.n_bricks) self.observation_space = spaces.Tuple( (self.board_space, self.brick_space)) self.dtype = self.board_space.sample().dtype self.seed() # Start the first game self.reset() self._action_space = None
def __init__(self, agent_conf, name, max_allowed_power): # action space specify which transition can be activated self.action_space = spaces.Discrete( len(EFLEXEnergyGeneratorAgentTransition)) # {0,1,...,n-1} # observation is a multi discrete specifying which state is activated self.observation_space = spaces.MultiBinary( len(EFLEXEnergyGeneratorAgentState) + 1) # reward_range self.reward_range = (float(-1.0), float(1.0)) # Simulation related variables. self.p_min = agent_conf['p_min'] self.p_max = agent_conf['p_max'] self.p_slope = agent_conf['p_slope'] self.name = name self.current_state = None self.np_random = None self.current_reward = 0.0 self.obs = None self.obs_pre = None self.max_allowed_power = max_allowed_power self.seed() self.reset() # Just need to initialize the relevant attributes self._configure() self.startStep = 0 self.currentStep = 0 self.last_power = 0
def __init__(self, width=4, height=4, object_coordinates=None): self.n_squares_height = width self.n_squares_width = height self.OBJECT_TO_IDX = { # objects will be coded by a 1 in the positions they occupy, and a 0 if absent, except for the arrows 'goal': 0, 'void': 1, 'agent': 2, 'coin': 3, 'thorns': 4, 'arrow': 5 # arrows will be represented by 0 if absent, # and one of [1,2,3,4] representing the direction in which to push the agent } self.action_space = spaces.Discrete(4) self.observation_space = spaces.MultiBinary( (len(self.OBJECT_TO_IDX), self.n_squares_height, self.n_squares_width)) self.seed() self.viewer = None self.state = None self.has_been_reset_before = False self.moved_into_wall = False self.done = False self.n_steps = None self.steps_beyond_done = None if object_coordinates is not None: self.setup(object_coordinates)
def car(): return SpaceDict({ "sensors": SpaceDict({ "position": spaces.Box(low=-100, high=100, shape=(3, )), "velocity": spaces.Box(low=-1, high=1, shape=(3, )), "front_cam": spaces.Tuple(( spaces.Box(low=0, high=1, shape=(10, 10, 3)), spaces.Box(low=0, high=1, shape=(10, 10, 3)), )), "rear_cam": spaces.Box(low=0, high=1, shape=(10, 10, 3)), }), "ext_controller": spaces.MultiDiscrete((5, 2, 2)), "inner_state": { "charge": spaces.Discrete(100), "system_checks": spaces.MultiBinary(10), "job_status": SpaceDict({ "task": spaces.Discrete(5), "progress": spaces.Box(low=0, high=100, shape=()), }), }, })