Karush Kuhn Tucker Proximity Measure (KKTPM)

[rabiu42000]

Is it possible to calculate KKTPM for problems with no known Pareto-front? When I run my user-defined problem, I get this error
pymoo\indicators\kktpm.py", line 39, in calc
z -= utopian_eps
TypeError: unsupported operand type(s) for -=: 'NoneType' and 'float'
In calculating the ideal_points it requires the Pareto-front which is not known for my problem.

[blankjul]

For KKTPM you need the ideal point and also the derivatives. Please have a look at the original paper why this is the case.

[rabiu42000]

I followed the example for calculating KKTPM for a whole genetic algorithm run but am still getting the same error. Each evaluation has a derivative using the Evaluator class and the problem define with AutomaticDifferentiation

[blankjul]

Do you have an example to reproduce the error? Please paste below.

[rabiu42000]

import numpy as np
from pymoo.core.problem import ElementwiseProblem
from pymoo.problems.autodiff import AutomaticDifferentiation
from pymoo.problems.bounds_as_constr import BoundariesAsConstraints
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.factory import get_sampling, get_crossover, get_mutation
from pymoo.core.evaluator import Evaluator
from pymoo.factory import get_termination
from pymoo.optimize import minimize
from pymoo.indicators.kktpm import KKTPM
import matplotlib.pyplot as plt

class MyProblem(ElementwiseProblem):

def __init__(self):
    super().__init__(n_var=2,
                     n_obj=2,
                     n_constr=2,
                     xl=np.array([-2,-2]),
                     xu=np.array([2,2]))

def _evaluate(self, x, out, *args, **kwargs):
    f1 = 100 * (x[0]**2 + x[1]**2)
    f2 = (x[0]-1)**2 + x[1]**2

    g1 = 2*(x[0]-0.1) * (x[0]-0.9) / 0.18
    g2 = - 20*(x[0]-0.4) * (x[0]-0.6) / 4.8

    out["F"] = [f1, f2]
    out["G"] = [g1, g2]

problem = AutomaticDifferentiation(BoundariesAsConstraints(MyProblem()))

algorithm = NSGA2(
pop_size=40,
n_offsprings=10,
sampling=get_sampling("real_random"),
crossover=get_crossover("real_sbx", prob=0.9, eta=15),
mutation=get_mutation("real_pm", eta=20),
eliminate_duplicates=True
)

make sure each evaluation also has the derivatives - necessary for KKTPM

evaluator = Evaluator(evaluate_values_of=["F", "CV", "G", "dF", "dG"])

termination = get_termination("n_gen", 40)

res = minimize(problem,
algorithm,
termination,
evaluator=evaluator,
seed=1,
save_history=True,
verbose=True)

gen, _min, _median, _max = [], [], [], []

for algorithm in res.history:
if algorithm.n_gen % 5 == 0:
X = algorithm.pop.get("X")
kktpm = KKTPM().calc(X, problem)

    gen.append(algorithm.n_gen)
    _min.append(kktpm.min())
    _median.append(np.median(kktpm))
    _max.append(kktpm.max())

plt.plot(gen, _min, label="Min")
plt.plot(gen, _median, label="Median")
plt.plot(gen, _max, label="Max")
plt.yscale("log")
plt.legend()
plt.show()

[blankjul]

You still will need the ideal point. Automatic Derivation is a bit tricky when you have mixed ElementwiseProblem and just Problem. Probably something we have to think about in the framework design in general.

I have not found the time to test this in the current stable. But this works on my local development.

import autograd.numpy as np
import matplotlib.pyplot as plt

from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.constraints.bounds import BoundariesAsConstraints
from pymoo.core.evaluator import Evaluator
from pymoo.core.problem import Problem
from pymoo.factory import get_sampling, get_crossover, get_mutation
from pymoo.factory import get_termination
from pymoo.indicators.kktpm import KKTPM
from pymoo.optimize import minimize
from pymoo.problems.autodiff import AutomaticDifferentiation


class MyProblem(Problem):

    def __init__(self):
        super().__init__(n_var=2,
                         n_obj=2,
                         n_constr=2,
                         xl=np.array([-2, -2]),
                         xu=np.array([2, 2]))

    def _evaluate(self, x, out, *args, **kwargs):
        f1 = 100 * (x[:, 0] ** 2 + x[:, 1] ** 2)
        f2 = (x[:, 0] - 1) ** 2 + x[:, 1] ** 2

        g1 = 2 * (x[:, 0] - 0.1) * (x[:, 0] - 0.9) / 0.18
        g2 = - 20 * (x[:, 0] - 0.4) * (x[:, 0] - 0.6) / 4.8

        out["F"] = np.column_stack([f1, f2])
        out["G"] = np.column_stack([g1, g2])


problem = BoundariesAsConstraints(AutomaticDifferentiation(MyProblem()))

algorithm = NSGA2(
    pop_size=40,
    n_offsprings=10,
    sampling=get_sampling("real_random"),
    crossover=get_crossover("real_sbx", prob=0.9, eta=15),
    mutation=get_mutation("real_pm", eta=20),
    eliminate_duplicates=True
)

evaluator = Evaluator(evaluate_values_of=["F", "CV", "G", "dF", "dG"])

termination = get_termination("n_gen", 100)

res = minimize(problem,
               algorithm,
               termination,
               evaluator=evaluator,
               seed=1,
               save_history=True,
               verbose=True)


ideal = np.zeros(2)

gen, _min, _median, _max = [], [], [], []

for algorithm in res.history:
    if algorithm.n_gen % 1 == 0:
        X = algorithm.pop.get("X")
        kktpm = KKTPM().calc(X, problem, ideal=ideal)

        gen.append(algorithm.n_gen)
        _min.append(kktpm.min())
        _median.append(np.median(kktpm))
        _max.append(kktpm.max())

plt.plot(gen, _min, label="Min")
plt.plot(gen, _median, label="Median")
plt.plot(gen, _max, label="Max")
plt.yscale("log")
plt.legend()
plt.show()

[rabiu42000]

The solution you sent works for me too but when I tried it with my custom problem I get the following error message. pymoo\indicators\kktpm.py", line 44, in calc
F, CV, G, dF, dG = problem.evaluate(X, return_values_of=["F", "CV", "G", "dF", "dG"]) pymoo\problems\autodiff.py", line 48, in calc_jacobian
return vspace(start.shape).zeros() raise TypeError("Can't find vector space for value {} of type {}. "
TypeError: Can't find vector space for value 9 of type <class 'int'>. Valid types are dict_keys([<class 'autograd.core.SparseObject'>, <class 'list'>, <class 'tuple'>, <class 'dict'>, <class 'numpy.ndarray'>, <class 'float'>, <class 'numpy.float64'>, <class 'numpy.float32'>, <class 'numpy.float16'>, <class 'complex'>, <class 'numpy.complex64'>, <class 'numpy.complex128'>])

value 9 is pop_size which is an integer

[blankjul]

Have you used autograd for your problem definition? Without that automatic differentiation will not work (this error looks like this is happening)

[rabiu42000]

problem = AutomaticDifferentiation(
BoundariesAsConstraints(VectorizedProblem(params)))
Do you mean this or inside the problem class itself?