def test_modify_connection_weight(self): neat = Mutator() genome = TestGenome3() new_genome = TestGenome3() network = Network(genome) neat.modify_connection_weight(new_genome) new_network = Network(new_genome) self.assertTrue(network.genome.genes[0].weight != new_network.genome.genes[0].weight)
def test_change_connection_status(self): neat = Mutator() genome = TestGenome3() new_genome = TestGenome3() network = Network(genome) neat.change_connection_status(new_genome) new_network = Network(new_genome) self.assertFalse(new_network.genome.genes[0].enabled)
def __init__(self, config, replication=False):
self.brain = None
self.config = config
self.num_inputs = config['num_inputs']
self.num_outputs = config['num_outputs']
self.fitness = None
self.adjusted_fitness = None
if not replication:
self.brain = Network(self.config)
def test_add_new_connection(self): neat = Mutator() genome = TestGenome2() neat.add_new_connection(genome) network = Network(genome)
def initialze_network(self, **kwargs):
number_hidden_nodes = kwargs['number_hidden_nodes']
number_genes = kwargs['number_genes']
new_weight_range = kwargs['new_weight_range']
genome = Genome()
genes = []
genome.allocate_hidden_nodes(number_hidden_nodes)
self.input_node1 = genome.add_input_node()
self.input_node2 = genome.add_input_node()
self.output_node = genome.add_output_node()
genes.append(
Gene(0, self.output_node,
new_weight_range - 2 * new_weight_range * random.random()))
genes.append(
Gene(self.input_node1, self.output_node,
new_weight_range - 2 * new_weight_range * random.random()))
genes.append(
Gene(self.input_node2, self.output_node,
new_weight_range - 2 * new_weight_range * random.random()))
genome.set_genes(genes)
genome.allocate_genes(number_genes)
return Network(genome)
def test_mutate(self): neat = Mutator() genome = TestGenome2() network = Network(genome) new_network = Network(genome) neat.probabilities[1].value = 1.0 neat.mutate(new_network) self.assertEqual(network.genome.genes[0].weight, new_network.genome.genes[-1].weight) self.assertEqual(new_network.genome.genes[-2].weight, 1.0) self.assertEqual(network.genome.genes[0].in_node_id, new_network.genome.genes[-2].in_node_id) self.assertEqual(network.genome.genes[0].out_node_id, new_network.genome.genes[-1].out_node_id) self.assertFalse(new_network.genome.genes[0].enabled)
def test_add_new_node(self): neat = Mutator() genome = TestGenome2() new_genome = copy.deepcopy(genome) network = Network(genome) neat.add_new_node(new_genome) while (not new_genome.genes[-1].used): neat.add_new_node(new_genome) new_network = Network(new_genome) self.assertEqual(network.genome.genes[0].weight, new_network.genome.genes[-1].weight) self.assertEqual(new_network.genome.genes[-2].weight, 1.0) self.assertEqual(network.genome.genes[0].in_node_id, new_network.genome.genes[-2].in_node_id) self.assertEqual(network.genome.genes[0].out_node_id, new_network.genome.genes[-1].out_node_id) self.assertFalse(new_network.genome.genes[0].enabled)
def __init__(self, seed, size):
"""
Erstellt eine neue Population mit der Groesse 'size' und wird zuerst fuer den uebergebenen seed trainiert.
"""
self.seed = seed
# Das Attribut generation_count wird von Gadakeco automatisch inkrementiert.
self.generation_count = 1
# eindeutiger name name des Netzwerks (noch zu implementieren)
self.name = "name"
self.current_generation = [Network()]
def test_mate(self):
Genome.reset()
for pair in Genome.GENE_INNOVATION_PAIRS:
print(pair[0])
print(pair[1])
genome_parent_1 = TestGenome()
genome_parent_2 = TestGenome()
genome_child = TestGenome()
network_parent_1 = Network(genome_parent_1)
network_parent_2 = Network(genome_parent_2)
network_child = Network(genome_child)
genome_parent_1.add_new_node(0)
genome_parent_2.add_new_node(1)
genome_child.add_new_node(2)
Genome.mate(genome_parent_1, genome_parent_2, genome_child)
network_child.set_up(genome_child)
for i in range(-1, -4, -1):
self.assertTrue(network_child.genome.genes[i].enabled)
self.assertTrue(network_child.genome.genes[i].used)
self.assertEqual(network_child.genome.genes[3].innovation, 1)
self.assertEqual(network_child.genome.genes[4].innovation, 2)
self.assertEqual(network_child.genome.genes[5].innovation, 3)
class BallBalanceNetwork(BallBalanceBase):
"""Ball balancing game run by a neural network"""
def __init__(self, genome):
super().__init__()
self.network = Network(genome)
def update(self, dt, *args, **kwargs):
dist = self.get_center_dist()
left_dist = self.half_width + dist
right_dist = self.half_width - dist
abs_dist = abs(dist)
output = self.network.evaluate([left_dist, abs_dist, right_dist])
self.left_pressed, self.right_pressed = output
super().update(dt)
def test_network_initialization(self):
network = Network()
class Organism:
def __init__(self, config, replication=False):
self.brain = None
self.config = config
self.num_inputs = config['num_inputs']
self.num_outputs = config['num_outputs']
self.fitness = None
self.adjusted_fitness = None
if not replication:
self.brain = Network(self.config)
def think(self, sensors):
self.brain.reset()
return self.brain.forward(sensors)
def replicate(self):
copy = self.__class__(self.config, replication=True)
copy.brain = self.brain.replicate()
copy.fitness = self.fitness
return copy
def fully_weight_mutated(self):
self.brain.full_weight_mutation()
return self
def mutate(self):
self.brain.mutate()
def reset(self):
self.fitness = None
self.adjusted_fitness = None
def crossover(self, other_parent):
# Create copy of this organism (parent with higher fitness)
offspring = self.replicate()
for conn in offspring.brain.get_connections():
for other_conn in other_parent.brain.get_connections():
# If connection has matching innovation number
if conn.number == other_conn.number:
# Randomly decide which parent's weight to use
if random.random() < 0.5:
conn.weight = other_conn.weight
# disable connection with prob 0.75 if either parent connection is disabled
if not conn.enabled or not other_conn.enabled:
conn.enabled = not (random.random() < 0.75)
# disable connection with prob 0.75 parent connection is disabled
elif not conn.enabled:
conn.enabled = not (random.random() < 0.75)
return offspring
def __lt__(self, other):
return self.fitness > other.fitness
for n, weight in enumerate((-1.9623, -2.2216, 3.1370)):
genome.addConnection(x_1, hiddens[n], weight)
for n, weight in enumerate((-1.7715, -2.6616, 2.7087)):
genome.addConnection(x_2, hiddens[n], weight)
for n, weight in enumerate((2.1962, 3.1903, -3.9824)):
genome.addConnection(b_1, hiddens[n], weight)
for n, weight in enumerate((-3.9746, -6.0582, 6.5607)):
genome.addConnection(hiddens[n], h, weight)
genome.addConnection(b_2, h, 0.092103)
network = Network(genome)
if __name__ == "__main__":
# ---- NETWORK USE ----
print("Neural network implementing the AND gate")
print("Python runner written by Sam van Kampen")
print("Source: https://github.com/pws-machneutop/neurotische-netwerkjes\n")
#print("Network topology (I input B bias H hidden O output): \n")
#print("\t4(H)")
#print("1(I)\t5(H)")
#print("2(I)\t\t8(O)")
#print("3(B)\t6(H)")
#print("\t7(B)\n\n")
def __init__(self, genome):
super().__init__()
self.network = Network(genome)