def get_config(mode='train'): """Generate environment config. Args: mode: 'train' or 'test'. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ # Select clusters to use, and their c0 factor distribution. c0_clusters = [CLUSTERS_DISTS[cluster] for cluster in MODES[mode]] print('Clustering task: {}, #sprites: {}'.format(MODES[mode], NUM_SPRITES_PER_CLUSTER)) other_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['square', 'triangle', 'circle']), distribs.Discrete('scale', [0.13]), distribs.Continuous('c1', 0.3, 1.), distribs.Continuous('c2', 0.9, 1.), ]) # Generate the sprites to be used in this task, by combining Hue with the # other factors. sprite_factors = [ distribs.Product((other_factors, c0)) for c0 in c0_clusters ] # Convert to sprites, generating the appropriate number per cluster. sprite_gen_per_cluster = [ sprite_generators.generate_sprites(factors, num_sprites=NUM_SPRITES_PER_CLUSTER) for factors in sprite_factors ] # Concat clusters into single scene to generate. sprite_gen = sprite_generators.chain_generators(*sprite_gen_per_cluster) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) # Clustering task will define rewards task = tasks.Clustering(c0_clusters, terminate_bonus=0., reward_range=10., sparse_reward=True) config = { 'task': task, 'action_space': common.noisy_action_space(), 'renderers': common.renderers(), 'init_sprites': sprite_gen, 'max_episode_length': MAX_EPISODE_LENGTH, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def testKeys(self): d_0 = distribs.Product( (distribs.Continuous('x', 0, 2), distribs.Continuous('y', 0, 1))) d_1 = distribs.Product( (distribs.Continuous('x', 0, 1), distribs.Continuous('y', 0, 0.5))) d_2 = distribs.Continuous('x', 0.4, 0.6) distribs.Intersection((d_0, d_1)) with self.assertRaises(ValueError): distribs.Intersection((d_0, d_2))
def get_config(mode='train'): """Generate environment config. Args: mode: 'train' or 'test'. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ shared_factors = distribs.Product([ distribs.Discrete('shape', ['square', 'triangle', 'circle']), distribs.Discrete('scale', [0.13]), distribs.Continuous('c1', 0.3, 1.), distribs.Continuous('c2', 0.9, 1.), ]) target_hue = distribs.Continuous('c0', 0., 0.4) distractor_hue = distribs.Continuous('c0', 0.5, 0.9) target_factors = distribs.Product([ MODES_TARGET_POSITIONS[mode], target_hue, shared_factors, ]) distractor_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distractor_hue, shared_factors, ]) target_sprite_gen = sprite_generators.generate_sprites( target_factors, num_sprites=NUM_TARGETS) distractor_sprite_gen = sprite_generators.generate_sprites( distractor_factors, num_sprites=NUM_DISTRACTORS) sprite_gen = sprite_generators.chain_generators(target_sprite_gen, distractor_sprite_gen) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) task = tasks.FindGoalPosition(filter_distrib=target_hue, terminate_distance=TERMINATE_DISTANCE) config = { 'task': task, 'action_space': common.action_space(), 'renderers': common.renderers(), 'init_sprites': sprite_gen, 'max_episode_length': 20, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def testKeys(self): d_base = distribs.Product( (distribs.Continuous('x', 0, 2), distribs.Continuous('y', 0, 1))) d_filter_1 = distribs.Continuous('x', 0, 1) d_filter_2 = distribs.Continuous('z', 0.4, 0.6) distribs.Selection(d_base, d_filter_1) with self.assertRaises(ValueError): distribs.Selection(d_base, d_filter_2)
def testkeys(self): dists = [ distribs.Discrete('x', [1, 2.5, 3, 12]), distribs.Continuous('y', 0, 5), distribs.Continuous('z', 2, 10), ] d = distribs.Product(dists) self.assertEqual(d.keys, set(('x', 'y', 'z')))
def get_config(mode=None): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to physics_environment.PhysicsEnvironment. """ # Factor distributions for the sprites. factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['circle', 'square', 'triangle']), distribs.Discrete('scale', [0.1]), distribs.Continuous('c0', 0, 1), distribs.Continuous('c1', 0.5, 1.), distribs.Discrete('c2', [1.]), distribs.Continuous('x_vel', -0.03, 0.03), distribs.Continuous('y_vel', -0.03, 0.03), distribs.Continuous('mass', 0.5, 2.0), ]) sprite_gen = generate_sprites.generate_sprites( factors, num_sprites=lambda: np.random.randint(4, 8)) # The collisions are simulated by applying an invisible rigid circular shell # around each sprite. The shell_radius of 0.08 is eye-balled to look # reasonable. force = forces.SymmetricShellCollision(shell_radius=0.08) graph_generator = graph_generators.LowerTriangular(force=force) renderers = { 'image': spriteworld_renderers.PILRenderer( image_size=(64, 64), anti_aliasing=5) } config = { 'graph_generators': (graph_generator,), 'renderers': renderers, 'init_sprites': sprite_gen, 'episode_length': 30, 'bounce_off_walls': True, 'physics_steps_per_env_step': 10, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def testCubeWithTunnel(self): cube = distribs.Product([ distribs.Continuous('x', 0, 1), distribs.Continuous('y', 0, 1), distribs.Continuous('z', 0, 1), ]) tunnel = distribs.Product([ distribs.Continuous('x', 0.25, 0.75), distribs.Continuous('y', 0.25, 0.75), ]) cube_with_tunnel = distribs.SetMinus(cube, tunnel) contained = [{ 'x': 0.2, 'y': 0.2, 'z': 0.2 }, { 'x': 0.2, 'y': 0.2, 'z': 0.5 }, { 'x': 0.2, 'y': 0.5, 'z': 0.5 }] not_contained = [ { 'x': 0.5, 'y': 0.5, 'z': 0.5 }, { 'x': 0.5, 'y': 0.5, 'z': 0.2 }, ] test_sampling_and_containment(self, cube_with_tunnel, contained, not_contained)
def get_config(mode='train'): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to physics_environment.PhysicsEnvironment. """ # Factor distributions for the sprites. factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['circle']), distribs.Discrete('scale', [0.1]), distribs.Continuous('c0', 0, 1), distribs.Discrete('c1', [1.]), distribs.Discrete('c2', [1.]), distribs.Continuous('x_vel', -0.03, 0.03), distribs.Continuous('y_vel', -0.03, 0.03), distribs.Discrete('mass', [1]), ]) num_sprites = _NUM_SPRITES[mode] sprite_gen = generate_sprites.generate_sprites( factors, num_sprites=num_sprites) graph_generator = graph_generators.FullyConnected(force=forces.NoForce) renderers = { 'image': spriteworld_renderers.PILRenderer( image_size=(64, 64), anti_aliasing=5) } config = { 'graph_generators': (graph_generator,), 'renderers': renderers, 'init_sprites': sprite_gen, 'episode_length': 20, 'bounce_off_walls': False, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def get_config(mode='train'): """Generate environment config. Args: mode: 'train' or 'test'. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ factors = distribs.Product([ MODES_SHAPES[mode], distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('scale', [0.2]), distribs.Discrete('c0', [0.9, 0.55, 0.27], probs=[0.333, 0.334, 0.333]), distribs.Discrete('c1', [0.6]), distribs.Continuous('c2', 0.9, 1.), ]) sprite_gen = sprite_generators.generate_sprites(factors, num_sprites=NUM_TARGETS, fix_colors=True) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) task = tasks.FindGoalPosition(terminate_distance=TERMINATE_DISTANCE, sparse_reward=True) config = { 'task': task, 'action_space': common.noisy_action_space(MOTION_STD_DEV, PROPORTIONAL_MOTION_NOISE, None), 'renderers': common.renderers(), 'init_sprites': sprite_gen, 'max_episode_length': 60, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def get_config(mode=None): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to physics_environment.PhysicsEnvironment. """ # Factor distributions for the sprites. factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['circle', 'square', 'triangle']), distribs.Discrete('scale', [0.1]), distribs.Continuous('c0', 0, 1), distribs.Continuous('c1', 0.5, 1.), distribs.Discrete('c2', [1.]), distribs.Continuous('x_vel', -0.03, 0.03), distribs.Continuous('y_vel', -0.03, 0.03), distribs.Continuous('mass', 0.5, 2.0), ]) sprite_gen = generate_sprites.generate_sprites(factors, num_sprites=4) force = forces.Spring(spring_constant=0.03, spring_equilibrium=0.25) graph_generator = graph_generators.FullyConnected(force=force) renderers = { 'image': spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5) } config = { 'graph_generators': (graph_generator, ), 'renderers': renderers, 'init_sprites': sprite_gen, 'episode_length': 30, 'bounce_off_walls': False, 'physics_steps_per_env_step': 10, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def get_config(mode=None): """Generate environment config. Args: mode: Unused. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ del mode # No train/test split for pure exploration factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['square', 'triangle', 'circle']), distribs.Discrete('scale', [0.13]), distribs.Continuous('c0', 0., 1.), distribs.Continuous('c1', 0.3, 1.), distribs.Continuous('c2', 0.9, 1.), ]) num_sprites = lambda: np.random.randint(1, 7) sprite_gen = sprite_generators.generate_sprites(factors, num_sprites=num_sprites) task = tasks.NoReward() config = { 'task': task, 'action_space': common.action_space(), 'renderers': common.renderers(), 'init_sprites': sprite_gen, 'max_episode_length': 10, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def testSamplingContainmentProductMultiple(self): dists = [ distribs.Discrete('x', [1, 2.5, 3, 4, 6]), distribs.Discrete('y', [1, 2.5, 3, 12]), distribs.Continuous('z', 0, 5), distribs.Continuous('w', 2, 10), ] contained = [{'x': 2.5, 'y': 12, 'z': 3.5, 'w': 9}] not_contained = [ { 'x': 2.5, 'y': 12, 'z': 3.5, 'w': 1 }, { 'x': 3.5, 'y': 12, 'z': 3.5, 'w': 9 }, ] d = distribs.Product(dists) test_sampling_and_containment(self, d, contained, not_contained)
def get_config(mode=None): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ del mode shared_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['square', 'triangle', 'circle']), distribs.Discrete('scale', [0.13]), distribs.Continuous('c1', 0.3, 1.), distribs.Continuous('c2', 0.9, 1.), ]) target_hue = distribs.Continuous('c0', 0., 0.4) distractor_hue = distribs.Continuous('c0', 0.5, 0.9) target_factors = distribs.Product([ target_hue, shared_factors, ]) distractor_factors = distribs.Product([ distractor_hue, shared_factors, ]) target_sprite_gen = sprite_generators.generate_sprites( target_factors, num_sprites=NUM_TARGETS) distractor_sprite_gen = sprite_generators.generate_sprites( distractor_factors, num_sprites=NUM_DISTRACTORS) sprite_gen = sprite_generators.chain_generators(target_sprite_gen, distractor_sprite_gen) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) # Create the agent body agent_body_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['circle']), distribs.Discrete('scale', [0.07]), distribs.Discrete('c0', [1.]), distribs.Discrete('c1', [0.]), distribs.Discrete('c2', [1.]), ]) agent_body_gen = sprite_generators.generate_sprites(agent_body_factors, num_sprites=1) sprite_gen = sprite_generators.chain_generators(sprite_gen, agent_body_gen) task = tasks.FindGoalPosition(filter_distrib=target_hue, terminate_distance=TERMINATE_DISTANCE) renderers = { 'image': spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5, color_to_rgb=color_maps.hsv_to_rgb) } config = { 'task': task, 'action_space': action_spaces.Embodied(step_size=0.05), 'renderers': renderers, 'init_sprites': sprite_gen, 'max_episode_length': 50, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def get_config(mode=None): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to physics_environment.PhysicsEnvironment. """ # Factor distribution for the fixed center star center_factors = distribs.Product([ distribs.Discrete('x', [0.5]), distribs.Discrete('y', [0.5]), distribs.Discrete('shape', ['circle']), distribs.Discrete('scale', [0.15]), distribs.Discrete('c0', [3.]), distribs.Discrete('c1', [1.]), distribs.Discrete('c2', [1.]), distribs.Continuous('mass', 1, 3), ]) center_sprite_gen = generate_sprites.generate_sprites(center_factors, num_sprites=1) # Factor distributions for the orbiting sprites orbit_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['star_4', 'star_5', 'star_6']), distribs.Discrete('scale', [0.08]), distribs.Continuous('c0', 0, 1), distribs.Continuous('c1', 0.5, 1.), distribs.Discrete('c2', [1.]), distribs.Continuous('x_vel', -0.03, 0.03), distribs.Continuous('y_vel', -0.03, 0.03), distribs.Discrete('mass', [1]), ]) orbit_sprite_gen = generate_sprites.generate_sprites(orbit_factors, num_sprites=4) sprite_gen = sprite_generators.chain_generators(center_sprite_gen, orbit_sprite_gen) force = forces.Gravity(gravity_constant=-0.0001, distance_for_max_force=0.05) adjacency_matrix = { (0, 1): force, (0, 2): force, (0, 3): force, (0, 4): force, } graph_generator = graph_generators.AdjacencyMatrix( adjacency_matrix=adjacency_matrix, symmetric=False) renderers = { 'image': spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5) } config = { 'graph_generators': (graph_generator, ), 'renderers': renderers, 'init_sprites': sprite_gen, 'episode_length': 30, 'bounce_off_walls': True, 'physics_steps_per_env_step': 10, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
from __future__ import print_function import os from spriteworld import factor_distributions as distribs from spriteworld import sprite_generators from spriteworld import tasks from spriteworld.configs.cobra import common TERMINATE_DISTANCE = 0.075 NUM_TARGETS = 1 NUM_DISTRACTORS = 1 MODES_TARGET_POSITIONS = { 'train': distribs.SetMinus( distribs.Product(( distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), )), distribs.Product(( distribs.Continuous('x', 0.5, 0.9), distribs.Continuous('y', 0.5, 0.9), )), ), 'test': distribs.Product(( distribs.Continuous('x', 0.5, 0.9), distribs.Continuous('y', 0.5, 0.9), )), } def get_config(mode='train'):
def get_config(mode='train'): """Generate environment config. Args: mode: Unused task mode. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ # Factor distributions common to all objects. common_factors = distribs.Product([ distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Continuous('angle', 0, 360, dtype='int32'), ]) # train/test split for goal-finding object scales and clustering object colors goal_finding_scale_test = distribs.Continuous('scale', 0.08, 0.12) green_blue_colors = distribs.Product([ distribs.Continuous('c1', 64, 256, dtype='int32'), distribs.Continuous('c2', 64, 256, dtype='int32'), ]) if mode == 'train': goal_finding_scale = distribs.SetMinus( distribs.Continuous('scale', 0.05, 0.15), goal_finding_scale_test, ) cluster_colors = distribs.Product([ distribs.Continuous('c0', 128, 256, dtype='int32'), green_blue_colors ]) elif mode == 'test': goal_finding_scale = goal_finding_scale_test cluster_colors = distribs.Product([ distribs.Continuous('c0', 0, 128, dtype='int32'), green_blue_colors ]) else: raise ValueError( 'Invalid mode {}. Mode must be "train" or "test".'.format(mode)) # Create clustering sprite generators sprite_gen_list = [] cluster_shapes = [ distribs.Discrete('shape', [s]) for s in ['triangle', 'square', 'pentagon'] ] for shape in cluster_shapes: factors = distribs.Product([ common_factors, cluster_colors, shape, distribs.Continuous('scale', 0.08, 0.12), ]) sprite_gen_list.append( sprite_generators.generate_sprites(factors, num_sprites=2)) # Create goal-finding sprite generators goal_finding_colors = [ distribs.Product([ distribs.Continuous('c0', 192, 256, dtype='int32'), distribs.Continuous('c1', 0, 128, dtype='int32'), distribs.Continuous('c2', 64, 128, dtype='int32'), ]), distribs.Product([ distribs.Continuous('c0', 0, 128, dtype='int32'), distribs.Continuous('c1', 192, 256, dtype='int32'), distribs.Continuous('c2', 64, 128, dtype='int32'), ]) ] # Goal positions corresponding to the colors in goal_finding_colors goal_finding_positions = [(0., 0.5), (1., 0.5)] goal_finding_shapes = distribs.Discrete('shape', ['spoke_4', 'star_4']) for colors in goal_finding_colors: factors = distribs.Product([ common_factors, goal_finding_scale, goal_finding_shapes, colors, ]) sprite_gen_list.append( sprite_generators.generate_sprites( factors, num_sprites=lambda: np.random.randint(1, 3))) # Create distractor sprite generator distractor_factors = distribs.Product([ common_factors, distribs.Discrete('shape', ['circle']), distribs.Continuous('c0', 64, 256, dtype='uint8'), distribs.Continuous('c1', 64, 256, dtype='uint8'), distribs.Continuous('c2', 64, 256, dtype='uint8'), distribs.Continuous('scale', 0.08, 0.12), ]) sprite_gen_list.append( sprite_generators.generate_sprites( distractor_factors, num_sprites=lambda: np.random.randint(0, 3))) # Concat clusters into single scene to generate sprite_gen = sprite_generators.chain_generators(*sprite_gen_list) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) # Create the combined task of goal-finding and clustering task_list = [] task_list.append( tasks.Clustering(cluster_shapes, terminate_bonus=0., reward_range=10.)) for colors, goal_pos in zip(goal_finding_colors, goal_finding_positions): goal_finding_task = tasks.FindGoalPosition(distribs.Product( [colors, goal_finding_shapes]), goal_position=goal_pos, weights_dimensions=(1, 0), terminate_distance=0.15, raw_reward_multiplier=30) task_list.append(goal_finding_task) task = tasks.MetaAggregated(task_list, reward_aggregator='sum', termination_criterion='all') renderers = { 'image': spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5) } config = { 'task': task, 'action_space': action_spaces.SelectMove(scale=0.5), 'renderers': renderers, 'init_sprites': sprite_gen, 'max_episode_length': 50, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
def load_data(self): # download if not avaiable file_path = os.path.join(self.path, self.fname) if not os.path.exists(file_path): os.makedirs(self.path, exist_ok=True) print(f'file not found, downloading from {self.url} ...') from urllib import request url = self.url request.urlretrieve(url, file_path) with open(file_path) as data: self.csv_dict = load_csv(data, sequence=self.sequence_len) self.orig_num = [32, 32, 6, 40, 4, 1, 1, 1] self.dsprites = { 'x': np.linspace(0.2, 0.8, self.orig_num[0]), 'y': np.linspace(0.2, 0.8, self.orig_num[1]), 'scale': np.linspace(0, 0.5, self.orig_num[2] + 1)[1:], 'angle': np.linspace(0, 360, self.orig_num[3], dtype=np.int, endpoint=False), 'shape': ['square', 'triangle', 'star_4', 'spoke_4'], 'c0': [1.], 'c1': [1.], 'c2': [1.] } distributions = [] for key in self.dsprites.keys(): distributions.append(distribs.Discrete(key, self.dsprites[key])) self.factor_dist = distribs.Product(distributions) self.renderer = spriteworld_renderers.PILRenderer(image_size=(64, 64), anti_aliasing=5, color_to_rgb=rgb) if self.area_filter: keep_idxes = [] print(len(self.csv_dict['x'])) for i in range(self.sequence_len): x = pd.Series(np.array(self.csv_dict['area'])[:, i]) keep_idxes.append( x.between(x.quantile(self.area_filter / 2), x.quantile(1 - (self.area_filter / 2)))) for k in self.csv_dict.keys(): y = pd.Series(self.csv_dict[k]) self.csv_dict[k] = np.array( [x for x in y[np.logical_and(*keep_idxes)]]) print(len(self.csv_dict['x'])) if self.natural_discrete: num_bins = self.orig_num[:3] self.lab_encs = {} print('num_bins', num_bins) for i, key in enumerate(['x', 'y', 'area']): count, bin_edges = np.histogram(np.array( self.csv_dict[key]).flatten().tolist(), bins=num_bins[i]) bin_left, bin_right = bin_edges[:-1], bin_edges[1:] bin_centers = bin_left + (bin_right - bin_left) / 2 new_data = [] old_shape = np.array(self.csv_dict[key]).shape lab_enc = preprocessing.LabelEncoder() if key == 'area': self.lab_encs['scale'] = lab_enc.fit( np.sqrt(bin_centers / (64**2))) else: self.lab_encs[key] = lab_enc.fit(bin_centers / 64) for j in range(self.sequence_len): differences = ( np.array(self.csv_dict[key])[:, j].reshape(1, -1) - bin_centers.reshape(-1, 1)) new_data.append([ bin_centers[x] for x in np.abs(differences).argmin(axis=0) ]) self.csv_dict[key] = np.swapaxes(new_data, 0, 1) assert old_shape == np.array(self.csv_dict[key]).shape assert len(np.unique(np.array( self.csv_dict[key]).flatten())) == num_bins[i] for i, key in enumerate(['angle', 'shape', 'c0', 'c1', 'c2']): lab_enc = preprocessing.LabelEncoder() self.lab_encs[key] = lab_enc.fit(self.dsprites[key]) assert self.lab_encs.keys() == self.dsprites.keys() self.factor_sizes = [ len(np.unique(np.array(self.csv_dict['x']).flatten())), len(np.unique(np.array(self.csv_dict['y']).flatten())), len(np.unique(np.array(self.csv_dict['area']).flatten())), 40, 4, 1, 1, 1 ] print(self.factor_sizes) self.latent_factor_indices = list(range(5)) self.num_factors = len(self.latent_factor_indices) self.observation_factor_indices = [ i for i in range(self.num_factors) if i not in self.latent_factor_indices ] self.mapping = {'square': 0, 'triangle': 1, 'star_4': 2, 'spoke_4': 3}
from __future__ import absolute_import from __future__ import division from __future__ import print_function from absl.testing import absltest from absl.testing import parameterized import numpy as np from spriteworld import factor_distributions as distribs from spriteworld import sprite from spriteworld import sprite_generators _distrib_0 = distribs.Product([ distribs.Discrete('x', [0.5]), distribs.Discrete('y', [0.5]), distribs.Discrete('shape', ['square', 'triangle']), distribs.Discrete('c0', [255]), distribs.Discrete('c1', [255]), distribs.Discrete('c2', [255]), ]) _distrib_1 = distribs.Product([ distribs.Discrete('x', [0.5]), distribs.Discrete('y', [0.5]), distribs.Discrete('shape', ['hexagon', 'circle', 'star_5']), distribs.Discrete('c0', [255]), distribs.Discrete('c1', [255]), distribs.Discrete('c2', [255]), ]) class SpriteGeneratorTest(parameterized.TestCase):
def get_config(mode='train'): """Generate environment config. Args: mode: 'train' or 'test'. Returns: config: Dictionary defining task/environment configuration. Can be fed as kwargs to environment.Environment. """ # Create the subtasks and their corresponding sprite generators subtasks = [] sprite_gen_per_subtask = [] for subtask in SUBTASKS: subtasks.append( tasks.FindGoalPosition( filter_distrib=subtask['distrib'], goal_position=subtask['goal_position'], terminate_distance=TERMINATE_DISTANCE, raw_reward_multiplier=RAW_REWARD_MULTIPLIER)) factors = distribs.Product(( subtask['distrib'], distribs.Continuous('x', 0.1, 0.9), distribs.Continuous('y', 0.1, 0.9), distribs.Discrete('shape', ['square', 'triangle', 'circle']), distribs.Discrete('scale', [0.13]), distribs.Continuous('c1', 0.3, 1.), distribs.Continuous('c2', 0.9, 1.), )) sprite_gen_per_subtask.append( sprite_generators.generate_sprites(factors, num_sprites=1)) # Consider all combinations of subtasks subtask_combos = list( itertools.combinations(np.arange(len(SUBTASKS)), NUM_TARGETS)) if mode == 'train': # Randomly sample a combination of subtasks, holding one combination out sprite_gen = sprite_generators.sample_generator([ sprite_generators.chain_generators( *[sprite_gen_per_subtask[i] for i in c]) for c in subtask_combos[1:] ]) elif mode == 'test': # Use the held-out subtask combination for testing sprite_gen = sprite_generators.chain_generators( *[sprite_gen_per_subtask[i] for i in subtask_combos[0]]) else: raise ValueError('Invalide mode {}.'.format(mode)) # Randomize sprite ordering to eliminate any task information from occlusions sprite_gen = sprite_generators.shuffle(sprite_gen) task = tasks.MetaAggregated(subtasks, reward_aggregator='sum', termination_criterion='all') config = { 'task': task, 'action_space': common.action_space(), 'renderers': common.renderers(), 'init_sprites': sprite_gen, 'max_episode_length': MAX_EPISODE_LENGTH, 'metadata': { 'name': os.path.basename(__file__), 'mode': mode } } return config
class SelectionTest(parameterized.TestCase): """Runs tests for Selection of distributions.""" @parameterized.named_parameters( ( 'Continuous', distribs.Continuous('x', 0, 2), distribs.Continuous('x', 1, 3), [{ 'x': 1.5 }], [{ 'x': 0.5 }, { 'x': 2.5 }], ), ( 'Discrete', distribs.Discrete('x', [0, 1]), distribs.Discrete('x', [1, 2]), [{ 'x': 1 }], [{ 'x': 0 }, { 'x': 2 }], ), ( 'MultiDimensional', distribs.Product( (distribs.Discrete('x', [1, 2]), distribs.Discrete( 'y', [3, 4]))), distribs.Discrete('x', [2]), [{ 'x': 2, 'y': 3 }], [{ 'x': 1, 'y': 3 }, { 'x': 2 }, { 'x': 2, 'y': 5 }], ), ) def testSamplingContainmentSelection(self, d_base, d_filter, contained, not_contained): d = distribs.Selection(d_base, d_filter) test_sampling_and_containment(self, d, contained, not_contained) def testRaisesErrorFailedSampling(self): d_base = distribs.Continuous('x', 0, 1) d_filter = distribs.Continuous('x', 2, 3) d = distribs.Selection(d_base, d_filter) with self.assertRaises(ValueError): d.sample() def testKeys(self): d_base = distribs.Product( (distribs.Continuous('x', 0, 2), distribs.Continuous('y', 0, 1))) d_filter_1 = distribs.Continuous('x', 0, 1) d_filter_2 = distribs.Continuous('z', 0.4, 0.6) distribs.Selection(d_base, d_filter_1) with self.assertRaises(ValueError): distribs.Selection(d_base, d_filter_2)
def testCornerUnion(self): square_0 = distribs.Product([ distribs.Continuous('x', 0, 3), distribs.Continuous('y', 0, 3), ]) hold_out_0 = distribs.Product([ distribs.Continuous('x', 1, 3), distribs.Continuous('y', 0, 2), ]) square_1 = distribs.Product([ distribs.Continuous('x', 2, 5), distribs.Continuous('y', 0, 3), ]) hold_out_1 = distribs.Product([ distribs.Continuous('x', 2, 4), distribs.Continuous('y', 1, 3), ]) corner_0 = distribs.SetMinus(square_0, hold_out_0) corner_1 = distribs.SetMinus(square_1, hold_out_1) corner_union = distribs.Mixture([corner_0, corner_1]) contained = [ { 'x': 0.5, 'y': 0.5 }, { 'x': 0.5, 'y': 2.5 }, { 'x': 2.5, 'y': 2.5 }, { 'x': 2.5, 'y': 0.5 }, { 'x': 4.5, 'y': 0.5 }, { 'x': 4.5, 'y': 2.5 }, ] not_contained = [ { 'x': 1.5, 'y': 0.5 }, { 'x': 1.5, 'y': 1.5 }, { 'x': 2.5, 'y': 1.5 }, { 'x': 3.5, 'y': 1.5 }, { 'x': 3.5, 'y': 2.5 }, ] test_sampling_and_containment(self, corner_union, contained, not_contained)
def testSamplingContainmentProductTwo(self, d_0, d_1, contained, not_contained): d = distribs.Product((d_0, d_1)) test_sampling_and_containment(self, d, contained, not_contained)
def testRaisesError(self): d_0 = distribs.Continuous('x', 0, 1) d_1 = distribs.Continuous('x', 2, 3) with self.assertRaises(ValueError): distribs.Product((d_0, d_1))