def fitness_xor(net: neat.Network):
total, p = 0, 2
total += np.power(0 - net.predict([0, 0]), p)
total += np.power(1 - net.predict([0, 1]), p)
total += np.power(1 - net.predict([1, 0]), p)
total += np.power(0 - net.predict([1, 1]), p)
total = total[0]
return 4 - total
def fitness_car_race(net: neat.Network, render: bool=False, steps=1000):
score = 0
for _ in range(3):
# env._max_episode_steps = steps
obs = env.reset()
net.clear()
s = 0
while True:
close = False
if render:
close = not env.render()
# print(obs)
obs = obs / 255.0
obs_in = obs[::8,::8]
# if render:
# plt.cla()
# plt.imshow(obs_in[:,:,1])
# plt.pause(0.00001)
res = net.predict(obs_in.flatten())
res = res * 2 - 1
action = res #np.argmax(res)
obs, reward, done, _ = env.step(action)
s += reward
if done or close:
break
score += s
if render:
print(s)
env.close()
if close:
break
return score / 3
def create_network(self, cppn: neat.Network):
# print(cppn)
m = None
try:
m = nn.Model.from_config(self.model_cfg)
except Exception as e:
print("Error time: {}".format(e))
print(m)
print(nn)
print(nn.Model)
print(self.model_cfg)
import sys
sys.exit()
for i in range(len(m.layers)):
layer = m.layers[i]
# print(i, layer.output_shape)
if isinstance(layer, nn.Dense):
for j in range(layer.W.shape[1]):
# print(j, layer.W.shape[1])
layer.b[j] = cppn.predict([0.0, 0.0, 0.0, 0.0
])[2 * i + 0] * 20
for k in range(layer.W.shape[0]):
layer.W[k, j] = cppn.predict([
(k + 0.5) / layer.W.shape[0] * 2 - 1,
(j + 0.5) / layer.W.shape[1] * 2 - 1,
0.0,
0.0,
])[2 * i + 1] * 20
# print(layer.get_weights())
elif isinstance(layer, nn.Conv2D):
for i0 in range(layer.W.shape[0]):
for i1 in range(layer.W.shape[1]):
for i2 in range(layer.W.shape[2]):
for i3 in range(layer.W.shape[3]):
layer.W[i0, i1, i2, i3] = cppn.predict([
(i0 + 0.5) / layer.W.shape[0] * 2 - 1,
(i1 + 0.5) / layer.W.shape[1] * 2 - 1,
(i2 + 0.5) / layer.W.shape[2] * 2 - 1,
(i3 + 0.5) / layer.W.shape[3] * 2 - 1,
])[2 * i + 1] * 20
else:
# raise Exception("Unknown layer type: {}".format(type(layer)))
pass
return m
def fitness_lander(net: neat.Network, render: bool = False, steps=1000):
score = 0
n = 10
if render:
n = 3
for _ in range(n):
env._max_episode_steps = steps
obs = env.reset()
net.clear()
# total reward (fitness score)
s = 0
while True:
close = False
if render:
close = not env.render()
# print(obs)
# determine action to take
res = net.predict(obs)
res = res * 2 - 1
action = res #np.argmax(res)
obs, reward, done, _ = env.step(action)
s += reward
if done or close:
break
score += s
if render:
print(s)
env.close()
if close:
break
env.close()
return score / n
def fitness_pong(net: neat.Network, render: bool = False, steps=1000):
score = 0
for _ in range(1):
# env._max_episode_steps = steps
obs = env.reset()
net.clear()
# fitness
s = 0
while True:
close = False
if render:
close = not env.render()
# print(obs)
obs = obs / 256
# determine action
res = net.predict(obs)
action = np.argmax(res)
obs, reward, done, _ = env.step(action)
s += reward
if done or close:
break
score += s
if render:
print(s)
env.close()
if close:
break
return score
def main():
net = Network()
net.addLayer(LayerFactory.newInputLayer(2))
net.addLayer(LayerFactory.newHiddenLayer(1, net.layers[0]))
net.addLayer(LayerFactory.newOutputLayer(1, net.layers[1]))
trainer = Trainer(net, 200)
populationstuff = trainer.train(150, 0.005, 3)
#from here on its just demonstrating what the best network can do after training
#species should already be sorted by fitness, so the best one is just the first element
trainer.network.loadDNA(populationstuff.population[0])
inputs = []
inputs.append(uniform(-5, 10))
inputs.append(uniform(-10, 20))
trainer.network.setInputs(inputs)
result = trainer.network.run()[0]
expectation = inputs[0] - inputs[1]
print("Input 0: " + str(inputs[0]) + " Input 1: " + str(inputs[1]))
print("Expected output: " + str(expectation))
print("Actual output: " + str(result))
print("Difference: " + str(abs(result - expectation)))
def setup(genome, node_inno, con_inno):
seed(1337)
print('========== Test 1 ==========')
genome = Genome()
genome.add_node(Node(0, 0, NodeType.INPUT))
genome.add_node(Node(1, 1, NodeType.OUTPUT))
genome.add_connection(Connection(0, 0, 1, 0.5, True))
net = Network(genome)
input = [1.0]
for _ in range(3):
output = net.calculate(input)
print(f'Output len={len(output)}, output[0]={output[0]}=0.9192')
print()
print('========== Test 2 ==========')
genome = Genome()
genome.add_node(Node(0, 0, NodeType.INPUT))
genome.add_node(Node(1, 1, NodeType.OUTPUT))
genome.add_connection(Connection(0, 0, 1, 0.1, True))
net = Network(genome)
input = [-0.5]
for _ in range(3):
output = net.calculate(input)
print(f'Output len={len(output)}, output[0]={output[0]}=0.50973')
print()
print('========== Test 3 ==========')
genome = Genome()
genome.add_node(Node(0, 0, NodeType.INPUT))
genome.add_node(Node(1, 2, NodeType.OUTPUT))
genome.add_node(Node(2, 1, NodeType.HIDDEN))
genome.add_connection(Connection(0, 0, 2, 0.4, True))
genome.add_connection(Connection(1, 2, 1, 0.7, True))
net = Network(genome)
input = [0.9]
for _ in range(3):
output = net.calculate(input)
print(f'Output len={len(output)}, output[0]={output[0]}=0.9524')
print()
print('========== Test 4 ==========')
genome = Genome()
genome.add_node(Node(0, 0, NodeType.INPUT))
genome.add_node(Node(1, 0, NodeType.INPUT))
genome.add_node(Node(2, 0, NodeType.INPUT))
genome.add_node(Node(3, 2, NodeType.OUTPUT))
genome.add_node(Node(4, 1, NodeType.HIDDEN))
genome.add_connection(Connection(0, 0, 4, 0.4, True))
genome.add_connection(Connection(1, 1, 4, 0.7, True))
genome.add_connection(Connection(2, 2, 4, 0.1, True))
genome.add_connection(Connection(3, 4, 3, 1.0, True))
net = Network(genome)
input = [0.5, 0.75, 0.9]
for _ in range(3):
output = net.calculate(input)
print(f'Output len={len(output)}, output[0]={output[0]}=0.9924')
print()
print('========== Test 5 ==========')
genome = Genome()
genome.add_node(Node(0, 0, NodeType.INPUT))
genome.add_node(Node(1, 0, NodeType.INPUT))
genome.add_node(Node(2, 0, NodeType.INPUT))
genome.add_node(Node(3, 2, NodeType.OUTPUT))
genome.add_node(Node(4, 1, NodeType.HIDDEN))
genome.add_node(Node(5, 1, NodeType.HIDDEN))
genome.add_connection(Connection(0, 0, 4, 0.4, True))
genome.add_connection(Connection(1, 1, 4, 0.7, True))
genome.add_connection(Connection(2, 2, 4, 0.1, True))
genome.add_connection(Connection(3, 4, 3, 1.0, True))
genome.add_connection(Connection(4, 2, 5, 0.2, True))
genome.add_connection(Connection(5, 5, 4, 0.75, True))
genome.add_connection(Connection(6, 5, 3, 0.55, True))
net = Network(genome)
input = [1., 2., 3.]
for _ in range(3):
output = net.calculate(input)
print(f'Output len={len(output)}, output[0]={output[0]}=0.99895')
print()
# print(nets[0].dna)
# print(nets[1].dna)
max_fit = 0
curr_i = 0
for i in range(len(nets)):
if nets[i].fitness > max_fit:
max_fit = nets[i].fitness
curr_i = i
data_handler.save(nets, "save")
genome = data_handler.load("save")[1]
n = Network(3, 1, False, 1, genome, False, False)
answer = n.feed_forward([0, 0, 1])[0]
print(answer)
n.fitness += abs(0 - answer)
answer = n.feed_forward([1, 0, 1])[0]
print(answer)
n.fitness += abs(1 - answer)
answer = n.feed_forward([0, 1, 1])[0]
print(answer)
n.fitness += abs(1 - answer)
answer = n.feed_forward([1, 1, 1])[0]