def test_grid_equality(self):
global_vars.set('grid', True)
layer_grid_1 = models_generation.random_grid_model([2, 2])
layer_grid_2 = models_generation.random_grid_model([2, 2])
layer_grid_3 = models_generation.random_grid_model([2, 2])
layer_grid_1.nodes[(0,0)]['layer'] = ConvLayer(filter_num=10, kernel_time=10)
layer_grid_1.nodes[(0,1)]['layer'] = BatchNormLayer()
layer_grid_1.nodes[(1,0)]['layer'] = PoolingLayer(stride_time=3, pool_time=3)
layer_grid_1.nodes[(1,1)]['layer'] = BatchNormLayer()
layer_grid_2.nodes[(0,0)]['layer'] = ConvLayer(filter_num=10, kernel_time=10)
layer_grid_2.nodes[(0,1)]['layer'] = BatchNormLayer()
layer_grid_2.nodes[(1,0)]['layer'] = PoolingLayer(stride_time=3, pool_time=3)
layer_grid_2.nodes[(1,1)]['layer'] = BatchNormLayer()
layer_grid_3.nodes[(0, 0)]['layer'] = ConvLayer(filter_num=10, kernel_time=10)
layer_grid_3.nodes[(0, 1)]['layer'] = BatchNormLayer()
layer_grid_3.nodes[(1, 0)]['layer'] = PoolingLayer(stride_time=2, pool_time=3)
layer_grid_3.nodes[(1, 1)]['layer'] = BatchNormLayer()
assert(equal_grid_models(layer_grid_1, layer_grid_2))
assert(not equal_grid_models(layer_grid_1, layer_grid_3))
layer_grid_2.add_edge((0,0),(1,1))
layer_grid_1.add_edge((0,0),(1,1))
assert (equal_grid_models(layer_grid_1, layer_grid_2))
layer_grid_2.add_edge((0,0),(1,0))
assert (not equal_grid_models(layer_grid_1, layer_grid_2))
def test_remove_all_edges_from_input(self):
global_vars.set('grid', True)
global_vars.set('parallel_paths_experiment', True)
layer_grid_1 = models_generation.random_grid_model([5, 10])
layer_grid_1.remove_edge('input', (0, 0))
layer_grid_1.remove_edge('input', (1, 0))
layer_grid_1.remove_edge('input', (2, 0))
layer_grid_1.remove_edge('input', (3, 0))
layer_grid_1.remove_edge('input', (4, 0))
model = models_generation.ModelFromGrid(layer_grid_1)
def test_random_grid_model(self):
model = models_generation.random_grid_model([10, 10])
for i in range(100):
add_random_connection(model)
model.add_edge('input', (0, 5))
real_model = models_generation.ModelFromGrid(model)
input_shape = (2, global_vars.get('eeg_chans'), global_vars.get('input_time_len'), 1)
out = real_model.forward(np_to_var(np.ones(input_shape, dtype=np.float32)))
print(list(nx.topological_sort(model)))
nx.draw(model, with_labels=True)
plt.show()
def test_breed_grid(self):
global_vars.set('grid', True)
layer_grid_1 = models_generation.random_grid_model([5, 5])
layer_grid_2 = models_generation.random_grid_model([5, 5])
for node in layer_grid_1.nodes.values():
node['layer'] = models_generation.random_layer()
for node in layer_grid_2.nodes.values():
node['layer'] = models_generation.random_layer()
layer_grid_1.nodes[(0,0)]['layer'] = ConvLayer()
layer_grid_1.nodes[(0,1)]['layer'] = BatchNormLayer()
layer_grid_1.nodes[(0,2)]['layer'] = PoolingLayer()
layer_grid_1.nodes[(0,3)]['layer'] = BatchNormLayer()
layer_grid_1.nodes[(0,4)]['layer'] = DropoutLayer()
layer_grid_1.nodes[(1,1)]['layer'] = BatchNormLayer()
layer_grid_1.nodes[(2,2)]['layer'] = ConvLayer()
layer_grid_2.nodes[(0, 0)]['layer'] = BatchNormLayer()
layer_grid_2.nodes[(0, 1)]['layer'] = PoolingLayer()
layer_grid_2.nodes[(0, 2)]['layer'] = ConvLayer()
layer_grid_2.nodes[(0, 3)]['layer'] = BatchNormLayer()
layer_grid_2.nodes[(0, 4)]['layer'] = IdentityLayer()
layer_grid_2.nodes[(1, 1)]['layer'] = ConvLayer()
layer_grid_2.nodes[(2, 2)]['layer'] = IdentityLayer()
layer_grid_2.nodes[(3, 3)]['layer'] = BatchNormLayer()
layer_grid_2.nodes[(2, 4)]['layer'] = IdentityLayer()
layer_grid_2.nodes[(2, 0)]['layer'] = PoolingLayer()
layer_grid_1.add_edge((0, 1), (2, 1))
layer_grid_1.add_edge((0, 1), (2, 2))
layer_grid_1.add_edge((0, 2), (2, 0))
layer_grid_1.add_edge((0, 2), (2, 3))
layer_grid_1.add_edge((2, 2), (0, 4))
layer_grid_1.add_edge((2, 3), (0, 3))
layer_grid_1.add_edge((3, 1), (2, 3))
layer_grid_2.add_edge((0, 0), (1, 1))
layer_grid_2.add_edge((0, 1), (0, 2))
layer_grid_2.add_edge((0, 1), (3, 3))
layer_grid_2.add_edge((0, 3), (1, 1))
layer_grid_2.add_edge((0, 3), (2, 4))
layer_grid_2.add_edge((1, 1), (0, 4))
layer_grid_2.add_edge((2, 2), (3, 3))
layer_grid_2.add_edge((3, 3), (0, 3))
model_1 = models_generation.ModelFromGrid(layer_grid_1)
model_2 = models_generation.ModelFromGrid(layer_grid_2)
child_model, child_model_state, _ = breed_grid(0, layer_grid_1, layer_grid_2, model_1.state_dict(), model_2.state_dict(),
cut_point=2)
assert (type(child_model.nodes[(0, 0)]['layer']) == ConvLayer)
assert (type(child_model.nodes[(0, 1)]['layer']) == BatchNormLayer)
assert (type(child_model.nodes[(0, 2)]['layer']) == ConvLayer)
assert (type(child_model.nodes[(0, 3)]['layer']) == BatchNormLayer)
assert (type(child_model.nodes[(0, 4)]['layer']) == IdentityLayer)
assert (type(child_model.nodes[(1, 1)]['layer']) == BatchNormLayer)
assert (type(child_model.nodes[(2, 2)]['layer']) == IdentityLayer)
assert (type(child_model.nodes[(3, 3)]['layer']) == BatchNormLayer)
assert (type(child_model.nodes[(2, 4)]['layer']) == IdentityLayer)
finalized_child_model = finalize_model(child_model)
finalized_child_model.load_state_dict(child_model_state)
model_1_state = model_1.state_dict()
child_state = finalized_child_model.state_dict()
for key in child_state.keys():
if '(0, 0)' in key:
assert child_state[key].equal(model_1_state[key])
if '(0, 1)' in key:
assert child_state[key].equal(model_1_state[key])
def test_remove_random_connection(self):
model = models_generation.random_grid_model([10, 10])
num_connections = len(list(model.edges))
success = models_generation.remove_random_connection(model)
assert(len(list(model.edges)) == num_connections - 1 or not success)
def test_save_best_model_grid(self):
global_vars.set('grid', True)
global_vars.set('layer_num', [10, 10])
weighted_population = [{'model': random_grid_model([10, 10])}]
self.naiveNAS.save_best_model(weighted_population)