def random_pairs(): dir = "data/2n_rp-3_shannon-dd_neural_social_coll-edge/seed_001" evo_file = os.path.join(dir, "evo_2000.json") sim_file = os.path.join(dir, "simulation.json") output_file = os.path.join(dir, "perf_dist.json") evo = Evolution.load_from_file(evo_file, folder_path=dir) sim = Simulation.load_from_file(sim_file) sim.num_random_pairings = 0 # we build the pairs dynamically pop_size = len(evo.population) best_agent = evo.population[0] if os.path.exists(output_file): perfomances, distances = read_data_from_file(output_file) else: new_population_pairs = [] perfomances = [] distances = [] for j in range(1, pop_size): b = evo.population[j] pair = np.concatenate([best_agent, b]) new_population_pairs.append(pair) distances.append(euclidean_distance(best_agent, b)) for i in tqdm(range(pop_size - 1)): perf = sim.run_simulation(new_population_pairs, i) perfomances.append(perf) write_data_to_file(perfomances, distances, output_file) plt.scatter(distances, perfomances) plt.show()
def single_paired_agents(input_dir='data'): """ Test whether individually evolved agents can perform the task together and calculate their combined neural complexity. """ from dol.simulation import Simulation import json seed_dir = f'{input_dir}/2n_exc-0.1_zfill/seed_001' generation = 5000 population_idx = 0 rs = RandomState(1) sim_json_filepath = os.path.join(seed_dir, 'simulation.json') evo_json_filepath = os.path.join(seed_dir, 'evo_{}.json'.format(generation)) sim = Simulation.load_from_file( sim_json_filepath, switch_agents_motor_control=True, # forcing switch num_random_pairings=1 # forcing to play with one another ) evo = Evolution.load_from_file(evo_json_filepath, folder_path=None) original_populations = evo.population_unsorted best_two_agent_pop = np.array([ [ original_populations[0][x] for x in evo.population_sorted_indexes[population_idx][:2] ] ]) data_record_list = [] performance, sim_perfs, _ = sim.run_simulation( best_two_agent_pop, 0, 0, 0, None, data_record_list ) nc = get_sim_agent_complexity( sim_perfs, sim, data_record_list, agent_index=None, sim_idx=None, analyze_sensors=True, analyze_brain=True, analyze_motors=False, combined_complexity=False, only_part_n1n2=False, rs=rs ) print('performance', performance) print("Sim agents similarity: ", sim.agents_genotype_distance[0]) print('nc', nc)
def main_scatter_plot(input_dir='data'): """ From a given seed, look at the last generation, and compute the neural complexity for all agents. Plot correlation between fitness and complexity. """ seed_dir = f'{input_dir}/2n_exc-0.1_zfill/seed_001' generation = 5000 pop_index = 0 analyze_sensors = True analyze_brain = True analyze_motors = False combined_complexity = False only_part_n1n2 = True rs = RandomState(1) evo_file = sorted([f for f in os.listdir(seed_dir) if 'evo_' in f])[0] evo_json_filepath = os.path.join(seed_dir, evo_file) evo = Evolution.load_from_file(evo_json_filepath, folder_path=None) pop_size = len(evo.population[0]) print('pop_size', pop_size) perf_data = np.zeros(pop_size) nc_data = np.zeros(pop_size) for genotype_idx in tqdm(range(pop_size)): perf, sim_perfs, evo, sim, data_record_list, sim_idx = run_simulation_from_dir( seed_dir, generation, genotype_idx, population_idx=pop_index, quiet=True) agent_index = None # agent_index must be None (to get best agents of the two) sim_idx = None # sim_idx must be None (to get best sim among randomom pairs) nc_avg = get_sim_agent_complexity( sim_perfs, sim, data_record_list, agent_index, sim_idx, analyze_sensors, analyze_brain, analyze_motors, combined_complexity, only_part_n1n2, rs ) perf_data[genotype_idx] = perf nc_data[genotype_idx] = nc_avg fig = plt.figure(figsize=(10, 6)) ax = fig.add_subplot(1, 1, 1) ax.scatter(perf_data, nc_data) plt.xlabel('performance') plt.ylabel('nc') plt.show()
def same_pairs(): dir = "data/2n_shannon-dd_neural_social_coll-edge/seed_001" evo_file = os.path.join(dir, "evo_2000.json") sim_file = os.path.join(dir, "simulation.json") output_file = os.path.join(dir, "perf_dist.json") if os.path.exists(output_file): perfomances, distances = read_data_from_file(output_file) else: evo = Evolution.load_from_file(evo_file, folder_path=dir) sim = Simulation.load_from_file(sim_file) assert sim.num_random_pairings == 0 pop_size = len(evo.population) perfomances = [] distances = [] for i in tqdm(range(pop_size)): perf = sim.run_simulation(evo.population, i) a, b = np.array_split(evo.population[i], 2) perfomances.append(perf) distances.append(euclidean_distance(a, b)) write_data_to_file(perfomances, distances, output_file) plt.scatter(distances, perfomances) plt.show()
def test_continuation(): eval_func = lambda pop, rand_seed: RandomState(rand_seed).random(len(pop)) print('Loading evolution from json file') folder_path = './tmp_cont1' utils.make_dir_if_not_exists(folder_path) evo1 = Evolution( random_seed=123, population_size=1000, genotype_size=2, evaluation_function=eval_func, fitness_normalization_mode='RANK', selection_mode='RWS', reproduction_mode= 'GENETIC_ALGORITHM', #'HILL_CLIMBING', 'GENETIC_ALGORITHM' mutation_variance=0.1, elitist_fraction=0.1, mating_fraction=0.9, crossover_probability=0.5, crossover_mode='1-POINT', max_generation=100, folder_path=folder_path, termination_function=None, checkpoint_interval=50) evo1.run() print() new_folder_path = './tmp_cont2' utils.make_dir_if_not_exists(new_folder_path) evo2 = Evolution.load_from_file(os.path.join(folder_path, 'evo_00050.json'), evaluation_function=eval_func, folder_path=new_folder_path, max_generation=110) evo2.run()
args = parser.parse_args() dir = args.dir evo_files = sorted([f for f in os.listdir(dir) if f.startswith('evo_')]) assert len(evo_files) > 0, "Can't find evo files in dir {}".format(dir) last_generation = evo_files[-1].split('_')[1].split('.')[0] file_num_zfill = len(last_generation) sim_json_filepath = os.path.join(dir, 'simulation.json') evo_json_filepath = os.path.join(dir, 'evo_{}.json'.format(last_generation)) assert args.max_gen > int(last_generation), \ "max_gen is <= of the last available generation ({})".format(last_generation) sim = Simulation.load_from_file(sim_json_filepath) if args.cores > 0: sim.cores = args.cores evo = Evolution.load_from_file(evo_json_filepath, evaluation_function=sim.evaluate, max_generation=args.max_gen) t = TicToc() t.tic() evo.run() print('Ellapsed time: {}'.format(t.tocvalue()))
def run_simulation_from_dir(dir, generation=None, genotype_idx=0, population_idx=0, random_target_seed=None, random_pairing_seed=None, isolation_idx=None, write_data=False, **kwargs): """ Utitity function to get data from a simulation """ evo_files = sorted([f for f in os.listdir(dir) if f.startswith('evo_')]) assert len(evo_files) > 0, "Can't find evo files in dir {}".format(dir) file_num_zfill = len(evo_files[0].split('_')[1].split('.')[0]) if generation is None: evo_json_filepath = os.path.join(dir, evo_files[-1]) generation = int(evo_files[-1].split('_')[1].split('.')[0]) else: generation_str = str(generation).zfill(file_num_zfill) evo_json_filepath = os.path.join(dir, 'evo_{}.json'.format(generation_str)) sim_json_filepath = os.path.join(dir, 'simulation.json') sim = Simulation.load_from_file(sim_json_filepath) evo = Evolution.load_from_file(evo_json_filepath, folder_path=dir) data_record_list = [] random_seed = evo.pop_eval_random_seed expect_same_results = isolation_idx is None # overwriting simulaiton if random_target_seed is not None: print("Using random target") # standard target was initialized in sim.__post_init__ # so this is going to overwrite it sim.init_target(RandomState(random_target_seed)) expect_same_results = False if random_pairing_seed is not None: print("Setting random pairing with seed ", random_pairing_seed) random_seed = random_pairing_seed expect_same_results = False original_populations = evo.population_unsorted # get the indexes of the populations as they were before being sorted by performance # we only need to do this for the first population (index 0) original_genotype_idx = evo.population_sorted_indexes[population_idx][genotype_idx] performance, sim_perfs, _ = sim.run_simulation( original_populations, original_genotype_idx, random_seed, population_idx, isolation_idx, data_record_list ) performance = sim.normalize_performance(performance) verbose = not kwargs.get('quiet', False) if verbose: if genotype_idx == 0: perf_orig = evo.best_performances[generation][population_idx] perf_orig = sim.normalize_performance(perf_orig) print("Performace original: {}".format(perf_orig)) print("Performace recomputed: {}".format(performance)) if expect_same_results: diff_perfomance = abs(perf_orig - performance) if diff_perfomance > 1e-5: print(f'Warning: diff_perfomance: {diff_perfomance}') # assert diff_perfomance < 1e-5, f'diff_perfomance: {diff_perfomance}' # if performance == perf_orig: # print("Exact!!") if write_data: for s, data_record in enumerate(data_record_list, 1): if len(data_record_list) > 1: outdir = os.path.join(dir, 'data', 'sim_{}'.format(s)) else: outdir = os.path.join(dir, 'data') utils.make_dir_if_not_exists_or_replace(outdir) for k, v in data_record.items(): if type(v) is dict: # summary outfile = os.path.join(outdir, '{}.json'.format(k)) utils.save_json_numpy_data(v, outfile) else: outfile = os.path.join(outdir, '{}.json'.format(k)) utils.save_json_numpy_data(v, outfile) if kwargs.get('select_sim', None) is None: # select best one sim_idx = np.argmax(sim_perfs) # if sim.num_random_pairings != None and sim.num_random_pairings > 0: if verbose: print("Best sim (random pairings)", sim_idx+1) else: sim_idx = kwargs['select_sim'] - 1 # zero based if verbose: print("Selecting simulation", sim_idx+1) if verbose: sim_perf = sim.normalize_performance(sim_perfs[sim_idx]) print("Performance recomputed (sim): ", sim_idx+1, sim_perf) if sim.num_agents == 2: print("Sim agents genotype distance: ", sim.agents_genotype_distance[sim_idx]) # print agents signatures agents_sign = [get_numpy_signature(gt) for gt in data_record_list[sim_idx]['genotypes']] print('Agent(s) signature(s):', agents_sign) if kwargs.get('compute_complexity', False): from dol.analyze_complexity import get_sim_agent_complexity for a in range(sim.num_agents): nc = get_sim_agent_complexity( sim_perfs, sim, data_record_list, agent_index=a, sim_idx=sim_idx, analyze_sensors=True, analyze_brain=True, analyze_motors=False, combined_complexity=False, only_part_n1n2=True, rs=RandomState(1) ) print('TSE', a+1, nc) return performance, sim_perfs, evo, sim, data_record_list, sim_idx
def test_split_genotypes(): dir = "data/2n_shannon-dd_neural_social_coll-edge/seed_001" evo_file = os.path.join(dir, "evo_2000.json") evo = Evolution.load_from_file(evo_file, folder_path=dir) get_similarity_matrix(evo.population) get_similarity_split(evo.population)
def run_simulation_from_dir(dir, generation=None, genotype_idx=0, **kwargs): ''' utitity function to get data from a simulation ''' random_pos_angle = kwargs.get('random_pos_angle', None) entropy_type = kwargs.get('entropy_type', None) entropy_target_value = kwargs.get('entropy_target_value', None) concatenate = kwargs.get('concatenate', None) collision_type = kwargs.get('collision_type', None) ghost_index = kwargs.get('ghost_index', None) initial_distance = kwargs.get('initial_distance', None) isolation = kwargs.get('isolation', None) write_data = kwargs.get('write_data', None) func_arguments = locals() from pyevolver.evolution import Evolution evo_files = [f for f in os.listdir(dir) if f.startswith('evo_')] assert len(evo_files) > 0, "Can't find evo files in dir {}".format(dir) file_num_zfill = len(evo_files[0].split('_')[1].split('.')[0]) if generation is None: # assumes last generation evo_files = sorted([f for f in os.listdir(dir) if f.startswith('evo')]) evo_json_filepath = os.path.join(dir, evo_files[-1]) else: generation = str(generation).zfill(file_num_zfill) evo_json_filepath = os.path.join(dir, 'evo_{}.json'.format(generation)) sim_json_filepath = os.path.join(dir, 'simulation.json') sim = Simulation.load_from_file(sim_json_filepath) evo = Evolution.load_from_file(evo_json_filepath, folder_path=dir) if initial_distance is not None: print("Forcing initial distance to: {}".format(initial_distance)) sim.agents_pair_initial_distance = initial_distance sim.set_initial_positions_angles() if random_pos_angle: print("Randomizing positions and angles") random_state = RandomState() sim.set_initial_positions_angles(random_state) if entropy_type is not None: sim.entropy_type = entropy_type print("Forcing entropy type: {}".format(sim.entropy_type)) if entropy_target_value is not None: sim.entropy_target_value = entropy_target_value print("Forcing entropy target value: {}".format( sim.entropy_target_value)) if concatenate is not None: sim.concatenate = concatenate == 'on' print("Forcing concatenation: {}".format(sim.concatenate)) if collision_type is not None: sim.collision_type = collision_type sim.init_agents_pair() print("Forcing collision_type: {}".format(sim.collision_type)) if isolation is not None: sim.isolation = isolation print("Forcing isolation to: {}".format(isolation)) data_record_list = [] genotype_idx_unsorted = evo.population_sorted_indexes[genotype_idx] random_seed = evo.pop_eval_random_seeds[genotype_idx_unsorted] if ghost_index is not None: assert ghost_index in [0, 1], 'ghost_index must be 0 or 1' # get original results without ghost condition and no random func_arguments['ghost_index'] = None func_arguments['random_pos_angle'] = False func_arguments['initial_distance'] = None func_arguments['write_data'] = None _, _, original_data_record_list = run_simulation_from_dir( **func_arguments) perf = sim.run_simulation( evo.population_unsorted, genotype_idx_unsorted, random_seed, data_record_list, ghost_index=ghost_index, original_data_record_list=original_data_record_list) print( "Overall Performance recomputed (non-ghost agent only): {}".format( perf)) else: perf = sim.run_simulation(evo.population_unsorted, genotype_idx_unsorted, random_seed, data_record_list) if genotype_idx == 0: original_perfomance = evo.best_performances[-1] print("Original Performance: {}".format(original_perfomance)) print("Overall Performance recomputed: {}".format(perf)) if write_data: for s, data_record in enumerate(data_record_list, 1): if len(data_record_list) > 1: outdir = os.path.join(dir, 'data', 'sim_{}'.format(s)) else: outdir = os.path.join(dir, 'data') utils.make_dir_if_not_exists(outdir) for t in range(sim.num_trials): for k, v in data_record.items(): if v is dict: # summary if t == 0: # only once outfile = os.path.join(outdir, '{}.json'.format(k)) utils.save_json_numpy_data(v, outfile) elif len(v) != sim.num_trials: # genotype/phenotype outfile = os.path.join(outdir, '{}.json'.format(k)) utils.save_json_numpy_data(v, outfile) elif len(v[0]) == 2: # data for each agent for a in range(2): outfile = os.path.join( outdir, '{}_{}_{}.json'.format(k, t + 1, a + 1)) utils.save_json_numpy_data(v[t][a], outfile) else: # single data for both agent (e.g., distance) outfile = os.path.join(outdir, '{}_{}.json'.format(k, t + 1)) utils.save_json_numpy_data(v[t], outfile) return evo, sim, data_record_list