pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/algorithms/moo/cmopso.py

@@ -0,0 +1,239 @@
+import numpy as np
+
+from pymoo.algorithms.moo.spea2 import SPEA2Survival
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.initialization import Initialization
+from pymoo.core.population import Population
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.mutation.pm import PolynomialMutation
+from pymoo.operators.repair.to_bound import (
+    ToBoundOutOfBoundsRepair,
+    set_to_bounds_if_outside,
+)
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.survival.rank_and_crowding.metrics import get_crowding_function
+from pymoo.util import default_random_state
+from pymoo.util.archive import MultiObjectiveArchive, SurvivalTruncation
+from pymoo.util.display.multi import MultiObjectiveOutput
+
+
+class CrowdingDistanceTournamentSurvival(Survival):
+    def __init__(self, tournament_size=3):
+        """
+        Survival strategy that uses tournament selection based on crowding distance.
+
+        This class inherits from :class:`~pymoo.core.survival.Survival` and implements a
+        tournament selection mechanism where individuals with higher crowding distance
+        (indicating better diversity) are preferred.
+
+        Parameters
+        ----------
+        tournament_size : int, optional
+            The number of individuals participating in each tournament. Defaults to 3.
+        """
+        super().__init__(filter_infeasible=True)
+        self._tournament_size = tournament_size
+        self._cd = get_crowding_function("cd")
+
+    def _do(self, problem, pop, n_survive, random_state=None, **kwargs):
+        crowding = self._cd.do(pop.get("F"))
+
+        # Select solutions with better crowding distance (more diverse)
+        selected_indices = []
+        remaining_indices = list(range(len(pop)))
+
+        while len(selected_indices) < n_survive and remaining_indices:
+            # Tournament selection favoring higher crowding distance
+            tournament_size = min(self._tournament_size, len(remaining_indices))
+            tournament_indices = random_state.choice(
+                remaining_indices, size=tournament_size, replace=False
+            )
+
+            # Select the one with highest crowding distance in tournament
+            best_idx = tournament_indices[np.argmax(crowding[tournament_indices])]
+            selected_indices.append(best_idx)
+            remaining_indices.remove(best_idx)
+
+        return pop[selected_indices]
+
+
+def angle_between(v1, v2):
+    v1 = v1 / (np.linalg.norm(v1) + 1e-6)  # unit vector; +1-e6 to avoid zero-division
+    v2 = v2 / (np.linalg.norm(v2) + 1e-6)  # unit vector
+    return np.arccos(np.clip(np.dot(v1, v2), -1.0, 1.0))
+
+
+@default_random_state
+def cmopso_equation(X, L, V, V_max, random_state=None):
+    """
+    Calculates the new positions and velocities of particles based on the CMOPSO
+    competition-based learning strategy.
+
+    This function implements the core update equations for the Competitive Mechanism
+    based Multi-objective Particle Swarm Optimizer (CMOPSO). Each particle's
+    velocity is updated by learning from a "winner" selected from the elite archive
+    (`L`) through a binary tournament. The winner is chosen based on the smallest
+    angle between the particle's current position and the elite's position, promoting
+    diversity.
+
+    Parameters
+    ----------
+    X : numpy.ndarray
+        Current positions of the particles (population). Shape `(n_particles, n_var)`.
+    L : numpy.ndarray
+        Positions of the elite particles from the archive. Shape `(n_elites, n_var)`.
+    V : numpy.ndarray
+        Current velocities of the particles. Shape `(n_particles, n_var)`.
+    V_max : numpy.ndarray
+        Maximum allowed velocity for each decision variable. Shape `(n_var,)`.
+    random_state : numpy.random.RandomState, optional
+        Random state for reproducibility. If None, a new default random number
+        generator is used.
+
+    Returns
+    -------
+    Xp : numpy.ndarray
+        New positions of the particles after the update. Shape `(n_particles, n_var)`.
+    Vp : numpy.ndarray
+        New velocities of the particles after the update. Shape `(n_particles, n_var)`.
+    """
+
+    W_X = []
+    for i in range(np.shape(X)[0]):  # binary tournament selection on elites
+        aidx = random_state.choice(range(len(L)))
+        bidx = random_state.choice(range(len(L)))
+        a = L[aidx]
+        b = L[bidx]
+        pw = min(a, b, key=lambda x: angle_between(x, X[i]))
+        W_X.append(pw)
+    W_X = np.asarray(W_X)
+
+    r1 = random_state.random(X.shape)
+    r2 = random_state.random(X.shape)
+
+    # calculate the velocity vector
+    Vp = r1 * V + r2 * (W_X - X)
+    Vp = set_to_bounds_if_outside(Vp, -V_max, V_max)
+
+    Xp = X + Vp
+
+    return Xp, Vp
+
+
+class CMOPSO(Algorithm):
+    def __init__(
+        self,
+        pop_size=100,
+        max_velocity_rate=0.2,
+        elite_size=10,
+        initial_velocity="random",  # 'random' | 'zero'
+        mutation_rate=0.5,
+        sampling=FloatRandomSampling(),
+        repair=ToBoundOutOfBoundsRepair(),
+        output=MultiObjectiveOutput(),
+        **kwargs,
+    ):
+        """
+        Competitive mechanism based Multi-objective Particle Swarm Optimizer (CMOPSO).
+
+        Particle updates are based on learning from the "winner" of binary tournaments
+        of randomly selected elites. Replacement strategy is based on SPEA2.
+
+        Zhang, X., Zheng, X., Cheng, R., Qiu, J., & Jin, Y. (2018). A competitive mechanism
+        based multi-objective particle swarm optimizer with fast convergence.
+        Inf. Sci., 427, 63-76.
+
+        Parameters
+        ----------
+        pop_size : int, optional
+            The population size. Defaults to 100.
+        max_velocity_rate : float, optional
+            The maximum velocity rate. Defaults to 0.2.
+        max_elite_size : int, optional
+            The maximum size of the elite archive. Defaults to 10.
+        initial_velocity : str, optional
+            Defines how the initial velocity of particles is set. Can be "random" or "zero".
+            Defaults to "random".
+        mutate_rate : float, optional
+            Rate at which to apply polynomial mutation to the offspring. Defaults to 0.5.
+        sampling : :class:`~pymoo.core.sampling.Sampling`, optional
+            Sampling strategy used to generate the initial population. Defaults to
+            :class:`~pymoo.operators.sampling.rnd.FloatRandomSampling`.
+        repair : :class:`~pymoo.operators.repair.Repair`, optional
+            Repair method for out-of-bounds variables. Defaults to
+            :class:`~pymoo.operators.repair.to_bound.ToBoundOutOfBoundsRepair`.
+        output : :class:`~pymoo.util.display.output.Output`, optional
+            Output object to be used for logging. Defaults to
+            :class:`~pymoo.util.display.multi.MultiObjectiveOutput`.
+        **kwargs
+            Additional keyword arguments to be passed to the Algorithm superclass.
+        """
+        super().__init__(output=output, **kwargs)
+        self.pop_size = pop_size
+        self.max_velocity_rate = max_velocity_rate
+        self.elite_size = elite_size
+        self.initialization = Initialization(sampling)
+        self.initial_velocity = initial_velocity
+        self.repair = repair
+        self._cd = get_crowding_function("cd")
+        self.mutation = PolynomialMutation(prob=mutation_rate)
+        self.survival = SPEA2Survival()
+
+    def _setup(self, problem, **kwargs):
+        super()._setup(problem, **kwargs)
+        self.elites = MultiObjectiveArchive(
+            truncation=SurvivalTruncation(
+                CrowdingDistanceTournamentSurvival(), problem=problem
+            ),
+            max_size=self.pop_size,
+            truncate_size=self.elite_size,
+        )
+        self.V_max = self.max_velocity_rate * (problem.xu - problem.xl)
+
+    def _initialize_infill(self):
+        return self.initialization.do(
+            self.problem, self.pop_size, algorithm=self, random_state=self.random_state
+        )
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.pop = infills
+
+        if self.initial_velocity == "random":
+            init_V = (
+                self.random_state.random((len(self.pop), self.problem.n_var))
+                * self.V_max[None, :]
+            )
+        elif self.initial_velocity == "zero":
+            init_V = np.zeros((len(self.pop), self.problem.n_var))
+        else:
+            raise Exception("Unknown velocity initialization.")
+
+        self.pop.set("V", init_V)
+        self.elites = self.elites.add(self.pop)
+
+    def _infill(self):
+        (X, V) = self.pop.get("X", "V")
+        L = self.elites.get("X")
+
+        Xp, Vp = cmopso_equation(X, L, V, self.V_max, random_state=self.random_state)
+
+        # create the offspring population
+        off = Population.new(X=Xp, V=Vp)
+        off = self.mutation(self.problem, off, random_state=self.random_state)
+        off = self.repair(self.problem, off)
+
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, (
+            "This algorithm uses the AskAndTell interface thus 'infills' must to be provided."
+        )
+
+        particles = Population.merge(self.pop, infills)
+        self.elites = self.elites.add(particles)
+        self.pop = self.survival.do(self.problem, particles, n_survive=self.pop_size)
+
+
+parse_doc_string(CrowdingDistanceTournamentSurvival.__init__)
+parse_doc_string(CMOPSO.__init__)

pymoo/algorithms/moo/ctaea.py

@@ -0,0 +1,305 @@
+import math
+
+import numpy as np
+from scipy.spatial.distance import cdist, pdist, squareform
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.core.population import Population
+from pymoo.decomposition.asf import ASF
+from pymoo.docs import parse_doc_string
+from pymoo.functions import load_function
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import TournamentSelection
+from pymoo.util import default_random_state
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.dominator import Dominator
+from pymoo.util.misc import has_feasible, random_permutations
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+
+
+# =========================================================================================================
+# Implementation
+# Following original code by K. Li https://cola-laboratory.github.io/codes/CTAEA.zip
+# =========================================================================================================
+
+
+@default_random_state
+def comp_by_cv_dom_then_random(pop, P, random_state=None, **kwargs):
+    S = np.full(P.shape[0], np.nan)
+
+    for i in range(P.shape[0]):
+        a, b = P[i, 0], P[i, 1]
+
+        if pop[a].CV <= 0.0 and pop[b].CV <= 0.0:
+            rel = Dominator.get_relation(pop[a].F, pop[b].F)
+            if rel == 1:
+                S[i] = a
+            elif rel == -1:
+                S[i] = b
+            else:
+                S[i] = random_state.choice([a, b])
+        elif pop[a].CV <= 0.0:
+            S[i] = a
+        elif pop[b].CV <= 0.0:
+            S[i] = b
+        else:
+            S[i] = random_state.choice([a, b])
+
+    return S[:, None].astype(int)
+
+
+class RestrictedMating(TournamentSelection):
+    """Restricted mating approach to balance convergence and diversity archives"""
+
+    @default_random_state
+    def _do(self, problem, Hm, n_select, n_parents, random_state=None, **kwargs):
+        n_pop = len(Hm) // 2
+
+        _, rank = NonDominatedSorting().do(Hm.get('F'), return_rank=True)
+
+        Pc = (rank[:n_pop] == 0).sum() / len(Hm)
+        Pd = (rank[n_pop:] == 0).sum() / len(Hm)
+
+        # number of random individuals needed
+        n_random = n_select * n_parents * self.pressure
+        n_perms = math.ceil(n_random / n_pop)
+        # get random permutations and reshape them
+        P = random_permutations(n_perms, n_pop, random_state=random_state)[:n_random]
+        P = np.reshape(P, (n_select * n_parents, self.pressure))
+        if Pc <= Pd:
+            # Choose from DA
+            P[::n_parents, :] += n_pop
+        pf = random_state.random(n_select)
+        P[1::n_parents, :][pf >= Pc] += n_pop
+
+        # compare using tournament function
+        S = self.func_comp(Hm, P, random_state=random_state, **kwargs)
+
+        return np.reshape(S, (n_select, n_parents))
+
+
+class CADASurvival:
+
+    def __init__(self, ref_dirs):
+        self.ref_dirs = ref_dirs
+        self.opt = None
+        self.ideal_point = np.full(ref_dirs.shape[1], np.inf)
+        self._decomposition = ASF()
+        self._calc_perpendicular_distance = load_function("calc_perpendicular_distance")
+
+    @default_random_state
+    def do(self, _, pop, da, n_survive=None, random_state=None, **kwargs):
+        # Store random_state for use in methods
+        self.random_state = random_state
+        # Offspring are last of merged population
+        off = pop[-n_survive:]
+        # Update ideal point
+        self.ideal_point = np.min(np.vstack((self.ideal_point, off.get("F"))), axis=0)
+        # Update CA
+        pop = self._updateCA(pop, n_survive, random_state=random_state)
+        # Update DA
+        Hd = Population.merge(da, off)
+        da = self._updateDA(pop, Hd, n_survive)
+        return pop, da
+
+    def _associate(self, pop):
+        """Associate each individual with a F vector and calculate decomposed fitness"""
+        F = pop.get("F")
+        dist_matrix = self._calc_perpendicular_distance(F - self.ideal_point, self.ref_dirs)
+        niche_of_individuals = np.argmin(dist_matrix, axis=1)
+        FV = self._decomposition.do(F, weights=self.ref_dirs[niche_of_individuals, :],
+                                    ideal_point=self.ideal_point, weight_0=1e-4)
+        pop.set("niche", niche_of_individuals)
+        pop.set("FV", FV)
+        return niche_of_individuals, FV
+
+    @default_random_state
+    def _updateCA(self, pop, n_survive, random_state=None):
+        """Update the Convergence archive (CA)"""
+        CV = pop.get("CV").flatten()
+
+        Sc = pop[CV == 0]  # ConstraintsAsObjective population
+        if len(Sc) == n_survive:  # Exactly n_survive feasible individuals
+            F = Sc.get("F")
+            fronts, rank = NonDominatedSorting().do(F, return_rank=True)
+            Sc.set('rank', rank)
+            self.opt = Sc[fronts[0]]
+            return Sc
+        elif len(Sc) < n_survive:  # Not enough feasible individuals
+            remainder = n_survive - len(Sc)
+            # Solve sub-problem CV, tche
+            SI = pop[CV > 0]
+            f1 = SI.get("CV")
+            _, f2 = self._associate(SI)
+            sub_F = np.column_stack([f1, f2])
+            fronts = NonDominatedSorting().do(sub_F, n_stop_if_ranked=remainder)
+            I = []
+            for front in fronts:
+                if len(I) + len(front) <= remainder:
+                    I.extend(front)
+                else:
+                    n_missing = remainder - len(I)
+                    last_front_CV = np.argsort(f1.flatten()[front])
+                    I.extend(front[last_front_CV[:n_missing]])
+            SI = SI[I]
+            S = Population.merge(Sc, SI)
+            F = S.get("F")
+            fronts, rank = NonDominatedSorting().do(F, return_rank=True)
+            S.set('rank', rank)
+            self.opt = S[fronts[0]]
+            return S
+        else:  # Too many feasible individuals
+            F = Sc.get("F")
+            # Filter by non-dominated sorting
+            fronts, rank = NonDominatedSorting().do(F, return_rank=True, n_stop_if_ranked=n_survive)
+            I = np.concatenate(fronts)
+            S, rank, F = Sc[I], rank[I], F[I]
+            if len(S) > n_survive:
+                # Remove individual in most crowded niche and with worst fitness
+                niche_of_individuals, FV = self._associate(S)
+                index, count = np.unique(niche_of_individuals, return_counts=True)
+                survivors = np.full(S.shape[0], True)
+                while survivors.sum() > n_survive:
+                    crowdest_niches, = np.where(count == count.max())
+                    worst_idx = None
+                    worst_niche = None
+                    worst_fit = -1
+                    for crowdest_niche in crowdest_niches:
+                        crowdest, = np.where((niche_of_individuals == index[crowdest_niche]) & survivors)
+                        niche_worst = crowdest[FV[crowdest].argmax()]
+                        dist_to_max_fit = cdist(F[[niche_worst], :], F).flatten()
+                        dist_to_max_fit[niche_worst] = np.inf
+                        dist_to_max_fit[~survivors] = np.inf
+                        min_d_to_max_fit = dist_to_max_fit.min()
+
+                        dist_in_niche = squareform(pdist(F[crowdest]))
+                        np.fill_diagonal(dist_in_niche, np.inf)
+
+                        delta_d = dist_in_niche - min_d_to_max_fit
+                        min_d_i = np.unravel_index(np.argmin(delta_d, axis=None), dist_in_niche.shape)
+                        if (delta_d[min_d_i] < 0) or (
+                                delta_d[min_d_i] == 0 and (FV[crowdest[list(min_d_i)]] > niche_worst).any()):
+                            min_d_i = list(min_d_i)
+                            random_state.shuffle(min_d_i)
+                            closest = crowdest[min_d_i]
+                            niche_worst = closest[np.argmax(FV[closest])]
+                        if (FV[niche_worst] > worst_fit).all():
+                            worst_fit = FV[niche_worst]
+                            worst_idx = niche_worst
+                            worst_niche = crowdest_niche
+                    survivors[worst_idx] = False
+                    count[worst_niche] -= 1
+                S, rank = S[survivors], rank[survivors]
+            S.set('rank', rank)
+            self.opt = S[rank == 0]
+            return S
+
+    def _updateDA(self, pop, Hd, n_survive):
+        """Update the Diversity archive (DA)"""
+        niche_Hd, FV = self._associate(Hd)
+        niche_CA, _ = self._associate(pop)
+
+        itr = 1
+        S = []
+        while len(S) < n_survive:
+            for i in range(n_survive):
+                current_ca, = np.where(niche_CA == i)
+                if len(current_ca) < itr:
+                    for _ in range(itr - len(current_ca)):
+                        current_da = np.where(niche_Hd == i)[0]
+                        if current_da.size > 0:
+                            F = Hd[current_da].get('F')
+                            nd = NonDominatedSorting().do(F, only_non_dominated_front=True, n_stop_if_ranked=0)
+                            i_best = current_da[nd[np.argmin(FV[current_da[nd]])]]
+                            niche_Hd[i_best] = -1
+                            if len(S) < n_survive:
+                                S.append(i_best)
+                        else:
+                            break
+                if len(S) == n_survive:
+                    break
+            itr += 1
+        return Hd[S]
+
+
+class CTAEA(GeneticAlgorithm):
+
+    def __init__(self,
+                 ref_dirs,
+                 sampling=FloatRandomSampling(),
+                 selection=RestrictedMating(func_comp=comp_by_cv_dom_then_random),
+                 crossover=SBX(n_offsprings=1, eta=30, prob=1.0),
+                 mutation=PM(prob_var=None, eta=20),
+                 eliminate_duplicates=True,
+                 output=MultiObjectiveOutput(),
+                 **kwargs):
+        """
+        CTAEA
+
+        Parameters
+        ----------
+        ref_dirs : {ref_dirs}
+        sampling : {sampling}
+        selection : {selection}
+        crossover : {crossover}
+        mutation : {mutation}
+        eliminate_duplicates : {eliminate_duplicates}
+        """
+
+        self.ref_dirs = ref_dirs
+        pop_size = len(ref_dirs)
+
+        if 'survival' in kwargs:
+            survival = kwargs['survival']
+            del kwargs['survival']
+        else:
+            survival = CADASurvival(ref_dirs)
+
+        # Initialize diversity archives
+        self.da = None
+
+        super().__init__(pop_size=pop_size,
+                         sampling=sampling,
+                         selection=selection,
+                         crossover=crossover,
+                         mutation=mutation,
+                         survival=survival,
+                         eliminate_duplicates=eliminate_duplicates,
+                         n_offsprings=pop_size,
+                         output=output,
+                         **kwargs)
+
+    def _setup(self, problem, **kwargs):
+
+        if self.ref_dirs is not None and self.ref_dirs.shape[1] != problem.n_obj:
+            raise Exception(
+                "Dimensionality of reference points must be equal to the number of objectives: %s != %s" %
+                (self.ref_dirs.shape[1], problem.n_obj))
+
+    def _initialize_infill(self):
+        return self.initialization.do(self.problem, self.pop_size, algorithm=self, random_state=self.random_state)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        super()._initialize_advance(infills, **kwargs)
+        self.pop, self.da = self.survival.do(self.problem, self.pop, Population(), n_survive=len(self.pop),
+                                             algorithm=self, random_state=self.random_state)
+
+    def _infill(self):
+        Hm = Population.merge(self.pop, self.da)
+        return self.mating.do(self.problem, Hm, n_offsprings=self.n_offsprings, algorithm=self, random_state=self.random_state)
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus infills must to be provided."
+        pop = Population.merge(self.pop, infills)
+        self.pop, self.da = self.survival.do(self.problem, pop, self.da, self.pop_size, algorithm=self, random_state=self.random_state)
+
+    def _set_optimum(self, **kwargs):
+        if not has_feasible(self.pop):
+            self.opt = self.pop[[np.argmin(self.pop.get("CV"))]]
+        else:
+            self.opt = self.survival.opt
+
+
+parse_doc_string(CTAEA.__init__)

pymoo/algorithms/moo/dnsga2.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+from pymoo.algorithms.moo.nsga2 import NSGA2
+from pymoo.core.population import Population
+
+
+class DNSGA2(NSGA2):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 perc_diversity=0.3,
+                 eps=0.0,
+                 version="A",
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.perc_detect_change = perc_detect_change
+        self.perc_diversity = perc_diversity
+        self.eps = eps
+        self.version = version
+
+    def setup(self, problem, **kwargs):
+        assert not problem.has_constraints(), "DNSGA2 only works for unconstrained problems."
+        return super().setup(problem, **kwargs)
+
+    def _infill(self):
+        
+        return None
+
+    def _advance(self, **kwargs):
+
+        pop = self.pop
+        X, F = pop.get("X", "F")
+
+        # the number of solutions to sample from the population to detect the change
+        n_samples = int(np.ceil(len(pop) * self.perc_detect_change))
+
+        # choose randomly some individuals of the current population to test if there was a change
+        I = self.random_state.choice(np.arange(len(pop)), size=n_samples)
+        samples = self.evaluator.eval(self.problem, Population.new(X=X[I]))
+
+        # calculate the differences between the old and newly evaluated pop
+        delta = ((samples.get("F") - F[I]) ** 2).mean()
+
+        # if there is an average deviation bigger than eps -> we have a change detected
+        change_detected = delta > self.eps
+
+        if change_detected:
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+            # find indices to be replaced (introduce diversity)
+            I = np.where(self.random_state.random(len(pop)) < self.perc_diversity)[0]
+
+            # replace with randomly sampled individuals
+            if self.version == "A":
+                pop[I] = self.initialization.sampling(self.problem, len(I), random_state=self.random_state)
+
+            # replace by mutations of existing solutions (this occurs inplace)
+            elif self.version == "B":
+                self.mating.mutation(self.problem, pop[I])
+            else:
+                raise Exception(f"Unknown version of D-NSGA-II: {self.version}")
+
+            # reevaluate because we know there was a change
+            self.evaluator.eval(self.problem, pop)
+
+            # do a survival to recreate rank and crowding of all individuals
+            pop = self.survival.do(self.problem, pop, n_survive=len(pop), random_state=self.random_state)
+
+        # create the offsprings from the current population
+        off = self.mating.do(self.problem, pop, self.n_offsprings, algorithm=self, random_state=self.random_state)
+        self.evaluator.eval(self.problem, off)
+
+        # merge the parent population and offsprings
+        pop = Population.merge(pop, off)
+
+        # execute the survival to find the fittest solutions
+        self.pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, algorithm=self, random_state=self.random_state)