Module moog_demos.example_configs.parallelogram_catch

First-person shape catcher task with parallelogram arrangement of prey.

In this task the subject controls a green circlular agent with a joystick. The motion is first-person, so the agent is fixed at the center of the screen while everything else moves. There are four yellow prey sprites. These prey sprites are identical parallelograms, and they are spatially arranged in a parallelogram with the same aspect ratio. There is an annulus occluding all peripheral vision, i.e. never are two prey visible simultaneously.

The entire prey configuration may be drifting and rotating, depending on the level. See the get_config() function at the bottom of this file.

This forces the subject to make a hierarchical inference task. After seeing the first prey, there are four possible arrangements of the other prey. After finding the second prey, there are two possible arrangements of the remaining prey. After finding the third prey, the fourth prey's position is deterministic.

Functions

def get_config(level)

Expand source code

def get_config(level):
    """Get config dictionary of kwargs for environment constructor.
    
    Args:
        level: Int. Different values yield different velocities of the prey.
    """
    if level == 0:
        return _get_config(max_vel=0.)
    elif level == 1:
        return _get_config(max_vel=0.01)
    elif level == 2:
        return _get_config(max_vel=0.02)
    else:
        raise ValueError('Invalid level {}'.format(level))

Get config dictionary of kwargs for environment constructor.

Args

level

Int. Different values yield different velocities of the prey.

def get_parallelogram(min_axis_ratio=0.4)

Expand source code

def get_parallelogram(min_axis_ratio=0.4):
    """Get parallelogram vertices centered around 0 with maximum radius 1."""
    angles = np.pi * (np.array([0., 0.5, 1., 1.5]) + np.random.uniform(0, 2))
    vertices = np.stack((np.sin(angles), np.cos(angles)), axis=1)
    axis_ratio = np.random.uniform(min_axis_ratio, 1.)
    vertices *= np.array([[1.], [axis_ratio], [1.], [axis_ratio]])

    return vertices

Get parallelogram vertices centered around 0 with maximum radius 1.

def get_prey(centered_vertices, scale=1.0, max_vel=0.0, sprite_scale=0.1)

Expand source code

def get_prey(centered_vertices, scale=1., max_vel=0., sprite_scale=0.1):
    """Get prey sprites.

    Args:
        centered_vertices: Numpy array of shape [num_vertices, 2] containing
            vertex positions.
        scale: Re-scaling factor of centered_vertices for the global space.
        max_vel: Maximum velocity of the sprites.
        sprite_scale: Re-scaling factor of centered_vertices for the individual
            sprite shapes.
    """
    sprite_shape = sprite_scale * centered_vertices
    sprite_positions = scale * centered_vertices
    sprite_positions += np.array([0.5, 0.5]) - sprite_positions[0]

    # We sample each sprite's velocity independently so that the entire tethered
    # configuration may rotate
    prey = [
        sprite.Sprite(
            x=pos[0], y=pos[1], shape=sprite_shape, scale=1.,
            x_vel=np.random.uniform(-1 * max_vel, max_vel),
            y_vel=np.random.uniform(-1 * max_vel, max_vel),
            c0=0.2, c1=1., c2=1.)
        for pos in sprite_positions
    ]
    return prey

Get prey sprites.

Args

centered_vertices

Numpy array of shape [num_vertices, 2] containing vertex positions.

scale

Re-scaling factor of centered_vertices for the global space.

max_vel

Maximum velocity of the sprites.

sprite_scale

Re-scaling factor of centered_vertices for the individual sprite shapes.