pydmoo 0.0.18__py3-none-any.whl → 0.1.0__py3-none-any.whl

pydmoo/algorithms/base/dmoo/dmoeadde.py

@@ -0,0 +1,131 @@
+import time
+
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.moo.moeadde import MOEADDE
+
+
+class DMOEADDE(MOEADDE):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.perc_detect_change = perc_detect_change
+        self.eps = eps
+
+    def setup(self, problem, **kwargs):
+        assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
+        return super().setup(problem, **kwargs)
+
+    def _detect_change_sample_part_population(self):
+        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
+        return change_detected
+
+    def _next_static_dynamic(self):
+        # for dynamic environment
+        pop = self.pop
+
+        if self.state is None:
+
+            change_detected = self._detect_change_sample_part_population()
+
+            if change_detected:
+
+                start_time = time.time()
+
+                pop = self._response_change()
+
+                # reevaluate because we know there was a change
+                self.evaluator.eval(self.problem, pop)
+
+                if len(pop) > self.pop_size:
+                    # do a survival to recreate rank and crowding of all individuals
+                    # Modified by DynOpt on Dec 21, 2025
+                    # n_survive=len(pop) -> n_survive=self.pop_size
+                    pop = RankAndCrowding().do(self.problem, pop, n_survive=self.pop_size, random_state=self.random_state)
+
+                self.pop = pop
+
+                self.data["response_duration"] = time.time() - start_time
+
+        return pop
+
+    def _response_change(self):
+        pass
+
+
+class DMOEADDEA(DMOEADDE):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # 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
+        pop[I] = self.initialization.sampling(self.problem, len(I), random_state=self.random_state)
+
+        return pop
+
+
+class DMOEADDEB(DMOEADDE):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # 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 by mutations of existing solutions (this occurs inplace)
+        self.mating.mutation(self.problem, pop[I])
+
+        return pop

pydmoo/algorithms/base/dmoo/dnsga2.py

@@ -0,0 +1,137 @@
+"""
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [dnsga2.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/algorithms/moo/dnsga2.py).
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+
+The framework was adapted to enable efficient aggregation of change response strategies.
+"""
+import time
+
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.base.moo.nsga2 import NSGA2
+
+
+class DNSGA2(NSGA2):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.perc_detect_change = perc_detect_change
+        self.eps = eps
+
+    def setup(self, problem, **kwargs):
+        assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
+        return super().setup(problem, **kwargs)
+
+    def _detect_change_sample_part_population(self):
+        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
+        return change_detected
+
+    def _infill_static_dynamic(self):
+        # for dynamic environment
+        pop = self.pop
+
+        change_detected = self._detect_change_sample_part_population()
+
+        if change_detected:
+
+            start_time = time.time()
+
+            pop = self._response_change()
+
+            # 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
+            # Modified by DynOpt on Dec 21, 2025
+            # n_survive=len(pop) -> n_survive=self.pop_size
+            pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, random_state=self.random_state)
+
+            self.pop = pop
+
+            self.data["response_duration"] = time.time() - start_time
+
+        return pop
+
+    def _response_change(self):
+        pass
+
+
+class DNSGA2A(DNSGA2):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # 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
+        pop[I] = self.initialization.sampling(self.problem, len(I), random_state=self.random_state)
+
+        return pop
+
+
+class DNSGA2B(DNSGA2):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # 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 by mutations of existing solutions (this occurs inplace)
+        self.mating.mutation(self.problem, pop[I])
+
+        return pop

pydmoo/algorithms/base/moo/moead.py

@@ -0,0 +1,199 @@
+"""
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [moead.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/algorithms/moo/moead.py).
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+
+Add a method `_next_static_dynamic for dynamic multi-objective optimization.`
+"""
+import numpy as np
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.population import Population
+from pymoo.core.selection import Selection
+from pymoo.core.variable import Real, get
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.reference_direction import default_ref_dirs
+from scipy.spatial.distance import cdist
+
+from pydmoo.algorithms.base.core.algorithm import LoopwiseAlgorithm
+from pydmoo.algorithms.base.core.genetic import GeneticAlgorithm
+
+
+class NeighborhoodSelection(Selection):
+
+    def __init__(self, prob=1.0) -> None:
+        super().__init__()
+        self.prob = Real(prob, bounds=(0.0, 1.0))
+
+    def _do(self, problem, pop, n_select, n_parents, neighbors=None, random_state=None, **kwargs):
+        assert n_select == len(neighbors)
+        P = np.full((n_select, n_parents), -1)
+
+        prob = get(self.prob, size=n_select)
+
+        for k in range(n_select):
+            if random_state.random() < prob[k]:
+                P[k] = random_state.choice(neighbors[k], n_parents, replace=False)
+            else:
+                P[k] = random_state.permutation(len(pop))[:n_parents]
+
+        return P
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+class MOEAD(LoopwiseAlgorithm, GeneticAlgorithm):
+
+    def __init__(self,
+                 ref_dirs=None,
+                 n_neighbors=20,
+                 decomposition=None,
+                 prob_neighbor_mating=0.9,
+                 sampling=FloatRandomSampling(),
+                 crossover=SBX(prob=1.0, eta=20),
+                 mutation=PM(prob_var=None, eta=20),
+                 output=MultiObjectiveOutput(),
+                 **kwargs):
+
+        # reference directions used for MOEAD
+        self.ref_dirs = ref_dirs
+
+        # the decomposition metric used
+        self.decomposition = decomposition
+
+        # the number of neighbors considered during mating
+        self.n_neighbors = n_neighbors
+
+        self.neighbors = None
+
+        self.selection = NeighborhoodSelection(prob=prob_neighbor_mating)
+
+        super().__init__(pop_size=len(ref_dirs),
+                         sampling=sampling,
+                         crossover=crossover,
+                         mutation=mutation,
+                         eliminate_duplicates=NoDuplicateElimination(),
+                         output=output,
+                         advance_after_initialization=False,
+                         **kwargs)
+
+    def _setup(self, problem, **kwargs):
+        assert not problem.has_constraints(), "This implementation of MOEAD does not support any constraints."
+
+        # if no reference directions have been provided get them and override the population size and other settings
+        if self.ref_dirs is None:
+            self.ref_dirs = default_ref_dirs(problem.n_obj)
+        self.pop_size = len(self.ref_dirs)
+
+        # neighbours includes the entry by itself intentionally for the survival method
+        self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs), axis=1, kind='quicksort')[:, :self.n_neighbors]
+
+        # if the decomposition is not set yet, set the default
+        if self.decomposition is None:
+            self.decomposition = default_decomp(problem)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        super()._initialize_advance(infills, **kwargs)
+        self.ideal = np.min(self.pop.get("F"), axis=0)
+
+    def _next(self):
+        pop = self._next_static_dynamic()
+
+        # iterate for each member of the population in random order
+        for k in self.random_state.permutation(len(pop)):
+            # get the parents using the neighborhood selection
+            P = self.selection.do(self.problem, pop, 1, self.mating.crossover.n_parents, neighbors=[self.neighbors[k]], random_state=self.random_state)
+
+            # perform a mating using the default operators - if more than one offspring just pick the first
+            off = self.random_state.choice(self.mating.do(self.problem, pop, 1, parents=P, n_max_iterations=1, random_state=self.random_state))
+
+            # evaluate the offspring
+            off = yield off
+
+            # update the ideal point
+            self.ideal = np.min(np.vstack([self.ideal, off.F]), axis=0)
+
+            # now actually do the replacement of the individual is better
+            self._replace(k, off)
+
+    # Added by DynOpt on Dec 21, 2025
+    def _next_static_dynamic(self):
+        pop = self.pop
+
+        return pop
+
+    def _replace(self, k, off):
+        pop = self.pop
+
+        # calculate the decomposed values for each neighbor
+        N = self.neighbors[k]
+        FV = self.decomposition.do(pop[N].get("F"), weights=self.ref_dirs[N, :], ideal_point=self.ideal)
+        off_FV = self.decomposition.do(off.F[None, :], weights=self.ref_dirs[N, :], ideal_point=self.ideal)
+
+        # this makes the algorithm to support constraints - not originally proposed though and not tested enough
+        # if self.problem.has_constraints():
+        #     CV, off_CV = pop[N].get("CV")[:, 0], np.full(len(off_FV), off.CV)
+        #     fmax = max(FV.max(), off_FV.max())
+        #     FV, off_FV = parameter_less(FV, CV, fmax=fmax), parameter_less(off_FV, off_CV, fmax=fmax)
+
+        # get the absolute index in F where offspring is better than the current F (decomposed space)
+        I = np.where(off_FV < FV)[0]
+        pop[N[I]] = off
+
+
+class ParallelMOEAD(MOEAD):
+
+    def __init__(self, ref_dirs, **kwargs):
+        super().__init__(ref_dirs, **kwargs)
+        self.indices = None
+
+    def _infill(self):
+        pop_size, cross_parents, cross_off = self.pop_size, self.mating.crossover.n_parents, self.mating.crossover.n_offsprings
+
+        # do the mating in a random order
+        indices = self.random_state.permutation(len(self.pop))[:self.n_offsprings]
+
+        # get the parents using the neighborhood selection
+        P = self.selection.do(self.problem, self.pop, self.n_offsprings, cross_parents,
+                              neighbors=self.neighbors[indices], random_state=self.random_state)
+
+        # do not any duplicates elimination - thus this results in exactly pop_size * n_offsprings offsprings
+        off = self.mating.do(self.problem, self.pop, 1e12, n_max_iterations=1, parents=P, random_state=self.random_state)
+
+        # select a random offspring from each mating
+        off = Population.create(*[self.random_state.choice(pool) for pool in np.reshape(off, (self.n_offsprings, -1))])
+
+        # store the indices because of the neighborhood matching in advance
+        self.indices = indices
+
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+        assert len(self.indices) == len(infills), "Number of infills must be equal to the one created beforehand."
+
+        # update the ideal point before starting to replace
+        self.ideal = np.min(np.vstack([self.ideal, infills.get("F")]), axis=0)
+
+        # now do the replacements as in the loop-wise version
+        for k, off in enumerate(infills):
+            self._replace(self.indices[k], off)
+
+
+def default_decomp(problem):
+    if problem.n_obj <= 2:
+        from pymoo.decomposition.tchebicheff import Tchebicheff
+        return Tchebicheff()
+    else:
+        from pymoo.decomposition.pbi import PBI
+        return PBI()
+
+
+parse_doc_string(MOEAD.__init__)

pydmoo/algorithms/base/moo/moeadde.py

@@ -0,0 +1,105 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.decomposition.tchebicheff import Tchebicheff
+from pymoo.operators.mutation.pm import PM
+
+from pydmoo.algorithms.base.moo.moead import MOEAD
+
+
+class MOEADDE(MOEAD):
+    """MOEA/D-DE (Updated by Cao).
+
+    It is worth noting that there is a distinct modification in line 28 compared with the original framework of MOEA/D-DE.
+    The newly generated solution competes with each member from the corresponding mating neighborhood (denoted as Pool in Algorithm 2).
+    But in the original MOEA/D-DE framework, it only competes with two members from the corresponding mating neighborhood.
+    This modification expands the replacement neighborhood to enhance the exploitation capability that is extremely important in dealing with DMOPs.
+
+    Cao, L., Xu, L., Goodman, E. D., Bao, C., and Zhu, S. (2020).
+    Evolutionary dynamic multiobjective optimization assisted by a support vector regression predictor.
+    IEEE Transactions on Evolutionary Computation, 24(2), 305–319.
+    https://doi.org/10.1109/TEVC.2019.2925722
+
+    Hui Li and Qingfu Zhang. (2009).
+    Multiobjective optimization problems with complicated pareto sets, MOEA/D and NSGA-II.
+    IEEE Transactions on Evolutionary Computation, 13(2), 284–302.
+    https://doi.org/10.1109/TEVC.2008.925798
+    """
+    def __init__(self, decomposition=Tchebicheff(), prob_neighbor_mating=0.8, **kwargs):
+        super().__init__(decomposition=decomposition, prob_neighbor_mating=prob_neighbor_mating, **kwargs)
+
+        # Neighborhood Selection
+        # the number of neighbors considered during mating
+        self.n_neighbors = 20
+        self._delta = 0.8  # 0.9 (prob_neighbor_mating)
+
+        # DE crossover
+        self._cr = 0.5  # 1
+        self._F_ = 0.5  # 0.5
+
+        # Polynomial mutation
+        self._eta = 20
+        # self._pm = 1/d  # d is the number of variables
+        self.mutation = PM(eta=self._eta)  # prob_var=1/d, default is min(0.5, 1/d)
+
+    def _next(self):
+        pop = self._next_static_dynamic()
+
+        # iterate for each member of the population in random order
+        for k in self.random_state.permutation(len(pop)):
+            # Step 2.1 Selection of Mating/Update Range:
+            # Select parents - use neighborhood with probability delta, else global selection
+            pp = self.neighbors[k] if self.random_state.random() < self._delta else list(range(self.pop_size))
+
+            # Step 2.2 Reproduction
+            # Randomly select three distinct parents from the chosen pool
+            a, b, c = self.random_state.choice(pp, size=3, replace=True)
+
+            # Initialize problem parameters
+            n_var = self.problem.n_var
+            xl, xu = self.problem.xl, self.problem.xu
+
+            X = pop.get("X")  # Position critical
+
+            # mutation operator
+            # Differential evolution mutation: v = x1 + F*(x2 - x3)
+            mutation = X[a] + self._F_ * (X[b] - X[c])
+
+            # crossover operator
+            # Create mask for crossover operations (CR probability)
+            mask = self.random_state.random(n_var) < self._cr
+
+            # Combine mutation with target vector based on crossover probability
+            V = np.where(mask, mutation, X[k])
+
+            # mutation operator
+            # polynomial mutation operator
+            r = self.random_state.random(n_var)
+            delta = np.where(
+                self.random_state.random(n_var) < 0.5,
+                np.power(2*r, 1/(1+self._eta)) - 1,  # First perturbation formula
+                1 - np.power(2-2*r, 1/(1+self._eta))  # Alternative perturbation formula
+            )
+            perturb_mask = self.random_state.random(n_var) < (1/n_var)  # self._pm
+            V[perturb_mask] += delta[perturb_mask] * (xu[perturb_mask] - xl[perturb_mask])
+
+            # Step 2.3 Repair: If an element is out of the boundary, its value is reset to be a randomly selected value inside the boundary.
+            # Ensure solution stays within bounds
+            V = np.clip(V, xl, xu)
+
+            # Individual
+            off = Population.new(X=np.array([V]))[0]
+
+            # evaluate the offspring
+            off = yield off
+
+            # Step 2.4 Update
+            # update the ideal point
+            self.ideal = np.min(np.vstack([self.ideal, off.F]), axis=0)
+
+            # Step 2.5 Update of Solutions
+            # It is worth noting that there is a distinct modification in line 28 compared with the original framework of MOEA/D-DE.
+            # The newly generated solution competes with each member from the corresponding mating neighborhood (denoted as Pool in Algorithm 2).
+            # But in the original MOEA/D-DE framework, it only competes with two members from the corresponding mating neighborhood.
+            # This modification expands the replacement neighborhood to enhance the exploitation capability that is extremely important in dealing with DMOPs.
+            # now actually do the replacement of the individual is better
+            self._replace(k, off)