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

pymoo/util/nds/efficient_non_dominated_sort.py

@@ -0,0 +1,152 @@
+from math import floor
+
+import numpy as np
+
+from pymoo.util.dominator import Dominator
+
+
+def efficient_non_dominated_sort(F, strategy="sequential"):
+    """
+    Efficient Non-dominated Sorting (ENS)
+
+    Parameters
+    ----------
+    F: numpy.ndarray
+        objective values for each individual.
+    strategy: str
+        search strategy, can be "sequential" or "binary".
+
+    Returns
+    -------
+        fronts: list
+            Indices of the individuals in each front.
+
+    References
+    ----------
+    X. Zhang, Y. Tian, R. Cheng, and Y. Jin,
+    An efficient approach to nondominated sorting for evolutionary multiobjective optimization,
+    IEEE Transactions on Evolutionary Computation, 2015, 19(2): 201-213.
+    """
+
+    assert (strategy in ["sequential", 'binary']), "Invalid search strategy"
+
+    # the shape of the input
+    N, M = F.shape
+
+    # do a lexicographic ordering
+    I = np.lexsort(F.T[::-1])
+    F = F[I]
+
+    # front ranks for each individual
+    fronts = []
+
+    for i in range(N):
+
+        if strategy == 'sequential':
+            k = sequential_search(F, i, fronts)
+        else:
+            k = binary_search(F, i, fronts)
+
+        # create empty fronts if necessary
+        if k >= len(fronts):
+            fronts.append([])
+
+        # append the current individual to a front
+        fronts[k].append(i)
+
+    # now map the fronts back to the originally sorting
+    ret = []
+    for front in fronts:
+        ret.append(I[front])
+
+    return ret
+
+
+def sequential_search(F, i, fronts) -> int:
+    """
+    Find the front rank for the i-th individual through sequential search.
+
+    Parameters
+    ----------
+    F: np.ndarray
+        the objective values
+    i: int
+        the index of the individual
+    fronts: list
+        individuals in each front
+    """
+
+    num_found_fronts = len(fronts)
+    k = 0  # the front now checked
+    current = F[i]
+    while True:
+        if num_found_fronts == 0:
+            return 0
+        # solutions in the k-th front, examine in reverse order
+        fk_indices = fronts[k]
+        solutions = F[fk_indices[::-1]]
+        non_dominated = True
+        for f in solutions:
+            relation = Dominator.get_relation(current, f)
+            if relation == -1:
+                non_dominated = False
+                break
+        if non_dominated:
+            return k
+        else:
+            k += 1
+            if k >= num_found_fronts:
+                # move the individual to a new front
+                return num_found_fronts
+
+
+def binary_search(F, i, fronts):
+    """
+    Find the front rank for the i-th individual through binary search.
+
+    Parameters
+    ----------
+    F: np.ndarray
+        the objective values
+    i: int
+        the index of the individual
+    fronts: list
+        individuals in each front
+    """
+
+    num_found_fronts = len(fronts)
+    if num_found_fronts == 0:
+        return 0
+
+    k_min = 0  # the lower bound for checking
+    k_max = num_found_fronts  # the upper bound for checking
+    k = floor((k_max + k_min) / 2 + 0.5)  # the front now checked
+    current = F[i]
+    while True:
+
+        # solutions in the k-th front, examine in reverse order
+        fk_indices = fronts[k - 1]
+        solutions = F[fk_indices[::-1]]
+        non_dominated = True
+
+        for f in solutions:
+            relation = Dominator.get_relation(current, f)
+            if relation == -1:
+                non_dominated = False
+                break
+
+        # binary search
+        if non_dominated:
+            if k == k_min + 1:
+                return k - 1
+            else:
+                k_max = k
+                k = floor((k_max + k_min) / 2 + 0.5)
+        else:
+            k_min = k
+            if k_max == k_min + 1 and k_max < num_found_fronts:
+                return k_max - 1
+            elif k_min == num_found_fronts:
+                return num_found_fronts
+            else:
+                k = floor((k_max + k_min) / 2 + 0.5)

pymoo/util/nds/fast_non_dominated_sort.py

@@ -0,0 +1,70 @@
+import numpy as np
+
+from pymoo.util.dominator import Dominator
+
+
+def fast_non_dominated_sort(F, dominator=Dominator(), **kwargs):
+    if "dominator" in kwargs:
+        M = Dominator.calc_domination_matrix(F)
+    else:
+        M = dominator.calc_domination_matrix(F)
+
+    # calculate the dominance matrix
+    n = M.shape[0]
+
+    fronts = []
+
+    if n == 0:
+        return fronts
+
+    # final rank that will be returned
+    n_ranked = 0
+    ranked = np.zeros(n, dtype=int)
+
+    # for each individual a list of all individuals that are dominated by this one
+    is_dominating = [[] for _ in range(n)]
+
+    # storage for the number of solutions dominated this one
+    n_dominated = np.zeros(n)
+
+    current_front = []
+
+    for i in range(n):
+
+        for j in range(i + 1, n):
+            rel = M[i, j]
+            if rel == 1:
+                is_dominating[i].append(j)
+                n_dominated[j] += 1
+            elif rel == -1:
+                is_dominating[j].append(i)
+                n_dominated[i] += 1
+
+        if n_dominated[i] == 0:
+            current_front.append(i)
+            ranked[i] = 1.0
+            n_ranked += 1
+
+    # append the first front to the current front
+    fronts.append(current_front)
+
+    # while not all solutions are assigned to a pareto front
+    while n_ranked < n:
+
+        next_front = []
+
+        # for each individual in the current front
+        for i in current_front:
+
+            # all solutions that are dominated by this individuals
+            for j in is_dominating[i]:
+                n_dominated[j] -= 1
+                if n_dominated[j] == 0:
+                    next_front.append(j)
+                    ranked[j] = 1.0
+                    n_ranked += 1
+
+        fronts.append(next_front)
+        current_front = next_front
+
+    return fronts

pymoo/util/nds/naive_non_dominated_sort.py

@@ -0,0 +1,36 @@
+from pymoo.util.dominator import Dominator
+
+
+def naive_non_dominated_sort(F, **kwargs):
+    M = Dominator.calc_domination_matrix(F)
+
+    fronts = []
+    remaining = set(range(M.shape[0]))
+
+    while len(remaining) > 0:
+
+        front = []
+
+        for i in remaining:
+
+            is_dominated = False
+            dominating = set()
+
+            for j in front:
+                rel = M[i, j]
+                if rel == 1:
+                    dominating.add(j)
+                elif rel == -1:
+                    is_dominated = True
+                    break
+
+            if is_dominated:
+                continue
+            else:
+                front = [x for x in front if x not in dominating]
+                front.append(i)
+
+        [remaining.remove(e) for e in front]
+        fronts.append(front)
+
+    return fronts

pymoo/util/nds/non_dominated_sorting.py

@@ -0,0 +1,67 @@
+import numpy as np
+import sys
+from pymoo.util.dominator import Dominator
+from pymoo.util.function_loader import load_function
+
+
+class NonDominatedSorting:
+
+    def __init__(self, epsilon=None, method="fast_non_dominated_sort") -> None:
+        super().__init__()
+        self.epsilon = epsilon
+        self.method = method
+
+    def do(self, F, return_rank=False, only_non_dominated_front=False, n_stop_if_ranked=None, **kwargs):
+        F = F.astype(float)
+
+        # if not set just set it to a very large values because the cython algorithms do not take None
+        if n_stop_if_ranked is None:
+            n_stop_if_ranked = int(1e8)
+        func = load_function(self.method)
+
+        # set the epsilon if it should be set
+        if self.epsilon is not None:
+            kwargs["epsilon"] = float(self.epsilon)
+
+        fronts = func(F, **kwargs)
+
+        # convert to numpy array for each front and filter by n_stop_if_ranked if desired
+        _fronts = []
+        n_ranked = 0
+        for front in fronts:
+
+            _fronts.append(np.array(front, dtype=int))
+
+            # increment the n_ranked solution counter
+            n_ranked += len(front)
+
+            # stop if more than this solutions are n_ranked
+            if n_ranked >= n_stop_if_ranked:
+                break
+
+        fronts = _fronts
+
+        if only_non_dominated_front:
+            return fronts[0]
+
+        if return_rank:
+            rank = rank_from_fronts(fronts, F.shape[0])
+            return fronts, rank
+
+        return fronts
+
+
+def rank_from_fronts(fronts, n):
+    # create the rank array and set values
+    rank = np.full(n, sys.maxsize, dtype=int)
+    for i, front in enumerate(fronts):
+        rank[front] = i
+
+    return rank
+
+
+# Returns all indices of F that are not dominated by the other objective values
+def find_non_dominated(F, _F=None):
+    M = Dominator.calc_domination_matrix(F, _F)
+    I = np.where(np.all(M >= 0, axis=1))[0]
+    return I

pymoo/util/nds/tree_based_non_dominated_sort.py

@@ -0,0 +1,133 @@
+import weakref
+
+import numpy as np
+
+
+
+class Tree:
+    '''
+    Implementation of Nary-tree.
+    The source code is modified based on https://github.com/lianemeth/forest/blob/master/forest/NaryTree.py
+
+    Parameters
+    ----------
+    key: object
+        key of the node
+    num_branch: int
+        how many branches in each node
+    children: Iterable[Tree]
+        reference of the children
+    parent: Tree
+        reference of the parent node
+    Returns
+    -------
+        an N-ary tree.
+    '''
+
+    def __init__(self, key, num_branch, children=None, parent=None):
+        self.key = key
+        self.children = children or [None for _ in range(num_branch)]
+
+        self._parent = weakref.ref(parent) if parent else None
+
+    @property
+    def parent(self):
+        if self._parent:
+            return self._parent()
+
+    def __getstate__(self):
+        self._parent = None
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        for child in self.children:
+            child._parent = weakref.ref(self)
+
+    def traversal(self, visit=None, *args, **kwargs):
+        if visit is not None:
+            visit(self, *args, **kwargs)
+        l = [self]
+        for child in self.children:
+            if child is not None:
+                l += child.traversal(visit, *args, **kwargs)
+        return l
+
+
+def tree_based_non_dominated_sort(F):
+    """
+    Tree-based efficient non-dominated sorting (T-ENS).
+    This algorithm is very efficient in many-objective optimization problems (MaOPs).
+    Parameters
+    ----------
+    F: np.array
+        objective values for each individual.
+    Returns
+    -------
+        indices of the individuals in each front.
+    References
+    ----------
+    X. Zhang, Y. Tian, R. Cheng, and Y. Jin,
+    A decision variable clustering based evolutionary algorithm for large-scale many-objective optimization,
+    IEEE Transactions on Evolutionary Computation, 2018, 22(1): 97-112.
+    """
+
+    N, M = F.shape
+    # sort the rows in F
+    indices = np.lexsort(F.T[::-1])
+    F = F[indices]
+
+    obj_seq = np.argsort(F[:, :0:-1], axis=1) + 1
+
+    k = 0
+
+    forest = []
+
+    left = np.full(N, True)
+    while np.any(left):
+        forest.append(None)
+        for p, flag in enumerate(left):
+            if flag:
+                update_tree(F, p, forest, k, left, obj_seq)
+        k += 1
+
+    # convert forest to fronts
+    fronts = [[] for _ in range(k)]
+    for k, tree in enumerate(forest):
+        fronts[k].extend([indices[node.key] for node in tree.traversal()])
+    return fronts
+
+
+def update_tree(F, p, forest, k, left, obj_seq):
+    _, M = F.shape
+    if forest[k] is None:
+        forest[k] = Tree(key=p, num_branch=M - 1)
+        left[p] = False
+    elif check_tree(F, p, forest[k], obj_seq, True):
+        left[p] = False
+
+
+def check_tree(F, p, tree, obj_seq, add_pos):
+    if tree is None:
+        return True
+
+    N, M = F.shape
+
+    # find the minimal index m satisfying that p[obj_seq[tree.root][m]] < tree.root[obj_seq[tree.root][m]]
+    m = 0
+    while m < M - 1 and F[p, obj_seq[tree.key, m]] >= F[tree.key, obj_seq[tree.key, m]]:
+        m += 1
+
+    # if m not found
+    if m == M - 1:
+        # p is dominated by the solution at the root
+        return False
+    else:
+        for i in range(m + 1):
+            # p is dominated by a solution in the branch of the tree
+            if not check_tree(F, p, tree.children[i], obj_seq, i == m and add_pos):
+                return False
+
+        if tree.children[m] is None and add_pos:
+            # add p to the branch of the tree
+            tree.children[m] = Tree(key=p, num_branch=M - 1)
+        return True