def plot_2d_evo(popi):
magnet_dim = len(popi.get_x()[0])
ndf, dl, dc, ndl = pg.fast_non_dominated_sorting(popi.get_f()[:, :2])
# print(pg.sort_population_mo(popi.get_f()))
ndf_champ = []
# for j in range(2,200):
# print(pg.ideal(popi.get_f())[0])
print(ndf)
# x = np.linspace(pg.ideal(popi.get_f())[0],0)
# y = np.zeros(50)+(1)
old_ndf, new_ndf = np.zeros(1), np.zeros(1)
n_plots = 0
for j in range(2, len(popi.get_f())):
# print(x,y)
# plt.plot(x,y,linestyle="dashed",color="red")
# print(ndf)
# ndf_champ.append([popi.get_f()[i] for i in ndf[j]])
# ax = pg.plot_non_dominated_fronts(ndf_champ[0],comp=[0,1])
# ax.plot(color="C{}".format(j))
ndf, dl, dc, ndl = pg.fast_non_dominated_sorting(popi.get_f()[0:j, :2])
# print(ndf)
new_ndf = np.array(ndf[0])
if not np.array_equal(new_ndf, old_ndf):
if len(ndf[0]) <= 1:
continue
n_plots += 1
plt.cla()
ax = pg.plot_non_dominated_fronts(popi.get_f()[ndf[0]],
comp=[0, 1])
ax.set_ylabel(fNames[1])
ax.set_xlabel(fNames[0])
ax.set_ylim(1e-1, 1e1)
ax.set_yscale('log')
ax.set_xlim(0.1, 10.0)
ax.set_xscale('log')
ax.axvline(x=fNom[0], linestyle="dashed", color="red")
# axs[plot_y].axvline(x=best_point[0],linestyle="dotted",color="blue")
ax.axhline(y=1.0, linestyle="dashed", color="red")
# ax.set_xlabel('resolution')
# ax.set_ylabel('xangle_e_min')
# ax.set_ylim(1e-3,1000)
# ax.set_yscale('log')
# pri nt(ndf_champ, ndf[0])
# pri nt(ndf)
plt.savefig("popi{}".format(n_plots))
old_ndf = np.array(ndf[0])
return
def _calc_pareto_front(self, *args, **kwargs):
# args[0] should be f
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(args[0])
p = args[0][ndf, :]
# base class has this assignment
return p
def my_print(ad, pop, _):
# ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(fits)
# extract and print non-dominated fronts
# - ndf (list of 1D NumPy int array): the non dominated fronts
# - dl (list of 1D NumPy int array): the domination list
# - dc (1D NumPy int array): the domination count
# - ndr (1D NumPy int array): the non domination ranks
fits, vectors = pop.get_f(), pop.get_x()
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(fits)
with open(ad.solver.output_dir + 'MOO_log.txt', 'a',
encoding='utf-8') as fname:
print('-' * 40, 'Generation:', _, file=fname)
for rank_minus_1, front in enumerate(ndf):
print('Rank/Tier', rank_minus_1 + 1, front, file=fname)
index = 0
for domination_list, domination_count, non_domination_rank in zip(
dl, dc, ndr):
print('Individual #%d\t' % (index),
'Belong to Rank #%d\t' % (non_domination_rank),
'Dominating',
domination_count,
'and they are',
domination_list,
file=fname)
index += 1
# print(fits, vectors, ndf)
print(pop, file=fname)
def parEGO_out_process():
parEGO_folder_name = 'parEGO_out\\ZDT'
for i in np.arange(1, 5):
out_file = parEGO_folder_name + str(i) + '.txt'
f = np.genfromtxt(out_file, delimiter='\t')
f = np.atleast_2d(f).reshape(-1, 2)
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(f)
ndf = list(ndf)
f_pareto = f[ndf[0], :]
#ego
output_folder_name = 'outputs\\' + 'ZDT' + str(i)
if os.path.exists(output_folder_name):
output_f_name = output_folder_name + '\\best_f_seed_100.joblib'
best_f_ego = load(output_f_name)
else:
raise ValueError(
"results folder for EGO does not exist"
)
problem_obj = 'ZDT' + str(i) + '(n_var=3)'
problem = eval(problem_obj)
true_pf = problem.pareto_front()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(f_pareto[:, 0], f_pareto[:, 1], c='b', marker='o')
ax.scatter(true_pf[:, 0], true_pf[:, 1], c='r', marker='x')
ax.scatter(best_f_ego[:, 0], best_f_ego[:, 1], c='g', marker='d')
plt.title(problem_obj)
plt.show()
def plot_2d_evo(popi):
magnet_dim = len(popi.get_x()[0])
ndf, dl, dc, ndl = pg.fast_non_dominated_sorting(popi.get_f())
print(pg.sort_population_mo(popi.get_f()))
ndf_champ = []
# for j in range(2,200):
print(pg.ideal(popi.get_f())[0])
x = np.linspace(pg.ideal(popi.get_f())[0],0)
y = np.zeros(50)+(1)
for j in range(2,100):
plt.cla()
plt.plot(x,y,linestyle="dashed",color="red")
print(ndf[0])
ndf_champ.append([popi.get_f()[i] for i in ndf[j]])
# ax = pg.plot_non_dominated_fronts(ndf_champ[0],comp=[0,j])
# ax.plot(color="C{}".format(j))
ax = pg.plot_non_dominated_fronts(popi.get_f()[0:j])
ax.set_xlabel('resolution')
ax.set_ylabel('xangle_e_min')
ax.set_ylim(1e-3,1000)
ax.set_yscale('log')
# print(ndf_champ, ndf[0])
# print(ndf)
plt.savefig("popi{}".format(j))
return
def normalization_with_nd(y):
y = check_array(y)
n_obj = y.shape[1]
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(y)
ndf = list(ndf)
ndf_size = len(ndf)
# extract nd for normalization
if len(ndf[0]) > 1:
ndf_extend = ndf[0]
else:
ndf_extend = np.append(ndf[0], ndf[1])
nd_front = y[ndf_extend, :]
# normalization boundary
min_nd_by_feature = np.amin(nd_front, axis=0)
max_nd_by_feature = np.amax(nd_front, axis=0)
if np.any(max_nd_by_feature - min_nd_by_feature < 1e-5):
print('nd front aligned problem, re-select nd front')
ndf_index = ndf[0]
for k in np.arange(1, ndf_size):
ndf_index = np.append(ndf_index, ndf[k])
nd_front = y[ndf_index, :]
min_nd_by_feature = np.amin(nd_front, axis=0)
max_nd_by_feature = np.amax(nd_front, axis=0)
if np.any(max_nd_by_feature - min_nd_by_feature < 1e-5):
continue
else:
break
norm_y = (y - min_nd_by_feature) / (max_nd_by_feature - min_nd_by_feature)
return norm_y
def output_2d_cosy(popi,filename):
hv = pg.hypervolume(popi)
ref_point = hv.refpoint()
best_point = (popi.get_f()[hv.greatest_contributor(ref_point)])
ndf, dl, dc, ndl = pg.fast_non_dominated_sorting(popi.get_f())
magnet_dim = len(popi.get_x()[0])
ndf_champ = []
sorted_ndf = []
sort_param = 3
for i in ndf[0]:
if i == ndf[0][0]:
sorted_ndf.append(i)
else:
for j in range(len(sorted_ndf)):
if j == len(sorted_ndf)-1:
sorted_ndf.append(i)
break
elif j == 0 and popi.get_f()[i][sort_param] < popi.get_f()[sorted_ndf[j]][sort_param]:
sorted_ndf.insert(j,i)
break
elif (popi.get_f()[i][sort_param] < popi.get_f()[sorted_ndf[j]][sort_param]) and j>0:
if(popi.get_f()[i][sort_param] >= popi.get_f()[sorted_ndf[j-1]][sort_param]):
# print(popi.get_f()[i][0],popi.get_f()[sorted_ndf[j]][0],popi.get_f()[sorted_ndf[j-1]][0])
sorted_ndf.insert(j,i)
break
print(ndf[0], sorted_ndf)
for i in range(len(sorted_ndf)):
j = sorted_ndf[i]
write_fox(np.power(np.zeros(magnet_dim)+2,popi.get_x()[j]), i, "2f_FP3/")
return
def save_hv_igd(train_x, train_y, hv_ref, seed_index, target_problem,
method_selection):
problem_name = target_problem.name()
n_x = train_x.shape[0]
nd_front_index = return_nd_front(train_y)
nd_front = train_y[nd_front_index, :]
hv = return_hv(nd_front, hv_ref, target_problem)
# for igd, only consider first front
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(train_y)
ndf = list(ndf)
nd_front = train_y[ndf[0], :]
igd = return_igd(target_problem, 10000, nd_front)
save = [hv, igd]
print(
'sample size %d, final save hv of current nd_front: %.4f, igd is: %.4f'
% (n_x, hv, igd))
working_folder = os.getcwd()
result_folder = working_folder + '\\outputs' + '\\' + problem_name + '_' + method_selection
if not os.path.isdir(result_folder):
# shutil.rmtree(result_folder)
# os.mkdir(result_folder)
os.mkdir(result_folder)
saveName = result_folder + '\\hv_igd_' + str(seed_index) + '.csv'
np.savetxt(saveName, save, delimiter=',')
def multi_obj_pairs(dpairs0=None, dpframe=None):
'''
Input:
dpairs0
dpairs1
type
type_parameters
Output:
dpairs
pygmo will return the index of best pairs , which can then be picked from dpairs
first find non-dominated fronts and then sort by second 'TYPE2'
'''
import pygmo as pg
import numpy as np
import pandas as pd
yt = dpframe.iloc[:, 2:].values
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(
points=np.array(yt, dtype='float64'))
ndf2 = []
for frnt in ndf:
# frnt = ndf[0]
tmp_frnt = np.argsort(yt[:, 1][frnt])
ndf2.append(frnt[tmp_frnt])
sf = np.concatenate(ndf2)
# Invest equally in it
fn_dpairs = dpairs0[sf]
return fn_dpairs
def findParetoIs(objectivesList, bolMinimize):
'''Returns a list of booleans corresponsing to sets of objectives.
True is nondominates, False is dominated'''
# Negate values for maximization
if bolMinimize == False:
minObjectivesList = []
for objs in objectivesList:
minObjectivesList.append(list(map(lambda y : y * -1, objs)))
else:
minObjectivesList = objectivesList
# Dc is a list with domination counts, 0 == non-dominated
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(minObjectivesList)
# Fill list with booleans
nondominatedIs = []
for count in dc:
if count == 0:
nondominatedIs.append(True)
else:
nondominatedIs.append(False)
return nondominatedIs
def find_n_best(df, n):
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(-1.0 * df.to_numpy())
# print('non dom fronts', ndf)
# print(ndf[0])
print('Best: \n', df.iloc[ndf[0][:n]])
print('Worse: \n', df.iloc[ndf[-2][:n]])
print('Worst: \n', df.iloc[ndf[-1][:n]])
return df.sample(n=n)
def save_pareto_front(train_y, filename):
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(train_y)
ndf = list(ndf)
f_pareto = train_y[ndf[0], :]
best_f_out = f_pareto
dump(best_f_out, filename)
'''
def pareto_fronts_probabilities(partition_list, beta, probability_method):
"""Get non-dominated fronts and its probabilities
Parameters
----------
...
Returns
----------
num_fronts : int
Number of non-dominated fronts
ndr : numpy.ndarray
Non-domination ranks
probability : dictionary
Dictionary with subproblem as keys and assigned probability values
"""
# Get (-|Z_E|, -|Z_std|) points for all subproblems
points = [[
-(abs(subproblem['Z_E'])), -(abs(1 - abs(subproblem['Z_std'])))
] for subproblem in partition_list]
# Obtain the non-dominated sorting of points
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(points=points)
num_fronts = len(ndf)
# Calculate probability at for all fronts.
front_prob = {}
if probability_method == "Pareto_Inverse":
# Calculating denominator
denominator = 0
for i in range(num_fronts):
denominator = denominator + len(ndf[i]) * ((1 / (i + 1))**beta)
# Calculating probability
for i in range(num_fronts):
front_prob[i] = ((1 / (i + 1))**beta) / denominator
elif probability_method == "Pareto_Boltzman":
# Calculating denominator
denominator = 0
for i in range(num_fronts):
denominator = denominator + len(ndf[i]) * (np.e**(-beta * (i + 1)))
# Calculating probability
for i in range(num_fronts):
front_prob[i] = (np.e**(-beta * (i + 1))) / denominator
# Calculate probability for all elements of partition list
prob_dict = {}
for i in range(len(ndf)):
for j in range(len(ndf[i])):
prob_dict[ndf[i][j]] = front_prob[i]
probabilities = [i for (j, i) in sorted(prob_dict.items())]
return num_fronts, ndf, probabilities
def ego_outputs_read(prob):
output_folder_name = 'outputs\\' + prob
output_f_name = output_folder_name + '\\' + 'best_f_seed_' + str(100) + '.joblib'
best_f = load(output_f_name)
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(best_f)
ndf = list(ndf)
f_pareto = best_f[ndf[0], :]
test_f = np.sum(f_pareto, axis=1)
return f_pareto
def calcula_tempo(func):
pop = lhs(3, 100)
ini = time()
f1 = fnds(pop, func)
print('meu fnds: ', time() - ini)
ini = time()
f2, _, _, _ = pg.fast_non_dominated_sorting(points=pop)
print('pygmo fnds: ', time() - ini)
return f1, f2
def return_nd_front(train_y):
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(train_y)
ndf = list(ndf)
# extract nd for normalization
if len(ndf[0]) > 1:
ndf_extend = ndf[0]
else:
ndf_extend = np.append(ndf[0], ndf[1])
return ndf_extend
def get_best(values, ignore_idx=None):
"""Assumping everything are to MAXIMIZED.
Return the best value indices
https://esa.github.io/pagmo2/docs/python/utils/py_mo_utils.html
"""
V = np.array(values)
for idx in ignore_idx:
V[:, idx] = 0
_, _, dc, _ = pg.fast_non_dominated_sorting(points=-1 * V)
return [i for i, v in enumerate(dc) if v == 0]
def post_process(train_x, train_y, cons_y, target_problem, seed_index,
method_selection, run_signature):
n_sur_objs = target_problem.n_obj
n_sur_cons = target_problem.n_constr
# output best archive solutions
sample_n = train_x.shape[0]
a = np.linspace(0, sample_n - 1, sample_n, dtype=int)
out = {}
target_problem._evaluate(train_x, out)
if 'G' in out.keys():
mu_g = out['G']
mu_g = np.atleast_2d(mu_g).reshape(-1, n_sur_cons)
mu_g[mu_g <= 0] = 0
mu_cv = mu_g.sum(axis=1)
infeasible = np.nonzero(mu_cv)
feasible = np.setdiff1d(a, infeasible)
feasible_solutions = train_x[feasible, :]
feasible_f = train_y[feasible, :]
n = len(feasible_f)
# print('number of feasible solutions in total %d solutions is %d ' % (sample_n, n))
if n > 0:
best_f = np.argmin(feasible_f, axis=0)
print('Best solutions encountered so far')
print(feasible_f[best_f, :])
best_f_out = feasible_f[best_f, :]
best_x_out = feasible_solutions[best_f, :]
print(feasible_solutions[best_f, :])
else:
best_f_out = None
best_x_out = None
print('No best solutions encountered so far')
elif n_sur_objs == 1:
best_f = np.argmin(train_y, axis=0)
best_f_out = train_y[best_f, :]
best_x_out = train_x[best_f, :]
else:
# print('MO save pareto front from all y')
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(train_y)
ndf = list(ndf)
f_pareto = train_y[ndf[0], :]
best_f_out = f_pareto
best_x_out = train_x[ndf[0], :]
savename_x, savename_f, savename_FEs = saveNameConstr(
target_problem.name(), seed_index, method_selection, run_signature)
dump(best_x_out, savename_x)
dump(best_f_out, savename_f)
def my_plot_non_dominated_fronts(points,
marker='o',
comp=[0, 1],
up_to_rank_no=None):
# We plot
fronts, _, _, _ = pg.fast_non_dominated_sorting(points)
# We define the colors of the fronts (grayscale from black to white)
if up_to_rank_no is None:
cl = list(
zip(np.linspace(0.1, 0.9, len(fronts)),
np.linspace(0.1, 0.9, len(fronts)),
np.linspace(0.1, 0.9, len(fronts))))
else:
cl = list(
zip(np.linspace(0.1, 0.9, up_to_rank_no),
np.linspace(0.1, 0.9, up_to_rank_no),
np.linspace(0.1, 0.9, up_to_rank_no)))
fig, ax = plt.subplots()
count = 0
for ndr, front in enumerate(fronts):
count += 1
# We plot the points
for idx in front:
ax.plot(points[idx][comp[0]],
points[idx][comp[1]],
marker=marker,
color=cl[ndr])
# We plot the fronts
# Frist compute the points coordinates
x = [points[idx][comp[0]] for idx in front]
y = [points[idx][comp[1]] for idx in front]
# Then sort them by the first objective
tmp = [(a, b) for a, b in zip(x, y)]
tmp = sorted(tmp, key=lambda k: k[0])
# Now plot using step
ax.step([c[0] for c in tmp], [c[1] for c in tmp],
color=cl[ndr],
where='post')
if up_to_rank_no is None:
pass
else:
if count >= up_to_rank_no:
break
return ax
def write_ndf_csv(self, name):
'''Write a csv file that contains the non dominated vectors of the optimisation'''
fitness_keys = [ key for key in self.fitness_dict.keys() ]
fitness_values = [ val for val in self.fitness_dict.values() ]
_, _, dc, ndr = pyg.fast_non_dominated_sorting(fitness_values)
ndf = pyg.non_dominated_front_2d(fitness_values)
logger.info(name + "\nNon dominated vectors: "+str(len(ndf)) + "\nDomination count: " + str(dc) +"\nNon domination ranks: " + str(ndr))
pl.plot_front(name +" all fits", fitness_values, ndf)
# Save ndf results to file
with open(cfg.RESULTS_PATH + cfg.timestamp + '/NDF-' + name + '.csv', mode='w') as data_file:
data_writer = csv.writer(data_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
for i in ndf:
data = np.concatenate((fitness_keys[i], fitness_values[i]), axis=None)
data = np.concatenate((data, self.complete_results[fitness_keys[i]]), axis=None)
data_writer.writerow(data)
def updatePopulation(self, update: PopulationUpdate) -> None:
features = self.aurora.characterize(update.behaviors)
super().updatePopulation(update)
fitnesses = np.array([g.fitness for g in self.genomes])
novelties = None
if self.use_local_competition:
novelties, fitnesses = self.novelty_search.calculate_local_competition(
features, fitnesses)
else:
novelties = self.novelty_search.calculate_novelty(
features, fitnesses)
print(novelties)
for genome, novelty in zip(self.genomes, novelties):
genome.novelty = novelty
# Fitness and novelty are made negative, because the non dominated sorting
# is a minimalization algorithm
points = list(zip(-fitnesses, -novelties))
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(points=points)
for i in range(len(ndf)):
front_genomes = [self.genomes[j] for j in ndf[i]]
front_points = [points[j] for j in ndf[i]]
front_ranks = [ndr[j] for j in ndf[i]]
crowding_distances = pg.crowding_distance(
front_points) if len(front_points) > 1 else np.zeros(
(len(front_points)))
for g, d, r in zip(front_genomes, crowding_distances, front_ranks):
g.data['crowding_distance'] = d
g.data['rank'] = r
# super().updatePopulation(update)
self.epochs += 1
def _calc_pareto_front(self, n_pareto_points=100):
pf = None
p_size, p = uniform_points(n_pareto_points, self.n_obj)
c = np.ones((p_size, self.n_obj))
for i in range(p_size):
for j in range(1, self.n_obj):
tmp = p[i, j] / p[i, 0] * np.prod(1 - c[i, self.n_obj - 1 - j +
1:self.n_obj - 1])
c[i, self.n_obj - j -
1] = (tmp**2 - tmp + np.sqrt(2 * tmp)) / (tmp**2 + 1)
x = np.arccos(c) * 2 / np.pi
tmp = (1 - np.sin(np.pi / 2 * x[:, 1])) * p[:, self.n_obj -
1] / p[:, self.n_obj - 2]
tmp = np.atleast_2d(tmp).reshape(-1, 1)
a = np.arange(0, 1.00001, 0.0001)
a = np.atleast_2d(a).reshape(1, -1)
len_x = x.shape[0]
E = np.abs(
tmp.dot(1 - np.cos(np.pi / 2 * a)) - 1 +
np.repeat(a * np.cos(5 * np.pi * a)**2, len_x, axis=0))
rank = np.argsort(E, axis=1)
for i in range(len_x):
x[i, 0] = a[0, min(rank[i, 1:10])]
p = convex(x)
p[:, self.n_obj - 1] = disc(x)
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(p)
ndf = list(ndf)
# tmp = np.atleast_2d([np.inf] * len(p))
# tmp[:, ndf[0]] = 1
p = p[ndf[0], :]
len_p = len(p)
p1 = np.repeat(np.atleast_2d(np.arange(2, 2 * self.n_obj + 1, 2)),
len_p,
axis=0)
pf = p1 * p
return pf
def normalization_with_nd(mu, data_y):
# using nd front as normalization boundary
n_obj = data_y.shape[1]
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(data_y)
ndf = list(ndf)
ndf_size = len(ndf)
# extract nd for normalization
if len(ndf[0]) > 1:
ndf_extend = ndf[0]
else:
ndf_extend = np.append(ndf[0], ndf[1])
nd_front = data_y[ndf_extend, :]
# normalization boundary
min_nd_by_feature = np.amin(nd_front, axis=0)
max_nd_by_feature = np.amax(nd_front, axis=0)
if np.any(max_nd_by_feature - min_nd_by_feature < 1e-5):
print('nd front aligned problem, re-select nd front')
ndf_index = ndf[0]
for k in np.arange(1, ndf_size):
ndf_index = np.append(ndf_index, ndf[k])
nd_front = data_y[ndf_index, :]
min_nd_by_feature = np.amin(nd_front, axis=0)
max_nd_by_feature = np.amax(nd_front, axis=0)
if np.any(max_nd_by_feature - min_nd_by_feature < 1e-5):
continue
else:
break
# normalize nd front and x population for ei
norm_nd = (nd_front - min_nd_by_feature) / (max_nd_by_feature - min_nd_by_feature)
norm_mu = (mu - min_nd_by_feature) / (max_nd_by_feature - min_nd_by_feature)
point_reference = np.atleast_2d([1.1] * n_obj)
return norm_mu, norm_nd, point_reference
return archs_list_unique, science_ref_unique, cost_ref_unique, n_instr_unique
archs_unique, science_all_unique, cost_all_unique, num_instr = remove_duplicates(
archs_all, science_all, cost_all)
### Find the non-dominated architectures
scores = np.empty([len(archs_unique), 2])
for i in range(len(archs_unique)):
scores[i] = [-float(science_all_unique[i]), float(cost_all_unique[i])]
#science_floats = map(float, science_all_unique)
#cost_floats = map(float, cost_all_unique)
#non_dominated_points = pg.non_dominated_front_2d(scores)
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(scores)
#domination_bools = pg.pareto_dominance(science_floats, cost_floats)
### Plot the pareto fronts
def plot_pareto_fronts(non_dom_front, archs, science, cost, n_fronts_plot):
colors = iter(cm.rainbow(np.linspace(0, 1, n_fronts_plot)))
archs_pareto = []
science_pareto = []
cost_pareto = []
archs_instr_pareto = []
n_archs = 0
for i in range(n_fronts_plot):
archs_rank = []
science_rank = []
# # NDF = A and C since no solution(s) dominate A and C
# # points = [[0, 1], [0, 3], [0.8, 0], [0, 0.9], [0.7, 0]]
# # points = [[0,1],[-1,3],[2.3,-0.2],[1.1,-0.12],[1.1, 2.12],[-1.1,-1.1]]
# # points = [[0, 1], [1, 0]]
# nadir = pg.nadir(points) # The nadir is that point that has the maximum value of the objective function in the points of the non-dominated front.
# ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(points)
# print nadir
# print ndf[0] # list of indices of nd solutions
fronts = os.listdir('raw/')
for front in fronts:
print front
original_pf = np.loadtxt('raw/' + front)
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(original_pf)
if len(ndf[0]) < len(
original_pf): # remove dominated and store non-dom new file
print "Removing dominated and saving to file"
new_pf = []
d = [] # dominated sols indices
for i in range(len(original_pf)):
if i in ndf[0]:
new_pf.append(original_pf[i])
else:
d.append(i)
print 'Number of dominated sols => ', len(
d) # number of dominated sols
new_pf = np.array(new_pf).astype(np.float)
def main():
# Parse command line arguments
args = parse_args()
# Extract arguments
ntask = args.ntask
nprocmin_pernode = args.nprocmin_pernode
optimization = args.optimization
nrun = args.nrun
TUNER_NAME = args.optimization
(machine, processor, nodes, cores) = GetMachineConfiguration()
print ("machine: " + machine + " processor: " + processor + " num_nodes: " + str(nodes) + " num_cores: " + str(cores))
os.environ['MACHINE_NAME'] = machine
os.environ['TUNER_NAME'] = TUNER_NAME
nprocmax = nodes*cores
matrices = ["big.rua", "g4.rua", "g20.rua"]
# matrices = ["Si2.bin", "SiH4.bin", "SiNa.bin", "Na5.bin", "benzene.bin", "Si10H16.bin", "Si5H12.bin", "SiO.bin", "Ga3As3H12.bin","H2O.bin"]
# matrices = ["Si2.bin", "SiH4.bin", "SiNa.bin", "Na5.bin", "benzene.bin", "Si10H16.bin", "Si5H12.bin", "SiO.bin", "Ga3As3H12.bin", "GaAsH6.bin", "H2O.bin"]
# Task parameters
matrix = Categoricalnorm (matrices, transform="onehot", name="matrix")
# Input parameters
COLPERM = Categoricalnorm (['2', '4'], transform="onehot", name="COLPERM")
LOOKAHEAD = Integer (5, 20, transform="normalize", name="LOOKAHEAD")
nprows = Integer (1, nprocmax, transform="normalize", name="nprows")
npernode = Integer (int(math.log2(nprocmin_pernode)), int(math.log2(cores)), transform="normalize", name="npernode")
NSUP = Integer (30, 300, transform="normalize", name="NSUP")
NREL = Integer (10, 40, transform="normalize", name="NREL")
time = Real (float("-Inf") , float("Inf"), name="time")
memory = Real (float("-Inf") , float("Inf"), name="memory")
IS = Space([matrix])
PS = Space([COLPERM, LOOKAHEAD, npernode, nprows, NSUP, NREL])
OS = Space([time, memory])
constraints = {"cst1" : cst1, "cst2" : cst2}
models = {}
constants={"nodes":nodes,"cores":cores}
""" Print all input and parameter samples """
print(IS, PS, OS, constraints, models)
problem = TuningProblem(IS, PS, OS, objectives, constraints, None, constants=constants)
computer = Computer(nodes = nodes, cores = cores, hosts = None)
""" Set and validate options """
options = Options()
options['model_processes'] = 1
# options['model_threads'] = 1
options['model_restarts'] = 1
# options['search_multitask_processes'] = 1
# options['model_restart_processes'] = 1
options['distributed_memory_parallelism'] = False
options['shared_memory_parallelism'] = False
options['model_class'] = 'Model_LCM'
options['verbose'] = False
options['search_algo'] = 'nsga2' #'maco' #'moead' #'nsga2' #'nspso'
options['search_pop_size'] = 1000
options['search_gen'] = 10
options['search_more_samples'] = 4
options.validate(computer = computer)
if(TUNER_NAME=='GPTune'):
""" Building MLA with the given list of tasks """
giventasks = [["big.rua"]]
# giventasks = [["Si2.bin"],["SiH4.bin"]]
# giventasks = [["Si2.bin"],["SiH4.bin"], ["SiNa.bin"], ["Na5.bin"], ["benzene.bin"], ["Si10H16.bin"], ["Si5H12.bin"], ["SiO.bin"], ["Ga3As3H12.bin"],["GaAsH6.bin"],["H2O.bin"]]
# giventasks = [["Si2.bin"],["SiH4.bin"], ["SiNa.bin"], ["Na5.bin"], ["benzene.bin"], ["Si10H16.bin"], ["Si5H12.bin"], ["SiO.bin"]]
for tmp in giventasks:
giventask = [tmp]
data = Data(problem)
gt = GPTune(problem, computer = computer, data = data, options = options, driverabspath=os.path.abspath(__file__))
NI = len(giventask)
NS = nrun
(data, model,stats) = gt.MLA(NS=NS, NI=NI, Igiven =giventask, NS1 = max(NS//2,1))
print("stats: ",stats)
""" Print all input and parameter samples """
for tid in range(NI):
print("tid: %d"%(tid))
print(" matrix:%s"%(data.I[tid][0]))
print(" Ps ", data.P[tid])
print(" Os ", data.O[tid].tolist())
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(data.O[tid])
front = ndf[0]
# print('front id: ',front)
fopts = data.O[tid][front]
xopts = [data.P[tid][i] for i in front]
print(' Popts ', xopts)
print(' Oopts ', fopts.tolist())
def optimizer_DE(problem, nobj, ncon, bounds, recordFlag, pop_test, F, CR, NP, itermax, flag, **kwargs):
# NP: number of population members/popsize
# itermax: number of generation
import matplotlib.pyplot as plt
import pygmo as pg
plt.ion()
dimensions = len(bounds)
# Check input variables
VTR = -np.inf
refresh = 0
# F = 0.8
# CR = 0.8
strategy = 6
use_vectorize = 1
if NP < 5:
NP = 5
print('pop size is increased to minimize size 5')
if CR < 0 or CR > 1:
CR = 0.5
print('CR should be from interval [0,1]; set to default value 0.5')
if itermax <= 0:
itermax = 200
print('generation size is set to default 200')
# Initialize population and some arrays
# if pop is a matrix of size NPxD. It will be initialized with random
# values between the min and max values of the parameters
min_b, max_b = np.asarray(bounds).T
diff = np.fabs(min_b - max_b)
pop = np.random.rand(NP, dimensions)
pop_x = min_b + pop * diff
# for test
# pop_x = np.loadtxt('pop.csv', delimiter=',')
if 'add_info' in kwargs.keys():
print(kwargs['add_info'])
guide_x = kwargs['add_info']
if 'callback' in kwargs.keys():
bilevel_fix = kwargs['callback']
level = kwargs['level']
compensate_x = kwargs['other_x']
if 'add_info' in kwargs.keys():
pop_x[0, :] = guide_x
pop[0, :] = (guide_x - min_b)/diff
XVmin = np.repeat(np.atleast_2d(min_b), NP, axis=0)
XVmax = np.repeat(np.atleast_2d(max_b), NP, axis=0)
if ncon != 0:
if 'callback' in kwargs.keys():
pop_x_complete = bilevel_fix(pop_x, level, compensate_x)
pop_f, pop_g = problem.evaluate(pop_x_complete, return_values_of=["F", "G"], **kwargs)
else:
pop_f, pop_g = problem.evaluate(pop_x, return_values_of=["F", "G"], **kwargs)
tmp = pop_g.copy()
tmp[tmp <= 0] = 0
pop_cv = tmp.sum(axis=1)
if ncon == 0:
# np.savetxt('test_x.csv', pop_x, delimiter=',')
if 'callback' in kwargs.keys():
pop_x_complete = bilevel_fix(pop_x, level, compensate_x)
pop_f = problem.evaluate(pop_x_complete, return_values_of=["F"], **kwargs)
else:
pop_f = problem.evaluate(pop_x, return_values_of=["F"], **kwargs)
# plot_infill_landscape(**kwargs)
#-------------plot---------
if flag:
plt.clf()
obj_f1, _ = kwargs['krg'][0].predict(pop_x)
obj_f2, _ = kwargs['krg'][1].predict(pop_x)
nadir = kwargs['nadir']
ideal = kwargs['ideal']
train_y = kwargs['train_y']
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(train_y)
ndf = list(ndf)
nd_front = train_y[ndf[0], :]
plt.scatter(nd_front[:, 0], nd_front[:, 1], marker='o', c='g')
plt.scatter(obj_f1.ravel(), obj_f2.ravel())
plt.xlim((0, 3))
plt.ylim((0, 4))
plt.scatter(nadir[0], nadir[1], marker='+', c='r')
plt.text(nadir[0], nadir[1], 'nadir')
plt.scatter(ideal[0], ideal[1], marker='+', c='r')
plt.text(ideal[0], ideal[1], 'ideal')
plt.pause(0.5)
# best member of current iteration
bestval = np.min(pop_f) # single objective only
ibest = np.where(pop_f == bestval) # what if multiple best values?
bestmemit = pop_x[ibest[0][0]] # np.where return tuple of (row_list, col_list)
best_f_gen = []
# save best_x ever
bestmem = bestmemit
# DE-Minimization
# popold is the population which has to compete. It is static through one
# iteration. pop is the
# newly emerging population
# initialize bestmember matrix
bm = np.zeros((NP, dimensions))
# intermediate population of perturbed vectors
ui = np.zeros((NP, dimensions))
# rotating index array (size NP)
rot = np.arange(0, NP)
# rotating index array (size D)
rotd = np.arange(0, dimensions) # (0:1:D-1);
iter = 1
while iter < itermax and bestval > VTR:
# save the old population
# print('iteration: %d' % iter)
oldpop_x = pop_x.copy()
# index pointer array
ind = np.random.permutation(4) + 1
# shuffle locations of vectors
a1 = np.random.permutation(NP)
# for test
# a1 = np.loadtxt('a1.csv', delimiter=',')
# a1 = np.array(list(map(int, a1)))-1
# rotate indices by ind(1) positions
rt = np.remainder(rot + ind[0], NP)
# rotate vector locations
a2 = a1[rt]
# for test
# a2 = np.loadtxt('a2.csv', delimiter=',')
# a2 = np.array(list(map(int, a2)))-1
rt = np.remainder(rot + ind[1], NP)
a3 = a2[rt]
# for test
# a3 = np.loadtxt('a3.csv', delimiter=',')
# a3 = np.array(list(map(int, a3)))-1
rt = np.remainder(rot + ind[2], NP)
a4 = a3[rt]
# for test
# a4 = np.loadtxt('a4.csv', delimiter=',')
# a4 = np.array(list(map(int, a4)))-1
rt = np.remainder(rot + ind[3], NP)
a5 = a4[rt]
# for test
# a5 = np.loadtxt('a5.csv', delimiter=',')
# a5 = np.array(list(map(int, a5)))-1
# shuffled population 1
pm1 = oldpop_x[a1, :]
pm2 = oldpop_x[a2, :]
pm3 = oldpop_x[a3, :]
pm4 = oldpop_x[a4, :]
pm5 = oldpop_x[a5, :]
# population filled with the best member of the last iteration
# print(bestmemit)
for i in range(NP):
bm[i, :] = bestmemit
mui = np.random.rand(NP, dimensions) < CR
# mui = np.loadtxt('mui.csv', delimiter=',')
if strategy > 5:
st = strategy - 5
else:
# exponential crossover
st = strategy
# transpose, collect 1's in each column
# did not implement following strategy process
# inverse mask to mui
# mpo = ~mui
mpo = mui < 0.5
if st == 1: # DE/best/1
# differential variation
ui = bm + F * (pm1 - pm2)
# crossover
ui = oldpop_x * mpo + ui * mui
if st == 2: # DE/rand/1
# differential variation
ui = pm3 + F * (pm1 - pm2)
# crossover
ui = oldpop_x * mpo + ui * mui
if st == 3: # DE/rand-to-best/1
ui = oldpop_x + F * (bm - oldpop_x) + F * (pm1 - pm2)
ui = oldpop_x * mpo + ui * mui
if st == 4: # DE/best/2
ui = bm + F * (pm1 - pm2 + pm3 - pm4)
ui = oldpop_x * mpo + ui * mui
if st == 5: #DE/rand/2
ui = pm5 + F * (pm1 - pm2 + pm3 - pm4)
ui = oldpop_x * mpo + ui * mui
# correcting violations on the lower bounds of the variables
# validate components
maskLB = ui > XVmin
maskUB = ui < XVmax
# part one: valid points are saved, part two/three beyond bounds are set as bounds
ui = ui * maskLB * maskUB + XVmin * (~maskLB) + XVmax * (~maskUB)
# Select which vectors are allowed to enter the new population
if use_vectorize == 1:
if ncon != 0:
if 'callback' in kwargs.keys():
ui_complete = bilevel_fix(ui, level, compensate_x)
pop_f_temp, pop_g_temp = problem.evaluate(ui_complete, return_values_of=["F", "G"], **kwargs)
else:
pop_f_temp, pop_g_temp = problem.evaluate(ui, return_values_of=["F", "G"], **kwargs)
tmp = pop_g_temp.copy()
tmp[tmp <= 0] = 0
pop_cv_temp = tmp.sum(axis=1)
if ncon == 0:
if 'callback' in kwargs.keys():
ui_complete = bilevel_fix(ui, level, compensate_x)
pop_f_temp = problem.evaluate(ui_complete, return_values_of=["F"], **kwargs)
else:
pop_f_temp = problem.evaluate(ui, return_values_of=["F"], **kwargs)
# if competitor is better than value in "cost array"
indx = pop_f_temp <= pop_f
# replace old vector with new one (for new iteration)
change = np.where(indx)
pop_x[change[0], :] = ui[change[0], :]
pop_f[change[0], :] = pop_f_temp[change[0], :]
# we update bestval only in case of success to save time
indx = pop_f_temp < bestval
if np.sum(indx) != 0:
# best member of current iteration
bestval = np.min(pop_f_temp) # single objective only
ibest = np.where(pop_f_temp == bestval) # what if multiple best values?
'''
if len(ibest[0]) > 1:
print(
"multiple best values, selected first"
)
'''
bestmem = ui[ibest[0][0], :]
# freeze the best member of this iteration for the coming
# iteration. This is needed for some of the strategies.
bestmemit = bestmem.copy()
if refresh == 1:
print('Iteration: %d, Best: %.4f, F: %.4f, CR: %.4f, NP: %d' % (iter, bestval, F, CR, NP))
iter = iter + 1
if flag:
plt.clf()
obj_f1, _ = kwargs['krg'][0].predict(pop_x)
obj_f2, _ = kwargs['krg'][1].predict(pop_x)
nadir = kwargs['nadir']
ideal = kwargs['ideal']
plt.scatter(obj_f1.ravel(), obj_f2.ravel(), c='r')
plt.xlim((0, 3))
plt.ylim((0, 4))
plt.scatter(nadir[0], nadir[1], marker='+', c='r')
plt.text(nadir[0], nadir[1], 'nadir')
plt.scatter(ideal[0], ideal[1], marker='+', c='r')
plt.scatter(nd_front[:, 0], nd_front[:, 1], marker='o', c='g')
plt.text(ideal[0], ideal[1], 'ideal')
plt.pause(0.5)
print(pop_f.reshape(1, -1))
del oldpop_x
plt.ioff()
#print(pop_f.reshape(1, -1))
return np.atleast_2d(bestmem), np.atleast_2d(bestval)
def evaluate_pop(self):
cvi1 = self.cvi1
cvi2 = self.cvi2
cvi3 = self.cvi3
data = self.data
size = self.size
self.scores = [
] #list to store the evaluation score of the best model in each iteration
# calculate the integer value for the offspring out of the total size (20% out of total population)
offspring20 = size // 5
# calculate the integer value for the crossover out of the total size (5%)
crossover5 = size // 20
log = open("log.txt", "w")
for iteration in range(self.iterations): # start the optimization
population = self.population
vals12 = [
] # empty list to store the output for the first two evaluation metrics
vals3 = [
] # empty list to store the output for the third evaluation metric
indx = [
] # empty list to store the index of the successful configuration from the population
curr = []
for i in range(size):
if len(population[i]) <= 10:
try:
# process the cluster of each configuration in the population
clustering = population[i][1].fit(data)
except:
continue
try:
# get the clustering labels
labels = list(clustering.labels_)
# if the output has one cluster or n clusters, ignore it
if len(set(labels)) == 1 or len(
set(labels)) >= (len(data) - 1):
continue
except:
continue
try:
sample_size = int(
len(data) * 0.1) # what is the use of this part???
if sample_size < 100: #
sample_size = len(data) #
# some algorithms return cluster labels
# where the label numbering starts from -1
# we increment such labels with one,
# otherwise (in case of the old solution)
# we have 0 labels more than needed
if -1 in labels:
labels = list(np.array(labels) + 1)
# for u in range(len(labels)):
# if labels[u] < 0:
# labels[u] = 0
# evaluate clustering
validate = Validation(
np.asmatrix(data).astype(np.float), labels)
metric_values = validate.run_list(
list(set([cvi1[0], cvi2[0], cvi3[0]])))
if "SDBW" in [cvi1[0], cvi2[0]]:
sdbw_c = sdbw(
np.asmatrix(data).astype(np.float),
clustering.labels_,
clustering.cluster_centers_)
metric_values["SDBW"] = sdbw_c.sdbw_score()
# first two eval metrics
vals12.append([
metric_values[cvi1[0]] * cvi1[1],
metric_values[cvi2[0]] * cvi2[1]
])
vals3.append(metric_values[cvi3[0]] *
cvi3[1]) # third eval metric
try:
self.population[i][2] = metric_values[
cvi3[0]] * cvi3[1]
except:
self.population[i].append(metric_values[cvi3[0]] *
cvi3[1])
try:
self.population[i][3] = vals12[-1]
except:
self.population[i].append(vals12[-1])
except:
continue
else:
vals12.append(population[i][3])
vals3.append(population[i][2])
indx.append(i)
curr.append(population[i])
indx.append(i)
# pareto front optimization to order the configurations using the two eval metrics
vals12 = np.array(vals12)
l1 = vals12[:, 0]
min1 = min(l1)
max1 = max(l1)
for i in range(len(l1)):
l1[i] = (l1[i] - min1) / (max1 - min1)
l2 = vals12[:, 1]
min2 = min(l2)
max2 = max(l2)
for i in range(len(l2)):
l2[i] = (l2[i] - min2) / (max2 - min2)
for i in range(len(l2)):
vals12[i] = [l1[i], l2[i]]
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(points=vals12)
ndf.reverse()
# get the top 20% from the total population
top_20 = []
count = 0
for l in ndf:
temp = []
for ix in l:
#top_20.append(population[indx[ix]])
temp.append(curr[ix])
##top_20.append(curr[ix])
count += 1
if count >= offspring20:
break
temp = sorted(temp, key=itemgetter(2), reverse=True)
top_20.extend(temp)
if count >= offspring20:
break
#op_20=sorted(top_20, key=itemgetter(2),reverse=True)
try:
score = self.get_nmi_score(top_20[0][1])
except:
score = 0.0
log.write("iteration=> " + str(iteration) + "\n")
for pops in top_20:
log.write(str(pops).replace('\n', ' ') + "\n")
new_population = []
self.scores.append(score)
print("iteration: ", iteration, self.scores[-1], top_20[0])
self.iterations_log.write(
str(iteration) + "\t" + str(self.scores[-1]) + "\t" +
str(top_20[0]).replace('\n', ' ') + "\n")
new_population = list(top_20)
#print(top_20)
# do cross over
for c in range(0, crossover5 - 2, 2):
new_population.extend(
self.cross_over(population[offspring20 + c],
population[offspring20 + c + 1]))
# do mutation
for m in range(crossover5, offspring20):
if random.randint(1, 3) == 1:
new_population.extend(
self.mutation([population[m + offspring20]]))
else:
new_population.append(population[m + offspring20])
self.population = []
# update population and start new iteration
self.generate_pop(population=new_population)
return top_20 # return the final top 20 solutions
def main():
global ROOTDIR
global nodes
global cores
global target
global nprocmax
global nprocmin
# Parse command line arguments
args = parse_args()
# Extract arguments
ntask = args.ntask
nodes = args.nodes
cores = args.cores
nprocmin_pernode = args.nprocmin_pernode
machine = args.machine
optimization = args.optimization
nruns = args.nruns
truns = args.truns
# JOBID = args.jobid
TUNER_NAME = args.optimization
os.environ['MACHINE_NAME'] = machine
os.environ['TUNER_NAME'] = TUNER_NAME
nprocmax = nodes*cores-1 # YL: there is one proc doing spawning, so nodes*cores should be at least 2
nprocmin = min(nodes*nprocmin_pernode,nprocmax-1) # YL: ensure strictly nprocmin<nprocmax, required by the Integer space
# matrices = ["big.rua", "g4.rua", "g20.rua"]
# matrices = ["Si2.bin", "SiH4.bin", "SiNa.bin", "Na5.bin", "benzene.bin", "Si10H16.bin", "Si5H12.bin", "SiO.bin", "Ga3As3H12.bin","H2O.bin"]
matrices = ["Si2.bin", "SiH4.bin", "SiNa.bin", "Na5.bin", "benzene.bin", "Si10H16.bin", "Si5H12.bin", "SiO.bin", "Ga3As3H12.bin", "GaAsH6.bin", "H2O.bin"]
# Task parameters
matrix = Categoricalnorm (matrices, transform="onehot", name="matrix")
# Input parameters
COLPERM = Categoricalnorm (['2', '4'], transform="onehot", name="COLPERM")
LOOKAHEAD = Integer (5, 20, transform="normalize", name="LOOKAHEAD")
nprows = Integer (1, nprocmax, transform="normalize", name="nprows")
nproc = Integer (nprocmin, nprocmax, transform="normalize", name="nproc")
NSUP = Integer (30, 300, transform="normalize", name="NSUP")
NREL = Integer (10, 40, transform="normalize", name="NREL")
runtime = Real (float("-Inf") , float("Inf"), name="runtime")
memory = Real (float("-Inf") , float("Inf"), name="memory")
IS = Space([matrix])
PS = Space([COLPERM, LOOKAHEAD, nproc, nprows, NSUP, NREL])
OS = Space([runtime, memory])
cst1 = "NSUP >= NREL"
cst2 = "nproc >= nprows" # intrinsically implies "p <= nproc"
constraints = {"cst1" : cst1, "cst2" : cst2}
models = {}
""" Print all input and parameter samples """
print(IS, PS, OS, constraints, models)
problem = TuningProblem(IS, PS, OS, objectives, constraints, None)
computer = Computer(nodes = nodes, cores = cores, hosts = None)
""" Set and validate options """
options = Options()
options['model_processes'] = 1
# options['model_threads'] = 1
options['model_restarts'] = 1
# options['search_multitask_processes'] = 1
# options['model_restart_processes'] = 1
options['distributed_memory_parallelism'] = False
options['shared_memory_parallelism'] = False
options['model_class '] = 'Model_LCM'
options['verbose'] = False
options['search_algo'] = 'nsga2' #'maco' #'moead' #'nsga2' #'nspso'
options['search_pop_size'] = 1000
options['search_gen'] = 10
options['search_more_samples'] = 4
options.validate(computer = computer)
if(TUNER_NAME=='GPTune'):
""" Building MLA with the given list of tasks """
# giventasks = [["big.rua"], ["g4.rua"], ["g20.rua"]]
# giventasks = [["Si2.bin"],["SiH4.bin"]]
# giventasks = [["Si2.bin"],["SiH4.bin"], ["SiNa.bin"], ["Na5.bin"], ["benzene.bin"], ["Si10H16.bin"], ["Si5H12.bin"], ["SiO.bin"], ["Ga3As3H12.bin"],["GaAsH6.bin"],["H2O.bin"]]
giventasks = [["Si2.bin"],["SiH4.bin"], ["SiNa.bin"], ["Na5.bin"], ["benzene.bin"], ["Si10H16.bin"], ["Si5H12.bin"], ["SiO.bin"]]
for tmp in giventasks:
giventask = [tmp]
data = Data(problem)
gt = GPTune(problem, computer = computer, data = data, options = options)
NI = len(giventask)
NS = nruns
(data, model,stats) = gt.MLA(NS=NS, NI=NI, Igiven =giventask, NS1 = max(NS//2,1))
print("stats: ",stats)
""" Print all input and parameter samples """
for tid in range(NI):
print("tid: %d"%(tid))
print(" matrix:%s"%(data.I[tid][0]))
print(" Ps ", data.P[tid])
print(" Os ", data.O[tid].tolist())
ndf, dl, dc, ndr = pg.fast_non_dominated_sorting(data.O[tid])
front = ndf[0]
# print('front id: ',front)
fopts = data.O[tid][front]
xopts = [data.P[tid][i] for i in front]
print(' Popts ', xopts)
print(' Oopts ', fopts.tolist())
def finish(self):
if self.optimizer == "brute":
self.modelparms.write("\n")
self.modelprediction.write("\n")
self.modeldiff.write("\n")
self.modelparms.close()
self.modelprediction.close()
self.modeldiff.close()
return 1
self.x = np.array(self.x)
self.f_A = np.array(self.f_A)
self.rmsd_A = np.array(self.rmsd_A)
self.f_B = np.array(self.f_B)
self.rmsd_B = np.array(self.rmsd_B)
self.R2_A = np.array(self.R2_A)
self.R2_B = np.array(self.R2_B)
### Write out best result for selection A
### -------------------------------------
if self.fitter.decomp:
### ndf (list of 1D NumPy int array): the non-dominated fronts
### dl (list of 1D NumPy int array): the domination list
### dc (1D NumPy int array) : the domination count
### ndr (1D NumPy int array) : the non-domination ranks
ndf, dl, dc, ndr = pygmo.fast_non_dominated_sorting(self.f_A)
ax_A = pygmo.plot_non_dominated_fronts(self.f_A)
ax_A.figure.savefig("%spareto.selectionA.png" % self.prefix,
dpi=1000)
ax_A.figure.clear("all")
ordered_ndf = list()
for front in ndf:
ordered_ndf.append(pygmo.sort_population_mo(self.f_A[front]))
else:
ordered_ndf = np.argsort(self.f_A, axis=0)
self.modelparms.write("### Best result (A)\n")
self.modelprediction.write("### Best result (A)\n")
self.modeldiff.write("### Best result (A)\n")
for front_count, front in enumerate(ordered_ndf):
for solution_i in front:
step = self.step[solution_i]
x = self.x[solution_i]
f_A = self.f_A[solution_i]
f_B = self.f_B[solution_i]
rmsd_A = self.rmsd_A[solution_i]
rmsd_B = self.rmsd_B[solution_i]
R2_A = self.R2_A[solution_i]
R2_B = self.R2_B[solution_i]
self.modelparms.write("%d/%d " % (step, front_count))
self.modelprediction.write("%d/%d " % (step, front_count))
self.modeldiff.write("%d/%d " % (step, front_count))
self.fitter.gist_functional(x)
self.fitter._f_process(x)
if self.mode in [0, 3, 5]:
for i in self.parmidx:
self.modelparms.write("%6.3f " % x[i])
self.modelparms.write("%6.3f " % f_A[0])
self.modelparms.write("%6.3f " % f_B[0])
self.modelparms.write("%6.3f " % R2_A)
self.modelparms.write("%6.3f " % R2_B)
self.modelparms.write("%6.3f " % rmsd_A)
self.modelparms.write("%6.3f " % rmsd_B)
elif self.mode in [1, 4, 6, 7]:
### Energy Output
for i in self.parmidx:
self.modelparms.write("%6.3f " % x[i])
self.modelparms.write("%6.3f " % f_A[0])
self.modelparms.write("%6.3f " % f_B[0])
self.modelparms.write("%6.3f " % R2_A[0])
self.modelparms.write("%6.3f " % R2_B[0])
self.modelparms.write("%6.3f " % rmsd_A[0])
self.modelparms.write("%6.3f " % rmsd_B[0])
self.modelparms.write("\n")
### Entropy Output
self.modelparms.write("%d/%d " % (step, front_count))
for i in self.parmidx:
self.modelparms.write("%6.3f " % x[i])
self.modelparms.write("%6.3f " % f_A[1])
self.modelparms.write("%6.3f " % f_B[1])
self.modelparms.write("%6.3f " % R2_A[1])
self.modelparms.write("%6.3f " % R2_B[1])
self.modelparms.write("%6.3f " % rmsd_A[1])
self.modelparms.write("%6.3f " % rmsd_B[1])
else:
mode_error(self.mode)
if self.mode in [0, 3, 5]:
for i in range(self.N_len):
self.modelprediction.write("%6.3f " %
self.fitter._f[i])
diff = self.fitter._exp_data[i] - self.fitter._f[i]
self.modeldiff.write("%6.3f " % diff)
elif self.mode in [1, 4, 6, 7]:
for i in range(self.N_len):
self.modelprediction.write("%6.3f " %
self.fitter._f[i, 0])
diff = self.fitter._exp_data[i, 0] - self.fitter._f[i,
0]
self.modeldiff.write("%6.3f " % diff)
self.modelprediction.write("\n")
self.modelprediction.write("%d/%d " % (step, front_count))
self.modeldiff.write("\n")
self.modeldiff.write("%d/%d " % (step, front_count))
for i in range(self.N_len):
self.modelprediction.write("%6.3f " %
self.fitter._f[i, 1])
diff = self.fitter._exp_data[i, 1] - self.fitter._f[i,
1]
self.modeldiff.write("%6.3f " % diff)
else:
mode_error(self.mode)
self.modelparms.write("\n")
self.modelprediction.write("\n")
self.modeldiff.write("\n")
self.modelparms.write("\n")
self.modelprediction.write("\n")
self.modeldiff.write("\n")
self.modelparms.close()
self.modelprediction.close()
self.modeldiff.close()
