async def run(): """ The main coroutine, which is started below. """ n_cores = 1 experiment_conf = ExperimentConfig() settings = parser.parse_args() queue = SimulatorQueue(n_cores, settings) await queue.start() population = Population(experiment_conf.population_conf) await population.init_pop(queue) # population.simulator_connection.disconnect() # await simulator_supervisor.relaunch() gen_num = 0 while gen_num < experiment_conf.num_generations: population = await population.next_gen(gen_num + 1, queue) # simulator_connection.disconnect() # simulator_supervisor.relaunch() # population.simulator_connection = await World.create(settings) gen_num += 1
def main(): import traceback def handler(_loop, context): try: exc = context['exception'] except KeyError: print(context['message']) return if isinstance(exc, ConnectionResetError): print("Got disconnect / connection reset - shutting down.") sys.exit(0) if isinstance(exc, OSError) and exc.errno == 9: print(exc) traceback.print_exc() return # traceback.print_exc() raise exc try: arguments = parser.parse_args() loop = asyncio.get_event_loop() loop.set_exception_handler(handler) run(loop, arguments) except KeyboardInterrupt: print("Got CtrlC, shutting down.")
async def run(): """ The main coroutine, which is started below. """ # Parse command line / file input arguments settings = parser.parse_args() # Load a robot from yaml robot = revolve_bot.RevolveBot() if settings.robot_yaml is None: robot.load_file("experiments/bo_learner/yaml/spider.yaml") else: robot.load_file(settings.robot_yaml) robot.update_substrate() # Connect to the simulator and pause world = await World.create(settings) await world.pause(True) await world.delete_model(robot.id) await asyncio.sleep(2.5) # Insert the robot in the simulator robot_manager = await world.insert_robot(robot, Vector3(0, 0, 0.025)) # Resume simulation await world.pause(False) # Start a run loop to do some stuff while True: await asyncio.sleep(5.0)
async def run(): """ The main coroutine, which is started below. """ # Parse command line / file input arguments settings = parser.parse_args() # Load a robot from yaml robot = revolve_bot.RevolveBot() robot.load_file("experiments/examples/yaml/spider.yaml") # Connect to the simulator and pause world = await World.create(settings) await world.pause(True) # Insert the robot in the simulator robot_manager = await world.insert_robot(robot, Vector3(0, 0, 0.05)) # Resume simulation await world.pause(False) # Start a run loop to do some stuff while True: # Print robot fitness every second print("Robot fitness is {fitness}".format( fitness=robot_manager.fitness())) await asyncio.sleep(1.0)
async def run(): logger.info('Hello World!') settings = parser.parse_args() # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo' ) await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) connection = await World.create() if connection: logger.info("Connected to the simulator world.") await connection.pause(True) while True: await asyncio.sleep(10.0)
async def run(): """ The main coroutine, which is started below. """ # Parse command line / file input arguments settings = parser.parse_args() # Load a robot from yaml robot = revolve_bot.RevolveBot() robot.load_file("experiments/examples/yaml/spider.yaml") robot.update_substrate() # Connect to the simulator and pause world = await World.create(settings) await world.pause(True) await (await world.delete_model(robot.id)) await asyncio.sleep(2.5) # Insert the robot in the simulator insert_future = await world.insert_robot(robot, Vector3(0, 0, 0.25)) robot_manager = await insert_future # Resume simulation await world.pause(False) # Start a run loop to do some stuff while True: # Print robot fitness every second print("Robot fitness is {fitness}".format( fitness=robot_manager.fitness())) await asyncio.sleep(1.0)
async def run(): """ The main coroutine, which is started below """ log = logger.create_logger('experiment', handlers=[ logging.StreamHandler(sys.stdout), ]) # Set debug level to DEBUG log.setLevel(logging.DEBUG) # Parse command line / file input arguments settings = parser.parse_args() # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo') await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) # Connect to the simulator and pause connection = await World.create(settings, world_address=('127.0.0.1', settings.port_start)) await asyncio.sleep(1) # initialization finished # load robot file robot = RevolveBot(_id=settings.test_robot) robot.load_file("/Users/nihed/Desktop/nihedssnakes/nihedssnake6.yaml", conf_type='yaml') robot.save_file( f'{"/Users/nihed/Desktop/nihedssnakes/nihedssnake6.yaml"}.sdf', conf_type='sdf') # insert robot into the simulator robot_manager = await connection.insert_robot(robot, Vector3(0, 0, 0.25), life_timeout=None) await asyncio.sleep(1.0) # Start the main life loop while True: # Print robot fitness every second status = 'dead' if robot_manager.dead else 'alive' print( f"Robot fitness ({status}) is \n" f" OLD: {fitness.online_old_revolve(robot_manager)}\n" f" DISPLAC: {fitness.displacement(robot_manager, robot)}\n" f" DIS_VEL: {fitness.displacement_velocity(robot_manager, robot)}") await asyncio.sleep(1.0)
async def test_collision_robot(robot_file_path: str): log = logger.create_logger('experiment', handlers=[ logging.StreamHandler(sys.stdout), ]) # Set debug level to DEBUG log.setLevel(logging.DEBUG) # Parse command line / file input arguments settings = parser.parse_args() assert (settings.test_robot_collision is not None) robot = RevolveBot(_id=settings.test_robot_collision) robot.load_file(robot_file_path, conf_type='yaml') robot.save_file(f'{robot_file_path}.sdf', conf_type='sdf') def simulator_died_callback(_process, _ret_code): pass # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = CollisionSimSupervisor( world_file=os.path.join('tools', 'analyzer', 'analyzer-world.world'), simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo', process_terminated_callback=simulator_died_callback, ) await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) log.debug("simulator ready") # Connect to the simulator and pause analyzer = await BodyAnalyzer.create('127.0.0.1', settings.port_start) log.debug("connection ready") await asyncio.sleep(1) log.info("Sending robot to the analyzer simulator") start = time.time() result = await analyzer.analyze_robot(robot) end = time.time() log.debug(f'Analyzer finished in {end-start}') log.debug('result:') log.debug(result) await analyzer.disconnect() log.debug("disconnected") if settings.simulator_cmd != 'debug': await simulator_supervisor.stop() log.debug("simulator killed")
async def run(): settings = parser.parse_args() yaml_file = 'experiments/'+ settings.experiment_name sla+'/data_fullevolution/phenotypes/'+'phenotype_'+settings.test_robot+'.yaml' r = RevolveBot(_id=settings.test_robot) r.load_file(yaml_file, conf_type='yaml') #r.save_file('experiments/'+ settings +'/data_fullevolution/phenotype_35.sdf.xml', conf_type='sdf') #r.render_body('experiments/'+ settings +'/data_fullevolution/phenotypes/phenotype_35.body.png') connection = await World.create(settings, world_address=("127.0.0.1", settings.port_start)) await connection.insert_robot(r)
async def run(): print('Hello World from `{}`'.format(rvpath)) settings = parser.parse_args() world = await World.create() if world: print("Connected to the simulator world.") await world.pause(True) while True: await asyncio.sleep(10.0)
async def run(): """ The main coroutine, which is started below. """ robot_file_path = "experiments/examples/yaml/spider.yaml" # Parse command line / file input arguments settings = parser.parse_args() # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo') await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) # Load a robot from yaml robot = revolve_bot.RevolveBot() robot.load_file(robot_file_path) robot.update_substrate() # robot._brain = BrainRLPowerSplines() # Connect to the simulator and pause connection = await World.create(settings, world_address=('127.0.0.1', settings.port_start)) await asyncio.sleep(1) # Starts the simulation await connection.pause(False) # Insert the robot in the simulator robot_manager = await connection.insert_robot( robot, Vector3(0, 0, settings.z_start)) # Start a run loop to do some stuff while True: # Print robot fitness every second status = 'dead' if robot_manager.dead else 'alive' print( f"Robot fitness ({status}) is \n" f" OLD: {fitness.online_old_revolve(robot_manager)}\n" f" DISPLAC: {fitness.displacement(robot_manager, robot)}\n" f" DIS_VEL: {fitness.displacement_velocity(robot_manager, robot)}") await asyncio.sleep(1.0)
async def run(): # Start Simulator settings = parser.parse_args() if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo') await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) world = await World.create() if world: print("Connected to the simulator world.") sdf_model = """ <sdf version ='1.5'> <model name ='sphere'> <pose>1 0 0 0 0 0</pose> <link name ='link'> <pose>0 0 .5 0 0 0</pose> <collision name ='collision'> <geometry> <sphere> <radius>0.5</radius> </sphere> </geometry> </collision> <visual name ='visual'> <geometry> <sphere> <radius>0.5</radius> </sphere> </geometry> </visual> </link> </model> </sdf>""" await world.insert_model(sdf_model) await world.pause(True) while True: await asyncio.sleep(10.0)
async def run(): # Parse command line / file input arguments settings = parser.parse_args() # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo') await simulator_supervisor.launch_simulator(port=settings.port_start) # let there be some time to sync all initial output of the simulator await asyncio.sleep(5) # Connect to the simulator and pause connection = await World.create(settings, world_address=('127.0.0.1', settings.port_start)) await asyncio.sleep(1) await connection.disconnect() print("SIMULATOR STARTED")
async def run(): """ The main coroutine, which is started below. """ # Parse command line / file input arguments genotype_conf = PlasticodingConfig(max_structural_modules=100, ) mutation_conf = MutationConfig( mutation_prob=0.8, genotype_conf=genotype_conf, ) crossover_conf = CrossoverConfig(crossover_prob=0.8, ) settings = parser.parse_args() experiment_management = ExperimentManagement(settings) population_conf = PopulationConfig( population_size=100, genotype_constructor=random_initialization, genotype_conf=genotype_conf, fitness_function=fitness.displacement_velocity_hill, mutation_operator=standard_mutation, mutation_conf=mutation_conf, crossover_operator=standard_crossover, crossover_conf=crossover_conf, selection=lambda individuals: tournament_selection(individuals, 2), parent_selection=lambda individuals: multiple_selection( individuals, 2, tournament_selection), population_management=steady_state_population_management, population_management_selector=tournament_selection, evaluation_time=settings.evaluation_time, offspring_size=50, experiment_name=settings.experiment_name, experiment_management=experiment_management, ) settings = parser.parse_args() simulator_queue = SimulatorQueue(settings.n_cores, settings, settings.port_start) await simulator_queue.start() population = Population(population_conf, simulator_queue, 0) # choose a snapshot here. and the maximum best individuals you wish to watch generation = 100 max_best = 10 await population.load_snapshot(generation) fitnesses = [] for ind in population.individuals: fitnesses.append(ind.fitness) fitnesses = np.array(fitnesses) ini = len(population.individuals) - max_best fin = len(population.individuals) population.individuals = np.array(population.individuals) population.individuals = population.individuals[np.argsort(fitnesses) [ini:fin]] await population.evaluate(population.individuals, generation)
""" :param data: :return: """ if 'ODE Message 3' in data: self.ode_errors += 1 elif data.strip(): sys.stderr.write(data) if self.ode_errors >= 100: self.ode_errors = 0 sys.stderr.write('ODE Message 3 (100)\n') if __name__ == "__main__": settings = parser.parse_args() manager_settings = sys.argv[1:] supervisor = OnlineEvolutionSupervisor( manager_cmd=settings.manager, manager_args=manager_settings, world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join(rvpath, 'build', 'lib'), models_dir_path=os.path.join(rvpath, 'models')) if settings.manager is None: ret = supervisor.launch_simulator() else: ret = supervisor.launch() sys.exit(ret)
""" :param data: :return: """ if 'ODE Message 3' in data: self.ode_errors += 1 elif data.strip(): sys.stderr.write(data) if self.ode_errors >= 100: self.ode_errors = 0 sys.stderr.write('ODE Message 3 (100)\n') if __name__ == "__main__": settings = parser.parse_args() manager_settings = sys.argv[1:] supervisor = OnlineEvolutionSupervisor( manager_cmd=settings.manager, manager_args=manager_settings, world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join(rvpath, 'build', 'lib'), models_dir_path=os.path.join(rvpath, 'models') ) if settings.manager is None: ret = supervisor.launch_simulator() else: ret = supervisor.launch()
async def run(): """ The main coroutine, which is started below. """ # experiment params # num_generations = 200 population_size = 100 offspring_size = 100 front = 'slaves' # environment world and z-start environments = {'plane': 0.03, 'tilted5': 0.1 } genotype_conf = PlasticodingConfig( max_structural_modules=15, plastic=True, ) mutation_conf = MutationConfig( mutation_prob=0.8, genotype_conf=genotype_conf, ) crossover_conf = CrossoverConfig( crossover_prob=0.8, ) # experiment params # # Parse command line / file input arguments settings = parser.parse_args() experiment_management = ExperimentManagement(settings, environments) do_recovery = settings.recovery_enabled and not experiment_management.experiment_is_new() logger.info('Activated run '+settings.run+' of experiment '+settings.experiment_name) if do_recovery: gen_num, has_offspring, next_robot_id = experiment_management.read_recovery_state(population_size, offspring_size) if gen_num == num_generations-1: logger.info('Experiment is already complete.') return else: gen_num = 0 next_robot_id = 1 def fitness_function_plane(robot_manager, robot): return fitness.displacement_velocity_hill(robot_manager, robot, False) fitness_function = {'plane': fitness_function_plane, 'tilted5': fitness_function_plane} population_conf = PopulationConfig( population_size=population_size, genotype_constructor=random_initialization, genotype_conf=genotype_conf, fitness_function=fitness_function, mutation_operator=standard_mutation, mutation_conf=mutation_conf, crossover_operator=standard_crossover, crossover_conf=crossover_conf, selection=lambda individuals: tournament_selection(individuals, environments, 2), parent_selection=lambda individuals: multiple_selection(individuals, 2, tournament_selection, environments), population_management=steady_state_population_management, population_management_selector=tournament_selection, evaluation_time=settings.evaluation_time, offspring_size=offspring_size, experiment_name=settings.experiment_name, experiment_management=experiment_management, environments=environments, front=front ) settings = parser.parse_args() simulator_queue = {} analyzer_queue = None previous_port = None for environment in environments: settings.world = environment settings.z_start = environments[environment] if previous_port is None: port = settings.port_start previous_port = port else: port = previous_port+settings.n_cores previous_port = port simulator_queue[environment] = SimulatorQueue(settings.n_cores, settings, port) await simulator_queue[environment].start() analyzer_queue = AnalyzerQueue(1, settings, port+settings.n_cores) await analyzer_queue.start() population = Population(population_conf, simulator_queue, analyzer_queue, next_robot_id) if do_recovery: if gen_num >= 0: # loading a previous state of the experiment await population.load_snapshot(gen_num) logger.info('Recovered snapshot '+str(gen_num)+', pop with ' + str(len(population.individuals))+' individuals') if has_offspring: individuals = await population.load_offspring(gen_num, population_size, offspring_size, next_robot_id) gen_num += 1 logger.info('Recovered unfinished offspring '+str(gen_num)) if gen_num == 0: await population.init_pop(individuals) else: population = await population.next_gen(gen_num, individuals) experiment_management.export_snapshots(population.individuals, gen_num) else: # starting a new experiment experiment_management.create_exp_folders() await population.init_pop() experiment_management.export_snapshots(population.individuals, gen_num) while gen_num < num_generations-1: gen_num += 1 population = await population.next_gen(gen_num) experiment_management.export_snapshots(population.individuals, gen_num)
async def run(): """ The main coroutine, which is started below. """ arguments = parser.parse_args() if arguments.robot_name is not None: # this split will give errors on windows robot_file_path = "experiments/bodies/" + arguments.robot_name + ".yaml" if arguments.iterations is not None: # this split will give errors on windows iterations = int(arguments.iterations) #robot_file_path = "experiments/examples/yaml/spider.yaml" # Parse command line / file input arguments settings = parser.parse_args() # Start Simulator if settings.simulator_cmd != 'debug': simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo') await simulator_supervisor.launch_simulator(port=settings.port_start) await asyncio.sleep(0.1) # Load a robot from yaml robot = revolve_bot.RevolveBot() robot.load_file(robot_file_path) robot.update_substrate() # robot._brain = BrainRLPowerSplines() # Connect to the simulator and pause connection = await World.create(settings, world_address=('127.0.0.1', settings.port_start)) await asyncio.sleep(1) # Starts the simulation await connection.pause(False) # Insert the robot in the simulator #life_timeout = Fixed time a robot stays in the simulator robot_manager = await connection.insert_robot( robot, Vector3(0, 0, settings.z_start)) robot_fitness = [] for x in range(1, iterations): # Print robot fitness every second robot_fitness.append( fitness.displacement_velocity(robot_manager, robot)) await asyncio.sleep(0.1) print("**The Robot Fitness is: ", str(sum(robot_fitness) / len(robot_fitness)))
async def run(): # Parse command line / file input arguments settings = parser.parse_args() # create ata folder and logger data_folder = os.path.join(DATA_FOLDER_BASE, settings.experiment_name) data_folder = make_folders(data_folder) log = logger.create_logger('experiment', handlers=[ logging.StreamHandler(sys.stdout), logging.FileHandler(os.path.join( data_folder, 'experiment_manager.log'), mode='w') ]) # Set debug level to DEBUG log.setLevel(logging.DEBUG) # Save settings experimental_settings = { 'START': { 'human': time.strftime("%a, %d %b %Y %H:%M:%S"), 'seconds': time.time(), }, 'ROBOT_BATTERY': ROBOT_BATTERY, 'ROBOT_STOP': ROBOT_STOP, 'ROBOT_SELF_COLLIDE': ROBOT_SELF_COLLIDE, 'REPRODUCE_LOCALLY_RADIUS': REPRODUCE_LOCALLY_RADIUS, 'INDIVIDUAL_MAX_AGE': INDIVIDUAL_MAX_AGE, 'INDIVIDUAL_MAX_AGE_SIGMA': INDIVIDUAL_MAX_AGE_SIGMA, 'SEED_POPULATION_START': SEED_POPULATION_START, 'MIN_POP': MIN_POP, 'MAX_POP': MAX_POP, 'Z_SPAWN_DISTANCE': Z_SPAWN_DISTANCE, 'LIMIT_X': LIMIT_X, 'LIMIT_Y': LIMIT_Y, 'MATURE_AGE': MATURE_AGE, 'MATE_DISTANCE': MATE_DISTANCE, 'MATING_COOLDOWN': MATING_COOLDOWN, 'COUPLE_MATING_LIMIT': COUPLE_MATING_LIMIT, 'MATING_INCREASE_RATE': MATING_INCREASE_RATE, 'RECENT_CHILDREN_DELTA_TIME': RECENT_CHILDREN_DELTA_TIME, 'PLASTICODING_CONF.max_structural_modules': PLASTICODING_CONF.max_structural_modules, 'CROSSOVER_PROBABILITY': CROSSOVER_CONF.crossover_prob, 'MUTATION_PROBABILITY': MUTATION_CONF.mutation_prob, # FOLDER WHERE TO SAVE THE EXPERIMENT # {current_folder}/data/{arguments.experiment_name} # example ~/projects/revolve/experiments/unmanaged/data/default_experiment 'DATA_FOLDER_BASE': DATA_FOLDER_BASE, } with open(os.path.join(data_folder, 'experimental_settings.yaml'), 'w') as f: f.write(str(yaml.dump(experimental_settings))) # Start Simulator if settings.simulator_cmd != 'debug': def simulator_dead(_process, ret_code): log.error("SIMULATOR DIED BEFORE THE END OF THE EXPERIMENT") sys.exit(ret_code) simulator_supervisor = DynamicSimSupervisor( world_file=settings.world, simulator_cmd=settings.simulator_cmd, simulator_args=["--verbose"], plugins_dir_path=os.path.join('.', 'build', 'lib'), models_dir_path=os.path.join('.', 'models'), simulator_name='gazebo', process_terminated_callback=simulator_dead, ) await simulator_supervisor.launch_simulator(port=settings.port_start) # let there be some time to sync all initial output of the simulator await asyncio.sleep(5) # Connect to the simulator and pause connection = await World.create(settings, world_address=('127.0.0.1', settings.port_start)) connection.output_directory = os.path.join(data_folder, 'snapshots') await asyncio.sleep(1) robot_population = Population(log, data_folder, connection) log.info("SEEDING POPULATION STARTED") await robot_population.seed_initial_population(pause_while_inserting=False) log.info("SEEDING POPULATION FINISHED") # Start the main life loop try: last_snapshot = connection.last_time log.info("creating initial snapshot") success = await robot_population.create_snapshot() while True: world_time = connection.last_time if float(world_time - last_snapshot) > SNAPSHOT_TIME: log.info(f"Creating snapshot at {world_time}") last_snapshot = world_time success = await robot_population.create_snapshot() await robot_population.death_season() await robot_population.mating_season() await robot_population.immigration_season() robot_population.adjust_mating_multiplier(connection.age()) await asyncio.sleep(0.05) except Finish: await asyncio.wait_for(connection.disconnect(), 10) if settings.simulator_cmd != 'debug': await asyncio.wait_for(simulator_supervisor.stop(), 10) log.info("EVOLUTION finished successfully")
async def run(): """ The main coroutine, which is started below. """ # experiment params # num_generations = 100 population_size = 100 offspring_size = 50 genotype_conf = PlasticodingConfig( max_structural_modules=100, ) mutation_conf = MutationConfig( mutation_prob=0.8, genotype_conf=genotype_conf, ) crossover_conf = CrossoverConfig( crossover_prob=0.8, ) # experiment params # # Parse command line / file input arguments settings = parser.parse_args() experiment_management = ExperimentManagement(settings) do_recovery = settings.recovery_enabled and not experiment_management.experiment_is_new() logger.info('Activated run '+settings.run+' of experiment '+settings.experiment_name) if do_recovery: gen_num, has_offspring, next_robot_id = experiment_management.read_recovery_state(population_size, offspring_size) if gen_num == num_generations-1: logger.info('Experiment is already complete.') return else: gen_num = 0 next_robot_id = 1 def fitness_function(robot_manager, robot): contacts = measures.contacts(robot_manager, robot) assert(contacts != 0) return fitness.displacement_velocity_hill(robot_manager, robot) population_conf = PopulationConfig( population_size=population_size, genotype_constructor=random_initialization, genotype_conf=genotype_conf, fitness_function=fitness_function, mutation_operator=standard_mutation, mutation_conf=mutation_conf, crossover_operator=standard_crossover, crossover_conf=crossover_conf, selection=lambda individuals: tournament_selection(individuals, 2), parent_selection=lambda individuals: multiple_selection(individuals, 2, tournament_selection), population_management=steady_state_population_management, population_management_selector=tournament_selection, evaluation_time=settings.evaluation_time, offspring_size=offspring_size, experiment_name=settings.experiment_name, experiment_management=experiment_management, ) settings = parser.parse_args() simulator_queue = SimulatorQueue(settings.n_cores, settings, settings.port_start) await simulator_queue.start() population = Population(population_conf, simulator_queue, next_robot_id) if do_recovery: # loading a previous state of the experiment await population.load_snapshot(gen_num) if gen_num >= 0: logger.info('Recovered snapshot '+str(gen_num)+', pop with ' + str(len(population.individuals))+' individuals') if has_offspring: individuals = await population.load_offspring(gen_num, population_size, offspring_size, next_robot_id) gen_num += 1 logger.info('Recovered unfinished offspring '+str(gen_num)) if gen_num == 0: await population.init_pop(individuals) else: population = await population.next_gen(gen_num, individuals) experiment_management.export_snapshots(population.individuals, gen_num) else: # starting a new experiment experiment_management.create_exp_folders() await population.init_pop() experiment_management.export_snapshots(population.individuals, gen_num) while gen_num < num_generations-1: gen_num += 1 population = await population.next_gen(gen_num) experiment_management.export_snapshots(population.individuals, gen_num)
async def run(): """ The main coroutine, which is started below. """ # experiment params # num_generations = 100 population_size = 100 offspring_size = 50 front = 'slaves' # environment world and z-start environments = {'plane': 0.03, 'tilted5': 0.1} genotype_conf = PlasticodingConfig( max_structural_modules=15, plastic=True, ) mutation_conf = MutationConfig( mutation_prob=0.8, genotype_conf=genotype_conf, ) crossover_conf = CrossoverConfig(crossover_prob=0.8, ) # experiment params #load_individual # Parse command line / file input arguments settings = parser.parse_args() experiment_management = ExperimentManagement(settings, environments) do_recovery = settings.recovery_enabled and not experiment_management.experiment_is_new( ) logger.info('Activated run ' + settings.run + ' of experiment ' + settings.experiment_name) def fitness_function(robot_manager, robot): #contacts = measures.contacts(robot_manager, robot) #assert(contacts != 0) return fitness.displacement_velocity_hill(robot_manager, robot, False) population_conf = PopulationConfig( population_size=population_size, genotype_constructor=random_initialization, genotype_conf=genotype_conf, fitness_function=fitness_function, mutation_operator=standard_mutation, mutation_conf=mutation_conf, crossover_operator=standard_crossover, crossover_conf=crossover_conf, selection=lambda individuals: tournament_selection( individuals, environments, 2), parent_selection=lambda individuals: multiple_selection( individuals, 2, tournament_selection, environments), population_management=steady_state_population_management, population_management_selector=tournament_selection, evaluation_time=settings.evaluation_time, offspring_size=offspring_size, experiment_name=settings.experiment_name, experiment_management=experiment_management, environments=environments, front=front) settings = parser.parse_args() simulator_queue = {} analyzer_queue = None previous_port = None for environment in environments: settings.world = environment settings.z_start = environments[environment] if previous_port is None: port = settings.port_start previous_port = port else: port = previous_port + settings.n_cores previous_port = port simulator_queue[environment] = SimulatorQueue(settings.n_cores, settings, port) await simulator_queue[environment].start() analyzer_queue = AnalyzerQueue(1, settings, port + settings.n_cores) await analyzer_queue.start() population = Population(population_conf, simulator_queue, analyzer_queue, 1) # choose a snapshot here. and the maximum best individuals you wish to watch generation = 61 #99 max_best = 3 #10 await population.load_snapshot(generation) values = [] for ind in population.individuals: # define a criteria here for environment in environments: ind[environment].evaluated = False values.append(ind[list(environments.keys())[-1]].consolidated_fitness) #values.append(ind['plane'].phenotype._behavioural_measurements.displacement_velocity_hill) values = np.array(values) ini = len(population.individuals) - max_best fin = len(population.individuals) population.individuals = np.array(population.individuals) # highest population.individuals = population.individuals[np.argsort(values) [ini:fin]] # lowest #population.individuals = population.individuals[np.argsort(values)[0:max_best]] for ind in population.individuals: print(ind[list(environments.keys())[-1]].phenotype.id) print('consolidated_fitness', ind[list(environments.keys())[-1]].consolidated_fitness) for environment in environments: print(environment) await population.evaluate(new_individuals=population.individuals, gen_num=generation, environment=environment, type_simulation='watch')