def test_mutate_layout(self):
layout = Layout(
input_size=100,
output_size=10,
output_activation='softmax')
training = Training(
objective=None,
optimizer=None,
metric=None,
stopping=None,
batch_size=None)
experiment = Experiment(
'test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=ExperimentParameters(use_default_values=False))
experiment.parameters.all_search_parameters(True)
check_experiment_parameters(experiment)
for _ in range(10):
blueprint = create_random_blueprint(experiment)
mutant = mutate_blueprint(
blueprint,
parameters=experiment.parameters,
p_mutate_layout=1,
layout_mutation_count=1,
layout_mutables=['rows'],
mutate_in_place=False)
self.assertTrue(
len(mutant.layout.rows) != len(blueprint.layout.rows),
'Should have mutated rows')
mutant = mutate_blueprint(
blueprint,
parameters=experiment.parameters,
p_mutate_layout=1,
layout_mutation_count=1,
layout_mutables=['blocks'],
mutate_in_place=False)
self.assertTrue(
len(mutant.layout.get_blocks()) != len(blueprint.layout.get_blocks()),
'Should have mutated blocks')
mutant = mutate_blueprint(
blueprint,
parameters=experiment.parameters,
p_mutate_layout=1,
layout_mutation_count=1,
layout_mutables=['layers'],
mutate_in_place=False)
self.assertTrue(
len(mutant.layout.get_layers()) != len(blueprint.layout.get_layers()),
'Should have mutated layers')
def test_predefined_multiple_blocklayout(self):
layout = Layout(
input_size=100,
output_size=10,
output_activation='softmax',
block=[
[('Dense', {'activation': 'relu'})],
[('Dense', {'activation': 'relu'}),
'Dropout',
('Dense', {'output_dim': 100})]])
training = Training(
objective=None,
optimizer=Optimizer(),
metric=None,
stopping=None,
batch_size=None)
experiment = Experiment(
'test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=ExperimentParameters(use_default_values=False))
experiment.parameters.search_parameter('layout', False)
experiment.parameters.search_parameter('parameters', True)
experiment.parameters.search_parameter('optimizer', True)
for _ in range(10):
blueprint1 = create_random_blueprint(experiment)
blueprint2 = create_random_blueprint(experiment)
blueprint3 = mix_blueprints(blueprint1, blueprint2, experiment.parameters)
blueprint4 = mutate_blueprint(blueprint1, experiment.parameters, mutate_in_place=False)
for idx, blueprint in enumerate([blueprint1, blueprint2, blueprint3, blueprint4]):
self.assertIsNotNone(blueprint, 'Should have created a blueprint')
self.assertIsNotNone(blueprint.layout, 'Should have created a layout')
self.assertEqual(
1,
len(blueprint.layout.get_rows()),
'Should have 1 row')
self.assertEqual(
1,
len(blueprint.layout.get_blocks()),
'Should have 1 block')
for i, row in enumerate(blueprint.layout.get_rows()):
blocks = len(row.get_blocks())
self.assertTrue(
is_valid_param_value(
experiment.parameters.get_layout_parameter('blocks'),
blocks),
'Invalid value')
for block in row.get_blocks():
self.assertTrue(
len(block.layers) == len(layout.block[0])
or len(block.layers) == len(layout.block[1]),
'Should have used template')
def test_mutate_w_custom_definitions(self):
def custom_activation(x):
return x
register_custom_activation('custom_activation', custom_activation)
register_custom_layer('Dense2', Dense, deepcopy(reference_parameters['layers']['Dense']))
layout = Layout(
input_size=100,
output_size=10,
output_activation='softmax',
block=['Dense', 'Dense2'])
training = Training(
objective=Objective('categorical_crossentropy'),
optimizer=None,
metric=Metric('categorical_accuracy'),
stopping=EpochStoppingCondition(5),
batch_size=250)
experiment_parameters = ExperimentParameters(use_default_values=False)
experiment_parameters.layout_parameter('blocks', int_param(1, 5))
experiment_parameters.layout_parameter('layers', int_param(1, 5))
experiment_parameters.layer_parameter('Dense2.output_dim', int_param(10, 500))
experiment_parameters.layer_parameter('Dropout.p', float_param(0.1, 0.9))
experiment_parameters.all_search_parameters(True)
experiment = Experiment(
'test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=experiment_parameters)
check_experiment_parameters(experiment)
for _ in range(10):
blueprint = create_random_blueprint(experiment)
mutant = mutate_blueprint(
blueprint,
parameters=experiment.parameters,
p_mutate_layout=0,
p_mutate_param=1,
mutate_in_place=False)
for row_idx, row in enumerate(mutant.layout.rows):
for block_idx, block in enumerate(row.blocks):
for layer_idx, layer in enumerate(block.layers):
original_row = blueprint.layout.rows[row_idx]
original_block = original_row.blocks[block_idx]
original_layer = original_block.layers[layer_idx]
for name, value in layer.parameters.items():
self.assertTrue(
value != original_layer.parameters[name],
'Should have mutated parameter')
def test_build(self):
layout = Layout(input_size=100,
output_size=10,
output_activation='softmax')
training = Training(objective=Objective('categorical_crossentropy'),
optimizer=None,
metric=Metric('categorical_accuracy'),
stopping=EpochStoppingCondition(10),
batch_size=250)
experiment_parameters = ExperimentParameters(use_default_values=False)
experiment_parameters.layout_parameter('blocks', int_param(1, 5))
experiment_parameters.layout_parameter('layers', int_param(1, 5))
experiment_parameters.layer_parameter('Dense.output_dim',
int_param(10, 500))
experiment_parameters.layer_parameter('Dense.activation',
string_param(['relu', 'tanh']))
experiment_parameters.layer_parameter('Dropout.p',
float_param(0.1, 0.9))
experiment_parameters.all_search_parameters(True)
experiment = Experiment('test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=experiment_parameters)
check_experiment_parameters(experiment)
for _ in range(5):
blueprint1 = create_random_blueprint(experiment)
model = ModelBuilder().build(blueprint1, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint2 = create_random_blueprint(experiment)
model = ModelBuilder().build(blueprint2, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint3 = mix_blueprints(blueprint1, blueprint2,
experiment_parameters)
model = ModelBuilder().build(blueprint3, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint4 = mutate_blueprint(blueprint1,
experiment_parameters,
mutate_in_place=False)
model = ModelBuilder().build(blueprint4, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
def test_mutate_parameters(self):
layout = Layout(
input_size=100,
output_size=10,
output_activation='softmax')
training = Training(
objective=None,
optimizer=None,
metric=None,
stopping=None,
batch_size=None)
experiment = Experiment(
'test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=ExperimentParameters(use_default_values=False))
experiment.parameters.all_search_parameters(True)
for _ in range(10):
blueprint = create_random_blueprint(experiment)
mutant = mutate_blueprint(
blueprint,
parameters=experiment.parameters,
p_mutate_layout=0,
p_mutate_param=1,
mutate_in_place=False)
for row_idx, row in enumerate(mutant.layout.rows):
for block_idx, block in enumerate(row.blocks):
for layer_idx, layer in enumerate(block.layers):
original_row = blueprint.layout.rows[row_idx]
original_block = original_row.blocks[block_idx]
original_layer = original_block.layers[layer_idx]
for name, value in layer.parameters.items():
if value == original_layer.parameters[name]:
pass
self.assertTrue(
value != original_layer.parameters[name],
'Should have mutated parameter')
def test_build_w_custom_definitions(self):
def custom_activation(x):
return x
register_custom_activation('custom_activation', custom_activation)
register_custom_layer(
'Dense2', Dense, deepcopy(reference_parameters['layers']['Dense']),
True)
layout = Layout(input_size=100,
output_size=10,
output_activation='softmax',
block=['Dense2'])
training = Training(objective=Objective('categorical_crossentropy'),
optimizer=None,
metric=Metric('categorical_accuracy'),
stopping=EpochStoppingCondition(5),
batch_size=250)
experiment_parameters = ExperimentParameters(use_default_values=False)
experiment_parameters.layout_parameter('blocks', int_param(1, 5))
experiment_parameters.layout_parameter('layers', int_param(1, 5))
experiment_parameters.layout_parameter('layer.type',
string_param(['Dense2']))
experiment_parameters.layer_parameter('Dense2.output_dim',
int_param(10, 500))
experiment_parameters.layer_parameter(
'Dense2.activation', string_param(['custom_activation']))
experiment_parameters.layer_parameter('Dropout.p',
float_param(0.1, 0.9))
experiment_parameters.all_search_parameters(True)
experiment = Experiment('test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=experiment_parameters)
check_experiment_parameters(experiment)
for _ in range(5):
blueprint1 = create_random_blueprint(experiment)
for layer in blueprint1.layout.get_layers():
self.assertEqual('Dense2', layer.layer_type,
'Should have used custom layer')
model = ModelBuilder().build(blueprint1, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint2 = create_random_blueprint(experiment)
for layer in blueprint2.layout.get_layers():
self.assertEqual('Dense2', layer.layer_type,
'Should have used custom layer')
model = ModelBuilder().build(blueprint2, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint3 = mix_blueprints(blueprint1, blueprint2,
experiment_parameters)
for layer in blueprint3.layout.get_layers():
self.assertEqual('Dense2', layer.layer_type,
'Should have used custom layer')
model = ModelBuilder().build(blueprint3, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
blueprint4 = mutate_blueprint(blueprint1,
experiment_parameters,
mutate_in_place=False)
for layer in blueprint4.layout.get_layers():
self.assertEqual('Dense2', layer.layer_type,
'Should have used custom layer')
model = ModelBuilder().build(blueprint4, cpu_device())
self.assertIsNotNone(model, 'Should have built a model')
def test_predefined_layout(self):
layout = Layout(
input_size=100,
output_size=10,
output_activation='softmax',
block=[
('Dense', {'activation': 'relu'}),
'Dropout',
('Dense', {'output_dim': 100})])
training = Training(
objective=None,
optimizer=Optimizer(),
metric=None,
stopping=None,
batch_size=None)
experiment = Experiment(
'test',
layout,
training,
batch_iterator=None,
test_batch_iterator=None,
environment=None,
parameters=ExperimentParameters(use_default_values=False))
experiment.parameters.search_parameter('layout', False)
experiment.parameters.search_parameter('parameters', True)
experiment.parameters.search_parameter('optimizer', True)
for _ in range(10):
blueprint1 = create_random_blueprint(experiment)
blueprint2 = create_random_blueprint(experiment)
blueprint3 = mix_blueprints(blueprint1, blueprint2, experiment.parameters)
blueprint4 = mutate_blueprint(blueprint1, experiment.parameters, mutate_in_place=False)
for idx, blueprint in enumerate([blueprint1, blueprint2, blueprint3, blueprint4]):
self.assertIsNotNone(blueprint, 'Should have created a blueprint')
self.assertIsNotNone(blueprint.layout, 'Should have created a layout')
self.assertEqual(
1,
len(blueprint.layout.get_rows()),
'Should have 1 row')
self.assertEqual(
1,
len(blueprint.layout.get_blocks()),
'Should have 1 block')
self.assertEqual(
len(layout.block),
len(blueprint.layout.get_layers()),
'Should have predefined layers count')
for i, row in enumerate(blueprint.layout.get_rows()):
blocks = len(row.get_blocks())
self.assertTrue(
is_valid_param_value(
experiment.parameters.get_layout_parameter('blocks'),
blocks),
'Invalid value')
for block in row.get_blocks():
self.assertEqual(
len(layout.block),
len(block.layers),
'Should have used template')
for i in range(len(layout.block)):
layer = layout.block[i]
layer_type = str_param_name(layer[0] if isinstance(layer, tuple) else layer)
params = layer[1] if isinstance(layer, tuple) else dict()
self.assertEqual(
layer_type,
block.layers[i].layer_type,
'Should have used the predefined layer type')
for name, value in params.items():
self.assertEqual(
value,
block.layers[i].parameters[name],
'Should have used the predefined parameter value for blueprint %d' % idx)
def mutate_individual(self, individual, mutate_in_place=False):
return GaBlueprint(
individual=mutate_blueprint(
individual,
self.parameters,
mutate_in_place=mutate_in_place))