def test_node_gene_json(self):
"""Test whether a node gene can be saved to and loaded from JSON."""
ng = NodeGene(Hidden())
dump = json.dumps(ng.to_json())
ng_load = NodeGene.from_json(json.loads(dump))
self.assertEqual(ng, ng_load)
def _initialize_hidden_nodes(self):
'''
hidden nodes have keys starting at n_outputs
'''
n_hidden = self.genome_config.n_initial_hidden_neurons
for key in range(self.n_output, self.n_output + n_hidden):
node = NodeGene(key=key)
node.random_initialization()
self.node_genes[key] = node
def _node_distance(self, node_1: NodeGene, node_2: NodeGene):
'''
Node distance is modified to account for both bias and standard deviation
'''
distance = l2_distance(v1=[node_1.get_mean(),
node_1.get_std()],
v2=[node_2.get_mean(),
node_2.get_std()])
# TODO: add distance components if we are allowed to change activation or aggregation
# if self.activation != other.activation:
# d += 1.0
# if self.aggregation != other.aggregation:
# d += 1.0
return distance * self.compatibility_weight_coefficient
def _give_extra_brain_cell(self):
"""Add a new node to the genome via mutation.
This process chooses a random enabled connection, and splits it into
two new connections with a new node in the middle.
"""
new_node = NodeGene(Hidden())
new_node.node.bias = 0
new_node.node.id = len(self.node_genes)
self.add_gene(new_node)
enabled_connections = list(
filter(lambda cg: cg.is_enabled, self.connection_genes))
connection_to_split = random.choice(enabled_connections)
connection_to_split.connection.is_enabled = False
first_connection = \
ConnectionGene(connection_to_split.connection.input_id, new_node.node.id)
first_connection.connection.weight = 1.0
self.add_gene(first_connection)
second_connection = \
ConnectionGene(new_node.node.id, connection_to_split.connection.input_id)
second_connection.connection.weight = \
connection_to_split.connection.weight
self.add_gene(second_connection)
def generate_genome_given_graph(graph, connection_weights):
genome = Genome(key='foo')
unique_node_keys = []
input_nodes = []
for connection in graph:
for node_key in connection:
if node_key not in unique_node_keys:
unique_node_keys.append(node_key)
if node_key < 0:
input_nodes.append(node_key)
input_nodes = set(input_nodes)
unique_node_keys = list(
set(unique_node_keys + genome.get_output_nodes_keys()) - input_nodes)
nodes = {}
for node_key in unique_node_keys:
node = NodeGene(key=node_key).random_initialization()
node.set_mean(0)
node.set_std(STD)
nodes[node_key] = node
connections = {}
for connection_key, weight in zip(graph, connection_weights):
connection = ConnectionGene(key=connection_key)
connection.set_mean(weight)
connection.set_std(STD)
connections[connection_key] = connection
genome.connection_genes = connections
genome.node_genes = nodes
return genome
def _get_node_crossover(self, node_1: NodeGene, node_2: NodeGene):
assert node_1.key == node_2.key
node_key = node_1.key
new_node = NodeGene(key=node_key)
for attribute in new_node.crossover_attributes:
if random.random() > 0.5:
self.set_child_attribute(attribute=attribute,
new_gene=new_node,
parent_gene=node_1)
else:
self.set_child_attribute(attribute=attribute,
new_gene=new_node,
parent_gene=node_2)
# setattr(new_node, attribute, getattr(node_2, attribute))
return new_node
def from_json(config):
"""Load a genome object from JSON.
Arguments:
config: the JSON dictionary loaded from file.
Returns: a genome object.
"""
genotype = Genome()
genotype.add_genes([
NodeGene.from_json(ng_config) for ng_config in config['node_genes']
])
genotype.add_genes([
ConnectionGene.from_json(cg_config)
for cg_config in config['connection_genes']
])
return genotype
def mutate_add_node(self, genome: Genome):
# TODO: careful! this can add multihop-jumps to the network
possible_connections_to_split = list(genome.connection_genes.keys())
# Choose a random connection to split
k = min(len(possible_connections_to_split),
self.architecture_mutation_power)
connection_to_split_keys = random.sample(possible_connections_to_split,
k)
for connection_to_split_key in connection_to_split_keys:
new_node_key = genome.get_new_node_key()
new_node = NodeGene(key=new_node_key).random_initialization()
genome.node_genes[new_node_key] = new_node
connection_to_split = genome.connection_genes[
connection_to_split_key]
i, o = connection_to_split_key
# add connection between input and the new node
new_connection_key_i = (i, new_node_key)
new_connection_i = ConnectionGene(key=new_connection_key_i)
new_connection_i.set_mean(mean=1.0), new_connection_i.set_std(
std=0.0000001)
genome.connection_genes[new_connection_key_i] = new_connection_i
# add connection between new node and output
new_connection_key_o = (new_node_key, o)
new_connection_o = ConnectionGene(
key=new_connection_key_o).random_initialization()
new_connection_o.set_mean(mean=connection_to_split.get_mean())
new_connection_o.set_std(std=connection_to_split.get_std())
genome.connection_genes[new_connection_key_o] = new_connection_o
# delete connection
# Careful: neat-python disable the connection instead of deleting
# conn_to_split.enabled = False
del genome.connection_genes[connection_to_split_key]
logger.network(
f'Genome {genome.key}. Mutation: Add a Node: {new_node_key} between {i}->{o}'
)
return genome
def from_dict(genome_dict: dict):
genome_config_dict = genome_dict['config']
genome_config = jsons.load(genome_config_dict, BaseConfiguration)
genome = Genome(key=genome_dict['key'],
id=genome_dict['id'],
genome_config=genome_config)
# reconstruct nodes and connections
connection_genes_dict = genome_dict['connection_genes']
for key, connection_gene_dict in connection_genes_dict.items():
connection_gene = ConnectionGene.from_dict(
connection_gene_dict=connection_gene_dict)
genome.connection_genes[connection_gene.key] = connection_gene
node_genes_dict = genome_dict['node_genes']
for key, node_gene_dict in node_genes_dict.items():
node_gene = NodeGene.from_dict(node_gene_dict=node_gene_dict)
genome.node_genes[node_gene.key] = node_gene
genome.n_weight_parameters = genome_dict['n_weight_parameters']
genome.n_bias_parameters = genome_dict['n_bias_parameters']
genome.node_counter = count(max(list(genome.node_genes.keys())) + 1)
return genome
def create_from_julia_dict(genome_dict: dict):
config = get_configuration()
genome = Genome(key=genome_dict["key"], id=None, genome_config=config)
# reconstruct nodes and connections
connection_genes_dict = genome_dict['connections']
for key_str, connection_gene_dict in connection_genes_dict.items():
connection_key = Genome._get_connection_key_from_key_str(key_str)
connection_gene = ConnectionGene(key=connection_key)
connection_gene.set_mean(connection_gene_dict['mean_weight'])
connection_gene.set_std(connection_gene_dict['std_weight'])
genome.connection_genes[connection_gene.key] = connection_gene
node_genes_dict = genome_dict['nodes']
for key_str, node_gene_dict in node_genes_dict.items():
node_key = int(key_str)
node_gene = NodeGene(key=node_key)
node_gene.set_mean(node_gene_dict['mean_bias'])
node_gene.set_std(node_gene_dict['std_bias'])
genome.node_genes[node_gene.key] = node_gene
genome.calculate_number_of_parameters()
return genome
def _initialize_output_nodes(self):
for key in self.output_nodes_keys:
node = NodeGene(key=key)
node.random_initialization()
self.node_genes[key] = node
def add_node(self, key, mean=None, std=None):
node = NodeGene(key=key)
node.set_mean(mean)
node.set_std(std)
self.node_genes[key] = node
def add_node(node_genes, key):
node_i = NodeGene(key=key)
node_i.random_initialization()
node_genes[key] = node_i
return node_genes