def run_random_agents(): genotype_structure=gen_structure.DEFAULT_GEN_STRUCTURE(2) gen_size = gen_structure.get_genotype_size(genotype_structure) random_genotype = Evolution.get_random_genotype(RandomState(None), gen_size*2) # pairs of agents in a single genotype sim = Simulation( genotype_structure=genotype_structure, agent_body_radius=4, agents_pair_initial_distance=20, agent_sensors_divergence_angle=np.radians(45), # angle between sensors and axes of symmetry brain_step_size=0.1, trial_duration=200, # the brain would iterate trial_duration/brain_step_size number of time num_cores=1 ) trial_index = 0 data_record_list = [] random_seed = utils.random_int() perf = sim.run_simulation([random_genotype],0, random_seed, data_record_list=data_record_list) print("random perf: {}".format(perf)) data_record = data_record_list[0] vis = Visualization(sim) vis.start_simulation_from_data(trial_index, data_record)
def get_spinning_agents_data(): genotype_structure = gen_structure.DEFAULT_GEN_STRUCTURE(2) sim = Simulation( entropy_type='shannon', genotype_structure=genotype_structure, trial_duration= 200, # the brain would iterate trial_duration/brain_step_size number of time ) # set network manually for a in range(2): agent_net = sim.agents_pair_net[a] # set agent network manually agent_net.sensor_gains = np.zeros((2)) agent_net.sensor_biases = np.zeros((2)) agent_net.sensor_weights = np.zeros((2, 2)) agent_net.motor_gains = np.ones((3)) agent_net.motor_biases = np.zeros((3)) agent_net.motor_weights = \ np.full((3,2),-np.inf) if a==0 \ else np.array([ [0.4, 0.4], [-np.inf, -np.inf], # set emitter weights to zero so that output is zero [1., 1.] ]) agent_net.brain.taus = np.ones((2)) agent_net.brain.gains = np.ones((2)) agent_net.brain.biases = np.ones((2)) agent_net.brain.weights = np.ones((2, 2)) data_record_list = [] random_seed = utils.random_int() perf = sim.run_simulation(rnd_seed=random_seed, data_record_list=data_record_list) print("random perf: {}".format(perf)) # from dyadic_interaction.visual import Visualization # vis = Visualization(sim) # vis.start_simulation_from_data(trial_index=0, data_record=data_record) data_record = data_record_list[0] from dyadic_interaction import plot_results plot_results.plot_behavior(data_record) plot_results.plot_neural_activity_scatter(data_record) plot_results.plot_inputs(data_record) plot_results.plot_wheels(data_record) plot_results.plot_emitters(data_record) return data_record
def test_plot(entropy_type): from dyadic_interaction import plot_results sim = Simulation(entropy_type=entropy_type, genotype_structure=GEORGINA_GEN_STRUCTURE, num_cores=1) data_record_list = [] perf = sim.run_simulation(agent_pair_genome, data_record_list=data_record_list) print('Performance: {}'.format(perf)) data_record = data_record_list[0] plot_results.plot_behavior(data_record)
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 __init__(self, simulation=None, video_path=None): self.simulation = simulation or Simulation() self.agents_pair_body = self.simulation.agents_pair_body self.agents_pair_net = self.simulation.agents_pair_net # self.agent_body_radius = simulation.agent_body_radius # self.agent_sensors_divergence_angle = simulation.agent_sensors_divergence_angle # self.agent_position = None # self.agent_angle = None # self.emitter_position = None # self.agent = AgentBody( # agent_body_radius=self.agent_body_radius, # agent_sensors_divergence_angle=self.agent_sensors_divergence_angle # ) self.video_path = video_path self.video_mode = self.video_path is not None pygame.init() if self.video_mode: self.video_tmp_dir = tempfile.mkdtemp(dir=os.path.dirname(self.video_path)) self.main_surface = pygame.Surface((MAX_CANVAS_SIZE, MAX_CANVAS_SIZE)) else: self.main_surface = pygame.display.set_mode((MAX_CANVAS_SIZE, MAX_CANVAS_SIZE))
def test_visual(entropy_type): from dyadic_interaction.visual import Visualization sim = Simulation(entropy_type=entropy_type, genotype_structure=GEORGINA_GEN_STRUCTURE, num_cores=1) data_record_list = [] perf = sim.run_simulation(agent_pair_genome, data_record_list=data_record_list) print('Performance: {}'.format(perf)) data_record = data_record_list[0] vis = Visualization(sim) trial_index = 1 vis.start_simulation_from_data(trial_index, data_record)
def test_data(entropy_type): sim = Simulation(entropy_type=entropy_type, entropy_target_value='neural', concatenate=True, genotype_structure=GEORGINA_GEN_STRUCTURE, num_cores=1) utils.make_dir_if_not_exists('data/master/') data_record_list = [] perf = sim.run_simulation([agent_pair_genome], 0, data_record_list=data_record_list) print('Performance: {}'.format(perf)) data_record = data_record_list[0] for t in range(sim.num_trials): # t = 0 for k, v in data_record.items(): for a in range(2): utils.save_json_numpy_data( v[t][a], 'data/master/{}_{}_{}.json'.format(k, t + 1, a + 1))
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 compute_std_from_random_runs(num_cores, num_good_runs, entropy_target_value): from dyadic_interaction.simulation import Simulation assert entropy_target_value in ['neural', 'distance', 'angle'] genotype_structure = gen_structure.DEFAULT_GEN_STRUCTURE(num_neurons) gen_size = gen_structure.get_genotype_size(genotype_structure) num_data_points_per_agent_pair = sim_duration * num_trials num_data_points = num_data_points_per_agent_pair * num_good_runs # 8 million! if entropy_target_value == 'distance': num_all_runs = num_good_runs * MULTIPLY_FACTOR else: num_all_runs = num_good_runs all_distances = np.zeros(num_data_points) rs = RandomState(seed) sim_array = [ Simulation( entropy_type='shannon-dd', genotype_structure=genotype_structure, ) for _ in range(num_cores) ] random_genotypes = [ Evolution.get_random_genotype(rs, gen_size * 2) for _ in range(num_all_runs) ] def run_one_core(r): data_record_list = [] sim_array[r % num_cores].run_simulation( random_genotypes, r, data_record_list=data_record_list) data_record = data_record_list[0] if entropy_target_value == 'neural': concat_outputs = np.concatenate([ data_record['brain_output'][t][a] for t in range(4) for a in range(2) ]) concat_outputs = np.concatenate( [concat_outputs[:, c] for c in range(num_neurons)]) return concat_outputs elif entropy_target_value == 'distance': concat_distances = np.concatenate(data_record['distance']) if any(concat_distances > MAX_DISTANCE): return None return concat_distances else: assert entropy_target_value == 'angle' concat_angles = np.concatenate([ data_record['angle'][t][a] for t in range(4) for a in range(2) ]) return concat_angles run_distances = Parallel( n_jobs=num_cores)( # prefer="threads" does not work delayed(run_one_core)(r) for r in tqdm(range(num_all_runs))) good_run_distances = [run for run in run_distances if run is not None] print("Number of good runs: {}".format(len(good_run_distances))) assert len(good_run_distances) >= num_good_runs all_distances = np.concatenate(good_run_distances[:num_good_runs] ) # take only the first 1000 good runs # json.dump( # all_distances, # open('data/tmp_distances.json', 'w'), # indent=3, # cls=NumpyListJsonEncoder # ) std = all_distances.std() print(std)
else: # use the specified dir if it doesn't exist outdir = args.dir utils.make_dir_if_not_exists(outdir) else: outdir = None sim = Simulation( num_random_pairings=args.num_random_pairings, entropy_type=args.entropy_type, entropy_target_value=args.entropy_target_value, concatenate=args.concatenate == 'on', isolation=args.isolation == 'on', collision_type=args.collision_type, genotype_structure=genotype_structure, agent_body_radius=4, agents_pair_initial_distance=20, agent_sensors_divergence_angle=np.radians( 45), # angle between sensors and axes of symmetry brain_step_size=0.1, trial_duration=args. trial_duration, # the brain would iterate trial_duration/brain_step_size number of time num_cores=args.cores) if args.dir is not None: sim_config_json = os.path.join(outdir, 'simulation.json') sim.save_to_file(sim_config_json) if args.num_random_pairings == 0: genotype_size *= 2 # two agents per genotype
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