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',