def create(self):
# layer_node_keys = _filter_nodes_without_input_connection(node_keys=self.layer_node_keys,
# connections=self.connections)
layer_node_keys = self.nodes_per_layer[self.layer_counter]
layer_node_keys.sort()
n_output = len(layer_node_keys)
layer_connections = dict()
input_node_keys = set(self.nodes_per_layer[self.layer_counter + 1])
for connection_key, connection in self.connections.items():
if isinstance(connection_key, str):
connection_key_corrected = Genome._get_connection_key_from_key_str(
connection_key)
else:
connection_key_corrected = connection_key
input_node_key, output_node_key = connection_key_corrected
if output_node_key in layer_node_keys:
input_node_keys = input_node_keys.union({input_node_key})
layer_connections[connection_key_corrected] = self.connections[
connection_key]
input_node_keys = list(input_node_keys)
n_input = len(input_node_keys)
self.layer = Layer(key=self.layer_counter,
n_input=n_input,
n_output=n_output)
# sorted input keys
logger.debug(f'Layer: {self.layer_counter}')
original_input_keys = self.nodes_per_layer[self.layer_counter + 1]
original_input_keys.sort()
external_input_keys = self._get_external_input_keys(
input_node_keys, original_input_keys)
input_node_keys = original_input_keys + external_input_keys
logger.debug(f' Input Keys: {input_node_keys}')
self.layer.input_keys = input_node_keys
self.layer.original_input_keys = original_input_keys
self.layer.external_input_keys = external_input_keys
self.layer.output_keys = layer_node_keys
# set parameters
self.layer.weight_mean, self.layer.weight_log_var = \
self._build_weight_tensors(layer_connections=layer_connections,
input_node_keys=input_node_keys,
layer_node_keys=layer_node_keys,
n_input=n_input,
n_output=n_output)
self.layer.bias_mean, self.layer.bias_log_var = self._build_bias_tensors(
layer_node_keys, self.nodes)
self.layer.validate()
return self
def transform_genome_to_layers(genome: dict, n_input, n_output) -> dict:
layers = dict()
nodes = genome['nodes']
connections = genome['connections']
links = [
Genome._get_connection_key_from_key_str(key_str)
for key_str in connections.keys()
]
nodes_per_layer = calculate_nodes_per_layer(
links=links,
input_node_keys=_get_input_node_keys(n_input=n_input),
output_node_keys=_get_output_node_keys(n_output=n_output))
layer_indices = list(nodes_per_layer.keys())
layer_indices.sort()
for layer_index in layer_indices[:-1]:
# print(layer_index)
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