def _get_config(num_ghosts, maze_size): """Get environment config.""" ############################################################################ # Sprite initialization ############################################################################ # Agent agent_factors = dict(shape='circle', scale=0.05, c0=0.33, c1=1., c2=0.66) # Prey prey_factors = dict(shape='circle', scale=0.025, c0=0.2, c1=1., c2=1.) # Ghosts ghost_factors = dict(shape='circle', scale=0.05, mass=np.inf, c0=0., c1=1., c2=0.8) def state_initializer(): maze = maze_lib.generate_random_maze_matrix(size=maze_size, ambient_size=12) maze = maze_lib.Maze(np.flip(maze, axis=0)) walls = maze.to_sprites(c0=0., c1=0., c2=0.8) # Sample positions in maze grid of agent and ghosts n_ghosts = num_ghosts() points = maze.sample_distinct_open_points(1 + n_ghosts) positions = [maze.grid_side * (0.5 + np.array(x)) for x in points] # Agent agent_position = positions[0] agent = [ sprite.Sprite(x=agent_position[1], y=agent_position[0], **agent_factors) ] # ghosts ghosts = [] for i in range(n_ghosts): position = positions[i + 1] ghosts.append( sprite.Sprite(x=position[1], y=position[0], **ghost_factors)) # Place prey at every open maze location prey = [] open_maze_points = np.argwhere(maze.maze == 0) for p in open_maze_points: pos = maze.grid_side * (0.5 + np.array(p)) prey.append(sprite.Sprite(x=pos[1], y=pos[0], **prey_factors)) state = collections.OrderedDict([ ('walls', walls), ('prey', prey), ('ghosts', ghosts), ('agent', agent), ]) return state ############################################################################ # Physics ############################################################################ maze_physics = physics_lib.MazePhysics( maze_layer='walls', avatar_layers=('agent', 'prey', 'ghosts'), constant_speed=0.015, ) physics = physics_lib.Physics( (physics_lib.RandomMazeWalk(speed=0.015), ['ghosts']), updates_per_env_step=1, corrective_physics=[maze_physics], ) ############################################################################ # Task ############################################################################ ghost_task = tasks.ContactReward(-5, layers_0='agent', layers_1='ghosts', reset_steps_after_contact=0) prey_task = tasks.ContactReward(1, layers_0='agent', layers_1='prey') reset_task = tasks.Reset( condition=lambda state: len(state['prey']) == 0, steps_after_condition=5, ) task = tasks.CompositeTask(ghost_task, prey_task, reset_task, timeout_steps=1000) ############################################################################ # Action space ############################################################################ action_space = action_spaces.Grid( scaling_factor=0.015, action_layers='agent', control_velocity=True, momentum=0.5, # Value irrelevant, since maze_physics has constant speed ) ############################################################################ # Observer ############################################################################ observer = observers.PILRenderer( image_size=(256, 256), anti_aliasing=1, color_to_rgb='hsv_to_rgb', ) ############################################################################ # Game rules ############################################################################ def _unglue(s): s.mass = 1. def _unglue_condition(state): return not np.all(state['agent'][0].velocity == 0) unglue = game_rules.ConditionalRule( condition=_unglue_condition, rules=game_rules.ModifySprites(('prey', 'ghosts'), _unglue), ) vanish_on_contact = game_rules.VanishOnContact(vanishing_layer='prey', contacting_layer='agent') rules = (vanish_on_contact, unglue) ############################################################################ # Final config ############################################################################ config = { 'state_initializer': state_initializer, 'physics': physics, 'task': task, 'action_space': action_space, 'observers': { 'image': observer }, 'game_rules': rules, } return config
def get_config(num_targets): """Get environment config. Args: num_targets: Int. Number of targets. """ if num_targets == 0 or not isinstance(num_targets, int): raise ValueError( f'num_targets is {num_targets}, but must be a positive integer') ############################################################################ # State initialization ############################################################################ screen = sprite.Sprite(x=0.5, y=0.5, shape='square', scale=2., c0=0.6, c1=0.7, c2=0.7) target_factor_distrib = distribs.Product( [distribs.Continuous('c0', 0., 1.)], shape='circle', scale=0.085, c1=1., c2=1., ) cover_factors = dict(mass=0., shape='circle', scale=0.1, c0=0., c1=0., c2=0.5, opacity=0) def state_initializer(): """State initializer method to be fed into environment.""" # Get targets and covers sprite_positions = 0.5 + 0.35 * _get_polygon(num_targets, 0.7) target_factors = [ target_factor_distrib.sample() for _ in range(num_targets) ] targets = [ sprite.Sprite(x=pos[0], y=pos[1], **factors) for pos, factors in zip(sprite_positions, target_factors) ] covers = [ sprite.Sprite(x=pos[0], y=pos[1], **cover_factors) for pos in sprite_positions ] # Tag the cover metadata based on whether they are prey or not for i, s in enumerate(covers): if i == 0: s.metadata = {'prey': True} else: s.metadata = {'prey': False} # Make cue have the same factors as the first target, except slightly # smaller cue_factors = copy.deepcopy(target_factors[0]) cue_factors['scale'] = 0.7 * target_factors[0]['scale'] cue = sprite.Sprite(x=0.5, y=0.501, opacity=0, mass=np.inf, **cue_factors) agent = sprite.Sprite(x=0.5, y=0.5, shape='circle', scale=0.1, c0=0.4, c1=0., c2=1., mass=np.inf) annulus_verts = shapes.annulus_vertices(0.34, 0.36) annulus = sprite.Sprite(x=0.5, y=0.5, shape=annulus_verts, scale=1., c0=0., c1=0., c2=0.3) state = collections.OrderedDict([ ('annulus', [annulus]), ('targets', targets), ('covers', covers), ('agent', [agent]), ('cue', [cue]), ('screen', [screen]), ]) return state ################################################################################ # Physics ################################################################################ drag = (physics_lib.Drag(coeff_friction=0.25), ['agent', 'cue']) tether_covers = physics_lib.TetherZippedLayers(('targets', 'covers'), anchor=np.array([0.5, 0.5])) physics = physics_lib.Physics( drag, updates_per_env_step=1, corrective_physics=[tether_covers], ) ################################################################################ # Task ################################################################################ contact_task = tasks.ContactReward( reward_fn=lambda _, s: 1 if s.metadata['prey'] else -1, layers_0='agent', layers_1='covers', ) def _should_reset(state, meta_state): should_reset = (state['covers'][0].opacity == 0 and meta_state['phase'] == 'response') return should_reset reset_task = tasks.Reset( condition=_should_reset, steps_after_condition=15, ) task = tasks.CompositeTask(contact_task, reset_task, timeout_steps=800) ################################################################################ # Action Space ################################################################################ action_space = action_spaces.Joystick(scaling_factor=0.01, action_layers=['agent', 'cue']) ################################################################################ # Observer ################################################################################ _polygon_modifier = observers.polygon_modifiers.FirstPersonAgent( agent_layer='agent') observer = observers.PILRenderer( image_size=(64, 64), anti_aliasing=1, color_to_rgb='hsv_to_rgb', polygon_modifier=_polygon_modifier, ) ############################################################################ # Game rules ############################################################################ def _make_opaque(s): s.opacity = 255 def _make_transparent(s): s.opacity = 0 # Screen Phase screen_phase = gr.Phase(duration=1, name='screen') # Visible Phase disappear_screen = gr.ModifySprites('screen', _make_transparent) visible_phase = gr.Phase(one_time_rules=disappear_screen, duration=2, name='visible') # Motion Phase def _move(s): s.velocity = np.random.uniform(-0.25, 0.25, size=(2, )) cover_targets = gr.ModifySprites('covers', _make_opaque) begin_motion = BeginMotion(angle_vel_range=(0.1, 0.3)) motion_phase = gr.Phase( one_time_rules=[cover_targets, begin_motion], duration=100, name='motion', ) # Response Phase def _stop(s): s.angle_vel = 0. s.velocity = np.zeros(2) def _unglue(s): s.mass = 1. appear_cue = gr.ModifySprites('cue', _make_opaque) stop_targets = gr.ModifySprites(('targets', 'covers'), _stop) unglue_agent = gr.ModifySprites(('agent', 'cue'), _unglue) make_targets_discoverable = gr.ModifyOnContact( layers_0='agent', layers_1='covers', modifier_1=_make_transparent) response_phase = gr.Phase( one_time_rules=[appear_cue, stop_targets, unglue_agent], continual_rules=make_targets_discoverable, name='response', ) phase_sequence = gr.PhaseSequence( screen_phase, visible_phase, motion_phase, response_phase, meta_state_phase_name_key='phase', ) ############################################################################ # Final config ############################################################################ config = { 'state_initializer': state_initializer, 'physics': physics, 'task': task, 'action_space': action_space, 'observers': { 'image': observer }, 'game_rules': (phase_sequence, ), 'meta_state_initializer': lambda: { 'phase': '' } } return config
def _get_config(num_prey, num_predators): """Get environment config.""" ############################################################################ # Sprite initialization ############################################################################ # Agent agent_factors = distribs.Product( [distribs.Continuous('x', 0., 1.), distribs.Continuous('y', 0., 1.)], scale=0.08, c0=0, c1=255, c2=0, ) # Predators predator_factors = distribs.Product( [distribs.Continuous('x', 0., 1.), distribs.Continuous('y', 0., 1.), distribs.Continuous('x_vel', -0.02, 0.02), distribs.Continuous('y_vel', -0.02, 0.02),], scale=0.08, shape='circle', opacity=192, c0=255, c1=0, c2=0, ) # Prey prey_factors = distribs.Product( [distribs.Continuous('x', 0., 1.), distribs.Continuous('y', 0., 1.), distribs.Continuous('x_vel', -0.02, 0.02), distribs.Continuous('y_vel', -0.02, 0.02),], scale=0.08, shape='circle', opacity=192, c0=255, c1=255, c2=0, ) # Create callable initializer returning entire state predator_generator = sprite_generators.generate_sprites( predator_factors, num_sprites=num_predators) prey_generator = sprite_generators.generate_sprites( prey_factors, num_sprites=num_prey) def state_initializer(): """Callable returning state at every episode reset.""" agent = sprite.Sprite(**agent_factors.sample()) predators = predator_generator(without_overlapping=(agent,)) prey = prey_generator(without_overlapping=(agent,)) state = collections.OrderedDict([ ('prey', prey), ('predators', predators), ('agent', [agent]), ]) return state ############################################################################ # Physics ############################################################################ agent_friction_force = physics_lib.Drag(coeff_friction=0.25) random_force = physics_lib.RandomForce(max_force_magnitude=0.01) predator_attraction = physics_lib.DistanceForce( physics_lib.linear_force_fn(zero_intercept=-0.001, slope=0.0005)) prey_avoid = physics_lib.DistanceForce( physics_lib.linear_force_fn(zero_intercept=0.001, slope=-0.0005)) forces = ( (agent_friction_force, 'agent'), (random_force, ['predators', 'prey']), (predator_attraction, 'agent', 'predators'), (prey_avoid, 'agent', 'prey'), ) constant_speed = physics_lib.ConstantSpeed( layer_names=['prey', 'predators'], speed=0.015) physics = physics_lib.Physics( *forces, updates_per_env_step=10, corrective_physics=[constant_speed], ) ############################################################################ # Task ############################################################################ predator_task = tasks.ContactReward( -5, layers_0='agent', layers_1='predators', reset_steps_after_contact=0) prey_task = tasks.ContactReward(1, layers_0='agent', layers_1='prey') reset_task = tasks.Reset( condition=lambda state: len(state['prey']) == 0, steps_after_condition=5, ) task = tasks.CompositeTask( reset_task, predator_task, prey_task, timeout_steps=300) ############################################################################ # Action space ############################################################################ action_space = action_spaces.Joystick( scaling_factor=0.025, action_layers='agent', control_velocity=True) ############################################################################ # Observer ############################################################################ observer = observers.PILRenderer( image_size=(64, 64), anti_aliasing=1, polygon_modifier=polygon_modifiers.TorusGeometry( ['agent', 'predators', 'prey']), ) ############################################################################ # Game rules ############################################################################ prey_vanish = game_rules.VanishOnContact( vanishing_layer='prey', contacting_layer='agent') def _torus_position_wrap(s): s.position = np.remainder(s.position, 1) torus_position_wrap = game_rules.ModifySprites( ('agent', 'predators', 'prey'), _torus_position_wrap) rules = (prey_vanish, torus_position_wrap) ############################################################################ # Final config ############################################################################ config = { 'state_initializer': state_initializer, 'physics': physics, 'task': task, 'action_space': action_space, 'observers': {'image': observer}, 'game_rules': rules, } return config
def get_config(_): """Get environment config.""" ############################################################################ # Sprite initialization ############################################################################ # Agents agent_factors = distribs.Product( [distribs.Continuous('x', 0., 1.), distribs.Continuous('y', 0.35, 0.65)], shape='circle', scale=0.1, c1=1., c2=0.7, ) agent_0_factors = distribs.Product([agent_factors], c0=0.2) agent_1_factors = distribs.Product([agent_factors], c0=0.1) agent_2_factors = distribs.Product([agent_factors], c0=0.) # Walls walls = shapes.border_walls(visible_thickness=0.05, c0=0., c1=0., c2=0.5) # Fountains fountain_factors = { 'shape': 'circle', 'scale': 0.05, 'c0': 0.6, 'c1': 1., 'c2': _BAD_VALUE} fountains_across = np.linspace(0.1, 0.9, 6) fountains_up = np.linspace(0.75, 0.9, 2) fountains_grid_x, fountains_grid_y = np.meshgrid(fountains_across, fountains_up) fountains_positions = zip(np.ravel(fountains_grid_x), np.ravel(fountains_grid_y)) fountain_sprites = [ sprite.Sprite(x=x, y=y, **fountain_factors) for (x, y) in fountains_positions ] # Fruits fruit_factors = { 'shape': 'circle', 'scale': 0.05, 'c0': 0.3, 'c1': 1., 'c2': _BAD_VALUE} fruits_across = np.linspace(0.1, 0.9, 6) fruits_up = np.linspace(0.1, 0.25, 2) fruits_grid_x, fruits_grid_y = np.meshgrid(fruits_across, fruits_up) fruits_positions = zip(np.ravel(fruits_grid_x), np.ravel(fruits_grid_y)) fruit_sprites = [ sprite.Sprite(x=x, y=y, **fruit_factors) for (x, y) in fruits_positions ] # Create callable initializer returning entire state agent_0_generator = sprite_generators.generate_sprites( agent_0_factors, num_sprites=1) agent_1_generator = sprite_generators.generate_sprites( agent_1_factors, num_sprites=1) agent_2_generator = sprite_generators.generate_sprites( agent_2_factors, num_sprites=1) def state_initializer(): agent_0 = agent_0_generator(without_overlapping=walls) agent_1 = agent_1_generator(without_overlapping=walls) agent_2 = agent_2_generator(without_overlapping=walls) state = collections.OrderedDict([ ('walls', walls), ('fountains', fountain_sprites), ('fruits', fruit_sprites), ('agent_2', agent_2), ('agent_1', agent_1), ('agent_0', agent_0), ]) return state ############################################################################ # Physics ############################################################################ agent_friction_force = physics_lib.Drag(coeff_friction=0.25) asymmetric_collision = physics_lib.Collision( elasticity=0.25, symmetric=False) forces = ( (agent_friction_force, ['agent_0', 'agent_1', 'agent_2']), (asymmetric_collision, ['agent_0', 'agent_1', 'agent_2'], 'walls'), ) physics = physics_lib.Physics(*forces, updates_per_env_step=5) ############################################################################ # Task ############################################################################ task = tasks.ContactReward( 1, layers_0='agent_0', layers_1='fruits', condition=lambda s_0, s_1: s_1.c2 > _VALUE_THRESHOLD, ) ############################################################################ # Action space ############################################################################ action_space = action_spaces.Composite( agent_0=action_spaces.Joystick( scaling_factor=0.005, action_layers='agent_0'), agent_1=action_spaces.Joystick( scaling_factor=0.005, action_layers='agent_1'), agent_2=action_spaces.Joystick( scaling_factor=0.005, action_layers='agent_2'), ) ############################################################################ # Observer ############################################################################ image_observer = observers.PILRenderer( image_size=(64, 64), anti_aliasing=1, color_to_rgb='hsv_to_rgb', ) raw_state_observer = observers.RawState() # needed by hand-crafted agents ############################################################################ # Game rules ############################################################################ def _spoil_fruit(sprite): sprite.c2 = _BAD_VALUE def _ripen_fruit(sprite): sprite.c2 = _GOOD_VALUE def _poison_fountain(sprite): sprite.c2 = _BAD_VALUE def _clean_fountain(sprite): sprite.c2 = _GOOD_VALUE def agents_contacting_layer(state, layer, value): n_contact = 0 for s in state[layer]: if s.c2 != value: continue n_contact += ( s.overlaps_sprite(state['agent_0'][0]) or s.overlaps_sprite(state['agent_1'][0]) or s.overlaps_sprite(state['agent_2'][0]) ) return n_contact poison_fountains = game_rules.ModifySprites( layers='fountains', modifier=_poison_fountain, sample_one=True, filter_fn=lambda s: s.c2 > _VALUE_THRESHOLD) poison_fountains = game_rules.ConditionalRule( condition=lambda s: agents_contacting_layer(s, 'fruits', _GOOD_VALUE), rules=poison_fountains, ) ripen_fruits = game_rules.ModifySprites( layers='fruits', modifier=_ripen_fruit, sample_one=True, filter_fn=lambda s: s.c2 < _VALUE_THRESHOLD) ripen_fruits = game_rules.ConditionalRule( condition=lambda s: agents_contacting_layer(s, 'fountains', _BAD_VALUE), rules=ripen_fruits, ) spoil_fruits = game_rules.ModifyOnContact( layers_0='fruits', layers_1=('agent_0', 'agent_1', 'agent_2'), modifier_0=_spoil_fruit, filter_0=lambda s: s.c2 > _VALUE_THRESHOLD) clean_fountains = game_rules.ModifyOnContact( layers_0='fountains', layers_1=('agent_0', 'agent_1', 'agent_2'), modifier_0=_clean_fountain, filter_0=lambda s: s.c2 < _VALUE_THRESHOLD) rules = (poison_fountains, spoil_fruits, ripen_fruits, clean_fountains) ############################################################################ # Final config ############################################################################ config = { 'state_initializer': state_initializer, 'physics': physics, 'task': task, 'action_space': action_space, 'observers': {'image': image_observer, 'state': raw_state_observer}, 'game_rules': rules, } return config
def get_config(num_targets): """Get environment config. Args: num_targets: Int. Number of targets. """ ############################################################################ # Sprite initialization ############################################################################ # Target circles target_factors = distribs.Product( [ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), RadialVelocity(speed=0.01), ], scale=0.1, shape='circle', c0=0., c1=0., c2=0.9, ) # Target bars bar_factors = dict(scale=0.1, shape='square', aspect_ratio=0.3, c0=0., c1=0., c2=0.2) # Walls bottom_wall = [[-1, 0], [2, 0], [2, -1], [-1, -1]] top_wall = [[-1, 1], [2, 1], [2, 2], [-1, 2]] left_wall = [[0, -1], [0, 4], [-1, 4], [-1, -1]] right_wall = [[1, -1], [1, 4], [2, 4], [2, -1]] walls = [ sprite.Sprite(shape=np.array(v), x=0, y=0, c0=0., c1=0., c2=0.5) for v in [bottom_wall, top_wall, left_wall, right_wall] ] # Occluder occluder_factors = dict(x=0.5, y=0.5, c0=0.6, c1=0.25, c2=0.5, opacity=0) # Cross shape for agent and fixation cross cross_shape = 0.1 * np.array([[-5, 1], [-1, 1], [-1, 5], [1, 5], [1, 1], [5, 1], [5, -1], [1, -1], [1, -5], [-1, -5], [-1, -1], [-5, -1]]) def state_initializer(): fixation = sprite.Sprite(x=0.5, y=0.5, shape=cross_shape, scale=0.1, c0=0., c1=0., c2=0.) screen = sprite.Sprite(x=0.5, y=0.5, shape='square', scale=2., c0=0., c1=0., c2=1.) agent = sprite.Sprite(x=0.5, y=0.5, scale=0.04, shape=cross_shape, c0=0.33, c1=1., c2=1.) occluder_shape = shapes.annulus_vertices(0.13, 2.) occluder = sprite.Sprite(shape=occluder_shape, **occluder_factors) targets = [ sprite.Sprite(**target_factors.sample()) for _ in range(num_targets) ] bar_angles = 0.5 * np.pi * np.random.binomial(1, 0.5, (num_targets)) bars = [ sprite.Sprite(x=s.x, y=s.y, x_vel=s.x_vel, y_vel=s.y_vel, angle=angle, **bar_factors) for s, angle in zip(targets, bar_angles) ] state = collections.OrderedDict([ ('walls', walls), ('targets', targets), ('bars', bars), ('occluder', [occluder]), ('screen', [screen]), ('fixation', [fixation]), ('agent', [agent]), ]) return state ############################################################################ # Physics ############################################################################ elastic_collision = physics_lib.Collision(elasticity=1., symmetric=False, update_angle_vel=False) tether = physics_lib.TetherZippedLayers(layer_names=('targets', 'bars'), update_angle_vel=False) physics = physics_lib.Physics( (elastic_collision, 'targets', 'walls'), updates_per_env_step=10, corrective_physics=[tether], ) ############################################################################ # Task ############################################################################ def _reward_condition(_, meta_state): return meta_state['phase'] == 'reward' task = tasks.Reset( condition=_reward_condition, reward_fn=lambda _: 1, steps_after_condition=10, ) ############################################################################ # Action space ############################################################################ action_space = action_spaces.SetPosition(action_layers=('agent', 'occluder')) ############################################################################ # Observer ############################################################################ observer = observers.PILRenderer( image_size=(64, 64), anti_aliasing=1, color_to_rgb=observers.color_maps.hsv_to_rgb, ) ############################################################################ # Game rules ############################################################################ # Fixation phase fixation_rule = gr.Fixation('agent', 'fixation', _FIXATION_THRESHOLD, 'fixation_duration') def _should_end_fixation(_, meta_state): return meta_state['fixation_duration'] >= 15 fixation_phase = gr.Phase( continual_rules=fixation_rule, end_condition=_should_end_fixation, name='fixation', ) # Visible Phase vanish_fixation = gr.VanishByFilter('fixation', lambda _: True) vanish_screen = gr.VanishByFilter('screen', lambda _: True) visible_phase = gr.Phase( one_time_rules=[vanish_fixation, vanish_screen], duration=5, name='visible', ) # Tracking Phase def _make_opaque(s): s.opacity = 255 appear_occluder = gr.ModifySprites('occluder', _make_opaque) tracking_phase = gr.Phase( one_time_rules=appear_occluder, duration=lambda: np.random.randint(40, 80), name='tracking', ) # Change Phase fixation_response_rule = gr.Fixation('agent', 'targets', _FIXATION_THRESHOLD, 'response_duration') def _should_end_change(_, meta_state): return meta_state['response_duration'] >= 30 change_phase = gr.Phase( one_time_rules=ChangeTargetFeature(), continual_rules=fixation_response_rule, name='change', end_condition=_should_end_change, ) # Reward Phase def _make_transparent(s): s.opacity = 0 disappear_occluder = gr.ModifySprites('occluder', _make_transparent) def _glue(s): s.velocity = np.zeros(2) glue_targets = gr.ModifySprites(('targets', 'bars'), _glue) reward_phase = gr.Phase( one_time_rules=(disappear_occluder, glue_targets), name='reward', ) phase_sequence = gr.PhaseSequence( fixation_phase, visible_phase, tracking_phase, change_phase, reward_phase, meta_state_phase_name_key='phase', ) ############################################################################ # Final config ############################################################################ config = { 'state_initializer': state_initializer, 'physics': physics, 'task': task, 'action_space': action_space, 'observers': { 'image': observer, 'state': observers.RawState() }, 'game_rules': (phase_sequence, ), 'meta_state_initializer': lambda: { 'phase': '' }, } return config