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(200): # print("generation #", format(generation)) 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) # print("best fitness ", best) if best > 15.0: break return generations
def sparseness(genome): distances = [] for g in NEAT.GetGenomeList(pop): d = genome.behavior.distance_to(g.behavior) distances.append(d) # get the distances from the archive as well for ab in archive: distances.append(genome.behavior.distance_to(ab)) distances = sorted(distances) sp = np.mean(distances[1:ns_K + 1]) return sp
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 grid2d_substrate(inputs: int, hidden_layers: int, nodes_per_layer: [int], outputs: int, leaky=True): input_nodes = get_2d_point_line(inputs, (-1.0, -1.0), (-1.0, 1.0)) hidden_nodes = [] layers = get_2d_point_line(hidden_layers + 2, (-1, 0), (1, 0)) for i in range(hidden_layers): layer_x = layers[i + 1][0] hidden_nodes += get_2d_point_line(nodes_per_layer[i], (layer_x, -1.0), (layer_x, 1.0)) output_nodes = get_2d_point_line(outputs, (1.0, -1.0), (1.0, 1.0)) subst = neat.Substrate(input_nodes, hidden_nodes, output_nodes) subst.m_query_weights_only = True return subst
def Draw(x, size=(300, 300)): img = np.zeros((size[0], size[1], 3), dtype=np.uint8) img += 10 if isinstance(x, mneat.NeuralNetwork): DrawPhenotype(img, (0, 0, 250, 250), x) else: nn = mneat.NeuralNetwork() x.BuildPhenotype(nn) DrawPhenotype(img, (0, 0, 250, 250), nn) return img
def build_phenotype(self, current_genome): """ Constructs an agent phenotype from its genotype. :param current_genome: agent genome. :return: agent phenotype network. """ net = mneat.NeuralNetwork() current_genome.BuildPhenotype(net) return net
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 evaluate(genome): # create a neural network for the genome net = NEAT.NeuralNetwork() genome.BuildESHyperNEATPhenotype(net, substrate, params) # create a board board = Board(width, height) canAddPiece = 1 current = 0 line = 0 maxPieces = 300 # while the game is not over while (current < maxPieces): # get a piece pieceNum = random.randint(0, 6) piece = Piece(pieceNum) # pass board configuation & piece to the neural network conf = board.getBoard().ravel() c2, c3, c4, c5 = [piece.getPieceArray(i).ravel() for i in range(4)] conf = np.concatenate([conf, c2, c3, c4, c5]) #conf = [tuple(row) for row in conf] np.append(conf, pieceNum) np.append(conf, 1.0) # bias net.Input(conf) net.Activate() output = net.Output() if PRINT: print "output:", output[0], "outout", output[1] ## Found bug, output isnt always between 0 and 1 col = int(sum(output[0:10])) rot = int(sum(output[10:14])) print col, rot ##print "output1:", output[0], "output2:", output[1] # update the board by the output we get ##print "rot: ", rot, "col: ", col canAddPiece = board.addPiece(piece, rot, col) line = line + board.clearRows() if canAddPiece == -1: #print board break current += 1 # evaluate fitness #return line print "Rows Cleared:", line, " Pieces: ", current return current
def evaluate(genome): net = NEAT.NeuralNetwork() genome.BuildPhenotype(net) avg_reward = 0 for trial in range(trials): avg_reward += do_trial(net) avg_reward /= trials #print(avg_reward) return 1000000 + avg_reward
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 get_signals(genome, df): # this creates a neural network (phenotype) from the genome net = NEAT.NeuralNetwork() genome.BuildPhenotype(net) signals = [] for index, row in df.iterrows(): row_list = list(row) row_list.pop(0) net.Input(row_list) net.Activate() signals.append(net.Output()[0]) return signals
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 evaluate(genome): net = NEAT.NeuralNetwork() genome.BuildPhenotype(net) net.Flush() ge = GpuExec() full_input = np.array([1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], dtype=np.float32) out = ge.eval(full_input, 3, 4, net) # print(out) targets = [1, 1, 0, 0] err = np.abs(out - targets) return (4 - np.sum(err)) ** 2
def create_params(): params = NEAT.Parameters() params.PopulationSize = 150 params.DynamicCompatibility = True params.CompatTreshold = 3.0 params.YoungAgeTreshold = 15 params.SpeciesMaxStagnation = 100 params.OldAgeTreshold = 35 params.MinSpecies = 5 params.MaxSpecies = 10 params.RouletteWheelSelection = False params.MutateRemLinkProb = 0.02 params.RecurrentProb = 0 params.OverallMutationRate = 0.15 params.MutateAddLinkProb = 0.1 params.MutateAddNeuronProb = 0.03 params.MutateWeightsProb = 0.90 params.MaxWeight = 8.0 params.WeightMutationMaxPower = 0.2 params.WeightReplacementMaxPower = 1.0 params.MutateActivationAProb = 0.0 params.ActivationAMutationMaxPower = 0.5 params.MinActivationA = 0.05 params.MaxActivationA = 6.0 params.MutateNeuronActivationTypeProb = 0.3 params.ActivationFunction_SignedGauss_Prob = 1.0 params.ActivationFunction_SignedSigmoid_Prob = 1.0 params.ActivationFunction_SignedSine_Prob = 1.0 params.ActivationFunction_Linear_Prob = 1.0 params.ActivationFunction_Tanh_Prob = 0.0 params.ActivationFunction_SignedStep_Prob = 0.0 params.ActivationFunction_UnsignedSigmoid_Prob = 0.0 params.ActivationFunction_TanhCubic_Prob = 0.0 params.ActivationFunction_UnsignedStep_Prob = 0.0 params.ActivationFunction_UnsignedGauss_Prob = 0.0 params.ActivationFunction_Abs_Prob = 0.0 params.ActivationFunction_UnsignedSine_Prob = 0.0 params.MutateNeuronTraitsProb = 0 params.MutateLinkTraitsProb = 0 params.AllowLoops = False return params
def build_parameters(): params = NEAT.Parameters() params.PopulationSize = 100 params.DynamicCompatibility = True params.NormalizeGenomeSize = True params.WeightDiffCoeff = 0.1 params.CompatTreshold = 2.0 params.YoungAgeTreshold = 15 params.SpeciesMaxStagnation = 15 params.OldAgeTreshold = 35 params.MinSpecies = 2 params.MaxSpecies = 10 params.RouletteWheelSelection = False params.RecurrentProb = 0.0 params.OverallMutationRate = 1.0 params.ArchiveEnforcement = False params.MutateWeightsProb = 0.05 params.WeightMutationMaxPower = 0.5 params.WeightReplacementMaxPower = 8.0 params.MutateWeightsSevereProb = 0.0 params.WeightMutationRate = 0.25 params.WeightReplacementRate = 0.9 params.MaxWeight = 8 params.MutateAddNeuronProb = 0.001 params.MutateAddLinkProb = 0.3 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.0 params.MultipointCrossoverRate = 0.0 params.SurvivalRate = 0.2 params.MutateNeuronTraitsProb = 0 params.MutateLinkTraitsProb = 0 params.AllowLoops = True params.AllowClones = True return params
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 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 evaluate_solutions(robot, obj_func_coeffs, generation): best_robot_genome = None solution_found = False distances = [] n_items_list = [] # evaluate robot genomes against maze simulation robot_genomes = NEAT.GetGenomeList(robot.population) for genome in robot_genomes: found, distance, n_item = evaluate_individual_solution( genome=genome, generation=generation, robot=robot) # store returned values distances.append(distance) n_items_list.append(n_item) if found: best_robot_genome = genome solution_found = True # evaluate novelty scores of robot genomes and calculate fitness max_fitness = 0 best_coeffs = None best_distance = 1000 best_novelty = 0 for i, n_item in enumerate(n_items_list): novelty = robot.archive.evaluate_novelty_score( item=n_item, n_items_list=n_items_list) # The sanity check assert robot_genomes[i].GetID() == n_item.genomeId # calculate fitness fitness, coeffs = evaluate_solution_fitness(distances[i], novelty, obj_func_coeffs) robot_genomes[i].SetFitness(fitness) if not solution_found: # find the best genome in population if max_fitness < fitness: max_fitness = fitness best_robot_genome = robot_genomes[i] best_coeffs = coeffs best_distance = distances[i] best_novelty = novelty elif best_robot_genome.GetID() == n_item.genomeId: # store fitness of winner solution max_fitness = fitness best_coeffs = coeffs best_distance = distances[i] best_novelty = novelty return best_robot_genome, solution_found, max_fitness, distances, best_coeffs, best_distance, best_novelty
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
def evaluate_xor(genome): net = NEAT.NeuralNetwork() genome.BuildHyperNEATPhenotype(net, substrate) # nn=genome.BuildHyperNEATPhenotype(net, substrate) # error = 0 # depth = 5 # do stuff and return the fitness # net.Flush() net = NEAT.NeuralNetwork() genome.BuildPhenotype(net) img = np.zeros((400, 400, 3), dtype=np.uint8) img += 10 NEAT.DrawPhenotype(img, (0, 0, 400, 400), net) cv2.imshow("CPPN", img) # Visualize best network's Pheotype net = NEAT.NeuralNetwork() genome.BuildESHyperNEATPhenotype(net, substrate, params) img = np.zeros((800, 800, 3), dtype=np.uint8) img += 10 NEAT.DrawPhenotype(img, (0, 0, 800, 800), net, substrate=True) cv2.imshow("NN", img) cv2.waitKey(33) subprocess.call('./autostart.sh',shell=True) # print("b") # time.sleep(1) # print("c") main(MyDriver(net=net)) # print("d") with open("mydata.txt",'r') as f: fitt=f.read() # os.system('pkill torcs') subprocess.call('./autostop.sh',shell=True) # print("fitness ******************* ",fitt) return float(fitt)
def evaluate_xor(genome): net = NEAT.NeuralNetwork() try: genome.BuildESHyperNEATPhenotype(net, substrate, params) error = 0 depth = 3 correct = 0.0 net.Flush() net.Input([1, 0, 1]) [net.Activate() for _ in range(depth)] o = net.Output() error += abs(o[0] - 1) if o[0] > 0.75: correct += 1. net.Flush() net.Input([0, 1, 1]) [net.Activate() for _ in range(depth)] o = net.Output() error += abs(o[0] - 1) if o[0] > 0.75: correct += 1. net.Flush() net.Input([1, 1, 1]) [net.Activate() for _ in range(depth)] o = net.Output() error += abs(o[0] - 0) if o[0] < 0.25: correct += 1. net.Flush() net.Input([0, 0, 1]) [net.Activate() for _ in range(depth)] o = net.Output() error += abs(o[0] - 0) if o[0] < 0.25: correct += 1. return (4 - error)**2 except Exception as ex: print('Exception:', ex) return 0.0
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 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 simulate_genome(genome, config): """ """ network = NEAT.NeuralNetwork() traits = genome.GetGenomeTraits() genome.BuildPhenotype(network) genome.CalculateDepth() depth = genome.GetDepth() morphogens = [] def fitness(grid): return balanced_accuracy_score_np(pred=grid, true=config['target']) grid = run_simulation(network, depth, traits, config, fitness) return fitness(grid), grid
def __init__(self, parameter_data): self.parameter_data = parameter_data genotype = pickle.loads(self.parameter_data['genotype_pickled']) self.net = NEAT.NeuralNetwork() genotype.BuildPhenotype(self.net) self.standardizer = standardizer.Standardizer([]) self.standardizer.feature_statistics = self.parameter_data[ 'feature_statistics'] self.effect = effect.get_effect_instance( self.parameter_data['args']['effect_names']) self.effect_parameters = None
def create_objective_fun(seed): """ The function to create population of objective functions """ params = create_objective_fun_params() # Genome has one input (0.5) and two outputs (a and b) genome = NEAT.Genome( 0, 1, 1, 2, False, NEAT.ActivationFunction.TANH, # hidden layer activation NEAT.ActivationFunction.UNSIGNED_SIGMOID, # output layer activation 1, params, 0) pop = NEAT.Population(genome, params, True, 1.0, seed) pop.RNG.Seed(seed) obj_archive = archive.NoveltyArchive( metric=maze.maze_novelty_metric_euclidean) obj_fun = ObjectiveFun(archive=obj_archive, genome=genome, population=pop) return obj_fun
def create_robot_params(): """ The function to create NEAT hyper-parameters for population of robots """ params = NEAT.Parameters() params.PopulationSize = 250 params.DynamicCompatibility = True params.AllowClones = False params.AllowLoops = True params.CompatTreshold = 2.0 params.CompatTresholdModifier = 0.3 params.YoungAgeTreshold = 15 params.SpeciesMaxStagnation = 20 params.OldAgeTreshold = 200 params.MinSpecies = 3 params.MaxSpecies = 20 params.RouletteWheelSelection = True params.RecurrentProb = 0.2 params.OverallMutationRate = 0.4 params.LinkTries = 40 params.SpeciesDropoffAge = 200 params.DisjointCoeff = 1.0 params.ExcessCoeff = 1.0 params.MutateWeightsProb = 0.90 params.WeightMutationMaxPower = 0.8 params.WeightReplacementMaxPower = 5.0 params.MutateWeightsSevereProb = 0.5 params.WeightMutationRate = 0.75 params.MaxWeight = 30.0 params.MinWeight = -30.0 params.MutateAddNeuronProb = 0.03 params.MutateAddLinkProb = 0.05 params.MutateRemLinkProb = 0.1 params.Elitism = 0.1 params.CrossoverRate = 0.8 params.MultipointCrossoverRate = 0.6 params.InterspeciesCrossoverRate = 0.01 params.MutateNeuronTraitsProb = 0.1 params.MutateLinkTraitsProb = 0.1 return params
def evaluate(genome): net = NEAT.NeuralNetwork() genome.BuildPhenotype(net) error = 0 maxval = 100 for i in range(maxval): net.Flush() net.Input(np.array([float(i), 1])) for _ in range(2): net.Activate() o = net.Output() error += abs(i/2 -o[0]) fitness = -error/maxval return fitness
def eval_individual(genome_id, genome, genomes, n_items_map, generation): """ Evaluates the individual represented by genome. Arguments: genome_id: The ID of genome. genome: The genome to evaluate. genomes: The genomes population for current generation. n_items_map: The map to hold novelty items for current generation. generation: The current generation. Return: The True if successful solver found. """ # create NoveltyItem for genome and store it into map n_item = archive.NoveltyItem(generation=generation, genomeId=genome_id) n_items_map[genome_id] = n_item # run the simulation maze_env = copy.deepcopy(trial_sim.orig_maze_environment) multi_net = NEAT.NeuralNetwork() genome.BuildPhenotype(multi_net) control_net = ANN(multi_net) goal_fitness = maze.maze_simulation_evaluate( env=maze_env, net=control_net, time_steps=SOLVER_TIME_STEPS, n_item=n_item) # Store simulation results into the agent record record = agent.AgenRecord(generation=generation, agent_id=genome_id) record.fitness = goal_fitness record.x = maze_env.agent.location.x record.y = maze_env.agent.location.y record.hit_exit = maze_env.exit_found #record.species_id = trial_sim.population.species.get_species_id(genome_id) #record.species_age = record.generation - trial_sim.population.species.get_species(genome_id).created # add record to the store trial_sim.record_store.add_record(record) # Evaluate the novelty of a genome and add the novelty item to the archive of Novelty items if appropriate if not maze_env.exit_found: # evaluate genome novelty and add it to the archive if appropriate record.novelty = trial_sim.archive.evaluate_individual_novelty(genome=Genome(genome), genomes=genomes, n_items_map=n_items_map) # update fittest organisms list trial_sim.archive.update_fittest_with_genome(genome=Genome(genome), n_items_map=n_items_map) return (maze_env.exit_found, goal_fitness)
def __init__(self, path=None): self.traits_calculated = False # Evolution. self.neat = NEAT.Parameters() self.neat.PopulationSize = 80 self.neat.OldAgeTreshold = 10 self.neat.SpeciesMaxStagnation = 10 self.neat.MinSpecies = 2 self.neat.MaxSpecies = 8 self.neat.OverallMutationRate = 0.6 self.neat.MutateAddNeuronProb = 0.05 self.neat.MutateAddLinkProb = 0.05 self.neat.AllowLoops = False # Coral Growth. self.max_polyps = 15000 self.max_volume = 50.0 self.max_steps = 150 self.max_growth = .20 self.max_defect = 1.4 self.max_face_growth = 1.3 self.n_morphogens = 2 self.n_signals = 3 self.n_memory = 0 self.light_amount = 0.7 self.gradient_height = 6.0 self.gradient_bottom = 0.2 self.collection_radius = 5 self.C = .4 self.morphogen_thresholds = 2 self.morphogen_steps = 200 self.use_polar_direction = False self.addTrait('energy_diffuse_steps', (0, 8), 'int') if path: for line in open(path).readlines(): key, value = line.strip().split('\t') if value == 'True': value = '1' if value == 'False': value = '0' setattr(self, key, float(value) if '.' in value else int(value))
#!/usr/bin/python import os import sys import time import random as rnd import commands as comm import cv2 import numpy as np import cPickle as pickle import MultiNEAT as NEAT import multiprocessing as mpc params = NEAT.loadParameters('params.txt') # the simple 2D substrate with 3 input points, 2 hidden and 1 output for XOR substrate = NEAT.EvolvableSubstrate(params, [(-1, -1), (-1, 0), (-1, 1)], [(1, 0)]) # let's set the activation functions substrate.m_hidden_nodes_activation = NEAT.ActivationFunction.TANH substrate.m_outputs_nodes_activation = NEAT.ActivationFunction.UNSIGNED_SIGMOID # code cv2.namedWindow('CPPN', 0) cv2.namedWindow('NN', 0) def evaluate(genome): net = NEAT.NeuralNetwork()
import pyximport; pyximport.install() import numpy import math import os import sys import time import random as rnd import numpy as np import cPickle import pickle as pickle import MultiNEAT as NEAT import niche_transform print "loading..." NEAT.import_array() import matplotlib matplotlib.use('gtkagg') import pylab as plt from render_vox_fast import render import image_rec from image_rec import run_image from melites import melites from melites import novsearch from fool_eval import evaluate from clint.arguments import Args args = Args() arg_dict = dict(args.grouped) seed=10