pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/visualization/util.py

@@ -0,0 +1,296 @@
+import sys
+
+import numpy as np
+from pymoo.visualization.matplotlib import matplotlib, patches, PatchCollection, plt, animation
+
+
+def get_circle_points(n_points):
+    t = np.linspace(0, 2 * np.pi, n_points, endpoint=False)
+    return np.column_stack([np.cos(t), np.sin(t)])
+
+
+def default_number_to_text(val):
+    if val > 1e3:
+        return "{:.2e}".format(val)
+    else:
+        return "{:.2f}".format(val)
+
+
+def in_notebook():
+    return 'ipykernel' in sys.modules
+
+
+def get_uniform_points_around_circle(n):
+    t = 2 * np.pi * np.arange(n) / n
+    s = np.column_stack([np.cos(t), np.sin(t)])
+    return s
+
+
+def plot_circle(ax, center=0, radius=1, **kwargs):
+    P = get_circle_points(5000)
+    P = (P + center) * radius
+    plot(P[:, 0], P[:, 1], **kwargs)
+
+
+def plot_radar_line(ax, x, **kwargs):
+    x = np.vstack([x, x[0]])
+    plot(x[:, 0], x[:, 1], **kwargs)
+
+
+def plot_axes_arrow(ax, X, extend_factor=1.0, **kwargs):
+    for (x, y) in X:
+        ax.arrow(0, 0, x * extend_factor, y * extend_factor, **kwargs)
+
+
+def plot_axes_lines(ax, X, extend_factor=1.0, **kwargs):
+    for (x, y) in X:
+        plot([0, x * extend_factor], [0, y * extend_factor], **kwargs)
+
+
+def plot_polygon(ax, x, **kwargs):
+    ax.add_collection(PatchCollection([patches.Polygon(x, closed=True)], **kwargs))
+
+
+def plot_axis_labels(ax, endpoints, labels, margin=0.035, size='small', **kwargs):
+    for k in range(len(labels)):
+        xy = endpoints[k]
+
+        if xy[0] < 0.0:
+            x = xy[0] - margin
+            ha = "right"
+        else:
+            x = xy[0] + margin
+            ha = "left"
+
+        if xy[1] < 0.0:
+            y = xy[1] - margin
+            va = "top"
+        else:
+            y = xy[1] + margin
+            va = "bottom"
+
+        ax.text(x, y, labels[k], ha=ha, va=va, size=size, **kwargs)
+
+
+def equal_axis(ax):
+    ax.set_xlim([-1.1, 1.1])
+    ax.set_ylim([-1.1, 1.1])
+    ax.axis('equal')
+
+
+def no_ticks(ax):
+    ax.set_yticks([])
+    ax.set_xticks([])
+    ax.set_frame_on(False)
+
+
+def normalize(data, bounds, reverse=False, return_bounds=False):
+    from pymoo.util.normalization import normalize as _normalize
+
+    _F = np.vstack([e[0] for e in data])
+    if bounds is None:
+        bounds = (_F.min(axis=0), _F.max(axis=0))
+
+    to_plot = []
+    for k in range(len(data)):
+        F = _normalize(data[k][0], bounds[0], bounds[1])
+
+        if reverse:
+            F = 1 - F
+
+        to_plot.append([F, data[k][1]])
+
+    if return_bounds:
+        return to_plot, bounds
+    else:
+        return to_plot
+
+
+def parse_bounds(bounds, n_dim):
+    if bounds is not None:
+        bounds = np.array(bounds, dtype=float)
+        if bounds.ndim == 1:
+            bounds = bounds[None, :].repeat(n_dim, axis=0).T
+    return bounds
+
+
+def radviz_pandas(F):
+    import pandas as pd
+    df = pd.DataFrame([x for x in F], columns=["X%s" % k for k in range(F.shape[1])])
+    df["class"] = "Points"
+    return pd.plotting.radviz(df, "class")
+
+
+def plot(*args, show=True, labels=None, no_fill=False, **kwargs):
+    import numpy as np
+    F = np.array(args[0])
+
+    if F.ndim == 1:
+        print("Cannot plot a one dimensional array.")
+        return
+
+    n_dim = F.shape[1]
+
+    if n_dim == 2:
+        ret = plot_2d(*args, labels=labels, no_fill=no_fill, **kwargs)
+    elif n_dim == 3:
+        ret = plot_3d(*args, labels=labels, no_fill=no_fill, **kwargs)
+    else:
+        print("Cannot plot a %s dimensional array." % n_dim)
+        return
+
+    if labels:
+        plt.legend()
+
+    if show and matplotlib.get_backend().lower() != "agg":
+        plt.show()
+
+    return ret
+
+
+def plot_3d(*args, no_fill=False, labels=None, **kwargs):
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+
+    for i, F in enumerate(args):
+
+        if no_fill:
+            kwargs["s"] = 20
+            kwargs["marker"] = '.'
+            kwargs["facecolors"] = (0, 0, 0, 0)
+            kwargs["edgecolors"] = 'r'
+
+        if labels:
+            ax.scatter(F[:, 0], F[:, 1], F[:, 2], label=labels[i], **kwargs)
+        else:
+            ax.scatter(F[:, 0], F[:, 1], F[:, 2], **kwargs)
+
+    return ax
+
+
+def plot_2d(*args, labels=None, no_fill=False):
+    if no_fill:
+        kwargs = dict(
+            s=20,
+            facecolors='none',
+            edgecolors='r'
+        )
+    else:
+        kwargs = {}
+
+    for i, F in enumerate(args):
+        if labels:
+            plt.scatter(F[:, 0], F[:, 1], label=labels[i], **kwargs)
+        else:
+            plt.scatter(F[:, 0], F[:, 1], **kwargs)
+
+
+def animate(path_to_file, H, problem=None, func_iter=None, plot_min=None, plot_max=None):
+    if H.ndim != 3 or H.shape[2] != 2:
+        print("Can only animate a two dimensional set of arrays.")
+        return
+
+    fig = plt.figure()
+    ax = plt.gca()
+
+    # plot the pareto front if it is known for the problem
+    if problem is not None:
+        pf = problem.pareto_front()
+        plt.scatter(pf[:, 0], pf[:, 1], label='Pareto Front', s=60, facecolors='none', edgecolors='r')
+
+    # plot the initial population
+    _F = H[0, :, :]
+    scat = plt.scatter(_F[:, 0], _F[:, 1])
+    plt.title("0")
+
+    if func_iter is not None:
+        func_iter(ax, H[0])
+
+    # the update method
+    def update(n):
+        _F = H[n, :, :]
+        scat.set_offsets(_F)
+
+        # get the bounds for plotting and add padding
+        min = np.min(_F, axis=0) - 0.1
+        max = np.max(_F, axis=0) + 0.1
+
+        # set the scatter object with padding
+        ax.set_xlim(min[0], max[0])
+        ax.set_ylim(min[1], max[1])
+
+        if func_iter is not None:
+            func_iter(ax, H[n])
+
+        plt.title(n)
+
+    # create the animation
+    ani = animation.FuncAnimation(fig, update, frames=H.shape[0])
+
+    # write the file
+    Writer = animation.writers['ffmpeg']
+    writer = Writer(fps=6, bitrate=1800)
+    ani.save(path_to_file, writer=writer)
+
+    print("Saving: ", path_to_file)
+
+
+def plot_problem_surface(problem, n_samples, plot_type="wireframe", cmap="summer", show=True, return_figure=False):
+    try:
+        from pymoo.visualization.matplotlib import plt
+        from mpl_toolkits.mplot3d import Axes3D
+    except:
+        raise Exception("Please install 'matplotlib' to use the plotting functionality.")
+
+    fig = plt.figure()
+
+    if problem.n_var == 1 and problem.n_obj == 1:
+
+        X = np.linspace(problem.xl[0], problem.xu[0], num=n_samples)[:, None]
+        Y = problem.evaluate(X, return_values_of=["F"])
+        ax = plt.plot(X, Y)
+
+    elif problem.n_var == 2 and problem.n_obj == 1:
+
+        X_range = np.linspace(problem.xl[0], problem.xu[0], num=n_samples)
+        Y_range = np.linspace(problem.xl[1], problem.xu[1], num=n_samples)
+        X, Y = np.meshgrid(X_range, Y_range)
+
+        A = np.zeros((n_samples * n_samples, 2))
+        counter = 0
+        for i, x in enumerate(X_range):
+            for j, y in enumerate(Y_range):
+                A[counter, 0] = x
+                A[counter, 1] = y
+                counter += 1
+
+        F = np.reshape(problem.evaluate(A, return_values_of=["F"]), (n_samples, n_samples))
+
+        # Plot the surface.
+        if plot_type == "wireframe":
+            ax = fig.add_subplot(111, projection='3d')
+            ax.plot_wireframe(X, Y, F)
+        elif plot_type == "contour":
+            CS = plt.contour(X, Y, F)
+            plt.clabel(CS, inline=1, fontsize=10)
+        elif plot_type == "wireframe+contour":
+            ax = fig.add_subplot(111, projection="3d")
+            ax.plot_surface(X, Y, F, cmap=cmap, rstride=1, cstride=1)
+            ax.contour(X, Y, F, 10, linestyles="solid", offset=-1)
+            ax.set_xlabel("$x_1$")
+            ax.set_ylabel("$x_2$")
+            ax.set_zlabel("$f(x)$")
+            ax.view_init(45, 45)
+        else:
+            raise Exception("Unknown plotting method.")
+
+
+    else:
+        raise Exception("Can only plot single with less than two variables and one objective.")
+
+    if show:
+        plt.tight_layout()
+        plt.show()
+
+    if return_figure:
+        return fig, ax

pymoo/visualization/video/callback_video.py

@@ -0,0 +1,82 @@
+from pymoo.visualization.matplotlib import plt
+
+from pymoo.core.callback import Callback
+from pymoo.visualization.scatter import Scatter
+
+
+class AnimationCallback(Callback):
+
+    def __init__(self,
+                 do_show=False,
+                 do_close=True,
+                 nth_gen=1,
+                 dpi=None,
+                 recorder=None,
+                 fname=None,
+                 exception_if_not_applicable=True):
+
+        super().__init__()
+        self.nth_gen = nth_gen
+        self.do_show = do_show
+        self.do_close = do_close
+        self.exception_if_not_applicable = exception_if_not_applicable
+
+        self.recorder = recorder
+        if self.recorder is None and fname is not None:
+            try:
+                from pyrecorder.recorder import Recorder
+                from pyrecorder.writers.video import Video
+                from pyrecorder.converters.matplotlib import Matplotlib
+                self.recorder = Recorder(Video(fname), converter=Matplotlib(dpi=dpi))
+            except:
+                raise Exception("Please install or update pyrecorder for animation support: pip install -U pyrecorder")
+
+    def update(self, algorithm):
+        if algorithm.n_gen == 1 or algorithm.n_gen % self.nth_gen == 0:
+            try:
+
+                figure = self.do(algorithm.problem, algorithm)
+
+                if self.do_show:
+                    if figure is not None:
+                        figure.show()
+                    else:
+                        plt.show()
+
+                if self.recorder is not None:
+                    self.recorder.record(fig=figure)
+
+                if self.do_close:
+                    plt.close(fig=figure)
+
+                return figure
+
+            except Exception as ex:
+                if self.exception_if_not_applicable:
+                    raise ex
+
+    def do(self, problem, algorithm, **kwargs):
+        pass
+
+
+class ObjectiveSpaceAnimation(AnimationCallback):
+
+    def __init__(self, recorder=None, **kwargs):
+        if recorder is None:
+            from pyrecorder.recorder import Recorder
+            from pyrecorder.writers.streamer import Streamer
+            recorder = Recorder(Streamer())
+        super().__init__(recorder=recorder, **kwargs)
+
+    def update(self, algorithm):
+        F = algorithm.opt.get("F")
+        pf = algorithm.problem.pareto_front()
+
+        sc = Scatter()
+        sc.add(F)
+        if pf is not None:
+            sc.add(pf, plot_type="line", color="black", alpha=0.7)
+        sc.do()
+
+        self.recorder.record()
+

pymoo/visualization/video/one_var_one_obj.py

@@ -0,0 +1,57 @@
+from pymoo.visualization.matplotlib import plt
+import numpy as np
+
+from pymoo.visualization.video.callback_video import AnimationCallback
+
+
+class OneVariableOneObjectiveVisualization(AnimationCallback):
+
+    def __init__(self,
+                 n_samples_for_surface=10000,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.last_pop = None
+        self.n_samples_for_surface = n_samples_for_surface
+
+    def do(self, problem, algorithm):
+
+        # check whether the visualization can be done or not - throw exception or simply do nothing
+        if problem.n_var != 1 or problem.n_obj != 1:
+            raise Exception("This visualization can only be used for problems with one variable and one objective!")
+
+        # draw the problem surface
+        xl, xu = problem.bounds()
+        _X = np.linspace(xl, xu, self.n_samples_for_surface)
+        _F = problem.evaluate(_X)
+        plt.plot(_X, _F, label="True", color="black", alpha=0.6)
+        plt.ylim(xl[0], xu[0])
+        plt.ylim(_F.min(), _F.max())
+
+        pop = algorithm.pop
+
+        X, F, CV = pop.get("X", "F", "CV")
+        plt.scatter(X[:, 0], F[:, 0], color="blue", marker="o", s=70)
+
+        is_new = np.full(len(pop), True)
+        if self.last_pop is not None:
+            for k, ind in enumerate(pop):
+                if ind in self.last_pop:
+                    is_new[k] = False
+
+        # plot the new population
+        if is_new.sum() > 0:
+            X, F, CV = pop[is_new].get("X", "F", "CV")
+            plt.scatter(X[:, 0], F[:, 0], color="red", marker="*", s=70)
+
+        if hasattr(algorithm, "off") and algorithm.off is not None:
+            X, F, CV = algorithm.off.get("X", "F", "CV")
+            plt.scatter(X[:, 0], F[:, 0], color="purple", marker="*", s=40)
+
+        plt.title(f"Generation: {algorithm.n_gen}")
+        plt.legend()
+
+        # store the current population as the last
+        self.last_pop = set(pop)
+
+
+

pymoo/visualization/video/two_var_one_obj.py

@@ -0,0 +1,62 @@
+from pymoo.visualization.matplotlib import plt
+import numpy as np
+
+from pymoo.visualization.fitness_landscape import FitnessLandscape
+from pymoo.visualization.video.callback_video import AnimationCallback
+
+
+class TwoVariablesOneObjectiveVisualization(AnimationCallback):
+
+    def __init__(self,
+                 n_samples_for_surface=10000,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.last_pop = None
+        self.n_samples_for_surface = n_samples_for_surface
+
+    def do(self, problem, algorithm):
+
+        # check whether the visualization can be done or not - throw exception or simply do nothing
+        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
+        # if algorithm.surrogate.targets["F"].doe is not None:
+        #     problem = algorithm.surrogate
+        plot = FitnessLandscape(problem, _type="contour", kwargs_contour=dict(alpha=0.5))
+        plot.do()
+
+        # get the population
+        pop = algorithm.pop
+
+        X, F, CV = pop.get("X", "F", "CV")
+        plt.scatter(X[:, 0], X[:, 1], facecolor="none", edgecolors="black", marker="o", s=50, label="Solutions")
+
+        if hasattr(algorithm, "off") and algorithm.off is not None:
+            X, F, CV = algorithm.off.get("X", "F", "CV")
+            plt.scatter(X[:, 0], X[:, 1], color="green", marker="D", s=30, label="Offsprings")
+
+        is_new = np.full(len(pop), True)
+        if self.last_pop is not None:
+            for k, ind in enumerate(pop):
+                if ind in self.last_pop:
+                    is_new[k] = False
+
+        # plot the new population
+        if is_new.sum() > 0:
+            X, F, CV = pop[is_new].get("X", "F", "CV")
+            plt.scatter(X[:, 0], X[:, 1], color="red", marker="*", s=70, label="Survivors")
+
+        xl, xu = problem.bounds()
+        plt.xlim(xl[0], xu[0])
+        plt.ylim(xl[1], xu[1])
+
+        plt.title(f"Generation: {algorithm.n_gen}")
+        plt.legend()
+
+        # store the current population as the last
+        self.last_pop = set(pop)
+
+        plt.show()
+
+        return plt.gcf()

pymoo-0.6.1.6.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: pymoo
+Version: 0.6.1.6
+Summary: Multi-Objective Optimization in Python
+Author-email: Julian Blank <blankjul@outlook.com>
+License-Expression: Apache-2.0
+Project-URL: homepage, https://pymoo.org
+Keywords: optimization
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.3
+Requires-Dist: scipy>=1.1
+Requires-Dist: moocore>=0.1.7
+Requires-Dist: autograd>=1.4
+Requires-Dist: cma>=3.2.2
+Requires-Dist: matplotlib>=3
+Requires-Dist: alive_progress
+Requires-Dist: Deprecated
+Provides-Extra: dev
+Requires-Dist: numba; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: nbformat; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: pyrecorder; extra == "dev"
+Requires-Dist: optproblems; extra == "dev"
+Requires-Dist: pandas; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: ipykernel; extra == "dev"
+Provides-Extra: parallelization
+Requires-Dist: joblib; extra == "parallelization"
+Requires-Dist: dask[distributed]; extra == "parallelization"
+Requires-Dist: ray[default]; extra == "parallelization"
+Provides-Extra: others
+Requires-Dist: optuna; extra == "others"
+Provides-Extra: full
+Requires-Dist: numba; extra == "full"
+Requires-Dist: scikit-learn; extra == "full"
+Requires-Dist: pandas; extra == "full"
+Requires-Dist: pymoo[parallelization]; extra == "full"
+Requires-Dist: pymoo[others]; extra == "full"
+Dynamic: license-file
+
+
+
+.. |python| image:: https://img.shields.io/badge/python-3.10-blue.svg
+   :alt: python 3.10
+
+.. |license| image:: https://img.shields.io/badge/license-apache-orange.svg
+   :alt: license apache
+   :target: https://www.apache.org/licenses/LICENSE-2.0
+
+
+.. |logo| image:: https://github.com/anyoptimization/pymoo-data/blob/main/logo.png?raw=true
+  :target: https://pymoo.org
+  :alt: pymoo
+
+
+.. |animation| image:: https://github.com/anyoptimization/pymoo-data/blob/main/animation.gif?raw=true
+  :target: https://pymoo.org
+  :alt: pymoo
+
+
+.. _Github: https://github.com/anyoptimization/pymoo
+.. _Documentation: https://www.pymoo.org/
+.. _Paper: https://ieeexplore.ieee.org/document/9078759
+
+
+
+
+|python| |license|
+
+
+|logo|
+
+
+
+Documentation_ / Paper_ / Installation_ / Usage_ / Citation_ / Contact_
+
+
+
+pymoo: Multi-objective Optimization in Python
+====================================================================
+
+Our open-source framework pymoo offers state of the art single- and multi-objective algorithms and many more features
+related to multi-objective optimization such as visualization and decision making.
+
+
+.. _Installation:
+
+Installation
+********************************************************************************
+
+First, make sure you have a Python 3 environment installed. We recommend miniconda3 or anaconda3.
+
+The official release is always available at PyPi:
+
+.. code:: bash
+
+    pip install -U pymoo
+
+
+For the current developer version:
+
+.. code:: bash
+
+    git clone https://github.com/anyoptimization/pymoo
+    cd pymoo
+    pip install .
+
+
+Since for speedup, some of the modules are also available compiled, you can double-check
+if the compilation worked. When executing the command, be sure not already being in the local pymoo
+directory because otherwise not the in site-packages installed version will be used.
+
+.. code:: bash
+
+    python -c "from pymoo.functions import is_compiled;print('Compiled Extensions: ', is_compiled())"
+
+
+.. _Usage:
+
+Usage
+********************************************************************************
+
+We refer here to our documentation for all the details.
+However, for instance, executing NSGA2:
+
+.. code:: python
+
+
+    from pymoo.algorithms.moo.nsga2 import NSGA2
+    from pymoo.problems import get_problem
+    from pymoo.optimize import minimize
+    from pymoo.visualization.scatter import Scatter
+
+    problem = get_problem("zdt1")
+
+    algorithm = NSGA2(pop_size=100)
+
+    res = minimize(problem,
+                   algorithm,
+                   ('n_gen', 200),
+                   seed=1,
+                   verbose=True)
+
+    plot = Scatter()
+    plot.add(problem.pareto_front(), plot_type="line", color="black", alpha=0.7)
+    plot.add(res.F, color="red")
+    plot.show()
+
+
+
+A representative run of NSGA2 looks as follows:
+
+|animation|
+
+
+
+.. _Citation:
+
+Citation
+********************************************************************************
+
+If you have used our framework for research purposes, you can cite our publication by:
+
+| `J. Blank and K. Deb, pymoo: Multi-Objective Optimization in Python, in IEEE Access, vol. 8, pp. 89497-89509, 2020, doi: 10.1109/ACCESS.2020.2990567 <https://ieeexplore.ieee.org/document/9078759>`_
+|
+| BibTex:
+
+::
+
+    @ARTICLE{pymoo,
+        author={J. {Blank} and K. {Deb}},
+        journal={IEEE Access},
+        title={pymoo: Multi-Objective Optimization in Python},
+        year={2020},
+        volume={8},
+        number={},
+        pages={89497-89509},
+    }
+
+.. _Contact:
+
+Contact
+********************************************************************************
+
+Feel free to contact me if you have any questions:
+
+| `Julian Blank <http://julianblank.com>`_  (blankjul [at] outlook.com)
+| Michigan State University
+| Computational Optimization and Innovation Laboratory (COIN)
+| East Lansing, MI 48824, USA
+
+
+