def __init__(self):
Problem.__init__(self)
self.n_var = n_params
self.n_constr = 0
self.n_obj = 1
self.func = self.evaluate_
self.xl = 0.01 * np.ones(n_params)
self.xu = 20 * np.ones(n_params)
def __init__(self):
Problem.__init__(self)
self.n_var = n_var
self.n_constr = n_constr
self.n_obj = n_obj
self.func = self._evaluate
self.xl = xl
self.xu = xu
def __init__(self, n_var=1, **kwargs):
Problem.__init__(self, **kwargs)
self.n_var = n_var
self.n_constr = 0
self.n_obj = 1
self.func = self._evaluate
self.xl = 0 * np.ones(self.n_var)
self.xu = 10 * np.ones(self.n_var)
def __init__(self, n_var, thetaL, thetaU, func_likelihood):
Problem.__init__(self)
self.n_var = n_var
self.n_constr = 0
self.n_obj = 1
self.func_likelihood = func_likelihood
self.func = self.evaluate_
self.xl = thetaL
self.xu = thetaU
def calc_domination_matrix(F, G):
if G is None or len(G) == 0:
constr = np.zeros((F.shape[0], F.shape[0]))
else:
# consider the constraint violation
#CV = Problem.calc_constraint_violation(G)
#constr = (CV < CV) * 1 + (CV > CV) * -1
CV = Problem.calc_constraint_violation(G)[:, 0]
constr = (CV[:, None] < CV) * 1 + (CV[:, None] > CV) * -1
# look at the obj for dom
n = F.shape[0]
L = np.repeat(F, n, axis=0)
R = np.tile(F, (n, 1))
smaller = np.reshape(np.any(L < R, axis=1), (n, n))
larger = np.reshape(np.any(L > R, axis=1), (n, n))
dom = np.logical_and(smaller, np.logical_not(larger)) * 1 \
+ np.logical_and(larger, np.logical_not(smaller)) * -1
# if cv equal then look at dom
M = constr + (constr == 0) * dom
return M
def __init__(self, name, n_var, n_obj, k=None):
Problem.__init__(self)
self.n_obj = n_obj
self.n_var = n_var
self.k = 2 * (self.n_obj - 1) if k is None else k
self.func = self._evaluate
self.xl = np.zeros(self.n_var)
self.xu = np.ones(self.n_var)
# function used to evaluate
self.func = self._evaluate
# the function pointing to the optproblems implementation
exec('import optproblems.wfg')
clazz, = eval('optproblems.wfg.%s' % name),
self._func = clazz(num_objectives=self.n_obj,
num_variables=self.n_var,
k=self.k)
def minimize(fun, x0):
n_var = len(x0)
p = Problem(n_var=n_var, n_obj=1, n_constr=0, xl=-10, xu=10, func=None)
def evaluate(x):
f = numpy.zeros((x.shape[0], 1))
g = numpy.zeros((x.shape[0], 0))
if x.ndim == 1:
x = numpy.array([x])
for i in range(x.shape[0]):
f[i, :] = fun(x[i, :])[0]
return f, g
p.evaluate = evaluate
# X,F,G = NSGA(pop_size=300).solve(p, 60000)
# X, F, G = solve_by_de(p)
print(X)
print(F)
return X[0, :]
def _do(self, pop, off, size, **kwargs):
pop.merge(off)
if pop.F.shape[1] != 1:
raise ValueError("FitnessSurvival can only used for single objective problems!")
if pop.G is None or len(pop.G) == 0:
CV = np.zeros(pop.F.shape[0])
else:
CV = Problem.calc_constraint_violation(pop.G)
CV[CV < 0] = 0.0
# sort by cv and fitness
sorted_idx = sorted(range(pop.size()), key=lambda x: (CV[x], pop.F[x]))
# now truncate the population
sorted_idx = sorted_idx[:size]
pop.filter(sorted_idx)
def evaluate(self,
X,
*args,
return_values_of="auto",
return_as_dictionary=False,
**kwargs):
"""
Evaluate the given problem.
The function values set as defined in the function.
The constraint values are meant to be positive if infeasible. A higher positive values means "more" infeasible".
If they are 0 or negative, they will be considered as feasible what ever their value is.
Parameters
----------
X : np.array
A two dimensional matrix where each row is a point to evaluate and each column a variable.
return_as_dictionary : bool
If this is true than only one object, a dictionary, is returned. This contains all the results
that are defined by return_values_of. Otherwise, by default a tuple as defined is returned.
return_values_of : list of strings
You can provide a list of strings which defines the values that are returned. By default it is set to
"auto" which means depending on the problem the function values or additional the constraint violation (if
the problem has constraints) are returned. Otherwise, you can provide a list of values to be returned.
Allowed is ["F", "CV", "G", "dF", "dG", "dCV", "hF", "hG", "hCV", "feasible"] where the d stands for
derivative and h stands for hessian matrix.
Returns
-------
A dictionary, if return_as_dictionary enabled, or a list of values as defined in return_values_of.
"""
# make the array at least 2-d - even if only one row should be evaluated
# only_single_value = len(np.shape(X)) == 1
only_single_value = len(np.shape(X)) == 1
X = np.atleast_2d(X)
# check the dimensionality of the problem and the given input
# if X.shape[1] != self.n_var:
# raise Exception('Input dimension %s are not equal to n_var %s!' % (X.shape[1], self.n_var))
# automatic return the function values and CV if it has constraints if not defined otherwise
if type(return_values_of) == str and return_values_of == "auto":
return_values_of = ["F"]
if self.n_constr > 0:
return_values_of.append("CV")
# create the output dictionary for _evaluate to be filled
out = {}
for val in return_values_of:
out[val] = None
# all values that are set in the evaluation function
values_not_set = [
val for val in return_values_of if val not in self.evaluation_of
]
# have a look if gradients are not set and try to use autograd and calculate grading if implemented using it
gradients_not_set = [
val for val in values_not_set if val.startswith("d")
]
# if no autograd is necessary for evaluation just traditionally use the evaluation method
if len(gradients_not_set) == 0:
self._evaluate(X, out, *args, **kwargs)
at_least2d(out)
# if constraint violation should be returned as well
if self.n_constr == 0:
CV = np.zeros([X.shape[0], 1])
else:
CV = Problem.calc_constraint_violation(out["G"])
if "CV" in return_values_of:
out["CV"] = CV
# if an additional boolean flag for feasibility should be returned
if "feasible" in return_values_of:
out["feasible"] = (CV <= 0)
# remove the first dimension of the output - in case input was a 1d- vector
if only_single_value:
for key in out.keys():
if out[key] is not None:
out[key] = out[key][0, :]
if return_as_dictionary:
return out
else:
# if just a single value do not return a tuple
if len(return_values_of) == 1:
return out[return_values_of[0]]
else:
return tuple([out[val] for val in return_values_of])
def solve(
self,
problem,
evaluator,
seed=1,
return_only_feasible=True,
return_only_non_dominated=True,
history=None,
):
"""
Solve a given problem by a given evaluator. The evaluator determines the termination condition and
can either have a maximum budget, hypervolume or whatever. The problem can be any problem the algorithm
is able to solve.
Parameters
----------
problem: class
Problem to be solved by the algorithm
evaluator: class
object that evaluates and saves the number of evaluations and determines the stopping condition
seed: int
Random seed for this run. Before the algorithm starts this seed is set.
return_only_feasible : bool
If true, only feasible solutions are returned.
return_only_non_dominated : bool
If true, only the non dominated solutions are returned. Otherwise, it might be - dependend on the
algorithm - the final population
Returns
-------
X: matrix
Design space
F: matrix
Objective space
G: matrix
Constraint space
"""
# set the random seed for generator
pymoo.rand.random.seed(seed)
# just to be sure also for the others
seed = pymoo.rand.random.randint(0, 100000)
random.seed(seed)
np.random.seed(seed)
# this allows to provide only an integer instead of an evaluator object
if not isinstance(evaluator, Evaluator):
evaluator = Evaluator(evaluator)
# call the algorithm to solve the problem
X, F, G = self._solve(problem, evaluator)
if return_only_feasible:
if G is not None and G.shape[0] == len(F) and G.shape[1] > 0:
cv = Problem.calc_constraint_violation(G)[:, 0]
X = X[cv <= 0, :]
F = F[cv <= 0, :]
if G is not None:
G = G[cv <= 0, :]
if return_only_non_dominated:
idx_non_dom = NonDominatedRank.calc_as_fronts(F, G)[0]
X = X[idx_non_dom, :]
F = F[idx_non_dom, :]
if G is not None:
G = G[idx_non_dom, :]
return X, F, G