def getbest(i):
g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, i)
# pop.RNG.Seed(int(time.clock()*100))
pop.RNG.Seed(1234)
generations = 0
for generation in range(max_generations):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=False)
# fitness_list = EvaluateGenomeList_Parallel(genome_list, evaluate, display=False)
NEAT.ZipFitness(genome_list, fitness_list)
pop.Epoch()
generations = generation
best = max(fitness_list)
if best > 15.0:
break
net = NEAT.NeuralNetwork()
pop.GetBestGenome().BuildPhenotype(net)
# img = NEAT.viz.Draw(net)
# cv2.imshow("current best", img)
# cv2.waitKey(1)
return generations, net.NumHiddenNeurons(), net.NumConnections()
def evolve():
g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, 1)
pop.RNG.Seed(int(time.clock()*100))
generations = 0
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = []
for genome in genome_list:
fitness_list.append(evaluate(genome))
NEAT.ZipFitness(genome_list, fitness_list)
pop.Epoch()
generations = generation
best = max(fitness_list)
bestG = pop.GetBestGenome()
plot_nn(bestG)
plt.pause(0.001)
plt.ion()
plt.show(block=False)
print("Mejor fitness [",generation,"]: ",best)
if best > 15.9:
break
return generations
def getbest():
g = NEAT.Genome(0, 3, 0, 1, False,
NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params)
pop = NEAT.Population(g, params, True, 1.0)
generations = 0
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
NEAT.ZipFitness(genome_list, fitness_list)
best = max([x.GetLeader().GetFitness() for x in pop.Species])
# print 'Best fitness:', best, 'Species:', len(pop.Species)
# test
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildPhenotype(net)
img = np.zeros((250, 250, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 250, 250), net)
cv2.imshow("nn_win", img)
cv2.waitKey(1)
pop.Epoch()
# print "Generation:", generation
generations = generation
if best > 15.5:
break
return generations
def getbest(i):
g = NEAT.Genome(0, 3, 0, 1, False,
NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params)
pop = NEAT.Population(g, params, True, 1.0, i)
pop.RNG.Seed(i)
generations = 0
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
NEAT.ZipFitness(genome_list, fitness_list)
best = max([x.GetLeader().GetFitness() for x in pop.Species])
pop.Epoch()
generations = generation
if best > 15.0:
break
return generations
def run_experiment(config_file, trial_id, n_generations, out_dir, view_results=False, save_results=True):
"""
The function to run the experiment against hyper-parameters
defined in the provided configuration file.
The winner genome will be rendered as a graph as well as the
important statistics of neuroevolution process execution.
Arguments:
config_file: The path to the file with experiment
configuration
trial_id: The ID of current trial
n_generations: The number of evolutionary generations
out_dir: The directory to save intermediate results.
view_results: The flag to control if intermediate results should be displayed after each trial
save_results: The flag to control whether intermediate results should be saved after each trial.
Returns:
The tuple (solution_found, generation, complexity, best_genome_fitness) that has flag indicating whether
solution was found, the generation when solution was found, the complextity of best genome, and the fitness
of best genome.
"""
g = NEAT.Genome(0, 4+1, 0, 1+1, False, NEAT.ActivationFunction.TANH,
NEAT.ActivationFunction.TANH, 0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, trial_id)
# set random seed
seed = int(time.time())
pop.RNG.Seed(seed)
generations = 0
solved = False
best_trial_fitness = 0
best_trial_complexity = 0
for generation in range(n_generations):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=view_results)
NEAT.ZipFitness(genome_list, fitness_list)
generations = generation
best = max(genome_list, key=get_fitness)
best_fitness = best.GetFitness()
complexity = best.NumNeurons() + best.NumLinks()
solved = best_fitness >= cart.MAX_FITNESS # Changed to correspond limit used with other tested libraries
if solved:
best_trial_fitness = best_fitness
best_trial_complexity = complexity
print("Trial: %2d\tgeneration: %d\tfitness: %f\tcomplexity: %d\tseed: %d" %
(trial_id, generations, best_trial_fitness, complexity, seed))
break
# check if best fitness in this generation is better than current maximum
if best_fitness > best_trial_fitness:
best_trial_complexity = complexity
best_trial_fitness = best_fitness
# move to the next epoch
pop.Epoch()
if not solved:
print("Trial: %2d\tFAILED\t\tfitness: %f\tcomplexity: %d\tseed: %d" %
(trial_id, best_trial_fitness, best_trial_complexity, seed))
return solved, generations, best_trial_complexity, best_trial_fitness
def evolve():
global generations
global global_best
global rrse_list
global mae_list
global rows
global cols
# print("LOO Validation:")
g = NEAT.Genome(0, (cols - 1), (3), 1, False,
NEAT.ActivationFunction.LINEAR,
NEAT.ActivationFunction.LINEAR, 1, params, 1)
for test_idx in range(rows):
pop = NEAT.Population(g, params, True, 1.0, 0)
pop.RNG.Seed(int(time.clock() * 100))
generations = 0
global_best = -99999999
no_improvement = 0
# Run for a maximum of N generations
while no_improvement < 7 and generations < 100: #TODO: make max gens into variable and set via command line
# Reset the population if this path does not seem promising
if (generations > 7 and global_best < -150):
pop = NEAT.Population(g, params, True, 1.0, 0)
pop.RNG.Seed(int(time.clock() * 100))
generations = 0
global_best = -99999999
no_improvement = 0
genome_list = NEAT.GetGenomeList(pop)
fitness_list = []
for genome in genome_list:
fitness_list.append(evaluate(genome, test_idx))
NEAT.ZipFitness(genome_list, fitness_list)
pop.Epoch()
generations += 1
best = max(fitness_list)
#print("[ROW:", test_idx, "] ", -global_best, " (", no_improvement, " g. of no improvement)")
if best > global_best:
no_improvement = 0
global_best = best
else:
no_improvement += 1
#print("LOO test error (RRSE):")
#print(rrse_list[test_idx])
#print("LOO test error (MAE):")
#print(mae_list[test_idx])
print(rrse_list)
print(mae_list)
avg_rrse = np.mean(rrse_list)
avg_mae = np.mean(mae_list)
return [avg_rrse, avg_mae]
def optimize_neat(config, n_inputs, n_hidden, n_outputs, out_dir):
print('Starting Optimization')
params = NEAT.Parameters()
params.PopulationSize = 60
params.OldAgeTreshold = 10
params.SpeciesMaxStagnation = 20
params.AllowLoops = False
for i in range(config['n_morphogens']):
addTrait(params, 'K%i' % i, (.03, .08))
addTrait(params, 'F%i' % i, (.01, .06))
addTrait(params, 'diffU%i' % i, (.005, .02))
addTrait(params, 'diffV%i' % i, (.0025, .01))
######################## Create NEAT objects ###############################
fs_neat = False
seed_type = 0
out_type = NEAT.ActivationFunction.UNSIGNED_SIGMOID
hidden_type = NEAT.ActivationFunction.UNSIGNED_SIGMOID
genome_prototye = NEAT.Genome(0, n_inputs, n_hidden, n_outputs, fs_neat, \
out_type, hidden_type, seed_type, params, 0)
rand_seed = int(time.time())
pop = NEAT.Population(genome_prototye, params, True, 1.0, rand_seed)
######################## Main evolution loop ###############################
top_fitness = 0 # Fitness function is defined in [0, 1]
top_grid = None
for generation in range(config['generations']):
print('Starting generation', generation)
genomes = NEAT.GetGenomeList(pop)
fitness_list = [simulate_genome(g, config)[0] for g in genomes]
NEAT.ZipFitness(genomes, fitness_list)
max_fitness = max(fitness_list)
print('Generation complete')
print('Max fitness', max_fitness)
print('Mean fitness', np.mean(fitness_list))
if max_fitness > top_fitness:
print('New best fitness')
best_genome = genomes[fitness_list.index(max_fitness)]
_, best_grid = simulate_genome(best_genome, config)
top_fitness = max_fitness
top_grid = best_grid
np.save(out_dir + '/grid_%i' % generation, best_grid)
best_genome.Save(out_dir + '/genome_%i' % generation)
pop.Epoch()
print()
def getbest(i):
g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params)
pop = NEAT.Population(g, params, True, 1.0, i)
pop.RNG.Seed(int(time.clock()*100))
generations = 0
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=False)
NEAT.ZipFitness(genome_list, fitness_list)
pop.Epoch()
generations = generation
best = max(fitness_list)
if best > 15.0:
break
return generations
def objective_driven(seed):
i = seed
g = NEAT.Genome(0, 6, 0, 4, False, NEAT.ActivationFunction.SIGNED_SIGMOID,
NEAT.ActivationFunction.SIGNED_SIGMOID, 0, params)
pop = NEAT.Population(g, params, True, 1.0, i)
#pop.RNG.Seed(i)
generations = 0
for generation in range(250):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
fitness_list = [k[0] for k in fitness_list]
NEAT.ZipFitness(genome_list, fitness_list)
best_fits = [x.GetLeader().GetFitness() for x in pop.Species]
best = max(best_fits)
idx = best_fits.index(best)
print best, pop.Species[idx].GetLeader().GetFitness()
imgs, res = evaluate(pop.Species[idx].GetLeader(),
debug=True,
save="gen%d.ply" % generation)
plt.ion()
plt.clf()
subfig = 1
t_imgs = len(imgs)
for img in imgs:
plt.subplot(t_imgs, 1, subfig)
plt.title("Confidence: %0.2f%%" %
(res[subfig - 1, target_class] * 100.0))
plt.imshow(img)
subfig += 1
plt.draw()
plt.pause(0.1)
plt.savefig("out%d.png" % generation)
pop.Epoch()
generations = generation
return generations
def evolve_neat(params, generations, out_dir, run_id, pool):
pop = create_initial_population(params)
max_ever = None
t = time.time()
for generation in range(generations):
print(run_id, 'Starting generation', generation)
genomes = NEAT.GetGenomeList(pop)
if pool:
data = [(g, g.GetGenomeTraits(), params) for g in genomes]
fitnesses = pool.starmap(evaluate, data)
else:
fitnesses = [
evaluate(g, g.GetGenomeTraits(), params) for g in genomes
]
NEAT.ZipFitness(genomes, fitnesses)
maxf, meanf = max(fitnesses), sum(fitnesses) / float(len(fitnesses))
runtime = time.time() - t
t = time.time()
print()
print('Generation %i ran in %f, %f per coral' % \
(generation, runtime, runtime/len(genomes)))
print('Max fitness:', maxf, 'Mean fitness:', meanf)
if max_ever is None or maxf > max_ever:
best = pop.GetBestGenome()
max_ever = maxf
print('New best fitness.', best.NumNeurons(), best.NumLinks())
coral = simulate_and_save(best, params, out_dir, generation, maxf,
meanf)[0]
pop.Epoch()
print('#' * 80)
print('Run Complete.')
def evolve():
g = NEAT.Genome(0, 2, 0, 1, False, NEAT.ActivationFunction.LINEAR,
NEAT.ActivationFunction.LINEAR, 0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, 1)
pop.RNG.Seed(int(time.clock()*100))
generations = 0
for generation in range(50):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = []
for genome in genome_list:
fitness_list.append(evaluate(genome))
NEAT.ZipFitness(genome_list, fitness_list)
pop.Epoch()
generations = generation
best = -max(fitness_list)
bestG = pop.GetBestGenome()
plot_nn(bestG)
plt.pause(0.01)
plt.ion()
plt.show(block=False)
print("Mejor fitness [",generation,"]: ",best)
if best < 0.01:
break
testNet = NEAT.NeuralNetwork()
bestG.BuildPhenotype(testNet)
for i in range(10):
testNet.Flush()
testNet.Input(np.array([float(100+2*i), 1]))
for _ in range(2):
testNet.Activate()
o = testNet.Output()
print(100+2*i,"/ 2 = ",o[0])
return generations
def run_experiment(params, trial_id, n_generations, out_dir=None, view_results=False, save_results=True):
g = NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, trial_id)
# set random seed
seed = int(time.time())
pop.RNG.Seed(seed)
generations = 0
solved = False
max_fitness = 0
complexity = 0
for generation in range(n_generations):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = EvaluateGenomeList_Serial(genome_list, evaluate, display=view_results)
NEAT.ZipFitness(genome_list, fitness_list)
generations = generation
best = max(genome_list, key=get_fitness)
best_fitness = best.GetFitness()
complexity = best.NumNeurons() + best.NumLinks()
solved = best_fitness > 15.5 # Changed to correspond limit used with other tested libraries
if solved:
max_fitness = best_fitness
print("Trial: %2d\tgeneration: %d\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, generations, max_fitness, complexity, seed))
break
# check if best fitness in this generation is better than current maximum
max_fitness = max(best_fitness, max_fitness)
# move to the next epoch
pop.Epoch()
if not solved:
print("Trial: %2d\tFAILED\t\tfitness: %f\tcomplexity: %d\tseed: %d" % (trial_id, max_fitness, complexity, seed))
return solved, generations, complexity, max_fitness
def evolve_local(params,
generations,
out_dir,
run_id,
pool,
max_size=400,
K=10,
N=5):
max_ever = None
archive = Archive(max_size, K)
pop = create_initial_population(params)
seen_genomes = set()
corals_dir = pjoin(out_dir, 'corals')
hist_dir = pjoin(out_dir, 'local_fitness_history')
best_dir = pjoin(out_dir, 'best')
os.mkdir(corals_dir)
os.mkdir(hist_dir)
os.mkdir(best_dir)
# Main loop
for generation in range(generations):
print('\n' + '#' * 80)
print(run_id, 'Starting generation %i' % generation)
genomes = NEAT.GetGenomeList(pop)
fitness_list, feature_list = evaluate_genomes_novelty(
genomes, params, pool)
local_fitness_list = archive.calcLocalFitnessAndUpdate(
genomes, fitness_list, feature_list)
NEAT.ZipFitness(genomes, local_fitness_list)
current = {g.GetID(): g for g in genomes}
print()
maxf, meanf = max(fitness_list), sum(fitness_list) / float(
len(fitness_list))
print('Fitness - avg: %f, max:%f' % (meanf, maxf))
print('Local Fitness - avg: %f, max:%f' %
(np.mean(local_fitness_list), max(local_fitness_list)))
print('Top 5 Local Fitness',
sorted(archive.local_fitnesses, reverse=True)[:5])
np.save(pjoin(hist_dir, "%i" % generation),
np.array(archive.local_fitnesses))
top_n = archive.topNGenomes(N)
avg_local_fitness = sum(f for f, gid in top_n)
if max_ever is None or avg_local_fitness > max_ever:
print('New best average best local fitness!', avg_local_fitness)
max_ever = avg_local_fitness
for i, (local_fitness, genome_id) in enumerate(top_n):
# Only save a genome if we have not seen it before.
if genome_id in current:
genome = current[genome_id]
traits = genome.GetGenomeTraits()
coral_dir = pjoin(corals_dir,
"%i_%i" % (generation, genome_id))
os.mkdir(coral_dir)
genome.Save(pjoin(coral_dir, 'genome.txt'))
with open(pjoin(coral_dir, 'traits.txt'), "w+") as f:
for k, v in sorted(traits.items()):
f.write("%s\t%f\n" % (k, v))
simulate_genome(genome,
traits, [params],
export_folder=coral_dir)
with open(pjoin(best_dir, '%i.txt' % generation), 'w+') as out:
for local_fitness, genome_id in top_n:
out.write('%i\t%f\n' % (genome_id, local_fitness))
pop.Epoch()
print(k, '= %3.4f' % v, end=', ')
else:
print(k, '= {0}'.format(v), end=', ')
print()
print('Links:')
for tr in g.GetLinkTraits():
print(tr[0], tr[1], end=': ')
for k, v in tr[2].items():
if isinstance(v, float):
print(k, '= %3.4f' % v, end=', ')
else:
print(k, '= {0}'.format(v), end=', ')
print()
print()
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
fitness_list = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
NEAT.ZipFitness(genome_list, fitness_list)
PrintGenomeTraits(pop.GetBestGenome())
print()
print('Fitnesss:', max(fitness_list), 'Generation:', generation)
print()
pop.Epoch()
def main(use_futures, redirect_out=True):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
# mode = MPI.MODE_CREATE | MPI.MODE_WRONLY
if redirect_out:
sys.stdout = open('out.txt', 'w')
sys.stderr = open('err.txt', 'w')
print("Prepare traits and genomes")
neat_params = neat.Parameters()
system(
"grep -v '//' < input/neat_parameters.txt | grep . > input/neat_parameters.filtered.txt"
)
neat_params.Load('input/neat_parameters.filtered.txt')
system("rm input/neat_parameters.filtered.txt")
# system("grep -v '//' < input/global_parameters.json | grep . > input/global_parameters.filtered.json")
# network_parameters = json.load(open('input/global_parameters.filtered.json', 'r'))
# system("rm input/global_parameters.filtered.json")
# mode = MPI.MODE_RDONLY
network_parameters = json.load(open('input/global_parameters.json', 'r'))
# network_parameters = json.load(open(comm, 'input/global_parameters.json', mode))
for trait_name, trait_value in traits.network_traits.items():
neat_params.SetGenomeTraitParameters(trait_name, trait_value)
for trait_name, trait_value in traits.neuron_traits.items():
# change to SetNeuronTraitParameters to let the neuron parameters mutate individually for each neuron
neat_params.SetGenomeTraitParameters(trait_name, trait_value)
for trait_name, trait_value in traits.synapse_traits.items():
# change to SetLinkTraitParameters to let the synapse parameters mutate individually for each synapse
neat_params.SetGenomeTraitParameters(trait_name, trait_value)
genome = neat.Genome(
0, # Some genome ID, I don't know what it means.
network_parameters['inputs_number'],
2, # ignored for seed_type == 0, specifies number of hidden units if seed_type == 1
network_parameters['outputs_number'],
False, #fs_neat. If == 1, a minimalistic perceptron is created: each output is connected to a random input and the bias.
neat.ActivationFunction.
UNSIGNED_SIGMOID, # output neurons activation function
neat.ActivationFunction.
UNSIGNED_SIGMOID, # hidden neurons activation function
0, # seedtype
neat_params, # global parameters object returned by neat.Parameters()
0 # number of hidden layers
)
population = neat.Population(
genome,
neat_params,
True, # whether to randomize the population
0.5, # how much to randomize
0 # the RNG seed
)
# fh = MPI.File.Open(comm, "datafile", mode)
# line1 = str(comm.rank)*(comm.rank+1) + '\n'
# line2 = chr(ord('a')+comm.rank)*(comm.rank+1) + '\n'
# fh.Write_ordered(line1)
# fh.Write_ordered(line2)
# fh.Close()
print("Start solving generations")
outfile = open('output/fitness.txt', 'w')
# mode = MPI.MODE_CREATE | MPI.MODE_WRONLY
# outfile = MPI.File.Open(comm, 'output/fitness.txt', mode)
# with open('output/fitness.txt', 'w') as outfile:
for generation_number in range(network_parameters['generations']):
print("Generation " + str(generation_number) + " started")
genome_list = neat.GetGenomeList(population)
fitnesses_list = []
# map(prepare_genomes, genome_list)
for genome in genome_list:
prepare_genomes(genome)
if use_futures:
executor = fut.MPIPoolExecutor()
# fitnesses_list = executor.map(evaluate_futures, genome_list)
for fitness in executor.map(evaluate_futures, genome_list):
fitnesses_list.append(fitness)
else:
# fitnesses_list = map(evaluate, genome_list)
for genome in genome_list:
fitnesses_list.append(evaluate(genome))
neat.ZipFitness(genome_list, fitnesses_list)
population.GetBestGenome().Save('output/best_genome.txt')
# mode = MPI.MODE_APPEND
# genomefile = MPI.File.Open(comm, 'output/best_genome.txt', mode)
# genomefile.Write_ordered('\n' + str(population.GetBestGenome().GetNeuronTraits()) +
# '\n' + str(population.GetBestGenome().GetGenomeTraits()))
# genomefile.Close()
genomefile = open('output/best_genome.txt', 'a')
genomefile.write('\n' +
str(population.GetBestGenome().GetNeuronTraits()) +
'\n' +
str(population.GetBestGenome().GetGenomeTraits()))
genomefile.close()
# copytree('genome' + str(population.GetBestGenome().GetID()),
# 'output/generation' + str(generation_number) + '_best_genome')
try:
copytree(
'genome' + str(population.GetBestGenome().GetID()),
'output/generation' + str(generation_number) + '_best_genome')
except FileExistsError:
print('folder generation' + str(generation_number) +
'_best_genome exists')
# outfile.Write_ordered(str(generation_number) + '\t' + str(max(fitnesses_list)) + '\n')
outfile.write(
str(generation_number) + '\t' + str(max(fitnesses_list)) + '\n')
outfile.flush()
# sys.stderr.write(
# '\rGeneration ' + str(generation_number)
# + ': fitness = ' + str(population.GetBestGenome().GetFitness())
# )
# advance to the next generation
print("Generation " + str(generation_number) + \
": fitness = " + str(population.GetBestGenome().GetFitness()))
print("Generation " + str(generation_number) + " finished")
population.Epoch()
# outfile.Close()
outfile.close()
def do_gens(self,gens):
evaluate=self.evaluate
generations = 0
pop=self.pop
#do the requested number of generations of evolution
for generation in range(gens):
genome_list = NEAT.GetGenomeList(pop)
fitness_list=[]
behavior_list=[]
#get the novb (behavior) for each genome in the pop
for genome in genome_list:
#evaluate genome in the domain to get behavior and fitness
novb,fitness,extra = evaluate(genome)
if self.do_magic:
#novb=np.sqrt(novb.mean(axis=0).flatten())
novb=np.hstack([novb.max(axis=0),novb.min(axis=0)]).flatten()
novb=novb/np.linalg.norm(novb)
print novb.max(),novb.min()
print novb.shape
behavior_list.append(novb)
#now calculate novelty scotres
if True:
print "calculating novelty..."
behaviors = behavior_list
fitness_list = []
#judge the novelty of a new indiviudal by all the
#behaviors of current population + archive
compiled_array=numpy.array(self.archive+behavior_list)
for k in behavior_list:
fitness_list.append(calc_novelty(k,compiled_array))
#randomly add one individual to archive per generation
#you can do other things here... see original NS paper if interested..
idx = random.randint(0,len(behaviors)-1)
self.archive.append(behaviors[idx])
self.garchive.append(NEAT.Genome(genome_list[idx]))
#assign novelty as the fitness for each individual
NEAT.ZipFitness(genome_list, fitness_list)
if self.checkpoint and generation%self.ci==0:
print "saving..."
glist = [k for k in genome_list]
#to_save = [self.garchive,self.archive,glist,behavior_list]
to_save = [self.archive,self.garchive,glist,behavior_list]
cPickle.dump(to_save,open("nov%d.pkl"%self.checkpt_counter,"wb"))
self.checkpt_counter+=1
print "done!"
"""
# test
net = NEAT.NeuralNetwork()
champ=pop.Species[0].GetLeader()
champ.BuildPhenotype(net)
#evaluate(champ,False)
if vis:
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net )
cv2.imshow("nn_win", img)
cv2.waitKey(1000)
"""
print "before epoch"
pop.Epoch()
print "after epoch"
generations = generation
