def nn_opt(self, nn): with torch.no_grad(): def obj_cons(x): tx = torch.tensor(x) out = nn(tx) return out[:self.nobj].numpy().tolist(), out[self.nobj:].numpy( ).tolist() def obj_ucons(x): tx = torch.tensor(x) return nn(tx).numpy().tolist() arch = Archive() if self.ncons == 0: prob = Problem(self.dim, self.nobj) prob.function = obj_ucons else: prob = Problem(self.dim, self.nobj, self.ncons) prob.function = obj_cons prob.constraints[:] = "<=0" prob.types[:] = [Real(self.lb, self.ub) for i in range(self.dim)] self.algo = NSGAII(prob, population=50, archive=arch) self.algo.run(5000) optimized = self.algo.result rand_idx = np.random.randint(len(optimized)) suggested_x = torch.tensor(optimized[rand_idx].variables) suggested_y = nn(suggested_x) return suggested_x.view(-1, self.dim), suggested_y.view( -1, self.nobj + self.ncons)
def fit(self, x, y, bound=None, name=None): self.y = np.array(y) self.x = x TS = 1 ND = len(y) - 1 y = y / self.N t_start = 0.0 t_end = ND t_inc = TS t_range = np.arange(t_start, t_end + t_inc, t_inc) Model_Input = (self.S0, self.I0, self.R0) # GA Parameters number_of_generations = 1000 ga_population_size = 100 number_of_objective_targets = 1 # The MSE number_of_constraints = 0 number_of_input_variables = 2 # beta and gamma problem = Problem(number_of_input_variables, number_of_objective_targets, number_of_constraints) problem.function = functools.partial(self.fitness_function, y=y, Model_Input=Model_Input, t_range=t_range) algorithm = NSGAII(problem, population_size=ga_population_size) problem.types[0] = Real(0, 1) # beta initial Range problem.types[1] = Real(1 / 5, 1 / 14) # gamma initial Range # Running the GA algorithm.run(number_of_generations) feasible_solutions = [s for s in algorithm.result if s.feasible] self.beta = feasible_solutions[0].variables[0] self.gamma = feasible_solutions[0].variables[1] input_variables = ['beta', 'gamma'] file_address = 'optimised_coefficients/' filename = "ParametrosAjustados_Modelo_{}_{}_{}_Dias.txt".format( 'SIR_EDO', name, len(x)) if not os.path.exists(file_address): os.makedirs(file_address) file_optimised_parameters = open(file_address + filename, "w") file_optimised_parameters.close() if not os.path.exists(file_address): os.makedirs(file_address) with open(file_address + filename, "a") as file_optimised_parameters: for i in range(len(input_variables)): message = '{}:{:.4f}\n'.format( input_variables[i], feasible_solutions[0].variables[i]) file_optimised_parameters.write(message)
def Pareto_Front_Strategy(Probs, odds, Total_BetMax, Max_individual_bet, Min_individual_bet): #NOTE: The order of bets and Probs is as follows: 1st (1) is AWAY win and 2nd (2) is HOME win Bets = np.argmax(Probs, 1) + 1 n = len(Probs) #number of games # Calculate probabilities for ALL the events together (i.e. each outcome). This will be used as weights for our optimisation k = n num_events = int(pow(2, n)) Event_Probs = np.zeros(num_events) outc = outcomes_HACK(n) for i in range(num_events): individual_probs = np.diag(Probs[:, outc[i, :] - 1]) Event_Probs[i] = PoissonBinomialPDF(k, n, individual_probs) #Pareto optimization problem = Problem(n, 2, 1) #vars, problem dim, constraints problem.types[:] = Real( Min_individual_bet, Max_individual_bet) #lower and upper bounds for all decision variables problem.function = functools.partial(ExpectationRisk, arg1=n, arg2=odds, arg3=Event_Probs, arg4=Bets, arg5=outc) problem.constraints[:] = "<=" + str( Total_BetMax ) + "" #inequality constraints: sum of bets no more than BetMax algorithm = NSGAII(problem) algorithm.run(5000) plt.scatter([s.objectives[0] for s in algorithm.result], [s.objectives[1] for s in algorithm.result]) plt.show() Stakes = [] Ratio = 0 for i in range(len(algorithm.result)): #objectives are: -data[0] = Expectation, data[1] = Variance #Exp/Variance ration threshold Exp = algorithm.result[i].objectives._data[0] Var = algorithm.result[i].objectives._data[1] curRatio = Exp / Var if curRatio > Ratio: Ratio = curRatio Stakes = algorithm.result[i].variables ExpOut = Exp VarOut = Var return (Stakes, Bets, ExpOut, VarOut)
def update(self, **kwargs): """ Rewrite update """ assert 'X' in kwargs and 'Y' in kwargs assert 'eta' in kwargs and 'num_data' in kwargs super(USeMO, self).update(**kwargs) self.X_dim = self.X.shape[1] self.Y_dim = self.Y.shape[1] assert self.Y_dim > 1 # update single acquisition function for i in range(self.Y_dim): self.single_acq[i].update(model=self.model[i], eta=self.eta[i], num_data=self.num_data) self.uncertainty_acq[i].update(model=self.model[i], eta=self.eta[i], num_data=self.num_data) def CMO(x): x = np.asarray(x) # minimize negative acq return [ -self.single_acq[i](x, convert=False)[0][0] for i in range(self.Y_dim) ] problem = Problem(self.X_dim, self.Y_dim) set_problem_types(self.config_space, problem) problem.function = CMO variator = get_variator(self.config_space) algorithm = NSGAII(problem, population_size=100, variator=variator) algorithm.run(2500) # decode for s in algorithm.result: s.variables[:] = [ problem.types[i].decode(s.variables[i]) for i in range(problem.nvars) ] cheap_pareto_set = [ solution.variables for solution in algorithm.result ] # cheap_pareto_set_unique = [] # for i in range(len(cheap_pareto_set)): # if not any((cheap_pareto_set[i] == x).all() for x in self.X): # cheap_pareto_set_unique.append(cheap_pareto_set[i]) cheap_pareto_set_unique = cheap_pareto_set single_uncertainty = np.array([ self.uncertainty_acq[i](np.asarray(cheap_pareto_set_unique), convert=False) for i in range(self.Y_dim) ]) # shape=(Y_dim, N, 1) single_uncertainty = single_uncertainty.reshape(self.Y_dim, -1) # shape=(Y_dim, N) self.uncertainties = np.prod(single_uncertainty, axis=0) # shape=(Y_dim,) todo normalize? self.candidates = np.array(cheap_pareto_set_unique)
def make_platypus_objective_function_competing_function( self, sources, bad_sources=[]): total_ret_func = make_total_lookup_function( sources, interpolation_method=self.interpolation_method ) # the function to be optimized bad_sources_func = make_total_lookup_function( bad_sources, type="fastest", interpolation_method=self.interpolation_method ) # the function to be optimized def multiobjective_func(x): # this is the double objective function return [total_ret_func(x), bad_sources_func(x)] num_inputs = len(sources) * 2 # there is an x, y for each source NUM_OUPUTS = 2 # the default for now # define the demensionality of input and output spaces problem = Problem(num_inputs, NUM_OUPUTS) x, y, time = sources[0] # expand the first source min_x = min(x) min_y = min(y) max_x = max(x) max_y = max(y) print("min x : {}, max x : {}, min y : {}, max y : {}".format( min_x, max_x, min_y, max_y)) problem.types[::2] = Real(min_x, max_x) # This is the feasible region problem.types[1::2] = Real(min_y, max_y) problem.function = multiobjective_func # the second function should be maximized rather than minimized problem.directions[1] = Problem.MAXIMIZE return problem
def platypus_cube(objective, scale, n_trials, n_dim, strategy, with_count=False): global feval_count feval_count = 0 def _objective(vars): global feval_count feval_count += 1 return objective(list(vars))[0] problem = Problem(n_dim, 1, 0) problem.types[:] = [Real(-scale, scale)] * n_dim problem.constraints[:] = "<=0" problem.function = _objective algorithm = strategy(problem) algorithm.run(n_trials) feasible_solution_obj = [ s.objectives[0] for s in algorithm.result if s.feasible ] best_obj = min(feasible_solution_obj) return (best_obj, feval_count) if with_count else best_obj
def generate_initial_population(pop_size=10, number_of_gd_steps=50): p1 = GradientDescentAdam(R, lr=alpha) initial_pop = [] meta_g = None vec_len = None for x in range(pop_size): _, _, _, _, G, S = p1.optimize(number_of_gd_steps, ks=ks) v, meta = roll(G, S) meta_g = meta vec_len = len(v) initial_pop.append(v.tolist()) problem = Problem(vec_len, 1) problem.types[:] = Real(0, 1000) problem.function = partial(fit, p1, meta_g) generator = RandomGenerator() population = [] for i in range(pop_size): p = generator.generate(problem) p.variables = initial_pop[i] problem.evaluate(p) population.append(p) return problem, population, meta_g, generator
def project(): conn = sqlite3.connect('products.db') companies = get_companies(conn) problem = Problem(len(companies), 2) #problem.types[:] = [Integer(1, nlojas) for _ range(nprodutos)] problem.function = schaffer algorithm = NSGAII(problem) algorithm.run(10000) company = 0 while (company < len(companies)): result = schaffer(companies[company][0], conn) print(result) company += 1 conn.close() plt.scatter([s.objectives[0] for s in algorithm.result], [s.objectives[1] for s in algorithm.result]) plt.xlim([0, 1.1]) plt.ylim([0, 1.1]) plt.xlabel("Preço") plt.ylabel("Distancia") plt.show()
def make_platypus_objective_function_counting(self, sources, times_more_detectors=1): """ This balances the number of detectors with the quality of the outcome """ total_ret_func = make_total_lookup_function( sources, masked=True) # the function to be optimized counting_func = make_counting_objective() def multiobjective_func(x): # this is the double objective function return [total_ret_func(x), counting_func(x)] # there is an x, y, and a mask for each source so there must be three # times more input variables # the upper bound on the number of detectors n times the number of # sources num_inputs = len(sources) * 3 * times_more_detectors NUM_OUPUTS = 2 # the default for now # define the demensionality of input and output spaces problem = Problem(num_inputs, NUM_OUPUTS) x, y, time = sources[0] # expand the first source min_x = min(x) min_y = min(y) max_x = max(x) max_y = max(y) print("min x : {}, max x : {}, min y : {}, max y : {}".format( min_x, max_x, min_y, max_y)) problem.types[0::3] = Real(min_x, max_x) # This is the feasible region problem.types[1::3] = Real(min_y, max_y) # This appears to be inclusive, so this is really just (0, 1) problem.types[2::3] = Binary(1) problem.function = multiobjective_func return problem
def platypus_cube(objective, n_trials, n_dim, with_count=False, method=None): global feval_count feval_count = 0 def _objective(vars): global feval_count feval_count += 1 return float(objective( list(vars))) # Avoid np.array as Platypus may puke problem = Problem(n_dim, 1, 0) problem.types[:] = [Real(0.0, 1.0)] * n_dim problem.constraints[:] = "<=0" problem.function = _objective strategy_and_args = PLATYPUS_ALGORITHMS[method] if isinstance(strategy_and_args, tuple): strategy = strategy_and_args[0] strategy_args = strategy_and_args[1] algorithm = strategy(problem, **strategy_args) else: strategy = strategy_and_args algorithm = strategy(problem) algorithm.run(n_trials) feasible_solution_obj = sorted([(s.objectives[0], s.variables) for s in algorithm.result if s.feasible], reverse=False) best_obj, best_x = feasible_solution_obj[0] if isinstance(best_x, FixedLengthArray): best_x = best_x._data # CMA-ES returns it this way for some reason return (best_obj, best_x, feval_count) if with_count else (best_obj, best_x)
def autoIterate(model, river, reach, rs, flow, stage, nct, plot, outf, metrics, correctDatum, evals=None, si=False): """ Automatically iterate with NSGA-II """ keys = metrics # ensure same order evalf = evaluator(stage, useTests=keys, correctDatum=correctDatum) evals = int( input("How many evaluations to run? ")) if evals is None else evals plotpath = ".".join(outf.split(".")[:-1]) + ".png" count = 1 print("Running automatic calibration") def manningEval(vars): n = vars[0] metrics = minimized( nstageSingleRun(model, river, reach, rs, stage, n, keys, correctDatum)) values = [metrics[key] for key in keys] constraints = [-n, n - 1] nonlocal count print("Completed %d evaluations" % count) count += 1 return values, constraints c_type = "<0" problem = Problem( 1, len(keys), 2) # 1 decision variable, len(keys) objectives, and 2 constraints problem.types[:] = Real(0.001, 1) # range of decision variable problem.constraints[:] = c_type problem.function = manningEval algorithm = NSGAII(problem, population_size=nct) algorithm.run(evals) nondom = nondominated( algorithm.result ) # nondom: list of Solutions - wanted value is variables[0] nondomNs = [sol.variables[0] for sol in nondom] results = runSims(model, nondomNs, river, reach, len(stage), range=[rs]) resultPts = [(nondomNs[ix], [results[ix][rs][jx] for jx in range(1, len(stage) + 1)]) for ix in range(len(nondomNs))] metrics = [(res[0], evalf(res[1]), res[1]) for res in resultPts] nDisplay(metrics, flow, stage, plotpath, outf, plot, correctDatum, si) return metrics
def generate_problem(self): # 1 decision variables, 1 objectives, 2 constraints problem = Problem(1, 1, 2) problem.types[:] = Binary(len(self.requirements)) problem.directions[:] = Problem.MAXIMIZE problem.constraints[0] = "!=0" problem.constraints[1] = "<=0" problem.function = self.get_problem_function return problem
def so_run(population_size): so_problem = Problem(1, 1, 1) so_problem.types[:] = Binary(len(requirements)) so_problem.directions[:] = Problem.MAXIMIZE so_problem.constraints[:] = "<={}".format(budget) so_problem.function = single_objective_nrp so_algorithm = GeneticAlgorithm(so_problem, population_size) so_algorithm.run(runs) x_so = [solution.objectives[0] for solution in so_algorithm.result] y_so = [solution.constraints[0] * (-1) for solution in so_algorithm.result] return x_so, y_so, so_algorithm
def mo_run(population_size): mo_problem = Problem(2, 2, 2) mo_problem.types[:] = Binary(len(requirements)) mo_problem.directions[0] = Problem.MAXIMIZE mo_problem.directions[1] = Problem.MINIMIZE mo_problem.constraints[:] = "<={}".format(budget) mo_problem.function = multi_objective_nrp mo_nsga = NSGAII(mo_problem, population_size) mo_nsga.run(runs) x_mo = [solution.objectives[0] for solution in mo_nsga.result] y_mo = [solution.objectives[1] * (-1) for solution in mo_nsga.result] return x_mo, y_mo, mo_nsga
def update(self, **kwargs): """ Rewrite update to support pareto front sampling. """ assert 'X' in kwargs and 'Y' in kwargs assert 'constraint_perfs' in kwargs super(MESMOC, self).update(**kwargs) self.X_dim = self.X.shape[1] self.Y_dim = self.Y.shape[1] self.Multiplemes = [None] * self.Y_dim self.Multiplemes_constraints = [None] * self.num_constraints for i in range(self.Y_dim): self.Multiplemes[i] = MaxvalueEntropySearch(self.model[i], self.X, self.Y[:, i], random_state=self.random_state) self.Multiplemes[i].Sampling_RFM() for i in range(self.num_constraints): # Caution dim of self.constraint_perfs! self.Multiplemes_constraints[i] = MaxvalueEntropySearch(self.constraint_models[i], self.X, self.constraint_perfs[i]) self.Multiplemes_constraints[i].Sampling_RFM() self.min_samples = [] self.min_samples_constraints = [] for j in range(self.sample_num): for i in range(self.Y_dim): self.Multiplemes[i].weigh_sampling() for i in range(self.num_constraints): self.Multiplemes_constraints[i].weigh_sampling() def CMO(xi): xi = np.asarray(xi) y = [self.Multiplemes[i].f_regression(xi)[0][0] for i in range(self.Y_dim)] y_c = [self.Multiplemes_constraints[i].f_regression(xi)[0][0] for i in range(self.num_constraints)] return y, y_c problem = Problem(self.X_dim, self.Y_dim, self.num_constraints) for k in range(self.X_dim): problem.types[k] = Real(self.bounds[k][0], self.bounds[k][1]) # todo other types problem.constraints[:] = "<=0" # todo confirm problem.function = CMO algorithm = NSGAII(problem) algorithm.run(1500) cheap_pareto_front = [list(solution.objectives) for solution in algorithm.result] cheap_constraints_values = [list(solution.constraints) for solution in algorithm.result] # picking the min over the pareto: best case min_of_functions = [min(f) for f in list(zip(*cheap_pareto_front))] min_of_constraints = [min(f) for f in list(zip(*cheap_constraints_values))] # todo confirm self.min_samples.append(min_of_functions) self.min_samples_constraints.append(min_of_constraints)
def _prune(self): problem = Problem(len(self.ensemble_), 2) problem.types[:] = Integer(0, 1) problem.directions[0] = Problem.MAXIMIZE problem.directions[1] = Problem.MAXIMIZE problem.function = functools.partial(MCE._evaluate_imbalance, y_predicts=self._y_predict, y_true=self._y_valid) algorithm = NSGAII(problem) algorithm.run(10000) solutions = unique(nondominated(algorithm.result)) objectives = [sol.objectives for sol in solutions] def extract_variables(variables): extracted = [v[0] for v in variables] return extracted self._ensemble_quality = self.get_group( extract_variables(solutions[objectives.index( max(objectives, key=itemgetter(0)))].variables), self.ensemble_) self._ensemble_diversity = self.get_group( extract_variables(solutions[objectives.index( max(objectives, key=itemgetter(1)))].variables), self.ensemble_) self._ensemble_balanced = self.get_group( extract_variables(solutions[objectives.index( min(objectives, key=lambda i: abs(i[0] - i[1])))].variables), self.ensemble_) pareto_set, fitnesses = self._genetic_optimalisation( optimalisation_type='quality_single') self._ensemble_quality_single = self.get_group( pareto_set[fitnesses.index(max(fitnesses, key=itemgetter(0)))], self.ensemble_) # pareto_set, fitnesses = self._genetic_optimalisation(optimalisation_type='diversity_single') # self._ensemble_diversity_single = self.get_group(pareto_set[fitnesses.index(min(fitnesses, key=itemgetter(0)))], # self.ensemble_) pareto_set, fitnesses = self._genetic_optimalisation( optimalisation_type='precision_single') self._ensemble_precision_single = self.get_group( pareto_set[fitnesses.index(max(fitnesses, key=itemgetter(0)))], self.ensemble_) pareto_set, fitnesses = self._genetic_optimalisation( optimalisation_type='recall_single') self._ensemble_recall_single = self.get_group( pareto_set[fitnesses.index(max(fitnesses, key=itemgetter(0)))], self.ensemble_)
def cal(args, exeCount): start = time.time() param_count = 5 # パラメーター数 problem = Problem(param_count, 2) # 最適化パラメータの数, 目的関数の数 problem.types[:] = Real(-2.0, 2.0) # パラメータの範囲 problem.function = schaffer algorithm = NSGAII(problem) algorithm.run(5000) # 反復回数 print('{:-^63}'.format('-')) # データ整理 # params: 係数a # f1s : 残留振動 [deg] # f2s : エネルギー params = np.empty([100, param_count]) f1s = np.empty([100]) f2s = np.empty([100]) for i, solution in enumerate(algorithm.result): result = tuple(solution.variables \ + solution.objectives[:]) params[i, :] = result[:param_count][:] f1s[i] = 180 * result[param_count] / np.pi f2s[i] = result[param_count + 1] # 残留振動が最小になるaの値を表示 index = np.argmin(f1s) print('\n*** 残留振動が最小の時の各値 ***') print('残留振動[deg]\t{}'.format(f1s[index])) print('エネルギー[J]\t{}'.format(f2s[index])) print('係数a\t\t{}'.format(params[index, :])) np.savetxt('./results/nsga2/{}/nsga2_params_{}.csv'.format( args[1], exeCount), params[index, :], delimiter=',') # 経過時間 print(f'\nelapsed time: {time.time()-start}') # 係数a, 残留振動, エネルギーをCSVファイルに書き出す data = np.empty([100, param_count + 2]) data[:, 0:param_count] = params data[:, param_count] = f1s data[:, param_count + 1] = f2s np.savetxt('./results/nsga2/{}/nsga2_data_{}.csv'.format( args[1], exeCount), data, delimiter=',')
def build_problems(self): self.us = [self.u1, self.u2, self.u3] self.ws = [self.w1, self.w2, self.w3] temp = sum(self.used_components) if temp == 1: return self.defuzz_not_none() u_problem, w_problem = Problem(1, temp), Problem(1, temp) u_universe, w_universe = self.universe_not_none() u_problem.types[:] = Subset(u_universe, 1) w_problem.types[:] = Subset(w_universe, 1) u_problem.directions[:] = Problem.MAXIMIZE w_problem.directions[:] = Problem.MAXIMIZE u_problem.function, w_problem.function = self.u_function, self.w_function return u_problem, w_problem
def run_nsgaii_bc(): def CMO(xi): xi = np.asarray(xi) y = [branin(xi), Currin(xi)] return y problem = Problem(2, 2) problem.types[:] = Real(0, 1) problem.function = CMO algorithm = NSGAII(problem) algorithm.run(2500) cheap_pareto_front = np.array( [list(solution.objectives) for solution in algorithm.result]) return cheap_pareto_front
def generate_initial_population(number_of_gd_steps=50): p1 = GradientDescentAdam(R, lr=alpha) initial_pop = [] scale = 0.01 noise_scale=0.0000001 Gv, Sv = p1.construct_starting_point(ks, scale=scale) _, _, _, _, G, S = p1.optimize(G=Gv.copy(), S=Sv.copy(), steps=number_of_gd_steps, ks=ks) v, meta = roll(G, S) initial_pop.append(v.tolist()) GvNoise = [] for x in Gv: GvNoise.append(x+np.random.randn(*x.shape)*noise_scale) SvNoise = [] for x in Sv: n=[] for y in x: n.append(y+np.random.randn(*y.shape)*noise_scale) SvNoise.append(n) _, _, _, _, G, S = p1.optimize(G=GvNoise.copy(), S=SvNoise.copy(), steps=number_of_gd_steps, ks=ks) v, meta = roll(G, S) initial_pop.append(v.tolist()) np.random.rand() _, _, _, _, G, S = p1.optimize(number_of_gd_steps, ks=ks) v, meta = roll(G, S) meta_g = meta vec_len = len(v) initial_pop.append(v.tolist()) problem = Problem(vec_len, 1) problem.types[:] = Real(0, 1000) problem.function = partial(fit, p1, meta_g) generator = RandomGenerator() population = [] for i in range(3): p = generator.generate(problem) p.variables = initial_pop[i] problem.evaluate(p) population.append(p) return problem, population, meta_g, p1
def update(self, **kwargs): """ Rewrite update to support pareto front sampling. """ assert 'X' in kwargs and 'Y' in kwargs super(MESMO, self).update(**kwargs) self.X_dim = self.X.shape[1] self.Y_dim = self.Y.shape[1] self.Multiplemes = [None] * self.Y_dim for i in range(self.Y_dim): self.Multiplemes[i] = MaxvalueEntropySearch( self.model[i], self.X, self.Y[:, i], random_state=self.rng.randint(10000)) self.Multiplemes[i].Sampling_RFM() self.min_samples = [] for j in range(self.sample_num): for i in range(self.Y_dim): self.Multiplemes[i].weigh_sampling() def CMO(xi): xi = np.asarray(xi) y = [ self.Multiplemes[i].f_regression(xi)[0][0] for i in range(self.Y_dim) ] return y problem = Problem(self.X_dim, self.Y_dim) set_problem_types(self.config_space, problem) problem.function = CMO variator = get_variator(self.config_space) algorithm = NSGAII(problem, population_size=100, variator=variator) algorithm.run(1500) cheap_pareto_front = [ list(solution.objectives) for solution in algorithm.result ] # picking the min over the pareto: best case min_of_functions = [min(f) for f in list(zip(*cheap_pareto_front))] self.min_samples.append(min_of_functions)
def platypus_cube(objective,scale, n_trials, strategy): def _objective(vars): u1 = vars[0] u2 = vars[1] u3 = vars[2] return objective([u1,u2,u3])[0] problem = Problem(3, 1, 0) problem.types[:] = [Real(-scale, scale), Real(-scale, scale), Real(-scale, scale)] problem.constraints[:] = "<=0" problem.function = _objective algorithm = strategy(problem) algorithm.run(n_trials) feasible_solution_obj = [s.objectives[0] for s in algorithm.result if s.feasible] best_obj = min(feasible_solution_obj) return best_obj
def make_multiobjective_function_counting(sources, bounds, times_more_detectors=1, interpolation_method="nearest"): """ This balances the number of detectors with the quality of the outcome bounds : list[(x_min, x_max), (y_min, y_max), ...] The bounds on the feasible region """ objective_function = make_single_objective_function( sources, interpolation_method=interpolation_method, masked=True) # the function to be optimized counting_function = make_counting_objective() def multiobjective_func(x): # this is the double objective function return [objective_function(x), counting_function(x)] # there is an x, y, and a mask for each source so there must be three # times more input variables # the upper bound on the number of detectors n times the number of # sources parameterized_locations = sources[0].parameterized_locations dimensionality = parameterized_locations.shape[1] # We add a boolean flag to each location variable num_inputs = len(sources) * (dimensionality + 1) * times_more_detectors NUM_OUPUTS = 2 # the default for now # define the demensionality of input and output spaces problem = Problem(num_inputs, NUM_OUPUTS) logging.warning( f"Creating a multiobjective counting function with dimensionality {dimensionality}" ) logging.warning(f"bounds are {bounds}") for i in range(dimensionality): # splat "*" notation is expanding the pair which is low, high problem.types[i::(dimensionality + 1)] = Real( *bounds[i]) # This is the feasible region # indicator on whether the source is on problem.types[dimensionality::(dimensionality + 1)] = Binary(1) problem.function = multiobjective_func return problem
def update(self, **kwargs): """ Rewrite update """ assert 'X' in kwargs and 'Y' in kwargs assert 'eta' in kwargs and 'num_data' in kwargs super(USeMO, self).update(**kwargs) self.X_dim = self.X.shape[1] self.Y_dim = self.Y.shape[1] assert self.Y_dim > 1 # update single acquisition function for i in range(self.Y_dim): self.single_acq[i].update(model=self.model[i], eta=self.eta[i], num_data=self.num_data) self.uncertainty_acq[i].update(model=self.model[i], eta=self.eta[i], num_data=self.num_data) def CMO(x): x = np.asarray(x) # minimize negative acq return [-self.single_acq[i](x, convert=False)[0][0] for i in range(self.Y_dim)] problem = Problem(self.X_dim, self.Y_dim) for k in range(self.X_dim): problem.types[k] = Real(self.bounds[k][0], self.bounds[k][1]) # todo other types problem.function = CMO algorithm = NSGAII(problem) # todo population_size algorithm.run(2500) cheap_pareto_set = [solution.variables for solution in algorithm.result] # cheap_pareto_set_unique = [] # for i in range(len(cheap_pareto_set)): # if not any((cheap_pareto_set[i] == x).all() for x in self.X): # todo convert problem? no this step? # cheap_pareto_set_unique.append(cheap_pareto_set[i]) cheap_pareto_set_unique = cheap_pareto_set single_uncertainty = np.array([self.uncertainty_acq[i](np.asarray(cheap_pareto_set_unique), convert=False) for i in range(self.Y_dim)]) # shape=(Y_dim, N, 1) single_uncertainty = single_uncertainty.reshape(self.Y_dim, -1) # shape=(Y_dim, N) self.uncertainties = np.prod(single_uncertainty, axis=0) # shape=(Y_dim,) todo normalize? self.candidates = np.array(cheap_pareto_set_unique)
def NSGA_test(data_name, input_dim, output_dim, x_bounds, epoch, population): """ bench_mark functionのjson "function_name":{ "hypervolume":, "v_ref":[], "w_ref":[], "x_bounds":[], "input_dim":, "output_dim": } """ problem = Problem(input_dim, output_dim) problem.types[:] = [ Real(x_bounds[i][0], x_bounds[i][1]) for i in range(input_dim) ] problem.function = eval(data_name) algorithm = NSGAII(problem, population_size=population) start = time.perf_counter() algorithm.run(epoch) end = time.perf_counter() - start v_ref = [] w_ref = [] w_ref_norm = [] print(len(algorithm.result)) pareto_frontier = np.zeros((len(algorithm.result), output_dim)) pareto_frontier_norm = np.zeros((len(algorithm.result), output_dim)) for i in range(output_dim): frontier_i = np.array([s.objectives[i] for s in algorithm.result]) pareto_frontier[:, i] = frontier_i min_i = np.min(frontier_i) max_i = np.max(frontier_i) frontier_i_norm = (frontier_i - min_i) / (max_i - min_i) pareto_frontier_norm[:, i] = frontier_i_norm v_ref.append(min_i) w_ref.append(max_i) w_ref_norm.append(1) hyp = Hypervolume(minimum=v_ref, maximum=w_ref) HV = hyp(algorithm.result) return HV, end
def make_multiobjective_function_competing(sources, bounds=None, bad_sources=(), interpolation_method="nearest"): """Create an objective function with a false alarm""" # Create the two functions objective_function = make_single_objective_function( sources, interpolation_method=interpolation_method ) # the function to be optimized bad_objective_function = make_single_objective_function( bad_sources, function_type="worst_case_TTA", interpolation_method=interpolation_method ) # the function to be optimized def multiobjective_func(x): # this is the double objective function return [objective_function(x), bad_objective_function(x)] parameterized_locations = sources[0].parameterized_locations dimensionality = parameterized_locations.shape[1] num_inputs = len(sources) * dimensionality NUM_OUPUTS = 2 # the default for now # define the demensionality of input and output spaces problem = Problem(num_inputs, NUM_OUPUTS) logging.warning( f"Creating a multiobjective competing function with dimensionality {dimensionality}" ) logging.warning(f"bounds are {bounds}") for i in range(dimensionality): # splat "*" notation is expanding the pair which is low, high problem.types[i::dimensionality] = Real( *bounds[i]) # This is the feasible region problem.function = multiobjective_func # the second function should be maximized rather than minimized problem.directions[1] = Problem.MAXIMIZE return problem
def platypus_grid(w_, garden_index, grids): # first compute convex hull of grids # parametrize problem by just the center of the grid points_list = [] for i in range(grids.shape[0]): p = Point(grids[i, :]) points_list.append(p) mtp = MultiPoint(points_list) cvx_hull = mtp.convex_hull gminx, gminy, gmaxx, gmaxy = cvx_hull.bounds problem = Problem(3, 2) problem.types[0] = Real(gminx, gmaxx) problem.types[1] = Real(gminy, gmaxy) problem.types[2] = Real(0, 180) problem.function = platypus_obj algorithm = NSGAII(problem) algorithm.run(100) print(algorithm.result) return algorithm.result
def get_currentratio(data_name, pareto_front_list, w_ref, input_dim, output_dim, x_bounds): problem = Problem(input_dim, output_dim) problem.types[:] = [ Real(x_bounds[i][0], x_bounds[i][1]) for i in range(input_dim) ] problem.function = eval(data_name) algorithm = NSGAII(problem, population_size=50) algorithm.run(10000) true_pareto_front = np.zeros((len(algorithm.result), output_dim)) for i in range(len(algorithm.result)): true_pareto_front[i, :] = algorithm.result[i].objectives[:] # print(true_pareto_front) true_w_ref = np.max(true_pareto_front, axis=0) + 1.0e-2 for i in range(w_ref.shape[0]): if true_w_ref[i] > w_ref[i]: w_ref[i] = true_w_ref[i] true_HV = utils.calc_hypervolume(true_pareto_front, w_ref) ratio_list = [] for pareto_front in pareto_front_list: hv_i = utils.calc_hypervolume(pareto_front, w_ref) ratio_list.append(hv_i / true_HV) return ratio_list
from platypus import GeneticAlgorithm, Problem, Constraint, Binary, nondominated, unique # This simple example has an optimal value of 15 when picking items 1 and 4. items = 7 capacity = 9 weights = [2, 3, 6, 7, 5, 9, 4] profits = [6, 5, 8, 9, 6, 7, 3] def knapsack(x): selection = x[0] total_weight = sum([weights[i] if selection[i] else 0 for i in range(items)]) total_profit = sum([profits[i] if selection[i] else 0 for i in range(items)]) return total_profit, total_weight problem = Problem(1, 1, 1) problem.types[0] = Binary(items) problem.directions[0] = Problem.MAXIMIZE problem.constraints[0] = Constraint("<=", capacity) problem.function = knapsack algorithm = GeneticAlgorithm(problem) algorithm.run(10000) for solution in unique(nondominated(algorithm.result)): print(solution.variables, solution.objectives)
c = c1 + [c2] + [c3] return [f], c take_input() dic = {} for rmax__ in frange(0, rmaxi, 0.01): for bmax__ in frange(0, bmaxi, 0.01): from platypus import NSGAII, Problem, Real global rmax, bmax rmax, bmax = rmax__, bmax__ problem = Problem(5, 1, n + 2) problem.types[:] = Real(0, 2000) problem.constraints[:] = "<=0" problem.function = belegundu algorithm = NSGAII(problem) algorithm.run(100 * 100) index = np.argmax(algorithm.result) dic[algorithm.result[index]. objectives[0]] = algorithm.result[index].variables print "============== OUTPUTS ==============" ''' print 'Solution:' for solution in algorithm.result: print(solution.objectives), solution.variables '''
def fit(self, X, y): opt_start_time = time.time() kfold = None if isinstance(self.cv, int) and self.cv == 1: X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=0.2, random_state=self.random_seed, stratify=y) logger.info("Not using Cross-Validation. " "Performing single train/test split") else: is_clf = self.model.is_classifier() kfold = check_cv(self.cv, y=y, classifier=is_clf) # kfold = StratifiedKFold( # n_splits=self.cv, random_state=self.random_seed, shuffle=True # ) logger.info(f"Using Cross-Validation - {kfold}") self.ind = 0 def train_test_model(parameter): # First check if we exceeded allocated time budget current_time = time.time() elapsed_time = current_time - opt_start_time if (self.max_opt_time is not None) and (elapsed_time > self.max_opt_time): msg = ( f"Max optimization time exceeded. " f"Max Opt time = {self.max_opt_time}, Elapsed Time = {elapsed_time}, " f"NFE Completed - {self.ind}") raise MaxBudgetExceededException(msg) self.ind = self.ind + 1 logger.info(f"Training population {self.ind}") parameter = self.param_to_dict( parameter, self.model_helper.param_choices, self.model_helper.param_categories, self.model_helper.param_type, ) scorers = [get_scorer(scorer) for scorer in self.scoring] nscorers = len(scorers) try: if kfold is None: clf = self.model_helper.create_instance(parameter) clf_trained = clf.fit(X_train, y_train) obj_val = [ scorer(clf_trained, X_val, y_val) for scorer in scorers ] else: obj_scores = [[] for _ in range(nscorers)] # Perform k-fold cross-validation for train_index, test_index in kfold.split(X, y): if isinstance(X, pd.DataFrame): X_train_split, X_val_split = ( X.iloc[train_index], X.iloc[test_index], ) y_train_split, y_val_split = ( y.iloc[train_index], y.iloc[test_index], ) else: X_train_split, X_val_split = X[train_index], X[ test_index] y_train_split, y_val_split = y[train_index], y[ test_index] clf = self.model_helper.create_instance(parameter) clf_trained = clf.fit(X_train_split, y_train_split) obj_score = [ scorer(clf_trained, X_val_split, y_val_split) for scorer in scorers ] for i in range(nscorers): obj_scores[i].append(obj_score[i]) # Aggregate CV score obj_val = [np.mean(obj_scores[i]) for i in range(nscorers)] logger.debug(f"Obj k-fold scores - {obj_scores}") # By default we are solving a minimization MOO problem fitnessValue = [ self.best_score[i] - obj_val[i] for i in range(nscorers) ] logger.info(f"Train fitnessValue - {fitnessValue}") except jsonschema.ValidationError as e: logger.error(f"Caught JSON schema validation error.\n{e}") logger.error("Setting fitness (loss) values to infinity") fitnessValue = [np.inf for i in range(nscorers)] logger.info(f"Train fitnessValue - {fitnessValue}") return fitnessValue def time_check_callback(alg): current_time = time.time() elapsed_time = current_time - opt_start_time logger.info( f"NFE Complete - {alg.nfe}, Elapsed Time - {elapsed_time}") parameter_num = len(self.model_helper.param_choices) target_num = len(self.scoring) # Adjust max_evals if not a multiple of population size. This is # required as Platypus performs evaluations in multiples of # population_size. adjusted_max_evals = (self.max_evals // self.population_size) * self.population_size if adjusted_max_evals != self.max_evals: logger.info( f"Adjusting max_evals to {adjusted_max_evals} from specified {self.max_evals}" ) problem = Problem(parameter_num, target_num) problem.types[:] = self.model_helper.types problem.function = train_test_model # Set the variator based on types of decision variables varg = {} first_type = problem.types[0].__class__ all_type_same = all([isinstance(t, first_type) for t in problem.types]) # use compound operator for mixed types if not all_type_same: varg["variator"] = CompoundOperator(SBX(), HUX(), PM(), BitFlip()) algorithm = NSGAII( problem, population_size=self.population_size, **varg, ) try: algorithm.run(adjusted_max_evals, callback=time_check_callback) except MaxBudgetExceededException as e: logger.warning( f"Max optimization time budget exceeded. Optimization exited prematurely.\n{e}" ) solutions = nondominated(algorithm.result) # solutions = [s for s in algorithm.result if s.feasible]` # solutions = algorithm.result moo_solutions = [] for solution in solutions: vars = [] for pnum in range(parameter_num): vars.append(problem.types[pnum].decode( solution.variables[pnum])) vars_dict = self.param_to_dict( vars, self.model_helper.param_choices, self.model_helper.param_categories, self.model_helper.param_type, ) moo_solutions.append(self.Soln(vars_dict, solution.objectives)) logger.info(f"{vars}, {solution.objectives}") self.moo_solutions = moo_solutions pareto_models = [] for solution in self.moo_solutions: est = self.model_helper.create_instance(solution.variables) est_trained = est.fit(X, y) pareto_models.append((solution.variables, est_trained)) self.pareto_models = pareto_models return self
import functools from platypus import NSGAII, Problem, Real def problem_with_args(x, arg1, arg2=5): print("x:", x) print("arg1:", arg1) print("arg2:", arg2) return [x[0]**2, (x[0]-2)**2] problem = Problem(1, 2) problem.types[:] = Real(-10, 10) problem.function = functools.partial(problem_with_args, arg1=2) algorithm = NSGAII(problem) algorithm.run(100)
from platypus import NSGAII, Problem, Real def schaffer(x): return [x[0]**2, (x[0]-2)**2] problem = Problem(1, 2) problem.types[:] = Real(-10, 10) problem.function = schaffer algorithm = NSGAII(problem) algorithm.run(10000)
from platypus import NSGAII, Problem, Real def belegundu(vars): x = vars[0] y = vars[1] return [-2*x + y, 2*x + y], [-x + y - 1, x + y - 7] problem = Problem(2, 2, 2) problem.types[:] = [Real(0, 5), Real(0, 3)] problem.constraints[:] = "<=0" problem.function = belegundu algorithm = NSGAII(problem) algorithm.run(10000)
(4493, 7102), (3600, 6950), (3100, 7250), (4700, 8450), (5400, 8450), (5610, 10053), (4492, 10052), (3600, 10800), (3100, 10950), (4700, 11650), (5400, 11650), (6650, 10800), (7300, 10950), (7300, 7250), (6650, 6950), (7300, 3300), (6650, 2300), (5400, 1600), (8350, 2300), (7850, 3300), (9450, 5750), (10150, 5750), (10358, 7103), (9243, 7102), (8350, 6950), (7850, 7250), (9450, 8450), (10150, 8450), (10360, 10053), (9242, 10052), (8350, 10800), (7850, 10950), (9450, 11650), (10150, 11650), (11400, 10800), (12050, 10950), (12050, 7250), (11400, 6950), (12050, 3300), (11400, 2300), (10150, 1600), (13100, 2300), (12600, 3300), (14200, 5750), (14900, 5750), (15108, 7103), (13993, 7102), (13100, 6950), (12600, 7250), (14200, 8450), (14900, 8450), (15110, 10053), (13992, 10052), (13100, 10800), (12600, 10950), (14200, 11650), (14900, 11650), (16150, 10800), (16800, 10950), (16800, 7250), (16150, 6950), (16800, 3300), (16150, 2300), (14900, 1600), (19800, 800), (19800, 10000), (19800, 11900), (19800, 12200), (200, 12200), (200, 1100), (200, 800)] def dist(x, y): return round(math.sqrt((x[0] - y[0])**2 + (x[1] - y[1])**2)) def tsp(x): tour = x[0] return sum([dist(cities[tour[i]], cities[tour[(i + 1) % len(cities)]]) for i in range(len(tour))]) problem = Problem(1, 1) problem.types[0] = Permutation(range(len(cities))) problem.directions[0] = Problem.MINIMIZE problem.function = tsp algorithm = GeneticAlgorithm(problem) algorithm.run(100000, callback = lambda a : print(a.nfe, unique(nondominated(algorithm.result))[0].objectives[0]))