def call( iproblem: IProblem, epochs: int, agent_count: int ) -> Generator[Tuple[np.ndarray, np.ndarray], None, None]: problem = Problem(iproblem) evolution = Evolution(problem, epochs, agent_count) for pop in evolution.evolve(): xs = [x for x in map(lambda x: x.features, pop.fronts[0])] fs = [f for f in map(lambda x: x.objectives, pop.fronts[0])] # f_norms = [x for x in map(lambda x: x.normalized_objectives, pop.fronts[0])] # Originally here for debugging purposes yield np.array(xs), np.array(fs)
def Select(population, MSR, RV, BI_size, population_K ,nsol, new_msr, new_rv,new_bisize, new_K, generation,self_population,Zdt_definitions,PPlotter,PProblem,EEvolution,population_label,children_label): if (Zdt_definitions is None) and (PPlotter is None) and (PProblem is None) and (EEvolution is None): zdt_definitions = ZDT3Definitions() plotter = Plotter(zdt_definitions) problem = ZDT(zdt_definitions) evolution = Evolution(problem, 1, len(population)) evolution.register_on_new_generation(plotter.plot_population_best_front) evolution.register_on_new_generation(collect_metrics) else: zdt_definitions=Zdt_definitions plotter=PPlotter problem=PProblem evolution=EEvolution new_pop,objectives,self_population,Final_label,K= evolution.evolve(population,MSR, RV, BI_size, population_K,nsol, new_msr, new_rv, new_bisize, new_K,generation,self_population,population_label,children_label) return new_pop,objectives,self_population,zdt_definitions,plotter,problem,evolution,Final_label,K
def optimizator(nGeneration=1000, nVariables=1, objectives=None, varRange=None, same_range=None, expand=False, nIndividuals=50): """Hàm tìm bộ tham số tối ưu để tối thiểu hóa các hàm `objectives` Keyword Arguments: nGeneration {int} -- Số lượng thế hệ muốn chạy tìm tối ưu (default: {1000}) nVariables {int} -- Số lượng biến trong hàm tối ưu (default: {1}) objectives {list} -- Danh sách các hàm cần tối ưu (default: {None}) varRange {list} -- Danh sách các tuple là khoảng giá trị của các biến trong các hàm `objectives` (default: {None}) Returns: list, list -- danh sách các giá trị của biến khiến các hàm `objectives` đạt tối thiểu, danh sách các giá trị tối thiểu của các hàm float -- time """ ############################## # Định nghĩa problem cần minimize ############################## problem = Problem(num_of_variables=nVariables, objectives=objectives, variables_range=varRange, expand=expand, same_range=same_range) ############################## # Tiến hành minimize ############################## evo = Evolution(problem, num_of_generations=nGeneration, num_of_individuals=nIndividuals) start = time.time() evol = evo.evolve() end = time.time() return evol[0].features, evol[0].objectives, end - start
def f1(x): s = 0 for i in range(len(x) - 1): s += -10 * math.exp(-0.2 * math.sqrt(x[i]**2 + x[i + 1]**2)) return s def f2(x): s = 0 for i in range(len(x)): s += abs(x[i])**0.8 + 5 * math.sin(x[i]**3) return s problem = Problem(num_of_variables=3, objectives=[f1, f2], variables_range=[(-5, 5)], same_range=True, expand=False) evo = Evolution(problem, mutation_param=20) func = [i.objectives for i in evo.evolve()] function1 = [i[0] for i in func] function2 = [i[1] for i in func] plt.xlabel('Function 1', fontsize=15) plt.ylabel('Function 2', fontsize=15) plt.scatter(function1, function2) plt.show()
problem = Problem(num_of_variables=5, objectives=[gmean_inv, dem_fpr], variables_range=[ (min_range_criterion, max_range_criterion), (min_range_max_depth, max_range_max_depth), (min_range_samples_split, max_range_samples_split), (min_range_leaf_nodes, max_range_leaf_nodes), (min_range_class_weight, max_range_class_weight) ], individuals_df=pd.DataFrame(), num_of_generations=generations, num_of_individuals=individuals, dataset_name=dataset, variable_name=variable, seed=set_seed) print("------------RUN:", run) evo = Evolution(problem, evolutions_df=pd.DataFrame(), dataset_name=dataset, protected_variable=variable, num_of_generations=generations, num_of_individuals=individuals) pareto = evo.evolve() first = True for p in pareto: problem.test_and_save(p, first, problem.seed) first = False
print("Generation: {}".format(generation_num + 1)) collected_metrics = {} def collect_metrics(population, generation_num): pareto_front = population.fronts[0] metrics = ZDT3Metrics() hv = metrics.HV(pareto_front) hvr = metrics.HVR(pareto_front) collected_metrics[generation_num] = hv, hvr pbr_props.show_info = True pbr_definitions = PBRDefinitions() plotter = Plotter(pbr_definitions) problem = PBRCosts(pbr_definitions) evolution = Evolution(problem, 50, 50) evolution.register_on_new_generation(plotter.plot_population_best_front) evolution.register_on_new_generation(print_generation) evolution.register_on_new_generation(collect_metrics) pareto_front = evolution.evolve() plotter.write_report(pareto_front) pbr_engine.close_aspen() # plotter.plot_x_y(collected_metrics.keys(), map(lambda (hv, hvr): hvr, collected_metrics.values()), 'generation', 'HVR', 'HVR metric for PBR problem', 'hvr-pbr_problem') print("--- Whole run: %s seconds ---" % (time.time() - start_time))
def optimize(self,predictions,run_day,C=0,Q=0.6,Q_rfa=1,num_of_generations=250, num_of_individuals=200, num_of_tour_particips=10,tournament_prob=1, p_c=0.5,p_m=0.5,p_risked=0.8,full=True,policy='return'): """optimizes the portfolio following constraints, predictions and historical risk Parameters ---------- predictions : array array of optimal portfolios run_day : datetime array of corresponfing portfolios risks C : int array of corresponfing portfolios returns Q : float maximal quantity to be invested in a risky asset Q_rfa : sloat maximal quantity to be invested in the risk free asset num_of_generations : int number of NSGAII generations num_of_individuals : int NSGAII population num_of_tour_particips : int NSGAII tournament participants tournament_prob : float paramters in binary selection tournament (not used for now) p_c : float crossover probability p_m : float mutaion probability p_risked : float probability of doing the crossover on the risky assets full : boolean True: cross over on the whole portfolio , False : cross over on a part of the portfolio policy : str selection policy Returns ------- array the selected optimal portfolio """ L=[] B=[] all_real_returns=self.get_all_real_returns() cov=all_real_returns[all_real_returns.index<=run_day].cov().values def f1(x): return self.risk_portfolio(x,cov) def f2(x): return self.return_portfolio(x,predictions) portfolio_size=self.N Q=Q Q_rfa=Q_rfa if(C==0): C=portfolio_size problem = Problem(portfolio_size=portfolio_size, objectives=[f1, f2],Q=Q,Q_rfa=Q_rfa,C=C) evo = Evolution(problem, num_of_generations, num_of_individuals, num_of_tour_particips,tournament_prob, p_c,p_m,p_risked,full=True) solutions=evo.evolve() func = [i.objectives for i in solutions] function1 = [i[0] for i in func] function2 = [i[1] for i in func] plt.scatter(function1,function2) plt.title('Paret Set of Optimar Portfolios') plt.xlabel('Risk') plt.ylabel('Return') plt.savefig(self.portfolios_path+'/front_'+str(run_day)+'.png') selected_portfolio=self.choose_portfolio(solutions,function1,function2,policy,L,B) with open(self.portfolios_path+'/portfolio_'+str(run_day)+'.p', 'wb') as f: pickle.dump(selected_portfolio, f) return selected_portfolio
from nsga2.problem import Problem from nsga2.evolution import Evolution import matplotlib.pyplot as plt def f1(x): return x**2 def f2(x): return (x - 2)**2 problem = Problem(num_of_variables=1, objectives=[f1, f2], variables_range=[(-55, 55)]) evo = Evolution(problem) evol = evo.evolve() func = [i.objectives for i in evol] function1 = [i[0] for i in func] function2 = [i[1] for i in func] plt.xlabel('Function 1', fontsize=15) plt.ylabel('Function 2', fontsize=15) plt.scatter(function1, function2) plt.show()
def print_generation(population, generation_num): print("Generation: {}".format(generation_num)) def print_metrics(population, generation_num): pareto_front = population.fronts[0] metrics = ZDT3Metrics() hv = metrics.HV(pareto_front) hvr = metrics.HVR(pareto_front) print("HV: {}".format(hv)) print("HVR: {}".format(hvr)) collected_metrics = {} def collect_metrics(population, generation_num): pareto_front = population.fronts[0] metrics = ZDT3Metrics() hv = metrics.HV(pareto_front) hvr = metrics.HVR(pareto_front) collected_metrics[generation_num] = hv, hvr zdt_definitions = ZDT3Definitions() plotter = Plotter(zdt_definitions) problem = ZDT(zdt_definitions) evolution = Evolution(problem, 200, 200) evolution.register_on_new_generation(plotter.plot_population_best_front) evolution.register_on_new_generation(print_generation) evolution.register_on_new_generation(print_metrics) evolution.register_on_new_generation(collect_metrics) pareto_front = evolution.evolve() plotter.plot_x_y(collected_metrics.keys(), map(lambda (hv, hvr): hvr, collected_metrics.values()), 'generation', 'HVR', 'HVR metric for ZDT3 problem', 'hvr-zdt3')