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