def create_initial_population(params):
# Create network size based off coral and parameters.
n_inputs, n_outputs = Coral.calculate_inouts(params)
genome_prototype = NEAT.Genome(
0, # ID
n_inputs,
0, # NUM_HIDDEN
n_outputs,
False, # FS_NEAT
NEAT.ActivationFunction.
UNSIGNED_SIGMOID, # Output activation function.
NEAT.ActivationFunction.
UNSIGNED_SIGMOID, # Hidden activation function.
0, # Seed type, must be 1 to have hidden nodes.
params.neat,
0)
pop = NEAT.Population(
genome_prototype, # Seed genome.
params.neat,
True, # Randomize weights.
1.0, # Random Range.
int(time.time()) # Random number generator seed.
)
return pop
def getbest(i):
g = NEAT.Genome(0, substrate.GetMinCPPNInputs(), 2,
substrate.GetMinCPPNOutputs(), False,
NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.TANH,
0, params)
pop = NEAT.Population(g, params, True, 1.0, i)
pop.RNG.Seed(i)
for generation in range(2000):
genome_list = NEAT.GetGenomeList(pop)
# if sys.platform == 'linux':
# fitnesses = EvaluateGenomeList_Parallel(genome_list, evaluate, display=False)
# else:
fitnesses = EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
print('Gen: %d Best: %3.5f' % (generation, max(fitnesses)))
best = max(fitnesses)
pop.Epoch()
generations = generation
if best > 15.0:
break
return generations
def test_multi_neat(self):
params = NEAT.Parameters()
params.PopulationSize = 100
genome = NEAT.Genome(
0, # ID
3, # number of inputs. Note: always add one extra input, for bias
0, # number of hidden nodes
2, # number of outputs
False, # FS_NEAT; auto-determine an appropriate set of inputs for the evolved networks
NEAT.ActivationFunction.UNSIGNED_SIGMOID, # OutputActType
NEAT.ActivationFunction.UNSIGNED_SIGMOID, # HiddenActType
0, # SeedType
params # Parameters
)
seed = 42
pop = NEAT.Population(
genome,
params,
True, # whether the population should be randomized
1.0, # how much the population should be randomized,
seed)
for generation in range(3):
# retrieve a list of all genomes in the population
genome_list = NEAT.GetGenomeList(pop)
# apply the evaluation function to all genomes
for genome in genome_list:
fitness = self.evaluate(genome)
genome.SetFitness(fitness)
# advance to the next generation
pop.Epoch()
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 getbest(i):
g = NEAT.Genome(0, substrate.GetMinCPPNInputs(), 0,
substrate.GetMinCPPNOutputs(), False,
NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.TANH,
0, params)
pop = NEAT.Population(g, params, True, 1.0, i)
pop.RNG.Seed(i)
for generation in range(2000):
genome_list = NEAT.GetGenomeList(pop)
fitnesses = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
best = max([x.GetLeader().GetFitness() for x in pop.Species])
pop.Epoch()
generations = generation
if best > 15.0:
break
return generations
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 validator(self, NEAT_file):
""" Validate a single run.
Args:
NEAT_File: file for the NEAT genome
"""
global man, quadruped
# Initialize the manager to be unique to the process.
man = ODEManager(near_callback,
stepsize=self.dt / self.n,
log_data=self.log_frames,
run_num=self.run_num)
# Initialize the quadruped
quadruped = Quadruped(man=man)
# If logging the output, tell manager to write the body type, dimensions, and position to the logging file.
if self.log_frames:
man.log_world_setup(self.eval_time, ind_num=self.run_num)
# Load in the best performing NEAT genome
genome = NEAT.Genome(NEAT_file)
self.current_network = NEAT.NeuralNetwork()
if not self.hyperNEAT:
genome.BuildPhenotype(self.current_network)
else:
genome.BuildHyperNEATPhenotype(self.current_network,
self.substrate)
fit = self.physics_only_simulation_validator()
print(fit)
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 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 evolve(env_name, seed, params, max_evaluations, num_batches):
env = gym.make(env_name)
discrete_output = isinstance(env.action_space,
gym.spaces.discrete.Discrete)
train_network, test_network = configure_train_test(env_name, seed)
if discrete_output:
g = NEAT.Genome(0, len(np.reshape(env.observation_space.sample(),
-1)), 0, env.action_space.n, False,
NEAT.ActivationFunction.LINEAR,
NEAT.ActivationFunction.RELU, 0, params)
else:
g = NEAT.Genome(0, len(np.reshape(env.observation_space.sample(), -1)),
0, 2 * len(np.reshape(env.action_space.sample(), -1)),
False, NEAT.ActivationFunction.LINEAR,
NEAT.ActivationFunction.RELU, 0, params)
env.close()
population = NEAT.Population(g, params, True, 1.0, seed)
population.RNG.Seed(seed)
run_neat = configure_neat(population, train_network)
iterator = run_neat()
generations_per_batch = max(
(max_evaluations / num_batches) / params.PopulationSize, 1)
current_best = None
i = 0
while i * params.PopulationSize < max_evaluations:
for _ in xrange(generations_per_batch):
generation, current_best = iterator.next()
i += 1
assert i == generation
best = pickle.loads(current_best)
results = test_network(best)
neurons, connections = network_size(best)
yield i * params.PopulationSize, results, neurons, connections
def init_pop_new(pop_size, current_project):
""" Create a new randomized population using the default parameters"""
MN.Parameters.Load(params, para_file)
params.PopulationSize = pop_size
genome = MN.Genome(0, current_project.nn_in, current_project.nn_hidden,
current_project.nn_outs,
current_project.nn_start_minimal,
MN.ActivationFunction.UNSIGNED_SIGMOID,
MN.ActivationFunction.UNSIGNED_SIGMOID, 1, params, 0)
pop = MN.Population(genome, params, True, 1.0,
random_seed) # randomized for first gen
return pop, pop_size
def init_neat(self):
params = NEAT.Parameters()
params.PopulationSize = self.args.population_size
params.AllowClones = self.args.allow_clones
params.MaxWeight = self.args.max_weight
params.WeightMutationMaxPower = self.args.weight_mutation_max_power
params.MutateWeightsSevereProb = self.args.mutate_weights_severe_prob
params.WeightMutationRate = self.args.weight_mutation_rate
params.InterspeciesCrossoverRate = self.args.interspecies_crossover_rate
params.CrossoverRate = self.args.crossover_rate
params.OverallMutationRate = self.args.mutation_rate
params.RecurrentProb = 0.0
params.RecurrentLoopProb = 0.0
params.Elitism = self.args.elitism
params.SurvivalRate = self.args.survival_rate
num_inputs = len(self.neural_input_vectors[0])
num_hidden_nodes = 0
num_outputs = self.effect.num_parameters
if self.args.neural_mode == 'targets':
num_outputs *= self.num_frames
params.MutateAddNeuronProb = 0.0
params.MutateAddLinkProb = 0.0
params.MutateRemLinkProb = 0.0
params.MutateRemSimpleNeuronProb = 0.0
else:
params.MutateAddNeuronProb = self.args.add_neuron_probability
params.MutateAddLinkProb = self.args.add_link_probability
params.MutateRemLinkProb = self.args.remove_link_probability
params.MutateRemSimpleNeuronProb = self.args.remove_simple_neuron_probability
output_activation_function = NEAT.ActivationFunction.UNSIGNED_SIGMOID
if self.args.output_activation_function == 'linear':
output_activation_function = NEAT.ActivationFunction.LINEAR
elif self.args.output_activation_function == 'sine':
output_activation_function = NEAT.ActivationFunction.UNSIGNED_SINE
genome = NEAT.Genome(
0, # ID
num_inputs,
num_hidden_nodes,
num_outputs,
self.args.fs_neat,
output_activation_function, # OutputActType
NEAT.ActivationFunction.TANH, # HiddenActType
0, # SeedType
params # Parameters
)
self.population = NEAT.Population(
genome,
params,
True, # whether the population should be randomized
2.0, # how much the population should be randomized,
self.seed)
def getbest(run):
g = NEAT.Genome(0, substrate.GetMinCPPNInputs(), 0,
substrate.GetMinCPPNOutputs(), False,
NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.TANH,
0, params)
pop = NEAT.Population(g, params, True, 1.0, run)
for generation in range(1000):
# Evaluate genomes
genome_list = NEAT.GetGenomeList(pop)
fitnesses = EvaluateGenomeList_Serial(genome_list,
evaluate_xor,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
print('Gen: %d Best: %3.5f' % (generation, max(fitnesses)))
# Print best fitness
# print("---------------------------")
# print("Generation: ", generation)
# print("max ", max([x.GetLeader().GetFitness() for x in pop.Species]))
# Visualize best network's Genome
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildPhenotype(net)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net)
cv2.imshow("CPPN", img)
# Visualize best network's Pheotype
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildESHyperNEATPhenotype(
net, substrate, params)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net, substrate=True)
cv2.imshow("NN", img)
cv2.waitKey(1)
if max(fitnesses) > 15.0:
break
# Epoch
generations = generation
pop.Epoch()
return generations
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 create_dummy_stuff(mult=1.0):
params = NEAT.Parameters()
params.PopulationSize = 500
params.DynamicCompatibility = True
params.WeightDiffCoeff = 4.0
params.CompatTreshold = 2.0
params.YoungAgeTreshold = 15
params.SpeciesMaxStagnation = 15
params.OldAgeTreshold = 35
params.MinSpecies = 5
params.MaxSpecies = 25
params.RouletteWheelSelection = False
params.RecurrentProb = 0.0
params.OverallMutationRate = 0.5 * mult
params.MutateWeightsProb = 0.8
params.WeightMutationMaxPower = 1.5 *mult
params.WeightReplacementMaxPower = 2.0
params.MutateWeightsSevereProb = 0.2 *mult
params.WeightMutationRate = 0.2 *mult
params.MaxWeight = 8
params.MutateAddNeuronProb = 0.03
params.MutateAddLinkProb = 0.05
params.MutateRemLinkProb = 0.0
params.MinActivationA = 4.9
params.MaxActivationA = 4.9
params.ActivationFunction_SignedSigmoid_Prob = 0.0
params.ActivationFunction_UnsignedSigmoid_Prob = 1.0
params.ActivationFunction_Tanh_Prob = 0.0
params.ActivationFunction_SignedStep_Prob = 0.0
params.CrossoverRate = 0.75 # mutate only 0.25
params.MultipointCrossoverRate = 0.4
params.SurvivalRate = 0.2
g= NEAT.Genome(0, 3, 0, 1, False, NEAT.ActivationFunction.UNSIGNED_SIGMOID, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params)
seed = 1032
pop = NEAT.Population(g, params, True, 1.0, seed)
species = pop.Species[0]
RNG=pop.RNG
return pop,species,RNG,params
def getbest(run):
g = NEAT.Genome(0, 7, 1, True, NEAT.ActivationFunction.SIGNED_SIGMOID,
NEAT.ActivationFunction.SIGNED_SIGMOID, params)
pop = NEAT.Population(g, params, True, 1.0, run)
for generation in range(1000):
#Evaluate genomes
genome_list = NEAT.GetGenomeList(pop)
fitnesses = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate_xor,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
# Print best fitness
#print("---------------------------")
#print("Generation: ", generation)
#print("max ", max([x.GetLeader().GetFitness() for x in pop.Species]))
# Visualize best network's Genome
'''
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildPhenotype(net)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net )
cv2.imshow("CPPN", img)
# Visualize best network's Pheotype
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().Build_ES_Phenotype(net, substrate, params)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
Utilities.DrawPhenotype(img, (0, 0, 500, 500), net, substrate=True )
cv2.imshow("NN", img)
cv2.waitKey(1)
'''
if max([x.GetLeader().GetFitness() for x in pop.Species]) > 15.0:
break
# Epoch
generations = generation
pop.Epoch()
return generations
def getbest():
g = NEAT.Genome(0, substrate.GetMinCPPNInputs(), 0,
substrate.GetMinCPPNOutputs(), False,
NEAT.ActivationFunction.SIGNED_GAUSS,
NEAT.ActivationFunction.SIGNED_GAUSS, 0, params)
pop = NEAT.Population(g, params, True, 1.0)
for generation in range(1000):
genome_list = NEAT.GetGenomeList(pop)
# fitnesses = NEAT.EvaluateGenomeList_Parallel(genome_list, evaluate)
fitnesses = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
best = max([x.GetLeader().GetFitness() for x in pop.Species])
# print 'Best fitness:', best
# 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("CPPN", img)
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildHyperNEATPhenotype(net, substrate)
img = np.zeros((250, 250, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 250, 250), net, substrate=True)
cv2.imshow("NN", img)
cv2.waitKey(1)
pop.Epoch()
# print "Generation:", generation
generations = generation
if best > 15.5:
break
return generations
def validator(NEAT_file, Morph_file, log_frames, run_num, eval_time, dt, n,
num_joints, output_path, gennumber, eucquad):
genome = [0, {}]
# Load in the best performing NEAT genome
genome[0] = NEAT.Genome(NEAT_file)
# Load the morphology
with open(Morph_file, "r") as f:
line = f.readline()
line = line.strip().split(',')
genome[1][0] = float(line[0]) # read frequency
GlobalVarWorkaround.man = ODEManager(near_callback,
stepsize=dt / n,
log_data=log_frames,
fluid_dynamics=1,
gravity=0,
run_num=run_num)
GlobalVarWorkaround.worm = Worm(man=GlobalVarWorkaround.man,
morphology_genome=genome[1],
num_joints=num_joints,
logging=log_frames,
log_path=output_path,
logfileprefix='rep' + str(run_num) +
'_gen' + str(gennumber))
GlobalVarWorkaround.foodenv = FoodEnvironment(man=GlobalVarWorkaround.man,
square_size=40,
eucquadrant=eucquad)
# If logging the output, tell manager to write the body type, dimensions, and position to the logging file.
# Must be placed after creating the quadruped.
if log_frames:
GlobalVarWorkaround.man.log_world_setup(eval_time, ind_num=run_num)
simulation = Simulation(eval_time,
dt=dt,
n=n,
man=GlobalVarWorkaround.man,
worm=GlobalVarWorkaround.worm)
#simulation.current_network = NEAT.NeuralNetwork()
#genome[0].BuildPhenotype(simulation.current_network)
fit = simulation.evaluate_individual(genome)
print(fit)
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 getbest():
g = NEAT.Genome(0, 7, 1, False, NEAT.ActivationFunction.SIGNED_SIGMOID,
NEAT.ActivationFunction.SIGNED_SIGMOID, params)
pop = NEAT.Population(g, params, True, 1.0)
for generation in range(2000):
genome_list = NEAT.GetGenomeList(pop)
# fitnesses = NEAT.EvaluateGenomeList_Parallel(genome_list, evaluate)
fitnesses = NEAT.EvaluateGenomeList_Serial(genome_list,
evaluate_xor,
display=True)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
best = max([x.GetLeader().GetFitness() for x in pop.Species])
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().BuildPhenotype(net)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
NEAT.DrawPhenotype(img, (0, 0, 500, 500), net)
cv2.imshow("CPPN", img)
net = NEAT.NeuralNetwork()
pop.Species[0].GetLeader().Build_ES_Phenotype(net, substrate, params)
img = np.zeros((500, 500, 3), dtype=np.uint8)
img += 10
utilities.DrawPhenotype(img, (0, 0, 500, 500), net, substrate=True)
cv2.imshow("NN", img)
cv2.waitKey(1)
generations = generation
if best > 15.0:
break
pop.Epoch()
return generations
def getbest():
g = NEAT.Genome(0, 3, 2, 1, False,
NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 1, params)
pop = NEAT.Population(g, params, True, 1.0)
pool = mpc.Pool(processes=4)
generations = 0
for generation in range(1000):
genome_list = []
for s in pop.Species:
for i in s.Individuals:
genome_list.append(i)
# for g in genome_list:
# f = evaluate(g)
# g.SetFitness(f)
# Parallel processing
fits = pool.map(evaluate, genome_list)
for f, g in zip(fits, genome_list):
g.SetFitness(f)
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 create_robot(maze_env, seed):
"""
The function to create population of robots.
"""
params = create_robot_params()
# Genome has 11 inputs and two outputs
genome = NEAT.Genome(0, 11, 0, 2, False,
NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params,
0)
pop = NEAT.Population(genome, params, True, 1.0, seed)
pop.RNG.Seed(seed)
robot_archive = archive.NoveltyArchive(metric=maze.maze_novelty_metric)
robot = Robot(maze_env=maze_env,
archive=robot_archive,
genome=genome,
population=pop)
return robot
def validator(self,NEAT_file,Morph_file):
""" Validate a single run.
Args:
NEAT_File: file for the NEAT genome
Morph_file: file for the morphology components
"""
global man, quadruped
self.validating = True
# Initialize the manager to be unique to the process.
man = ODEManager(near_callback, stepsize=self.dt/self.n, log_data=self.log_frames, run_num=self.run_num,erp=0.5,cfm=1E-2)
genome = [0,{}]
if NEAT_file:
# Load in the best performing NEAT genome
genome[0] = NEAT.Genome(NEAT_file)
self.current_network = NEAT.NeuralNetwork()
if not self.hyperNEAT:
genome[0].BuildPhenotype(self.current_network)
else:
genome[0].BuildHyperNEATPhenotype(self.current_network,self.substrate)
if Morph_file:
with open(Morph_file,"r") as f:
line = f.readline()
line = line.strip().split(',')
genome[1]['erp'] = float(line[0])
genome[1]['cfm'] = float(line[1])
# Initialize the quadruped
quadruped = Quadruped(man=man,morphology_genome={'erp':genome[1]['erp'],'cfm':genome[1]['cfm']})
# If logging the output, tell manager to write the body type, dimensions, and position to the logging file.
# Must be placed after creating the quadruped.
if self.log_frames:
man.log_world_setup(self.eval_time,ind_num=self.run_num)
fit = self.physics_only_simulation_validator()
return self.ann_activations,self.joint_feedback
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 __init__(self,
population_size=100,
input_size=9,
output_size=1,
generations=50):
"""Initialize the trainer.
Keyword arguments:
population_size -- number of genomes per generation (default 100)
input_size -- size of the input state + 1 (default 9)
output_size -- size of the result of the genome neural networks (default 1)
generations -- number of generations (default 50)
"""
self.generations = generations
self.params = NEAT.Parameters()
self.params.PopulationSize = population_size
genome = NEAT.Genome(0, input_size, 0, output_size, False,
NEAT.ActivationFunction.UNSIGNED_SIGMOID,
NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0,
self.params, 0)
self.population = NEAT.Population(genome, self.params, True, 1.0, 0)
def getbest(i):
g = NEAT.Genome(0, substrate.GetMinCPPNInputs(), 0,
substrate.GetMinCPPNOutputs(), False,
NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.TANH,
0, params, 0)
pop = NEAT.Population(g, params, True, 1.0, i)
pop.RNG.Seed(i)
for generation in range(max_generations):
genome_list = NEAT.GetGenomeList(pop)
# if sys.platform == 'linux':
# fitnesses = EvaluateGenomeList_Parallel(genome_list, evaluate, display=False)
# else:
fitnesses = EvaluateGenomeList_Serial(genome_list,
evaluate,
display=False)
[
genome.SetFitness(fitness)
for genome, fitness in zip(genome_list, fitnesses)
]
net = NEAT.NeuralNetwork()
pop.GetBestGenome().BuildPhenotype(net)
complexity = "complexity ({}, {})".format(net.NumHiddenNeurons(),
net.NumConnections())
print('Gen: %d/%d Best: %3.5f. %s' %
(generation, max_generations - 1, max(fitnesses), complexity))
best = max(fitnesses)
pop.Epoch()
generations = generation
if best > 15.0:
break
return generations
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 hillclimb(g,params,evals,evaluate,seed=1):
pop = NEAT.Population(g, params, True, 1.0, seed)
pop.RNG.Seed(seed)
species = pop.Species[0]
champ = g
c_fitness,beh = evaluate(champ)
champ.SetFitness(c_fitness)
champ.SetEvaluated()
for x in xrange(evals):
baby = NEAT.Genome(champ) #copy.copy(champ)
species.MutateGenome(False,pop,baby,params,pop.RNG)
b_fitness,beh = evaluate(baby)
#print b_fitness, evaluate(champ)
if b_fitness > c_fitness:
#print b_fitness,evaluate(champ)
c_fitness = b_fitness
champ.Destroy()
champ = baby
else:
baby.Destroy()
return champ,c_fitness
