pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/problems/many/cdtlz.py

@@ -0,0 +1,159 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.problems.many.dtlz import DTLZ1, DTLZ2, DTLZ3, DTLZ4, get_ref_dirs
+
+
+class C1DTLZ1(DTLZ1):
+
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=1, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        super()._evaluate(X, out, *args, **kwargs)
+        out["G"] = constraint_c1_linear(out["F"])
+
+    def _calc_pareto_front(self, ref_dirs=None, *args, **kwargs):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return super()._calc_pareto_front(ref_dirs, *args, **kwargs)
+
+
+class C1DTLZ3(DTLZ3):
+
+    def __init__(self, n_var=12, n_obj=3, r=None, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=1, **kwargs)
+
+        if r is None:
+            if self.n_obj < 5:
+                r = 9.0
+            elif 5 <= self.n_obj <= 12:
+                r = 12.5
+            else:
+                r = 15.0
+
+        self.r = r
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        super()._evaluate(X, out, *args, **kwargs)
+        out["G"] = constraint_c1_spherical(out["F"], self.r)
+
+    def _calc_pareto_front(self, ref_dirs=None, *args, **kwargs):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return super()._calc_pareto_front(ref_dirs, *args, **kwargs)
+
+
+class C2DTLZ2(DTLZ2):
+
+    def __init__(self, n_var=12, n_obj=3, r=None, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=1, **kwargs)
+
+        if r is None:
+            if n_obj == 2:
+                r = 0.2
+            elif n_obj == 3:
+                r = 0.4
+            else:
+                r = 0.5
+
+        self.r = r
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        super()._evaluate(X, out, *args, **kwargs)
+        out["G"] = constraint_c2(out["F"], self.r)
+
+    def _calc_pareto_front(self, ref_dirs=None, *args, **kwargs):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        F = super()._calc_pareto_front(ref_dirs, *args, **kwargs)
+        G = constraint_c2(F, r=self.r)
+        G[G <= 0] = 0
+        return F[G <= 0]
+
+
+class C3DTLZ1(DTLZ1):
+
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=n_obj, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        super()._evaluate(X, out, *args, **kwargs)
+        out["G"] = constraint_c3_linear(out["F"])
+
+
+class C3DTLZ4(DTLZ4):
+
+    def __init__(self, n_var=7, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=n_obj, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        super()._evaluate(X, out, *args, **kwargs)
+        out["G"] = constraint_c3_spherical(out["F"])
+
+    def _calc_pareto_front(self, ref_dirs=None, *args, **kwargs):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        F = super()._calc_pareto_front(ref_dirs, *args, **kwargs)
+        a = np.sqrt(np.sum(F ** 2, 1) - 3 / 4 * np.max(F ** 2, axis=1))
+        a = np.expand_dims(a, axis=1)
+        a = np.tile(a, [1, ref_dirs.shape[1]])
+        F = F / a
+
+        return F
+
+
+def constraint_c1_linear(f):
+    g = - (1 - f[:, -1] / 0.6 - anp.sum(f[:, :-1] / 0.5, axis=1))
+    return g
+
+
+def constraint_c1_spherical(f, r):
+    radius = anp.sum(f ** 2, axis=1)
+    g = - (radius - 16) * (radius - r ** 2)
+
+    return g
+
+
+def constraint_c2(f, r):
+    n_obj = f.shape[1]
+
+    v1 = anp.full(f.shape[0], anp.inf)
+
+    for i in range(n_obj):
+        temp = (f[:, i] - 1) ** 2 + (anp.sum(f ** 2, axis=1) - f[:, i] ** 2) - r ** 2
+        v1 = anp.minimum(temp.flatten(), v1)
+
+    a = 1 / anp.sqrt(n_obj)
+    v2 = anp.sum((f - a) ** 2, axis=1) - r ** 2
+    g = anp.minimum(v1, v2.flatten())
+
+    return g
+
+
+def constraint_c3_linear(f):  # M lines
+    n_obj = f.shape[1]
+    g = []
+
+    for i in range(n_obj):
+        _g = 1 - f[:, i] / 0.5 - (anp.sum(f, axis=1) - f[:, i])
+        g.append(_g)
+
+    return anp.column_stack(g)
+
+
+def constraint_c3_spherical(f):  # M ellipse
+    n_obj = f.shape[1]
+    g = []
+
+    for i in range(n_obj):
+        _g = 1 - f[:, i] ** 2 / 4 - (anp.sum(f ** 2, axis=1) - f[:, i] ** 2)
+        g.append(_g)
+    return anp.column_stack(g)
+
+
+def constraint_c4_cylindrical(f, r):  # cylindrical
+    l = anp.mean(f, axis=1)
+    l = anp.expand_dims(l, axis=1)
+    g = -anp.sum(anp.power(f - l, 2), axis=1) + anp.power(r, 2)
+    return g

pymoo/problems/many/dcdtlz.py

@@ -0,0 +1,88 @@
+import pymoo.gradient.toolbox as anp
+
+from pymoo.problems.many.dtlz import DTLZ1, DTLZ3
+
+
+def constraint_dc1(X, a=5, b=0.95):
+    G = b - anp.cos(a * anp.pi * X[:, 0])
+    return G
+
+
+def constraints_dc2(gx, a=3, b=0.9):
+    G = anp.column_stack([
+        b - anp.cos(gx / 100 * anp.pi * a),
+        b - anp.exp (-gx / 100)
+    ])
+    return G
+
+
+def constraints_dc3(X, gx, a=5, b=0.5):
+    Ggx = b - anp.cos(a * anp.pi * gx)
+    Gx = b - anp.cos(a * anp.pi * X)
+    return anp.column_stack([Ggx, Gx])
+
+
+class DC1DTLZ1(DTLZ1):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, **kwargs)
+        self.n_ieq_constr = 1
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        super()._evaluate(x, out, *args, **kwargs)
+        out["G"] = constraint_dc1(x)
+
+
+class DC1DTLZ3(DTLZ3):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, **kwargs)
+        self.n_ieq_constr = 1
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        super()._evaluate(x, out, *args, **kwargs)
+        out["G"] = constraint_dc1(x)
+
+
+class DC2DTLZ1(DTLZ1):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, **kwargs)
+        self.n_ieq_constr = 2
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g)
+        out["G"] = constraints_dc2(g)
+
+
+class DC2DTLZ3(DTLZ3):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, **kwargs)
+        self.n_ieq_constr = 2
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g, alpha=1)
+        out["G"] = constraints_dc2(g)
+
+
+class DC3DTLZ1(DTLZ1):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, n_ieq_constr=n_obj, **kwargs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g)
+        out["G"] = constraints_dc3(X_, g)
+
+
+class DC3DTLZ3(DTLZ3):
+    def __init__(self, n_var=12, n_obj=3, **kwargs):
+        super().__init__(n_var, n_obj, n_ieq_constr=n_obj, **kwargs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g, alpha=1)
+        out["G"] = constraints_dc3(X_, g)

pymoo/problems/many/dtlz.py

@@ -0,0 +1,264 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.reference_direction import UniformReferenceDirectionFactory
+from pymoo.util.remote import Remote
+
+
+class DTLZ(Problem):
+    def __init__(self, n_var, n_obj, k=None, **kwargs):
+
+        if n_var:
+            self.k = n_var - n_obj + 1
+        elif k:
+            self.k = k
+            n_var = k + n_obj - 1
+        else:
+            raise Exception("Either provide number of variables or k!")
+
+        super().__init__(n_var=n_var, n_obj=n_obj, xl=0, xu=1, vtype=float, **kwargs)
+
+    def g1(self, X_M):
+        return 100 * (self.k + anp.sum(anp.square(X_M - 0.5) - anp.cos(20 * anp.pi * (X_M - 0.5)), axis=1))
+
+    def g2(self, X_M):
+        return anp.sum(anp.square(X_M - 0.5), axis=1)
+
+    def obj_func(self, X_, g, alpha=1):
+        f = []
+
+        for i in range(0, self.n_obj):
+            _f = (1 + g)
+            _f *= anp.prod(anp.cos(anp.power(X_[:, :X_.shape[1] - i], alpha) * anp.pi / 2.0), axis=1)
+            if i > 0:
+                _f *= anp.sin(anp.power(X_[:, X_.shape[1] - i], alpha) * anp.pi / 2.0)
+
+            f.append(_f)
+
+        f = anp.column_stack(f)
+        return f
+
+
+class DTLZ1(DTLZ):
+    def __init__(self, n_var=7, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return 0.5 * ref_dirs
+
+    def obj_func(self, X_, g):
+        f = []
+
+        for i in range(0, self.n_obj):
+            _f = 0.5 * (1 + g)
+            _f *= anp.prod(X_[:, :X_.shape[1] - i], axis=1)
+            if i > 0:
+                _f *= 1 - X_[:, X_.shape[1] - i]
+            f.append(_f)
+
+        return anp.column_stack(f)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g)
+
+
+class DTLZ2(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return generic_sphere(ref_dirs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g2(X_M)
+        out["F"] = self.obj_func(X_, g, alpha=1)
+
+
+class DTLZ3(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return generic_sphere(ref_dirs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+        out["F"] = self.obj_func(X_, g, alpha=1)
+
+
+class DTLZ4(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, alpha=100, d=100, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+        self.alpha = alpha
+        self.d = d
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        return generic_sphere(ref_dirs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g2(X_M)
+        out["F"] = self.obj_func(X_, g, alpha=self.alpha)
+
+
+class DTLZ5(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self):
+        if self.n_obj == 3:
+            return Remote.get_instance().load("pymoo", "pf", "dtlz5-3d.pf")
+        else:
+            raise Exception("Not implemented yet.")
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g2(X_M)
+
+        theta = 1 / (2 * (1 + g[:, None])) * (1 + 2 * g[:, None] * X_)
+        theta = anp.column_stack([x[:, 0], theta[:, 1:]])
+
+        out["F"] = self.obj_func(theta, g)
+
+
+class DTLZ6(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self):
+        if self.n_obj == 3:
+            return Remote.get_instance().load("pymoo", "pf", "dtlz6-3d.pf")
+        else:
+            raise Exception("Not implemented yet.")
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = anp.sum(anp.power(X_M, 0.1), axis=1)
+
+        theta = 1 / (2 * (1 + g[:, None])) * (1 + 2 * g[:, None] * X_)
+        theta = anp.column_stack([x[:, 0], theta[:, 1:]])
+
+        out["F"] = self.obj_func(theta, g)
+
+
+class DTLZ7(DTLZ):
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(n_var=n_var, n_obj=n_obj, **kwargs)
+
+    def _calc_pareto_front(self):
+        if self.n_obj == 3:
+            return Remote.get_instance().load("pymoo", "pf", "dtlz7-3d.pf")
+        else:
+            raise Exception("Not implemented yet.")
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f = []
+        for i in range(0, self.n_obj - 1):
+            f.append(x[:, i])
+        f = anp.column_stack(f)
+
+        g = 1 + 9 / self.k * anp.sum(x[:, -self.k:], axis=1)
+        h = self.n_obj - anp.sum(f / (1 + g[:, None]) * (1 + anp.sin(3 * anp.pi * f)), axis=1)
+
+        out["F"] = anp.column_stack([f, (1 + g) * h])
+
+
+class InvertedDTLZ1(DTLZ1):
+
+    def _calc_pareto_front(self):
+        raise Exception("Not implemented yet.")
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        X_, X_M = x[:, :self.n_obj - 1], x[:, self.n_obj - 1:]
+        g = self.g1(X_M)
+
+        super()._evaluate(x, out, *args, **kwargs)
+        out["F"] = 0.5 * (1 + g[:, None]) - out["F"]
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return self.problem.pareto_front(*args, **kwargs)
+
+
+class ScaledProblem(Problem):
+
+    def __init__(self, problem, scale_factor):
+        super().__init__(n_var=problem.n_var, n_obj=problem.n_obj, n_ieq_constr=problem.n_ieq_constr,
+                         n_eq_constr=problem.n_eq_constr, xl=problem.xl, xu=problem.xu, vtype=problem.vtype)
+        self.problem = problem
+        self.scale_factor = scale_factor
+
+    @staticmethod
+    def get_scale(n, scale_factor):
+        return np.power(np.full(n, scale_factor), np.arange(n))
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        self.problem._evaluate(X, out, *args, **kwargs)
+        out["F"] = out["F"] * ScaledProblem.get_scale(self.n_obj, self.scale_factor)
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return self.problem.pareto_front(*args, **kwargs) * ScaledProblem.get_scale(self.n_obj, self.scale_factor)
+
+
+class ConvexProblem(Problem):
+
+    def __init__(self, problem):
+        super().__init__(problem.n_var, problem.n_obj, problem.n_ieq_constr, problem.n_eq_constr, problem.xl, problem.xu)
+        self.problem = problem
+
+    def get_power(self, n):
+        p = np.full(n, 4.0)
+        p[-1] = 2.0
+        return p
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        self.problem._evaluate(X, out, **kwargs)
+        out["F"] = anp.power(out["F"], self.get_power(self.n_obj))
+
+    def _calc_pareto_front(self, ref_dirs, *args, **kwargs):
+        F = self.problem.pareto_front(ref_dirs)
+        return np.power(F, self.get_power(self.n_obj))
+
+
+class ScaledDTLZ1(ScaledProblem):
+
+    def __init__(self, n_var=7, n_obj=3, scale_factor=10, **kwargs):
+        super().__init__(DTLZ1(n_var=n_var, n_obj=n_obj, **kwargs), scale_factor=scale_factor)
+
+
+class ConvexDTLZ2(ConvexProblem):
+
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(DTLZ2(n_var=n_var, n_obj=n_obj, **kwargs))
+
+
+class ConvexDTLZ4(ConvexProblem):
+
+    def __init__(self, n_var=10, n_obj=3, **kwargs):
+        super().__init__(DTLZ4(n_var=n_var, n_obj=n_obj, **kwargs))
+
+
+def generic_sphere(ref_dirs):
+    return ref_dirs / np.tile(np.linalg.norm(ref_dirs, axis=1)[:, None], (1, ref_dirs.shape[1]))
+
+
+def get_ref_dirs(n_obj):
+    if n_obj == 2:
+        ref_dirs = UniformReferenceDirectionFactory(2, n_points=100).do()
+    elif n_obj == 3:
+        ref_dirs = UniformReferenceDirectionFactory(3, n_partitions=15).do()
+    else:
+        raise Exception("Please provide reference directions for more than 3 objectives!")
+    return ref_dirs