def cora(): G = nx.barabasi_albert_graph(1000, 3) # G = nx.watts_strogatz_graph(1000, 5, 0.3) # G = nx.random_regular_graph(4, 1000) p = Population(G) e = Evolution() g = game.PDG(2) e.set_population(p).set_game(g) # p.strategy = np.ones(len(p), np.int) f, axs = plt.subplots(3, 4) axs = axs.reshape(12) for r in range(11): if r > 5: r_ = 10 - r p.strategy = np.zeros(len(p), dtype=np.int) s = 1 else: r_ = r p.strategy = np.ones(len(p), dtype=np.int) s = 0 n = int(round(len(p) / 10.0 * r_)) selected_list = np.random.choice(range(len(p)), n) p.strategy[selected_list] = s # print p.strategy g.strategy = p.strategy g.play() p.show_degree(axs[r]) plt.show()
def __init__(self, dim, renderer, animation): self.dim = dim self.renderer = renderer self.animation = animation self.evolution = Evolution() self.grid = [[None for y in range(dim)] for x in range(dim)] for i in range(dim): for j in range(dim): self.grid[i][j] = Cell(i, j) for i in range(dim): for j in range(dim): cell = self.grid[i][j] cell.addNeighbor(self.grid[i - 1][j] if i - 1 >= 0 else None) cell.addNeighbor(self.grid[i + 1][j] if i + 1 < dim else None) cell.addNeighbor(self.grid[i][j - 1] if j - 1 >= 0 else None) cell.addNeighbor(self.grid[i][j + 1] if j + 1 < dim else None) cell.addNeighbor(self.grid[i - 1][j - 1] if i - 1 >= 0 and j - 1 >= 0 else None) cell.addNeighbor(self.grid[i - 1][j + 1] if i - 1 >= 0 and j + 1 < dim else None) cell.addNeighbor(self.grid[i + 1][j - 1] if i + 1 < dim and j - 1 >= 0 else None) cell.addNeighbor(self.grid[i + 1][j + 1] if i + 1 < dim and j + 1 < dim else None)
def darwinLoop(self, maxLoops, parentCount=4, parentKept=2): ### Loop on world, evaluate n parents, keep only m best ones and replace others by evolution from kept best ones j = 0 print "darwin loop started" while (j < maxLoops): print "--- Darwin in the while loop " + str(j) ### Store best Move and distance bestDistance = 0 bestMove = 0 evalMovesIndexes = random.sample(range(0, len(self.world)), parentCount) print "evalMoves=" print evalMovesIndexes print "darwin after evalmoves" for i in evalMovesIndexes: print "darwin in the for loop" print self.world print self.world[str(i)] if (self.world[str(i)]._distance is None): self.world[str(i)]._distance = self.executor.run( self.world[str(i)]) print "Executor done" # sort evalMoves print "evalMovesSorted=" evalMovesSorted = sorted( evalMovesIndexes, key=lambda i: self.world[str(i)]._distance) print evalMovesSorted #keep 2 bests (2 last) # We dont need to do anything to keep them... # replace 2 worsts by children of 2 best ==> Verify the content of simpleCrossover execution e = Evolution() print("CrossingOver : last and last-1") pprint.pprint(str(self.world[str(evalMovesSorted[-1])])) pprint.pprint(str(self.world[str(evalMovesSorted[-2])])) print("CrossOver result : ") (A, B) = e.simpleCrossover(self.world[str(evalMovesSorted[-1])], self.world[str(evalMovesSorted[-2])]) # Uncomment to use mutation (NOT TESTED YET) # A = mutation(0.05, 10, A) # B = mutation(0.05, 10, B) self.world[str(evalMovesSorted[0])] = A self.world[str(evalMovesSorted[1])] = B pprint.pprint(str(self.world[str(evalMovesSorted[0])])) pprint.pprint(str(self.world[str(evalMovesSorted[1])])) j += 1
def solve(problem, save=False, img_prefix=""): bests = [] evolution = Evolution( generate_population(len(problem.world), problem.population), makefitness(problem.U, problem.T, problem.world), selection, crossover, mutation_simple, keep=min ) before = evolution.stats() first = evolution.best(min) for i in range(problem.iterations): print(i) evolution.advance() bests.append(min(evolution.scores)) after = evolution.stats() if(save): # representation.save_chart('results/' + img_prefix + 'chart.png', bests, problem.iterations) # representation.save_graph('results/' + img_prefix + 'first.png', problem, first) representation.save_graph('results2/' + img_prefix + '.png', problem, evolution.best(min)) else: write_results(problem, before, after)
def lattice(): l = 100 def observe(s, f): plt.imshow(s.reshape((l, l)), interpolation='sinc', cmap='bwr') plt.show() G = nx.grid_2d_graph(l, l) # nx.draw(G, node_size=200, with_labels=True) # plt.show() p = Population(G) e = Evolution() e.set_population(p).set_game(g).set_rule(u) # e.evolve(1) observe(p.strategy, p.fitness)
def __init__(self, races, statistics=None): self._creature_counter = 0 self._races = races self._space = Space(ConfigPhysics.SPACE_SIZE) self._time = 0 self.statistics = statistics for race in races: num_fathers = ConfigPhysics.NUM_FATHERS fathers_locations_i = np.random.choice(ConfigPhysics.SPACE_SIZE, num_fathers) fathers_locations_j = np.random.choice(ConfigPhysics.SPACE_SIZE, num_fathers) ages = np.random.randint(low=0, high=ConfigBiology.BASE_LIFE_EXPECTANCY, size=num_fathers) for n in range(num_fathers): dna = Evolution.mutate_dna(race.race_basic_dna()) self.create_creature(race, id=self.allocate_id(), dna=dna, coord=(fathers_locations_i[n], fathers_locations_j[n]), age=ages[n], parents=None) self.give_food(ConfigPhysics.INITIAL_FOOD_AMOUNT)
def next_generation(self): self.current_id = 0 self.avg_fitness = 0 if self.create: brains = [snake.brain for snake in self.snakes.values()] generation = Evolution(brains, self.selection, self.crossover, self.mutation, self.seed, self.generation) brains = generation.evolve() self.snakes = dict() for snk_id in range(self.population): snake = Snake(snk_id, self.initial_pos, brains[snk_id]) self.snakes[snk_id] = snake else: for snk_id in range(self.population): snake = Snake.load(self.generation, snk_id) self.snakes[snk_id] = snake self.reset_game()
def run_deap(X, y): popsize = 500 mutRate = 0.4 crRate = 0.6 GenMax = 250 # concatenate selected features with their target values dataset = np.column_stack((X, y)) evo = Evolution( dataset=dataset.tolist(), # data samples popsize=popsize, # initial population size hofsize=25, # the number of best individual to track cx=crRate, # crossover rate mut=mutRate, # mutation rate maxgen=GenMax, # max number of generations ) pop, logbook, hof = evo.run(verbose=1) return evo, pop, logbook, hof
def repeat_b(): # 博弈收益参数不同,合作率曲线 e = Evolution(has_mut=False) G = nx.random_regular_graph(4, 1000) p = Population(G) b = 5 for i in range(b): g = game.PDG(i * 2 + 2) e.set_population(p).set_game(g).set_rule(u) print('Control Variable b: %d' % (i * 2 + 2)) e.evolve(100000, restart=True, quiet=True, autostop=False) e.show(fmt[i], label="b=%d" % (i * 2 + 2)) plt.legend(loc='lower right') plt.show()
class Grid: def __init__(self, dim, renderer, animation): self.dim = dim self.renderer = renderer self.animation = animation self.evolution = Evolution() self.grid = [[None for y in range(dim)] for x in range(dim)] for i in range(dim): for j in range(dim): self.grid[i][j] = Cell(i, j) for i in range(dim): for j in range(dim): cell = self.grid[i][j] cell.addNeighbor(self.grid[i - 1][j] if i - 1 >= 0 else None) cell.addNeighbor(self.grid[i + 1][j] if i + 1 < dim else None) cell.addNeighbor(self.grid[i][j - 1] if j - 1 >= 0 else None) cell.addNeighbor(self.grid[i][j + 1] if j + 1 < dim else None) cell.addNeighbor(self.grid[i - 1][j - 1] if i - 1 >= 0 and j - 1 >= 0 else None) cell.addNeighbor(self.grid[i - 1][j + 1] if i - 1 >= 0 and j + 1 < dim else None) cell.addNeighbor(self.grid[i + 1][j - 1] if i + 1 < dim and j - 1 >= 0 else None) cell.addNeighbor(self.grid[i + 1][j + 1] if i + 1 < dim and j + 1 < dim else None) def alive(self, i, j): self.grid[i][j].value = True return self def render(self): self.renderer.render(self) def animate(self): self.animation.animate(self) def next(self): self.evolution.next(self)
def test(): # Initialize darwinian = Evolution(10, 5) # Evolve darwinian.evolve(1000) # Get the best agent best_agent = darwinian.get_best_agent() # Visualize the performance for i_episode in range(10): observation = darwinian.env.reset() for t in range(500): darwinian.env.render() action = best_agent.action(observation) observation, reward, done, info = darwinian.env.step(action) if done: print("Episode finished after {} timesteps".format(t + 1)) break # Plot the statistics stats = darwinian.getStats() plt.plot(stats[0], stats[1]) plt.ylabel("Best Rewarded Genome") plt.xlabel("Generation") plt.show() # Sleep a bit time.sleep(1) darwinian.env.close()
def _get_next_evolution(p_name, p_lvl): evolutions = peds.get_level_up_evolutions(p_name) p_name = p_name.capitalize() if p_lvl == 100 or len(evolutions) == 0: return None # choose to evolve or not if len(evolutions) == 1: evo_name = evolutions[0][0] if _get_y_or_n_input('%s can evolve into %s, do you want ' % (p_name, evo_name.capitalize()) + 'this evolution to occur (y/n)? ') == 'y': next_evo = evolutions[0] else: next_evo = None # choose from selection of evolutions elif len(evolutions) > 1: evos = {evo[0]: evo[1] for evo in evolutions} print( '%s can evolve into one of these forms while leveling up:' % p_name, ', '.join(evos.keys())) next_evo_name = _get_choice_from_options( 'Which form should %s evolve into (or "none")? ' % p_name, list(evos.keys()) + ['none']) next_evo = ((next_evo_name, evos[next_evo_name]) if next_evo_name != 'none' else None) # get desired level for evolution if next_evo is None: return None next_evo_name, next_evo_conditions = next_evo # if level is specified if 'min_level' in next_evo_conditions: evo_level = max(next_evo_conditions['min_level'], p_lvl + 1) print('The earliest level that this evolution can ' + 'occur at is %i' % evo_level) if _get_y_or_n_input('Do you want %s ' % p_name + 'to evolve at this level (y/n)? ') == 'n': evo_level = _get_level_input('Which level should ' + '%s evolve at? ' % p_name, min_lvl=evo_level) # level not specified - happiness? time of day? else: print('A minimum level for this evolution is not specified. ' + 'It is instead determined by special conditions') evo_level = _get_level_input('Which level should ' + '%s evolve at? ' % p_name, min_lvl=p_lvl + 1) return Evolution(p_name.lower(), next_evo_name, evo_level, next_evo_conditions)
def creature_divide(self, creature): if creature.age() < ConfigBiology.MATURITY_AGE: if creature.energy() < ConfigBiology.MOVE_ENERGY: self.kill_creature(creature) return creature.reduce_energy(ConfigBiology.MOVE_ENERGY) return self.create_creature(creature.get_race(), self.allocate_id(), dna=Evolution.mutate_dna(creature.dna()), coord=creature.coord(), energy=int(creature.energy() / 2) + 1, parents=[creature]) creature.reduce_energy(amount=int(creature.energy() / 2)) creature._age = 1
def repeat_k(): # 网络平均度不同,合作率曲线 e = Evolution(has_mut=False) k = 5 a = [0] * k for i in range(k): G = nx.random_regular_graph(i * 2 + 2, 1000) p = Population(G) e.set_population(p).set_game(g).set_rule(u) print('Control Variable k: %d' % (i * 2 + 2)) e.evolve(100000, restart=True, quiet=True) # TODO: if e is CoEvolution, population need re-copy # a[i] = e.cooperate[-1] e.show(fmt[i], label="k=%d" % (i * 2 + 2)) # plt.plot(range(2, k+1), a[1:], 'r-') # plt.plot([400+i*i for i in range(20)], 'ro--', label='k=4') # plt.plot([400 + i for i in range(20)], 'g^-.', label='k=6') # plt.plot([400 - i for i in range(20)], 'cx:', label='k=8') plt.legend(loc='lower right') plt.show()
def repeat_start_pc(): # 初始Pc不同的合作变化曲线 # G = nx.watts_strogatz_graph(1000, 4, 0.2) G = nx.barabasi_albert_graph(1000, 3) p = Population(G) g = game.PDG(b=10) u = rule.DeathBirth() e = Evolution(has_mut=False) e.set_population(p).set_game(g).set_rule(u) for i in range(5): pc = (2 * i + 1) / 10.0 p.init_strategies(g, [pc, 1 - pc]) print('Initial P(C) is %.2f' % pc) e.evolve(100000, restart=True, quiet=True, autostop=False) e.show(fmt[i], label=r'start $P_C$=%.2f' % pc) plt.legend(loc='lower right') plt.title(r'Evolution under Different Start $P_C$') plt.xlabel('Number of generations') plt.ylabel(r'Fraction of cooperations, $\rho_c$') plt.show()
def creature_mate(self, creature): if creature.age() < ConfigBiology.MATURITY_AGE: if creature.energy() < ConfigBiology.MOVE_ENERGY: self.kill_creature(creature) return creature.reduce_energy(ConfigBiology.MOVE_ENERGY) return if creature.energy() < ConfigBiology.MATE_ENERGY: self.kill_creature(creature) return creature.reduce_energy(ConfigBiology.MATE_ENERGY) potential_spouses = self.space().get_nearby_creatures_from_same_race( creature) spouse = creature.select_spouse(potential_spouses) if spouse is None: return new_dna = Evolution.mix_dna(creature.dna(), spouse.dna()) self.create_creature(creature.get_race(), self.allocate_id(), new_dna, creature.coord(), parents=[creature, spouse])
def repeat2d(): e = Evolution() bs = np.linspace(1, 10, 3) # fig, axes = plt.subplots() colors = 'brgcmykwa' symbs = '.ox+*sdph-' for i in range(1, 10): i = 4 G = nx.random_regular_graph(i + 1, 1000) p = Population(G) a = [0] * len(bs) for j, b in enumerate(bs): g = game.PDG(b) e.set_population(p).set_game(g).set_rule(u) e.evolve(10000) a[j] = e.cooperate[-1] plt.plot(bs, a, colors[j] + symbs[j], label='b=%f' % b) break plt.show()
def run(): # Initialize darwinian = Evolution(15, 6) # Evolve darwinian.evolve(150) # Get the best agent best_genome = darwinian.get_best_genome() # Visualize the performance for i_episode in range(10): observation = darwinian.env.reset() for t in range(500): darwinian.env.render() action = best_genome.action(observation) observation, reward, done, info = darwinian.env.step(action) if done: print("Episode finished after {} timesteps".format(t+1)) break # Display the network architecture visualize(best_genome.get_inputs(), best_genome.get_outputs(), best_genome.get_connections()) # Plot the statistics stats = darwinian.get_statistics() plt.plot(stats[0], stats[1]) # average plt.plot(stats[0], stats[2]) # best plt.ylabel("Reward") plt.xlabel("Generation") plt.legend(['average', 'best'], loc='upper left') plt.show() # Sleep a bit time.sleep(1) darwinian.env.close()
from evolution import Evolution from file_loader import loadData X = [] Y = [] loadData('randomdata_4_500_500_3_30.txt', X, Y) evolutionAlgorithm = Evolution(20, 20, 20, 0.9, 3, X, Y) wyr = evolutionAlgorithm.evolving(40, False, True)
from evolution import Evolution, Species # define a species (gene pool, gene length) species = Species() # define a set of 10 organisms of species `Species` organisms = Evolution(species, pop_size=10) organims.create() fittest_organism = organisms.evolve(evolve_until_thresh_reached=True)
self.CAN_SAVE = can_save # additional config options for database connection or fukebane(s) self.HAS_CONFIG = has_config def parse(self, addressbook, conf): '''load file / open database connection''' # XXX: set addressbook in __init__? self.ab = addressbook pass def add(self, name, birthday): '''save new birthday to file/database (only if CAN_SAVE == true)''' pass def save_config(self, conf): '''record current entries in config menu into configuration''' pass def create_config(self, vbox, conf): '''create additional pygtk config in config menu''' pass from csv import CSV from evolution import Evolution from lightning import Lightning from mysql import MySQL from sunbird import Sunbird mysql_db = MySQL() DATABASES = [CSV(), Evolution(), Lightning(), mysql_db, Sunbird()]
batch_size = 4 sizes = [784, 30, 10] train_iterations = 100 test_iterations = 10 all_params = pop_size * [{ 'weights': [np.random.randn(m, n) for m, n in zip(sizes[1:], sizes)], 'biases': [np.random.randn(m, 1) for m in sizes[1:]], 'learning_rate': .1, 'regularization': .01 }] task = Task(batch_size) evolution = Evolution() for i in itertools.count(): agents = [ Agent(params['weights'], params['biases'], params['learning_rate'], params['regularization']) for params in all_params ] for j in range(train_iterations): x, y = task.train_input() costs = [np.average(a.costs) for a in agents] print('Ite {}: Avg cost: {}. Best cost {}'.format( j, np.average(costs), max(costs))) for agent in agents: agent.train(x, y)
verticals+=1 photos.append(Photo(len(photos), line[0], set(line[2:]))) return n, photos, verticals if __name__ == "__main__": """ uso: python3 main.py nombre-entrada """ filename = sys.argv[1] n, photos, verticals = get_info('input/{}'.format(filename)) print("file " + filename) e = Evolution(population, photos) if verticals <=1: vertical_mutation = 0 else: vertical_mutation = mutate_vertical_percent e.init_params(vertical_mutation, mutate_random_percent, parent_percent) for i in range(generations): print ("generation "+ str(i)) e.run_generation() best = e.best_ever fingerprint = "{}-{}-{}-{}-{}".format(population,generations, mutate_vertical_percent, mutate_random_percent, parent_percent ) with open("output/{}-{}.out".format(filename, fingerprint), "w") as f:
return 0 if __name__ == '__main__': results = [] labels = [2, 4, 6, 8] epochs = 100 for i in labels: evo = Evolution(size=i, fitness=fitness, combine_params=0.5, mutate_params={ "std": 0.5, "dim": 1, "min": 0, "max": 5 }, pop_params={ "min": 0, "max": 5, "dim": 1 }, method="combine") evo.run(epochs) results.append(evo.result) for i in labels: evo = Evolution(size=i, fitness=fitness, combine_params=0.1, mutate_params={ "std": 0.5,
# concatenate selected features with their target values dataset = np.column_stack((X, y)) popsize = [100, 250, 500, 1000] GenMax = [50, 100, 250, 500] mutRate = [0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] crRate = [0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6]# 0.7, 0.8, 0.9] reps = 5 states = 1 i = 6 evo = Evolution( dataset = dataset.tolist(), # data samples popsize = popsize[3], # initial population size hofsize = 10, # the number of best individual to track cx = crRate[i], # crossover rate mut = mutRate[6], # mutation rate maxgen = GenMax[2], # max number of generations ) logs = pd.DataFrame() gen = np.zeros((reps, GenMax[2]+1)) nevals = np.zeros((reps, GenMax[2]+1)) avg = np.zeros((reps, GenMax[2]+1)) mini = np.zeros((reps, GenMax[2]+1)) maxi = np.zeros((reps, GenMax[2]+1)) for l in range(reps): np.random.seed(reps)
from world import World from creature import Creature from evolution import Evolution import time if __name__ == "__main__": size = 35 population_size = 10 evolution_steps = 20 default_creatures_spec = {"max_step_size": 3, "steps_before_die": 10} world = World(size) evolution = Evolution(world, population_size, default_creatures_spec) for step in range(evolution_steps): world.draw_world() world.draw_creatures(evolution.creatures) world.redraw() evolution.make_step() time.sleep(0.3)
for i, filename in enumerate(filenames): tsp = Tsp(filename) print(filename, ans[i]) with open('log/test1/{}.txt'.format(filename), 'w') as f: start = time.time() f.write('{}, {}\n\n'.format(filename, ans[i])) for size in sizes: for generation in generations: for solution in solutions: selection = selections[solution[0]] crossover = crossovers[solution[1]] mutation = mutations[solution[2]] evolution = Evolution(tsp, size, generation, selection, crossover, mutation, select_rate, mutation_rate) f.write( 'size: {}, generation: {}, selection: {}, crossover: {}, mutation: {}\n' .format(size, generation, solution[0], solution[1], solution[2])) print( 'size: {}, generation: {}, selection: {}, crossover: {}, mutation: {}' .format(size, generation, solution[0], solution[1], solution[2])) dis_log = [] for g in range(generation): evolution.forward() min_dis, _ = evolution.get_population().min() if g % 1000 == 0:
def main(): #Create config builder values #Game Parameters HEIGHT = config_values.HEIGHT WIDTH = config_values.WIDTH WALL_DENSITY = config_values.WALL_DENSITY PILL_DENSITY = config_values.WALL_DENSITY FRUIT_CHANCE = config_values.FRUIT_CHANCE FRUIT_SCORE = config_values.FRUIT_SCORE TIME_MULT = config_values.TIME_MULT #Paramters RUNS = config_values.RUNS EVALS = config_values.EVALS #EA Parameters MAX_DEPTH = config_values.MAX_DEPTH PAC_POP_SIZE = config_values.pac_population_size GHOST_POP_SIZE = config_values.ghost_population_size PAC_GEN_STEP = config_values.pac_generation_step GHOST_GEN_STEP = config_values.ghost_generation_step P_SELECT = config_values.parent_selection OVER_S = config_values.over_sel S_SELECT = config_values.survival_selection T_SELECT = config_values.termination PAC_SUR_K = config_values.pac_survival_k GHOST_SUR_K = config_values.ghost_survival_k PAC_P_COEFF = config_values.pac_parsimony GHOST_P_COEFF = config_values.ghost_parsimony TERM_EVALS = config_values.term_evals CONVERGE = config_values.convergence MUT_RATE = config_values.mutation_rate P_UPPER = config_values.p_upper #Paths LOG = config_values.LOG GAME = config_values.BEST_GAME PAC_CONTROLLER = config_values.PAC GHOST_CONTOLLER = config_values.GHOST best_pac_fitness_all_runs = -1 best_ghost_fitness_all_runs = 1 #Starting logging logger.log_start(config_values) #Create the Game dictinary. Add 2 to compensate for border. game_dict = { "height" : HEIGHT+2, "width" : WIDTH+2, "wall_density" : WALL_DENSITY, "pill_density" : PILL_DENSITY, "fruit_chance" : FRUIT_CHANCE, "fruit_score" : FRUIT_SCORE, "time_mult" : TIME_MULT, } for i in range(RUNS): #Starting this Run print("Starting run {}".format(i+1)) #Insert now log block... logger.log_new_run(LOG, i) #Create the EA instance EA = Evolution(PAC_POP_SIZE, GHOST_POP_SIZE, PAC_GEN_STEP, GHOST_GEN_STEP, P_SELECT, S_SELECT, T_SELECT, PAC_SUR_K, GHOST_SUR_K, PAC_P_COEFF, GHOST_P_COEFF, OVER_S, TERM_EVALS, CONVERGE, MUT_RATE, game_dict, MAX_DEPTH, P_UPPER) best_pac_this_run = EA.get_best_fitness() best_ghost_this_run = EA.get_best_ghost_fitness() #Better fitnesses may have emerged this run's inital population if best_pac_this_run > best_pac_fitness_all_runs: #print the game and assign print_game(EA.best_world_string()) #Game contoller EA.get_best_member().print_controller(PAC_CONTROLLER) best_pac_fitness_all_runs = best_pac_this_run #Now for chost if best_ghost_this_run < best_ghost_fitness_all_runs: #Just print contoller and assign worst_game(EA.worst_world_string()) EA.get_best_ghost().print_controller(GHOST_CONTOLLER) best_ghost_fitness_all_runes = best_ghost_this_run #Start this runs log logger.log_new_entry(LOG, max(PAC_POP_SIZE, GHOST_POP_SIZE), best_pac_this_run, EA.get_average_fitness()) #Since a fitness evaluation is new defined as a game being player, when creating generations the number of #games played is max(pacman_lambda, ghost_lambda) for j in range((max(PAC_POP_SIZE, GHOST_POP_SIZE)+max(PAC_GEN_STEP, GHOST_GEN_STEP)), EVALS+1, max(PAC_GEN_STEP, GHOST_GEN_STEP)): #Main evolution loop #Create the next generation EA.create_generation() #Dump pools into their poplation EA.pac_dump_pool() EA.ghost_dump_pool() #Do the survival selection for both populations EA.do_pac_survival_selection() EA.do_ghost_survival_selection() #Log entry best_pac_this_run = EA.get_best_fitness() best_ghost_this_run = EA.get_best_ghost_fitness() #Check to see if any better controllers have emerged from the next generation #log entry logger.log_new_entry(LOG, j, best_pac_this_run, EA.get_average_fitness()) if best_pac_this_run > best_pac_fitness_all_runs: #print the game and assign print_game(EA.best_world_string()) #Game contoller EA.get_best_member().print_controller(PAC_CONTROLLER) best_pac_fitness_all_runs = best_pac_this_run if best_ghost_this_run <= best_ghost_fitness_all_runs: #Just print contoller and assign #Print the worst game for testing worst_game(EA.worst_world_string()) EA.get_best_ghost().print_controller(GHOST_CONTOLLER) best_ghost_fitness_all_runs = best_ghost_this_run if EA.determine_termination(): break
def f2(x): m = len(x) g = 1.0 + 10.0 * (m - 1) for i in range(1, m): g += (x[i]**2 - 10.0 * np.cos(4.0 * np.pi * x[i])) h = 1.0 - np.sqrt(x[0] / g) result = g * h return result problem = Problem(num_of_variables=10, objectives=[f1, f2], variables_range=[(-5, 5)], same_range=True, expand=False) problem.variables_range[0] = (0, 1) print(problem.variables_range) evo = Evolution(problem, mutation_param=5) func = [i.objectives for i in evo.evolve()] function1 = [i[0] for i in func] function2 = [i[1] for i in func] plt.xlabel('Function 1', fontsize=15) plt.ylabel('Function 2', fontsize=15) plt.plot(function1, function2, 'bo') plt.show() np.save('zdt4', func)
avg = t / len(networks) return avg if __name__ == '__main__': generations, population = 40, 30 parameters = { "no_neurons": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], # 4, "momentum_rate": [0.001, 0.01, 0.1, 0.2, 0.4, 0.6], #0.01, "lambda_rate": [0.001, 0.01, 0.1, 0.2, 0.4, 0.6], #0.001, "learning_rate": [0.1, 0.2, 0.4, 0.5, 0.6], #0.5, } history_of_errors = [] evolution_obj = Evolution(parameters) networks = evolution_obj.generate_population(population) for generations_idx in range(1, generations + 1): print("Generation - {} / {} :".format(generations_idx, generations)) for network in networks: network.fit() average_loss = find_average_loss(networks) history_of_errors.append(average_loss) print("Average Loss : {}".format(average_loss)) print("----------------------------------------------------") if (generations_idx != generations):