NSGA II is not updating the population

[adelka-m]

Hi everyone,

I am using NSGA II to solve my problem. But it seems that the survival operator is not even called. The population stays over the 10 generations same as the first sampled population.

In my algorithm I rewrote the crossover and mutation operators as follows:

class MyCrossover(Crossover):
    def __init__(self, n_offsprings=2, prob_per_variable=0.5, **kwargs):
        super().__init__(2, n_offsprings, **kwargs)
        self.prob_per_variable = prob_per_variable
        self.n_offsprings = n_offsprings

    def do(self, problem, pop, parents, alpha = 0.5, beta = 0.5, **kwargs):    
        X = pop.get('X')
        # some code
        offspringPopulation = Population.new("X", offspringsX)
        return offspringPopulation

class MyMutation(Mutation):
    def __init__(self, prob=None):
        super().__init__()
    
    def do(self, problem, pop, **kwargs):
        X = pop.get('X')
        # some code
        mutatedPopulation = Population.new("X", X1)
        return mutatedPopulation

The crossovered population is correctly passed to the mutation operator, but then the next crossover has again as an input the first population selected by sampling operator.

The survival operator seems not to be called at all.

---

This is the code I use for the optimization:

sampling  = MySampling()
crossover = MyCrossover()
mutation  = MyMutation()
survival  = MyRankAndCrowdingSurvival()

from pymoo.algorithms.moo.nsga2 import NSGA2
algorithm = NSGA2(
        pop_size = 10,   
        sampling = sampling, crossover = crossover, mutation = mutation, survival = survival,
        eliminate_duplicates = True  
    )

from pymoo.util.termination.default import MultiObjectiveDefaultTermination
termination = MultiObjectiveDefaultTermination(n_max_gen=10)

from pymoo.optimize import minimize
res = minimize(problem,  algorithm,  
               termination=termination,  seed=1,
               verbose=False,  return_least_infeasible=True)

---

Can anyone help me with this problem?

Why is the survival operator not called?

---

To further check if the survival operator is called, I just copied the code for the default NSGA II Survival from the source code and add some print statements to see whats happening (code below). But it is never printing.

from pymoo.core.survival import Survival
from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
from pymoo.algorithms.moo.nsga2 import calc_crowding_distance
class MyRankAndCrowdingSurvival(Survival):

    def __init__(self, nds=None) -> None:
        super().__init__(filter_infeasible=True)
        self.nds = nds if nds is not None else NonDominatedSorting()

    def _do(self, problem, pop, *args, n_survive=None, **kwargs):
        print('doing survival')
        # get the objective space values and objects
        F = pop.get("F").astype(float, copy=False)

        # the final indices of surviving individuals
        survivors = []

        # do the non-dominated sorting until splitting front
        fronts = self.nds.do(F, n_stop_if_ranked=n_survive)

        for k, front in enumerate(fronts):

            # calculate the crowding distance of the front
            crowding_of_front = calc_crowding_distance(F[front, :])

            # save rank and crowding in the individual class
            for j, i in enumerate(front):
                pop[i].set("rank", k)
                pop[i].set("crowding", crowding_of_front[j])

            # current front sorted by crowding distance if splitting
            if len(survivors) + len(front) > n_survive:
                I = randomized_argsort(crowding_of_front, order='descending', method='numpy')
                I = I[:(n_survive - len(survivors))]

            # otherwise take the whole front unsorted
            else:
                I = np.arange(len(front))

            # extend the survivors by all or selected individuals
            survivors.extend(front[I])
        print('END survival')
        return pop[survivors]

THANKS A LOT!

[adelka-m]

Found the problem, it was here

super().__init__(filter_infeasible=True)

Set it to False and it calls everything as it should