def NSGAII_Experiment():
NSGAII_results = {}
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(7,2,11)
problem.types[:] = [Real(2.6,3.6),Real(0.7,0.8),Real(17,28),Real(7.3,8.3),Real(7.3,8.3),Real(2.9,3.9),Real(5,5.5)]
problem.constraints[:] = "<=0"
problem.function = SRD
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'SRD'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([7000,1700])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(3,2,3)
problem.types[:] = [Real(1,3),Real(0.0005,0.05),Real(0.0005,0.05)]
problem.constraints[:] = "<=0"
problem.function = TBTD
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'TBTD'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([0.1,50000])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(4,2,5)
problem.types[:] = [Real(0.125,5),Real(0.1,10),Real(0.1,10),Real(0.125,5)]
problem.constraints[:] = "<=0"
problem.function = WB
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'WB'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([350,0.1])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(4,2,5)
problem.types[:] = [Real(55,80),Real(75,110),Real(1000,3000),Real(2,20)]
problem.constraints[:] = "<=0"
problem.function = DBD
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'DBD'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([5,50])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,5)
problem.types[:] = [Real(20,250),Real(10,50)]
problem.constraints[:] = "<=0"
problem.function = NBP
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'NBP'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([11150, 12500])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(6,3,9)
problem.types[:] = [Real(150,274.32),Real(25,32.31),Real(12,22),Real(8,11.71),Real(14,18),Real(0.63,0.75)]
problem.constraints[:] = "<=0"
problem.function = SPD
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'SPD'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([16,19000,-260000])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(7,3,10)
problem.types[:] = [Real(0.5,1.5),Real(0.45,1.35),Real(0.5,1.5),Real(0.5,1.5),Real(0.875,2.625),Real(0.4,1.2),Real(0.4,1.2)]
problem.constraints[:] = "<=0"
problem.function = CSI
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'CSI'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([42,4.5,13])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(3,5,7)
problem.types[:] = [Real(0.01,0.45),Real(0.01,0.1),Real(0.01,0.1)]
problem.constraints[:] = "<=0"
problem.function = WP
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'WP'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([83000, 1350, 2.85, 15989825, 25000])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,2)
problem.types[:] = [Real(0,5),Real(0,3)]
problem.constraints[:] = "<=0"
problem.function = BNH
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'BNH'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([140,50])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,2)
problem.types[:] = [Real(0.1,1),Real(0,5)]
problem.constraints[:] = "<=0"
problem.function = CEXP
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'CEXP'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([1,9])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(6,2,2)
problem.types[:] = [Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1)]
problem.constraints[:] = "<=0"
problem.function = C3DTLZ4
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'C3DTLZ4'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([3,3])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,2)
problem.types[:] = [Real(-20,20),Real(-20,20)]
problem.constraints[:] = "<=0"
problem.function = SRN
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'SRN'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([301,72])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,2)
problem.types[:] = [Real(1e-5,np.pi),Real(1e-5,np.pi)]
problem.constraints[:] = "<=0"
problem.function = TNK
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run( 40*problem.nvars)
funcname = 'TNK'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([3,3])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(6,2,6)
problem.types[:] = [Real(0,10),Real(0,10),Real(1,5),Real(0,6),Real(1,5),Real(0,10)]
problem.constraints[:] = "<=0"
problem.function = OSY
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run( 40*problem.nvars)
funcname = 'OSY'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([0,386])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,2,2)
problem.types[:] = [Real(0,1),Real(0,1)]
problem.constraints[:] = "<=0"
problem.function = CTP1
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run( 40*problem.nvars)
funcname = 'CTP1'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([1,2])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(10,2,1)
problem.types[:] = [Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1)]
problem.constraints[:] = "<=0"
problem.function = BICOP1
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'BICOP1'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([9,9])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(10,2,2)
problem.types[:] = [Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1),Real(0,1)]
problem.constraints[:] = "<=0"
problem.function = BICOP2
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'BICOP2'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([70,70])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
hypNS2 = [0]
random.seed(0)
for p in [5,8,10,20]:
hyp = []
for i in range(100):
problem = Problem(2,3,3)
problem.types[:] = [Real(-4,4),Real(-4,4)]
problem.constraints[:] = "<=0"
problem.function = TRICOP
algorithm = NSGAII(problem, p*problem.nvars)
algorithm.run(40*problem.nvars)
funcname = 'TRICOP'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([34,-4,90])
obj = []
for s in nondominated_solutions:
lijst = str(s.objectives)
obj.append(ast.literal_eval(lijst))
obj = np.array(obj)
hyp.append(hypervolume(obj,ref))
if np.mean(hyp) > np.mean(hypNS2):
hypNS2 = hyp
print(funcname, np.mean(hypNS2), '(', np.std(hypNS2), ')')
NSGAII_results[funcname] = hypNS2
return NSGAII_results
from platypus import NSGAII, DTLZ2
# define the problem definition
problem = DTLZ2()
# instantiate the optimization algorithm
algorithm = NSGAII(problem)
# optimize the problem using 10,000 function evaluations
algorithm.run(10000)
# display the results
for solution in algorithm.result:
print(solution.objectives)
mmax = 1000.0
problem = Problem(2,2,1)
problem.types[:] = [Real(umin_min,umin_max),Real(mmin,mmax)]
problem.constraints[:] = "<=0"
problem.function = uswitch_objective
# Run optimization in parallel
n_proc = 4
n_evals = 100000
alg_name = 'NSGAII'
#alg_name = 'NSGAIII'
#alg_name = 'SPEA2'
start_time = time.time()
with ProcessPoolEvaluator(n_proc) as evaluator:
if alg_name=='NSGAII':
algorithm = NSGAII(problem,evaluator=evaluator)
elif alg_name=='NSGAIII':
divs = 20
alg_name=alg_name+str(divs)
algorithm = NSGAIII(problem,divisions_outer=div,evaluator=evaluator)
elif alg_name=='SPEA2':
algorithm = SPEA2(problem,evaluator=evaluator)
else:
print("Using NSGAII algorithm by default")
algorithm = NSGAII(problem,evaluator=evaluator)
algorithm.run(n_evals)
print("Total run time = {:.2f} hours".format((time.time()-start_time)/3600.))
# Save Results
save_dir = "./Data/U_switch/plat/"
pareto_file_name = save_dir + "pareto_front_{0}_{1}_{2}_".format(d,tau_p,n_evals) + alg_name + "_dtmax{0}.npy".format(dtmax)
def grid_multi_GA(nx=20,
ny=20,
volume_frac=0.5,
parent=400,
generation=100,
path="data"):
PATH = os.path.join(path, "grid_nx_{}_ny_{}".format(nx, ny),
"gen_{}_pa_{}".format(generation, parent))
os.makedirs(PATH, exist_ok=True)
start = time.time()
def objective(vars):
rho = np.array(vars)
rho = rho.reshape(ny, nx - 1)
rho = np.concatenate([rho, np.ones((ny, 1))], 1)
volume = np.sum(rho) / (nx * ny)
return [calc_E(rho), calc_G(rho)], [volume]
# 2変数2目的の問題
problem = Problem(ny * (nx - 1), 2, 1)
# 最小化or最大化を設定
problem.directions[:] = Problem.MAXIMIZE
# 決定変数の範囲を設定
int1 = Integer(0, 1)
problem.types[:] = int1
problem.constraints[:] = "<=" + str(volume_frac)
problem.function = objective
problem.directions[:] = Problem.MAXIMIZE
algorithm = NSGAII(problem, population_size=parent)
algorithm.run(generation)
# グラフを描画
fig = plt.figure()
plt.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result],
c="blue",
label="infeasible solution")
plt.scatter([s.objectives[0] for s in algorithm.result if s.feasible],
[s.objectives[1] for s in algorithm.result if s.feasible],
c="red",
label='feasible solution')
# 非劣解をとりだす
nondominated_solutions = nondominated(algorithm.result)
plt.scatter(
[s.objectives[0] for s in nondominated_solutions if s.feasible],
[s.objectives[1] for s in nondominated_solutions if s.feasible],
c="green",
label="pareto solution")
plt.legend(loc='lower left')
plt.xlabel("$E$")
plt.ylabel("$G$")
fig.savefig(os.path.join(PATH, "graph.png"))
plt.close()
for solution in [s for s in nondominated_solutions if s.feasible]:
image_list = []
for j in solution.variables:
image_list.append(j)
image = np.array(image_list).reshape(ny, nx - 1)
image = np.concatenate([image, np.ones((ny, 1))], 1)
np.save(
os.path.join(
PATH, 'E_{}_G_{}.npy'.format(solution.objectives[0],
solution.objectives[1])), image)
convert_folder_npy_to_image(PATH)
elapsed_time = time.time() - start
with open("time.txt", mode='a') as f:
f.writelines("grid_nx_{}_ny_{}_gen_{}_pa_{}:{}sec\n".format(
nx, ny, generation, parent, elapsed_time))
from platypus import NSGAII, Problem, Integer
import CustomProblem
algorithm = NSGAII(CustomProblem.my_mo_problem())
algorithm.run(2000)
feasible_solutions = [s for s in algorithm.result if s.feasible]
# plot the results using matplotlib
'''
import matplotlib.pyplot as plt
plt.scatter([s.objectives[0] for s in feasible_solutions],
[s.objectives[1] for s in feasible_solutions])
plt.xlabel("$PRI(x)$")
plt.ylabel("$Cost(x)$")
plt.show()
'''
def N_Rp_Op():
def Op_ABC(C_all_points):
#len(C_all_points) = 10 (2 * Num_of_Points)
# for i in range(len(C_all_points)/2):
# i = i * 2
# print C_all_points[i],',',C_all_points[i+1]
# print ' '
#Point in Polygon?
for i in range(len(C_all_points) / 2):
i = i * 2
if g.point_in_polygon(
vg.Point(C_all_points[i], C_all_points[i + 1])) == -1:
pass
else:
return float('inf'), float('inf'), float('inf')
#change[a,b,c,d] to [[a,b],[c,d]]
CABC_all_points = []
for i in range(len(C_all_points) / 2):
i = i * 2
Temp_CABC = [C_all_points[i], C_all_points[i + 1]]
CABC_all_points.append(Temp_CABC)
ap = [Point(p) for p in CABC_all_points]
co = [LRF_(p.x, p.y, Radius) for p in ap]
#A: The intersect part of path coverage (Enclude polygons)
Sa = getIntersection(co).area
#B: The rest of the map's area except path coverage
Sb = getUnscanned(co).area
#C: The shortest distance
def Dis_PosC(x):
Dist_ = 0
Store_Comb = []
Permutation_list = []
list_ = []
for i in range(len(C_all_points) / 2):
list_.append(i)
list_Num = len(list_)
x_list = []
for i in range(len(C_all_points) / 2):
x[i] = math.floor(x[i])
x_list.append(int(round(x[i])))
for i in range(list_Num):
Permutation_list.append(list_[x_list[i]])
del list_[x_list[i]]
# for i in range(len(C_all_points)/2):
# print Permutation_list[i]
# print ' '
for i in range(len(C_all_points) / 2):
Store_Comb.append(CABC_all_points[Permutation_list[i]])
for i in range(len(C_all_points) / 2 - 1):
Dis_0 = vg.Point(Store_Comb[i][0], Store_Comb[i][1])
Dis_1 = vg.Point(Store_Comb[i + 1][0], Store_Comb[i + 1][1])
Dist = g.shortest_path(Dis_0, Dis_1)
_Dist_ = LineString(sp2list(Dist)).length
Dist_ = Dist_ + _Dist_
return Dist_
bounds_C = []
for i in range(len(C_all_points) / 2):
bounds_C.append((0.1, len(C_all_points) / 2 - i - 0.1))
Nearest_Dis = differential_evolution(Dis_PosC,
bounds_C,
maxiter=5,
polish=False)
Dc = Nearest_Dis.fun
# for i in range(len(C_all_points)/2):
# New_Nearest_Dis.append(Nearest_Dis.x[i])
#A - Sa; B - Sb; C - Dc
return Sa, Sb, Dc
min_x = po.bounds[0] + 10
max_x = po.bounds[2] - 10
min_y = po.bounds[1] + 10
max_y = po.bounds[3] - 10
Store_Adjust_fun = []
Store_Adjust_x = []
for Num_of_Random_ in range(3, 7):
Num_of_Random = Num_of_Random_
print Num_of_Random
bounds_ABC = []
for i in range(Num_of_Random * 2):
if (i % 2 == 0):
bounds_ABC.append((min_x, max_x))
else:
bounds_ABC.append((min_y, max_y))
problem = Problem(Num_of_Random_ * 2, 3)
problem.types = []
for i in range(Num_of_Random_ * 2):
if (i % 2 == 0):
problem.types.append(Real(min_x, max_x))
else:
problem.types.append(Real(min_y, max_y))
problem.function = Op_ABC
#Execute MO-NSGAII
algorithm = NSGAII(problem)
algorithm.run(1000)
# display the results
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, projection='3d')
ax.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result],
[s.objectives[2] for s in algorithm.result])
ax.set_title(algorithm)
ax.set_xlim([0, 6000])
ax.set_ylim([0, 6000])
ax.set_zlim([0, 250])
ax.view_init(elev=30.0, azim=45.0)
ax.locator_params(nbins=6)
plt.show()
# display the results
Result_Random_fun = []
Result_Random_x = []
for solution in algorithm.result:
Result_Random_fun.append(solution.objectives)
Result_Random_x.append(solution.variables)
Show_Result_Random_fun = []
Add_Result_Random_fun = []
for i in range(100):
Show_Result_Random_fun.append([
Result_Random_fun[i][0], Result_Random_fun[i][1],
Result_Random_fun[i][2]
])
Add_Result_Random_fun.append(Result_Random_fun[i][0] +
Result_Random_fun[i][1] +
Result_Random_fun[i][2])
#Find the minimum
Min_Result_Random_x = Add_Result_Random_fun.index(
min(Add_Result_Random_fun))
Store_Adjust_x.append(Result_Random_x[Min_Result_Random_x])
Store_Adjust_fun.append(Add_Result_Random_fun[Min_Result_Random_x])
#Find the Global minimum
GlobalMin_Result_Random_x = Store_Adjust_fun.index(min(Store_Adjust_fun))
Adjust_x.append(Store_Adjust_x[GlobalMin_Result_Random_x])
print Adjust_x
return Adjust_x
print('cego', funcName, np.mean(gdCEGO))
problem = Problem(7, 2, 11)
problem.types[:] = [
Real(2.6, 3.6),
Real(0.7, 0.8),
Real(17, 28),
Real(7.3, 8.3),
Real(7.3, 8.3),
Real(2.9, 3.9),
Real(5, 5.5)
]
problem.constraints[:] = "<=0"
problem.function = SRD
algorithm = NSGAII(problem, 200)
algorithm.run(100000)
funcname = 'SRD'
nondominated_solutions = nondominated(algorithm.result)
ref = np.array([7000, 1700])
refPF = []
for s in nondominated_solutions:
lijst = str(s.objectives)
refPF.append(ast.literal_eval(lijst))
refPF = np.array(refPF)
doMeasurement(refPF, funcname, ref)
problem = Problem(3, 2, 3)
problem.types[:] = [Real(1, 3), Real(0.0005, 0.05), Real(0.0005, 0.05)]
problem.constraints[:] = "<=0"
problem.function = TBTD
ProcessPoolExecutor(max_workers=8)
print("-------EMSGMOP:")
problem = EMSGMOP_problem(n, m, s_i, SA_i, p_i, d_hat_j_tmp, t_hat_ij_tmp,
d_ij, e_ij, theat_ij, fr_ij)
# 默认求最小目标值
problem.directions[:] = Problem.MINIMIZE
# algorithm = EpsMOEA(problem, epsilons=0.5)
# algorithm = MOEAD(problem)
# algorithm = SMPSO(problem)
# algorithm = OMOPSO(problem, epsilons=0.5)
# algorithm = EpsNSGAII(problem, epsilons=0.5)
# algorithm = SPEA2(problem)
# algorithm = GDE3(problem)
algorithm = NSGAII(problem)
# algorithm = NSGAIII(problem,divisions_outer=25)
algorithm.population_size = 10
algorithm.run(Algorithm_Run_NUM)
# feasible_solutions = [s for s in algorithm.result if s.feasible]
# if len(feasible_solutions) > 0:
# print(feasible_solutions.objectives)
# print("------------------")
# print("Population size: ")
# print(len(algorithm.result))
# # The output shows on each line the objectives for a Pareto optimal solution:
# for solution in algorithm.result:
# print(solution.variables)
Model_Input = (S0, I0, 0.0)
# GA Parameters
number_of_generations = 10000
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(fitness_function,
model=model,
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)
# Getting the feasible solutions only just to be safe
# The GA may generate bad solutions if number_of_generations is not enough or there are too many contraints
feasible_solutions = [s for s in algorithm.result if s.feasible]
beta = feasible_solutions[0].variables[0]
print('Beta Optimsed = {}'.format(beta))
gamma = feasible_solutions[0].variables[1]
print('Gamma Optimsed = {}'.format(gamma))
def my_graph(points, edges):
global n_dim
global fig
number = 0
d1 = pd.read_csv(points)
d2 = pd.read_csv(edges)
n_dim = len(d1.columns)
m1 = 'MDS'
m2 = 'MOPSO-NSGAII'
m3 = 'MOPSO-NSGAIII'
# ## MDS
mds = MDS(n_components=2)
dat = pd.DataFrame(mds.fit(d1).embedding_, columns=["x1", "x2"])
dij = manhattan_distances(d1.values, d1.values)
dis2 = manhattan_distances(dat.values, dat.values)
mds_stress = (np.sum((dij - dis2)**2))**0.5
mds_inter = number_of_intersection(dat["x1"], dat["x2"], d2)
graph(dat, d2, m1, number, 1, mds_stress, mds_inter)
print "MDS Stress : ", mds_stress
print "Total Intersection MDS = ", mds_inter
# ## Multi Objective Particle Swarm Optimization (MOPSO)
def objective_mopso(x):
twoD = np.reshape(x, (-1, 2))
dis = manhattan_distances(twoD, twoD)
stress = (np.sum((dij - dis)**2))**0.5
mopso_inter = number_of_intersection(x[0:][::2], x[1:][::2], d2)
return [stress, mopso_inter]
problem = Problem(len(d1) * 2, 2)
problem.types[:] = Real(-50, 50)
problem.function = objective_mopso
ngsaii = NSGAII(problem, population_size=100)
ngsaii.run(10000)
result = ngsaii.result
ngsaiii = NSGAIII(problem, population_size=100, divisions_outer=100)
ngsaiii.run(10000)
result2 = ngsaiii.result
ax = fig.add_subplot(1, 4, 4)
lngsaii = plt.scatter([s.objectives[0] for s in ngsaii.result],
[s.objectives[1] for s in ngsaii.result],
color='b')
lngsaiii = plt.scatter([s.objectives[0] for s in ngsaiii.result],
[s.objectives[1] for s in ngsaiii.result],
color='g')
lmds, = plt.plot(mds_stress, mds_inter, 'ro', markersize=8)
y_min, y_max = ax.get_ylim()
x_min, x_max = ax.get_xlim()
plt.xticks(
np.arange(math.floor(x_min), math.ceil(x_max),
math.ceil((math.ceil(x_max) - math.ceil(x_min)) / 5)))
if math.ceil(y_min) == math.floor(y_max):
plt.yticks(np.arange(math.ceil(y_min - 1.1), math.ceil(y_max + 1.1),
1))
else:
plt.yticks(
np.arange(
math.floor(y_min - .1), math.ceil(y_max + .1),
math.ceil(
(math.ceil(y_max + .1) - math.ceil(y_min - .1)) / 5)))
plt.savefig('./output/graph' + str(number) + '.png', bbox_inches='tight')
count = 0
out = {}
ngsaii_inter = result[0].objectives[1]
ngsaii_stress = result[0].objectives[0]
val = 0
for solution in ngsaii.result:
out[solution.objectives] = solution.variables
if solution.objectives[1] < ngsaii_inter:
ngsaii_inter = solution.objectives[1]
ngsaii_stress = solution.objectives[0]
val = count
count += 1
sample = out[result[val].objectives]
x = sample[0:][::2]
y = sample[1:][::2]
newD = pd.DataFrame({"x1": x, "x2": y})
print "Stress for NGSAII = ", ngsaii_stress
print "Total Intersection NGSAII = ", ngsaii_inter
graph(newD, d2, m2, number, 2, ngsaii_stress, ngsaii_inter)
count = 0
out = {}
ngsaiii_inter = result2[0].objectives[1]
ngsaiii_stress = result2[0].objectives[0]
val = 0
for solution in ngsaiii.result:
out[solution.objectives] = solution.variables
if solution.objectives[1] < ngsaiii_inter:
ngsaiii_inter = solution.objectives[1]
ngsaiii_stress = solution.objectives[0]
val = count
count += 1
sample = out[result2[val].objectives]
x = sample[0:][::2]
y = sample[1:][::2]
newD = pd.DataFrame({"x1": x, "x2": y})
print "Stress for NGSAIII = ", ngsaiii_stress
print "Total Intersection NGSAIII = ", ngsaiii_inter
graph(newD, d2, m3, number, 3, ngsaiii_stress, ngsaiii_inter)
state,
g(0),
num_steps,
energy_weight=0.0,
max_energy=4.439301)
problem = Problem(6 * num_steps, 2)
problem.types[:3 * num_steps] = Real(0, pi)
problem.types[3 * num_steps:] = Real(-pi, pi)
problem.function = lambda p: (optim.infidelity(array(p)),
optim.param_vec_energy(array(p)) / 1.9169321)
# instantiate the optimization algorithm
# optimize the problem using 10,000 function evaluations
# plot the results using matplotlib
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1)
algorithm = NSGAII(problem)
algorithm.run(10000)
ax.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result])
algorithm = NSGAII(problem, population_size=200)
algorithm.run(20000)
ax.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result])
ax.set_xlabel("$f_1(x)$")
ax.set_ylabel("$f_2(x)$")
fig.show()
def fit(self, x, y, bound=None, name=''):
self.y = np.array(y)
self.x = x
TS = 1
ND = len(y) - 1
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.E0,self.Q0,self.I0,self.J0, \
self.R0,self.N0,self.D0)
input_variables = [
'beta', 'epsilon_E', 'epsilon_Q', 'epsilon_J', 'Pi', 'mu', 'v',
'gamma1', 'gamma2', 'kappa1', 'kappa2', 'd1', 'd2', 'sigma1',
'sigma2'
]
number_of_generations = 1000
ga_population_size = 100
number_of_objective_targets = 1
number_of_constraints = 0
number_of_input_variables = len(input_variables)
problem = Problem(number_of_input_variables,
number_of_objective_targets, number_of_constraints)
problem.types[0] = Real(
0, 0.4
) # beta - Infectiousness and contact rate between a susceptible and an infectious individual
problem.types[1] = Real(
0, 0.5
) # epsilon_E - Modification parameter associated with infection from an exposed asymptomatic individual
problem.types[2] = Real(
0, 0.5
) # epsilon_Q - Modification parameter associated with infection from a quarantined individual
problem.types[3] = Real(
0, 1
) # epsilon_J - Modification parameter associated with infection from an isolated individual
problem.types[4] = Real(
0, 500
) # Pi - Rate of inflow of susceptible individuals into a region or community through birth or migration.
problem.types[5] = Real(
0, 0.00005
) # mu - The natural death rate for disease-free individuals
problem.types[6] = Real(
0,
0.1) # v - Rate of immunization of susceptible individuals
problem.types[7] = Real(
0, 0.3
) # gamma1 - Rate of quarantine of exposed asymptomatic individuals
problem.types[8] = Real(
0, 0.7
) # gamma2 - Rate of isolation of infectious symptomatic individuals
problem.types[9] = Real(
0, 0.3
) # kappa1 - Rate of development of symptoms in asymptomatic individuals
problem.types[10] = Real(
0, 0.3
) # kappa2 - Rate of development of symptoms in quarantined individuals
problem.types[11] = Real(
0, 0.1
) # d1 - Rate of disease-induced death for symptomatic individuals
problem.types[12] = Real(
0, 0.1
) # d2 - Rate of disease-induced death for isolated individuals
problem.types[13] = Real(
0, 0.1) # sigma1 - Rate of recovery of symptomatic individuals
problem.types[14] = Real(
0, 0.1) # sigma2 - Rate of recovery of isolated individuals
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)
algorithm.run(number_of_generations)
feasible_solutions = [s for s in algorithm.result if s.feasible]
self.beta = feasible_solutions[0].variables[
0] # Infectiousness and contact rate between a susceptible and an infectious individual
self.epsilon_E = feasible_solutions[0].variables[
1] # Modification parameter associated with infection from an exposed asymptomatic individual
self.epsilon_Q = feasible_solutions[0].variables[
2] # Modification parameter associated with infection from a quarantined individual
self.epsilon_J = feasible_solutions[0].variables[
3] # Modification parameter associated with infection from an isolated individual
self.Pi = feasible_solutions[0].variables[
4] # Rate of inflow of susceptible individuals into a region or community through birth or migration.
self.mu = feasible_solutions[0].variables[
5] # The natural death rate for disease-free individuals
self.v = feasible_solutions[0].variables[
6] # Rate of immunization of susceptible individuals
self.gamma1 = feasible_solutions[0].variables[
7] # Rate of quarantine of exposed asymptomatic individuals
self.gamma2 = feasible_solutions[0].variables[
8] # Rate of isolation of infectious symptomatic individuals
self.kappa1 = feasible_solutions[0].variables[
9] # Rate of development of symptoms in asymptomatic individuals
self.kappa2 = feasible_solutions[0].variables[
10] # Rate of development of symptoms in quarantined individuals
self.d1 = feasible_solutions[0].variables[
11] # Rate of disease-induced death for symptomatic individuals
self.d2 = feasible_solutions[0].variables[
12] # Rate of disease-induced death for isolated individuals
self.sigma1 = feasible_solutions[0].variables[
13] # Rate of recovery of symptomatic individuals
self.sigma2 = feasible_solutions[0].variables[
14] # Rate of recovery of isolated individuals
self.DS = self.mu + self.v
self.DE = self.gamma1 + self.kappa1 + self.mu
self.DI = self.gamma2 + self.d1 + self.sigma1 + self.mu
self.DJ = self.sigma2 + self.d2 + self.mu
self.DQ = self.mu + self.kappa2
file_address = 'optimised_coefficients/'
filename = "ParametrosAjustados_Modelo_{}_{}_{}_Dias.txt".format(
'SEQIJR_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()
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 fit(self, x, y, bound=None, name=''):
self.y = np.array(y)
self.x = x
TS = 1
ND = len(y) - 1
t_start = 0.0
t_end = ND
t_inc = TS
t_range = np.arange(t_start, t_end + t_inc, t_inc)
INPUT = (self.S, self.I, self.E, self.D, self.C, self.R, self.N)
input_variables = [
'beta0', 'alpha', 'kappa', 'gamma', 'sigma', 'lamb', 'mu', 'd'
]
# GA Parameters
number_of_generations = 1000
ga_population_size = 100
number_of_objective_targets = 1
number_of_constraints = 0
number_of_input_variables = len(input_variables)
problem = Problem(number_of_input_variables,
number_of_objective_targets, number_of_constraints)
problem.types[0] = Real(0, 2) #beta0
problem.types[1] = Real(0, 2) #alpha
problem.types[2] = Real(0, 2000) #kappa
problem.types[3] = Real(0, 2) #gamma
problem.types[4] = Real(0, 2) #sigma
problem.types[5] = Real(0, 2) #lamb
problem.types[6] = Real(0, 2) #mu
problem.types[7] = Real(0, 2) #d
problem.function = functools.partial(self.fitness_function,
y=y,
Model_Input=INPUT,
t_range=t_range)
algorithm = NSGAII(problem, population_size=ga_population_size)
algorithm.run(number_of_generations)
feasible_solutions = [s for s in algorithm.result if s.feasible]
self.beta0 = feasible_solutions[0].variables[0]
self.alpha = feasible_solutions[0].variables[1]
self.kappa = feasible_solutions[0].variables[2]
self.gamma = feasible_solutions[0].variables[3]
self.sigma = feasible_solutions[0].variables[4]
self.lamb = feasible_solutions[0].variables[5]
self.mu = feasible_solutions[0].variables[6]
self.d = feasible_solutions[0].variables[7]
file_address = 'optimised_coefficients/'
filename = "ParametrosAjustados_Modelo_{}_{}_{}_Dias.txt".format(
'SEIR_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()
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)
result_fit = spi.odeint(
self.SEIR_diff_eqs,
(self.S, self.I, self.E, self.D, self.C, self.R, self.N),
t_range,
args=(self.beta0, self.alpha, self.kappa, self.gamma, self.sigma,
self.lamb, self.mu, self.d))
plt.plot(result_fit[:, 1], c='b', label='Predição Infectados')
plt.plot(self.y, c='r', marker='o', markersize=3, label='Infectados')
plt.legend(fontsize=15)
plt.ylabel('Casos COnfirmados', fontsize=15)
plt.xlabel('Dias', fontsize=15)
plt.show()
class AM(Problem):
def __init__(self):
# we call Problem(2, 2, 2) to create a problem with
# two decision variables, two objectives, and two constraints, respectively
super(AM, self).__init__(3, 2)
self.types[:] = [Real(210, 280), Real(15, 50), Real(0.42, 0.7)]
# self.constraints[:] = "<=0"
def evaluate(self, solution):
t = solution.variables[0]
v = solution.variables[1]
h = solution.variables[2]
solution.objectives[:] = BNN_BL_obj(np.array([t, v, h]))
# solution.constraints[:] = [-x + y - 1, x + y - 7]
algorithm = NSGAII(AM())
algorithm.run(1000)
# plot the results using matplotlib
import matplotlib.pyplot as plt
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("$f_1(x)$")
plt.ylabel("$f_2(x)$")
plt.show()
def __init__(self,
problem,
epsilons,
population_size=100,
generator=RandomGenerator(),
selector=TournamentSelector(2),
variator=None,
**kwargs):
L = len(problem.nvars)
p = 1 / L
# Parameterization taken from
# Borg: An Auto-Adaptive MOEA Framework - Hadka, Reed
variators = [
GAOperator(SBX(probability=1.0, distribution_index=15.0),
PM(probability=p, distribution_index=20.0)),
GAOperator(PCX(nparents=3, noffspring=2, eta=0.1, zeta=0.1),
PM(probability=p, distribution_index=20.0)),
GAOperator(
DifferentialEvolution(crossover_rate=0.6, step_size=0.6),
PM(probability=p, distribution_index=20.0)),
GAOperator(
UNDX(nparents=3,
noffspring=2,
zeta=0.5,
eta=0.35 / math.sqrt(L)),
PM(probability=p, distribution_index=20.0)),
GAOperator(
SPX(nparents=L + 1,
noffspring=L + 1,
expansion=math.sqrt(L + 2)),
PM(probability=p, distribution_index=20.0)),
UM(probability=1 / L)
]
variator = Multimethod(self, variators)
super(GenerationalBorg, self).__init__(
NSGAII(problem, population_size, generator, selector, variator,
EpsilonBoxArchive(epsilons), **kwargs))
# class GeneAsGenerationalBorg(EpsilonProgressContinuation):
# '''A generational implementation of the BORG Framework, combined with
# the GeneAs appraoch for heterogenously typed decision variables
#
# This algorithm adopts Epsilon Progress Continuation, and Auto Adaptive
# Operator Selection, but embeds them within the NSGAII generational
# algorithm, rather than the steady state implementation used by the BORG
# algorithm.
#
# Note:: limited to RealParameters only.
#
# '''
#
# # TODO::
# # Addressing the limitation to RealParameters is non-trivial. The best
# # option seems to be to extent MultiMethod. Have a set of GAoperators
# # for each datatype.
# # next Iterate over datatypes and apply the appropriate operator.
# # Implementing this in platypus is non-trivial. We probably need to do some
# # dirty hacking to create 'views' on the relevant part of the
# # solution that is to be modified by the operator
# #
# # A possible solution is to create a wrapper class for the operators
# # This class would create the 'view' on the solution. This view should
# # also have a fake problem description because the number of
# # decision variables is sometimes used by operators. After applying the
# # operator to the view, we can than take the results and set these on the
# # actual solution
# #
# # Also: How many operators are there for Integers and Subsets?
#
# def __init__(self, problem, epsilons, population_size=100,
# generator=RandomGenerator(), selector=TournamentSelector(2),
# variator=None, **kwargs):
#
# L = len(problem.parameters)
# p = 1/L
#
# # Parameterization taken from
# # Borg: An Auto-Adaptive MOEA Framework - Hadka, Reed
# real_variators = [GAOperator(SBX(probability=1.0, distribution_index=15.0),
# PM(probability=p, distribution_index=20.0)),
# GAOperator(PCX(nparents=3, noffspring=2, eta=0.1, zeta=0.1),
# PM(probability =p, distribution_index=20.0)),
# GAOperator(DifferentialEvolution(crossover_rate=0.6,
# step_size=0.6),
# PM(probability=p, distribution_index=20.0)),
# GAOperator(UNDX(nparents= 3, noffspring=2, zeta=0.5,
# eta=0.35/math.sqrt(L)),
# PM(probability= p, distribution_index=20.0)),
# GAOperator(SPX(nparents=L+1, noffspring=L+1,
# expansion=math.sqrt(L+2)),
# PM(probability=p, distribution_index=20.0)),
# UM(probability = 1/L)]
#
# # TODO
# integer_variators = []
# subset_variators = []
#
# variators = [VariatorWrapper(variator) for variator in real_variators]
# variator = Multimethod(self, variators)
#
# super(GenerationalBorg, self).__init__(
# NSGAII(problem,
# population_size,
# generator,
# selector,
# variator,
# EpsilonBoxArchive(epsilons),
# **kwargs))
#
#
# class VariatorWrapper(object):
# def __init__(self, actual_variator, indices, problem):
# '''
#
# Parameters
# ----------
# actual_variator : underlying GAOperator
# indices : np.array
# indices to which the variator should be applied
# probem : a representation of the problem considering only the
# same kind of Parameters
#
# '''
# self.variator = actual_variator
# self.indices = indices
#
# def evolve(self, parents):
fake_parents = [self.create_view[p] for p in parents]
fake_children = self.variator.evolve(fake_parents)
# tricky, no 1 to 1 mapping between parents and children
# some methods have 3 parents, one child
children = [map_back]
pass
def test_platypus_nsgaii_step(two_reservoir_constrained_problem):
"""Undertake a single step of the NSGAII algorithm with a small population."""
algorithm = NSGAII(two_reservoir_constrained_problem.problem,
population_size=10)
algorithm.step()
def run2():
problem = Problem(40, 3)
#输入上述每个LID的可变规模区间——交互输入，如lid1=（x，y）x为面积下限，y为上限
problem.types[:] = [
Real(1000, 6500),
Real(1000, 6400),
Real(1000, 4200),
Real(1000, 4600),
Real(700, 3000),
Real(1000, 7450),
Real(2000, 9500),
Real(1000, 4300),
Real(700, 3400),
Real(1000, 4100),
Real(1000, 4200),
Real(1000, 5500),
Real(700, 3600),
Real(1000, 4000),
Real(1000, 14000),
Real(1000, 9500),
Real(1000, 9600),
Real(1000, 6100),
Real(1000, 4900),
Real(1000, 4500),
Real(1000, 3900),
Real(1000, 3600),
Real(1000, 3400),
Real(1000, 3400),
Real(1000, 3400),
Real(1000, 3200),
Real(1000, 3200),
Real(1000, 2900),
Real(1000, 2700),
Real(1000, 2700),
Real(1000, 2700),
Real(1000, 2500),
Real(1000, 2400),
Real(1000, 2400),
Real(1000, 2400),
Real(1000, 2200),
Real(1000, 2200),
Real(1000, 2200),
Real(1000, 2200),
Real(1000, 2200)
]
problem.function = schaffer
#
num = int(s)
#starttime = datetime.datetime.now()
algorithm = NSGAII(problem)
#输入循环次数——交互输入
algorithm.run(num)
for solution in algorithm.result:
print(solution.objectives)
print(solution)
endtime = datetime.datetime.now()
#
fig = plt.figure()
x = [s.objectives[0] for s in algorithm.result]
y = [s.objectives[1] for s in algorithm.result]
z = [s.objectives[2] for s in algorithm.result]
ax = Axes3D(fig)
ax.scatter(x, y, z)
ax.set_zlabel('SS', fontdict={'size': 10, 'color': 'red'})
ax.set_ylabel('RUNOFF', fontdict={'size': 10, 'color': 'red'})
ax.set_xlabel('COST', fontdict={'size': 10, 'color': 'red'})
plt.savefig(str(filename2) + '/result.png')
plt.show()
def EMSG(Algorithm_Run_NUM, n, m, s_i, SA_i, p_i, d_hat_j_tmp, t_hat_ij_tmp,
d_ij, e_ij, theat_ij, fr_ij):
ProcessPoolExecutor(max_workers=8)
print("-------EMSGMOP:")
problem = EMSGMOP_problem(n, m, s_i, SA_i, p_i, d_hat_j_tmp, t_hat_ij_tmp,
d_ij, e_ij, theat_ij, fr_ij)
# 默认求最小目标值
# problem.directions[:] = Problem.MINIMIZE
# algorithm = EpsMOEA(problem, epsilons=0.5)
# algorithm = MOEAD(problem)
# algorithm = SMPSO(problem)
# algorithm = OMOPSO(problem, epsilons=0.5)
# algorithm = EpsNSGAII(problem, epsilons=0.5)
# algorithm = SPEA2(problem)
# algorithm = GDE3(problem)
algorithm = NSGAII(problem)
# algorithm = NSGAIII(problem,divisions_outer=25)
algorithm.population_size = 10
algorithm.run(Algorithm_Run_NUM)
# feasible_solutions = [s for s in algorithm.result if s.feasible]
# if len(feasible_solutions) > 0:
# print(feasible_solutions.objectives)
# print("------------------")
# print("Population size: ")
# print(len(algorithm.result))
# # The output shows on each line the objectives for a Pareto optimal solution:
# for solution in algorithm.result:
# print(solution.variables)
objectives_result = algorithm.result[0].objectives
x_result = algorithm.result[0].variables
x_matrix = np.zeros([n, m])
for i in range(n):
for j in range(m):
x_matrix[i][j] = round(x_result[j + i * m])
r_s_i = x_matrix.sum(axis=1)
r_d_j = x_matrix.sum(axis=0)
print("objectives_result:")
print(objectives_result)
# print("x_matrix:")
# print(x_matrix)
print("r_s_i:")
print(r_s_i)
print("std of r_s_i-s_i:")
print(np.std(r_s_i - s_i))
print("r_d_j:")
print(r_d_j)
# plot the results using matplotlib
import matplotlib.pyplot as plt
plt.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result])
plt.xlabel("$f_1(x)$")
plt.ylabel("$f_2(x)$")
plt.show()
return objectives_result, x_matrix
'''
def Operwas2(nr_runs):
# if not all([check.get() for check in checks]):
# print('Not set!!!')
# return
#
# try:
# nr_runs = int(nr_runs)
# except:
# print('Could not convert number of runs', nr_runs, ' to an int (try again)')
# return
t_start = timer()
print('running start time: ', t_start)
print('Running set for: ', nr_runs, 'runs')
# Todo: set up folders
list_of_paths = [path_results, path_temp, path_pour_points, path_outputs]
for i in list_of_paths:
if not os.path.exists(i):
os.makedirs(i)
# reset data file
with open(file_all_generations, 'w') as f:
pass
# get the decision variable lists
junc = loadtxt(file_with_possible_locations, skiprows=1, delimiter=';')
if len(junc.shape) == 1:
junc = np.expand_dims(junc, axis=0)
print('junc is', junc)
print('type of junc is ', type(junc))
tuple_junctions = tuple(tuple(row) for row in junc)
print(tuple_junctions)
# set the problem via Class Problem
class Operwa2(Problem):
def __init__(self):
super(Operwa2, self).__init__(1, 2)
self.types[:] = LimitedBinary(len(junc))
self.directions[0] = Problem.MAXIMIZE
self.directions[1] = Problem.MAXIMIZE
self._maria_sols = []
self._maria_coords = []
self._iteration = 0
def evaluate(self, solution):
include_junctions = solution.variables[0]
coordinates = [
junc[i] for i in range(len(junc)) if include_junctions[i]
]
coordinates = np.array(coordinates)
# try:
_sol = AOKP(coordinates)
print(("Finished iteration {}".format(self._iteration)))
# except:
# _sol = (0,0)
# print(('iteration failed: ', sys.exc_info()[1]))
self._iteration += 1
_sol_tuple = tuple(_sol)
solution.objectives[:] = _sol_tuple
solution.constraints[:] = ">(0,0)"
nr_wwtp = sum(include_junctions)
to_save = "{},{},{},\"{}\"\n".format(nr_wwtp, _sol_tuple[0],
_sol_tuple[1],
include_junctions)
with open(file_all_generations, 'a') as f:
f.write(to_save)
# optimize the problem using 10,000 function evaluations
prob = Operwa2()
if nr_runs < 100:
nr_pop = nr_runs
else:
nr_pop = 100
print("number of population is ", nr_pop)
algorithm = NSGAII(prob,
nr_pop) # second parameter is for size of population
algorithm.run(nr_runs)
with open(file_with_results, 'w+') as file_handler:
for item in algorithm.result:
file_handler.write("{}\n".format(item))
x_coverage = [s.objectives[1] for s in algorithm.result]
y_bencost = [s.objectives[0] for s in algorithm.result]
z_wwtp = [sum(s.variables) for s in algorithm.result]
w_coord = [s.variables for s in algorithm.result]
if len(x_coverage) == 0 and len(y_bencost) == 0:
max_x_coverage = 1
max_y_bencost = 1
else:
max_x_coverage = max(x_coverage)
max_y_bencost = max(y_bencost)
df = pd.DataFrame(dict(x=x_coverage, y=y_bencost, s=z_wwtp, w=w_coord))
df.to_csv(file_with_last_population, index=None, header=True)
for key, row in df.iterrows():
plt.scatter(row['x'], row['y'], s=row['s'] * 10, alpha=.5)
plt.annotate(int(row['s']),
xy=(row['x'], row['y']),
ha='center',
va='center')
# plt.scatter(x, y, s=z*1000, alpha=0.5)
plt.xlim(xmin=0, xmax=1.2 * max_x_coverage)
plt.ylim(ymin=0, ymax=1.2 * max_y_bencost)
plt.xlabel("$Coverage$")
plt.ylabel("$Benefits/Costs$")
plt.grid()
plt.show()
# # # For each point, we add a text inside the bubble
# for s in algorithm.result:
# plt.text(plt.x.iloc[s.objectives[1]], plt.y.iloc[s.objectives[0]], plt.z.iloc[sum(s.variables)], horizontalalignment='center', size='medium', color='black',
# weight='semibold')
# bubbles = plt.subplots()
# produce a legend with a cross section of sizes from the scatter
# handles, labels = graph.legend(prop="sizes", alpha=0.5)
# legend2 = bubbles.legend(handles, labels, loc="upper right", title="Sizes")
print('End of optimization run')
t_end = timer()
print("Calculation took ", t_end - t_start, " seconds = ", \
(t_end - t_start) / 60, "minutes = ", \
((t_end - t_start) / 60) / 60, "hours")
# for solution in algorithm.result:
# print(solution.objectives)
for solution in algorithm.result:
print(df)
_, ax = plt.subplots(figsize=(11, 11))
ax.barh(y_pos, relevancy, align='center')
ax.set_yticks(y_pos)
ax.set_yticklabels(var_list)
ax.invert_yaxis()
ax.set_xlabel('Relevancy')
if objective_idx == 0:
ax.set_title('Best Variables - Sensitivity')
else:
ax.set_title('Best Variables - Specificity')
plt.show()
if __name__ == "__main__":
algorithm = NSGAII(SVM(), population_size=30)
algorithm.run(100)
nondominated_results = nondominated(algorithm.result)
# prints results
fig1 = plt.figure(figsize=[11, 11])
plt.scatter([s.objectives[0] for s in nondominated_results],
[s.objectives[1] for s in nondominated_results])
plt.xlim([0, 1.1])
plt.ylim([0, 1.1])
plt.xlabel("Sensitivity")
plt.ylabel("Specificity")
plt.show()
calculate_relevancy(nondominated_results, 0, 0.81, 15)
def Operwa(nr_wwtp, nr_runs, checks):
print('Optimization 1')
# if not all([check.get() for check in checks]):
# print('Not set!!!')
# return
#
try:
nr_wwtp = int(nr_wwtp)
except:
print('Could not convert number of wwtp', nr_wwtp,
' to an int (try again)')
return
try:
nr_runs = int(nr_runs)
except:
print('Could not convert number of runs', nr_runs,
' to an int (try again)')
return
t_start = timer()
print('running start time: ', t_start)
print('Running set for: ', nr_runs, 'runs')
# get the decision variable lists
junc = loadtxt(file_with_possible_locations, skiprows=1, delimiter=';')
#junc = loadtxt(file_with_possible_locations, delimiter=';')
if len(junc.shape) == 1:
junc = np.expand_dims(junc, axis=0)
print('junc is', junc)
print('type of junc is ', type(junc))
tuple_junctions = tuple(tuple(row) for row in junc)
print(tuple_junctions)
# set the problem via Class Problem
class Operwa(Problem):
def __init__(self):
super(Operwa, self).__init__(1, 2)
self.types[:] = Subset(tuple_junctions, nr_wwtp)
print('tuple_junctions', tuple_junctions)
self.directions[0] = Problem.MAXIMIZE
self.directions[1] = Problem.MAXIMIZE
self._maria_sols = []
self._maria_coords = []
self._iteration = 0
def evaluate(self, solution):
print('solution variables', solution.variables[:])
coordinates = solution.variables[:]
print(coordinates)
coordinates = np.array(coordinates[0])
print(coordinates)
#try:
_sol = AOKP(coordinates)
print(("Finished iteration {}".format(self._iteration)))
#except:
# sol = (0, 0)
# print(('iteration failed: ', sys.exc_info()[1]))
self._iteration += 1
_sol_tuple = tuple(_sol)
solution.objectives[:] = _sol_tuple
solution.constraints[:] = ">(0,0)"
to_save = "{},{},\"{}\"\n".format(_sol_tuple[0], _sol_tuple[1],
coordinates)
with open(file_all_generations, 'a') as f:
f.write(to_save)
# optimize the problem using function evaluations
prob = Operwa()
nr_runs = int(nr_runs)
if nr_runs < 100:
nr_pop = nr_runs
else:
nr_pop = 100
print("nr_pop is ", nr_pop)
print("type of nr_pop is ", type(nr_pop))
algorithm = NSGAII(
prob, nr_pop) # second parameter is for size of initial population
# default initial population (without second parameter) is 100
print('type of nr_runs is', type(nr_runs))
print('nr_runs is ', nr_runs)
algorithm.run(nr_runs)
with open(file_with_results, 'w+') as file_handler:
for item in algorithm.result:
file_handler.write("{}\n".format(item))
# Plot data in graph
x_coverage = [s.objectives[1] for s in algorithm.result]
y_bencost = [s.objectives[0] for s in algorithm.result]
print("Nr. of calculations = ", nr_runs)
print("Nr. of results =", len(x_coverage))
plt.scatter(x_coverage, y_bencost)
if len(x_coverage) == 0 and len(y_bencost) == 0:
max_x_coverage = 1
max_y_bencost = 1
else:
max_x_coverage = max(x_coverage)
max_y_bencost = max(y_bencost)
plt.xlim(xmin=0, xmax=1.1 * max_x_coverage)
plt.ylim(ymin=0, ymax=1.1 * max_y_bencost)
plt.xlabel("$Coverage$")
plt.ylabel("$Benefit/Costs$")
plt.grid()
plt.show()
print('End of optimization run')
t_end = timer()
print("Calculation took ", t_end - t_start, " seconds = ", \
(t_end - t_start) / 60, "minutes = ", \
((t_end - t_start) / 60) / 60, "hours")
for solution in algorithm.result:
print((solution.objectives))
def _pick_algorithm(myproblem,
algorithm,
population,
mutation_probability,
current_solution,
evaluator=None):
"""
Return a serial or parallel platypus.Algorithm object based on input string
:param myproblem: EZFF Problem to be optimized
:type myproblem: Problem
:param algorithm: EZFF Algorithm to use for optimization. Allowed options are ``NSGAII``, ``NSGAIII`` and ``IBEA``
:type algorithm: str
:param population: Population size for genetic algorithms
:type population: int
:param evaluator: Platypus.Evaluator in case of parallel execution
:type evaluator: Platypus.Evaluator
"""
if mutation_probability is None:
variator = GAOperator(SBX(), PM())
else:
variator = GAOperator(SBX(), PM(probability=mutation_probability))
print('Using provided mutation probability')
if algorithm.lower().upper() == 'NSGAII':
if evaluator is None:
if current_solution is None:
return NSGAII(myproblem,
population_size=population,
variator=variator)
else:
return NSGAII(myproblem,
population_size=population,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]))
else:
if current_solution is None:
return NSGAII(myproblem,
population_size=population,
variator=variator,
evaluator=evaluator)
else:
return NSGAII(myproblem,
population_size=population,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]),
evaluator=evaluator)
elif algorithm.lower().upper() == 'NSGAIII':
num_errors = len(myproblem.directions)
divisions = int(
np.power(population * np.math.factorial(num_errors - 1), 1.0 /
(num_errors - 1))) + 2 - num_errors
divisions = np.maximum(1, divisions)
if evaluator is None:
if current_solution is None:
return NSGAIII(myproblem,
divisions_outer=divisions,
variator=variator)
else:
return NSGAIII(myproblem,
divisions_outer=divisions,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]))
else:
if current_solution is None:
return NSGAIII(myproblem,
divisions_outer=divisions,
variator=variator,
evaluator=evaluator)
else:
return NSGAIII(myproblem,
divisions_outer=divisions,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]),
evaluator=evaluator)
elif algorithm.lower().upper() == 'IBEA':
if evaluator is None:
if current_solution is None:
return IBEA(myproblem,
population_size=population,
variator=variator)
else:
return IBEA(myproblem,
population_size=population,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]))
else:
if current_solution is None:
return IBEA(myproblem,
population_size=population,
variator=variator,
evaluator=evaluator)
else:
return IBEA(myproblem,
population_size=population,
variator=variator,
generator=InjectedPopulation(
current_solution[0:population]),
evaluator=evaluator)
else:
raise Exception(
'Please enter an algorithm for optimization. NSGAII , NSGAIII , IBEA are supported'
)
sizePop = 3
library = 2
pathsave = '/home/oscar/Documents/PythonProjects/kuramotoAO/optimizationResults/'
#pathsave = '/Users/p277634/python/kaoModel/optimResult/'
filenameTXT = 'ihsTest.txt'
filenameNPZ = 'ihsTest.npz'
print('Running: ', filenameNPZ[:-4])
# Cost function definiton
kaom = myUDPkaos.kaoSimplMultiObjContr(lib=library)
lowBound, upBound = kaom.get_bounds()
# OPtimization Prblem definition
problem = Problem(len(upBound), kaom.get_nobj(), kaom.get_nic()) # (number of decision variables, number of objectives, number of constrains)
problem.nvars = sizePop
problem.types[:] = [Real(lb, ub) for lb,ub in zip(lowBound,upBound)]
problem.constraints[:] = "<=0"
problem.function = kaom.fitness
# Evolutionary algorithm
algorithm = NSGAII(problem)
start = time.time()
algorithm.run(generations)
print('time evolution: ',time.time()-start)
logged = kaom.get_mylogs()
def bar_multi_GA(nx=20,
ny=20,
volume_frac=0.5,
parent=400,
generation=100,
path="data"):
PATH = os.path.join(path, "bar_nx_{}_ny_{}".format(nx, ny),
"gen_{}_pa_{}".format(generation, parent))
os.makedirs(PATH, exist_ok=True)
start = time.time()
def objective(vars):
y_1, y_2, y_3, x_4, nodes, widths = convert_var_to_arg(vars)
edges = make_6_bar_edges(nx, ny, y_1, y_2, y_3, x_4, nodes, widths)
rho = make_bar_structure(nx, ny, edges)
volume = np.sum(rho) / (nx * ny)
return [calc_E(rho), calc_G(rho)], [volume]
def convert_var_to_arg(vars):
y_1 = vars[0]
y_2 = vars[1]
y_3 = vars[2]
x_4 = vars[3]
node_y_indexes = vars[4:4 + 6 * 3]
node_x_indexes = vars[4 + 6 * 3:4 + 6 * 3 * 2]
nodes = np.stack([node_x_indexes, node_y_indexes], axis=1)
widths = vars[4 + 6 * 3 * 2:]
return y_1, y_2, y_3, x_4, nodes, widths
# 2変数2目的の問題
problem = Problem(4 + 6 * 3 * 2 + 6 * 4, 2, 1)
# 最小化or最大化を設定
problem.directions[:] = Problem.MAXIMIZE
# 決定変数の範囲を設定
x_index_const = Integer(1, nx) # x座標に関する制約
y_index_const = Integer(1, ny) # y座標に関する制約
bar_constraint = Real(0, ny / 2) # バーの幅に関する制約
problem.types[0:3] = y_index_const
problem.types[3] = x_index_const
problem.types[4:4 + 6 * 3] = y_index_const
problem.types[4 + 6 * 3:4 + 6 * 3 * 2] = x_index_const
problem.types[4 + 6 * 3 * 2:] = bar_constraint
problem.constraints[:] = "<=" + str(volume_frac)
problem.function = objective
problem.directions[:] = Problem.MAXIMIZE
algorithm = NSGAII(problem,
population_size=parent,
variator=CompoundOperator(SBX(), HUX(), PM(),
BitFlip()))
algorithm.run(generation)
# グラフを描画
fig = plt.figure()
plt.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result],
c="blue",
label="infeasible solution")
plt.scatter([s.objectives[0] for s in algorithm.result if s.feasible],
[s.objectives[1] for s in algorithm.result if s.feasible],
c="red",
label='feasible solution')
# 非劣解をとりだす
nondominated_solutions = nondominated(algorithm.result)
plt.scatter(
[s.objectives[0] for s in nondominated_solutions if s.feasible],
[s.objectives[1] for s in nondominated_solutions if s.feasible],
c="green",
label="pareto solution")
plt.legend(loc='lower left')
plt.xlabel("$E$")
plt.ylabel("$G$")
fig.savefig(os.path.join(PATH, "graph.png"))
plt.close()
for solution in [s for s in nondominated_solutions if s.feasible]:
vars_list = []
for j in solution.variables[:3]:
vars_list.append(y_index_const.decode(j))
vars_list.append(x_index_const.decode(solution.variables[3]))
for j in solution.variables[4:4 + 6 * 3]:
vars_list.append(y_index_const.decode(j))
for j in solution.variables[4 + 6 * 3:4 + 6 * 3 * 2]:
vars_list.append(x_index_const.decode(j))
for j in solution.variables[4 + 6 * 3 * 2:]:
vars_list.append(bar_constraint.decode(j))
y_1, y_2, y_3, x_4, nodes, widths = convert_var_to_arg(vars_list)
edges = make_6_bar_edges(nx, ny, y_1, y_2, y_3, x_4, nodes, widths)
image = make_bar_structure(nx, ny, edges)
np.save(
os.path.join(
PATH, 'E_{}_G_{}.npy'.format(solution.objectives[0],
solution.objectives[1])), image)
convert_folder_npy_to_image(PATH)
elapsed_time = time.time() - start
with open("time.txt", mode='a') as f:
f.writelines("bar_nx_{}_ny_{}_gen_{}_pa_{}:{}sec\n".format(
nx, ny, generation, parent, elapsed_time))
def HBV_calibration(P,
E,
Case,
area,
Q_obs,
objective,
iterations,
population_size=1):
if objective == 'all': # the objective is to minimize RMSE considering all the hydrograph
num_objectives = 1
pass
elif objective == 'low': # the objective is to minimize RMSE considering only low flows
num_objectives = 1
low_flow_indexes = [Q_obs < np.percentile(Q_obs, 50)]
Q_obs_low = Q_obs[tuple(low_flow_indexes)]
elif objective == 'high': # the objective is to minimize RMSE considering only high flows
num_objectives = 1
high_flow_indexes = [Q_obs > np.percentile(Q_obs, 50)]
Q_obs_high = Q_obs[tuple(high_flow_indexes)]
elif objective == 'double': # two objectives (RMSE of low and high flows)
num_objectives = 2
low_flow_indexes = [Q_obs < np.percentile(Q_obs, 50)]
Q_obs_low = Q_obs[tuple(low_flow_indexes)]
high_flow_indexes = [Q_obs > np.percentile(Q_obs, 50)]
Q_obs_high = Q_obs[tuple(high_flow_indexes)]
def auto_calibration(vars):
SSM0 = vars[0]
SUZ0 = vars[1]
SLZ0 = vars[2]
BETA = vars[3]
LP = vars[4]
FC = vars[5]
PERC = vars[6]
K0 = vars[7]
K1 = vars[8]
K2 = vars[9]
UZL = vars[10]
MAXBAS = vars[11]
ini = [SSM0, SUZ0, SLZ0]
param = [BETA, LP, FC, PERC, K0, K1, K2, UZL, MAXBAS]
Q_sim, [SM, UZ, LZ], [EA, R, RL, Q0,
Q1] = HBV_sim(P, E, param, Case, ini, area)
if objective == 'all':
# Consider the entire hydrograph
value = np.sqrt(((Q_sim - Q_obs)**2).mean())
return [value]
elif objective == 'low':
Q_sim_low = Q_sim[tuple(low_flow_indexes)]
value = np.sqrt(((Q_sim_low - Q_obs_low)**2).mean())
return [value]
elif objective == 'high':
Q_sim_high = Q_sim[tuple(high_flow_indexes)]
value = np.sqrt(((Q_sim_high - Q_obs_high)**2).mean())
return [value]
elif objective == 'double':
Q_sim_low = Q_sim[tuple(low_flow_indexes)]
Q_sim_high = Q_sim[tuple(high_flow_indexes)]
value = [
np.sqrt(((Q_sim_low - Q_obs_low)**2).mean()),
np.sqrt(((Q_sim_high - Q_obs_high)**2).mean())
]
return value
problem = Problem(12, num_objectives)
real0 = Real(0, 400)
real1 = Real(0, 100)
real2 = Real(0, 100)
real3 = Real(0, 7)
real4 = Real(0.3, 1)
real5 = Real(1, 2000)
real6 = Real(0, 100)
real7 = Real(0.05, 2)
real8 = Real(0.01, 1)
real9 = Real(0, 0.1)
real10 = Real(0, 100)
real11 = Real(1, 6)
problem.types[:] = [real0] + [real1] + [real2] + [real3] + [real4] + [
real5
] + [real6] + [real7] + [real8] + [real9] + [real10] + [real11]
problem.function = auto_calibration
algorithm = NSGAII(problem, population_size)
algorithm.run(iterations) # Number of iterations
if objective == 'double':
results_low = np.array([
algorithm.result[i].objectives[0] for i in range(population_size)
])
results_high = np.array([
algorithm.result[i].objectives[1] for i in range(population_size)
])
else:
results = np.array([
algorithm.result[i].objectives[0] for i in range(population_size)
])
solution = [
algorithm.result[i].variables[0:12] for i in range(population_size)
]
RMSE = [
np.sqrt(((
HBV_sim(P, E, solution[i][3:12], Case, solution[i][0:3], area)[0] -
Q_obs)**2).mean()) for i in range(population_size)
]
if objective == 'double':
return results_low, results_high, solution, RMSE
else:
return results, solution, RMSE
logging.basicConfig(level=logging.INFO)
# simulate an computationally expensive problem
class DTLZ2_Slow(DTLZ2):
def evaluate(self, solution):
sum(range(1000000))
super(DTLZ2_Slow, self).evaluate(solution)
if __name__ == "__main__":
# define the problem definition
problem = DTLZ2_Slow()
pool = MPIPool()
# only run the algorithm on the master process
if not pool.is_master():
pool.wait()
sys.exit(0)
# instantiate the optimization algorithm to run in parallel
with PoolEvaluator(pool) as evaluator:
algorithm = NSGAII(problem, evaluator=evaluator)
algorithm.run(10000)
# display the results
for solution in algorithm.result:
print(solution.objectives)
pool.close()
def optimizer(fixedParameters, constraints):
"""
- fixedParameters: {gridComponents : {
"battery" : {
"initialStorage": float between 0 and 1, the battery initial energy storage as a percentage of its maximum capacity,
"maxInputPow": float, the maximum charging power of the battery in kW for a 1kWh battery. The real value will be obtained by multiplying by the maximum storage capacity,
"maxOutputPow": float, the maximum discharging power of the battery in kW for a 1kWh battery. The real value will be obtained by multiplying by the maximum storage capacity,
"SOC_min": float, the minimum amount of energy that can be stored in the battery as a percentage of the maximum storage capacity,
"maxThroughput": float, the number by which we multiply the max storage to get the maximum amount of energy that can flow in and out of the battery during its lifetime (kWh),
"lifetime": int, the nominal lifetime of the battery in hours. It's the time after which we must replace it if we did not exceed the maximum throughput,
"capitalCost": float, the cost of a 1kWh battery in $,
"replacementCost": float, the cost to replace 1kWh of batteries in $,
"operationalCost": float, the cost PER HOUR, to operate and maintain the battery ($)
},
"diesel" : {
"fuelCost": float, the cost of 1l of fuel ($),
"fuelCostGrad": float, there is a fuel curve modeling the relationship between the functionning power of the dg and it's consumption of liters fuel per kW. This parameter is the slope of the model curve,
"fuelCostIntercept": float, there is a fuel curve modeling the relationship between the functionning power of the dg and it's consumption of liters fuel per kW. This parameter is the intercept of the model curve,
"lifetime": int, the nominal lifetime of the dg in hours,
"capitalCost": float, the cost of the dg in $,
"replacementCost": float, the cost to replace the dg in $,
"operationalCost": float, the cost PER HOUR, to operate and maintain the dg,
},
"photovoltaic" : {
"lifetime": int, the nominal lifetime of a pannel in hours,
"capitalCost": float, the cost of a pannel in $,
"replacementCost": float, the cost to replace a pannel in $,
"operationalCost": float, the cost PER HOUR, to operate and maintain the pannel ($),
"powerTimeVector": numpy array, the power output of the pannel at each time step (kW)
}
},
timeStep : float, the time step of the simulation that generated the load in hours,
loadVector : numpy array of floats, the power demand on the grid (kW),
projectDuration : int, the duration of the whole project in hours (e.g 25 * 365 * 24),
discountRate: float, the discount ratio,
strategy : "LF" or "CC", respectively for "Load Following" or "Cycle Charging"
- constraints : {
"diesel":
{
"upperBound": float, the upper Bound for the value of the generatorMaximumPower (kW),
"lowerBound": float, the lower Bound for the value of the generatorMaximumPower (kW),
},
"battery":
{
"upperBound": float, the upper Bound for the value of the battery maximum storage capacity (kWh),
"lowerBound": float, the lower Bound for the value of the battery maximum storage capacity (kWh),
},
"photovoltaic":
{
"upperBound": float, the upper Bound for the value of the pvMaximumPower (kW),
"lowerBound": float, the upperlower Bound for the value of the pvMaximumPower (kW),
},
}
OUTPUT:
{
"parameters":
{
"battery": float, the battery storage capacity (kWh),
"diesel": float, the generator maximum power (kW),
"photovoltaic": float, the pv maximum power (kW)
},
"costs":
{
"dollars": float, the cost of the project in dollars,
"carbon": float, the carbon emissions generated by the project (kg)
}
}
"""
gridComponents = fixedParameters["gridComponents"]
timeStep = fixedParameters["timeStep"]
loadVector = fixedParameters["loadVector"]
projectDuration = fixedParameters["projectDuration"]
discountRate = fixedParameters["discountRate"]
strategy = fixedParameters["strategy"]
pvPowerTimeVector = gridComponents["photovoltaic"]["powerTimeVector"]
normalizingFactor = 52
maxInputPowMulti = gridComponents["battery"]["maxInputPow"]
maxOutputPowMulti = gridComponents["battery"]["maxOutputPow"]
SOC_min_multi = gridComponents["battery"]["SOC_min"]
def costFunction(x):
global dispatchingResult, netLoadVector, pvPowerVector
gridComponents["battery"]["maxStorage"] = x[0]
gridComponents["diesel"]["maxPower"] = x[1]
gridComponents["photovoltaic"]["maxPower"] = x[2]
batteryInitialStorage = gridComponents["battery"]["initialStorage"] * x[0]
battMaxInputPow = maxInputPowMulti * x[0]
battMaxOutputPow = maxOutputPowMulti * x[0]
SOC_min = SOC_min_multi * x[0]
specifications = [x[0], x[1], battMaxInputPow, battMaxOutputPow, SOC_min]
pvPowerVector = ((pvPowerTimeVector)/normalizingFactor)*(x[2])
netLoadVector = loadVector - pvPowerVector
dispatchingResult = dispatchingLoop(timeStep, netLoadVector, batteryInitialStorage, specifications, strategy)
return [dollarCost(gridComponents, timeStep, loadVector, projectDuration, discountRate, strategy, dispatchingResult),
carbonCost(gridComponents, timeStep, loadVector, projectDuration, discountRate, strategy, dispatchingResult)]
problem = Problem(3, 2)
problem.types[:] = [Real(constraints["battery"]["lowerBound"], constraints["battery"]["upperBound"]), Real(constraints["diesel"]["lowerBound"], constraints["diesel"]["upperBound"]), Real(constraints["photovoltaic"]["lowerBound"], constraints["photovoltaic"]["upperBound"])]
problem.function = costFunction # lambda x: [sum(x), sum([val**2 for val in x])] #The function helped us see that the computational time of our cost functions was a problem
algorithm = NSGAII(problem)
algorithm.run(1)
displayResults(netLoadVector, pvPowerVector, dispatchingResult[0], dispatchingResult[1], [solution for solution in algorithm.result if solution.feasible])
def main():
# One-shot objects parameters
init_num_test_samples_per_object = 1000
init_range = 20
# Regularization samples parameters
init_num_reg_samples_per_object = 10
# Generalization generator parameters
# TODO: num_objects = os.num_objects,
init_num_gen_samples_per_object = 300
# Classifier parameters
# TODO: self.num_classes = num_classes (num_objects)
init_learning_rate = 0.003
init_training_epochs = 300 # 1200
init_display_step = 100
init_num_hidden_1 = 10 # 1st layer number of features
init_num_hidden_2 = 10 # 2nd layer number of features
os = OneShotObjects(
num_test_samples_per_object=init_num_test_samples_per_object,
range=init_range)
rs = RegularizationSamples(
one_shot_objects=os,
num_reg_samples_per_object=init_num_reg_samples_per_object)
gg = GeneralizationGenerator(
one_shot_objects=os,
regularization_samples=rs,
num_objects=os.num_objects,
num_gen_samples_per_object=init_num_gen_samples_per_object)
cs = Classifier(num_classes=os.num_objects,
range=init_range,
learning_rate=init_learning_rate,
training_epochs=init_training_epochs,
display_step=init_display_step,
num_hidden_1=init_num_hidden_1,
num_hidden_2=init_num_hidden_2)
gol_model = GOL(os, rs, gg, cs)
opt_algorithm = NSGAII(gol_model)
opt_algorithm.run(2)
plt.figure(2)
plt.scatter([s.objectives[0] for s in opt_algorithm.result],
[s.objectives[1] for s in opt_algorithm.result])
plt.xlabel("$J(\Theta, \hat{x}(t))$")
plt.ylabel("$a(\Theta, \hat{x}(t))$")
if animate:
# Save pareto solutions image
file_path = anim_path + '/_pareto_solutions.png'
plt.savefig(file_path)
plt.close()
# Save the pareto solutions
file_path = anim_path + '/_pareto_solutions.csv'
with open(file_path, 'w', newline='') as f:
writer = csv.writer(f)
for s in opt_algorithm.result:
writer.writerow((s.objectives[0], s.objectives[1]))
f.close()
else:
plt.show()
POPSIZE = 100
DIRECTIONS = [Problem.MAXIMIZE, Problem.MINIMIZE, Problem.MINIMIZE]
print(" * %d variables, %d objectives" % (D, OBJS))
print(" * %d individuals, MAX_FEs %d, %d iterations" %
(POPSIZE, FEs, FEs // POPSIZE))
problem = Problem(D, OBJS)
all_types = [Integer(0, 2) for _ in range(D)]
problem.types[:] = all_types
problem.function = SIM.fitness
problem.directions[:] = DIRECTIONS
# Multi-processing (4 parallel processes)
with ProcessPoolEvaluator(4) as evaluator:
algorithm = NSGAII(problem,
population_size=POPSIZE,
evaluator=evaluator)
res = algorithm.run(FEs)
final_results = [(s.objectives[0], s.objectives[1], s.objectives[2])
for s in algorithm.result]
final_solutions = []
for solution in algorithm.result:
temp = []
for n in range(D):
tpe = all_types[n]
value = tpe.decode(solution.variables[n])
name = SIM._sorted_names[n]
if value == 1:
temp.append("%s IS low" % name)
elif value == 2:
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)
return ''.join(sb)
def evaluate(variables):
genome = variables[0]
phenotype = genome_to_grammar(genome)
phenotype = phenotype.replace(' ', '')
accuracy, f1score = 0, 0 #get_metrics(phenotype)
# print(phenotype, accuracy, f1score)
return accuracy, f1score
problem = Problem(1, 2)
problem.types[0] = Genome(100, 255)
problem.directions[0] = Problem.MAXIMIZE
problem.directions[1] = Problem.MAXIMIZE
problem.function = evaluate
operator = GAOperator(GenomeSinglePointCrossover(probability=0.75),
GenomeUniformMutation(probability=0.25))
algorithm = NSGAII(problem, population_size=50, variator=operator)
# algorithm = SPEA2(problem, population_size=50, variator=operator)
for i in range(30):
print('Geração:', i + 1)
algorithm.step()
for solution in unique(nondominated(algorithm.result)):
genome = solution.variables[0]
phenotype = genome_to_grammar(genome)
print(phenotype, solution.objectives)
