def generate_test_data():
for str_problem in ["osy"]:
problem = get_problem(str_problem)
X = []
# define a callback function that prints the X and F value of the best individual
def my_callback(algorithm):
pop = algorithm.pop
_X = pop.get("X")[np.random.permutation(len(pop))[:10]]
X.append(_X)
minimize(problem,
method='nsga2',
method_args={'pop_size': 100},
termination=('n_gen', 100),
callback=my_callback,
pf=problem.pareto_front(),
disp=True,
seed=1)
np.savetxt("%s.x" % str_problem,
np.concatenate(X, axis=0),
delimiter=",")
asf = np.eye(F.shape[1])
asf[asf == 0] = 1e6
F_asf = np.max(F * asf[:, None, :], axis=2).T / 1e6
for k in range(n_obj):
crowding[np.argmin(F_asf[:, k])] = np.inf
return crowding
def normalize(F, ideal_point, nadir_point, utopian_epsilon=0.0):
utopian_point = ideal_point - utopian_epsilon
N = (F - utopian_point) / (nadir_point - utopian_point)
return N
problem = get_problem("dtlz2", n_var=None, n_obj=3, k=5)
n_gen = 400
pop_size = 91
ref_dirs = UniformReferenceDirectionFactory(3, n_partitions=12,
scaling=1.0).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='nsga2',
method_args={
'pop_size': 100,
'survival': ASFSurvival()
},
from pymoo.optimize import minimize
from pymoo.algorithms.nsga2 import nsga2
from pymoo.util import plotting
import numpy as np
from pymop.factory import get_problem
# create the algorithm object
method = nsga2(pop_size=100, elimate_duplicates=True)
# execute the optimization
res = minimize(get_problem("zdt1"), method, termination=('n_gen', 200))
print("Best solution found: %s" % res.X)
print("Function value: %s" % res.F)
print("Constraint violation: %s" % res.CV)
plotting.plot(res.F, no_fill=True)
from pymop.factory import get_problem, get_uniform_weights
# for some problems the pareto front does not need any parameters
pf = get_problem("tnk").pareto_front()
pf = get_problem("osy").pareto_front()
# for other problems the number of non-dominated points can be defined
pf = get_problem("zdt1").pareto_front(n_pareto_points=100)
# for DTLZ for example the reference direction should be provided, because the pareto front for the
# specific problem will depend on the factory for the reference lines
ref_dirs = get_uniform_weights(100, 3)
pf = get_problem("dtlz1", n_var=7, n_obj=3).pareto_front(ref_dirs)
import numpy as np
from pymop.factory import get_problem
problem = get_problem("zdt1")
F, dF, CV = problem.evaluate(np.random.random((100, 30)),
return_values_of=["F", "dF", "CV"])
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymop.factory import get_problem, UniformReferenceDirectionFactory
# create the optimization problem
problem = get_problem("dtlz2")
ref_dirs = UniformReferenceDirectionFactory(3, n_points=100).do()
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='moead',
method_args={
'ref_dirs': ref_dirs,
'n_neighbors': 15,
'decomposition': 'pbi',
'prob_neighbor_mating': 0.7
},
termination=('n_gen', 200),
pf=pf,
save_history=False,
disp=True)
plotting.plot(pf, res.F, labels=["Pareto-front", "F"])
return {
'ref_dirs': ref_dirs,
'pop_size': pop_size,
'crossover': SimulatedBinaryCrossover(1.0, 30),
'mutation': PolynomialMutation(20)
}
setup = {
# ==========================================
# DTLZ1
# ==========================================
'dtlz1_3obj': {
'termination': ('n_gen', 400),
'problem': get_problem("dtlz1", None, 3, k=5),
**get_setup(3)
},
'dtlz1_5obj': {
'termination': ('n_gen', 600),
'problem': get_problem("dtlz1", None, 5, k=5),
**get_setup(5)
},
'dtlz1_8obj': {
'termination': ('n_gen', 750),
'problem': get_problem("dtlz1", None, 8, k=5),
**get_setup(8)
},
'dtlz1_10obj': {
'termination': ('n_gen', 1000),
'problem': get_problem("dtlz1", None, 10, k=5),
# create the optimization problem
import numpy as np
from pymoo.model.population import Population
from pymoo.optimize import minimize
from pymop.factory import get_problem
problem = get_problem("rastrigin")
pop_size = 100
pop = Population(pop_size)
pop.set("X", np.random.random((pop_size, problem.n_var)))
res = minimize(problem,
method='ga',
method_args={
'pop_size': pop_size,
'sampling': pop
},
termination=('n_gen', 200),
disp=True)
from pymoo.util import plotting
from pymoo.experimental.pbi import ReferenceDirectionSurvivalPBI
from pymoo.optimize import minimize
from pymoo.util.reference_direction import UniformReferenceDirectionFactory, MultiLayerReferenceDirectionFactory
from pymop.factory import get_problem
import matplotlib.pyplot as plt
import numpy as np
problem = get_problem("dtlz3", n_var=None, n_obj=15, k=10)
n_gen = 2000
pop_size = 136
ref_dirs = MultiLayerReferenceDirectionFactory([
UniformReferenceDirectionFactory(15, n_partitions=2, scaling=1.0),
UniformReferenceDirectionFactory(15, n_partitions=1, scaling=0.5)
]).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
ideal_point = []
nadir_point = []
def my_callback(algorithm):
ideal_point.append(np.copy(algorithm.survival.ideal_point))
nadir_point.append(np.copy(algorithm.survival.nadir_point))
import numpy as np # this will be the evaluation function that is called each time from pymop.factory import get_problem from pymop.problem import Problem def my_evaluate_func(x, out, *args, **kwargs): f1 = 31*x[:,0] + 38*x[:,1] + 19*x[:,2] + 37*x[:,3] + 45*x[:,4] + 23*x[:,5] + 23*x[:,6]) f2 = 27*x[:,0] + 35*x[:,1] + 74*x[:,2] + 62*x[:,3] + 22*x[:,4] + 27*x[:,5] + 33*x[:,6]) f3 = 61*x[:,0] + 56*x[:,1] + 55*x[:,2] + 84.6*x[:,3] + 65*x[:,4] + 73*x[:,5] + 62*x[:,6] g1 = x[:,0] + x[:,1] + x[:,2] + x[:,3] + x[:,4] + x[:,5] + x[:,6] - 1 g2 = 1 - x[:,0] - x[:,1] - x[:,2] - x[:,3] - x[:,4] - x[:,5] - x[:,6] out["F"] = anp.column_stack([f1]) out["G"] = anp.column_stack([g1, g2]) mask = ["int", "int", "int", "int", "int", "int", "int"] problem = get_problem(my_evaluate_func, np.array([0, 0 , 0, 0, 0, 0, 0, 0]), np.array([1, 1, 1, 1, 1, 1, 1])) F, CV = problem.evaluate(np.random.rand(100, 7))
from pymoo.optimize import minimize
from pymop.factory import get_problem
problem = get_problem("g01")
res = minimize(problem,
method='ga',
method_args={
'pop_size': 100,
'eliminate_duplicates': False,
},
termination=('n_gen', 50),
disp=True)
print("Best solution found: %s" % res.X)
print("Function value: %s" % res.F)
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymoo.util.reference_direction import UniformReferenceDirectionFactory
from pymop.factory import get_problem
problem = get_problem("dtlz2", n_var=12, n_obj=3)
# create the reference directions to be used for the optimization
ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='unsga3',
method_args={
'pop_size': 100,
'ref_dirs': ref_dirs
},
termination=('n_gen', 200),
pf=pf,
disp=True)
plotting.plot(res.F)
__F = _F - ideal_point
__F[__F < 1e-3] = 0
# update the extreme points for the normalization having the highest asf value each
F_asf = np.max(__F * asf[:, None, :], axis=2)
I = np.argmin(F_asf, axis=1)
return I
def normalize(F, ideal_point, nadir_point, utopian_epsilon=0.0):
utopian_point = ideal_point - utopian_epsilon
N = (F - utopian_point) / (nadir_point - utopian_point)
return N
problem = get_problem("carside")
#problem = ConvexProblem(DTLZ2(n_var=12, n_obj=3))
n_gen = 400
pop_size = 91
ref_dirs = UniformReferenceDirectionFactory(3, n_partitions=12,
scaling=1.0).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(
UniformReferenceDirectionFactory(3, n_partitions=70, scaling=1.0).do())
res = minimize(
problem,
method='nsga3',
import numpy as np
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymop.factory import get_problem, UniformReferenceDirectionFactory
problem = get_problem("zdt1")
pf = problem.pareto_front()
# create the reference directions to be used for the optimization
ref_points = np.array([[0.3, 0.4], [0.8, 0.5]])
res = minimize(problem,
method='rnsga3',
method_args={
'ref_points': ref_points,
'pop_per_ref_point': 50,
'mu': 0.1
},
termination=('n_gen', 400),
pf=pf,
disp=True)
plotting.plot(pf,
res.F,
ref_points,
show=True,
labels=['pf', 'F', 'ref_points'])
problem = get_problem("dtlz4", n_var=12, n_obj=3)
ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do()
pf = problem.pareto_front(ref_dirs)
'mutation': PolynomialMutation(20)
}
setup = {
# ==========================================
# MISC
# ==========================================
# ==========================================
# C1-DTLZ1
# ==========================================
'c1-dtlz1-3obj': {
'termination': ('n_gen', 500),
'problem': get_problem("c1dtlz1", n_obj=3),
**get_setup(3),
},
'c1-dtlz1-5obj': {
'termination': ('n_gen', 600),
'problem': get_problem("c1dtlz1", n_obj=5),
**get_setup(5),
},
# ==========================================
# C1-DTLZ3
# ==========================================
'c1-dtlz3-3obj': {
'termination': ('n_gen', 1000),
'problem': get_problem("c1dtlz3", n_obj=3),
**get_setup(3),
# ZDT 1
#
import numpy as np
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymop.factory import get_problem
problem = get_problem("zdt1", n_var=30)
pf = problem.pareto_front()
# create the reference directions to be used for the optimization
ref_points = np.array([[0.5, 0.2], [0.1, 0.6]])
res = minimize(
problem,
method='rnsga2',
method_args={
'pop_size': 40,
'ref_points': ref_points,
'epsilon': 0.02,
'normalization': 'no',
'survival_type': "closest",
'extreme_points_as_reference_points': True
# 'weights': np.array([0.9, 0.1])
},
save_history=True,
termination=('n_gen', 500),
seed=1,
pf=pf,
disp=True)
from pymop.factory import get_problem
# create a simple test problem from string
p = get_problem("Ackley")
# the input name is not case sensitive
p = get_problem("ackley")
# also input parameter can be provided directly
p = get_problem("dtlz1", n_var=20, n_obj=5)
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymoo.util.reference_direction import UniformReferenceDirectionFactory
from pymop.factory import get_problem
problem = get_problem("dtlz1", n_var=7, n_obj=3)
# create the reference directions to be used for the optimization
ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='nsga3',
method_args={
'pop_size': 92,
'ref_dirs': ref_dirs
},
termination=('n_gen', 400),
pf=pf,
seed=1,
disp=True)
plotting.plot(res.F)
from pymoo.optimize import minimize
from pymop.factory import get_problem
problem = get_problem("rastrigin", n_var=10)
res = minimize(problem,
method='de',
method_args={
'pop_size': 200,
'variant': "DE/rand+best/1/exp",
'CR': 0.5,
'F': 0.75,
# 'selection': RandomSelection(),
# 'survival': ConstraintHandlingSurvival(method="parameter_less"),
# 'survival': ConstraintHandlingSurvival(method="epsilon_constrained")
# 'survival': ConstraintHandlingSurvival(method="penalty", weight=0.25)
# 'survival': ConstraintHandlingSurvival(method="stochastic_ranking", prob=0.45)
},
termination=('n_gen', 1750),
disp=True)
print("Best solution found: %s" % res.X)
print("Function value: %s" % res.F)
config = configparser.ConfigParser()
config.read("configuration.ini")
PROBLEM = str(config['Properties']['PROBLEM'])
BOUND_LOW = float(config['Properties']['BOUND_LOW'])
BOUND_UP = float(config['Properties']['BOUND_UP'])
NDIM = int(config['Properties']['DIMENSIONS'])
ALGORITHM = str(config['Properties']['ALGORITHM'])
NGEN = int(config['Properties']['NGEN'])
MU = int(config['Properties']['POPULATION'])
CXPB = float(config['Properties']['CXPB'])
CXETA = float(config['Properties']['CXETA'])
MUTETA = float(config['Properties']['MUTETA'])
problem = factory.get_problem(PROBLEM, n_var=NDIM)
creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0))
creator.create("Individual",
array.array,
typecode='d',
fitness=creator.FitnessMin)
def uniform(low, up, size=None):
try:
return [random.uniform(a, b) for a, b in zip(low, up)]
except TypeError:
return [
random.uniform(a, b) for a, b in zip([low] * size, [up] * size)
]
}
}
if __name__ == '__main__':
run_files = []
prefix = "runs"
method_name = "pyde-rand+best-exp"
n_runs = 31
entries = setup.keys()
for key in entries:
s = setup[key]
str_problem = s['problem']
problem = get_problem(str_problem)
for run in range(n_runs):
fname = "%s_%s_%s.run" % (method_name, str_problem, (run + 1))
data = {
'args': [problem, "de"],
'kwargs': {
'method_args': {
'pop_size': 200
},
'termination': s['termination'],
'seed': (run + 1)
},
'out':
"%s/%s/%s_%s_%s.out" %
"""
This is the experiment for nsga2.
"""
import os
import pickle
from pymoo.algorithms.nsga2 import nsga2
from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover
from pymoo.operators.mutation.polynomial_mutation import PolynomialMutation
from pymop.factory import get_problem
setup = {
'zdt1': {
'pop_size': 100,
'termination': ('n_gen', 200),
'problem': get_problem("zdt1", n_var=30),
'crossover': SimulatedBinaryCrossover(0.9, 15),
'mutation': PolynomialMutation(20),
},
'zdt2': {
'pop_size': 100,
'termination': ('n_gen', 200),
'problem': get_problem("zdt2", n_var=30),
'crossover': SimulatedBinaryCrossover(0.9, 15),
'mutation': PolynomialMutation(20)
},
'zdt3': {
'pop_size': 100,
'termination': ('n_gen', 200),
'problem': get_problem("zdt3", n_var=30),
'crossover': SimulatedBinaryCrossover(0.9, 15),
import matplotlib.pyplot as plt
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymoo.util.reference_direction import UniformReferenceDirectionFactory
from pymop.factory import get_problem
problem = get_problem("c3dtlz4", n_var=12, n_obj=3)
# create the reference directions to be used for the optimization
ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do()
#ref_dirs = UniformReferenceDirectionFactory(2, n_points=100).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='nsga3',
method_args={
'pop_size': 92,
'ref_dirs': ref_dirs
},
termination=('n_gen', 1000),
pf=pf,
seed=4,
disp=True)
plotting.plot(res.F)
aggregation['l'].append('asf')
aggregation['G'].append('acv')
aggregation['fg_M5'].append('asfcv')
aggregation['fg_M6'].append('asfcv')
metamodel_list = ['dacefit']
init_pop_size = 100
pop_size_per_epoch = 21
pop_size_per_algorithm = 21
pop_size_lf = 100
problem_name = 'tnk'
# problem = get_problem(problem_name, n_var=10, n_obj=2)
problem = get_problem(problem_name)
# problem = get_problem(problem_name, n_var=10)
ref_dirs = UniformReferenceDirectionFactory(problem.n_obj, n_points=pop_size_per_epoch).do()
if problem_name.__contains__('dtlz'):
pf = problem.pareto_front(ref_dirs=ref_dirs)
else:
pf = np.loadtxt("../data/IGD/TNK.2D.pf") # problem.pareto_front()
acq_list, framework_acq_dict = get_acq_function(framework_id=framework_id,
aggregation=aggregation,
problem=problem,
n_dir=pop_size_per_epoch)
res = minimize(problem=problem,
method='samoo',
def test_correctness(self):
np.random.seed(1)
setup = {
"zdt1": {
'utopian_epsilon': 1e-3
},
"zdt2": {
'utopian_epsilon': 1e-4
},
"zdt3": {
'utopian_epsilon': 1e-4,
"ideal_point": np.array([0.0, -1.0])
},
"osy": {
'utopian_epsilon': 0.0,
"ideal_point": np.array([-300, -0.05])
}
}
for str_problem, parameter in setup.items():
problem = get_problem(str_problem)
import os
X = np.loadtxt(os.path.join("resources", "kktpm",
"%s.x" % str_problem),
delimiter=",")
#F = np.loadtxt(os.path.join("resources", "kktpm", "%s.f" % str_problem))
#G = np.loadtxt(os.path.join("resources", "kktpm", "%s.g" % str_problem))
_F, _G, _dF, _dG = problem.evaluate(
X, return_values_of=["F", "G", "dF", "dG"])
#self.assertTrue(np.abs(F - _F).mean() < 1e-6)
#self.assertTrue(np.abs(G - _G).mean() < 1e-6)
#indices = np.random.permutation(X.shape[0])[:100]
indices = np.arange(X.shape[0])
# load the correct results
correct = np.loadtxt(
os.path.join("resources", "kktpm",
"%s.kktpm" % str_problem))[indices]
# calculate the KKTPM measure
kktpm, _ = KKTPM(var_bounds_as_constraints=True).calc(
X[indices], problem, **parameter)
error = np.abs(kktpm[:, 0] - correct)
for i in range(len(error)):
if error[i] > 0.0001:
print("Error for ", str_problem)
print("index: ", i)
print("Error: ", error[i])
print("X", ",".join(np.char.mod('%f', X[i])))
print("Python: ", kktpm[i])
print("Correct: ", correct[i])
import os
os._exit(1)
# make sure the results are almost equal
self.assertTrue(error.mean() < 1e-6)
print(str_problem, error.mean())
from pymoo.algorithms.nsga3 import NSGA3
from pymoo.experimental.emo.max_non_dominated import ReferenceDirectionSurvivalNonDominated
from pymoo.experimental.emo.max_of_extremes import ReferenceDirectionSurvivalMaxExtremes
from pymoo.experimental.emo.true import ReferenceDirectionSurvivalTrue
from pymoo.model.termination import MaximumGenerationTermination
from pymop import ScaledProblem
from pymop.factory import get_problem
setup = {
# ==========================================
# DTLZ1
# ==========================================
'dtlz1_3obj': {
'termination': ('n_gen', 400),
'problem': get_problem("dtlz1", None, 3, k=5),
**get_setup(3)
},
'dtlz1_5obj': {
'termination': ('n_gen', 600),
'problem': get_problem("dtlz1", None, 5, k=5),
**get_setup(5)
},
'dtlz1_10obj': {
'termination': ('n_gen', 1000),
'problem': get_problem("dtlz1", None, 10, k=5),
**get_setup(10)
},
# ==========================================
# DTLZ2
from pymoo.optimize import minimize
from pymoo.util import plotting
from pymoo.util.reference_direction import UniformReferenceDirectionFactory
from pymop.factory import get_problem
problem = get_problem("dtlz1")
# create the reference directions to be used for the optimization
ref_dirs = UniformReferenceDirectionFactory(3, n_points=91).do()
# create the pareto front for the given reference lines
pf = problem.pareto_front(ref_dirs)
res = minimize(problem,
method='nsga3',
method_args={
'pop_size': 92,
'ref_dirs': ref_dirs
},
termination=('n_gen', 600),
pf=pf,
seed=4,
disp=True)
# if desired we can filter out the solutions that are not close to ref_dirs
closest_to_ref_dir = res.opt.get("closest")
plotting.plot(res.F[closest_to_ref_dir, :], show=True)
