def test_fully_connected_hidden_nodirect_old(self):
"""
full (no specification re direct/nodirect) with hidden nodes;
should output warning re docs/code conflict.
"""
gid = 42
config = self.config.genome_config
config.initial_connection = 'full'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
print("\nThis should output a warning:", file=sys.stderr)
g.configure_new(config) # TODO: Test for emitted warning
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertEqual(len(g.connections), 6)
# Check that each input is connected to each hidden node.
for i in config.input_keys:
for h in (1, 2):
assert ((i, h) in g.connections)
# Check that each hidden node is connected to the output.
for h in (1, 2):
assert ((h, 0) in g.connections)
# Check that inputs are not directly connected to the output
for i in config.input_keys:
assert ((i, 0) not in g.connections)
def run(path):
global G_gen
global G_hall_of_fame
config = neat.config.Config(*C_NEAT_CONFIG_DEFAULTS, path)
pop = neat.Population(config)
pop.add_reporter(neat.StdOutReporter(True))
stats = neat.StatisticsReporter()
pop.add_reporter(stats)
best_fitness = -1000
winner = neat.DefaultGenome(0)
graph = Graph(C_FITNESS_THRESHOLD, C_HANDS_PER_GENERATION, C_POP_PER_GEN)
while best_fitness < C_FITNESS_THRESHOLD:
winner = pop.run(eval_genomes, 1)
G_hall_of_fame.append(winner.fitness)
G_ao10.append(average(G_hall_of_fame))
graph.update(G_hall_of_fame, G_ao10, G_gen)
best_fitness = winner.fitness
print("Winner (after %s hand of blackjack):" %
(C_HANDS_PER_GENERATION * C_POP_PER_GEN * G_gen))
print(winner)
with open("winner-feedforward", 'wb') as f:
pickle.dump(winner, f)
print("Winner saved")
def test_fully_connected_hidden(self):
gid = 42
config = self.config.genome_config
config.initial_connection = 'full'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(iterkeys(g.nodes)), {0, 1, 2})
self.assertEqual(len(g.connections), 6)
# Check that each input is connected to each hidden node.
for i in config.input_keys:
for h in (1, 2):
assert ((i, h) in g.connections)
# Check that each hidden node is connected to the output.
for h in (1, 2):
assert ((h, 0) in g.connections)
# Check that inputs are not directly connected to outputs
for i in config.input_keys:
assert ((i, 0) not in g.connections)
def test_fully_connected_hidden_direct(self):
"""full with direct input-output connections (and also via hidden hodes)."""
gid = 42
config = self.config.genome_config
config.initial_connection = 'full_direct'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertEqual(len(g.connections), 8)
# Check that each input is connected to each hidden node.
for i in config.input_keys:
for h in (1, 2):
assert ((i, h) in g.connections)
# Check that each hidden node is connected to the output.
for h in (1, 2):
assert ((h, 0) in g.connections)
# Check that inputs are directly connected to the output
for i in config.input_keys:
assert ((i, 0) in g.connections)
def test_unconnected_hidden(self):
gid = 42
config = self.config.genome_config
config.initial_connection = 'unconnected'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(self.config.genome_config)
print(g)
self.assertEqual(set(iterkeys(g.nodes)), {0, 1, 2})
assert (not g.connections)
def test_fs_neat_nohidden(self):
"""fs_neat not connecting hidden nodes."""
gid = 42
config = self.config.genome_config
config.initial_connection = 'fs_neat_nohidden'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertEqual(len(g.connections), 1)
def test_partially_connected_no_hidden(self):
gid = 42
config = self.config.genome_config
config.initial_connection = 'partial'
config.connection_fraction = 0.5
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(iterkeys(g.nodes)), {0})
self.assertLess(len(g.connections), 2)
def test_unconnected_no_hidden(self):
"""Unconnected network with only input and output nodes."""
gid = 42
config = self.config.genome_config
config.initial_connection = 'unconnected'
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(self.config.genome_config)
print(g)
self.assertEqual(set(g.nodes), {0})
assert (not g.connections)
def test_partially_connected_hidden_nodirect(self):
"""partial with no direct input-output connections, only via hidden nodes."""
gid = 42
config = self.config.genome_config
config.initial_connection = 'partial_nodirect'
config.connection_fraction = 0.5
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertLess(len(g.connections), 6)
def test_fs_neat_no_hidden(self):
"""
fs_neat with no hidden nodes
(equivalent to fs_neat_hidden and fs_neat_nohidden with no hidden nodes).
"""
gid = 42
config = self.config.genome_config
config.initial_connection = 'fs_neat'
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0})
self.assertEqual(len(g.connections), 1)
def test_fully_connected_no_hidden(self):
gid = 42
config = self.config.genome_config
config.initial_connection = 'full'
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(iterkeys(g.nodes)), {0})
self.assertEqual(len(g.connections), 2)
# Check that each input is connected to the output node
for i in config.input_keys:
assert ((i, 0) in g.connections)
def test_fs_neat_hidden_old(self):
"""
fs_neat (without hidden/nohidden specification) with hidden;
should output warning about doc/code conflict.
"""
gid = 42
config = self.config.genome_config
config.initial_connection = 'fs_neat'
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
print("\nThis should output a warning:", file=sys.stderr)
g.configure_new(config) # TODO: Test for emitted warning
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertEqual(len(g.connections), 1)
def test_partially_connected_no_hidden(self):
"""
partial with no hidden nodes
(equivalent to partial_nodirect and partial_direct with no hidden nodes)
"""
gid = 42
config = self.config2.genome_config
config.initial_connection = 'partial'
config.connection_fraction = 0.5
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0})
self.assertLess(len(g.connections), 2)
def test_partially_connected_hidden_direct(self):
"""
partial with (potential) direct input-output connections
(and also, potentially, via hidden hodes).
"""
gid = 42
config = self.config.genome_config
config.initial_connection = 'partial_direct'
config.connection_fraction = 0.5
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(iterkeys(g.nodes)), {0, 1, 2})
self.assertLess(len(g.connections), 8)
def test_partially_connected_hidden_nodirect_old(self):
"""
partial (no specification re direct/nodirect) with hidden nodes;
should output warning re docs/code conflict.
"""
gid = 42
config = self.config2.genome_config
config.initial_connection = 'partial'
config.connection_fraction = 0.5
config.num_hidden = 2
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
print("\nThis should output a warning:", file=sys.stderr)
g.configure_new(config) # TODO: Test for emitted warning
print(g)
self.assertEqual(set(g.nodes), {0, 1, 2})
self.assertLess(len(g.connections), 6)
def test_fully_connected_no_hidden(self):
"""
full with no hidden nodes
(equivalent to full_nodirect and full_direct with no hidden nodes)
"""
gid = 42
config = self.config.genome_config
config.initial_connection = 'full'
config.num_hidden = 0
g = neat.DefaultGenome(gid)
self.assertEqual(gid, g.key)
g.configure_new(config)
print(g)
self.assertEqual(set(g.nodes), {0})
self.assertEqual(len(g.connections), 2)
# Check that each input is connected to the output node
for i in config.input_keys:
assert ((i, 0) in g.connections)
def genome_and_network_fixture(gid: int):
genome = neat.DefaultGenome(gid)
genome.configure_new(CONFIG.genome_config)
network = neat.nn.FeedForwardNetwork.create(genome, CONFIG)
return genome, network
def keras2neat(neat_config,
keras_h5_path,
new_genome_key,
run_name='1',
generation=''):
new_genome_key = str(new_genome_key)
print("[keras2neat] Loading model data..")
model_data = load_keras2neat_model_data(keras_h5_path)
print("[keras2neat] Loaded.")
# Use a random key
new_genome = neat.DefaultGenome(new_genome_key)
num_inputs = model_data[0]['kernel'].shape[0]
num_outputs = model_data[-1]['kernel'].shape[1]
new_node_id = num_outputs
prev_layer_size = None
total_layer_size = 0
prev_layer_first_id = 0
prev_layer_last_id = 0
layer_last_id = 0
complete = False
# create the output nodes
for o in range(num_outputs):
new_node = new_genome.create_node(neat_config.genome_config, o)
# set the bias of the node
setattr(new_node, 'bias', model_data[-1]["bias"][o])
new_genome.nodes[o] = new_node
for layer_id, layer in enumerate(model_data):
if complete:
break
layer_size = layer["bias"].shape[0]
layer_first_node_id = new_node_id
total_layer_size += layer_size
if layer_id != 0:
prev_layer_first_id = new_node_id - prev_layer_size
prev_layer_last_id = prev_layer_first_id + prev_layer_size
layer_last_id = layer_first_node_id + layer_size
for j in range(layer_size):
# each entry in ['bias'] represents a node in this layer
# create a new node
new_node = new_genome.create_node(neat_config.genome_config,
new_node_id)
# set the bias of the node
setattr(new_node, 'bias', layer["bias"][j])
# add the node to the genome
new_genome.nodes[new_node_id] = new_node
# add the connections to the previous layer. NOTE: Assumes a fully connected network
if layer_id == 0:
# connect to the inputs (ID is negative)
for k in range(-1, -num_inputs - 1, -1):
#print("connecting {} to {}".format(k, new_node_id))
new_genome.add_connection(neat_config.genome_config, k,
new_node_id,
layer["kernel"][k][j], True)
elif layer_id == len(model_data) - 1:
# connect the outputs
for p in range(prev_layer_size):
for o in range(num_outputs):
# connect the prev_layer to the output
new_genome.add_connection(neat_config.genome_config,
p + prev_layer_first_id, o,
layer['kernel'][p][o], True)
complete = True
break
else:
#print("Connecting hidden layer {}..".format(layer_id))
# connect to the previous layer
for k_i, k in enumerate(layer['kernel']):
new_genome.add_connection(neat_config.genome_config,
k_i + prev_layer_first_id,
new_node_id, k[j], True)
new_node_id += 1
prev_layer_size = layer_size
visualize.draw_net(neat_config,
new_genome,
view=False,
filename="eval/run_{}/keras2neat/{}_gen_{}".format(
run_name, new_genome_key, generation))
return new_genome
