def setUp(self):
super(MetaAggregatedTest, self).setUp()
self.subtasks = [
tasks.FindGoalPosition(filter_distrib=distribs.Continuous(
'c0', 0, 100),
goal_position=np.array([0.2, 0.2]),
terminate_distance=0.1),
tasks.FindGoalPosition(filter_distrib=distribs.Continuous(
'c0', 100, 200),
goal_position=np.array([0.5, 0.5]),
terminate_distance=0.1,
terminate_bonus=5.0),
tasks.FindGoalPosition(filter_distrib=distribs.Continuous(
'c0', 200, 256),
goal_position=np.array([0.8, 0.8]),
terminate_distance=0.1,
terminate_bonus=10.0),
]
self.success_sprites = [
sprite.Sprite(x=0.2, y=0.2, c0=50),
sprite.Sprite(x=0.5, y=0.45, c0=150),
sprite.Sprite(x=0.85, y=0.75, c0=250),
]
self.success_rewards = [5., 7.5, 11.5]
self.failure_sprites = [
sprite.Sprite(x=0.2, y=0.8, c0=50),
sprite.Sprite(x=0.3, y=0.45, c0=150),
sprite.Sprite(x=0.9, y=0.75, c0=250),
]
self.failure_rewards = [-25., -5.3, -0.6]
def testFilterDistrib(self):
sprites = [
sprite.Sprite(x=0.45, y=0.45, c0=64),
sprite.Sprite(x=0.45, y=0.55, c0=128),
sprite.Sprite(x=0.55, y=0.45, c0=192),
sprite.Sprite(x=0.4, y=0.4, c0=255),
]
filter_distribs = [
distribs.Continuous('c0', 0, 65), # selects sprites[:1]
distribs.Continuous('c0', 0, 129), # selects sprites[:2]
distribs.Continuous('c0', 0, 193), # selects sprites[:3]
distribs.Continuous('c0', 0, 256), # selects sprites[:4]
distribs.Continuous('c0', 65, 256), # selects sprites[1:4]
]
task_list = [
tasks.FindGoalPosition(filter_distrib=x,
goal_position=(0.5, 0.5),
terminate_distance=0.1)
for x in filter_distribs
]
rewards = [1.5, 2.9, 4.4, 2.3, 0.9]
successes = [True, True, True, False, False]
for t, r, s in zip(task_list, rewards, successes):
self.assertAlmostEqual(t.reward(sprites), r, delta=0.1)
self.assertEqual(t.success(sprites), s)
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):
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 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)
class IntersectionTest(parameterized.TestCase):
"""Runs tests for Intersection of distributions."""
@parameterized.named_parameters(
('ContinuousContinuous', distribs.Continuous(
'x', 0, 2), distribs.Continuous('x', 1, 3), [1.5], [0.5, 2.5]),
('DiscreteDiscrete', distribs.Discrete(
'x', [0, 1]), distribs.Discrete('x', [1, 2]), [1], [0, 2]),
('DiscreteContinuous', distribs.Discrete(
'x', [1, 3]), distribs.Continuous('x', 0, 2), [1], [0.5, 1.5, 3]),
)
def testSamplingContainmentIntersectionTwo(self, d_0, d_1, contained,
not_contained):
d = distribs.Intersection((d_0, d_1))
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
def testSamplingContainmentIntersectionMultiple(self):
dists = [
distribs.Discrete('x', [1, 2.5, 3, 4, 6]),
distribs.Discrete('x', [1, 2.5, 3, 12]),
distribs.Continuous('x', 0, 5),
distribs.Continuous('x', 2, 10),
]
contained = [2.5, 3]
not_contained = [1, 4, 8]
d = distribs.Intersection(dists)
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
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)
d = distribs.Intersection((d_0, d_1))
with self.assertRaises(ValueError):
d.sample()
def testIndexForSampling(self):
d_0 = distribs.Continuous('x', 0, 2)
d_1 = distribs.Discrete('x', [1, 3])
d = distribs.Intersection((d_0, d_1), index_for_sampling=1)
d.sample()
with self.assertRaises(ValueError):
d = distribs.Intersection((d_0, d_1), index_for_sampling=0)
d.sample()
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 testDType(self):
d_int = distribs.Continuous('x', 0, 1, dtype='int32')
d_float = distribs.Continuous('x', 0, 1, dtype='float32')
self.assertTrue(d_int.contains({'x': 0}))
self.assertTrue(d_float.contains({'x': 0}))
self.assertFalse(d_int.contains({'x': 1}))
self.assertFalse(d_float.contains({'x': 1}))
for _ in range(5):
self.assertEqual(d_int.sample(), {'x': 0})
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 testMoreSprites(self, positions_0, positions_1, reward):
sprites = [sprite.Sprite(x=p[0], y=p[1], c0=75) for p in positions_0]
sprites.extend(
[sprite.Sprite(x=p[0], y=p[1], c0=225) for p in positions_1])
cluster_distribs = [
distribs.Continuous('c0', 50, 100),
distribs.Continuous('c0', 200, 250),
]
task = tasks.Clustering(cluster_distribs=cluster_distribs)
self.assertAlmostEqual(task.reward(sprites), reward, delta=0.1)
def testSamplingContainmentSetMinusMultiple(self):
base = distribs.Continuous('x', 2, 10)
hold_out = distribs.Mixture([
distribs.Discrete('x', [1, 4, 6]),
distribs.Discrete('x', [3, 8, 9, 12]),
distribs.Continuous('x', 3, 5),
])
contained = [{'x': value} for value in [2.5, 5.5, 7, 9.5]]
not_contained = [{'x': value} for value in [4, 6, 9, 11]]
d = distribs.SetMinus(base, hold_out)
test_sampling_and_containment(self, d, contained, not_contained)
def setUp(self):
super(ClusteringTest, self).setUp()
self.sprites = [
sprite.Sprite(x=0.2, y=0.2, c0=64),
sprite.Sprite(x=0.3, y=0.3, c0=128),
sprite.Sprite(x=0.8, y=0.9, c0=192),
sprite.Sprite(x=0.9, y=0.8, c0=255),
]
self.cluster_distribs = [
distribs.Continuous('c0', 0, 129),
distribs.Continuous('c0', 190, 256),
]
def testSamplingContainmentIntersectionMultiple(self):
dists = [
distribs.Discrete('x', [1, 2.5, 3, 4, 6]),
distribs.Discrete('x', [1, 2.5, 3, 12]),
distribs.Continuous('x', 0, 5),
distribs.Continuous('x', 2, 10),
]
contained = [2.5, 3]
not_contained = [1, 4, 8]
d = distribs.Intersection(dists)
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
class MixtureTest(parameterized.TestCase):
"""Runs tests for Mixture of distributions."""
@parameterized.named_parameters(
('DisjointContinuous', distribs.Continuous('x', 0, 1),
distribs.Continuous('x', 2, 3), [0.5, 2.5], [1.5, 3.5]),
('OverlappingContinuous', distribs.Continuous('x', 0, 2),
distribs.Continuous('x', 1, 3), [0.5, 2.5], [-0.5, 3.5]),
('DisjointDiscrete', distribs.Discrete(
'x', [0, 1]), distribs.Discrete('x', [2, 3]), [1, 2], [-1, 4]),
('OverlappingDiscrete', distribs.Discrete(
'x', [0, 1]), distribs.Discrete('x', [1, 2]), [0, 1, 2], [-1, 3]),
('ContinuousDiscrete', distribs.Continuous(
'x', 0, 2), distribs.Discrete('x', [1, 3]), [0.5, 3], [2.5]),
)
def testSamplingContainmentMixtureTwo(self, c_0, c_1, contained,
not_contained):
d = distribs.Mixture((c_0, c_1))
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
def testSamplingContainmentMixtureMultiple(self):
dists = [
distribs.Continuous('x', 0, 2),
distribs.Continuous('x', 1, 5),
distribs.Continuous('x', 9, 12),
distribs.Discrete('x', [7, 10]),
distribs.Discrete('x', [14]),
]
contained = [0.5, 4, 11, 7, 14]
not_contained = [5.5, 6, 8, 13]
d = distribs.Mixture(dists)
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
def testRaisesError(self):
c_0 = distribs.Discrete('x', [0])
c_1 = distribs.Discrete('y', [1])
with self.assertRaises(ValueError):
distribs.Mixture((c_0, c_1))
def testProbs(self):
c_0 = distribs.Discrete('x', [0])
c_1 = distribs.Discrete('x', [1])
d_0 = distribs.Mixture([c_0, c_1], probs=(0.3, 0.7))
d_1 = distribs.Mixture([c_0, c_1], probs=(0.0, 1.0))
for _ in range(5):
self.assertTrue(d_0.contains(d_0.sample()))
for _ in range(5):
self.assertEqual(d_1.sample(), {'x': 1})
def testSamplingContainmentMixtureMultiple(self):
dists = [
distribs.Continuous('x', 0, 2),
distribs.Continuous('x', 1, 5),
distribs.Continuous('x', 9, 12),
distribs.Discrete('x', [7, 10]),
distribs.Discrete('x', [14]),
]
contained = [0.5, 4, 11, 7, 14]
not_contained = [5.5, 6, 8, 13]
d = distribs.Mixture(dists)
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
def test4Sprites(self, positions, reward, success):
sprites = [
sprite.Sprite(x=positions[0][0], y=positions[0][1], c0=64),
sprite.Sprite(x=positions[1][0], y=positions[1][1], c0=128),
sprite.Sprite(x=positions[2][0], y=positions[2][1], c0=192),
sprite.Sprite(x=positions[3][0], y=positions[3][1], c0=255),
]
cluster_distribs = [
distribs.Continuous('c0', 0, 129),
distribs.Continuous('c0', 190, 256),
]
task = tasks.Clustering(cluster_distribs=cluster_distribs)
self.assertAlmostEqual(task.reward(sprites), reward, delta=0.1)
self.assertEqual(task.success(sprites), success)
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 testNoFilteredSprites(self):
sprites = [sprite.Sprite(x=0.45, y=0.45, c0=255)]
filter_distrib = distribs.Continuous('c0', 0, 254)
r = tasks.FindGoalPosition(filter_distrib=filter_distrib,
goal_position=(0.5, 0.5),
terminate_distance=0.1).reward(sprites)
self.assertTrue(np.isnan(r))
def test3Clusters(self):
sprites = [
sprite.Sprite(x=0.2, y=0.2, c0=64),
sprite.Sprite(x=0.3, y=0.3, c0=64),
sprite.Sprite(x=0.8, y=0.9, c0=128),
sprite.Sprite(x=0.9, y=0.8, c0=128),
sprite.Sprite(x=0.8, y=0.9, c0=255),
sprite.Sprite(x=0.9, y=0.8, c0=255),
]
cluster_distribs = [
distribs.Continuous('c0', 0, 100),
distribs.Continuous('c0', 100, 150),
distribs.Continuous('c0', 200, 256),
]
task = tasks.Clustering(cluster_distribs=cluster_distribs)
self.assertAlmostEqual(task.reward(sprites), 17.5, delta=0.1)
def testIndexForSampling(self):
d_0 = distribs.Continuous('x', 0, 2)
d_1 = distribs.Discrete('x', [1, 3])
d = distribs.Intersection((d_0, d_1), index_for_sampling=1)
d.sample()
with self.assertRaises(ValueError):
d = distribs.Intersection((d_0, d_1), index_for_sampling=0)
d.sample()
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=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 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
class SetMinusTest(parameterized.TestCase):
"""Runs tests for SetMinus of distributions."""
@parameterized.named_parameters(
('ContinuousContinuous', distribs.Continuous(
'x', 0, 2), distribs.Continuous('x', 1, 3), [0.5], [1.5]),
('DiscreteDiscrete', distribs.Discrete(
'x', [0, 1]), distribs.Discrete('x', [1, 2]), [0], [1]),
('DiscreteContinuous', distribs.Discrete(
'x', [1, 3]), distribs.Continuous('x', 0, 2), [3], [1]),
('ContinuousDiscrete', distribs.Continuous(
'x', 0, 2), distribs.Discrete('x', [1, 3]), [0.5, 1.5], [1]),
)
def testSamplingContainmentSetMinusTwo(self, d_0, d_1, contained,
not_contained):
d = distribs.SetMinus(d_0, d_1)
contained = [{'x': value} for value in contained]
not_contained = [{'x': value} for value in not_contained]
test_sampling_and_containment(self, d, contained, not_contained)
def testSamplingContainmentSetMinusMultiple(self):
base = distribs.Continuous('x', 2, 10)
hold_out = distribs.Mixture([
distribs.Discrete('x', [1, 4, 6]),
distribs.Discrete('x', [3, 8, 9, 12]),
distribs.Continuous('x', 3, 5),
])
contained = [{'x': value} for value in [2.5, 5.5, 7, 9.5]]
not_contained = [{'x': value} for value in [4, 6, 9, 11]]
d = distribs.SetMinus(base, hold_out)
test_sampling_and_containment(self, d, contained, not_contained)
def testRaisesError(self):
d_0 = distribs.Continuous('x', 0, 2)
d_1 = distribs.Continuous('y', 1, 3)
with self.assertRaises(ValueError):
distribs.SetMinus(d_0, d_1)
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='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 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 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
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'):
"""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
