pymoo 0.6.1.5.dev0__cp310-cp310-macosx_11_0_arm64.whl

pymoo/visualization/petal.py

@@ -0,0 +1,91 @@
+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
+from pymoo.visualization.util import get_circle_points, plot_axes_lines, \
+    plot_axis_labels, plot_circle, plot_polygon, parse_bounds, normalize, equal_axis, no_ticks
+
+
+class Petal(Plot):
+
+    def __init__(self,
+                 bounds=None,
+                 **kwargs):
+        """
+
+        Petal Diagram
+
+
+        Parameters
+        ----------------
+        bounds : tuple
+            The boundaries for each objective. Necessary to be provided for this plot!
+        axis_style : {axis_style}
+        reverse : bool
+            Default false. Otherwise, larger area means smaller value.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(bounds=bounds, **kwargs)
+
+        if bounds is None:
+            raise Exception("Boundaries must be provided for Petal Width. Otherwise, no trade-offs can be calculated.")
+
+        set_if_none(self.axis_style, "color", "black")
+        set_if_none(self.axis_style, "linewidth", 2)
+        set_if_none(self.axis_style, "alpha", 0.5)
+
+    def _plot(self, ax, F):
+
+        # equal axis length and no ticks
+        equal_axis(ax)
+        no_ticks(ax)
+
+        V = get_circle_points(len(F))
+
+        # sections to plot
+        sections = np.linspace(0, 2 * np.pi, self.n_dim + 1)
+
+        t = [(sections[i] + sections[i + 1]) / 2 for i in range(len(sections) - 1)]
+        endpoints = np.column_stack([np.cos(t), np.sin(t)])
+        plot_axis_labels(ax, endpoints, self.get_labels(), **self.axis_label_style)
+
+        center = np.zeros(2)
+
+        for i in range(len(sections) - 1):
+            t = np.linspace(sections[i], sections[i + 1], 100)
+            v = np.column_stack([np.cos(t), np.sin(t)])
+
+            P = np.row_stack([center, F[i] * v])
+            plot_polygon(ax, P, color=self.colors[i])
+
+        # draw the outer circle
+        plot_circle(ax, **self.axis_style)
+        plot_axes_lines(ax, V, **self.axis_style)
+
+    def _do(self):
+
+        n_rows = len(self.to_plot)
+        n_cols = max([len(e[0]) for e in self.to_plot])
+        self.init_figure(n_rows=n_rows, n_cols=n_cols, force_axes_as_matrix=True)
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds, reverse=self.reverse)
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+            for j, _F in enumerate(F):
+                self._plot(self.ax[k, j], _F)
+
+
+parse_doc_string(Petal.__init__)

pymoo/visualization/radar.py

@@ -0,0 +1,108 @@
+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_from_tuples
+from pymoo.visualization.util import plot_axes_lines, plot_axis_labels, plot_polygon, get_circle_points, \
+    plot_radar_line, equal_axis, no_ticks, parse_bounds, normalize
+
+
+class Radar(Plot):
+
+    def __init__(self,
+                 normalize_each_objective=True,
+                 n_partitions=3,
+                 point_style={},
+                 **kwargs):
+
+        """
+        Radar Plot
+
+        Parameters
+        ----------------
+        normalize_each_objective : bool
+            Whether each objective is normalized. Otherwise, the inner and outer bound is plotted.
+        point_style : dict
+            The style being used to visualize the points
+        n_partitions : int
+            Number of partitions to show in the radar.
+        reverse : {reverse}
+        axis_style : {axis_style}
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+        """
+
+        super().__init__(**kwargs)
+        self.normalize_each_objective = normalize_each_objective
+        self.n_partitions = n_partitions
+
+        self.point_style = point_style
+        set_if_none_from_tuples(self.point_style, ("s", 15))
+
+        set_if_none_from_tuples(self.axis_style, ("color", "black"), ("linewidth", 0.5), ("alpha", 0.75))
+
+    def _plot(self, ax, _F, inner, outer, kwargs):
+
+        set_if_none_from_tuples(kwargs, ("alpha", 0.5))
+
+        # equal axis length and no ticks
+        equal_axis(ax)
+        no_ticks(ax)
+
+        # draw the axis lines and labels
+        plot_axes_lines(ax, outer, extend_factor=1.0, **self.axis_style)
+        plot_axis_labels(ax, outer, self.get_labels(), margin=0.015, **self.axis_label_style)
+
+        # plot the outer radar line and the inner polygon
+        plot_radar_line(ax, outer, **self.axis_style)
+        plot_polygon(ax, inner)
+
+        # find the corresponding point
+        _F = inner + _F[:, None] * (outer - inner)
+
+        # plot the points and no polygon
+        ax.scatter(_F[:, 0], _F[:, 1], **self.point_style)
+        plot_polygon(ax, _F, **kwargs)
+
+    def _do(self):
+
+        if self.bounds is None:
+            raise Exception("The boundaries must be provided.")
+
+        _F = np.row_stack([e[0] for e in self.to_plot])
+        if np.any(_F < self.bounds[0]) or np.any(_F > self.bounds[1]):
+            raise Exception(
+                "Points out of the boundaries exist! Please make sure the boundaries are indeed boundaries.")
+
+        n_rows = len(self.to_plot)
+        n_cols = max([len(e[0]) for e in self.to_plot])
+        self.init_figure(n_rows=n_rows, n_cols=n_cols, force_axes_as_matrix=True)
+
+        # normalize the input
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds, reverse=self.reverse)
+
+        # get the endpoints of circle
+        V = get_circle_points(self.n_dim)
+
+        if self.normalize_each_objective:
+            inner = np.zeros((self.n_dim, 1)) * V
+            outer = np.ones((self.n_dim, 1)) * V
+        else:
+            inner = bounds[[0]].T * V
+            outer = (bounds[[1]].T * V) / bounds[1].max()
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+
+            for j, _F in enumerate(F):
+                self._plot(self.ax[k, j], _F, inner, outer, kwargs)
+
+
+parse_doc_string(Radar.__init__)

pymoo/visualization/radviz.py

@@ -0,0 +1,68 @@
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+from pymoo.util.misc import set_if_none_from_tuples
+from pymoo.visualization.util import plot_circle, plot_radar_line, plot_axis_labels, equal_axis, no_ticks, \
+    get_uniform_points_around_circle
+
+
+class Radviz(Plot):
+
+    def __init__(self, endpoint_style={}, **kwargs):
+        """
+
+        Radviz Plot
+
+        Parameters
+        ----------------
+
+        axis_style : {axis_style}
+        endpoint_style : dict
+            Endpoints are drawn at each extreme point of an objective. This style can be modified.
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+
+        super().__init__(**kwargs)
+
+        # set the default axis style
+        set_if_none_from_tuples(self.axis_style, ("color", "black"), ("linewidth", 1), ("alpha", 0.75))
+
+        self.endpoint_style = endpoint_style
+        set_if_none_from_tuples(self.endpoint_style, ("color", "black"), ("s", 70), ("alpha", 0.3))
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # equal axis length and no ticks
+        equal_axis(self.ax)
+        no_ticks(self.ax)
+
+        V = get_uniform_points_around_circle(self.n_dim)
+        plot_axis_labels(self.ax, V, self.get_labels(), **self.axis_label_style)
+
+        # draw the outer circle and radar lines
+        plot_circle(self.ax, **self.axis_style)
+        plot_radar_line(self.ax, V, **self.axis_style)
+
+        # draw the endpoints of each objective
+        if self.endpoint_style:
+            self.ax.scatter(V[:, 0], V[:, 1], **self.endpoint_style)
+
+        # plot all the points
+        for k, (F, kwargs) in enumerate(self.to_plot):
+            N = (F[..., None] * V).sum(axis=1) / F.sum(axis=1)[:, None]
+            self.ax.scatter(N[:, 0], N[:, 1], **kwargs)
+
+
+parse_doc_string(Radviz.__init__)

pymoo/visualization/scatter.py

@@ -0,0 +1,150 @@
+import numpy as np
+
+from pymoo.core.plot import Plot
+from pymoo.docs import parse_doc_string
+from pymoo.util.misc import set_if_none
+
+
+def plot_1d(sc):
+    sc.init_figure()
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F, np.zeros_like(F), **kwargs)
+        ax.set_xlabel(labels[0])
+
+
+def plot_2d(sc):
+    sc.init_figure()
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F[:, 0], F[:, 1], **kwargs)
+        ax.set_xlabel(labels[0])
+        ax.set_ylabel(labels[1])
+
+    return sc
+
+
+def plot_3d(sc, angle):
+    sc.init_figure(plot_3D=True)
+    labels = sc.get_labels()
+    ax = sc.ax
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+
+        # here alo `plot_trisurf` is allowed
+        func = getattr(ax, kwargs.pop("mode"))
+        func(F[:, 0], F[:, 1], F[:, 2], **kwargs)
+
+        ax.xaxis.pane.fill = False
+        ax.yaxis.pane.fill = False
+        ax.zaxis.pane.fill = False
+
+        ax.set_xlabel(labels[0])
+        ax.set_ylabel(labels[1])
+        ax.set_zlabel(labels[2])
+
+        if sc.angle is not None:
+            ax.view_init(*angle)
+
+
+def plot_pairwise(sc):
+    sc.init_figure(n_rows=sc.n_dim, n_cols=sc.n_dim)
+    labels = sc.get_labels()
+
+    for k, (F, kwargs) in enumerate(sc.to_plot):
+
+        assert F.shape[1] >= 2, "A pairwise sc plot needs at least two dimensions."
+        mode = kwargs.pop("mode")
+
+        for i in range(sc.n_dim):
+            for j in range(sc.n_dim):
+
+                ax = sc.ax[i, j]
+                func = getattr(ax, mode)
+
+                if i != j:
+                    func(F[:, i], F[:, j], **kwargs)
+                    ax.set_xlabel(labels[i])
+                    ax.set_ylabel(labels[j])
+                else:
+                    func(0, 0, s=1, color="white")
+                    ax.set_xticks([])
+                    ax.set_yticks([])
+                    ax.text(0, 0, labels[i], ha='center', va='center', fontsize=20)
+
+
+class Scatter(Plot):
+
+    def __init__(self,
+                 plot_3d=True,
+                 angle=(45, 45),
+                 **kwargs):
+        """
+
+        Scatter Plot
+
+        Parameters
+        ----------------
+
+        axis_style : {axis_style}
+        labels : {labels}
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+
+        """
+
+        super().__init__(**kwargs)
+        self.angle = angle
+        self.plot_3d = plot_3d
+
+    def _do(self):
+
+        # set some default values
+        to_plot = []
+        for k, (F, v) in enumerate(self.to_plot):
+            v = dict(v)
+            set_if_none(v, "color", self.colors[k % len(self.colors)])
+            set_if_none(v, "alpha", 1.0)
+
+            # this is added to have compatibility to an old version
+            # should be removed when the documentation is updated
+            if "plot_type" in v:
+                name = v.pop("plot_type")
+
+                if name == "line":
+                    name = "plot"
+                elif name == "surface":
+                    name = "plot_trisurf"
+
+                v["mode"] = name
+            set_if_none(v, "mode", "scatter")
+
+            to_plot.append([F, v])
+
+        self.to_plot = to_plot
+
+        if self.n_dim == 1:
+            plot_1d(self)
+        elif self.n_dim == 2:
+            plot_2d(self)
+        elif self.n_dim == 3 and self.plot_3d:
+            plot_3d(self, self.angle)
+        else:
+            plot_pairwise(self)
+
+        return self
+
+
+parse_doc_string(Scatter.__init__)

pymoo/visualization/star_coordinate.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+from pymoo.visualization.util import plot_axes_arrow, plot_axis_labels, equal_axis, no_ticks, parse_bounds, \
+    normalize, get_uniform_points_around_circle
+from pymoo.docs import parse_doc_string
+from pymoo.core.plot import Plot
+
+
+class StarCoordinate(Plot):
+
+    def __init__(self,
+                 axis_extension=1.03,
+                 **kwargs):
+        """
+
+        Star Coordinate Plot
+
+        Parameters
+        ----------------
+
+        axis_style : {axis_style}
+        labels : {labels}
+        endpoint_style : dict
+            Endpoints are drawn at each extreme point of an objective. This style can be modified.
+
+        Other Parameters
+        ----------------
+
+        figsize : {figsize}
+        title : {title}
+        legend : {legend}
+        tight_layout : {tight_layout}
+        cmap : {cmap}
+
+        """
+        super().__init__(**kwargs)
+
+        self.axis_extension = axis_extension
+
+        if "arrow_style" not in kwargs:
+            self.arrow_style = {
+                "head_width": 0.02,
+                "head_length": 0.01
+            }
+        else:
+            self.arrow_style = kwargs["arrow_style"]
+
+    def _do(self):
+
+        # initial a figure with a single plot
+        self.init_figure()
+
+        # equal axis length and no ticks
+        equal_axis(self.ax)
+        no_ticks(self.ax)
+
+        # determine the overall scale of points
+        _F = np.row_stack([e[0] for e in self.to_plot])
+        _min, _max = _F.min(axis=0), _F.max(axis=0)
+
+        V = get_uniform_points_around_circle(self.n_dim)
+
+        plot_axes_arrow(self.ax, V, extend_factor=self.axis_extension, **{**self.axis_style, **self.arrow_style})
+        plot_axis_labels(self.ax, V, self.get_labels(), **self.axis_label_style)
+
+        # normalize in range for this plot - here no implicit normalization as in radviz
+        bounds = parse_bounds(self.bounds, self.n_dim)
+        to_plot_norm = normalize(self.to_plot, bounds)
+
+        for k, (F, kwargs) in enumerate(to_plot_norm):
+            N = (F[..., None] * V).sum(axis=1)
+            self.ax.scatter(N[:, 0], N[:, 1], **kwargs)
+
+
+parse_doc_string(StarCoordinate.__init__)

pymoo/visualization/util.py

@@ -0,0 +1,123 @@
+import sys
+
+import numpy as np
+from matplotlib import patches
+from matplotlib.collections import PatchCollection
+
+
+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
+    ax.plot(P[:, 0], P[:, 1], **kwargs)
+
+
+def plot_radar_line(ax, x, **kwargs):
+    x = np.row_stack([x, x[0]])
+    ax.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:
+        ax.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.row_stack([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")
+

pymoo/visualization/video/callback_video.py

@@ -0,0 +1,82 @@
+import matplotlib.pyplot as 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()
+