def calibrate(run_counts): """调用优化计算模型进行参数优选 Parameters ---------- run_counts: int 运行次数 Returns --------- optimal_params: list 非劣解集 """ algorithm = NSGAII(XajCalibrate(), population_size=500, variator=GAOperator(SBX(0.95, 20.0), PM(2, 25.0))) algorithm.run(run_counts) # algorithm.run(run_counts) # We could also get only the non-dominated solutions,这里只展示非劣解集 nondominated_solutions = nondominated(algorithm.result) # plot the results using matplotlib # 如果目标超过三个,可视化方面需要进行降维操作,这里先以两个目标为例进行分析 plt.scatter([s.objectives[0] for s in nondominated_solutions], [s.objectives[1] for s in nondominated_solutions]) plt.xlim([0, 1]) plt.ylim([0, 1]) plt.xlabel("$mare$") plt.ylabel("$nse$") plt.show() # 返回最优参数 optimal_params = [] for nondominated_solution in nondominated_solutions: optimal_params.append(nondominated_solution.variables) return optimal_params
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 main(): os = OneShotObjects() rs = RegularizationSamples(os, num_reg_samples_per_object=10) gg = GeneralizationGenerator(os, rs, num_objects=os.num_objects, num_gen_samples_per_object=1000) cs = Classifier(num_classes=os.num_objects, range=os.range) gol_model = GOL(os, rs, gg, cs) opt_algorithm = NSGAII(gol_model) opt_algorithm.run(2) for solution in opt_algorithm.result: print(solution.objectives) print(np.shape(opt_algorithm.result)) # Uncomment this code block for saving the pareto solutions to a file ''' with open('pareto_solutions.csv', 'w', newline='') as f: writer = csv.writer(f) for s in range(np.shape(opt_algorithm.result)[0]): writer.writerow((s.objectives[0], s.objectives[1])) f.close() ''' plt.scatter([s.objectives[0] for s in opt_algorithm.result], [s.objectives[1] for s in opt_algorithm.result]) #plt.xlim([0, 500.1]) #plt.ylim([0, 1.1]) plt.xlabel("$J(\Theta, \hat{x}(t))$") plt.ylabel("$a(\Theta, \hat{x}(t))$") plt.show()
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 main(): to = TemplateObjects() rs = RegularizationSamples(to, num_reg_samples_per_object=10) gg = GeneralizationGenerator(to, rs, num_objects=to.num_objects, num_gen_samples_per_object=100) cs = Classifier(num_classes=to.num_objects) #model = GOL(to, rs, gg, cs) #model.train() algorithm = NSGAII(GOL(to, rs, gg, cs)) algorithm.run(1) for solution in algorithm.result: print(solution.objectives) print(np.shape(algorithm.result)) plt.scatter([s.objectives[0] for s in algorithm.result], [s.objectives[1] for s in algorithm.result]) plt.xlim([0, 500.1]) plt.ylim([0, 1.1]) plt.xlabel("$f_1(x)$") plt.ylabel("$f_2(x)$") plt.show()
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 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 main(): to = TemplateObjects() rs = RegularizationSamples(to, num_reg_samples_per_object=10) gg = GeneralizationGenerator(to, rs, num_objects=to.num_objects, num_gen_samples_per_object=100) cs = Classifier(num_classes=to.num_objects) #model = GOL(to, rs, gg, cs) #model.train() algorithm = NSGAII(GOL(to, rs, gg, cs)) algorithm.run(2) for solution in algorithm.result: print(solution.objectives) print(np.shape(algorithm.result)) with open('pareto_solutions.csv', 'w', newline='') as f: writer = csv.writer(f) for s in range(np.shape(algorithm.result)[0]): writer.writerow((s.objectives[0], s.objectives[1])) f.close()
def test_platypus_nsgaii_process_pool(two_reservoir_problem): """Undertake a single step of the NSGAII algorithm with a ProcessPool.""" with ProcessPoolEvaluator(2) as evaluator: algorithm = NSGAII(two_reservoir_problem.problem, population_size=50, evaluator=evaluator) algorithm.run(10)
def validate_flow_methods(model_run_name="upper_cosumnes_subset_2010", show_plot=True): problem = run_optimize_new(run_problem=False, model_run_name=model_run_name)["problem"] measurements = numpy.linspace(0, 1, 101) for measurement in measurements: log.info(measurement) initial_flows = optimize.SimpleInitialFlowsGenerator(measurement) runner = NSGAII( problem, generator=initial_flows, population_size=1 ) # shouldn't matter what algorithm we use - we only do 1 NFE runner.run( 1) # run it for 1 NFE just to see what these initial flows do plt.plot(problem.iterations, problem.objective_1) plt.xlabel("Percent of Available Flow") plt.ylabel("Environmental Benefit") plt.savefig(os.path.join(settings.BASE_DIR, "data", "results", "validation_plot_{}.png".format(model_run_name)), dpi=300) if show_plot: plt.show() plt.close() return {"x": problem.iterations, "y": problem.objective_1}
def get_critical_nodes(): # algorithm = NSGAII(problem=BOCNDP(), generator=DfsGenerator()) algorithm = NSGAII(problem=BOCNDP(), generator=DegreeGenerator()) # algorithm = NSGAII(problem=BOCNDP(), generator=RandomWalkGenerator()) algorithm.run(10000) print(algorithm.result[0].objectives) return algorithm.result[0].objectives
def _solve(args): problem, iterations, use_max = args algorithm = NSGAII(problem) algorithm.run(iterations) feasible_solutions = [ s.objectives[0] for s in algorithm.result if s.feasible ] return max(feasible_solutions) if use_max else min(feasible_solutions)
def get_critical_nodes(): algorithm = NSGAII(BOCNDP(), selector=TournamentSelector(dominance=NashDominance()), archive=NashArchive()) algorithm.run(100) print(algorithm.result[0].objectives) return algorithm.result[0].objectives
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_point(nobjs, population_size): # define the problem definition problem = DTLZ2(nobjs=nobjs) # instantiate the optimization algorithm algorithm = NSGAII(problem, population_size=population_size) algorithm.run(1000) # mutate_point = RandomGenerator().generate(problem=problem) return algorithm.result[0].objectives._data pass
def get_critical_nodes(): algorithm = NSGAII(CNDP(), selector=TournamentSelector(dominance=BergeDominance()), archive=BergeArchive()) algorithm.run(1000) fitness = algorithm.result[0].objectives[0] print(fitness) return fitness
def get_critical_nodes(): algorithm = NSGAII(BOCNDP()) # algorithm = EpsMOEA(BOCNDP(), epsilons=[0.05]) # algorithm = SPEA2(BOCNDP()) # algorithm = IBEA(BOCNDP()) # algorithm = PAES(BOCNDP()) # algorithm = EpsNSGAII(BOCNDP(), epsilons=[0.05]) algorithm.run(10000) print(algorithm.result[0].objectives) return algorithm.result[0].objectives
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 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 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 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_portfolios(buying_power: float, user_id: int, start_date: str, end_date: str, num_portfs: int): # Setup stock universe universe = ReadUniverse(start_date, end_date) filtered_universe = filter_universe_trend(universe, start_date, end_date) if (filtered_universe == None or filtered_universe.count == 0): print( "Error filtering, please ensure correct start and end dates, and that they're valid trading days." ) return None # Initialize problem class and genetic algorithm to be used, and run for 10000 evolutions problem = OptPortfolio(filtered_universe, buying_power) algorithm = NSGAII(problem) algorithm.run(1000) # Only keep solutions that are within constraints feasible_solutions = [s for s in algorithm.result if s.feasible] ports = num_portfs # If the number of feasible solutions is less than the number requested, use the length as the number to return if len(feasible_solutions) < num_portfs: ports = len(feasible_solutions) # Decode solutions back to integers for the number of requested portfolios solutions = [[ problem.typeInt.decode(i) for i in feasible_solutions[j].variables ] for j in range(ports)] # Create allocation dictionary using ticker name as key, assuming uniform weights, for each solution portfolios = [] for sol in solutions: alloc = {} shares = {} assets = [] for i, asset in enumerate(filtered_universe.UniverseSet): if (sol[i] == 1): alloc[asset.Ticker] = 0.1 shares[asset.Ticker] = (buying_power * 0.1) / asset.LastPrice assets.append(asset) portf = Portfolio(UserID=user_id, BuyingPower=buying_power, assets=assets, AssetAlloc=alloc, AssetShares=shares) portfolios.append(portf) return portfolios
def main(): # get config vars config = cli.init() population_size_nsgaii = config['POPULATION_SIZE_NSGAII'] number_of_runs_nsgaii = config['NUMBER_OF_RUNS_NSGAII'] number_of_runs_ga = config['NUMBER_OF_RUNS_GA'] population_size_ga = config['POPULATION_SIZE_GA'] config_path = config['TEST_DATA_PATH'] ga_weights = config['GA_WEIGHTS'] budget_constraint = config['BUDGET_CONSTRAINT'] # parse and get specific data data = test_data.parse(config_path) requirements = data[0] clients = data[1] # run NSGA-II multi-objective algorithm print(datetime.datetime.now()) print('Running NSGA-II...') NRP_multi = NRP_MOO(requirements, clients, budget_constraint) algorithm = NSGAII(NRP_multi.generate_problem(), population_size=population_size_nsgaii) algorithm.run(number_of_runs_nsgaii) NSGAII_solutions = unique(nondominated(algorithm.result)) # run GA single-objective algorithm with different weights GA_solutions = [] for ga_weight in ga_weights: print(datetime.datetime.now()) print('Running GA for weights ' + str(ga_weight) + ' and ' + str(1 - ga_weight) + '...') NRP_single = NRP_SOO(requirements, clients, budget_constraint, ga_weight, 1 - ga_weight) algorithm = GeneticAlgorithm(NRP_single.generate_problem(), population_size=population_size_ga) algorithm.run(number_of_runs_ga) GA_solutions.extend(unique(nondominated(algorithm.result))) # run random algorithm print(datetime.datetime.now()) print('Generating random solution...') NRP_random = NRP_Random(requirements, clients, budget_constraint) random_solutions = NRP_random.generate_solutions() print('done!') # draw graphs results.draw_graphs([ results.get_graph_data_nsga_ii(NSGAII_solutions), results.get_graph_data_ga(GA_solutions, requirements, clients, budget_constraint), results.get_graph_data_ga(random_solutions, requirements, clients, budget_constraint) ])
def fit(self, X, y): X, y, = copy.deepcopy(X), copy.deepcopy(y) self.y = y y_bin = y self.X, self.y_bin = X, y # # start evolving in MOEA num_variables = (self.X.shape[1] + 1) * self.n_hidden algorithm = NSGAII(Objectives(num_variables, 2, self.X, y_bin, self.n_hidden, sparse_degree=self.sparse_degree), population_size=self.n_pop) # MOEAD(Objectives(num_variables, 2, self.X, y_bin, self.n_hidden, sparse_degree=self.sparse_degree), # population_size=self.n_pop, neighborhood_size=int(self.n_pop/10)) # delta=0.5, eta=0.8 algorithm.run(self.max_iter) self.evo_result = algorithm.result print('total solution:', algorithm.result.__len__()) nondom_result = nondominated(algorithm.result) print('nondominated solution:', nondom_result.__len__()) self.nondom_solution = nondom_result self.W = [] self.B = [] for i in range(nondom_result.__len__()): s = nondom_result[i] W = np.asarray(s.variables).reshape(self.X.shape[1] + 1, self.n_hidden) X_ = np.append(self.X, np.ones((self.X.shape[0], 1)), axis=1) H = expit(np.dot(X_, W)) B = np.dot(linalg.pinv(H), y_bin) self.W.append(W) self.B.append(B) real_degree = H.mean(axis=0) # n_hidden dim avg_activation = real_degree.mean() print('NO.', i, ' obj:', s.objectives, 'AVG activation:', avg_activation) self.W = np.asarray(self.W) self.B = np.asarray(self.B) # # best W/B best_index = self.get_best_index() self.best_W = self.W[best_index] self.best_B = self.B[best_index] return self
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 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 multi_objective(requirements, budget): problem = ReleaseProblem(requirements, budget * sum(req.cost for req in requirements)) alg = NSGAII(problem) alg.run(10000) plt.scatter([s.objectives[0] for s in alg.result], [s.objectives[1] for s in alg.result]) plt.xlim([ min(s.objectives[0] for s in alg.result), max(s.objectives[0] for s in alg.result) ]) plt.ylim([ max(s.objectives[1] for s in alg.result), min(s.objectives[1] for s in alg.result) ]) plt.xlabel("Value") plt.ylabel("Cost") plt.show() return alg.result
def generate_portfolio(universe: Universe, buying_power: float, user_id: int): algorithm = NSGAII(OptPortfolio(universe, buying_power)) algorithm.run(1000) feasible_solutions = [s for s in algorithm.result if s.feasible] sol = feasible_solutions[0] alloc = {} for i in range(universe.count): alloc[universe.universe_set[i].ticker] = sol.variables[i] print(alloc) portf = Portfolio(user_id=user_id, buying_power=buying_power * (1 - sum(sol.variables)), assets=universe.universe_set, asset_alloc=alloc) return portf
def single_objective(requirements, budget): weights = np.arange(0.1, 1, 0.05) results = [] for weight in weights: problem = SingleObjReleaseProblem( requirements, budget * sum(req.cost for req in requirements), weight) alg = NSGAII(problem) alg.run(10000) results.append(alg.result[0:10]) cost_value_list = [] for result_list in results: for result in result_list: sum_value = 0 sum_cost = 0 for i in range(0, len(result.variables) - 1): if result.variables[i][0]: sum_value += requirements[i].value sum_cost += requirements[i].cost cost_value_list.append([sum_value, sum_cost]) plt.scatter([r[0] for r in cost_value_list], [r[1] for r in cost_value_list]) plt.xlim([ min(r[0] for r in cost_value_list) - 1, max(r[0] for r in cost_value_list) + 1 ]) plt.ylim([ max(r[1] for r in cost_value_list) + 1, min(r[1] for r in cost_value_list) - 1 ]) plt.xlabel("Value") plt.ylabel("Cost") plt.show() return results
from platypus import NSGAII, Problem, Real class Schaffer(Problem): def __init__(self): super(Schaffer, self).__init__(1, 2) self.types[:] = Real(-10, 10) def evaluate(self, solution): x = solution.variables[:] solution.objectives[:] = [x[0]**2, (x[0]-2)**2] algorithm = NSGAII(Schaffer()) algorithm.run(10000)