def run():
t0 = time.time()
# Load the config file, which is assumed to live in
# the same directory as this script.
local_dir = os.path.dirname(__file__)
config = Config(os.path.join(local_dir, "xor2_config"))
num_workers = 6
pool = Pool(num_workers)
print("Starting with %d workers" % num_workers)
def fitness(genomes):
return eval_fitness(genomes, pool)
pop = population.Population(config)
pop.epoch(fitness, 400)
print("total evolution time %.3f sec" % (time.time() - t0))
print("time per generation %.3f sec" % ((time.time() - t0) / pop.generation))
winner = pop.most_fit_genomes[-1]
print("Number of evaluations: %d" % winner.ID)
# Verify network output against training data.
print("\nBest network output:")
net = nn.create_feed_forward_phenotype(winner)
for i, inputs in enumerate(INPUTS):
output = net.serial_activate(inputs) # serial activation
print("%1.5f \t %1.5f" % (OUTPUTS[i], output[0]))
# Visualize the winner network and plot statistics.
visualize.plot_stats(pop.most_fit_genomes, pop.avg_fitness_scores)
visualize.plot_species(pop.species_log)
visualize.draw_net(winner, view=True)
def evaluate_genome(g):
net = nn.create_feed_forward_phenotype(g)
fitnesses = []
for runs in range(runs_per_net):
sim = cart_pole.CartPole()
# Run the given simulation for up to num_steps time steps.
fitness = 0.0
for s in range(num_steps):
inputs = sim.get_scaled_state()
action = net.serial_activate(inputs)
# Apply action to the simulated cart-pole
force = cart_pole.discrete_actuator_force(action)
sim.step(force)
# Stop if the network fails to keep the cart within the position or angle limits.
# The per-run fitness is the number of time steps the network can balance the pole
# without exceeding these limits.
if abs(sim.x) >= sim.position_limit or abs(sim.theta) >= sim.angle_limit_radians:
break
fitness += 1.0
fitnesses.append(fitness)
# The genome's fitness is its worst performance across all runs.
return min(fitnesses)
def eval_fitness(genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
# When the output matches expected for all inputs, fitness will reach
# its maximum value of 1.0.
g.fitness = get_fitness(net.serial_activate)
def testGenome(genome, v=False,summary=False):
g = genome
net = nn.create_feed_forward_phenotype(g)
wordsFound=[]
allwords=[]
score = 0.0
for i in range(tests):
letters = [random.randint(0,1) for i in range(26)]
output = net.serial_activate(letters)
word = decrypt(output)
allwords.append(word)
if word in words:
wordsFound.append(word)
wordsFound = set(wordsFound)
if v: print(wordsFound)
profile = ([len(set(map(lambda x: x[i],wordsFound))) for i in range(outputLength)])
profile = sum([x/float(len(letters)) for x in profile])/(outputLength)
score = 0.5*profile
score += 0.5*len(wordsFound)/float(tests)
if summary:
for i in allwords:
if i in words:print('%s - GOOD'%i)
else:print('%s - BAD'%i)
print (score)
return score
def run():
t0 = time.time()
# Get the path to the config file, which is assumed to live in
# the same directory as this script.
local_dir = os.path.dirname(__file__)
config_path = os.path.join(local_dir, 'xor2_config')
# Use a pool of four workers to evaluate fitness in parallel.
pe = parallel.ParallelEvaluator(4, fitness)
pop = population.Population(config_path)
pop.run(pe.evaluate, 400)
print("total evolution time {0:.3f} sec".format((time.time() - t0)))
print("time per generation {0:.3f} sec".format(
((time.time() - t0) / pop.generation)))
print('Number of evaluations: {0:d}'.format(pop.total_evaluations))
# Show output of the most fit genome against training data.
winner = pop.statistics.best_genome()
print('\nBest genome:\n{!s}'.format(winner))
print('\nBest network output:')
net = nn.create_feed_forward_phenotype(winner)
for i, inputs in enumerate(xor_inputs):
output = net.serial_activate(inputs) # serial activation
print("{0:1.5f} \t {1:1.5f}".format(xor_outputs[i], output[0]))
def eval_fitness(genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
sum_square_error = 0.0
for inputs, expected in zip(inputsTrain, outputsTrain):
output = net.serial_activate(inputs)
sum_square_error += np.mean((output - expected) ** 2)
g.fitness = -sum_square_error
def initialize():
module_dir = os.path.dirname(os.path.abspath(__file__))
textfile_path = os.path.join(module_dir, 'nn_winner_genome')
with open(textfile_path, 'rb') as f:
genome = pickle.load(f)
print genome
return nn.create_feed_forward_phenotype(genome)
def simpler_eval_fitness(genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
error = 0.0
for inputs, expected in zip(simpler_inputs, simpler_outputs):
output = net.serial_activate(inputs)
error += (output[0] - expected) ** 2
g.fitness = 1-error
def update_fitness_G(genomes,D):
for g in genomes:
g.fitness = 0.0
for i in range(len(dataset)):
noise = [ random.random() for x in range(G_config.input_nodes) ]
generated = apply_network(nn.create_feed_forward_phenotype(g),noise)
g.fitness += apply_network(D,generated)[0] / len(dataset)
def parallel_evaluation(genome):
""" This function will run in parallel """
net = nn.create_feed_forward_phenotype(genome)
error = 0.0
for inputData, outputData in zip(INPUTS, OUTPUTS):
# serial activation
output = net.serial_activate(inputData)
error += (output[0] - outputData) ** 2
return 1 - math.sqrt(error / len(OUTPUTS))
def eval_fitness(genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
sum_square_error = 0.0
for inputs, expected in zip(xor_inputs, xor_outputs):
# Serial activation propagates the inputs through the entire network.
output = net.serial_activate(inputs)
sum_square_error += (output[0] - expected) ** 2
# When the output matches expected for all inputs, fitness will reach
# its maximum value of 1.0.
g.fitness = 1 - sum_square_error
def eval_mono_image(genome, width, height):
net = nn.create_feed_forward_phenotype(genome)
image = []
for r in range(height):
y = -2.0 + 4.0 * r / (height - 1)
row = []
for c in range(width):
x = -2.0 + 4.0 * c / (width - 1)
output = net.serial_activate([x, y])
gray = 255 if output[0] > 0.0 else 0
row.append(gray)
image.append(row)
return image
def eval_gray_image(genome, width, height):
net = nn.create_feed_forward_phenotype(genome)
image = []
for r in range(height):
y = -1.0 + 2.0 * r / (height - 1)
row = []
for c in range(width):
x = -1.0 + 2.0 * c / (width - 1)
output = net.serial_activate([x, y])
gray = int(round((output[0] + 1.0) * 255 / 2.0))
gray = max(0, min(255, gray))
row.append(gray)
image.append(row)
return image
def __init__(self, genome):
self.genome = genome
self.color = ['blue', 'red', 'yellow', 'black'][rnd.randint(0,3)]
self.state = 0 # denotes the state of the wing
self.generator = cycle([0,1,2,1]) # iterator of the wing states
self.alive = True
self.jumps = 0 # counts total number of flaps
self.x = WIDTH // 5
self.y = HEIGHT // 2.5
self.velocity = -8 # vertical velocity
self.acceleration = 1 # vertical acceleration
self.brain = nn.create_feed_forward_phenotype(genome)
def update_fitness_D(genomes,G):
for g in genomes:
real_inputs, real_outputs = zip(*dataset)
noise = [ random.random() for x in range(G_config.input_nodes) ]
fake_inputs = [ apply_network(G,noise) for _ in range( len(dataset) ) ]
fake_outputs = [ [0] for x in range( len(dataset) ) ]
inputs = list(real_inputs) + fake_inputs
outputs = list(real_outputs) + fake_outputs
g.fitness = 1 - evaluate_network(nn.create_feed_forward_phenotype(g),
inputs,outputs)
def eval_fitness(self,genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
output = []
for x in self.fit_X:
l = net.serial_activate(x)
count = 0
sum = 0
for j in l:
#print(l)
sum += j
count += 1
k = sum/count
output.append(k)
error = roc_auc_score(self.fit_Y,output)
g.fitness = 1 - error
def new_and_simpler_stuff():
pop.epoch(simpler_eval_fitness, num_epochs)
print('Number of evaluations: {0}'.format(pop.total_evaluations))
# Display the most fit genome.
print('\nBest genome:')
winner = pop.most_fit_genomes[-1]
print(winner)
# Verify network output against training data.
print('\nOutput:')
winner_net = nn.create_feed_forward_phenotype(winner)
for inputs, expected in zip(simpler_inputs, simpler_outputs):
output = winner_net.serial_activate(inputs)
print("expected {0:1.5f} got {1:1.5f}".format(expected, output[0]))
import ipdb; ipdb.set_trace()
import pydevd; pydevd.settrace()
def __init__(self, x, main_game, genome):
self._id = x
self.main_game = main_game
self._x = random.randint(0, self.main_game.screen_width) * 1.0
self._y = random.randint(0, self.main_game.screen_height) * 1.0
self._r = random.randint(0, 360) * 1.0
self._line = 0
self._sprite = pygame.Surface((20, 20))
pygame.draw.polygon(self._sprite, Color("Purple"), ((6, 0), (0, 12), (12, 12)))
self._net = nn.create_feed_forward_phenotype(genome)
self._genome = genome
self._rect = self._sprite.get_rect()
self.projectiles = []
self.alive = True
self._genome.fitness = 0
self.hunger = 0
self.reload = 0
def eval_color_image(genome, width, height):
net = nn.create_feed_forward_phenotype(genome)
image = []
for r in range(height):
y = -1.0 + 2.0 * r / (height - 1)
row = []
for c in range(width):
x = -1.0 + 2.0 * c / (width - 1)
output = net.serial_activate([x, y])
red = int(round((output[0] + 1.0) * 255 / 2.0))
green = int(round((output[1] + 1.0) * 255 / 2.0))
blue = int(round((output[2] + 1.0) * 255 / 2.0))
red = max(0, min(255, red))
green = max(0, min(255, green))
blue = max(0, min(255, blue))
row.append((red, green, blue))
image.append(row)
return image
def visualizeWinners(checkpoint, config, picdir, rounds):
colors = ['red', 'yellow', 'green', 'blue']
while len(checkpoint) < 4:
checkpoint.extend(checkpoint)
checkpoint = checkpoint[:4]
print("Going to let fight: ", checkpoint)
print("With colors: ", colors)
nets = {}
for i, c in enumerate(checkpoint):
pop = population.Population(config)
pop.load_checkpoint(c)
trainfunc = partial(eval_fitness_internalfight, num_runs=10, steplength=200, x=16, y=16)
pop.run(trainfunc, 1)
winner = pop.statistics.best_genome()
nets[c+str(i)] = nn.create_feed_forward_phenotype(winner)
filelist = glob.glob(os.path.join(picdir, 'step*.png'))
for f in filelist:
os.remove(f)
x = 40; y = 40
game = ca.CellularAutomaton(initialState=ca.initializeHexagonal(x, y), param=ca.defaultParameters)
for i,k in enumerate(nets.keys()):
game.setNewSpecies(util.nicePositions4(i,x, y), k, colors[i])
util.saveStatePicture(game.getState(), picdir)
while game.step < rounds:
state = game.getState()
for s in game.findSpecies():
try:
game.setDecisions(s, netDecision(state, s, nets[s]))
except:
pass
game.evolve()
util.saveStatePicture(state, picdir)
app = QApplication(sys.argv)
pics = util.sort_nicely(glob.glob(os.path.join(picdir, 'step*.png')))
gui = SimpleGUI(pics)
gui.show()
sys.exit(app.exec_())
def fitness(genome):
"""
This function will be run in parallel by ParallelEvaluator. It takes one
argument (a single genome) and should return one float (that genome's fitness).
Note that this function needs to be in module scope for multiprocessing.Pool
(which is what ParallelEvaluator uses) to find it. Because of this, make
sure you check for __main__ before executing any code (as we do here in the
last two lines in the file), otherwise you'll have made a fork bomb
instead of a neuroevolution demo. :)
"""
net = nn.create_feed_forward_phenotype(genome)
sum_square_error = 0.0
for inputData, outputData in zip(xor_inputs, xor_outputs):
# serial activation
output = net.serial_activate(inputData)
sum_square_error += (output[0] - outputData) ** 2
return 1 - math.sqrt(sum_square_error / len(xor_outputs))
def run():
pop = population.Population('xor2_config')
pop.epoch(eval_fitness, 300)
winner = pop.most_fit_genomes[-1]
print('Number of evaluations: %d' % winner.ID)
# Verify network output against training data.
print('\nBest network output:')
net = nn.create_feed_forward_phenotype(winner)
for inputs, expected in zip(INPUTS, OUTPUTS):
output = net.serial_activate(inputs)
print("expected %1.5f got %1.5f" % (expected, output[0]))
print(nn.create_feed_forward_function(winner))
# Visualize the winner network and plot statistics.
visualize.plot_stats(pop.most_fit_genomes, pop.avg_fitness_scores)
visualize.plot_species(pop.species_log)
visualize.draw_net(winner, view=True)
def old_more_complex_stuff():
# pop.epoch(eval_fitness, num_epochs)
while True:
try:
pop.run(eval_fitness, num_epochs)
except KeyboardInterrupt:
import pdb; pdb.set_trace()
except (ZeroDivisionError, ValueError, OverflowError):
pass
print('Number of evaluations: {0}'.format(pop.total_evaluations))
# Display the most fit genome.
print('\nBest genome:')
winner = pop.most_fit_genomes[-1]
print(winner)
# Verify network output against training data.
print('\nOutput:')
winner_net = nn.create_feed_forward_phenotype(winner)
for inputs, expected in zip(xor_inputs, xor_outputs):
output = winner_net.serial_activate(inputs)
print("expected {0:1.5f} got {1:1.5f}".format(expected, output[0]))
def eval_fitness_internalfight(allgenomes, num_runs=3, steplength=100, x=16, y=16):
for g in allgenomes:
g.fitness = 0
# sadly, the number of genomes from neat-python is not fixed, so we only train some to fit %4
topad = int(np.ceil(len(allgenomes)/4)*4-len(allgenomes))
traincount = np.zeros(len(allgenomes))
trainfitness = np.zeros(len(allgenomes))
print(len(allgenomes),topad)
for _ in range(num_runs):
# geht nur, wenn genomes durch 4 teilbar ist TODO change this
grouping = np.random.permutation(len(allgenomes))
if topad > 0:
grouping = np.concatenate((grouping, np.random.choice(grouping,topad)))
grouping = np.reshape(grouping, (len(grouping)/4, 4))
for group in grouping:
nets = []
game = ca.CellularAutomaton(initialState=ca.initializeHexagonal(x, y), param=ca.defaultParameters)
for i, g in enumerate(group):
nets.append(nn.create_feed_forward_phenotype(allgenomes[g]))
game.setNewSpecies(util.nicePositions4(i,x,y), 'spec' + str(i))
while game.step < steplength:
state = game.getState()
for j, g in enumerate(group):
game.setDecisions('spec' + str(j), netDecision(state, 'spec' + str(j), nets[j]))
game.evolve()
for k, g in enumerate(group):
trainfitness[g] += countSpecies(game.getState(), 'spec' + str(k))
traincount[g] += 1
# divide training results by traincount, bc of padding etc this has to be done
# fitness of all below median is set to zero
trainfitness = trainfitness/traincount
trainfitness[trainfitness < np.median(trainfitness)] = 0
# results of fights define the fitness
for k, g in enumerate(allgenomes):
g.fitness = trainfitness[k]
def fit(self, X, Y):
self.fit_X = X # XXX: store X_Train as a tmp class var
self.fit_Y = Y # XXX: store Y_Train as a tmp class var
self.pop.run(self.eval_fitness,self.n)
self.winner = self.pop.statistics.best_genome()
self.winner_net = nn.create_feed_forward_phenotype(self.winner)
def eval_fitness(genomes):
for g in genomes:
net = nn.create_feed_forward_phenotype(g)
score,turns = play_game(net)
#print ("Score, turns", score, turns)
g.fitness = score + turns*10
# Serial activation propagates the inputs through the entire network.
output = net.serial_activate(inputs)
sum_square_error += (output[0] - expected) ** 2
# When the output matches expected for all inputs, fitness will reach
# its maximum value of 1.0.
g.fitness = 1 - sum_square_error
local_dir = os.path.dirname(__file__)
config_path = os.path.join(local_dir, 'xor2_config')
pop = population.Population(config_path)
pop.run(eval_fitness, 300)
# Log statistics.
statistics.save_stats(pop.statistics)
statistics.save_species_count(pop.statistics)
statistics.save_species_fitness(pop.statistics)
print('Number of evaluations: {0}'.format(pop.total_evaluations))
# Show output of the most fit genome against training data.
winner = pop.statistics.best_genome()
print('\nBest genome:\n{!s}'.format(winner))
print('\nOutput:')
winner_net = nn.create_feed_forward_phenotype(winner)
for inputs, expected in zip(xor_inputs, xor_outputs):
output = winner_net.serial_activate(inputs)
print("expected {0:1.5f} got {1:1.5f}".format(expected, output[0]))
ranks = nx.pagerank(g.G)
ge.fitness = fit
print ge.fitness
pop = population.Population('conf')
pop.run(eval_fitness, 100)
statistics.save_stats(pop.statistics)
statistics.save_species_count(pop.statistics)
statistics.save_species_fitness(pop.statistics)
to_test = []
winner = pop.statistics.best_genome()
wn = nn.create_feed_forward_phenotype(winner)
test_years = [
'2008-09', '2009-10', '2010-11', '2011-12', '2012-13', '2013-14', '2015-16'
]
def test_winner(w, league='/E0.csv', test_years=test_years):
fit = 100
for year in test_years:
s = season('./seasons/' + year + league)
s.read_season()
g = network(s)
g.make_graph_to()
ranks = nx.pagerank(g.G)
while True:
def get_evo_network(pop):
winner = pop.statistics.best_genome()
return nn.create_feed_forward_phenotype(winner)
from __future__ import print_function
import pickle
import pygame
import evolve
from neat import nn, visualize
evolve.W = 1000
evolve.H = 1000
pb = evolve.PictureBreeder(128, 128, 1500, 1500, 1280, 1024, 'color', 4)
with open("genome-20219-701.bin", "rb") as f:
g = pickle.load(f)
print(g)
node_names = {0: 'x', 1: 'y', 2: 'gray'}
visualize.draw_net(g,
view=True,
filename="picture-net.gv",
show_disabled=False,
prune_unused=True,
node_names=node_names)
net = nn.create_feed_forward_phenotype(g)
pb.make_high_resolution(g)
break
if reward > 0:
reward = 1
cum_reward += reward
fitnesses.append(cum_reward)
fitness = (np.array(fitnesses).mean())
print("Species fitness: %s" % str(fitness))
scores.append(fitness)
return fitness
with open(winner, 'rb') as pickle_file:
winner_a = pickle.load(pickle_file)
winner_net = nn.create_feed_forward_phenotype(winner_a)
for i in range(100):
simulate_species(scores, winner_net, my_env, 1, 50000, True)
## We can decide to save only the sum of the scores, or to use min max normalization
#final_score=(np.mean(scores)-np.min(scores))/(np.max(scores)-np.min(scores))
final_score = np.sum(scores)
mx = np.max(scores)
with open('scores.txt', 'a') as the_file:
the_file.write(
'Mean scores for game {0} and trained on {1}: {2} with MAX={3} '.
format(game_name, winner, final_score, mx))
def update_fitness(genomes):
for g in genomes:
input_data,output_data = zip(*dataset)
result = evaluate_network( nn.create_feed_forward_phenotype(g),
input_data, output_data )
g.fitness = 1 - result
def __init__(self, genome):
self.i = 0
self.genome = genome
self.net = nn.create_feed_forward_phenotype(genome)
import pickle
from cart_pole import CartPole, discrete_actuator_force
from movie import make_movie
from neat import nn
# load the winner
with open('nn_winner_genome', 'rb') as f:
c = pickle.load(f)
print('Loaded genome:')
print(c)
net = nn.create_feed_forward_phenotype(c)
sim = CartPole()
print()
print("Initial conditions:")
print(" x = {0:.4f}".format(sim.x))
print(" x_dot = {0:.4f}".format(sim.dx))
print(" theta = {0:.4f}".format(sim.theta))
print("theta_dot = {0:.4f}".format(sim.dtheta))
print()
# Run the given simulation for up to 100k time steps.
num_balanced = 0
for s in range(10 ** 5):
inputs = sim.get_scaled_state()
action = net.serial_activate(inputs)
print fitness
env.reset()
break
genome.fitness = fitness #assigning fitness to the genome.
pop = population.Population(os.getcwd() + '/cartPole-v0_configuration') # Attaching the config file required by the NEAT Library
pop.run(eval_fitness, 300)
best = pop.statistics.best_genome()
env.monitor.start('cartpole-experiment/', force=True)
streak = 0
best_phenotype = nn.create_feed_forward_phenotype(best)
observation = env.reset()
env.render()
while streak < 100:
fitness = 0
frames = 0
while 1:
inputs = observation
# active neurons
output = best_phenotype.serial_activate(inputs)
if (output[0] >= 0):
observation, reward, done, info = env.step(MOVEMENT_RIGHT)
else:
