pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

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.6"

pymoo/visualization/__init__.py

@@ -0,0 +1,21 @@
+"""
+Visualization module for pymoo.
+
+All matplotlib functionality should be accessed through:
+    from pymoo.visualization.matplotlib import plt, patches, etc.
+
+This ensures proper handling when matplotlib is not available.
+"""
+
+# Import centralized matplotlib module
+from . import matplotlib
+
+__all__ = ["heatmap",
+           "pcp", 
+           "petal",
+           "radar",
+           "radviz",
+           "scatter",
+           "star_coordinate",
+           "matplotlib"
+           ]

pymoo/visualization/app/pso.py

@@ -0,0 +1,61 @@
+from pymoo.visualization.fitness_landscape import FitnessLandscape
+from pymoo.visualization.video.callback_video import AnimationCallback
+
+
+class PSOAnimation(AnimationCallback):
+
+    def __init__(self,
+                 nth_gen=1,
+                 n_samples_for_surface=200,
+                 dpi=200,
+                 **kwargs):
+
+        super().__init__(nth_gen=nth_gen, dpi=dpi, **kwargs)
+        self.n_samples_for_surface = n_samples_for_surface
+        self.last_pop = None
+
+    def do(self, problem, algorithm, **kwargs):
+        from pymoo.visualization.matplotlib import plt
+
+        if problem.n_var != 2 or problem.n_obj != 1:
+            raise Exception(
+                "This visualization can only be used for problems with two variables and one objective!")
+
+        # draw the problem surface
+        FitnessLandscape(problem,
+                         _type="contour",
+                         kwargs_contour=dict(alpha=0.3),
+                         n_samples=self.n_samples_for_surface,
+                         close_on_destroy=False).do()
+
+        # get the population
+        off = algorithm.particles
+        pop = algorithm.particles if self.last_pop is None else self.last_pop
+        pbest = algorithm.pop
+
+        for i in range(len(pop)):
+            plt.plot([off[i].X[0], pop[i].X[0]], [off[i].X[1], pop[i].X[1]], color="blue", alpha=0.5)
+            plt.plot([pbest[i].X[0], pop[i].X[0]], [pbest[i].X[1], pop[i].X[1]], color="red", alpha=0.5)
+            plt.plot([pbest[i].X[0], off[i].X[0]], [pbest[i].X[1], off[i].X[1]], color="red", alpha=0.5)
+
+        X, F, CV = pbest.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], edgecolors="red", marker="*", s=70, facecolors='none', label="pbest")
+
+        X, F, CV = off.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="blue", marker="o", s=30, label="particle")
+
+        X, F, CV = pop.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="blue", marker="o", s=30, alpha=0.5)
+
+        opt = algorithm.opt
+        X, F, CV = opt.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], color="black", marker="x", s=100, label="gbest")
+
+        xl, xu = problem.bounds()
+        plt.xlim(xl[0], xu[0])
+        plt.ylim(xl[1], xu[1])
+
+        plt.title(f"Generation: %s \nf: %.5E" % (algorithm.n_gen, opt[0].F[0]))
+        plt.legend()
+
+        self.last_pop = off.copy(deep=True)

pymoo/visualization/fitness_landscape.py

@@ -0,0 +1,128 @@
+import numpy as np
+
+import pymoo.visualization.util
+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"])
+            pymoo.visualization.util.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/matplotlib.py

@@ -0,0 +1,61 @@
+"""
+Centralized matplotlib imports for pymoo visualization.
+
+This module provides a single point of entry for all matplotlib functionality,
+with graceful handling when matplotlib is not available.
+"""
+
+# Try to import matplotlib and related modules
+try:
+    import matplotlib
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as patches
+    import matplotlib.colors as colors
+    import matplotlib.cm as cm
+    from matplotlib import animation
+    from matplotlib.collections import LineCollection, PatchCollection
+    from matplotlib.colors import ListedColormap
+
+    _MATPLOTLIB_AVAILABLE = True
+    
+    # Export all commonly used matplotlib objects
+    __all__ = [
+        'matplotlib', 'plt', 'patches', 'colors', 'cm', 'animation', 
+        'LineCollection', 'PatchCollection', 'ListedColormap', 'is_available'
+    ]
+    
+except ImportError:
+    _MATPLOTLIB_AVAILABLE = False
+    
+    class _MatplotlibNotAvailable:
+        """Helper class that raises informative errors when matplotlib is not available."""
+        
+        def __getattr__(self, name):
+            raise ImportError(
+                "Visualization features require matplotlib.\n"
+                "Install with: pip install pymoo[visualization]"
+            )
+        
+        def __call__(self, *args, **kwargs):
+            raise ImportError(
+                "Visualization features require matplotlib.\n"
+                "Install with: pip install pymoo[visualization]"
+            )
+    
+    # Create placeholder objects that give helpful errors
+    matplotlib = _MatplotlibNotAvailable()
+    plt = _MatplotlibNotAvailable()
+    patches = _MatplotlibNotAvailable()
+    colors = _MatplotlibNotAvailable()
+    cm = _MatplotlibNotAvailable()
+    animation = _MatplotlibNotAvailable()
+    LineCollection = _MatplotlibNotAvailable()
+    PatchCollection = _MatplotlibNotAvailable()
+    ListedColormap = _MatplotlibNotAvailable()
+
+
+def is_available():
+    """Check if matplotlib is available for visualization."""
+    return _MATPLOTLIB_AVAILABLE
+
+