def make_platypus_objective_function_counting(self,
sources,
times_more_detectors=1):
"""
This balances the number of detectors with the quality of the outcome
"""
total_ret_func = make_total_lookup_function(
sources, masked=True) # the function to be optimized
counting_func = make_counting_objective()
def multiobjective_func(x): # this is the double objective function
return [total_ret_func(x), counting_func(x)]
# there is an x, y, and a mask for each source so there must be three
# times more input variables
# the upper bound on the number of detectors n times the number of
# sources
num_inputs = len(sources) * 3 * times_more_detectors
NUM_OUPUTS = 2 # the default for now
# define the demensionality of input and output spaces
problem = Problem(num_inputs, NUM_OUPUTS)
x, y, time = sources[0] # expand the first source
min_x = min(x)
min_y = min(y)
max_x = max(x)
max_y = max(y)
print("min x : {}, max x : {}, min y : {}, max y : {}".format(
min_x, max_x, min_y, max_y))
problem.types[0::3] = Real(min_x, max_x) # This is the feasible region
problem.types[1::3] = Real(min_y, max_y)
# This appears to be inclusive, so this is really just (0, 1)
problem.types[2::3] = Binary(1)
problem.function = multiobjective_func
return problem
def make_platypus_objective_function_competing_function(
self, sources, bad_sources=[]):
total_ret_func = make_total_lookup_function(
sources, interpolation_method=self.interpolation_method
) # the function to be optimized
bad_sources_func = make_total_lookup_function(
bad_sources,
type="fastest",
interpolation_method=self.interpolation_method
) # the function to be optimized
def multiobjective_func(x): # this is the double objective function
return [total_ret_func(x), bad_sources_func(x)]
num_inputs = len(sources) * 2 # there is an x, y for each source
NUM_OUPUTS = 2 # the default for now
# define the demensionality of input and output spaces
problem = Problem(num_inputs, NUM_OUPUTS)
x, y, time = sources[0] # expand the first source
min_x = min(x)
min_y = min(y)
max_x = max(x)
max_y = max(y)
print("min x : {}, max x : {}, min y : {}, max y : {}".format(
min_x, max_x, min_y, max_y))
problem.types[::2] = Real(min_x, max_x) # This is the feasible region
problem.types[1::2] = Real(min_y, max_y)
problem.function = multiobjective_func
# the second function should be maximized rather than minimized
problem.directions[1] = Problem.MAXIMIZE
return problem
def fit(self, x, y, bound=None, name=None):
self.y = np.array(y)
self.x = x
TS = 1
ND = len(y) - 1
y = y / self.N
t_start = 0.0
t_end = ND
t_inc = TS
t_range = np.arange(t_start, t_end + t_inc, t_inc)
Model_Input = (self.S0, self.I0, self.R0)
# GA Parameters
number_of_generations = 1000
ga_population_size = 100
number_of_objective_targets = 1 # The MSE
number_of_constraints = 0
number_of_input_variables = 2 # beta and gamma
problem = Problem(number_of_input_variables,
number_of_objective_targets, number_of_constraints)
problem.function = functools.partial(self.fitness_function,
y=y,
Model_Input=Model_Input,
t_range=t_range)
algorithm = NSGAII(problem, population_size=ga_population_size)
problem.types[0] = Real(0, 1) # beta initial Range
problem.types[1] = Real(1 / 5, 1 / 14) # gamma initial Range
# Running the GA
algorithm.run(number_of_generations)
feasible_solutions = [s for s in algorithm.result if s.feasible]
self.beta = feasible_solutions[0].variables[0]
self.gamma = feasible_solutions[0].variables[1]
input_variables = ['beta', 'gamma']
file_address = 'optimised_coefficients/'
filename = "ParametrosAjustados_Modelo_{}_{}_{}_Dias.txt".format(
'SIR_EDO', name, len(x))
if not os.path.exists(file_address):
os.makedirs(file_address)
file_optimised_parameters = open(file_address + filename, "w")
file_optimised_parameters.close()
if not os.path.exists(file_address):
os.makedirs(file_address)
with open(file_address + filename, "a") as file_optimised_parameters:
for i in range(len(input_variables)):
message = '{}:{:.4f}\n'.format(
input_variables[i], feasible_solutions[0].variables[i])
file_optimised_parameters.write(message)
def __init__(self):
super(my_mo_problem, self).__init__(
self.nbOfPipes + self.nbOfPumps + 3 * self.nbOfTanks, 2, 1)
self.types[:] = [Real(0, 9)] * self.nbOfPipes + [
Real(0, self.n_curves - 1)
] * self.nbOfPumps + [Real(25, 100)] * self.nbOfTanks + [
Real(25, 40)
] * self.nbOfTanks + [Real(5, 10)] * self.nbOfTanks
self.constraints[:] = "<=0"
self.directions[:] = Problem.MINIMIZE
def Pareto_Front_Strategy(Probs, odds, Total_BetMax, Max_individual_bet,
Min_individual_bet):
#NOTE: The order of bets and Probs is as follows: 1st (1) is AWAY win and 2nd (2) is HOME win
Bets = np.argmax(Probs, 1) + 1
n = len(Probs) #number of games
# Calculate probabilities for ALL the events together (i.e. each outcome). This will be used as weights for our optimisation
k = n
num_events = int(pow(2, n))
Event_Probs = np.zeros(num_events)
outc = outcomes_HACK(n)
for i in range(num_events):
individual_probs = np.diag(Probs[:, outc[i, :] - 1])
Event_Probs[i] = PoissonBinomialPDF(k, n, individual_probs)
#Pareto optimization
problem = Problem(n, 2, 1) #vars, problem dim, constraints
problem.types[:] = Real(
Min_individual_bet,
Max_individual_bet) #lower and upper bounds for all decision variables
problem.function = functools.partial(ExpectationRisk,
arg1=n,
arg2=odds,
arg3=Event_Probs,
arg4=Bets,
arg5=outc)
problem.constraints[:] = "<=" + str(
Total_BetMax
) + "" #inequality constraints: sum of bets no more than BetMax
algorithm = NSGAII(problem)
algorithm.run(5000)
plt.scatter([s.objectives[0] for s in algorithm.result],
[s.objectives[1] for s in algorithm.result])
plt.show()
Stakes = []
Ratio = 0
for i in range(len(algorithm.result)):
#objectives are: -data[0] = Expectation, data[1] = Variance
#Exp/Variance ration threshold
Exp = algorithm.result[i].objectives._data[0]
Var = algorithm.result[i].objectives._data[1]
curRatio = Exp / Var
if curRatio > Ratio:
Ratio = curRatio
Stakes = algorithm.result[i].variables
ExpOut = Exp
VarOut = Var
return (Stakes, Bets, ExpOut, VarOut)
def nn_opt(self, nn):
with torch.no_grad():
def obj_cons(x):
tx = torch.tensor(x)
out = nn(tx)
return out[:self.nobj].numpy().tolist(), out[self.nobj:].numpy(
).tolist()
def obj_ucons(x):
tx = torch.tensor(x)
return nn(tx).numpy().tolist()
arch = Archive()
if self.ncons == 0:
prob = Problem(self.dim, self.nobj)
prob.function = obj_ucons
else:
prob = Problem(self.dim, self.nobj, self.ncons)
prob.function = obj_cons
prob.constraints[:] = "<=0"
prob.types[:] = [Real(self.lb, self.ub) for i in range(self.dim)]
self.algo = NSGAII(prob, population=50, archive=arch)
self.algo.run(5000)
optimized = self.algo.result
rand_idx = np.random.randint(len(optimized))
suggested_x = torch.tensor(optimized[rand_idx].variables)
suggested_y = nn(suggested_x)
return suggested_x.view(-1, self.dim), suggested_y.view(
-1, self.nobj + self.ncons)
def platypus_cube(objective,
scale,
n_trials,
n_dim,
strategy,
with_count=False):
global feval_count
feval_count = 0
def _objective(vars):
global feval_count
feval_count += 1
return objective(list(vars))[0]
problem = Problem(n_dim, 1, 0)
problem.types[:] = [Real(-scale, scale)] * n_dim
problem.constraints[:] = "<=0"
problem.function = _objective
algorithm = strategy(problem)
algorithm.run(n_trials)
feasible_solution_obj = [
s.objectives[0] for s in algorithm.result if s.feasible
]
best_obj = min(feasible_solution_obj)
return (best_obj, feval_count) if with_count else best_obj
def generate_initial_population(pop_size=10, number_of_gd_steps=50):
p1 = GradientDescentAdam(R, lr=alpha)
initial_pop = []
meta_g = None
vec_len = None
for x in range(pop_size):
_, _, _, _, G, S = p1.optimize(number_of_gd_steps, ks=ks)
v, meta = roll(G, S)
meta_g = meta
vec_len = len(v)
initial_pop.append(v.tolist())
problem = Problem(vec_len, 1)
problem.types[:] = Real(0, 1000)
problem.function = partial(fit, p1, meta_g)
generator = RandomGenerator()
population = []
for i in range(pop_size):
p = generator.generate(problem)
p.variables = initial_pop[i]
problem.evaluate(p)
population.append(p)
return problem, population, meta_g, generator
def platypus_cube(objective, n_trials, n_dim, with_count=False, method=None):
global feval_count
feval_count = 0
def _objective(vars):
global feval_count
feval_count += 1
return float(objective(
list(vars))) # Avoid np.array as Platypus may puke
problem = Problem(n_dim, 1, 0)
problem.types[:] = [Real(0.0, 1.0)] * n_dim
problem.constraints[:] = "<=0"
problem.function = _objective
strategy_and_args = PLATYPUS_ALGORITHMS[method]
if isinstance(strategy_and_args, tuple):
strategy = strategy_and_args[0]
strategy_args = strategy_and_args[1]
algorithm = strategy(problem, **strategy_args)
else:
strategy = strategy_and_args
algorithm = strategy(problem)
algorithm.run(n_trials)
feasible_solution_obj = sorted([(s.objectives[0], s.variables)
for s in algorithm.result if s.feasible],
reverse=False)
best_obj, best_x = feasible_solution_obj[0]
if isinstance(best_x, FixedLengthArray):
best_x = best_x._data # CMA-ES returns it this way for some reason
return (best_obj, best_x, feval_count) if with_count else (best_obj,
best_x)
def get_bounds(self):
types = []
bounds = np.zeros([self.n * self.m, 2])
for i in range(self.n * self.m):
bounds[i][0] = 0
bounds[i][1] = 200
types.append(Real(bounds[i][0], bounds[i][1]))
return types
def autoIterate(model,
river,
reach,
rs,
flow,
stage,
nct,
plot,
outf,
metrics,
correctDatum,
evals=None,
si=False):
"""
Automatically iterate with NSGA-II
"""
keys = metrics # ensure same order
evalf = evaluator(stage, useTests=keys, correctDatum=correctDatum)
evals = int(
input("How many evaluations to run? ")) if evals is None else evals
plotpath = ".".join(outf.split(".")[:-1]) + ".png"
count = 1
print("Running automatic calibration")
def manningEval(vars):
n = vars[0]
metrics = minimized(
nstageSingleRun(model, river, reach, rs, stage, n, keys,
correctDatum))
values = [metrics[key] for key in keys]
constraints = [-n, n - 1]
nonlocal count
print("Completed %d evaluations" % count)
count += 1
return values, constraints
c_type = "<0"
problem = Problem(
1, len(keys),
2) # 1 decision variable, len(keys) objectives, and 2 constraints
problem.types[:] = Real(0.001, 1) # range of decision variable
problem.constraints[:] = c_type
problem.function = manningEval
algorithm = NSGAII(problem, population_size=nct)
algorithm.run(evals)
nondom = nondominated(
algorithm.result
) # nondom: list of Solutions - wanted value is variables[0]
nondomNs = [sol.variables[0] for sol in nondom]
results = runSims(model, nondomNs, river, reach, len(stage), range=[rs])
resultPts = [(nondomNs[ix],
[results[ix][rs][jx] for jx in range(1,
len(stage) + 1)])
for ix in range(len(nondomNs))]
metrics = [(res[0], evalf(res[1]), res[1]) for res in resultPts]
nDisplay(metrics, flow, stage, plotpath, outf, plot, correctDatum, si)
return metrics
def __init__(self, Amin, M, J, splits, objectives, TFmax=7):
"""
@param Amin: minimum number of antecedents per rule
@param M: maximum number of rules per individual
@param J: matrix representing the initial rulebase
@param splits: fuzzy partitions for input features
@param objectives: array of objectives (2 or more). The first one is typically expresses the performance
for predictions. Indeed, the solutions will be sorted according to this objective (best-to-worst)
@param TFmax: maximum number of fuzzy sets per feature (i.e. maximum granularity)
"""
self.Amin = Amin
self.M = M
self.Mmax = J.shape[0]
self.Mmin = len(set(J[:, -1]))
self.M = np.clip(self.M, self.Mmin, self.Mmax)
self.F = J.shape[1] - 1
self.TFmax = TFmax
self.J = J
self.initialBfs = splits
self.G = np.array([len(split) for split in splits])
self.objectives = objectives
self.crb_l = 2 * self.M
self.gran_l = self.F
self.cdb_l = self.gran_l * self.TFmax
# Creation of the problem and assignment of the types
# CRB: rule part
# Granularities: number of fuzzy sets
# CDB: database part
super(RCSProblem, self).__init__(self.crb_l + self.gran_l + self.cdb_l,
len(objectives))
self.types[0:self.crb_l:2] = [Real(0, self.M) for _ in range(self.M)]
self.types[1:self.crb_l:2] = [Binary(self.F) for _ in range(self.M)]
self.types[self.crb_l:self.crb_l +
self.gran_l] = [Real(2, self.TFmax) for _ in range(self.F)]
self.types[self.crb_l +
self.gran_l:] = [Real(0, 1) for _ in range(self.cdb_l)]
# Maximize objectives by minimizing opposite
self.directions[:] = [Problem.MINIMIZE for _ in range(len(objectives))]
self.train_x = None
self.train_y = None
def __init__(self, universe: Universe, buying_power: float):
super(OptPortfolio, self).__init__(universe.count, 1, 1)
self.universe = universe
self.universe_historical_data = gen_universe_hist_data(
universe.universe_set, "Adj. Close")
self.buying_power = buying_power
self.types[:] = Real(0, 1)
self.constraints[:] = "<=0"
self.directions[:] = Problem.MAXIMIZE
def platypus_cube(objective,scale, n_trials, strategy):
def _objective(vars):
u1 = vars[0]
u2 = vars[1]
u3 = vars[2]
return objective([u1,u2,u3])[0]
problem = Problem(3, 1, 0)
problem.types[:] = [Real(-scale, scale), Real(-scale, scale), Real(-scale, scale)]
problem.constraints[:] = "<=0"
problem.function = _objective
algorithm = strategy(problem)
algorithm.run(n_trials)
feasible_solution_obj = [s.objectives[0] for s in algorithm.result if s.feasible]
best_obj = min(feasible_solution_obj)
return best_obj
def __init__(self, host):
self.host = host
n = host.number_of_params()
nconstraints = len(host.train_args['label']) + 1
print('#number of constraints ', nconstraints)
super(InterestingnessProblem, self).__init__(n, 2, nconstraints)
self.types[:] = [Real(-10, 10) for _ in range(n)]
self.constraints[:] = "<=0"
def __init__(self,
stream_network,
starting_water_price=800,
total_units_needed_factor=0.99,
objectives=2,
min_proportion=0,
simplified=False,
plot_output_folder=None,
*args):
"""
:param decision_variables: when this is set to None, it will use the number of HUCs as the number of decision
variables
:param objectives: default is two (total needs met, and min by species)
:param min_proportion: What is the minimum proportion of flow that we can allocate to any single segment? Raising
this value (min 0, max 0.999999999) prevents the model from extracting all its water in one spot.
:param args:
"""
self.stream_network = stream_network
self.stream_network.economic_benefit_calculator = economic_components.EconomicBenefit(
starting_water_price,
total_units_needed=self.get_needed_water(
total_units_needed_factor))
if simplified:
self.decision_variables = 365
self.simplified = True
else:
self.decision_variables = len(
stream_network.stream_segments
) * 365 # we need a decision variable for every stream segment and day - we'll reshape them later
self.simplified = False
self.iterations = []
self.objective_1 = []
self.objective_2 = []
self.best_obj1 = 0
self._best_obj2_for_obj1 = 0
self.best_obj2 = 0
self.plot_output_folder = plot_output_folder
log.info("Number of Decision Variables: {}".format(
self.decision_variables))
super(StreamNetworkProblem,
self).__init__(self.decision_variables, objectives,
*args) # pass any arguments through
self.directions[:] = Problem.MAXIMIZE # we want to maximize all of our objectives
self.types[:] = Real(
min_proportion,
1) # we now construe this as a proportion instead of a raw value
self.eflows_nfe = 0
def set_problem_types(config_space, problem, instance_features=None):
"""
set problem.types for algorithms in platypus (NSGAII, ...)
"""
if instance_features is not None:
raise NotImplementedError
for i, param in enumerate(config_space.get_hyperparameters()):
if isinstance(param, (CategoricalHyperparameter)):
n_cats = len(param.choices)
problem.types[i] = Integer(0, n_cats - 1)
elif isinstance(param, (OrdinalHyperparameter)):
n_cats = len(param.sequence)
problem.types[i] = Integer(0, n_cats - 1)
elif isinstance(param, UniformFloatHyperparameter):
problem.types[i] = Real(0, 1)
elif isinstance(param, UniformIntegerHyperparameter):
problem.types[i] = Real(0, 1)
else:
raise TypeError("Unsupported hyperparameter type %s" % type(param))
def set_types(self):
"""
Sets the type of each decision variable and makes it the max, should be in the same order that we
assign flows out later, so the max values should allign with the allocations that come in.
:return:
"""
allocation_index = 0
hucs = self.hucs
for huc in hucs:
self.types[allocation_index] = Real(0, huc.max_possible_flow)
allocation_index += 1
def update(self, **kwargs):
"""
Rewrite update
"""
assert 'X' in kwargs and 'Y' in kwargs
assert 'eta' in kwargs and 'num_data' in kwargs
super(USeMO, self).update(**kwargs)
self.X_dim = self.X.shape[1]
self.Y_dim = self.Y.shape[1]
assert self.Y_dim > 1
# update single acquisition function
for i in range(self.Y_dim):
self.single_acq[i].update(model=self.model[i],
eta=self.eta[i],
num_data=self.num_data)
self.uncertainty_acq[i].update(model=self.model[i],
eta=self.eta[i],
num_data=self.num_data)
def CMO(x):
x = np.asarray(x)
# minimize negative acq
return [
-self.single_acq[i](x, convert=False)[0][0]
for i in range(self.Y_dim)
]
problem = Problem(self.X_dim, self.Y_dim)
for k in range(self.X_dim):
problem.types[k] = Real(self.bounds[k][0],
self.bounds[k][1]) # todo other types
problem.function = CMO
algorithm = NSGAII(problem) # todo population_size
algorithm.run(2500)
cheap_pareto_set = [
solution.variables for solution in algorithm.result
]
# cheap_pareto_set_unique = []
# for i in range(len(cheap_pareto_set)):
# if not any((cheap_pareto_set[i] == x).all() for x in self.X):
# cheap_pareto_set_unique.append(cheap_pareto_set[i])
cheap_pareto_set_unique = cheap_pareto_set
single_uncertainty = np.array([
self.uncertainty_acq[i](np.asarray(cheap_pareto_set_unique),
convert=False) for i in range(self.Y_dim)
]) # shape=(Y_dim, N, 1)
single_uncertainty = single_uncertainty.reshape(self.Y_dim,
-1) # shape=(Y_dim, N)
self.uncertainties = np.prod(single_uncertainty,
axis=0) # shape=(Y_dim,) todo normalize?
self.candidates = np.array(cheap_pareto_set_unique)
def cal(args, exeCount):
start = time.time()
param_count = 5 # パラメーター数
problem = Problem(param_count, 2) # 最適化パラメータの数, 目的関数の数
problem.types[:] = Real(-2.0, 2.0) # パラメータの範囲
problem.function = schaffer
algorithm = NSGAII(problem)
algorithm.run(5000) # 反復回数
print('{:-^63}'.format('-'))
# データ整理
# params: 係数a
# f1s : 残留振動 [deg]
# f2s : エネルギー
params = np.empty([100, param_count])
f1s = np.empty([100])
f2s = np.empty([100])
for i, solution in enumerate(algorithm.result):
result = tuple(solution.variables \
+ solution.objectives[:])
params[i, :] = result[:param_count][:]
f1s[i] = 180 * result[param_count] / np.pi
f2s[i] = result[param_count + 1]
# 残留振動が最小になるaの値を表示
index = np.argmin(f1s)
print('\n*** 残留振動が最小の時の各値 ***')
print('残留振動[deg]\t{}'.format(f1s[index]))
print('エネルギー[J]\t{}'.format(f2s[index]))
print('係数a\t\t{}'.format(params[index, :]))
np.savetxt('./results/nsga2/{}/nsga2_params_{}.csv'.format(
args[1], exeCount),
params[index, :],
delimiter=',')
# 経過時間
print(f'\nelapsed time: {time.time()-start}')
# 係数a, 残留振動, エネルギーをCSVファイルに書き出す
data = np.empty([100, param_count + 2])
data[:, 0:param_count] = params
data[:, param_count] = f1s
data[:, param_count + 1] = f2s
np.savetxt('./results/nsga2/{}/nsga2_data_{}.csv'.format(
args[1], exeCount),
data,
delimiter=',')
def update(self, **kwargs):
"""
Rewrite update to support pareto front sampling.
"""
assert 'X' in kwargs and 'Y' in kwargs
assert 'constraint_perfs' in kwargs
super(MESMOC, self).update(**kwargs)
self.X_dim = self.X.shape[1]
self.Y_dim = self.Y.shape[1]
self.Multiplemes = [None] * self.Y_dim
self.Multiplemes_constraints = [None] * self.num_constraints
for i in range(self.Y_dim):
self.Multiplemes[i] = MaxvalueEntropySearch(self.model[i], self.X, self.Y[:, i],
random_state=self.random_state)
self.Multiplemes[i].Sampling_RFM()
for i in range(self.num_constraints):
# Caution dim of self.constraint_perfs!
self.Multiplemes_constraints[i] = MaxvalueEntropySearch(self.constraint_models[i],
self.X, self.constraint_perfs[i])
self.Multiplemes_constraints[i].Sampling_RFM()
self.min_samples = []
self.min_samples_constraints = []
for j in range(self.sample_num):
for i in range(self.Y_dim):
self.Multiplemes[i].weigh_sampling()
for i in range(self.num_constraints):
self.Multiplemes_constraints[i].weigh_sampling()
def CMO(xi):
xi = np.asarray(xi)
y = [self.Multiplemes[i].f_regression(xi)[0][0] for i in range(self.Y_dim)]
y_c = [self.Multiplemes_constraints[i].f_regression(xi)[0][0] for i in range(self.num_constraints)]
return y, y_c
problem = Problem(self.X_dim, self.Y_dim, self.num_constraints)
for k in range(self.X_dim):
problem.types[k] = Real(self.bounds[k][0], self.bounds[k][1]) # todo other types
problem.constraints[:] = "<=0" # todo confirm
problem.function = CMO
algorithm = NSGAII(problem)
algorithm.run(1500)
cheap_pareto_front = [list(solution.objectives) for solution in algorithm.result]
cheap_constraints_values = [list(solution.constraints) for solution in algorithm.result]
# picking the min over the pareto: best case
min_of_functions = [min(f) for f in list(zip(*cheap_pareto_front))]
min_of_constraints = [min(f) for f in list(zip(*cheap_constraints_values))] # todo confirm
self.min_samples.append(min_of_functions)
self.min_samples_constraints.append(min_of_constraints)
def generate_initial_population(number_of_gd_steps=50):
p1 = GradientDescentAdam(R, lr=alpha)
initial_pop = []
scale = 0.01
noise_scale=0.0000001
Gv, Sv = p1.construct_starting_point(ks, scale=scale)
_, _, _, _, G, S = p1.optimize(G=Gv.copy(), S=Sv.copy(), steps=number_of_gd_steps, ks=ks)
v, meta = roll(G, S)
initial_pop.append(v.tolist())
GvNoise = []
for x in Gv:
GvNoise.append(x+np.random.randn(*x.shape)*noise_scale)
SvNoise = []
for x in Sv:
n=[]
for y in x:
n.append(y+np.random.randn(*y.shape)*noise_scale)
SvNoise.append(n)
_, _, _, _, G, S = p1.optimize(G=GvNoise.copy(), S=SvNoise.copy(), steps=number_of_gd_steps, ks=ks)
v, meta = roll(G, S)
initial_pop.append(v.tolist())
np.random.rand()
_, _, _, _, G, S = p1.optimize(number_of_gd_steps, ks=ks)
v, meta = roll(G, S)
meta_g = meta
vec_len = len(v)
initial_pop.append(v.tolist())
problem = Problem(vec_len, 1)
problem.types[:] = Real(0, 1000)
problem.function = partial(fit, p1, meta_g)
generator = RandomGenerator()
population = []
for i in range(3):
p = generator.generate(problem)
p.variables = initial_pop[i]
problem.evaluate(p)
population.append(p)
return problem, population, meta_g, p1
def platypus_grid(w_, garden_index, grids):
# first compute convex hull of grids
# parametrize problem by just the center of the grid
points_list = []
for i in range(grids.shape[0]):
p = Point(grids[i, :])
points_list.append(p)
mtp = MultiPoint(points_list)
cvx_hull = mtp.convex_hull
gminx, gminy, gmaxx, gmaxy = cvx_hull.bounds
problem = Problem(3, 2)
problem.types[0] = Real(gminx, gmaxx)
problem.types[1] = Real(gminy, gmaxy)
problem.types[2] = Real(0, 180)
problem.function = platypus_obj
algorithm = NSGAII(problem)
algorithm.run(100)
print(algorithm.result)
return algorithm.result
def __init__(self,
template_objects,
regularization_samples,
generalization_generator,
classifier=None,
range=20):
super(GOL, self).__init__(1, 2)
self.types[:] = Real(0, 500)
self.template_objects = template_objects
self.regularization_samples = regularization_samples
self.generalization_generator = generalization_generator
self.classifier = classifier
self.range = range
self.energy = None
def run_nsgaii_bc():
def CMO(xi):
xi = np.asarray(xi)
y = [branin(xi), Currin(xi)]
return y
problem = Problem(2, 2)
problem.types[:] = Real(0, 1)
problem.function = CMO
algorithm = NSGAII(problem)
algorithm.run(2500)
cheap_pareto_front = np.array(
[list(solution.objectives) for solution in algorithm.result])
return cheap_pareto_front
def run(self, n=10000):
comp = [2000, 2000, 1000, 1000, 1000]
for c in comp:
x, y = self.generateLHS(c)
self.ranComp(x, y)
logger.debug(f"-- finish {c} --")
sum = 0
for p in comp:
sum += p
num = n - sum
logger.debug(num)
r = [Real(x[0], x[1]) for x in self.ran]
mo = MOEA_D(des=self.dim, obj=self.obj, f=self.f, r=r)
mo.run(n=num)
def __init__(self,
one_shot_objects,
regularization_samples,
generalization_generator,
classifier=None):
super(GOL, self).__init__(1, 2)
self.types[:] = Real(0, 500)
self.one_shot_objects = one_shot_objects
self.regularization_samples = regularization_samples
self.generalization_generator = generalization_generator
self.classifier = classifier
self.gen_energy = None
self.epoch_count = 0
# Plot the initial distribution of the GOL model parameters
self._plot_distributions(self.epoch_count)
def __init__(self,
num_variables,
num_objectives,
X,
T,
n_hidden,
sparse_degree=0.05,
num_constraints=0):
super(Objectives, self).__init__(
num_variables, num_objectives, num_constraints
) # the number of decision variables, objectives, and constraints
self.types[:] = Real(
-1., 1.) # specify the type(coding scheme) of decision variables
self.X, self.T = X, T
self.n_hidden = n_hidden
self.sparse_degree = sparse_degree
def make_multiobjective_function_counting(sources,
bounds,
times_more_detectors=1,
interpolation_method="nearest"):
"""
This balances the number of detectors with the quality of the outcome
bounds : list[(x_min, x_max), (y_min, y_max), ...]
The bounds on the feasible region
"""
objective_function = make_single_objective_function(
sources, interpolation_method=interpolation_method,
masked=True) # the function to be optimized
counting_function = make_counting_objective()
def multiobjective_func(x): # this is the double objective function
return [objective_function(x), counting_function(x)]
# there is an x, y, and a mask for each source so there must be three
# times more input variables
# the upper bound on the number of detectors n times the number of
# sources
parameterized_locations = sources[0].parameterized_locations
dimensionality = parameterized_locations.shape[1]
# We add a boolean flag to each location variable
num_inputs = len(sources) * (dimensionality + 1) * times_more_detectors
NUM_OUPUTS = 2 # the default for now
# define the demensionality of input and output spaces
problem = Problem(num_inputs, NUM_OUPUTS)
logging.warning(
f"Creating a multiobjective counting function with dimensionality {dimensionality}"
)
logging.warning(f"bounds are {bounds}")
for i in range(dimensionality):
# splat "*" notation is expanding the pair which is low, high
problem.types[i::(dimensionality + 1)] = Real(
*bounds[i]) # This is the feasible region
# indicator on whether the source is on
problem.types[dimensionality::(dimensionality + 1)] = Binary(1)
problem.function = multiobjective_func
return problem
def NSGA_test(data_name, input_dim, output_dim, x_bounds, epoch, population):
"""
bench_mark functionのjson
"function_name":{
"hypervolume":,
"v_ref":[],
"w_ref":[],
"x_bounds":[],
"input_dim":,
"output_dim":
}
"""
problem = Problem(input_dim, output_dim)
problem.types[:] = [
Real(x_bounds[i][0], x_bounds[i][1]) for i in range(input_dim)
]
problem.function = eval(data_name)
algorithm = NSGAII(problem, population_size=population)
start = time.perf_counter()
algorithm.run(epoch)
end = time.perf_counter() - start
v_ref = []
w_ref = []
w_ref_norm = []
print(len(algorithm.result))
pareto_frontier = np.zeros((len(algorithm.result), output_dim))
pareto_frontier_norm = np.zeros((len(algorithm.result), output_dim))
for i in range(output_dim):
frontier_i = np.array([s.objectives[i] for s in algorithm.result])
pareto_frontier[:, i] = frontier_i
min_i = np.min(frontier_i)
max_i = np.max(frontier_i)
frontier_i_norm = (frontier_i - min_i) / (max_i - min_i)
pareto_frontier_norm[:, i] = frontier_i_norm
v_ref.append(min_i)
w_ref.append(max_i)
w_ref_norm.append(1)
hyp = Hypervolume(minimum=v_ref, maximum=w_ref)
HV = hyp(algorithm.result)
return HV, end
