def test_case_7(self):
links = ((-1, 1), (-2, 1))
nodes_per_layer = calculate_nodes_per_layer(links=links,
output_node_keys=[0, 1],
input_node_keys=[-1, -2])
expected_nodes_per_layer = {0: [0, 1], 1: [-1, -2]}
self.assertEqual(nodes_per_layer, expected_nodes_per_layer)
def test_case_9(self):
links = ((-2, 1), (-1, 0), (-2, 0), (-1, 2), (2, 3), (3, 1), (3, 0))
nodes_per_layer = calculate_nodes_per_layer(links=links,
output_node_keys=[0, 1],
input_node_keys=[-1, -2])
expected_nodes_per_layer = {0: [0, 1], 1: [3], 2: [2], 3: [-1, -2]}
self.assertEqual(expected_nodes_per_layer, nodes_per_layer)
def test_case_6(self):
links = ((-1, 1), (-2, 1), (-1, 2), (-2, 2), (1, 4), (1, 3), (2, 3),
(2, 4), (-1, 3), (3, 0), (4, 0), (-1, 0), (1, 0))
nodes_per_layer = calculate_nodes_per_layer(links=links,
output_node_keys=[0],
input_node_keys=[-1, -2])
expected_nodes_per_layer = {0: [0], 1: [3, 4], 2: [1, 2], 3: [-1, -2]}
self.assertEqual(nodes_per_layer, expected_nodes_per_layer)
def transform_genome_to_layers(genome: Genome) -> dict:
layers = dict()
nodes = genome.node_genes
connections = genome.connection_genes
nodes_per_layer = calculate_nodes_per_layer(
links=list(connections.keys()),
input_node_keys=genome.get_input_nodes_keys(),
output_node_keys=genome.get_output_nodes_keys())
layer_indices = list(nodes_per_layer.keys())
layer_indices.sort()
for layer_index in layer_indices[:-1]:
original_nodes_in_layer = nodes_per_layer[layer_index]
layer = LayerBuilder(nodes=nodes,
connections=connections,
layer_node_keys=original_nodes_in_layer,
nodes_per_layer=nodes_per_layer,
layer_counter=layer_index) \
.create() \
.get_layer()
layers[layer_index] = layer
# enrich layers
for layer_counter, layer in layers.items():
# logger.debug(f'Layer: {layer_counter}')
# add needed indices
for node_key in layer.external_input_keys:
index = None
for layer_2 in layers.values():
if node_key in layer_2.original_input_keys:
index = (layer_2.key, layer_2.input_keys.index(node_key))
break
assert index is not None
layer.indices_of_needed_nodes.append(index)
layer.needed_nodes[node_key] = index
# add indices to cache
for node_key in layer.original_input_keys:
for layer_2 in layers.values():
if node_key in layer_2.external_input_keys:
index = layer.input_keys.index(node_key)
# add if not in list
if index not in layer.indices_of_nodes_to_cache:
layer.indices_of_nodes_to_cache.append(index)
if len(layer.indices_of_needed_nodes) > 1:
needed_node_keys = list(layer.needed_nodes.keys())
needed_node_keys.sort()
sorted_indices_of_needed_nodes = []
for node_key in needed_node_keys:
sorted_indices_of_needed_nodes.append(
layer.needed_nodes[node_key])
assert len(sorted_indices_of_needed_nodes) == len(
layer.indices_of_needed_nodes)
layer.indices_of_needed_nodes = sorted_indices_of_needed_nodes
logger.debug(f'Indices to cache: {layer.indices_of_nodes_to_cache}')
logger.debug(
f'Indices needed from cache: {layer.indices_of_needed_nodes}')
return layers
