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

pymoo/util/normalization.py

@@ -0,0 +1,312 @@
+import warnings
+from abc import abstractmethod
+
+import numpy as np
+
+# ---------------------------------------------------------------------------------------------------------
+# Object Oriented Interface
+# ---------------------------------------------------------------------------------------------------------
+
+# ---- Abstract Class
+from numpy.linalg import LinAlgError
+
+
+class Normalization:
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def forward(self, X):
+        pass
+
+    @abstractmethod
+    def backward(self, X):
+        pass
+
+
+# ---- Useful if normalization is optional - can be simply disabled by using this object
+class NoNormalization(Normalization):
+
+    def forward(self, X):
+        return X
+
+    def backward(self, X):
+        return X
+
+
+# ---- Normalizes between zero and one given bounds or estimating them
+class ZeroToOneNormalization(Normalization):
+
+    def __init__(self, xl=None, xu=None) -> None:
+        super().__init__()
+
+        # if both are None we are basically done because normalization is disabled
+        if xl is None and xu is None:
+            self.xl, self.xu = None, None
+            return
+
+        # if not set simply fall back no nan values
+        if xl is None:
+            xl = np.full_like(xu, np.nan)
+        if xu is None:
+            xu = np.full_like(xl, np.nan)
+
+        xl, xu = np.copy(xl).astype(float), np.copy(xu).astype(float)
+
+        # if both are equal then set the upper bound to none (always the 0 or lower bound will be returned then)
+        xu[xl == xu] = np.nan
+
+        # store the lower and upper bounds
+        self.xl, self.xu = xl, xu
+
+        # check out when the input values are nan
+        xl_nan, xu_nan = np.isnan(xl), np.isnan(xu)
+
+        # now create all the masks that are necessary
+        self.xl_only, self.xu_only = np.logical_and(~xl_nan, xu_nan), np.logical_and(xl_nan, ~xu_nan)
+        self.both_nan = np.logical_and(np.isnan(xl), np.isnan(xu))
+        self.neither_nan = np.logical_and(~np.isnan(xl), ~np.isnan(xu))
+
+        # if neither is nan than xu must be greater or equal than xl
+        any_nan = np.logical_or(np.isnan(xl), np.isnan(xu))
+        assert np.all(np.logical_or(xu >= xl, any_nan)), "xl must be less or equal than xu."
+
+    def forward(self, X):
+        if X is None or (self.xl is None and self.xu is None):
+            return X
+
+        # simple copy the input
+        N = np.copy(X)
+
+        # normalize between zero and one if neither of them is nan
+        N[...,  self.neither_nan] = (X[...,  self.neither_nan] - self.xl[self.neither_nan]) / (self.xu[self.neither_nan] - self.xl[self.neither_nan])
+
+        N[..., self.xl_only] = X[..., self.xl_only] - self.xl[self.xl_only]
+
+        N[..., self.xu_only] = 1.0 - (self.xu[self.xu_only] - X[..., self.xu_only])
+
+        return N
+
+    def backward(self, N):
+        if N is None or (self.xl is None and self.xu is None):
+            return N
+
+        xl, xu, xl_only, xu_only = self.xl, self.xu, self.xl_only, self.xu_only
+        both_nan, neither_nan = self.both_nan, self.neither_nan
+
+        X = N.copy()
+        X[..., neither_nan] = xl[neither_nan] + N[..., neither_nan] * (xu[neither_nan] - xl[neither_nan])
+
+        X[..., xl_only] = N[..., xl_only] + xl[xl_only]
+
+        X[..., xu_only] = xu[xu_only] - (1.0 - N[..., xu_only])
+
+        return X
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Simple Normalization
+# Does not consider any none values and assumes lower as well as upper bounds are given.
+# ---------------------------------------------------------------------------------------------------------
+
+
+class SimpleZeroToOneNormalization(Normalization):
+
+    def __init__(self, xl=None, xu=None, estimate_bounds=True) -> None:
+        super().__init__()
+        self.xl = xl
+        self.xu = xu
+        self.estimate_bounds = estimate_bounds
+
+    def forward(self, X):
+
+        if self.estimate_bounds:
+            if self.xl is None:
+                self.xl = np.min(X, axis=0)
+            if self.xu is None:
+                self.xu = np.max(X, axis=0)
+
+        xl, xu = self.xl, self.xu
+
+        # if np.any(xl == xu):
+        #     raise Exception("Normalization failed because lower and upper bounds are equal!")
+
+        # calculate the denominator
+        denom = xu - xl
+
+        # we can not divide by zero -> plus small epsilon
+        denom += (denom == 0) * 1e-32
+
+        # normalize the actual values
+        N = (X - xl) / denom
+
+        return N
+
+    def backward(self, X):
+        return X * (self.xu - self.xl) + self.xl
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Functional Interface
+# ---------------------------------------------------------------------------------------------------------
+
+
+def normalize(X, xl=None, xu=None, return_bounds=False, estimate_bounds_if_none=True):
+    if estimate_bounds_if_none:
+        if xl is None:
+            xl = np.min(X, axis=0)
+        if xu is None:
+            xu = np.max(X, axis=0)
+
+    if isinstance(xl, float) or isinstance(xl, int):
+        xl = np.full(X.shape[-1], xl)
+
+    if isinstance(xu, float) or isinstance(xu, int):
+        xu = np.full(X.shape[-1], xu)
+
+    norm = ZeroToOneNormalization(xl, xu)
+    X = norm.forward(X)
+
+    if not return_bounds:
+        return X
+    else:
+        return X, norm.xl, norm.xu
+
+
+def denormalize(x, xl, xu):
+    return ZeroToOneNormalization(xl, xu).backward(x)
+
+
+def standardize(x, return_bounds=False):
+    mean = np.mean(x, axis=0)
+    std = np.std(x, axis=0)
+
+    # standardize
+    val = (x - mean) / std
+
+    if not return_bounds:
+        return val
+    else:
+        return val, mean, std
+
+
+def destandardize(x, mean, std):
+    return (x * std) + mean
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Pre Normalization
+# A class inheriting from it can use the in-built feature of normalizing
+# ---------------------------------------------------------------------------------------------------------
+
+
+class PreNormalization:
+
+    def __init__(self, zero_to_one=False, ideal=None, nadir=None, **kwargs):
+
+        # normalization related stuff if that should be performed beforehand
+        self.ideal, self.nadir = ideal, nadir
+
+        if zero_to_one:
+            assert self.ideal is not None and self.nadir is not None, "For normalization either provide pf or bounds!"
+
+            n_dim = len(self.ideal)
+            self.normalization = ZeroToOneNormalization(self.ideal, self.nadir)
+
+            # now the ideal and nadir points have change to only zeros and ones
+            self.ideal, self.nadir = np.zeros(n_dim), np.ones(n_dim)
+
+        else:
+            self.normalization = NoNormalization()
+
+    def do(self, *args, **kwargs):
+        pass
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Normalization in the Objective Space
+# ---------------------------------------------------------------------------------------------------------
+
+
+def find_ideal(F, current=None):
+    p = F.min(axis=0)
+    if current is not None:
+        p = np.minimum(current, p)
+    return p
+
+
+def get_extreme_points_c(F, ideal_point, extreme_points=None):
+    # calculate the asf which is used for the extreme point decomposition
+    weights = np.eye(F.shape[1])
+    weights[weights == 0] = 1e6
+
+    # add the old extreme points to never loose them for normalization
+    _F = F
+    if extreme_points is not None:
+        _F = np.concatenate([extreme_points, _F], axis=0)
+
+    # use __F because we substitute small values to be 0
+    __F = _F - ideal_point
+    __F[__F < 1e-3] = 0
+
+    # update the extreme points for the normalization having the highest asf value each
+    F_asf = np.max(__F * weights[:, None, :], axis=2)
+
+    I = np.argmin(F_asf, axis=1)
+    extreme_points = _F[I, :]
+
+    return extreme_points
+
+
+def get_nadir_point(extreme_points, ideal_point, worst_point, worst_of_front, worst_of_population):
+    try:
+
+        # find the intercepts using gaussian elimination
+        M = extreme_points - ideal_point
+        b = np.ones(extreme_points.shape[1])
+        plane = np.linalg.solve(M, b)
+
+        warnings.simplefilter("ignore")
+        intercepts = 1 / plane
+
+        nadir_point = ideal_point + intercepts
+
+        # check if the hyperplane makes sense
+        if not np.allclose(np.dot(M, plane), b) or np.any(intercepts <= 1e-6):
+            raise LinAlgError()
+
+        # if the nadir point should be larger than any value discovered so far set it to that value
+        # NOTE: different to the proposed version in the paper
+        b = nadir_point > worst_point
+        nadir_point[b] = worst_point[b]
+
+    except LinAlgError:
+
+        # fall back to worst of front otherwise
+        nadir_point = worst_of_front
+
+    # if the range is too small set it to worst of population
+    b = nadir_point - ideal_point <= 1e-6
+    nadir_point[b] = worst_of_population[b]
+
+    return nadir_point
+
+
+class ObjectiveSpaceNormalization:
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._ideal = None
+        self._infeas_ideal = None
+        self._worst = None
+
+    def update(self, pop):
+        F, feas = pop.get("F", "FEAS")
+        self._infeas_ideal = find_ideal(F, current=self._infeas_ideal)
+
+        if np.any(feas):
+            self._ideal = find_ideal(F[feas[:, 0]], self._ideal)
+
+    def ideal(self, only_feas=True):
+        return self._ideal if only_feas else self._infeas_ideal

pymoo/util/optimum.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+
+
+def filter_optimum(pop, least_infeasible=False):
+
+    # if the population is none to optimum can be found
+    if pop is None or len(pop) == 0:
+        return None
+
+    # first only choose feasible solutions
+    ret = pop[pop.get("feas")]
+
+    # if at least one feasible solution was found
+    if len(ret) > 0:
+
+        # then check the objective values
+        F = ret.get("F")
+
+        if F.shape[1] > 1:
+            I = NonDominatedSorting().do(F, only_non_dominated_front=True)
+            ret = ret[I]
+
+        else:
+            ret = ret[np.argmin(F[:, 0])]
+
+    # no feasible solution was found
+    else:
+        # if flag enable report the least infeasible
+        if least_infeasible:
+            ret = pop[np.argmin(pop.get("CV"))]
+        # otherwise just return none
+        else:
+            ret = None
+
+    if isinstance(ret, Individual):
+        ret = Population().create(ret)
+
+    return ret

pymoo/util/plotting.py

@@ -0,0 +1,177 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import animation
+
+
+def plot(*args, show=True, labels=None, no_fill=False, **kwargs):
+    F = 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:
+        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:
+        import matplotlib.pyplot as 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/util/pruning_cd.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+def calc_pcd(X, n_remove=0):
+
+    N = X.shape[0]
+    M = X.shape[1]
+
+    if n_remove <= (N - M):
+        if n_remove < 0:
+            n_remove = 0
+        else:
+            pass
+    else:
+        n_remove = N - M
+
+    extremes_min = np.argmin(X, axis=0)
+    extremes_max = np.argmax(X, axis=0)
+    
+    min_vals = np.min(X, axis=0)
+    max_vals = np.max(X, axis=0)
+
+    extremes = np.concatenate((extremes_min, extremes_max))
+    
+    X = (X - min_vals) / (max_vals - min_vals)
+    
+    H = np.arange(N)
+    d = np.full(N, np.inf)
+    
+    I = np.argsort(X, axis=0, kind='mergesort')
+
+    # sort the objective space values for the whole matrix
+    _X = X[I, np.arange(M)]
+
+    # calculate the distance from each point to the last and next
+    dist = np.row_stack([_X, np.full(M, np.inf)]) - np.row_stack([np.full(M, -np.inf), _X])
+
+    # prepare the distance to last and next vectors
+    dist_to_last, dist_to_next = dist, np.copy(dist)
+    dist_to_last, dist_to_next = dist_to_last[:-1], dist_to_next[1:]
+
+    # if we divide by zero because all values in one columns are equal replace by none
+    dist_to_last[np.isnan(dist_to_last)] = 0.0
+    dist_to_next[np.isnan(dist_to_next)] = 0.0
+
+    # sum up the distance to next and last and norm by objectives - also reorder from sorted list
+    J = np.argsort(I, axis=0)
+    _d = np.sum(dist_to_last[J, np.arange(M)] + dist_to_next[J, np.arange(M)], axis=1)
+    d[H] = _d
+    d[extremes] = np.inf
+    
+    n_removed = 0
+
+    #While n_remove not acheived
+    while n_removed < (n_remove - 1):
+
+        #Obtain element to drop
+        _d = d[H]
+        _k = np.argmin(_d)
+        k = H[_k]
+        
+        H = H[H != k]
+        
+        #Update index
+        n_removed = n_removed + 1
+
+        I = np.argsort(X[H].copy(), axis=0, kind='mergesort')
+
+        # sort the objective space values for the whole matrix
+        _X = X[H].copy()[I, np.arange(M)]
+
+        # calculate the distance from each point to the last and next
+        dist = np.row_stack([_X, np.full(M, np.inf)]) - np.row_stack([np.full(M, -np.inf), _X])
+
+        # prepare the distance to last and next vectors
+        dist_to_last, dist_to_next = dist, np.copy(dist)
+        dist_to_last, dist_to_next = dist_to_last[:-1], dist_to_next[1:]
+
+        # if we divide by zero because all values in one columns are equal replace by none
+        dist_to_last[np.isnan(dist_to_last)] = 0.0
+        dist_to_next[np.isnan(dist_to_next)] = 0.0
+
+        # sum up the distance to next and last and norm by objectives - also reorder from sorted list
+        J = np.argsort(I, axis=0)
+        _d = np.sum(dist_to_last[J, np.arange(M)] + dist_to_next[J, np.arange(M)], axis=1)
+        d[H] = _d
+        d[extremes] = np.inf
+    
+    return d
+

pymoo/util/randomized_argsort.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+from pymoo.util.misc import swap
+
+
+def randomized_argsort(A, method="numpy", order='ascending'):
+    if method == "numpy":
+        P = np.random.permutation(len(A))
+        I = np.argsort(A[P], kind='quicksort')
+        I = P[I]
+
+    elif method == "quicksort":
+        I = quicksort(A)
+
+    else:
+        raise Exception("Randomized sort method not known.")
+
+    if order == 'ascending':
+        return I
+    elif order == 'descending':
+        return np.flip(I, axis=0)
+    else:
+        raise Exception("Unknown sorting order: ascending or descending.")
+
+
+def quicksort(A):
+    I = np.arange(len(A))
+    _quicksort(A, I, 0, len(A) - 1)
+    return I
+
+
+def _quicksort(A, I, left, right):
+    if left < right:
+
+        index = np.random.randint(left, right + 1)
+        swap(I, right, index)
+
+        pivot = A[I[right]]
+
+        i = left - 1
+
+        for j in range(left, right):
+
+            if A[I[j]] <= pivot:
+                i += 1
+                swap(I, i, j)
+
+        index = i + 1
+        swap(I, right, index)
+
+        _quicksort(A, I, left, index - 1)
+        _quicksort(A, I, index + 1, right)
+
+
+if __name__ == '__main__':
+    a = np.array([5, 9, 10, 0, 0, 0, 100, -2])
+
+    for i in range(200):
+        I = randomized_argsort(a, method="numpy")
+        print(I)

pymoo/util/ref_dirs/__init__.py

@@ -0,0 +1,24 @@
+from pymoo.util.ref_dirs.energy import RieszEnergyReferenceDirectionFactory
+from pymoo.util.ref_dirs.energy_layer import LayerwiseRieszEnergyReferenceDirectionFactory
+from pymoo.util.ref_dirs.reduction import ReductionBasedReferenceDirectionFactory
+from pymoo.util.ref_dirs.incremental import IncrementalReferenceDirectionFactory
+from pymoo.util.reference_direction import MultiLayerReferenceDirectionFactory
+
+
+def get_reference_directions(name, *args, **kwargs):
+    from pymoo.util.reference_direction import UniformReferenceDirectionFactory
+
+    REF = {
+        "uniform": UniformReferenceDirectionFactory,
+        "das-dennis": UniformReferenceDirectionFactory,
+        "energy": RieszEnergyReferenceDirectionFactory,
+        "multi-layer": MultiLayerReferenceDirectionFactory,
+        "layer-energy": LayerwiseRieszEnergyReferenceDirectionFactory,
+        "reduction": ReductionBasedReferenceDirectionFactory,
+        "incremental": IncrementalReferenceDirectionFactory,
+    }
+
+    if name not in REF:
+        raise Exception("Reference directions factory not found.")
+
+    return REF[name](*args, **kwargs)()