def _do(self):
rnd = sample_on_unit_simplex(self.n_sample_points,
self.n_dim,
unit_simplex_mapping=self.sampling)
def h(n):
return get_partition_closest_to_points(n, self.n_dim)
H = h(self.n_points)
E = get_reference_directions("das-dennis", self.n_dim, n_partitions=H)
E = E[np.any(E == 0, axis=1)]
# add the edge coordinates
X = np.row_stack([E, rnd])
I = select_points_with_maximum_distance(X,
self.n_points,
selected=list(range((len(E)))))
centroids = X[I].copy()
if self.kmeans:
#centroids = kmeans(X, centroids, self.kmeans_max_iter, self.kmeans_a_tol, 0)
centroids = kmeans(X, centroids, self.kmeans_max_iter,
self.kmeans_a_tol, len(E))
return centroids
def Main(algorithm, problem, pop_size, crossover_probability,
mutation_probability, n_partitions, n_gen, seed):
# Instancia el problema
problem = Problems.get(problem)
reference_directions = get_reference_directions("das-dennis",
problem.n_obj,
n_partitions=n_partitions)
# Instancia el algoritmo
algorithm = NSGA_II.Get_Algorithm_Instance(
pop_size, crossover_probability, mutation_probability
) if (algorithm == Algorithms.NSGAII) else NSGA_III.Get_Algorithm_Instance(
reference_directions, pop_size, crossover_probability,
mutation_probability) if (algorithm == Algorithms.NSGAIII) else None
# Instancia el optimizador
optimizer = Optimizer(problem, algorithm)
optimization_result = optimizer.Minimize(n_gen, seed)
objective_spaces_values = optimization_result.F
pareto_front = problem.pareto_front(reference_directions) if type(
problem).__name__ == "DTLZ1" else problem.pareto_front()
# Instancia los indicadores de rendimiento (Distancia Generacional Invertida (IGD) / Distancia Generacional Invertida Plus (IGD+))
IGD = get_performance_indicator("igd", pareto_front)
#IGD_plus = get_performance_indicator("igd+", pareto_front)
# Imprime las métricas obtenidas por el conjunto de soluciones resultantes de la optimización multimodal/multiobjetivo
print("IGD:", IGD.calc(objective_spaces_values))
def ref_dirs(self):
ref_dirs = get_reference_directions(
"energy",
self.optimization_problem.n_objectives,
self.population_size,
seed=1)
return ref_dirs
def _calc_pareto_front(self):
ref_kwargs = dict(n_points=100) if self.n_obj == 2 else dict(
n_partitions=15)
ref_dirs = get_reference_directions('das-dennis',
n_dim=self.n_obj,
**ref_kwargs)
return generic_sphere(ref_dirs)
def generate_solution(self):
if self.rescheduling:
n_obj = 6
else:
n_obj = 5
ref_dirs = get_reference_directions("das-dennis",
n_obj,
n_partitions=8)
selection = get_selection('tournament',
func_comp=feasability_tournament,
pressure=self.tournament_size)
algorithm = NSGA3(pop_size=self.population_size,
sampling=DockSampling(),
selection=selection,
crossover=DockCrossover(),
mutation=DockMutation(),
ref_dirs=ref_dirs,
eliminate_duplicates=func_is_duplicate)
res = minimize(DockProblem(n_obj, self),
algorithm,
seed=1,
verbose=True,
save_history=True,
termination=('n_gen', self.max_generations))
return res.X.flatten(), res.history
def build_problem(name,
n_var,
n_obj,
n_init_sample,
n_process=1,
extra_params=None,
mode=0):
'''
Build optimization problem from name, get initial samples
Input:
name: name of the problem (supports ZDT1-6, DTLZ1-7)
n_var: number of design variables
n_obj: number of objectives
n_init_sample: number of initial samples
n_process: number of parallel processes
Output:
problem: the optimization problem
X_init, Y_init: initial samples
pareto_front: the true pareto front of the problem (if defined, otherwise None)
'''
# build problem
if name.startswith('zdt') or name == 'vlmop2':
problem = get_problem(name, n_var=n_var)
pareto_front = problem.pareto_front()
elif name.startswith('dtlz'):
problem = get_problem(name, n_var=n_var, n_obj=n_obj)
if n_obj <= 3 and name in ['dtlz1', 'dtlz2', 'dtlz3', 'dtlz4']:
ref_kwargs = dict(n_points=100) if n_obj == 2 else dict(
n_partitions=15)
ref_dirs = get_reference_directions('das-dennis',
n_dim=n_obj,
**ref_kwargs)
pareto_front = problem.pareto_front(ref_dirs)
elif n_obj == 3 and name in ['dtlz5', 'dtlz6']:
pareto_front = problem.pareto_front()
else:
pareto_front = None
else:
if mode == 0:
transformToInteger = False
else:
transformToInteger = True
if name == "cdn_ram" or name == "cdn_placement":
problem = get_problem(name,
n_var=n_var,
n_obj=n_obj,
transformToInteger=transformToInteger)
topo, fileSize, colorMode, colorList, runReqNums, warmUpReqNums, separatorRankIncrement, deleteCachePath, interval = extra_params
problem.get_parameters(topo, fileSize, colorMode, colorList,
runReqNums, warmUpReqNums,
separatorRankIncrement, n_process,
deleteCachePath, interval)
else:
problem = get_problem(name, n_var=n_var, n_obj=n_obj)
# get initial samples
X_init, Y_init = generate_initial_samples(problem, n_init_sample)
return problem, X_init, Y_init # problem, pareto_front, X_init, Y_init
def get_setup(n_obj):
if n_obj == 3:
pop_size = 91
ref_dirs = get_reference_directions("das-dennis",
n_obj,
n_points=pop_size)
return {
'ref_dirs': ref_dirs,
'crossover': SimulatedBinaryCrossover(20, n_offsprings=1, prob=0.9),
'mutation': PolynomialMutation(20)
}
def _nsga3(self) -> object:
sampling = get_sampling("int_random")
crossover = get_crossover("int_sbx")
mutation = get_mutation("int_pm")
# create the reference directions to be used for the optimization
if self._nome_of_mono is None:
ref_dirs = get_reference_directions("das-dennis",
len(self._nomes_direcoes_of),
n_partitions=len(
self._variaveis))
else:
ref_dirs = get_reference_directions("das-dennis",
1,
n_partitions=len(
self._variaveis))
algorithm = NSGA3(pop_size=self._tamanho_populacao,
sampling=sampling,
crossover=crossover,
mutation=mutation,
ref_dirs=ref_dirs,
eliminate_duplicates=True)
return algorithm
def set_algorithm(name, no_obj, setup):
"""
Text.
Args:
name (str): Name of the optimization algorithm.
n_obj (int): Number of objectives.
setup (dict): Optimization setup parameters.
Returns:
algorithm (): Optization algorithm object.
"""
if name == "default":
if no_obj == 1:
name = "ga"
elif no_obj > 1:
name = "nsga3"
# Get settings
setup_gen = load_json(
os.path.join(settings["root"], "app", "config", "opticonf", "general"))
setup_alg = load_json(
os.path.join(settings["root"], "app", "config", "opticonf", name))
algorithm_args = {}
# Get optimization settings objects
algorithm_args["sampling"] = get_sampling(setup_gen["sampling"])
if "operators" in setup:
for operator in setup["operators"]:
algorithm_args[operator] = get_operator(operator, setup)
# Get reference directions
if name == "nsga3":
algorithm_args["ref_dirs"] = get_reference_directions(
"energy", no_obj, setup_alg["ref_dirs_coef"] * no_obj)
# Modify population
if "n_offsprings" in setup:
algorithm_args["n_offsprings"] = setup["n_offsprings"]
if "pop_size" in setup:
algorithm_args["pop_size"] = setup["pop_size"]
algorithm = get_algorithm(name,
eliminate_duplicates=True,
**algorithm_args)
return algorithm
def test_equal_during_run(n_obj):
# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("energy", n_obj, n_points=100)
# create the algorithm object
algorithm = NSGA3(pop_size=92, ref_dirs=ref_dirs)
print(f"NDS with {n_obj} objectives.")
# execute the optimization
minimize(DTLZ2(n_obj=n_obj),
algorithm,
callback=MyCallback(),
seed=1,
termination=('n_gen', 200),
verbose=True)
def generate_solution(self):
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=8)
selection = get_selection('random')
#selection = get_selection('tournament',func_comp=feasability_tournament,pressure=self.tournament_size)
algorithm = NSGA2(pop_size=self.population_size,
sampling=GA_wrapper.PrioSampling(),
selection=selection,
crossover=GA_wrapper.PrioCrossover(),
mutation=GA_wrapper.PrioMutation(),
eliminate_duplicates=False)
res = minimize(GA_wrapper.PrioProblem(3, self),
algorithm,
seed=1,
verbose=True,
save_history=True,
termination=('n_gen', self.max_generations))
return res.X.flatten(), res.history
def build_problem(name, n_var, n_obj, n_init_sample, n_process=1):
'''
Build optimization problem from name, get initial samples
Input:
name: name of the problem (supports ZDT1-6, DTLZ1-7)
n_var: number of design variables
n_obj: number of objectives
n_init_sample: number of initial samples
n_process: number of parallel processes
Output:
problem: the optimization problem
X_init, Y_init: initial samples
pareto_front: the true pareto front of the problem (if defined, otherwise None)
'''
# build problem
if name.startswith('zdt') or name == 'vlmop2':
problem = get_problem(name, n_var=n_var)
pareto_front = problem.pareto_front()
elif name.startswith('dtlz'):
problem = get_problem(name, n_var=n_var, n_obj=n_obj)
if n_obj <= 3 and name in ['dtlz1', 'dtlz2', 'dtlz3', 'dtlz4']:
ref_kwargs = dict(n_points=100) if n_obj == 2 else dict(
n_partitions=15)
ref_dirs = get_reference_directions('das-dennis',
n_dim=n_obj,
**ref_kwargs)
pareto_front = problem.pareto_front(ref_dirs)
elif n_obj == 3 and name in ['dtlz5', 'dtlz6']:
pareto_front = problem.pareto_front()
else:
pareto_front = None
else:
try:
problem = get_problem(name)
except:
raise NotImplementedError('problem not supported yet!')
try:
pareto_front = problem.pareto_front()
except:
pareto_front = None
# get initial samples
X_init, Y_init = generate_initial_samples(problem, n_init_sample)
return problem, pareto_front, X_init, Y_init
def test_equal_during_run(self):
class MyCallback(Callback):
def notify(self, algorithm):
F = algorithm.pop.get("F")
python_fast_nds = load_function("fast_non_dominated_sort", _type="python")(F)
cython_fast_nds = load_function("fast_non_dominated_sort", _type="cython")(F)
assert_fronts_equal(python_fast_nds, cython_fast_nds)
python_efficient_fast_nds = load_function("efficient_non_dominated_sort", _type="python")(F,
strategy="binary")
assert_fronts_equal(python_fast_nds, python_efficient_fast_nds)
cython_efficient_fast_nds = load_function("efficient_non_dominated_sort", _type="cython")(F,
strategy="binary")
assert_fronts_equal(python_efficient_fast_nds, cython_efficient_fast_nds)
python_efficient_fast_nds_bin = load_function("efficient_non_dominated_sort", _type="python")(F)
assert_fronts_equal(python_fast_nds, python_efficient_fast_nds_bin)
cython_efficient_fast_nds_bin = load_function("efficient_non_dominated_sort", _type="cython")(F)
assert_fronts_equal(python_efficient_fast_nds_bin, cython_efficient_fast_nds_bin)
python_tree_based_nds = load_function("tree_based_non_dominated_sort", _type="python")(F)
assert_fronts_equal(python_fast_nds, python_tree_based_nds)
for n_obj in [3, 5, 10]:
# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("energy", n_obj, n_points=100)
# create the algorithm object
algorithm = NSGA3(pop_size=92,
ref_dirs=ref_dirs)
print(f"NDS with {n_obj} objectives.")
# execute the optimization
minimize(DTLZ2(n_obj=n_obj),
algorithm,
callback=MyCallback(),
seed=1,
termination=('n_gen', 600),
verbose=True)
def build_ensemble(x, y, num_splits, error_metric):
K_folds = KFold(n_splits=num_splits)
cv_error_measure = []
weights = get_reference_directions("das-dennis", 5, n_partitions=10)
count = 0
for train_index, test_index in K_folds.split(x):
count = count + 1
print(
'\x1b[1A\x1b[2K' + "Calculating optimal ensemble weights... [", (count / K_folds.get_n_splits()) * 100,
"% ]")
trained_models = train_models(x[train_index], y[train_index])
pred = predict_models(trained_models, x[test_index])
ensemble_error_measure = []
for j in weights:
y_pred = np.sum((j * np.array(pred).T), axis=1)
ensemble_error_measure.append(error_metric(y_pred, y[test_index]))
cv_error_measure.append(ensemble_error_measure)
mean_cv_ensembles = np.mean(cv_error_measure, axis=0)
best_weights = weights[np.argmin(mean_cv_ensembles)]
return best_weights
def test_das_dennis_achievable_points():
ref_dirs = get_reference_directions("das-dennis", 3, n_points=91)
assert len(ref_dirs) == 91
def optimize(config):
""" This is the core function."""
#---------------------------------------------------------------------------
# Config validation.
#---------------------------------------------------------------------------
if config.feasinfeas_2N:
assert config.novelty is not None, 'Must set a novelty method for feasinfeas_2N'
assert config.novelty is False or config.novelty in novelty.archives, 'Novelty method does not exist:' + config.novelty
feasinfeas = bool(config.feasinfeas) or bool(config.feasinfeas_2N)
if config.out is not None:
os.makedirs(config.out, exist_ok=False)
for k, v in vars(config).items():
if k[0] != '_': print(f'{k}: {v}')
original_state = State.fromFile(config.state)
original_state = original_state.mergeIslands()[0]
if config.seed is not None:
random.seed(config.seed)
np.random.seed(config.seed)
# for metric_name, limit, in config.metrics:
# assert (type(limit) is float and 0 <= limit <= 1), F'{limit} is not a number.'
# assert hasattr(metrics, metric_name), F'{metric_name} is not a metric.'
print('-' * 80)
#---------------------------------------------------------------------------
# The core of the code. First, contract the state graph.
#---------------------------------------------------------------------------
print('Subdividing State:')
states = [original_state]
mappings = [None]
while states[-1].n_tiles > config.max_start_tiles:
state, mapping = states[-1].contract()
states.append(state)
mappings.append(mapping)
states = states[::-1]
mappings = mappings[::-1]
#---------------------------------------------------------------------------
# Second, Create an initial population that has populaiton equality.
#---------------------------------------------------------------------------
state = states[0]
print(f"{'-'*80}\nCreating Initial Population:")
seeds = np.array(feasible_seeds(state, config))
#---------------------------------------------------------------------------
# Create metrics and hypervolume-masks. Masks determine which metrics are
# used for hypervolume.
#---------------------------------------------------------------------------
used_metrics = [] # list of funtions that return floats.
used_constraints = [] # list of funtions that return binary.
if feasinfeas:
feas_mask = [] # Binary array if metric_i is used in feas.
infeas_mask = [] # Binary array if metric_i is used in infeas.
metrics_limits = np.array([metrics.limits[m] for m in config.metrics])
for mi, name in enumerate(config.metrics):
limit = metrics.limits[name]
used_metrics.append(getattr(metrics, name))
if limit < 1.0:
used_constraints.append(
partial(value_constraint, index=mi, threshold=limit))
if feasinfeas:
feas_mask.append(True)
infeas_mask.append(
limit < 1.0) # If it has a limit it is a constraint.
if config.equality_constraint > 0:
used_constraints.append(
partial(equality_constraint, threshold=config.equality_constraint))
if feasinfeas: # FI uses contraints as objectives in infeas population.
used_metrics.append(
partial(metrics.equality
)) # Equality objective does not have a threshold.
feas_mask.append(False) # Only infeas population considers this.
infeas_mask.append(True)
if feasinfeas and config.novelty: # add the flag for novelty last.
infeas_mask.append(True) # Infeas always uses novelty.
feas_mask.append(config.feasinfeas_2N
) # Feas pop only uses novelty if this flag set.
ALG = NSGA2
if config.NSGA3:
from pymoo.factory import get_reference_directions
#TODO: grid search nsga3 params.
ref_dirs = get_reference_directions("das-dennis",
len(hv_mask),
n_partitions=50)
ALG = partial(NSGA3, ref_dirs=ref_dirs)
if feasinfeas:
run_fi = partial(run_fi_optimization,
feas_mask=feas_mask,
infeas_mask=infeas_mask)
assert len(feas_mask) == len(infeas_mask) == (len(used_metrics) +
bool(config.novelty))
#---------------------------------------------------------------------------
# Run a optimization process for each resolution using the previous
# outputs as the seeds for the next.
#---------------------------------------------------------------------------
print('-' * 80 + '\n' + 'Starting Optimization:')
hv_histories = []
# pf_histories = []
n_gens = config.n_gens // len(states)
for opt_i, (state, mapping) in enumerate(zip(states, mappings)):
print('-' * 80)
print(f'Optimizing {opt_i} / {len(states)}')
print(f'\tNum tiles: {state.n_tiles}')
last_phase = opt_i == len(states) - 1
OPT = run_fi if feasinfeas else run_optimization
result, hv_history = OPT(ALG, state, used_metrics, used_constraints,
seeds, config, n_gens, opt_i)
hv_histories.append(hv_history)
# pf_histories.append(pf_history)
if config.out is not None:
save_results(config, state, result, opt_i,
hv_history) #, pf_history)
plot_results(config, state, result, opt_i,
hv_history) #, pf_history)
if not last_phase:
# seeds = upscale(result.X, mapping)
seeds = upscale(result.pop.get('X'), mapping)
print('Final HV %f' % hv_history[-1])
return result.X.tolist(), result.F.tolist(), hv_histories
# START load_data
from pymoo.factory import get_problem, get_reference_directions
ref_dirs = get_reference_directions("uniform", 6, n_partitions=5)
F = get_problem("dtlz1").pareto_front(ref_dirs)
# END load_data
# START radviz
from pymoo.visualization.radviz import Radviz
Radviz().add(F).show()
# END radviz
# START radviz_custom
plot = Radviz(title="Optimization",
legend=(True, {'loc': "upper left", 'bbox_to_anchor': (-0.1, 1.08, 0, 0)}),
labels=["profit", "cost", "sustainability", "environment", "satisfaction", "time"],
endpoint_style={"s": 70, "color": "green"})
plot.set_axis_style(color="black", alpha=1.0)
plot.add(F, color="grey", s=20)
plot.add(F[65], color="red", s=70, label="Solution A")
plot.add(F[72], color="blue", s=70, label="Solution B")
plot.show()
# END radviz_custom
# file related constants
GEN = 100
NP = 100
# important methods -> ref_point
problem = "zdt6"
ref_point = np.array([1, 9.735527117321219])
if problem.startswith("zdt"):
pf = get_problem(problem).pareto_front()
# Dtlz-5 to dtlz-7 have their own files related to their pareto fronts
elif problem == "dtlz5" or problem == "dtlz6" or problem == "dtlz7":
pf = get_problem(problem, n_var=N_VAR,n_obj=N_OBJ).pareto_front()
else:
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)
pf = get_problem(problem, n_var=N_VAR,n_obj=N_OBJ).pareto_front(ref_dirs=ref_dirs)
metric = Hypervolume(pf=pf, ref_point=ref_point, normalize=True)
# dtlz-1 -> [482.1632866685836,479.911835933397,471.9731868733398]
# dtlz-2 -> [2.651414902010465,2.5206368624614965,2.656093434231162]
# dtlz-3 -> [1784.9822112456513,1683.7871520696372,1679.1459524987113]
# dtlz-4 -> [2.7493608245409247,2.665459302333755,2.691506519652278]
# dtlz-5 -> [2.6184046195044153,2.3154562025982375,2.490037232873547]
# dtlz-6 -> [10.460414515081052,10.523716498291654,10.571261523682367]
# dtlz-7 -> [1,1,24.464595045398383]
# zdt-1 -> [1, 5.687041127771669]
# zdt-2 -> [1, 6.71194298397789]
def main():
# Define search algorithms
algorithms = list()
# 1: GA
algorithm = GA(
pop_size=config.POPULATION_SIZE,
sampling=SudoRandomInitialization(),
# crossover=AdaptiveSinglePointCrossover(prob=0.8),
crossover=get_crossover("real_k_point", n_points=2),
mutation=BitStringMutation(),
eliminate_duplicates=RefactoringSequenceDuplicateElimination()
)
algorithms.append(algorithm)
# 2: NSGA II
algorithm = NSGA2(pop_size=config.POPULATION_SIZE,
sampling=SudoRandomInitialization(),
# crossover=AdaptiveSinglePointCrossover(prob=0.8),
crossover=get_crossover("real_k_point", n_points=2),
mutation=BitStringMutation(),
eliminate_duplicates=RefactoringSequenceDuplicateElimination()
)
algorithms.append(algorithm)
# 3: NSGA III
# Todo: Ask for best practices in determining ref_dirs
ref_dirs = get_reference_directions("energy", 8, 90, seed=1)
algorithm = NSGA3(ref_dirs=ref_dirs,
pop_size=config.POPULATION_SIZE,
sampling=SudoRandomInitialization(),
# crossover=AdaptiveSinglePointCrossover(prob=0.8),
crossover=get_crossover("real_k_point", n_points=2),
mutation=BitStringMutation(),
eliminate_duplicates=RefactoringSequenceDuplicateElimination()
)
algorithms.append(algorithm)
# Define problems
problems = list()
problems.append(
ProblemSingleObjective(n_refactorings_lowerbound=config.LOWER_BAND, n_refactorings_upperbound=config.UPPER_BAND)
)
problems.append(
ProblemMultiObjective(n_refactorings_lowerbound=config.LOWER_BAND, n_refactorings_upperbound=config.UPPER_BAND)
)
problems.append(
ProblemManyObjective(n_refactorings_lowerbound=config.LOWER_BAND, n_refactorings_upperbound=config.UPPER_BAND)
)
# Do optimization for various problems with various algorithms
res = minimize(problem=problems[2],
algorithm=algorithms[2],
termination=('n_gen', config.MAX_ITERATIONS),
seed=1,
verbose=True)
logger.info("** FINISHED **")
logger.info("Best Individual:")
logger.info(res.X)
logger.info("Objective Values:")
logger.info(res.F)
logger.info("==================")
logger.info("Other Solutions:")
for ind in res.opt:
logger.info(ind.X)
logger.info(ind.F)
logger.info("==================")
logger.info(f"Start Time: {res.start_time}")
logger.info(f"End Time: {res.end_time}")
logger.info(f"Execution Time in Seconds: {res.exec_time}")
from pymoo.factory import get_problem, get_reference_directions
from pymoo.visualization.pcp import PCP
ref_dirs = get_reference_directions("das-dennis", 6, n_partitions=5) * [2, 4, 8, 16, 32, 64]
F = get_problem("dtlz1").pareto_front(ref_dirs)
PCP().add(F).show()
plot = PCP()
plot.set_axis_style(color="grey", alpha=0.5)
plot.add(F, color="grey", alpha=0.3)
plot.add(F[50], linewidth=5, color="red")
plot.add(F[75], linewidth=5, color="blue")
plot.show()
plot.reset()
plot.normalize_each_axis = False
plot.bounds = [[1, 1, 1, 2, 2, 5], [32, 32, 32, 32, 32, 32]]
plot.show()
def test_das_dennis():
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)
assert len(ref_dirs) == 91
from pymoo.algorithms.nsga3 import NSGA3
from pymoo.factory import get_reference_directions
from pymoo.optimize import minimize
from pymoo.problems.multi.sympart import SYMPART, SYMPARTRotated
from pymoo.visualization.scatter import Scatter
import matplotlib.pyplot as plt
for problem, name in zip([SYMPART(), SYMPARTRotated()],
["SYM-PART", "SYM-PART rotated"]):
ref_dirs = get_reference_directions("das-dennis",
problem.n_obj,
n_partitions=20)
PS = problem.pareto_set(500)
PF = problem.pareto_front(500)
algorithm = NSGA3(ref_dirs=ref_dirs)
res = minimize(problem, algorithm, ('n_gen', 500), seed=1, verbose=False)
fig_name = f"{algorithm.__class__.__name__} on {name}"
# visualize decision space
plot = Scatter(title="Decision Space")
plot.add(PS, s=10, color='r', label="PS")
plot.add(res.X, s=30, color='b', label="Obtained solutions")
plot.do()
plt.legend()
# visualize objective space
plot = Scatter(title="Objective Space")
plot.add(PF, s=10, color='r', label="PF")
sampling_func,
crossover_func, crossover_func_args,
mutation_func, mutation_func_args,
)
)
elif alg_name == "MOEAD":
alg_specific_args = MOO_CONFIG["alg_specific_args"]["MOEAD"]
n_neighbors = alg_specific_args["n_neighbors"]
prob_neighbor_mating = alg_specific_args["prob_neighbor_mating"]
#################
# set algorithm #
#################
algorithm = MOEAD(
ref_dirs=get_reference_directions(ref_dir_func,
**ref_dir_func_args),
n_neighbors=n_neighbors,
prob_neighbor_mating=prob_neighbor_mating,
crossover=get_crossover(crossover_func, **crossover_func_args),
mutation=get_mutation(mutation_func, **mutation_func_args),
)
#####################
# algorithm logging #
#####################
MOO_log(
msg="algorithm = {}(\n"
"ref_dirs = get_reference_directions({},{}),\n"
"n_neighbors = {}\n"
"prob_neighbor_mating = {}\n"
"crossover=get_crossover({},{}),\n"
"mutation=get_mutation({},{}),\n"
else:
hv = 0
results.append((j[0], res, res.F, hv))
hypervolume_scores[ind, i] = hv
ind = ind + 1
mean_hv = np.mean(hypervolume_scores, axis=1)
std = np.std(hypervolume_scores, axis=1)
output = []
for i in range(len(problems)):
output.append([problems[i][0], mean_hv[i], std[i]])
path = 'results/' + algorithm.__module__ + '.csv'
pd.DataFrame(np.array(output)).to_csv(path,
header=('function', 'mean HV',
'std'),
index=False)
print("all runs:", hypervolume_scores)
return (hypervolume_scores, print("Output written to " + path + '\n'))
problems = (('bnh', np.array([140, 50])), ('tnk', np.array([2, 2])),
('ctp1', np.array([1, 2])), ('zdt4', np.array([1, 260])),
('kursawe', np.array([-10,
2])), ('welded_beam', np.array([350, 0.1])),
('carside', np.array([42, 4.5, 13])))
ref_dir = get_reference_directions("das-dennis", 2, n_partitions=10)
algorithms = (NSGA2(pop_size=10), MOEAD(ref_dir,
n_neighbors=10), CTAEA(ref_dir))
for algorithm in algorithms:
print("Minimizing functions with " + algorithm.__module__)
compute_mean_HV(algorithm, problems, 50)
from pymoo.algorithms.moead import MOEAD
from pymoo.factory import get_problem, get_visualization, get_reference_directions
from pymoo.optimize import minimize
problem = get_problem("dtlz2")
algorithm = MOEAD(get_reference_directions("das-dennis", 3, n_partitions=12),
n_neighbors=15,
decomposition="pbi",
prob_neighbor_mating=0.7)
res = minimize(problem, algorithm, termination=('n_gen', 200))
get_visualization("scatter").add(res.F).show()
def main():
# get argument values
args = get_args()
# get reference point
if args.ref_point is None:
args.ref_point = get_ref_point(args.problem, args.n_var, args.n_obj,
args.n_init_sample)
t0 = time()
# set seed
np.random.seed(args.seed)
# build problem, get initial samples
jsonFile = "/home/picarib/Desktop/cdnet/config/json/sbd_custom.json"
configDirPath = "/home/picarib/Desktop/cdnet/config/sbd_custom/"
dataPath = "/home/picarib/Desktop/cdnet/data/"
config = loadJSON(jsonFile)
interval = 1 if "custom" not in config["RequestModels"] else config[
"RequestModels"]["custom"]["interval"]
isLoadRTable = config["isLoadRTable"]
isLoadSeparatorRank = config["isLoadSeparatorRank"]
mode = config["RoutingMode"] # [no-cache, no-color, tag-color, full-color]
fileSize = config["FileSize"]
runReqNums = config["RunReqNums"] if "RunReqNums" in config else -1
warmUpReqNums = config["WarmUpReqNums"] if "WarmUpReqNums" in config else -1
colorNums = config["colorNums"]
separatorRankIncrement = config["separatorRankIncrement"]
colorList = [
''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
for i in range(colorNums)
]
topo = NetTopology(config, configDirPath, mode, warmUpReqNums, fileSize,
colorList)
topo.build()
extra_params = (topo, fileSize, mode, colorList, runReqNums, warmUpReqNums,
separatorRankIncrement)
problem, X_init, Y_init = build_problem(args.problem,
args.n_var,
args.n_obj,
args.n_init_sample,
args.n_process,
extra_params=extra_params)
args.n_var, args.n_obj, args.algo = problem.n_var, problem.n_obj, 'moeda'
# save arguments and setup logger
save_args(args)
logger = setup_logger(args)
print(problem)
# initialize evolutionary algorithm
ref_dir = get_reference_directions("das-dennis", 2, n_partitions=15)
args.batch_size = min(len(ref_dir), args.batch_size)
# initialize population
if args.pop_init_method == 'lhs':
sampling = LatinHypercubeSampling()
elif args.pop_init_method == 'nds':
sorted_indices = NonDominatedSorting().do(Y_init)
sampling = X_init[np.concatenate(sorted_indices)][:args.batch_size]
if len(sampling) < args.batch_size:
rest_sampling = lhs(X_init.shape[1],
args.batch_size - len(sampling))
sampling = np.vstack([sampling, rest_sampling])
elif args.pop_init_method == 'random':
sampling = FloatRandomSampling()
else:
raise NotImplementedError
ea_algorithm = MOEAD(ref_dir,
n_neighbors=args.batch_size,
sampling=sampling,
crossover=get_crossover("int_one_point"),
mutation=get_mutation("int_pm", prob=1.0 / 13),
decomposition="pbi",
seed=1)
# initialize data exporter
exporter = DataExport(X_init, Y_init, args)
# find Pareto front
res = minimize(problem,
ea_algorithm, ('n_gen', args.n_iter),
save_history=True)
X_history = np.array([algo.pop.get('X') for algo in res.history])
Y_history = np.array([algo.pop.get('F') for algo in res.history])
# update data exporter
for X_next, Y_next in zip(X_history, Y_history):
exporter.update(X_next, Y_next)
# export all result to csv
exporter.write_csvs()
# statistics
final_hv = calc_hypervolume(exporter.Y, exporter.ref_point)
print('========== Result ==========')
print('Total runtime: %.2fs' % (time() - t0))
print('Total evaluations: %d, hypervolume: %.4f\n' %
(args.batch_size * args.n_iter, final_hv))
# close logger
if logger is not None:
logger.close()
af = AirfoilFFD()
# Setup problem
class OptProblem(Problem):
def __init__(self, n_var, xl, xu):
super().__init__(n_var=n_var, n_obj=2, xl=xl, xu=xu)
def _evaluate(self, X, out, *args, **kwargs):
out["F"] = af.obj_func(X)
problem = OptProblem(n_var=af.dim,
xl=af.bounds[:, 0],
xu=af.bounds[:, 1])
algorithm = CTAEA(ref_dirs=get_reference_directions("das-dennis",
2,
n_partitions=14),
seed=None)
termination = get_termination("n_gen", 11)
print('Run EA ...')
res = minimize(problem,
algorithm,
termination,
seed=None,
save_history=True,
verbose=True)
run_time = time.time() - t0
print('Wall time: {:.1f}s'.format(run_time))
# START ctaea
from pymoo.algorithms.ctaea import CTAEA
from pymoo.factory import get_problem, get_reference_directions
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter
problem = get_problem("DASCMOP1", 2)
# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("das-dennis", problem.n_obj, n_points=91)
# create the algorithm object
algorithm = CTAEA(ref_dirs=ref_dirs)
# execute the optimization
res = minimize(problem, algorithm, ('n_gen', 600), seed=1, verbose=True)
plot = Scatter()
plot.add(problem.pareto_front(), plot_type="line", color="black", alpha=0.7)
plot.add(res.F, color="red")
plot.show()
# END ctaea
# START carside
problem = get_problem("carside")
ref_dirs = get_reference_directions("das-dennis", problem.n_obj, n_points=91)
algorithm = CTAEA(ref_dirs=ref_dirs)
res = minimize(problem, algorithm, ('n_gen', 600), seed=1, verbose=True)
Scatter().add(res.F).show()
def test_das_dennis_not_achievable_points():
get_reference_directions("das-dennis", 3, n_points=92)
def calc_pareto_front(problem, ref_dirs):
n_pareto_points = 200
np.random.seed(1)
pf = problem.pareto_front(n_pareto_points=n_pareto_points, use_cache=False)
# survival = ReferenceDirectionSurvival(ref_dirs)
survival = RankAndCrowdingSurvival()
for i in range(1000):
_pf = problem.pareto_front(n_pareto_points=n_pareto_points,
use_cache=False)
F = np.row_stack([pf, _pf])
pop = Population().new("F", F)
pop = survival.do(problem, pop, n_pareto_points // 2)
pf = pop.get("F")
return pf
if __name__ == '__main__':
ref_dirs = get_reference_directions("das-dennis", 3, n_points=91)
F = calc_pareto_front(WFG3(6, 3), ref_dirs)
Scatter().add(F).show()
for problem in [WFG1, WFG2, WFG3, WFG4, WFG5, WFG6, WFG7, WFG8, WFG9]:
print("")
