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 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 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 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
#individual_id_list = contains all UNIQUE GENE ID that is used for calculating BHI
#individual_ref_id_list = contains all GENE reference id that is used for calculating PPI Interaction Score
#all_datamatrix, all_normalized_data_matrix = preprocessed the gene expression values that is fed to FCM
#unique_protein_ref: Contains unique Gene refernce ID
"""
individual_list = []
individual_length, individual_list, individual_id_list, individual_ref_id_list = preprocess(
'Input_data/preprocessed_ILD.txt')
all_data_matrix, all_normalized_data_matrix = preprocess_fcm_datamatrix(
individual_length, individual_list)
"""
Input from user
"""
chromosome_number = int(
sys.argv[1]
) # Enter the number of chromosome(individual) you want to generate
generation_number = int(sys.argv[2]) # Enter the maximum number of generation
zdt_definitions = ZDT3Definitions(individual_list, individual_id_list,
individual_ref_id_list)
plotter = Plotter(zdt_definitions, individual_list)
problem = ZDT(zdt_definitions, all_normalized_data_matrix, chromosome_number)
evolution = Evolution(problem, generation_number, chromosome_number,
individual_list, individual_length)
evolution.register_on_new_generation(plotter.plot_population_best_front)
evolution.register_on_new_generation(print_generation)
pareto_front = evolution.evolve()
end = time.time()
print "##$$$##"
print(end - start)
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()
(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)
# problem with 3 fo:
#problem = Problem(num_of_variables = 5, objectives = [gmean_inv, dem_fpr, complexity], 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)
#problem = Problem(num_of_variables = 5, objectives = [accuracy_inv, dem_fpr], variables_range = [(min_range_criterion, max_range_criterion), (min_range_max_depth, max_range_max_depth), (min_range_samples_leaf, max_range_samples_leaf), (min_range_impurity_decrease, max_range_impurity_decrease), (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)
evo = Evolution(problem,
evolutions_df=pd.DataFrame(),
dataset_name=dataset,
protected_variable=variable,
num_of_generations=generations,
num_of_individuals=individuals)
func = [i.objectives for i in evo.evolve()]
print(func)
df = pd.read_csv(config['ROOT_PATH'] + '/results/population/evolution_' +
dataset + '_' + variable + '_seed_' + str(set_seed) +
'_gen_' + str(generations) + '_indiv_' + str(individuals) +
'.csv')
df = df.loc[(df['rank'] == 0)
& ((df['generation'] == 1) | (df['generation'] == 20)
| (df['generation'] == 40) | (df['generation'] == 60)
| (df['generation'] == 80) | (df['generation'] == 100))]
#scatterplot(df, set_seed, 'dem_fp', 'error', 'generation', dataset, variable, generations, individuals)
156,50,32,112,132,84,56,49,136,134,75,31,57,36,54,59,\
114,13,40,14,66,5,63,107,176,133,180,97,162,123,0,67]
'''
# hos_opt_id_arr 存储需要优化的医院ID，traffic的前10以及road的前10，非重复数值16个
hos_opt_id_arr = [
1, 6, 11, 26, 27, 29, 35, 46, 47, 62, 71, 84, 94, 113, 122, 132
]
#打乱数组顺序，随机洗牌，选取前P个作为候选点
np.random.shuffle(hos_opt_id_arr)
hos_opt = hos_opt_id_arr[0:vardim]
hos_definitions = HospitalDefinitions()
plotter = Plotter(hos_definitions)
problem = Hospital(hos_definitions, vardim, bound, hos_opt)
'''Evolution(self,problem, vardim, num_of_generations, num_of_individuals, mutation_prob, num_of_genes_to_mutate, num_of_tour_particips)'''
evolution = Evolution(problem, vardim, i, num_of_generations,
num_of_individuals, 0.4, 1, 2)
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 Hospital relocation problem',
str(vardim) + '-' + str(i) + '-' + 'HVR')
fout = open(
"D:\\PythonCode\\NSGA-II\\txt\\" + str(vardim) + '-' + str(i) + '-' +
'metrics.txt', 'w')
fout.write('generation,HV,HVR' + '\n')
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')
