pymoo 0.6.1.5.dev0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/core/plot.py

@@ -0,0 +1,210 @@
+import importlib
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import ListedColormap
+
+from pymoo.util.misc import set_if_none
+from pymoo.visualization.util import default_number_to_text, in_notebook
+
+
+class Plot:
+
+    def __init__(self,
+                 fig=None,
+                 ax=None,
+                 figsize=(8, 6),
+                 title=None,
+                 legend=False,
+                 tight_layout=False,
+                 bounds=None,
+                 reverse=False,
+                 cmap="tab10",
+                 axis_style=None,
+                 axis_label_style=None,
+                 func_number_to_text=default_number_to_text,
+                 labels="f",
+                 close_on_destroy=True,
+                 **kwargs):
+
+        super().__init__()
+
+        # change the font of plots to serif (looks better)
+        plt.rc('font', family='serif')
+
+        # the matplotlib classes
+        self.fig = fig
+        self.ax = ax
+        self.figsize = figsize
+
+        # whether the figure should be closed when object is destroyed
+        self.close_on_destroy = close_on_destroy
+
+        # the title of the figure - can also be a list if subfigures
+        self.title = title
+
+        # the style to be used for the axis
+        if axis_style is None:
+            self.axis_style = {}
+        else:
+            self.axis_style = axis_style.copy()
+
+        # the style of the axes
+        if axis_label_style is None:
+            self.axis_label_style = {}
+        else:
+            self.axis_label_style = axis_label_style.copy()
+
+        # how numbers are represented if plotted
+        self.func_number_to_text = func_number_to_text
+
+        # if data are normalized reverse can be applied
+        self.reverse = reverse
+
+        # the labels for each axis
+        self.axis_labels = labels
+
+        # the data to plot
+        self.to_plot = []
+
+        # whether to plot a legend or apply tight layout
+        self.legend = legend
+        self.tight_layout = tight_layout
+
+        # the colormap or the color lists to use
+        if isinstance(cmap, str):
+            self.cmap = matplotlib.pyplot.get_cmap(cmap)
+        else:
+            self.cmap = cmap
+        if isinstance(self.cmap, ListedColormap):
+            self.colors = self.cmap.colors
+
+        # the dimensionality of the data
+        self.n_dim = None
+
+        # the boundaries for normalization
+        self.bounds = bounds
+
+    def init_figure(self, n_rows=1, n_cols=1, plot_3D=False, force_axes_as_matrix=False):
+        if self.ax is not None:
+            return
+
+        if not plot_3D:
+            self.fig, self.ax = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=self.figsize)
+        else:
+            importlib.import_module("mpl_toolkits.mplot3d")
+            self.fig = plt.figure(figsize=self.figsize)
+            self.ax = self.fig.add_subplot(1, 1, 1, projection='3d')
+
+        # if there is more than one figure we represent it as a 2D numpy array
+        if (n_rows > 1 or n_cols > 1) or force_axes_as_matrix:
+            self.ax = np.array(self.ax).reshape(n_rows, n_cols)
+
+    def do(self):
+
+        if len(self.to_plot) > 0:
+            unique_dim = np.unique(np.array([e[0].shape[-1] for e in self.to_plot]))
+            if len(unique_dim) > 1:
+                raise Exception("Inputs with different dimensions were added: %s" % unique_dim)
+
+            self.n_dim = unique_dim[0]
+
+        # actually call the class
+        self._do()
+
+        # convert the axes to a list
+        axes = np.array(self.ax).flatten()
+
+        for i, ax in enumerate(axes):
+
+            legend, kwargs = get_parameter_with_options(self.legend)
+            if legend:
+                ax.legend(**kwargs)
+
+            title, kwargs = get_parameter_with_options(self.title)
+            if self.title:
+                if isinstance(self.title, list):
+                    ax.set_title(title[i], **kwargs)
+                else:
+                    ax.set_title(title, **kwargs)
+
+        if self.tight_layout:
+            self.fig.tight_layout()
+
+        return self
+
+    def apply(self, func):
+        func(self.ax)
+        return self
+
+    def get_plot(self):
+        return self.ax
+
+    def set_axis_style(self, **kwargs):
+        for key, val in kwargs.items():
+            self.axis_style[key] = val
+        return self
+
+    def reset(self):
+        self.fig = plt.figure(figsize=self.figsize)
+        self.ax = None
+        return self
+
+    def add(self, F, **kwargs):
+
+        if F is None:
+            return self
+        elif F.ndim == 1:
+            self.to_plot.append([F[None, :], kwargs])
+        elif F.ndim == 2:
+            self.to_plot.append([F, kwargs])
+        elif F.ndim == 3:
+            [self.to_plot.append([_F, kwargs.copy()]) for _F in F]
+
+        return self
+
+    def plot_if_not_done_yet(self):
+        if self.ax is None:
+            self.do()
+
+    def show(self, **kwargs):
+        self.plot_if_not_done_yet()
+
+        # in a notebook the plot method need not to be called explicitly
+        if not in_notebook() and matplotlib.get_backend() != "agg":
+            plt.show(**kwargs)
+            plt.close()
+
+        return self
+
+    def save(self, fname, **kwargs):
+        self.plot_if_not_done_yet()
+        set_if_none(kwargs, "bbox_inches", "tight")
+        self.fig.savefig(fname, **kwargs)
+        return self
+
+    def get_labels(self):
+        if isinstance(self.axis_labels, list):
+            if len(self.axis_labels) != self.n_dim:
+                raise Exception("Number of axes labels not equal to the number of axes.")
+            else:
+                return self.axis_labels
+        else:
+            return [f"${self.axis_labels}_{{{i}}}$" for i in range(1, self.n_dim + 1)]
+
+    def __del__(self):
+        if self.fig is not None and self.close_on_destroy:
+            plt.close(self.fig)
+
+
+def get_parameter_with_options(param):
+    if param is None:
+        return None, None
+    else:
+        if isinstance(param, tuple):
+            val, kwargs = param
+        else:
+            val, kwargs = param, {}
+
+        return val, kwargs

pymoo/core/population.py

@@ -0,0 +1,180 @@
+import numpy as np
+
+from pymoo.core.individual import Individual
+
+
+class Population(np.ndarray):
+
+    def __new__(cls, individuals=[]):
+        if isinstance(individuals, Individual):
+            individuals = [individuals]
+        return np.array(individuals).view(cls)
+
+    def has(self, key):
+        return all([ind.has(key) for ind in self])
+
+    def collect(self, func, to_numpy=True):
+        val = []
+        for i in range(len(self)):
+            val.append(func(self[i]))
+        if to_numpy:
+            val = np.array(val)
+        return val
+
+    def apply(self, func):
+        self.collect(func, to_numpy=False)
+
+    def set(self, *args, **kwargs):
+
+        # if population is empty just return
+        if self.size == 0:
+            return
+
+        # done for the old interface with the interleaving variable definition
+        kwargs = interleaving_args(*args, kwargs=kwargs)
+
+        # for each entry in the dictionary set it to each individual
+        for key, values in kwargs.items():
+            is_iterable = hasattr(values, '__len__') and not isinstance(values, str)
+
+            if is_iterable and len(values) != len(self):
+                raise Exception("Population Set Attribute Error: Number of values and population size do not match!")
+
+            for i in range(len(self)):
+                val = values[i] if is_iterable else values
+
+                # check for view and make copy to prevent memory leakage (#455)
+                if isinstance(val, np.ndarray) and not val.flags["OWNDATA"]:
+                    val = val.copy()
+
+                self[i].set(key, val)
+
+        return self
+
+    def get(self, *args, to_numpy=True, **kwargs):
+
+        val = {}
+        for c in args:
+            val[c] = []
+
+        # for each individual
+        for i in range(len(self)):
+
+            # for each argument
+            for c in args:
+                val[c].append(self[i].get(c, **kwargs))
+
+        # convert the results to a list
+        res = [val[c] for c in args]
+
+        # to numpy array if desired - default true
+        if to_numpy:
+            res = [np.array(e) for e in res]
+
+        # return as tuple or single value
+        if len(args) == 1:
+            return res[0]
+        else:
+            return tuple(res)
+
+    @classmethod
+    def merge(cls, a, b, *args):
+
+        # do the regular merge between first and second element
+        m = merge(a, b)
+
+        # process the list of others and merge as well
+        others = list(args)
+        while len(others) > 0:
+            m = merge(m, others.pop(0))
+
+        return m
+
+    @classmethod
+    def create(cls, *args):
+        return Population.__new__(cls, args)
+
+    @classmethod
+    def empty(cls, size=0):
+        individuals = [Individual() for _ in range(size)]
+        return Population.__new__(cls, individuals)
+
+    @classmethod
+    def new(cls, *args, **kwargs):
+        kwargs = interleaving_args(*args, kwargs=kwargs)
+
+        if len(kwargs) > 0:
+            sizes = np.unique(np.array([len(v) for _, v in kwargs.items()]))
+            if len(sizes) == 1:
+                size = sizes[0]
+            else:
+                raise Exception(f"Population.new needs to be called with same-sized inputs, but the sizes are {sizes}")
+        else:
+            size = 0
+
+        pop = Population.empty(size)
+        pop.set(**kwargs)
+
+        return pop
+
+
+def pop_from_array_or_individual(array, pop=None):
+    # the population type can be different - (different type of individuals)
+    if pop is None:
+        pop = Population.empty()
+
+    # provide a whole population object - (individuals might be already evaluated)
+    if isinstance(array, Population):
+        pop = array
+    elif isinstance(array, np.ndarray):
+        pop = pop.new("X", np.atleast_2d(array))
+    elif isinstance(array, Individual):
+        pop = Population.empty(1)
+        pop[0] = array
+    else:
+        return None
+
+    return pop
+
+
+def merge(a, b):
+    if a is None:
+        return b
+    elif b is None:
+        return a
+
+    a, b = pop_from_array_or_individual(a), pop_from_array_or_individual(b)
+
+    if len(a) == 0:
+        return b
+    elif len(b) == 0:
+        return a
+    else:
+        obj = np.concatenate([a, b]).view(Population)
+        return obj
+
+
+def interleaving_args(*args, kwargs=None):
+    if len(args) % 2 != 0:
+        raise Exception(f"Even number of arguments are required but {len(args)} arguments were provided.")
+
+    if kwargs is None:
+        kwargs = {}
+
+    for i in range(int(len(args) / 2)):
+        key, values = args[i * 2], args[i * 2 + 1]
+        kwargs[key] = values
+    return kwargs
+
+
+def calc_cv(pop, config=None):
+
+    if config is None:
+        config = Individual.default_config()
+
+    G, H = pop.get("G", "H")
+
+    from pymoo.core.individual import calc_cv as func
+    CV = np.array([func(g, h, config) for g, h in zip(G, H)])
+    
+    return CV