Source code for iwopy.interfaces.pymoo.optimizer

import numpy as np
import matplotlib.pyplot as plt

from iwopy.core import Optimizer
from .problem import SingleObjProblemTemplate, MultiObjProblemTemplate
from .factory import Factory
from . import imports


[docs] class DefaultCallbackTemplate: """ Template for the default callback :group: interfaces.pymoo """
[docs] def __init__(self): """ Constructor """ self.data["f_best"] = None self.data["cv_best"] = None
[docs] def notify(self, algorithm): fvals = algorithm.pop.get("F") cvals = algorithm.pop.get("CV") n_obj = fvals.shape[1] n_con = cvals.shape[1] i = np.argmin(fvals, axis=0) if self.data["f_best"] is None: self.data["f_best"] = fvals[None, i, range(n_obj)] self.data["cv_best"] = cvals[None, i, range(n_con)] else: self.data["f_best"] = np.append( self.data["f_best"], fvals[None, i, range(n_obj)], axis=0 ) self.data["cv_best"] = np.append( self.data["cv_best"], cvals[None, i, range(n_con)], axis=0 )
[docs] @classmethod def get_class(cls): """ Creates the class, dynamically derived from pymoo.Callback """ imports.load() attrb = {v: d for v, d in cls.__dict__.items()} init0 = cls.__init__ def init1(self): imports.Callback.__init__(self) init0(self) attrb["__init__"] = init1 attrb["__doc__"] = "The default callback" del attrb["get_class"] return type("DefaultCallback", (imports.Callback,), attrb)()
[docs] class Optimizer_pymoo(Optimizer): """ Interface to the pymoo optimization solver. Attributes ---------- problem_pars: dict Parameters for the problem algo_pars: dict Parameters for the alorithm setup_pars: dict Parameters for the calculation setup term_pars: dict Parameters for the termination conditions pymoo_problem: iwopy.interfaces.pymoo.SingleObjProblem The pygmo problem algo: pygmo.algo The pygmo algorithm :group: interfaces.pymoo """
[docs] def __init__(self, problem, problem_pars, algo_pars, setup_pars={}, term_pars={}): """ Constructor Parameters ---------- problem: iwopy.Problem The problem to optimize problem_pars: dict Parameters for the problem algo_pars: dict Parameters for the alorithm setup_pars: dict Parameters for the calculation setup """ super().__init__(problem) self.problem_pars = problem_pars self.algo_pars = algo_pars self.setup_pars = setup_pars self.term_pars = term_pars self.pymoo_problem = None self.algo = None
[docs] def print_info(self): """ Print solver info, called before solving """ super().print_info() if len(self.problem_pars): print("\nProblem:") print("--------") for k, v in self.problem_pars.items(): if isinstance(v, int) or isinstance(v, float) or isinstance(v, str): print(f" {k}: {v}") if len(self.algo_pars): print("\nAlgorithm:") print("----------") for k, v in self.algo_pars.items(): if isinstance(v, int) or isinstance(v, float) or isinstance(v, str): print(f" {k}: {v}") if len(self.setup_pars): print("\nSetup:") print("------") for k, v in self.setup_pars.items(): if isinstance(v, int) or isinstance(v, float) or isinstance(v, str): print(f" {k}: {v}") if len(self.term_pars): print("\nTermination:") print("------------") if isinstance(self.term_pars, (tuple, list)): print(f" {self.term_pars[0]}: {self.term_pars[1]}") else: for k, v in self.term_pars.items(): if isinstance(v, int) or isinstance(v, float) or isinstance(v, str): print(f" {k}: {v}") print()
[docs] def initialize(self, verbosity=1): """ Initialize the object. Parameters ---------- verbosity: int The verbosity level, 0 = silent """ if self.problem.n_objectives <= 1: self.pymoo_problem = SingleObjProblemTemplate.get_class()( self.problem, **self.problem_pars ) else: self.pymoo_problem = MultiObjProblemTemplate.get_class()( self.problem, **self.problem_pars ) if verbosity: print("Initializing", type(self).__name__) factory = Factory(self.pymoo_problem, verbosity) self.algo = factory.get_algorithm(self.algo_pars) self.term = factory.get_termination(self.term_pars) super().initialize(verbosity)
[docs] def solve(self, callback="default", verbosity=1): """ Run the optimization solver. Parameters ---------- callback: pymoo.Callback, optional The callback verbosity: int The verbosity level, 0 = silent Returns ------- results: iwopy.SingleObjOptResults or iwopy.MultiObjOptResults The optimization results object """ if callback == "default": callback = DefaultCallbackTemplate.get_class() # check problem initialization: super().solve() # run pymoo solver: self.callback = callback self.results = imports.minimize( self.pymoo_problem, algorithm=self.algo, termination=self.term, verbose=verbosity > 0, callback=self.callback, **self.setup_pars, ) # transfer callback: if self.callback is not None: self.callback = self.results.algorithm.callback return self.pymoo_problem.finalize(self.results)
[docs] def get_figure_f(self, fig=None, ax=None, valid_dict=None, **kwargs): """ Create a figure that shows the objective function development during optimization. The kwargs are forwarded to the plot command. Parameters ---------- fig: plt.Figure, optional The figure to which to add the plot ax: plt.Axis, optional The axis to which to add the plot valid_dict: dict, optional Settings for the point of first valid solution, forwarded to scatter Returns ------- fig: plt.Figure The figure """ if self.problem.n_objectives() == 1: if fig is None and ax is None: fig, ax = plt.subplots() elif ax is None: ax = fig.add_subplot(111) else: raise TypeError(f"Impossible fig/ax input") fname = self.problem.objs[0].base_name fvals = self.callback.data["f_best"] gens = range(len(fvals)) ax.plot(gens, fvals, label=fname, **kwargs) if self.problem.n_constraints(): cv = np.array(self.callback.data["cv_best"]) sel = cv == 0.0 if np.any(sel): i = np.argwhere(sel)[0][0] vdict = {"label": "first valid", "color": "red"} if valid_dict is not None: vdict.update(valid_dict) ax.scatter(i, fvals[i], **vdict) ax.legend() ax.set_xlabel("n_gen") ax.set_ylabel(fname) plt.tight_layout() return fig else: raise NotImplementedError