def solve(self):
# the result object to be finally returned
res = Result()
# set the timer in the beginning of the call
res.start_time = time.time()
# call the algorithm to solve the problem
self._solve(self.problem)
# store the time when the algorithm as finished
res.end_time = time.time()
res.exec_time = res.end_time - res.start_time
# store the resulting population
res.pop = self.pop
# get the optimal solution found
opt = self.opt
# if optimum is not set
if len(opt) == 0:
opt = None
# if no feasible solution has been found
elif not np.any(opt.get("feasible")):
if self.return_least_infeasible:
opt = filter_optimum(opt, least_infeasible=True)
else:
opt = None
# set the optimum to the result object
res.opt = opt
# if optimum is set to none to not report anything
if opt is None:
X, F, CV, G = None, None, None, None
# otherwise get the values from the population
else:
X, F, CV, G = self.opt.get("X", "F", "CV", "G")
# if single-objective problem and only one solution was found - create a 1d array
if self.problem.n_obj == 1 and len(X) == 1:
X, F, CV, G = X[0], F[0], CV[0], G[0]
# set all the individual values
res.X, res.F, res.CV, res.G = X, F, CV, G
# create the result object
res.problem, res.pf = self.problem, self.pf
res.history = self.history
return res
def solve(self):
# the result object to be finally returned
res = Result()
# set the timer in the beginning of the call
res.start_time = time.time()
# call the algorithm to solve the problem
self._solve()
# create the result object based on the current iteration
res = self.result()
return res
def solve(self):
# the result object to be finally returned
res = Result()
# call the algorithm to solve the problem
self._solve(self.problem)
# store the resulting population
res.pop = self.pop
# if the algorithm already set the optimum just return it, else filter it by default
if self.opt is None:
opt = filter_optimum(res.pop.copy(), least_infeasible=self.return_least_infeasible)
else:
opt = self.opt
# get the vectors and matrices
res.opt = opt
if isinstance(opt, Population):
X, F, CV, G = opt.get("X", "F", "CV", "G")
elif isinstance(opt, Individual):
X, F, CV, G = opt.X, opt.F, opt.CV, opt.G
else:
X, F, CV, G = None, None, None, None
# set all the individual values
res.X, res.F, res.CV, res.G = X, F, CV, G
# create the result object
res.problem, res.pf = self.problem, self.pf
res.history = self.history
return res
def solve(self,
problem,
termination,
seed=None,
disp=False,
callback=None,
save_history=False,
pf=None,
**kwargs):
"""
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
termination: 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.
disp : bool
If it is true than information during the algorithm execution are displayed
callback : func
A callback function can be passed that is executed every generation. The parameters for the function
are the algorithm itself, the number of evaluations so far and the current population.
def callback(algorithm):
pass
save_history : bool
If true, a current snapshot of each generation is saved.
pf : np.array
The Pareto-front for the given problem. If provided performance metrics are printed during execution.
Returns
-------
res : dict
A dictionary that saves all the results of the algorithm. Also, the history if save_history is true.
"""
# set the random seed for generator
if seed is not None:
random.seed(seed)
# the evaluator object which is counting the evaluations
self.evaluator = Evaluator()
self.problem = problem
self.termination = termination
self.pf = pf
self.disp = disp
self.callback = callback
self.save_history = save_history
# call the algorithm to solve the problem
pop = self._solve(problem, termination)
# get the optimal result by filtering feasible and non-dominated
opt = pop.copy()
opt = opt[opt.collect(lambda ind: ind.feasible)[:, 0]]
# if at least one feasible solution was found
if len(opt) > 0:
if problem.n_obj > 1:
I = NonDominatedSorting().do(opt.get("F"),
only_non_dominated_front=True)
opt = opt[I]
X, F, CV, G = opt.get("X", "F", "CV", "G")
else:
opt = opt[np.argmin(opt.get("F"))]
X, F, CV, G = opt.X, opt.F, opt.CV, opt.G
else:
opt = None
res = Result(opt, opt is None, "")
res.algorithm, res.problem, res.pf = self, problem, pf
res.pop = pop
if opt is not None:
res.X, res.F, res.CV, res.G = X, F, CV, G
res.history = self.history
return res