output_space=environment.action_space, priority_metric=rules.PittRulesExecutable.PriorityMetric.RULE_ORDER) with open('./genomes.csv', 'w') as genomes_file: ea = generational_ea( max_generations=generations, pop_size=pop_size, # Solve a problem that executes agents in the # environment and obtains fitness from it problem=problems.EnvironmentProblem(runs_per_fitness_eval, simulation_steps, environment, 'reward', gui=gui), representation=Representation( initialize=decoder.initializer(num_rules), decoder=decoder), # The operator pipeline. pipeline=[ ops.tournament_selection, ops.clone, decoder.mutator(condition_mutator=genome_mutate_gaussian( std=mutate_std, hard_bounds=decoder.condition_bounds, expected_num_mutations=1 / num_rules), action_mutator=individual_mutate_randint( bounds=decoder.action_bounds, probability=1.0)), ops.evaluate, ops.pool(size=pop_size), *build_probes(genomes_file,
# specific infinite max_generations generations = float('inf') l = 2 pop_size = 10 ea = generational_ea(max_generations=generations,pop_size=pop_size, problem=problem, # Fitness function # Stopping condition: we stop when fitness or diversity drops below a threshold stop=lambda pop: (max(pop).fitness < fitness_threshold) or (probe.pairwise_squared_distance_metric(pop) < diversity_threshold), # Representation representation=Representation( # Initialize a population of integer-vector genomes initialize=create_real_vector( bounds=[problem.bounds] * l) ), # Operator pipeline pipeline=[ ops.tournament_selection(k=2), ops.clone, # Apply binomial mutation: this is a lot like # additive Gaussian mutation, but adds an integer # value to each gene mutate_gaussian(std=0.2, hard_bounds=[problem.bounds]*l, expected_num_mutations=1), ops.evaluate, ops.pool(size=pop_size),
if os.environ.get(test_env_var, False) == 'True': generations = 2 else: generations = 1000 l = 2 pop_size = 10 ea = multi_population_ea( max_generations=generations, num_populations=topology.number_of_nodes(), pop_size=pop_size, problem=problem, # Fitness function # Representation representation=Representation( individual_cls=Individual, initialize=create_real_vector(bounds=[problem.bounds] * l)), # Operator pipeline shared_pipeline=[ ops.tournament_selection, ops.clone, mutate_gaussian(std=30, expected_num_mutations=1, hard_bounds=problem.bounds), ops.evaluate, ops.pool(size=pop_size), ops.migrate(topology=topology, emigrant_selector=ops.tournament_selection, replacement_selector=ops.random_selection, migration_gap=50), probe.FitnessStatsCSVProbe( stream=sys.stdout,
if args.track_workers_file: track_workers_stream = open(args.track_workers_file, 'w') track_workers_func = log_worker_location(track_workers_stream) if args.track_pop_file is not None: track_pop_stream = open(args.track_pop_file, 'w') track_pop_func = log_pop(args.update_interval, track_pop_stream) final_pop = asynchronous.steady_state( client, births=args.max_births, init_pop_size=args.init_pop_size, pop_size=args.pop_size, representation=Representation( initialize=create_binary_sequence(args.length), individual_cls=DistributedIndividual), problem=MaxOnes(), offspring_pipeline=[ ops.random_selection, ops.clone, mutate_bitflip(expected_num_mutations=1), ops.pool(size=1) ], evaluated_probe=track_workers_func, pop_probe=track_pop_func) logger.info('Final pop: \n%s', pformat(final_pop)) except Exception as e: logger.critical(str(e)) raise e finally:
def ea_solve(function, bounds, generations=100, pop_size=cpu_count(), mutation_std=1.0, maximize=False, viz=False, viz_ylim=(0, 1), hard_bounds=True, dask_client=None): """Provides a simple, top-level interfact that optimizes a real-valued function using a simple generational EA. :param function: the function to optimize; should take lists of real numbers as input and return a float fitness value :param [(float, float)] bounds: a list of (min, max) bounds to define the search space :param int generations: the number of generations to run for :param int pop_size: the population size :param float mutation_std: the width of the mutation distribution :param bool maximize: whether to maximize the function (else minimize) :param bool viz: whether to display a live best-of-generation plot :param bool hard_bounds: if True, bounds are enforced at all times during evolution; otherwise they are only used to initialize the population. :param (float, float) viz_ylim: initial bounds to use of the plots vertical axis :param dask_client: is optional dask Client for enable parallel evaluations The basic call includes instrumentation that prints the best-so-far fitness value of each generation to stdout: >>> from leap_ec.simple import ea_solve >>> ea_solve(sum, bounds=[(0, 1)]*5) # doctest:+ELLIPSIS generation, bsf 0, ... 1, ... ... 100, ... array([..., ..., ..., ..., ...]) When `viz=True`, a live BSF plot will also display: >>> ea_solve(sum, bounds=[(0, 1)]*5, viz=True) # doctest:+ELLIPSIS generation, bsf 0, ... 1, ... ... 100, ... array([..., ..., ..., ..., ...]) .. plot:: from leap_ec.simple import ea_solve ea_solve(sum, bounds=[(0, 1)]*5, viz=True) """ if hard_bounds: mutation_op = mutate_gaussian(std=mutation_std, hard_bounds=bounds, expected_num_mutations='isotropic') else: mutation_op = mutate_gaussian(std=mutation_std, expected_num_mutations='isotropic') pipeline = [ ops.tournament_selection, ops.clone, mutation_op, ops.uniform_crossover(p_swap=0.2), ] # If a dask client is given, then use the synchronous (map/reduce) parallel # evaluation of individuals; else, revert to serial evaluations. if dask_client: pipeline.append( synchronous.eval_pool(client=dask_client, size=pop_size)) else: pipeline.extend([ops.evaluate, ops.pool(size=pop_size)]) if viz: plot_probe = probe.FitnessPlotProbe(ylim=viz_ylim, ax=plt.gca()) pipeline.append(plot_probe) ea = generational_ea(max_generations=generations, pop_size=pop_size, problem=FunctionProblem(function, maximize), representation=Representation( individual_cls=DistributedIndividual, initialize=create_real_vector(bounds=bounds)), pipeline=pipeline) best_genome = None print('generation, bsf') for g, ind in ea: print(f"{g}, {ind.fitness}") best_genome = ind.genome return best_genome
decorator=executable.ArgmaxExecutable) with open('./genomes.csv', 'w') as genomes_file: ea = generational_ea( max_generations=generations, pop_size=pop_size, # Solve a problem that executes agents in the # environment and obtains fitness from it problem=problems.EnvironmentProblem(runs_per_fitness_eval, simulation_steps, environment, 'reward', gui=gui), representation=Representation(initialize=create_real_vector( bounds=([[-1, 1]] * decoder.wrapped_decoder.length)), decoder=decoder), # The operator pipeline. pipeline=[ ops.tournament_selection, ops.clone, mutate_gaussian(std=mutate_std, hard_bounds=(-1, 1), expected_num_mutations=1), ops.evaluate, ops.pool(size=pop_size), *build_probes( genomes_file) # Inserting all the probes at the end ]) list(ea)
if os.environ.get(test_env_var, False) == 'True': generations = 2 else: generations = 1000 with open('./coop_stats.csv', 'w') as log_stream: ea = multi_population_ea(max_generations=generations, pop_size=pop_size, num_populations=9, problem=MaxOnes(), # Fitness function init_evaluate=ops.const_evaluate(value=-100), representation=Representation( individual_cls=Individual, initialize=create_binary_sequence( length=1) ), # Operator pipeline shared_pipeline=[ ops.tournament_selection, ops.clone, mutate_bitflip(expected_num_mutations=1), ops.CooperativeEvaluate( num_trials=1, collaborator_selector=ops.random_selection, log_stream=log_stream), ops.pool(size=pop_size) ])