pymoo 0.6.1.5.dev0__cp310-cp310-macosx_11_0_arm64.whl

pymoo/vendor/vendor_coco.py

@@ -0,0 +1,81 @@
+import os
+
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+class COCOProblem(Problem):
+
+    def __init__(self, name, n_var=10, pf_from_file=True, **kwargs):
+        self.function, self.instance, self.object = get_bbob(name, n_var)
+        self.name = name
+        self.pf_from_file = pf_from_file
+
+        coco = self.object
+        n_var, n_obj, n_ieq_constr = coco.number_of_variables, coco.number_of_objectives, coco.number_of_constraints
+        xl, xu = coco.lower_bounds, coco.upper_bounds
+
+        super().__init__(n_var=n_var,
+                         n_obj=n_obj,
+                         n_ieq_constr=n_ieq_constr,
+                         xl=xl,
+                         xu=xu,
+                         **kwargs)
+
+    def _calc_pareto_set(self, *args, **kwargs):
+        if self.n_obj == 1:
+            fname = '._bbob_problem_best_parameter.txt'
+
+            self.object._best_parameter(what="print")
+            ps = np.loadtxt(fname)
+            os.remove(fname)
+
+            return ps
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        if self.pf_from_file:
+            return Remote.get_instance().load("pymoo", "pf", "bbob.pf", to="json")[str(self.function)][str(self.instance)]
+        else:
+            ps = self.pareto_set()
+            if ps is not None:
+                return self.evaluate(ps)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        out["F"] = np.array([self.object(x) for x in X])
+
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        d["object"] = None
+        return d
+
+    def __setstate__(self, d):
+        self.__dict__.update(d)
+        self.object = get_bbob(self.name, self.n_var)
+
+
+def get_bbob(name, n_var=10, **kwargs):
+    try:
+        import cocoex as ex
+    except:
+        raise Exception("COCO test suite not found. \nInstallation Guide: https://github.com/numbbo/coco")
+
+    args = name.split("-")
+
+    n_instance = int(args[-1])
+    n_function = int(args[-2].replace("f", ""))
+
+    assert 1 <= n_function <= 24, f"BBOB has 24 different functions to be chosen. {n_function} is out of range."
+
+    suite_filter_options = f"function_indices: {n_function} " \
+                           f"instance_indices: {n_instance} " \
+                           f"dimensions: {n_var}"
+
+    problems = ex.Suite("bbob", "", suite_filter_options)
+    assert len(problems) == 1, "COCO problem not found."
+
+    coco = problems.next_problem()
+
+    return n_function, n_instance, coco
+

pymoo/vendor/vendor_scipy.py

@@ -0,0 +1,232 @@
+
+from pymoo.core.termination import NoTermination
+from pymoo.termination.max_eval import MaximumFunctionCallTermination
+from pymoo.util.display.single import SingleObjectiveOutput
+
+try:
+    from scipy.optimize import minimize as scipy_minimize, NonlinearConstraint, LinearConstraint
+except:
+    raise Exception("Please install SciPy: pip install scipy")
+
+import warnings
+
+import numpy as np
+
+from pymoo.algorithms.base.local import LocalSearch
+from pymoo.core.individual import Individual, constr_to_cv
+from pymoo.core.population import Population
+
+from pymoo.termination.max_gen import MaximumGenerationTermination
+
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Interface
+# ---------------------------------------------------------------------------------------------------------
+
+
+class Optimizer(LocalSearch):
+
+    def __init__(self, method, with_bounds=False, with_constr=False, require_jac=False,
+                 use_bounds=True, use_constr=True, estm_gradients=True, disp=False, show_warnings=False, **kwargs):
+
+        super().__init__(output=SingleObjectiveOutput(), **kwargs)
+
+        self.method, self.with_bounds, self.with_constr, self.require_jac = method, with_bounds, with_constr, require_jac
+        self.show_warnings = show_warnings
+        self.use_bounds = use_bounds
+        self.use_constr = use_constr
+        self.estm_gradients = estm_gradients
+
+        self.options = {
+            'maxiter': int(1e8),  # because of C code interfacing this can not be inf
+            'disp': disp}
+
+    def _setup(self, problem, **kwargs):
+        if isinstance(self.termination, MaximumGenerationTermination):
+            self.options["maxiter"] = self.termination.n_max_gen
+        elif isinstance(self.termination, MaximumFunctionCallTermination):
+            self.options["maxfev"] = self.termination.n_max_evals
+
+        self.termination = NoTermination()
+        self.return_least_infeasible = True
+
+    def _advance(self, **kwargs):
+        problem, evaluator = self.problem, self.evaluator
+
+        # add the box constraints defined in the problem
+        bounds = None
+        if self.use_bounds:
+
+            xl, xu = self.problem.bounds()
+            if self.with_bounds:
+                bounds = np.column_stack([xl, xu])
+            else:
+                if xl is not None or xu is not None:
+                    raise Exception(f"Error: Boundary constraints can not be handled by {self.method}")
+
+        # define the actual constraints if supported by the algorithm
+        constr = []
+        if self.use_constr:
+
+            constr = [LinearConstraint(np.eye(self.problem.n_var), xl, xu)]
+
+            if problem.has_constraints():
+
+                if self.with_constr:
+                    def fun_constr(x):
+                        g = problem.evaluate(x, return_values_of=["G"])
+                        cv = constr_to_cv(g)
+                        return cv
+
+                    non_lin_constr = NonlinearConstraint(fun_constr, -float("inf"), 0)
+
+                    constr.append(non_lin_constr)
+
+                else:
+                    raise Exception(f"Error: Constraint handling is not supported by {self.method}")
+
+        # the objective function to be optimized and add gradients if available
+        if self.estm_gradients:
+            jac = None
+
+            def fun_obj(x):
+                f = problem.evaluate(x, return_values_of=["F"])[0]
+                evaluator.n_eval += 1
+                return f
+
+        else:
+            jac = True
+
+            def fun_obj(x):
+                f, df = problem.evaluate(x, return_values_of=["F", "dF"])
+
+                if df is None:
+                    raise Exception("If the gradient shall not be estimate, please set out['dF'] in _evaluate. ")
+
+                evaluator.n_eval += 1
+                return f[0], df[0]
+
+        # the arguments to be used
+        kwargs = dict(args=(), method=self.method, bounds=bounds, constraints=constr, jac=jac, options=self.options)
+
+        # the starting solution found by sampling beforehand
+        x0 = self.opt[0].X
+
+        # actually run the optimization
+        if not self.show_warnings:
+            warnings.simplefilter("ignore")
+
+        res = scipy_minimize(fun_obj, x0, **kwargs)
+
+        opt = Population.create(Individual(X=res.x))
+        self.evaluator.eval(self.problem, opt, algorithm=self)
+
+        self.pop, self.off = opt, opt
+
+        self.termination.force_termination = True
+
+        if hasattr("res", "nit"):
+            self.n_gen = res.nit + 1
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Object Oriented Interface
+# ---------------------------------------------------------------------------------------------------------
+
+# +++++++++++++++++++++++++++++++++++++++++
+# UNCONSTRAINED
+# +++++++++++++++++++++++++++++++++++++++++
+
+class NelderMead(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("Nelder-Mead", **kwargs)
+
+
+class CG(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("CG", require_jac=True, **kwargs)
+
+
+class NewtonCG(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("Newton-CG", require_jac=True, **kwargs)
+
+
+class BFGS(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("BFGS", **kwargs)
+
+
+class Powell(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("Powell", **kwargs)
+
+
+class Dogleg(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("dogleg", require_jac=True, **kwargs)
+
+
+class TrustNCG(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("trust-ncg", require_jac=True, **kwargs)
+
+
+class TrustExact(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("trust-exact", require_jac=True, **kwargs)
+
+
+class TrustKrylov(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("trust-krylov", require_jac=True, **kwargs)
+
+
+# +++++++++++++++++++++++++++++++++++++++++
+# BOX CONSTRAINS
+# +++++++++++++++++++++++++++++++++++++++++
+
+
+class LBFGSB(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("L-BFGS-B", with_bounds=True, **kwargs)
+
+
+class TNC(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("TNC", with_bounds=True, **kwargs)
+
+
+# +++++++++++++++++++++++++++++++++++++++++
+# NON-LINEAR CONSTRAINTS
+# +++++++++++++++++++++++++++++++++++++++++
+
+
+class COBYLA(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("COBYLA", with_bounds=False, with_constr=True, **kwargs)
+
+
+class SLSQP(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("SLSQP", with_bounds=True, with_constr=True, **kwargs)
+
+
+class TrustConstr(Optimizer):
+
+    def __init__(self, **kwargs):
+        super().__init__("trust-constr", with_bounds=True, with_constr=True, **kwargs)

pymoo/version.py

@@ -0,0 +1 @@
+__version__ = "0.6.1.5.dev"

pymoo/visualization/__init__.py

@@ -0,0 +1,8 @@
+__all__ = ["heatmap",
+           "pcp",
+           "petal",
+           "radar",
+           "radviz",
+           "scatter",
+           "star_coordinate"
+           ]

pymoo/visualization/fitness_landscape.py

@@ -0,0 +1,127 @@
+import numpy as np
+
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import all_combinations
+
+
+class FitnessLandscape(Plot):
+
+    def __init__(self,
+                 problem,
+                 _type="surface+contour",
+                 n_samples=100,
+                 colorbar=False,
+                 contour_levels=30,
+                 kwargs_surface=None,
+                 kwargs_contour=None,
+                 kwargs_contour_labels=None,
+                 **kwargs):
+
+        """
+
+        Fitness Landscape
+
+        Parameters
+        ----------------
+
+        problem : The problem to be plotted
+        _type : str
+            Either "contour", "surface" or "contour+surface"
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+
+        Returns
+        -------
+        FitnessLandscape : :class:`~pymoo.core.analytics.visualization.fitness_landscape.FitnessLandscape`
+
+        """
+
+        super().__init__(**kwargs)
+        self.problem = problem
+        self.n_samples = n_samples
+        self._type = _type
+        self.colorbar = colorbar
+
+        self.contour_levels = contour_levels
+
+        self.kwargs_surface = kwargs_surface
+        if self.kwargs_surface is None:
+            self.kwargs_surface = dict(cmap="summer", rstride=1, cstride=1)
+
+        self.kwargs_contour = kwargs_contour
+        if self.kwargs_contour is None:
+            self.kwargs_contour = dict(linestyles="solid", offset=-1)
+
+        self.kwargs_contour_labels = kwargs_contour_labels
+
+    def _do(self):
+
+        problem, n_samples, _type = self.problem, self.n_samples, self._type
+
+        if problem.n_var == 1 and problem.n_obj == 1:
+
+            self.init_figure()
+
+            X = np.linspace(problem.xl[0], problem.xu[0], num=n_samples)[:, None]
+            Z = problem.evaluate(X, return_values_of=["F"])
+            self.ax.plot(X, Z)
+            self.ax.set_xlabel("x")
+            self.ax.set_ylabel("f(x)")
+
+        elif problem.n_var == 2 and problem.n_obj == 1:
+
+            A = np.linspace(problem.xl[0], problem.xu[0], n_samples)
+            B = np.linspace(problem.xl[1], problem.xu[1], n_samples)
+            X = all_combinations(A, B)
+
+            F = np.reshape(problem.evaluate(X, return_values_of=["F"]), (n_samples, n_samples))
+
+            _X = X[:, 0].reshape((n_samples, n_samples))
+            _Y = X[:, 1].reshape((n_samples, n_samples))
+            _Z = F.reshape((n_samples, n_samples))
+
+            def plot_surface():
+                surf = self.ax.plot_surface(_X, _Y, _Z, **self.kwargs_surface)
+
+                if self.colorbar:
+                    self.fig.colorbar(surf)
+
+            def plot_contour():
+                CS = self.ax.contour(_X, _Y, _Z, self.contour_levels, **self.kwargs_contour)
+                if self.kwargs_contour_labels is not None:
+                    self.ax.clabel(CS, **self.kwargs_contour_labels)
+
+                if self.colorbar:
+                    self.fig.colorbar(CS)
+
+            if _type == "surface":
+                self.init_figure(plot_3D=True)
+                plot_surface()
+            elif _type == "contour":
+                self.init_figure(plot_3D=False)
+
+                if "offset" in self.kwargs_contour:
+                    del self.kwargs_contour["offset"]
+
+                plot_contour()
+            elif _type == "surface+contour":
+
+                self.init_figure(plot_3D=True)
+                plot_surface()
+                plot_contour()
+
+        else:
+            raise Exception("Only landscapes of problems with one or two variables and one objective can be visualized.")
+
+
+parse_doc_string(FitnessLandscape.__init__)

pymoo/visualization/heatmap.py

@@ -0,0 +1,123 @@
+import numpy as np
+
+from pymoo.visualization.util import parse_bounds, normalize
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none_from_tuples
+
+
+class Heatmap(Plot):
+
+    def __init__(self,
+                 cmap="Blues",
+                 order_by_objectives=False,
+                 reverse=True,
+                 solution_labels=True,
+                 **kwargs):
+        """
+
+        Heatmap
+
+        Parameters
+        ----------------
+
+        cmap : str
+            The color map to be used.
+
+        order_by_objectives : int or list
+            Whether the result should be ordered by an objective. If false no order.
+            Otherwise, either supply just the objective or a list. (it is lexicographically sorted).
+
+        reverse : bool
+            If true large values are white and small values the corresponding color. Otherwise, the other way around.
+
+        solution_labels : bool or list
+            If False no labels are plotted in the y axis. If true just the corresponding index. Otherwise, the label provided.
+
+        bounds : {bounds}
+
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+
+        """
+
+        super().__init__(cmap=cmap, reverse=reverse, **kwargs)
+        self.order_by_objectives = order_by_objectives
+        self.solution_labels = solution_labels
+
+        # set default style
+        set_if_none_from_tuples(self.axis_style, ("interpolation", "nearest"), ("vmin", 0), ("vmax", 1))
+
+    def _do(self):
+
+        if len(self.to_plot) != 1:
+            raise Exception("Only one element can be added to a heatmap.")
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds, reverse=self.reverse)
+        (F, kwargs) = to_plot_norm[0]
+
+        # dot the sorting if required
+        if self.order_by_objectives is not None and self.order_by_objectives is not False:
+
+            if isinstance(self.order_by_objectives, list) and len(self.order_by_objectives) == self.n_dim:
+                L = self.order_by_objectives
+            elif isinstance(self.order_by_objectives, int):
+                L = [i for i in range(F.shape[1]) if i != self.order_by_objectives]
+                L.insert(0, self.order_by_objectives)
+            else:
+                L = range(self.n_dim)
+
+            _F = [F[:, j] for j in L]
+            I = np.lexsort(_F[::-1])
+        else:
+            I = np.arange(len(F))
+
+        # plot the data
+        self.ax.imshow(F[I], cmap=self.cmap, **self.axis_style)
+
+        # set the x ticks and labels
+        self.ax.set_xticks(np.arange(self.n_dim))
+        self.ax.set_xticklabels(self.get_labels())
+
+        # no solution labels should be used
+        if self.solution_labels is None:
+            pass
+
+        # if true, just use a number for each solution
+        elif isinstance(self.solution_labels, bool) and self.solution_labels:
+            self.solution_labels = np.arange(len(F)) + 1
+
+        # otherwise, use directly the label provided
+        else:
+            if len(self.solution_labels) != len(F):
+                raise Exception(
+                    "The labels provided for each solution must be equal to the number of solutions being plotted.")
+
+        if self.solution_labels is None:
+            self.ax.set_yticks([])
+            self.ax.set_yticklabels([])
+
+        else:
+
+            # for ordered by objective apply it to labels
+            self.solution_labels = [self.solution_labels[i] for i in I]
+
+            self.ax.set_yticks(np.arange(len(F)))
+            self.ax.set_yticklabels(self.solution_labels)
+
+
+parse_doc_string(Heatmap.__init__)

pymoo/visualization/pcp.py

@@ -0,0 +1,120 @@
+import numpy as np
+
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none, set_if_none_from_tuples
+from pymoo.visualization.util import parse_bounds, normalize
+
+
+class PCP(Plot):
+
+    def __init__(self,
+                 bounds=None,
+                 show_bounds=True,
+                 n_ticks=5,
+                 normalize_each_axis=True,
+                 bbox=False,
+                 **kwargs):
+        """
+
+        Parallel Coordinate Plot
+
+
+        Parameters
+        ----------------
+
+        bounds : {bounds}
+
+        axis_style : {axis_style}
+
+        labels : {labels}
+
+        n_ticks : int
+            Number of ticks to be shown on each parallel axis.
+
+        show_bounds : bool
+            Whether the value of the boundaries are shown in the plot or not.
+
+        normalize_each_axis : bool
+            Whether the values should be normalized either by bounds or implicitly.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(bounds=bounds, **kwargs)
+        self.show_bounds = show_bounds
+        self.n_ticks = n_ticks
+        self.bbox = bbox
+        self.normalize_each_axis = normalize_each_axis
+
+        set_if_none_from_tuples(self.axis_style, ("color", "red"), ("linewidth", 2), ("alpha", 0.75))
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # if no normalization of each axis the bounds are based on the overall min and max
+        if not self.normalize_each_axis and self.bounds is None:
+            _F = np.row_stack([e[0] for e in self.to_plot])
+            self.bounds = [_F.min(), _F.max()]
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm, bounds = normalize(self.to_plot, bounds, return_bounds=True)
+
+        # plot for each set the lines
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+
+            _kwargs = kwargs.copy()
+            set_if_none(_kwargs, "color", self.colors[k % len(self.colors)])
+
+            for i in range(len(F)):
+                self.ax.plot(np.arange(F.shape[1]), F[i, :], **_kwargs)
+
+        # Plot the parallel coordinate axes
+        for i in range(self.n_dim):
+            self.ax.axvline(i, **self.axis_style)
+
+            bottom, top = -0.1, 1.075
+            margin_left = 0.08
+
+            if self.show_bounds:
+                lower = self.ax.text(i - margin_left, bottom, self.func_number_to_text(bounds[0][i]))
+                upper = self.ax.text(i - margin_left, top, self.func_number_to_text(bounds[1][i]))
+
+                if self.bbox:
+                    lower.set_bbox(dict(facecolor='white', alpha=0.8))
+                    upper.set_bbox(dict(facecolor='white', alpha=0.8))
+
+            if self.n_ticks is not None:
+                n_length = 0.03
+                for y in np.linspace(0, 1, self.n_ticks):
+                    self.ax.hlines(y, i - n_length, i + n_length, **self.axis_style)
+
+        # if bounds are shown, then move them to the bottom
+        if self.show_bounds:
+            self.ax.tick_params(axis='x', which='major', pad=25)
+
+        self.ax.spines['right'].set_visible(False)
+        self.ax.spines['left'].set_visible(False)
+
+        self.ax.set_yticklabels([])
+        self.ax.set_yticks([])
+        self.ax.set_ylim((-0.05, 1.05))
+
+        self.ax.set_xticks(np.arange(self.n_dim))
+        self.ax.set_xticklabels(self.get_labels())
+
+        return self
+
+
+parse_doc_string(PCP.__init__)