def test_filter():
# make an RGB observation smaller
transition = EnvResponse(next_state={'observation': np.ones([20, 30, 3])},
reward=0,
game_over=False)
rescale_filter = InputFilter()
rescale_filter.add_observation_filter(
'observation', 'rescale',
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([10, 20, 3]), high=255)))
result = rescale_filter.filter(transition)[0]
unfiltered_observation = transition.next_state['observation']
filtered_observation = result.next_state['observation']
# make sure the original observation is unchanged
assert unfiltered_observation.shape == (20, 30, 3)
# validate the shape of the filtered observation
assert filtered_observation.shape == (10, 20, 3)
assert np.all(filtered_observation == np.ones([10, 20, 3]))
# make a grayscale observation bigger
transition = EnvResponse(next_state={'observation': np.ones([20, 30])},
reward=0,
game_over=False)
rescale_filter = InputFilter()
rescale_filter.add_observation_filter(
'observation', 'rescale',
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([40, 60]), high=255)))
result = rescale_filter.filter(transition)[0]
filtered_observation = result.next_state['observation']
# validate the shape of the filtered observation
assert filtered_observation.shape == (40, 60)
assert np.all(filtered_observation == np.ones([40, 60]))
# rescale channels -> error
# with pytest.raises(ValueError):
# InputFilter(
# observation_filters=OrderedDict([('rescale',
# ObservationRescaleToSizeFilter(ImageObservationSpace(np.array([10, 20, 1]),
# high=255)
# ))]))
# TODO: validate input to filter
# different number of axes -> error
# env_response = EnvResponse(state={'observation': np.ones([20, 30, 3])}, reward=0, game_over=False)
# rescale_filter = ObservationRescaleToSizeFilter(ObservationSpace(np.array([10, 20]))
# )
# with pytest.raises(ValueError):
# result = rescale_filter.filter(transition)
# channels first -> error
with pytest.raises(ValueError):
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([3, 10, 20]), high=255))
def test_get_filtered_observation_space():
# error on wrong number of channels
with pytest.raises(ValueError):
observation_filters = InputFilter()
observation_filters.add_observation_filter(
'observation', 'rescale',
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([5, 10, 5]), high=255),
RescaleInterpolationType.BILINEAR))
# mismatch and wrong number of channels
rescale_filter = InputFilter()
rescale_filter.add_observation_filter(
'observation', 'rescale',
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([5, 10, 3]), high=255),
RescaleInterpolationType.BILINEAR))
observation_space = PlanarMapsObservationSpace(np.array([10, 20, 5]),
low=0,
high=255)
with pytest.raises(ValueError):
rescale_filter.get_filtered_observation_space('observation',
observation_space)
# error on wrong number of dimensions
observation_space = ObservationSpace(np.array([10, 20, 10, 3]), high=255)
with pytest.raises(ValueError):
rescale_filter.get_filtered_observation_space('observation',
observation_space)
# make sure the new observation space shape is calculated correctly
observation_space = ImageObservationSpace(np.array([10, 20, 3]), high=255)
filtered_observation_space = rescale_filter.get_filtered_observation_space(
'observation', observation_space)
assert np.all(filtered_observation_space.shape == np.array([5, 10, 3]))
# make sure the original observation space is unchanged
assert np.all(observation_space.shape == np.array([10, 20, 3]))
def test_filter_stacking():
# test that filter stacking works fine by taking as input a transition with:
# - an observation of shape 210x160,
# - a reward of 100
# filtering it by:
# - rescaling the observation to 110x84
# - cropping the observation to 84x84
# - clipping the reward to 1
# - stacking 4 observations to get 84x84x4
env_response = EnvResponse({'observation': np.ones([210, 160])}, reward=100, game_over=False)
filter1 = ObservationRescaleToSizeFilter(
output_observation_space=ImageObservationSpace(np.array([110, 84]), high=255),
)
filter2 = ObservationCropFilter(
crop_low=np.array([16, 0]),
crop_high=np.array([100, 84])
)
filter3 = RewardClippingFilter(
clipping_low=-1,
clipping_high=1
)
output_filter = ObservationStackingFilter(
stack_size=4,
stacking_axis=-1
)
input_filter = InputFilter(
observation_filters={
"observation": OrderedDict([
("filter1", filter1),
("filter2", filter2),
("output_filter", output_filter)
])},
reward_filters=OrderedDict([
("filter3", filter3)
])
)
result = input_filter.filter(env_response)[0]
observation = np.array(result.next_state['observation'])
assert observation.shape == (84, 84, 4)
assert np.all(observation == np.ones([84, 84, 4]))
assert result.reward == 1
gym_fetch_envs = ['reach', 'slide', 'push', 'pick_and_place']
fetch_v1 = {
e: "{}".format('Fetch' + lower_under_to_upper(e) + '-v1')
for e in gym_fetch_envs
}
"""
Atari Environment Components
"""
AtariInputFilter = InputFilter(is_a_reference_filter=True)
AtariInputFilter.add_reward_filter('clipping', RewardClippingFilter(-1.0, 1.0))
AtariInputFilter.add_observation_filter(
'observation',
'rescaling',
ObservationRescaleToSizeFilter(
ImageObservationSpace(
np.array([84, 84, 3]), #np.array([224, 224, 3]),
high=255)))
#AtariInputFilter.add_observation_filter('observation', 'to_grayscale', ObservationRGBToYFilter())
#AtariInputFilter.add_observation_filter('observation', 'to_uint8', ObservationToUInt8Filter(0, 255))
#AtariInputFilter.add_observation_filter('observation', 'stacking', ObservationStackingFilter(4))
AtariOutputFilter = NoOutputFilter()
class Atari(GymEnvironmentParameters):
def __init__(self, level=None):
super().__init__(level=level)
self.frame_skip = 4
self.max_over_num_frames = 2
self.random_initialization_steps = 30
self.default_input_filter = AtariInputFilter
self.default_output_filter = AtariOutputFilter
# agent_params.network_wrappers['main'].num_output_head_copies = 4 # follow lane, left, right, straight
agent_params.network_wrappers['main'].rescale_gradient_from_head_by_factor = [1, 1, 1, 1]
agent_params.network_wrappers['main'].loss_weights = [1, 1, 1, 1]
# TODO: there should be another head predicting the speed which is connected directly to the forward camera embedding
agent_params.network_wrappers['main'].batch_size = 120
agent_params.network_wrappers['main'].learning_rate = 0.0002
# crop and rescale the image + use only the forward speed measurement
agent_params.input_filter = InputFilter()
agent_params.input_filter.add_observation_filter('CameraRGB', 'cropping',
ObservationCropFilter(crop_low=np.array([115, 0, 0]),
crop_high=np.array([510, -1, -1])))
agent_params.input_filter.add_observation_filter('CameraRGB', 'rescale',
ObservationRescaleToSizeFilter(
ImageObservationSpace(np.array([88, 200, 3]), high=255)))
agent_params.input_filter.add_observation_filter('CameraRGB', 'to_uint8', ObservationToUInt8Filter(0, 255))
agent_params.input_filter.add_observation_filter(
'measurements', 'select_speed',
ObservationReductionBySubPartsNameFilter(
["forward_speed"], reduction_method=ObservationReductionBySubPartsNameFilter.ReductionMethod.Keep))
# no exploration is used
agent_params.exploration = AdditiveNoiseParameters()
agent_params.exploration.noise_percentage_schedule = ConstantSchedule(0)
agent_params.exploration.evaluation_noise_percentage = 0
# no playing during the training phase
agent_params.algorithm.num_consecutive_playing_steps = EnvironmentSteps(0)
# use the following command line to download and extract the CARLA dataset:
_SELECT_ALL = [0]
class StarcraftObservationType(Enum):
Features = 0
RGB = 1
StarcraftInputFilter = InputFilter(is_a_reference_filter=True)
StarcraftInputFilter.add_observation_filter('screen', 'move_axis',
ObservationMoveAxisFilter(0, -1))
StarcraftInputFilter.add_observation_filter(
'screen', 'rescaling',
ObservationRescaleToSizeFilter(
PlanarMapsObservationSpace(np.array([84, 84, 1]),
low=0,
high=255,
channels_axis=-1)))
StarcraftInputFilter.add_observation_filter('screen', 'to_uint8',
ObservationToUInt8Filter(0, 255))
StarcraftInputFilter.add_observation_filter('minimap', 'move_axis',
ObservationMoveAxisFilter(0, -1))
StarcraftInputFilter.add_observation_filter(
'minimap', 'rescaling',
ObservationRescaleToSizeFilter(
PlanarMapsObservationSpace(np.array([64, 64, 1]),
low=0,
high=255,
channels_axis=-1)))
StarcraftInputFilter.add_observation_filter('minimap', 'to_uint8',