def eval_fitness(genomes, config): for idx, g in genomes: cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(substrate, cppn, params) net = network.create_phenotype_network() fitnesses = [] for i in xrange(trials): ob = env.reset() net.reset() total_reward = 0 for j in xrange(max_steps): for k in range(network.activations): o = net.activate(ob) action = np.argmax(o) ob, reward, done, info = env.step(action) total_reward += reward if done: break fitnesses.append(total_reward) g.fitness = np.array(fitnesses).mean()
def run(config_file): # Load configuration. config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. # p = neat.Population(config) p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-4') # Add a stdout reporter to show progress in the terminal. p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(1000)) #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-299') # Run for up to 300 generations. pe = neat.ParallelEvaluator(multiprocessing.cpu_count(), eval_genome) winner = p.run(pe.evaluate, 300) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') cppn = neat.nn.RecurrentNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) winner_net = network.create_phenotype_network( filename='es_hyperneat_winner.png') input("Winner is found") for i in range(10): train(winner_net, network, True) draw_net(cppn, filename="es_hyperneat")
def run(config_file): # Load configuration. config = neat.config.Config(neat.genome.DefaultGenome, neat.reproduction.DefaultReproduction, neat.species.DefaultSpeciesSet, neat.stagnation.DefaultStagnation, config_file) # Create the population, which is the top-level object for a NEAT run. #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-15') # Add a stdout reporter to show progress in the terminal. pop = neat.population.Population(config) stats = neat.statistics.StatisticsReporter() pop.add_reporter(stats) pop.add_reporter(neat.reporting.StdOutReporter(True)) pop.add_reporter(neat.Checkpointer(999)) #p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-299') # Run for up to 300 generations. winner = pop.run(eval_multipleGenomes, 300) # Display the winning genome. print('\nBest genome:\n{!s}'.format(winner)) # Show output of the most fit genome against training data. print('\nOutput:') cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) winner_net = network.create_phenotype_network( filename='es_hyperneat_winner.png') input("Winner is found") for i in range(10): train(winner_net, network, True) draw_net(cppn, filename="es_hyperneat")
def eval_fitness(self, genome, config): self.epoch_len = randint(42, 42 * 4) r_start = randint(0 + self.epoch_len, self.hs.hist_full_size - self.hd) #r_start_2 = self.hs.hist_full_size - self.epoch_len-1 best_g_fit = 0.0 champ_counter = self.gen_count % 10 #img_count = 0 for idx, g in genomes: cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(self.subStrate, cppn, self.params, self.hd) net = network.create_phenotype_network_nd() train_ft = self.evaluate(net, network, r_start, g) #validate_ft = self.evaluate(net, network, r_start_2, g) g.fitness = train_ft if (g.fitness > best_g_fit): best_g_fit = g.fitness with open( "./champ_data/kraken/latest_greatest" + str(champ_counter) + ".pkl", 'wb') as output: pickle.dump(g, output) #img_count += 1 if (champ_counter == 0): self.refresh() self.compare_champs() self.gen_count += 1 return
def eval_genomes(genomes, config): best_net = (None, None, -9999) runs = 10 environments = [MultiAgentDeliveryEnv() for i in range(runs)] for genome_id, genome in genomes: cppn = neat.nn.FeedForwardNetwork.create(genome, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() episode_reward = 0 genome.fitness = 0 sum_square_error = 0.0 for inputs, expected in zip(xor_inputs, xor_outputs): new_input = inputs + (1.0, ) net.reset() for i in range(network.activations): output = net.activate(new_input) sum_square_error += ((output[0] - expected[0])**2.0) / 4.0 fitness = episode_reward / runs if fitness > best_net[2]: best_net = (net, network, fitness) # Append episode reward to a list and log stats (every given number of episodes) genome.fitness += fitness for i in range(4): train(best_net[0], best_net[1], True)
def eval_genomes(genomes, config): # start torcs serever # start torcs client # wait until finished # fitness = results for genome_id, genome in genomes: genome.fitness = 0 # cppn = neat.nn.FeedForwardNetwork.create(genome, config) # net = create_phenotype_network(cppn, sub, "sigmoid") cppn = neat.nn.FeedForwardNetwork.create(genome, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() # net = neat.nn.FeedForwardNetwork.create(genome, config) # make a file from net in torcs folder # run torcs # read fitness predictions = [] for input, output_real in zip((inputs), (outputs)): output_pred = net.activate(input) # print(output_pred,output_real) predictions.append(output_pred) genome.fitness = 0 - sklearn.metrics.mean_squared_error( outputs, predictions)
def eval_fitness(self, genomes, config): r_start = randint(0, self.hs.hist_full_size - self.epoch_len) for idx, g in genomes: cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(self.subStrate, cppn, self.params) net = network.create_phenotype_network() g.fitness = self.evaluate(net, network, r_start)
def trial_run(self): r_start = 0 file = open("es_trade_god_cppn_3d.pkl", 'rb') [cppn] = pickle.load(file) network = ESNetwork(self.subStrate, cppn, self.params) net = network.create_phenotype_network_nd() fitness = self.evaluate(net, network, r_start) return fitness
def eval_fitness(genomes, config): for idx, g in genomes: cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(substrate, cppn, params) net = network.create_phenotype_network() fitnesses = [] for i in range(trials): x = game.start_game() possb = [ game.up_possible(x), game.down_possible(x), game.left_possible(x), game.right_possible(x) ] scr = 0 y = [0 for z in range(16)] y = game.matrix_to_vector(x) death = 1 death_flag = 0 net.reset() for j in range(max_steps): for k in range(network.activations): o = net.activate(format_input(x)) x = action(np.argmax(o), x) if game.matrix_to_vector(x) == y: if death_flag == 0: death = -3 death_flag = 1 else: death += 1 else: death = 1 death_flag = 0 y = game.matrix_to_vector(x) if death == 0: break scr = game.score(x) possb = [ game.up_possible(x), game.down_possible(x), game.left_possible(x), game.right_possible(x) ] if possb == [0, 0, 0, 0]: break fitnesses.append(scr) g.fitness = np.array(fitnesses).mean()
def eval_genome(genome, config): cppn = neat.nn.RecurrentNetwork.create(genome, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() episode_reward = 0 runs = 10 for i in range(runs): episode_reward += train(net, network, False) fitness = episode_reward / runs # Append episode reward to a list and log stats (every given number of episodes) return fitness
def poloTrader(self): self.refresh_balances() end_prices = {} active = self.get_one_bar_input_2d() self.load_net() network = ESNetwork(self.subStrate, self.cppn, self.params, self.hd) net = network.create_phenotype_network_nd('paper_net.png') net.reset() sell_syms = [] buy_syms = [] buy_signals = [] sell_signals = [] self.closeOrders() for n in range(1, self.hd): net.activate(active[self.hd - n]) out = net.activate(active[0]) for x in range(len(out)): sym = self.hs.coin_dict[x] end_prices[sym] = self.get_price(self.base_sym + "_" + sym) if (out[x] > .5): buy_signals.append(out[x]) buy_syms.append(sym) if (out[x] < -.5): sell_signals.append(out[x]) sell_syms.append(sym) #rng = iter(shuffle(rng)) sorted_buys = np.argsort(buy_signals)[::-1] sorted_sells = np.argsort(sell_signals) self.reset_tickers() for x in sorted_sells: sym = sell_syms[x] p = self.get_price(self.base_sym + "_" + sym) price = p - (p * .005) self.sell_coin(self.base_sym + "_" + sym, price) for x in sorted_buys: sym = buy_syms[x] self.target_percent = .1 + out[x] - .45 p = self.get_price(self.base_sym + "_" + sym) price = p * 1.005 self.buy_coin(self.base_sym + "_" + sym, price) if datetime.now() >= self.end_ts: return else: self.purge_polo_client() time.sleep(self.ticker_len) self.load_polo_client() self.refresh_data() self.make_shapes() #self.closeOrders() self.poloTrader()
def eval_fitness(genomes, config): for idx, g in genomes: cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() sum_square_error = 0.0 for inputs, expected in zip(xor_inputs, xor_outputs): new_input = inputs + (1.0, ) net.reset() for i in range(network.activations): output = net.activate(new_input) sum_square_error += ((output[0] - expected[0])**2.0) / 4.0 g.fitness = 1 - sum_square_error
def validate_fitness(self): config = self.config genomes = neat.Checkpointer.restore_checkpoint("./pkl_pops/pop-checkpoint-27").population self.epoch_len = 233 r_start = self.hs.hist_full_size - self.epoch_len-1 best_g_fit = 1.0 for idx in genomes: g = genomes[idx] cppn = neat.nn.FeedForwardNetwork.create(g, config) network = ESNetwork(self.subStrate, cppn, self.params, self.hd) net = network.create_phenotype_network_nd() g.fitness = self.evaluate(net, network, r_start, g) if(g.fitness > best_g_fit): best_g_fit = g.fitness with open('./champ_data/latest_greatest.pkl', 'wb') as output: pickle.dump(g, output) return
def poloTrader(self): end_prices = {} active = self.get_one_bar_input_2d() sub = Substrate(self.in_shapes, self.out_shapes) network = ESNetwork(sub, self.cppn, self.params) net = network.create_phenotype_network() net.reset() for n in range(network.activations): out = net.activate(active) #print(len(out)) rng = len(out) #rng = iter(shuffle(rng)) for x in np.random.permutation(rng): sym = self.coin_dict[x] #print(out[x]) try: if (out[x] < -.5): print("selling: ", sym) self.folio.sell_coin( sym, self.currentHists[sym]['close'][self.end_idx]) elif (out[x] > .5): print("buying: ", sym) self.folio.buy_coin( sym, self.currentHists[sym]['close'][self.end_idx]) except: print('error', sym) #skip the hold case because we just dont buy or sell hehe end_prices[sym] = self.hist_shaped[x][len(self.hist_shaped[x]) - 1][2] if datetime.now() >= self.end_ts: port_info = self.folio.get_total_btc_value(end_prices) print("total val: ", port_info[0], "btc balance: ", port_info[1]) return else: print(self.get_current_balance()) for t in range(3): time.sleep(self.ticker_len / 4) p_vals = self.get_current_balance() print("current value: ", p_vals[0], "current btc holdings: ", p_vals[1]) #print(self.folio.ledger) time.sleep(self.ticker_len / 4) self.pull_polo() self.poloTrader()
def trainMultiple(genomes, config, render, env): step = 0 current_state = env.reset() done = False nets = [] networks = [] rewards = np.zeros(len(genomes)) for genome_id, genome in genomes: cppn = neat.nn.FeedForwardNetwork.create(genome, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() nets.append(net) networks.append(network) pq = [] for i in range(len(nets)): heapq.heappush(pq, (0, i)) while not done and step < 1000: time, index = heapq.heappop(pq) network = networks[index] net = nets[index] numAction = [] for action in current_state: action = np.append(action, [1]) #bias action = convert(action) for k in range(network.activations): o = net.activate(action) numAction.append(o) action = np.argmax(numAction) new_state, reward, done, distance = env.stepM(action, index) if render: env.render(100) print(action) rewards[index] += reward heapq.heappush(pq, (time + distance, index)) current_state = new_state step += 1 if render: print(rewards) # Append episode reward to a list and log stats (every given number of episodes) return rewards
def compare_champs(self): r_start = 40 self.epoch_len = 40 print(self.end_idx) champ_fit = 0 for f in os.listdir("./champ_data/stonks"): if(f != "lastest_greatest.pkl"): champ_file = open("./champ_data/stonks/"+f,'rb') g = pickle.load(champ_file) champ_file.close() cppn = neat.nn.FeedForwardNetwork.create(g, self.config) network = ESNetwork(self.subStrate, cppn, self.params, self.hd) net = network.create_phenotype_network_nd() g.fitness = self.evaluate_champ(net, network, r_start, g) if (g.fitness > champ_fit): with open("./champ_data/stonks/latest_greatest.pkl", 'wb') as output: pickle.dump(g, output) print(champ_fit) return
def eval_genomes(genomes, config): best_net = (None, None, -9999) for genome_id, genome in genomes: cppn = neat.nn.RecurrentNetwork.create(genome, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network() episode_reward = 0 runs = 10 genome.fitness = 0 for i in range(runs): episode_reward += train(net, network, False) fitness = episode_reward / runs if fitness > best_net[2]: best_net = (net, network, fitness) # Append episode reward to a list and log stats (every given number of episodes) genome.fitness += fitness for i in range(4): train(best_net[0], best_net[1], True)
def eval_fitness(genomes, config): """ Fitness function. For each genome evaluate its fitness, in this case, as the mean squared error. """ for _, genome in genomes: cppn = neat.nn.FeedForwardNetwork.create(genome, config) network = ESNetwork(SUBSTRATE, cppn, DYNAMIC_PARAMS) net = network.create_phenotype_network() sum_square_error = 0.0 for xor_inputs, xor_expected in zip(XOR_INPUTS, XOR_OUTPUTS): new_xor_input = xor_inputs + (1.0, ) net.reset() for _ in range(network.activations): xor_output = net.activate(new_xor_input) sum_square_error += ((xor_output[0] - xor_expected[0])**2.0) / 4.0 genome.fitness = 1 - sum_square_error
def poloTrader(self): end_prices = {} active = self.get_one_bar_input_2d() sub = Substrate(self.in_shapes, self.out_shapes) network = ESNetwork(sub, self.cppn, self.params) net = network.create_phenotype_network() net.reset() for n in range(network.activations): out = net.activate(active) #print(len(out)) rng = len(out) #rng = iter(shuffle(rng)) for x in np.random.permutation(rng): sym = self.coin_dict[x] #print(out[x]) try: if (out[x] < -.5): print("selling: ", sym) self.sell_coin( sym, self.get_price(sym), ) elif (out[x] > .5): print("buying: ", sym) self.buy_coin(sym, self.get_price(sym)) except: print('error', sym) #skip the hold case because we just dont buy or sell hehe end_prices[sym] = self.get_price(sym) if datetime.now() >= self.end_ts: return else: time.sleep(self.ticker_len) self.reset_tickers self.pull_polo() self.poloTrader()
def compare_champs(self): self.epoch_len = self.hs.hist_full_size - (self.hd + 1) r_start = self.epoch_len champ_current = open("./champ_data/kraken/latest_greatest.pkl", 'rb') g = pickle.load(champ_current) champ_current.close() cppn = neat.nn.FeedForwardNetwork.create(g, self.config) network = ESNetwork(self.subStrate, cppn, self.params, self.hd) net = network.create_phenotype_network_nd() champ_fit = self.evaluate(net, network, r_start, g) for f in os.listdir("./champ_data/kraken"): if (f != "lastest_greatest.pkl"): champ_file = open("./champ_data/kraken/" + f, 'rb') g = pickle.load(champ_file) champ_file.close() cppn = neat.nn.FeedForwardNetwork.create(g, self.config) network = ESNetwork(self.subStrate, cppn, self.params, self.hd) net = network.create_phenotype_network_nd() g.fitness = self.evaluate_champ(net, network, r_start, g) if (g.fitness > champ_fit): with open("./champ_data/kraken/latest_greatest.pkl", 'wb') as output: pickle.dump(g, output) return
DYNAMIC_PARAMS = params(version) winner = pop.run(eval_fitness, gens) print(f"es_hyperneat_xor_{VERSION_TEXT} done") return winner, stats # If run as script. if __name__ == '__main__': WINNER = run(300, VERSION)[0] # Only relevant to look at the winner. print('\nBest genome:\n{!s}'.format(WINNER)) # Verify network output against training data. print('\nOutput:') CPPN = neat.nn.FeedForwardNetwork.create(WINNER, CONFIG) NETWORK = ESNetwork(SUBSTRATE, CPPN, DYNAMIC_PARAMS) # This will also draw winner_net. WINNER_NET = NETWORK.create_phenotype_network( filename= f'pureples/experiments/xor/es_hyperneat_xor_{VERSION_TEXT}_winner.png') for inputs, expected in zip(XOR_INPUTS, XOR_OUTPUTS): new_input = inputs + (1.0, ) WINNER_NET.reset() for i in range(NETWORK.activations): output = WINNER_NET.activate(new_input) print(" input {!r}, expected output {!r}, got {!r}".format( inputs, expected, output))
def make_nets(self, genome): cppn = neat.nn.FeedForwardNetwork.create(genome, self) esnet = ESNetwork(self.substrate, cppn, self.es_params) net = esnet.create_phenotype_network() return cppn, esnet, net
neat.reproduction.DefaultReproduction, neat.species.DefaultSpeciesSet, neat.stagnation.DefaultStagnation, 'config_cppn_mountain_car') def run(gens, env): winner, stats = run_es(gens, env, 200, config, params, sub, max_trials=0) print("es_hyperneat_mountain_car_small done") return winner, stats # If run as script. if __name__ == '__main__': # Setup logger and environment. logger = logging.getLogger() logger.setLevel(logging.INFO) env = gym.make("MountainCar-v0") # Run! winner = run(200, env)[0] # Save CPPN if wished reused and draw it + winner to file. cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network( filename="es_hyperneat_mountain_car_small_winner") draw_net(cppn, filename="es_hyperneat_mountain_car_small_cppn") with open('es_hyperneat_mountain_car_small_cppn.pkl', 'wb') as output: pickle.dump(cppn, output, pickle.HIGHEST_PROTOCOL)
pop.add_reporter(stats) pop.add_reporter(neat.reporting.StdOutReporter(True)) winner = pop.run(eval_fitness, gens) print("es_hyperneat_xor_medium done") return winner, stats # If run as script. if __name__ == '__main__': winner = run(300)[0] print('\nBest genome:\n{!s}'.format(winner)) # Verify network output against training data. print('\nOutput:') cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) winner_net = network.create_phenotype_network(filename='es_hyperneat_xor_medium_winner.png') # This will also draw winner_net. for inputs, expected in zip(xor_inputs, xor_outputs): new_input = inputs + (1.0,) winner_net.reset() for i in range(network.activations): output = winner_net.activate(new_input) print(" input {!r}, expected output {!r}, got {!r}".format(inputs, expected, output)) # Save CPPN if wished reused and draw it to file. draw_net(cppn, filename="es_hyperneat_xor_medium_cppn") with open('es_hyperneat_xor_medium_cppn.pkl', 'wb') as output: pickle.dump(cppn, output, pickle.HIGHEST_PROTOCOL)
neat.species.DefaultSpeciesSet, neat.stagnation.DefaultStagnation, 'config_cppn_pole_balancing') # Use the gym_runner to run this experiment using ES-HyperNEAT. def run(gens, env): winner, stats = run_es(gens, env, 500, config, params, sub) print("es_hyperneat_polebalancing_medium done") return winner, stats # If run as script. if __name__ == '__main__': # Setup logger and environment. logger = logging.getLogger() logger.setLevel(logging.INFO) env = gym.make("CartPole-v1") # Run! winner = run(100, env)[0] # Save CPPN if wished reused and draw it + winner to file. cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network( filename="es_hyperneat_pole_balancing_medium_winner") draw_net(cppn, filename="es_hyperneat_pole_balancing_medium_cppn") with open('es_hyperneat_pole_balancing_medium_cppn.pkl', 'wb') as output: pickle.dump(cppn, output)
def poloTrader(self): try: trade_df = pd.read_json("./live_hist/json_hist.json") except Exception as e: trade_df = pd.DataFrame() end_prices = {} active = self.get_one_bar_input_2d() self.load_net() sub = Substrate(self.in_shapes, self.out_shapes) net = ESNetwork(sub, self.cppn, self.params, self.hd) network = net.create_phenotype_network_nd('paper_net.png') sell_syms = [] buy_syms = [] buy_signals = [] sell_signals = [] for n in range(1, self.hd): network.activate(active[self.hd - n]) out = network.activate(active[0]) self.reset_tickers() for x in range(len(out)): sym = self.hs.coin_dict[x] end_prices[sym] = self.get_price(self.base_sym + "_" + sym) if (out[x] > .5): buy_signals.append(out[x]) buy_syms.append(sym) if (out[x] < -.5): sell_signals.append(out[x]) sell_syms.append(sym) #rng = iter(shuffle(rng)) sorted_buys = np.argsort(buy_signals)[::-1] sorted_sells = np.argsort(sell_signals) for x in sorted_sells: try: sym = sell_syms[x] p = end_prices[sym] print("selling: ", sym) self.folio.sell_coin(sym, p) except Exception as e: print("error placing order") for x in sorted_buys: try: sym = buy_syms[x] p = end_prices[sym] print("buying: ", sym) self.folio.buy_coin(sym, p) except Exception as e: print("error placing order") ''' self.trade_hist["date"] = datetime.now() self.trade_hist["portfoliovalue"] = self.folio.get_total_btc_value_no_sell(end_prices)[0] self.trade_hist["portfolio"] = self.folio.ledger self.trade_hist["percentchange"] = ((self.trade_hist["portfoliovalue"] - self.folio.start)/self.folio.start)*100 trade_df.append(self.trade_hist) trade_df.to_json("./live_hist/json_hist.json") if(self.trade_hist["portfoliovalue"] > self.folio.start *1.1): self.folio.start = self.folio.get_total_btc_value(end_prices)[0] ''' if datetime.now() >= self.end_ts: port_info = self.folio.get_total_btc_value(end_prices) print("total val: ", port_info[0], "btc balance: ", port_info[1]) return else: print(self.get_current_balance()) for t in range(2): p_vals = self.get_current_balance() print("current value: ", p_vals[0], "current holdings: ", p_vals[1]) time.sleep(self.ticker_len / 2) self.refresh_data() self.poloTrader()
winner, stats = run_es(gens, env, 200, CONFIG, params(version), SUBSTRATE, max_trials=0) print(f"es_hyperneat_mountain_car_{VERSION_TEXT} done") return winner, stats # If run as script. if __name__ == '__main__': # Setup logger and environment. LOGGER = logging.getLogger() LOGGER.setLevel(logging.INFO) ENVIRONMENT = gym.make("MountainCar-v0") # Run! Only relevant to look at the winner. WINNER = run(200, ENVIRONMENT, VERSION)[0] # Save CPPN if wished reused and draw it + winner to file. CPPN = neat.nn.FeedForwardNetwork.create(WINNER, CONFIG) NETWORK = ESNetwork(SUBSTRATE, CPPN, params) NET = NETWORK.create_phenotype_network( filename=f"es_hyperneat_mountain_car_{VERSION_TEXT}_winner") draw_net(CPPN, filename=f"es_hyperneat_mountain_car_{VERSION_TEXT}_cppn") with open(f'es_hyperneat_mountain_car_{VERSION_TEXT}_cppn.pkl', 'wb') as output: pickle.dump(CPPN, output, pickle.HIGHEST_PROTOCOL)
print(f"es_hyperneat_polebalancing_{VERSION_TEXT} done") return winner, stats # If run as script. if __name__ == '__main__': # Setup logger and environment. LOGGER = logging.getLogger() LOGGER.setLevel(logging.INFO) ENVIRONMENT = gym.make("CartPole-v1") # Run! Only relevant to look at the winner. WINNER = run(100, ENVIRONMENT, VERSION)[0] # Save CPPN if wished reused and draw it + winner to file. CPPN = neat.nn.FeedForwardNetwork.create(WINNER, CONFIG) NETWORK = ESNetwork(SUBSTRATE, CPPN, params(VERSION)) NET = NETWORK.create_phenotype_network( filename= f"pureples/experiments/pole_balancing/es_hyperneat_pole_balancing_{VERSION_TEXT}_winner" ) draw_net( CPPN, filename= f"pureples/experiments/pole_balancing/es_hyperneat_pole_balancing_{VERSION_TEXT}_cppn" ) with open( f'pureples/experiments/pole_balancing/es_hyperneat_pole_balancing_{VERSION_TEXT}_cppn.pkl', 'wb') as output: pickle.dump(CPPN, output, pickle.HIGHEST_PROTOCOL)
# Create population and train the network. Return winner of network running 100 episodes. stats_one = neat.statistics.StatisticsReporter() pop = ini_pop(None, stats_one, config) pop.run(eval_fitness, gens) stats_ten = neat.statistics.StatisticsReporter() pop = ini_pop((pop.population, pop.species, 0), stats_ten, config) trials = 10 winner_ten = pop.run(eval_fitness, gens) if max_trials is 0: return winner_ten, (stats_one, stats_ten) stats_hundred = neat.statistics.StatisticsReporter() pop = ini_pop((pop.population, pop.species, 0), stats_hundred, config) trials = max_trials winner_hundred = pop.run(eval_fitness, gens) return winner_hundred, (stats_one, stats_ten, stats_hundred) logger = logging.getLogger() logger.setLevel(logging.INFO) winner = run(100, 1000000, config, params, sub)[0] cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) net = network.create_phenotype_network(filename="es_hyperneat_2048_winner") draw_net(cppn, filename="es_hyperNEAT_2048_cppn") with open('es_hyperNEAT_2048_cppn.pkl', 'wb') as output: pickle.dump(cppn, output, pickle.HIGHEST_PROTOCOL)
pop.add_reporter(neat.reporting.StdOutReporter(True)) winner = pop.run(eval_fitness, gens) print("es_hyperneat_xor_large done") return winner, stats # If run as script. if __name__ == '__main__': winner = run(300)[0] print('\nBest genome:\n{!s}'.format(winner)) # Verify network output against training data. print('\nOutput:') cppn = neat.nn.FeedForwardNetwork.create(winner, config) network = ESNetwork(sub, cppn, params) # This will also draw winner_net. winner_net = network.create_phenotype_network( filename='es_hyperneat_xor_large_winner.png') for inputs, expected in zip(xor_inputs, xor_outputs): new_input = inputs + (1.0, ) winner_net.reset() for i in range(network.activations): output = winner_net.activate(new_input) print(" input {!r}, expected output {!r}, got {!r}".format( inputs, expected, output)) # Save CPPN if wished reused and draw it to file. draw_net(cppn, filename="es_hyperneat_xor_large_cppn") with open('es_hyperneat_xor_large_cppn.pkl', 'wb') as output: pickle.dump(cppn, output)