def run(self, benchmark): """Execute the algorithm Argument -------- benchmark: str """ if self.__flags.seed is None: algorithm = pg.sga(gen=self.__flags.generations, cr=self.__flags.cr, m=self.__flags.m, param_m=self.__flags.param_m, param_s=self.__flags.param_s, crossover=self.__flags.crossover, mutation=self.__flags.mutation, selection=self.__flags.selection) else: algorithm = pg.sga(gen=self.__flags.generations, cr=self.__flags.cr, m=self.__flags.m, param_m=self.__flags.param_m, param_s=self.__flags.param_s, crossover=self.__flags.crossover, mutation=self.__flags.mutation, selection=self.__flags.selection, seed=self.__flags.seed) # Execute super().exec(algorithm, benchmark)
def solver(dimension, lower_bound, upper_bound, optim, bias, popsize): global algo global pop global niter global log global curve prob = pg.problem( rastrigin_prob(dimension, lower_bound, upper_bound, optim, bias)) algo = pg.algorithm( pg.sga(gen=2000, cr=0.9, eta_c=2.0, m=0.02, param_m=1.0, param_s=2, crossover='binomial', mutation='gaussian', selection='truncated')) algo.set_verbosity(1) pop = pg.population(prob, popsize) pop = algo.evolve(pop) log = algo.extract(pg.sga).get_log() curve = [x[2] for x in log] niter = log[-1][0] return prob, algo, pop, log, niter, curve
def run_problem(prob, uda=pg.sga(gen=100), population_size=100, verbosity=1): # Create algorithm to solve problem with algo = pg.algorithm(uda=uda) algo.set_verbosity(verbosity) # population of problems pop = pg.population(prob=prob, size=population_size) # solve problem pop = algo.evolve(pop) return pop
def main(untrained): pop = None prob = ConvNetSizeProblem(2, untrained=untrained) pg.set_global_rng_seed(94874) prob = pg.problem(prob) algo = pg.algorithm(pg.sga(1, m=0.2, mutation='uniform')) pop = pg.population(prob, pop_size) algo.set_verbosity(1) for g in range(gens): f = pop.get_f() x = pop.get_x() for i in range(len(x)): logger.info(str(g) + ';' + str(x[i]) + ';' + str(f[i][0])) pop = algo.evolve(pop)
def archipelago(): print('interferometer sga archipelago') uda = pg.sga(gen=50000) # instantiate an unconnected archipelago archi = pg.archipelago(t=pg.topologies.unconnected()) t = time() for _ in range(8): alg = pg.algorithm(uda) #alg.set_verbosity(1) prob = pg.problem(udp) pop = pg.population(prob, 20) isl = pg.island(algo=alg, pop=pop) archi.push_back(isl) archi.evolve() archi.wait_check() print(f'archi: {time() - t:0.3f}s')
def compute_black_box_optimization(self, x: CArray) -> CArray: self.problem.init_starting_point(x) seed = self.problem.seed if self.problem.seed is not None else 0 algorithm = pygmo.algorithm( pygmo.sga(gen=self.problem.iterations, seed=seed)) pygmo_problem = pygmo.problem(self.problem) pygmo_population = pygmo.population(pygmo_problem, size=self.problem.population_size, seed=self.problem.seed) minimization_results = algorithm.evolve(pygmo_population) best_x = minimization_results.get_x()[minimization_results.best_idx()] evolved_problem = minimization_results.problem.extract( type(self.problem)) confidences, fitness = evolved_problem.export_internal_results() self.confidences_ = confidences self.fitness = fitness return CArray(best_x)
def main(untrained): with Environment() as e: pop = None prob = ConvNetSizeProblem(2, distributed=True, untrained=untrained) pg.set_global_rng_seed(45714) prob = pg.problem(prob) algo = pg.algorithm(pg.sga(1, m=0.2, mutation='uniform')) pop = pg.population(prob, pop_size) algo.set_verbosity(1) for g in range(gens): f = pop.get_f() x = pop.get_x() for i in range(len(x)): e.log( str(g) + ';' + np.array2string( x[i], precision=2, separator=',', suppress_small=True) + ';' + str(f[i][0])) pop = algo.evolve(pop)
def compute_black_box_optimization(self, x: CArray) -> CArray: self.problem.init_starting_point(x) seed = self.problem.seed if self.problem.seed is not None else 0 # algorithm = pygmo.algorithm(pygmo.sga(gen=self.problem.iterations, seed=seed, crossover='exponential', mutation='gaussian')) algorithm = pygmo.algorithm(pygmo.sga(gen=self.problem.iterations, seed=seed)) algorithm.set_verbosity(1) start_t = time.time() pygmo_problem = pygmo.problem(self.problem) pygmo_population = pygmo.population(pygmo_problem, size=self.problem.population_size, seed=self.problem.seed) minimization_results = algorithm.evolve(pygmo_population) end_t = time.time() evolved_problem = minimization_results.problem.extract(type(self.problem)) confidences, fitness, sizes = evolved_problem.export_internal_results() self.confidences_ = confidences self.fitness_ = fitness self.sizes_ = sizes self.evolved_problem_ = evolved_problem self.elapsed_time_ = end_t - start_t best_t = minimization_results.champion_x return CArray(best_t)
def rosenbrock_2d(x): generations = x[0] prob = pg.problem(pg.rosenbrock(2)) # 2 - Instantiate a pagmo algorithm algo = pg.algorithm(pg.sga(gen=generations, cr = .90, eta_c = 1., m = 0.02, param_m = 1., param_s = 2, crossover = "exponential", mutation = "polynomial", selection = "tournament", seed = 3)) # 3 - Instantiate an archipelago with 16 islands having each 20 individuals archi = pg.archipelago(16, algo=algo, prob=prob, pop_size=20) # 4 - Run the evolution in parallel on the 16 separate islands 10 times. archi.evolve(10) # 5 - Wait for the evolutions to be finished archi.wait() # 6 - Print the fitness of the best solution in each island res = [isl.get_population().champion_f for isl in archi] import pdb; pdb.set_trace(); return res
def BGA_train(xMin, yMin, xMaj, yMaj, model_old, lr, epoch, batch_size, pop_size, gen_max, cx, mx): # define the problem print('define the problem') prob = pg.problem( BPFL_fc_imb(xMin, xMaj, yMin, yMaj, model_old, lr, epoch, batch_size)) # population initialization print('population initialization') pop_init = pg.population(prob=prob, size=pop_size) # genetic algorithm construction print('genetic algorithm construction') gaalgo = pg.algorithm( pg.sga(gen=gen_max, cr=cx, m=mx, param_s=2, crossover="single", mutation="uniform", selection="truncated")) # run ga and get the best population print('run ga and get the best population') pop_new = gaalgo.evolve(pop_init).get_x() return pop_new
def main(): parser = argparse.ArgumentParser(description="Make a squad from scratch") # General parameters parser.add_argument( "--budget", help="budget, in 0.1 millions", type=int, default=1000 ) parser.add_argument("--season", help="season, in format e.g. 1819") parser.add_argument("--gw_start", help="gameweek to start from", type=int) parser.add_argument( "--num_gw", help="how many gameweeks to consider", type=int, default=3 ) parser.add_argument( "--algorithm", help="Which optimization algorithm to use - 'normal' or 'genetic'", type=str, default="normal", ) # parameters for "normal" optimization parser.add_argument( "--num_iterations", help="number of iterations (normal algorithm only)", type=int, default=10, ) # parameters for "pygmo" optimization parser.add_argument( "--num_generations", help="number of generations (genetic only)", type=int, default=100, ) parser.add_argument( "--population_size", help="number of candidate solutions per generation (genetic only)", type=int, default=100, ) parser.add_argument( "--no_subs", help="Don't include points contribution from substitutes (genetic only)", action="store_true", ) parser.add_argument( "--include_zero", help="Include players with zero predicted points (genetic only)", action="store_true", ) parser.add_argument( "--gw_weight_type", help="'constant' to treat all gameweeks equally, or 'linear' to reduce weight of gameweeks with time (genetic only)", type=str, default="linear", ) args = parser.parse_args() if args.season: season = args.season else: season = get_current_season() budget = args.budget if args.gw_start: gw_start = args.gw_start else: gw_start = NEXT_GAMEWEEK gw_range = list(range(gw_start, min(38, gw_start + args.num_gw))) tag = get_latest_prediction_tag(season) if args.algorithm == "normal": from airsenal.framework.optimization_utils import make_new_squad num_iterations = args.num_iterations best_squad = make_new_squad(args.budget, num_iterations, tag, gw_range, season) elif args.algorithm == "genetic": from airsenal.framework.optimization_pygmo import make_new_squad num_generations = args.num_generations population_size = args.population_size remove_zero = not args.include_zero gw_weight_type = args.gw_weight_type uda = pg.sga(gen=num_generations) if args.no_subs: sub_weights = {"GK": 0, "Outfield": (0, 0, 0)} else: sub_weights = {"GK": 0.01, "Outfield": (0.4, 0.1, 0.02)} best_squad = make_new_squad( gw_range, tag, budget=budget, season=season, remove_zero=remove_zero, sub_weights=sub_weights, uda=uda, population_size=population_size, gw_weight_type=gw_weight_type, ) else: raise ValueError("'algorithm' must be 'normal' or 'genetic'") points = best_squad.get_expected_points(gw_start, tag) print("---------------------") print("Best expected points for gameweek {}: {}".format(gw_start, points)) print("---------------------") print(best_squad)
def _setOptimizer(self, optimizer): if callable(optimizer) == True: # User-defined optimizer function pass elif isinstance(optimizer, str): # Pre-defined optimizer if optimizer == 'ga': gen = self.optimization_configuration['number_of_generations'] cr = self.optimization_configuration['crossover_rate'] mr = self.optimization_configuration['mutation_rate'] elitism = self.optimization_configuration['elitism'] ind = self.optimization_configuration['number_of_individuals'] #================================================================= crossover_type = self.optimization_configuration[ 'crossover_type'] mutation_type = self.optimization_configuration[ 'mutation_type'] selection_type = self.optimization_configuration[ 'selection_type'] selection_param = self.optimization_configuration[ 'selection_param'] #================================================================= self._pagmo_selected_algorithm = pg.sga self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'Improvement' ] algo = pg.algorithm( pg.sga(gen=gen, cr=cr, eta_c=1., m=mr, param_m=1., param_s=selection_param, crossover=crossover_type, mutation=mutation_type, selection=selection_type)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('ga') if optimizer == 'sade': gen = self.optimization_configuration['number_of_generations'] de_ftol = self.optimization_configuration['ftol_de'] de_xtol = self.optimization_configuration['xtol_de'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.de1220 self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'F', 'CR', 'Variant', 'dx', 'df' ] algo = pg.algorithm( pg.de1220(gen=gen, ftol=de_ftol, xtol=de_xtol)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('sade') if optimizer == 'de': gen = self.optimization_configuration['number_of_generations'] cr = self.optimization_configuration['crossover_rate'] f_w = self.optimization_configuration['scale_factor'] de_variant = self.optimization_configuration['variant_de'] de_ftol = self.optimization_configuration['ftol_de'] de_xtol = self.optimization_configuration['xtol_de'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.de self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'F', 'CR', 'dx', 'df' ] algo = pg.algorithm( pg.de(gen=gen, F=f_w, CR=cr, variant=de_variant, ftol=de_ftol, xtol=de_xtol)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('de') if optimizer == 'pso': gen = self.optimization_configuration['number_of_generations'] omega = self.optimization_configuration['omega_pso'] eta1 = self.optimization_configuration['eta1_pso'] eta2 = self.optimization_configuration['eta2_pso'] vcoeff = self.optimization_configuration['max_v_pso'] pso_variant = self.optimization_configuration['variant_pso'] neighb_type = self.optimization_configuration[ 'neighborhood_type_pso'] neighb_param = self.optimization_configuration[ 'neighborhood_param_pso'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.pso self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'gbest', 'Mean Vel.', 'Mean lbest', 'Avg. Dist.' ] algo = pg.algorithm( pg.pso(gen=gen, omega=omega, eta1=eta1, eta2=eta2, max_vel=vcoeff, variant=pso_variant)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('pso') else: raise UnexpectedValueError("(decorated function, str)")
sub_weights = {"GK": 0.01, "Outfield": (0.4, 0.1, 0.02)} # Can choose not to optimize full squad by changing the number of players per position. # In that case, to create valid squads during the optimization, the empty slots are # filled with dummy players. Each dummy player has a cost of 'dummy_sub_cost'. players_per_position = TOTAL_PER_POSITION dummy_sub_cost = 45 # Optimisation algorithm # For the list of algorithms available in pygmo see here: # https://esa.github.io/pygmo2/overview.html#list-of-algorithms # Time it will take to run normally controlled by: # - "gen" argument of algorithm - no. of generations (no. of times population # is evolved) # - "population_size" - no. of candidate solutions in each generatino uda = pg.sga(gen=100) # ("User Defined Algorithm") population_size = 100 # ------------------------- # RUN OPTIMIZATION # ------------------------- gw_range = list(range(gw_start, min(38, gw_start + num_gw))) team = make_new_squad( gw_range, tag, uda=uda, population_size=population_size, sub_weights=sub_weights, budget=budget, players_per_position=players_per_position,
def findPowersRR(self, objectiveFunction="averageThr", sgaGenerations=100, numberOfThreads=11, numOfIndividuals=10, evolveTimes=10, method="global", x_arg=None, y_arg=None, expectedSignalLoss_arg=None): if method == "local": if x_arg == None: x = self.parent.constraintAreaMaxX / 2 else: x = x_arg if y_arg == None: y = self.parent.constraintAreaMaxY / 2 else: y = y_arg if expectedSignalLoss_arg == None: maxDistance = min(self.parent.constraintAreaMaxX / 2, self.parent.constraintAreaMaxY / 2) else: maxDistance = returnDistanceFromSNR(expectedSignalLoss_arg) localBsVector = [] for bs in self.parent.bs: if math.sqrt((bs.x - x)**2 + (bs.y - y)**2) < maxDistance: row = [] row.append(int(bs.ID)) row.append(math.sqrt((bs.x - x)**2 + (bs.y - y)**2)) localBsVector.append(row) localBsVector = np.asarray(localBsVector) if objectiveFunction == "averageThr": if method == "local": localListBS = [] for i in range(len(localBsVector)): localListBS.append(localBsVector[i, 0]) prob = pg.problem( local_maximalThroughputProblemRR( dim=len(localBsVector), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower, localListBS=localListBS)) if method == "global": prob = pg.problem( maximalThroughputProblemRR( dim=len(self.parent.bs), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower)) if objectiveFunction == "medianThr": if method == "local": localListBS = [] for i in range(len(localBsVector)): localListBS.append(localBsVector[i, 0]) prob = pg.problem( local_maximalMedianThrProblemRR( dim=len(localBsVector), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower, localListBS=localListBS)) if method == "global": prob = pg.problem( maximalMedianThrProblemRR( dim=len(self.parent.bs), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower)) if objectiveFunction == "minIQRthr": if method == "local": localListBS = [] for i in range(len(localBsVector)): localListBS.append(localBsVector[i, 0]) prob = pg.problem( local_minInterQuartileRangeroblemRR( dim=len(localBsVector), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower, localListBS=localListBS)) if method == "global": prob = pg.problem( minInterQuartileRangeroblemRR( dim=len(self.parent.bs), networkInstance=self.parent, lowerTxLimit=self.parent.minTxPower, upperTxLimit=self.parent.maxTxPower)) prob.siec = copy.deepcopy(self.parent) # algo = algorithm.sga(gen=sgaGenerations) algo = pg.algorithm(pg.sga(gen=sgaGenerations)) # archi = archipelago(algo, prob, numberOfThreads, numOfIndividuals, topology = topology.barabasi_albert()) # archi.evolve(evolveTimes) # archi.join() population = pg.population(prob, numOfIndividuals) population = algo.evolve(population) theBestCostF = 0 islandNumber = -1 islandCounter = 0 # for island in archi: # if theBestCostF > island.population.champion.f[0]: # theBestCostF = island.population.champion.f[0] # islandNumber = islandCounter # islandCounter = islandCounter + 1 if method == "global": for i in range(len(self.parent.bs)): self.parent.bs[i].outsidePower = population.champion_x[i] if method == "local": for i in range(len(localListBS)): # self.parent.bs[int(prob.bsList[i])].outsidePower = archi[islandNumber].population.champion.x[i] self.parent.bs[int( localListBS[i])].outsidePower = population.champion_x[i] return len(localBsVector)
import pygmo as pg """ Okay, so the lesson learned here is: not sure :-D """ if __name__ == "__main__": prob = pg.problem(pg.rosenbrock(dim=5)) pool_creator = pg.mp_island() # pool_creator.resize_pool(1) pool_creator.init_pool(1) island = pg.island(udi=pool_creator, algo=pg.sga(gen=200), pop=pg.population(prob, 200)) island.evolve() island.wait() print("island: ***** \n", island)
def get_bounds(self): # return ([stage[0].TWR*0.75,stage[1].TWR*0.75,stage[2].TWR*0.75,stage[3].TWR*0.75,stage[0].DV_Ratio*0.9,stage[1].DV_Ratio*0.9,stage[2].DV_Ratio*0.9,stage[3].DV_Ratio*0.9], # [stage[0].TWR*1.25,stage[1].TWR*1.25,stage[2].TWR*1.25,stage[3].TWR*1.25,stage[0].DV_Ratio*1.05,stage[1].DV_Ratio*1.05,stage[2].DV_Ratio*1.05,stage[3].DV_Ratio*1.05]) return ([ stage[0].DV_Ratio * 0.9, stage[1].DV_Ratio * 0.9, stage[2].DV_Ratio * 0.9 ], [ stage[0].DV_Ratio * 1.05, stage[1].DV_Ratio * 1.05, stage[2].DV_Ratio * 1.05 ]) if general.Design_optimization: prob = pg.problem(Design_Optimization()) algo = pg.algorithm(pg.sga( gen=1)) #Choose of heuristic algorithm and number of generations pop = pg.population(prob, 125) #Choose number of individuals pop = algo.evolve(pop) #Evolve the population y = pop.champion_x #Extract the best DV division solution to minimize mass #print(y) DV_sum = 0 for i in range(0, len(stage)): # stage[i].TWR=y[i] stage[i].DV_Ratio = y[i] DV_sum = DV_sum + stage[i].DV_Ratio rocket, stage = Rocket_build(mission, rocket, stage, general) Information(mission, rocket, stage) print(y)
def make_new_squad_pygmo( gw_range, tag, budget=1000, players_per_position=TOTAL_PER_POSITION, season=CURRENT_SEASON, verbose=1, bench_boost_gw=None, triple_captain_gw=None, remove_zero=True, # don't consider players with predicted pts of zero sub_weights={"GK": 0.01, "Outfield": (0.4, 0.1, 0.02)}, dummy_sub_cost=45, uda=pg.sga(gen=100), population_size=100, **kwargs, ): """Optimize a full initial squad using any PyGMO-compatible algorithm. Parameters ---------- gw_range : list Gameweeks to optimize squad for tag : str Points prediction tag to use budget : int, optional Total budget for squad times 10, by default 1000 players_per_position : dict No. of players to optimize in each position, by default airsenal.framework.squad.TOTAL_PER_POSITION season : str Season to optimize for, by default airsenal.framework.utils.CURRENT_SEASON verbose : int Verbosity of optimization algorithm, by default 1 bench_boost_gw : int Gameweek to play benfh boost, by default None triple_captain_gw : int Gameweek to play triple captaiin, by default None, remove_zero : bool If True don't consider players with predicted pts of zero, by default True sub_weights : dict Weighting to give to substitutes in optimization, by default {"GK": 0.01, "Outfield": (0.4, 0.1, 0.02)}, dummy_sub_cost : int, optional If not optimizing a full squad the price of each player that is not being optimized. For example, if you are optimizing 12 out of 15 players, the effective budget for optimizinig the squad will be budget - (15 -12) * dummy_sub_cost, by default 45 uda : class, optional PyGMO compatible algorithm class, by default pg.sga(gen=100) population_size : int, optional Number of candidate solutions in each generation of the optimization, by default 100 Returns ------- airsenal.framework.squad.Squad The optimized squad """ # Build problem opt_squad = SquadOpt( gw_range, tag, budget=budget, players_per_position=players_per_position, dummy_sub_cost=dummy_sub_cost, season=season, bench_boost_gw=bench_boost_gw, triple_captain_gw=triple_captain_gw, remove_zero=remove_zero, # don't consider players with predicted pts of zero sub_weights=sub_weights, ) prob = pg.problem(opt_squad) # Create algorithm to solve problem with algo = pg.algorithm(uda=uda) algo.set_verbosity(verbose) # population of problems pop = pg.population(prob=prob, size=population_size) # solve problem pop = algo.evolve(pop) if verbose > 0: print("Best score:", -pop.champion_f[0], "pts") # construct optimal squad squad = Squad(budget=opt_squad.budget, season=season) for idx in pop.champion_x: if verbose > 0: print( opt_squad.players[int(idx)].position(season), opt_squad.players[int(idx)].name, opt_squad.players[int(idx)].team(season, 1), opt_squad.players[int(idx)].price(season, 1) / 10, ) squad.add_player( opt_squad.players[int(idx)].player_id, gameweek=opt_squad.start_gw, ) # fill empty slots with dummy players (if chosen not to optimise full squad) for pos in opt_squad.positions: if opt_squad.dummy_per_position[pos] > 0: for _ in range(opt_squad.dummy_per_position[pos]): dp = DummyPlayer( opt_squad.gw_range, opt_squad.tag, pos, price=opt_squad.dummy_sub_cost, ) squad.add_player(dp) if verbose > 0: print(dp.position, dp.name, dp.purchase_price / 10) if verbose > 0: print(f"£{squad.budget/10}m in the bank") return squad
def main(): seed = args.seed np.random.seed(seed) cudnn.benchmark = True torch.manual_seed(seed) cudnn.enabled = True torch.cuda.manual_seed(seed) timestamp = str(utils.get_unix_timestamp()) utils.makedirs(args.save) path = os.path.join(args.save, timestamp) utils.create_exp_dir(path, scripts_to_save=glob.glob('../*.py')) logger = utils.get_logger(args.save, timestamp, file_type='txt') utils.makedirs(os.path.join(path, 'logs')) logger.info("time = %s, args = %s", str(utils.get_unix_timestamp()), args) input_shape = [ 11, 9, 3 ] # MANUALLY SET NUMBER OF CHANNELS (11) ACCORDING TO PRETRAINING os.system('cp -f ../pretrain-weights.pt {}'.format( os.path.join(path, 'weights.pt'))) utils.makedirs(os.path.join(path, 'scripts')) os.system('cp -f ./for-copy/parse-ga.py {}'.format( os.path.join(path, 'scripts', 'parse-ga.py'))) os.system('cp -f ./for-copy/parse-ga.py {}'.format( os.path.join(path, 'scripts', 'parse-log.py'))) os.system('cp -f ./for-copy/parse_data.py {}'.format( os.path.join(path, 'scripts', 'parse_data.py'))) os.system('cp -f ./for-copy/optimization-plots.sh {}'.format( os.path.join(path, 'scripts', '1_optimization-plots.sh'))) # PyTorch criterion = nn.CrossEntropyLoss() criterion = criterion.to(device) model = Network(input_shape, args.num_drones, criterion, path) model = model.to(device) utils.load(model, os.path.join(path, 'weights.pt')) optimizer = torch.optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) # PyGMO prob = pg.problem(genetic_algo.Flocking(path, timestamp, model)) pop = pg.population(prob, size=10, seed=24601) algo = pg.algorithm( pg.sga(gen=1, cr=.90, m=0.02, param_s=3, crossover="single", mutation="uniform", selection="truncated")) algo.set_verbosity(1) for i in range(29): logger.info( "time = %s gen = %d \n champ_f = %s \n champ_x = %s \n f_s = %s \n x_s = %s \n id_s = %s", str(utils.get_unix_timestamp()), i + 1, str(np.array(pop.champion_f).tolist()), str(np.array(pop.champion_x).tolist()), str(np.array(pop.get_f()).tolist()), str(np.array(pop.get_x()).tolist()), str(np.array(pop.get_ID()).tolist())) pop = algo.evolve(pop) model.online_update(path, genetic_algo.TS_LIST[-100:], input_shape, criterion, optimizer, logger, i) utils.save(model, os.path.join(path, 'weights.pt'))
def __call__(self, function): scanner_options = { 'sade': dict(gen=self.gen, variant=self.variant, variant_adptv=self.variant_adptv, ftol=self.ftol, xtol=self.xtol, memory=self.memory, seed=self.seed), 'gaco': dict(gen=self.gen, ker=self.ker, q=self.q, oracle=self.oracle, acc=self.acc, threshold=self.threshold, n_gen_mark=self.n_gen_mark, impstop=self.impstop, evalstop=self.evalstop, focus=self.focus, memory=self.memory, seed=self.seed), 'maco': dict(gen=self.gen, ker=self.ker, q=self.q, threshold=self.threshold, n_gen_mark=self.n_gen_mark, evalstop=self.evalstop, focus=self.focus, memory=self.memory, seed=self.seed), 'gwo': dict(gen=self.gen, seed=self.seed), 'bee_colony': dict(gen=self.gen, limit=self.limit, seed=self.seed), 'de': dict(gen=self.gen, F=self.F, CR=self.CR, variant=self.variant, ftol=self.ftol, xtol=self.xtol, seed=self.seed), 'sea': dict(gen=self.gen, seed=self.seed), 'sga': dict(gen=self.gen, cr=self.cr, eta_c=self.eta_c, m=self.m, param_m=self.param_m, param_s=self.param_s, crossover=self.crossover, mutation=self.mutation, selection=self.selection, seed=self.seed), 'de1220': dict(gen=self.gen, allowed_variants=self.allowed_variants, variant_adptv=self.variant_adptv, ftol=self.ftol, xtol=self.xtol, memory=self.memory, seed=self.seed), 'cmaes': dict(gen=self.gen, cc=self.cc, cs=self.cs, c1=self.c1, cmu=self.cmu, sigma0=self.sigma0, ftol=self.ftol, xtol=self.xtol, memory=self.memory, force_bounds=self.force_bounds, seed=self.seed), 'moead': dict(gen=self.gen, weight_generation=self.weight_generation, decomposition=self.decomposition, neighbours=self.neighbours, CR=self.CR, F=self.F, eta_m=self.eta_m, realb=self.realb, limit=self.limit, preserve_diversity=self.preserve_diversity, seed=self.seed), 'compass_search': dict(max_fevals=self.max_fevals, start_range=self.start_range, stop_range=self.stop_range, reduction_coeff=self.reduction_coeff), 'simulated_annealing': dict(Ts=self.Ts, Tf=self.Tf, n_T_adj=self.n_T_adj, n_range_adj=self.n_range_adj, bin_size=self.bin_size, start_range=self.start_range, seed=self.seed), 'pso': dict(gen=self.gen, omega=self.omega, eta1=self.eta1, eta2=self.eta2, max_vel=self.max_vel, variant=self.variant, neighb_type=self.neighb_type, neighb_param=self.neighb_param, memory=self.memory, seed=self.seed), 'pso_gen': dict(gen=self.gen, omega=self.omega, eta1=self.eta1, eta2=self.eta2, max_vel=self.max_vel, variant=self.variant, neighb_type=self.neighb_type, neighb_param=self.neighb_param, memory=self.memory, seed=self.seed), 'nsga2': dict(gen=self.gen, cr=self.cr, eta_c=self.eta_c, m=self.m, eta_m=self.eta_m, seed=self.seed), 'nspso': dict(gen=self.gen, omega=self.omega, c1=self.c1, c2=self.c2, chi=self.chi, v_coeff=self.v_coeff, leader_selection_range=self.leader_selection_range, diversity_mechanism=self.diversity_mechanism, memory=self.memory, seed=self.seed), 'mbh': dict(algo=self.algo, stop=self.stop, perturb=self.perturb, seed=self.seed), 'cstrs_self_adaptive': dict(iters=self.iters, algo=self.algo, seed=self.seed), 'ihs': dict(gen=self.gen, phmcr=self.phmcr, ppar_min=self.ppar_min, ppar_max=self.ppar_max, bw_min=self.bw_min, bw_max=self.bw_max, seed=self.seed), 'xnes': dict(gen=self.gen, eta_mu=self.eta_mu, eta_sigma=self.eta_sigma, eta_b=self.eta_b, sigma0=self.sigma0, ftol=self.ftol, xtol=self.xtol, memory=self.memory, force_bounds=self.force_bounds, seed=self.seed) } if self.log_data: xl = [] yl = [] log_data = self.log_data # class interf_function: def __init__(self, dim): self.dim = dim def fitness(self, x): x = np.expand_dims(x, axis=0) y = function(x) # x = x[0] y = y.tolist() if log_data: xl.append(x) yl.append(y) # print (x, y[0]) return y[0] if function.is_differentiable(): def gradient(self, x): x = np.expand_dims(x, axis=0) g = function(x) g = g.tolist() return g[0] def get_bounds(self): lb = [] ub = [] bounds = function.get_ranges() # warning # check for infinities for i in range(len(bounds)): lb.append(bounds[i, 0]) ub.append(bounds[i, 1]) r = (np.array(lb), np.array(ub)) return r # I need to call pygmo functions directly prob = pg.problem(interf_function(function)) # print (prob.get_thread_safety()) if self.scanner == "sade": # I need a dictionary with algorithms and options algo = pg.algorithm(pg.sade(**scanner_options[self.scanner])) elif self.scanner == "gaco": algo = pg.algorithm(pg.gaco(**scanner_options[self.scanner])) # elif self.scanner == "maco": # is not implemented though in webpage # looks it is # algo = pg.algorithm(pg.maco(**scanner_options[self.scanner])) elif self.scanner == "gwo": algo = pg.algorithm(pg.gwo(**scanner_options[self.scanner])) elif self.scanner == "bee_colony": algo = pg.algorithm(pg.bee_colony(**scanner_options[self.scanner])) elif self.scanner == "de": algo = pg.algorithm(pg.de(**scanner_options[self.scanner])) elif self.scanner == "sea": algo = pg.algorithm(pg.sea(**scanner_options[self.scanner])) elif self.scanner == "sga": algo = pg.algorithm(pg.sga(**scanner_options[self.scanner])) elif self.scanner == "de1220": algo = pg.algorithm(pg.de1220(**scanner_options[self.scanner])) elif self.scanner == "cmaes": algo = pg.algorithm(pg.cmaes(**scanner_options[self.scanner])) # elif self.scanner == "moead": #multiobjective algorithm # algo = pg.algorithm(pg.moead(**scanner_options[self.scanner])) elif self.scanner == "compass_search": algo = pg.algorithm( pg.compass_search(**scanner_options[self.scanner])) elif self.scanner == 'simulated_annealing': algo = pg.algorithm( pg.simulated_annealing(**scanner_options[self.scanner])) elif self.scanner == 'pso': algo = pg.algorithm(pg.pso(**scanner_options[self.scanner])) elif self.scanner == 'pso_gen': algo = pg.algorithm(pg.pso_gen(**scanner_options[self.scanner])) # elif self.scanner == 'nsga2': #multiobjective algorithm # algo = pg.algorithm(pg.nsga2(**scanner_options[self.scanner])) # elif self.scanner == 'nspso': is not implemented though in webpage # looks it is # algo = pg.algorithm(pg.nspso(**scanner_options[self.scanner])) elif self.scanner == 'mbh': if scanner_options[self.scanner]['algo'] == 'de': algo = pg.algorithm( pg.mbh(pg.algorithm(pg.de(**scanner_options['de'])))) # elif self.scanner == 'ihs': #does not work # algo = pg.algorithm(ihs(**scanner_options[self.scanner])) # elif self.scanner == 'xnes': #does not work # algo = pg.algorithm(xnes(**scanner_options[self.scanner])) # uda = algo.extract(xnes) else: print( 'The ' + self.scanner + ' algorithm is not implemented. The ' 'list of algorithms available is', algorithms) sys.exit() # add verbosing flag if self.verbose > 1: algo.set_verbosity(self.verbose) pop = pg.population(prob, self.size) if self.verbose > 9: print('prob', prob) opt = algo.evolve(pop) if self.verbose > 9: print('algo', algo) # best_x = np.expand_dims(opt.champion_x, axis=0) # best_fitness = np.expand_dims(opt.get_f()[opt.best_idx()], axis=0) best_x = np.expand_dims(opt.champion_x, axis=0) best_fitness = np.expand_dims(opt.champion_f, axis=0) if self.verbose > 0: print('best fit:', best_x, best_fitness) if self.log_data: x = np.squeeze(xl, axis=(1, )) y = np.squeeze(yl, axis=(2, )) if self.log_data: return (x, y) else: return (best_x, best_fitness)
def main(): parser = argparse.ArgumentParser(description="Make a squad from scratch") # General parameters parser.add_argument( "--budget", help="budget, in 0.1 millions", type=int, default=1000 ) parser.add_argument("--season", help="season, in format e.g. 1819") parser.add_argument("--gw_start", help="gameweek to start from", type=int) parser.add_argument( "--num_gw", help="how many gameweeks to consider", type=int, default=3 ) parser.add_argument( "--algorithm", help="Which optimization algorithm to use - 'normal' or 'genetic'", type=str, default="genetic", ) # parameters for "normal" optimization parser.add_argument( "--num_iterations", help="number of iterations (normal algorithm only)", type=int, default=10, ) # parameters for "pygmo" optimization parser.add_argument( "--num_generations", help="number of generations (genetic only)", type=int, default=100, ) parser.add_argument( "--population_size", help="number of candidate solutions per generation (genetic only)", type=int, default=100, ) parser.add_argument( "--no_subs", help="Don't include points contribution from substitutes (genetic only)", action="store_true", ) parser.add_argument( "--include_zero", help="Include players with zero predicted points (genetic only)", action="store_true", ) parser.add_argument( "--verbose", help="Print details on optimsation progress", action="store_true", ) parser.add_argument( "--fpl_team_id", help="ID for your FPL team", type=int, ) args = parser.parse_args() season = args.season or get_current_season() budget = args.budget gw_start = args.gw_start or NEXT_GAMEWEEK gw_range = list(range(gw_start, min(38, gw_start + args.num_gw))) tag = get_latest_prediction_tag(season) if not check_tag_valid(tag, gw_range, season=season): print( "ERROR: Database does not contain predictions", "for all the specified optimsation gameweeks.\n", "Please run 'airsenal_run_prediction' first with the", "same input gameweeks and season you specified here.", ) sys.exit(1) algorithm = args.algorithm num_iterations = args.num_iterations num_generations = args.num_generations population_size = args.population_size remove_zero = not args.include_zero verbose = args.verbose if args.no_subs: sub_weights = {"GK": 0, "Outfield": (0, 0, 0)} else: sub_weights = {"GK": 0.01, "Outfield": (0.4, 0.1, 0.02)} if algorithm == "genetic": try: import pygmo as pg uda = pg.sga(gen=num_generations) except ModuleNotFoundError as e: print(e) print("Defaulting to algorithm=normal instead") algorithm = "normal" uda = None else: uda = None best_squad = make_new_squad( gw_range, tag, budget=budget, season=season, algorithm=algorithm, remove_zero=remove_zero, sub_weights=sub_weights, uda=uda, population_size=population_size, num_iterations=num_iterations, verbose=verbose, ) if best_squad is None: raise RuntimeError( "best_squad is None: make_new_squad failed to generate a valid team or " "something went wrong with the squad expected points calculation." ) points = best_squad.get_expected_points(gw_start, tag) print("---------------------") print("Best expected points for gameweek {}: {}".format(gw_start, points)) print("---------------------") print(best_squad) fpl_team_id = args.fpl_team_id or fetcher.FPL_TEAM_ID fill_initial_suggestion_table( best_squad, fpl_team_id, tag, season=season, gameweek=gw_start, )
def sga(objective_function, gen=200, cr=0.9, eta_c=1.0, m=0.02, param_m=1.0, param_s=2, crossover='exponential', mutation='polynomial', selection='tournament', pop_size=15): """ Parameters - gen (int) – number of generations. - cr (float) – crossover probability. - eta_c (float) – distribution index for sbx crossover. This parameter is inactive if other types of crossover are selected. - m (float) – mutation probability. - param_m (float) – distribution index (polynomial mutation), gaussian width (gaussian mutation) or inactive (uniform mutation) - param_s (float) – the number of best individuals to use in “truncated” selection or the size of the tournament in tournament selection. - crossover (str) – the crossover strategy. One of exponential, binomial, single or sbx - mutation (str) – the mutation strategy. One of gaussian, polynomial or uniform. - selection (str) – the selection strategy. One of tournament, “truncated”. """ logs = [] problem = pg.problem(objective_function) algorithm = pg.algorithm( pg.sga(gen=gen, cr=cr, eta_c=eta_c, m=m, param_m=param_m, param_s=param_s, crossover=crossover, mutation=mutation, selection=selection)) algorithm.set_verbosity(50) population = pg.population(prob=problem, size=pop_size) solution = algorithm.evolve(population) """ get_logs output is a list of tuples with the following structure: - Gen (int), generation number - Fevals (int), number of functions evaluation made - Best (float), the best fitness function currently in the population - dx (float), the norm of the distance to the population mean of the mutant vectors - df (float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual - sigma (float), the current step-size """ logs = np.array(algorithm.extract(pg.sga).get_log())[:, ( 1, 2)] # taking only function evaluations and best fitness algo_ = algorithm.get_name() function_ = objective_function.get_name() return { 'champion solution': solution.champion_f, 'champion coordinates': solution.champion_x, 'log': logs, 'algorithm': algo_, 'problem': function_ }
import pygmo as pg from pygmo import sga # Maksimum generations of a run MAXGEN = 1000 # Mutation probability pm = 0.5 # Crossover probability cm = 0.3 # User defined algorithm (UDA) algo = pg.algorithm(sga(gen=MAXGEN, cr=cm, m=pm, selection='truncated'))