def preprocess(self, obs):
pov = obs['pov'].astype(np.float) / 255.0
item = np.concatenate([
flatten(self.observation_space['equipped_items'],
obs['equipped_items']),
flatten(self.observation_space['inventory'], obs['inventory'])
])
return pov, item
def test_flatten(base_space: gym.Space):
sparse_space = Sparse(base_space, sparsity=0.)
base_space.seed(123)
base_sample = base_space.sample()
flattened_base_sample = flatten(base_space, base_sample)
sparse_space.seed(123)
sparse_sample = sparse_space.sample()
flattened_sparse_sample = flatten(sparse_space, sparse_sample)
assert equals(flattened_base_sample, flattened_sparse_sample)
def _preprocess_transition(self, obs, act, next_obs):
if self.density_type == STATE_DENSITY:
return flatten(self.obs_space, obs)
elif self.density_type == STATE_ACTION_DENSITY:
return np.concatenate(
[flatten(self.obs_space, obs),
flatten(self.act_space, act)])
elif self.density_type == STATE_STATE_DENSITY:
return np.concatenate([
flatten(self.obs_space, obs),
flatten(self.obs_space, next_obs)
])
else:
raise ValueError(f"Unknown density type {self.density_type}")
def test_flatten(space, sample, expected_flattened_sample):
assert sample in space
flattened_sample = utils.flatten(space, sample)
assert flattened_sample.shape == expected_flattened_sample.shape
assert flattened_sample.dtype == expected_flattened_sample.dtype
assert np.all(flattened_sample == expected_flattened_sample)
def Step(self, request, context): # StepRequest
try:
# Get action space
action_space = envs.get_action_space_info(request.instanceId)
actions = Unserializer.unserializeAction(action_space,
request.actions)
# Returns 0 = obs_jsonable, 1 = reward, 2 = done, 3 = info in object (e.g. {'TimeLimit.truncated': True})
observation, reward, isDone, info = envs.step(
request.instanceId, actions, request.render)
# Get Observation Space Info (gym.spaces)
res_env = envs._lookup_env(request.instanceId)
res_osi = res_env.observation_space
# Flatten this so we can send over wire
observation = gym_utils.flatten(
res_osi, observation) # @todo: res_osi should be cached
# Encode Info (sometimes it can contain a bool)
info = ProtoUtil.json_object_to_proto_map(info)
res = api_v1.StepResponse(reward=reward,
isDone=isDone,
info=info,
observation=observation)
except:
print(sys.exc_info())
traceback.print_tb(sys.exc_info()[2])
raise
return res
def test_flat_space_contains_flat_points(space):
some_samples = [space.sample() for _ in range(10)]
flattened_samples = [utils.flatten(space, sample) for sample in some_samples]
flat_space = utils.flatten_space(space)
for i, flat_sample in enumerate(flattened_samples):
assert (
flat_sample in flat_space
), f"Expected sample #{i} {flat_sample} to be in {flat_space}"
def test_flat_space_contains_flat_points(space):
some_samples = [space.sample() for _ in range(10)]
flattened_samples = [
utils.flatten(space, sample) for sample in some_samples
]
flat_space = utils.flatten_space(space)
for i, flat_sample in enumerate(flattened_samples):
assert flat_sample in flat_space,\
'Expected sample #{} {} to be in {}'.format(i, flat_sample, flat_space)
def test_flatten_roundtripping(space):
some_samples = [space.sample() for _ in range(10)]
flattened_samples = [utils.flatten(space, sample) for sample in some_samples]
roundtripped_samples = [
utils.unflatten(space, sample) for sample in flattened_samples
]
for i, (original, roundtripped) in enumerate(
zip(some_samples, roundtripped_samples)
):
assert compare_nested(
original, roundtripped
), f"Expected sample #{i} {original} to equal {roundtripped}"
def Step(self, request, context): # StepRequest
print("[Server] Step")
# Unserialize Actions based on action_space
action = Unserializer.unserializeAction(self.action_space_info, request.actions)
# Take step
observation, reward, isDone, info = self.step(action, request.render)
# Flatten this so we can send over wire
observation = gym_utils.flatten(self.observation_space_info, observation) # @todo: res_osi should be cached
# Encode Info (sometimes it can contain a bool)
info = ProtoUtil.json_object_to_proto_map(info)
res = api_v1.StepResponse(reward=reward, isDone=isDone, info=info, observation=observation)
return res
def test_dtypes(original_space, expected_flattened_dtype):
flattened_space = utils.flatten_space(original_space)
original_sample = original_space.sample()
flattened_sample = utils.flatten(original_space, original_sample)
unflattened_sample = utils.unflatten(original_space, flattened_sample)
assert flattened_space.contains(
flattened_sample
), "Expected flattened_space to contain flattened_sample"
assert flattened_space.dtype == expected_flattened_dtype, "Expected flattened_space's dtype to equal " \
"{}".format(expected_flattened_dtype)
assert flattened_sample.dtype == flattened_space.dtype, "Expected flattened_space's dtype to equal " \
"flattened_sample's dtype "
compare_sample_types(original_space, original_sample, unflattened_sample)
def test_flatten_dim(space):
sample = utils.flatten(space, space.sample())
(single_dim,) = sample.shape
flatdim = utils.flatdim(space)
assert single_dim == flatdim, f"Expected {single_dim} to equal {flatdim}"
def map_raw_state_to_observation(observation_space, raw_game_state, player, opponent):
return flatten(observation_space, map_raw_state_to_state(raw_game_state, player, opponent))
def test_flatten_dim(space):
sample = utils.flatten(space, space.sample())
(single_dim, ) = sample.shape
flatdim = utils.flatdim(space)
assert single_dim == flatdim, "Expected {} to equal {}".format(
single_dim, flatdim)
def flatten_namedtuple_space_sample(space: NamedTupleSpace, x: NamedTuple):
if isinstance(x, Batch):
x = x.as_tuple()
return np.concatenate(
[flatten(s, x_part) for x_part, s in zip(x, space.spaces)])
def _get_agent_obs(self, agent, local_env):
return flatten(self.observation_space_n[0], self._draw_obs(agent, local_env))
