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

pydmoo/algorithms/base/core/genetic.py

@@ -92,7 +92,7 @@ class GeneticAlgorithm(Algorithm):
                                         random_state=self.random_state, algorithm=self, **kwargs)
 
     def _infill(self):
-        # Added by DynOpt on Dec 21, 2025
+        # Added by DynOpt Team on Dec 21, 2025
         pop = self._infill_static_dynamic()
 
         # do the mating using the current population
@@ -110,7 +110,7 @@ class GeneticAlgorithm(Algorithm):
 
         return off
 
-    # Added by DynOpt on Dec 21, 2025
+    # Added by DynOpt Team on Dec 21, 2025
     def _infill_static_dynamic(self):
         pop = self.pop
 

pydmoo/algorithms/base/dmoo/dmoead.py

@@ -52,7 +52,7 @@ class DMOEAD(MOEAD):
 
                 start_time = time.time()
 
-                pop = self._response_change()
+                pop = self._response_mechanism()
 
                 # reevaluate because we know there was a change
                 self.evaluator.eval(self.problem, pop)
@@ -69,8 +69,9 @@ class DMOEAD(MOEAD):
 
         return pop
 
-    def _response_change(self):
-        pass
+    def _response_mechanism(self):
+        """Response mechanism."""
+        raise NotImplementedError
 
 
 class DMOEADA(DMOEAD):
@@ -86,7 +87,8 @@ class DMOEADA(DMOEAD):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 
@@ -115,7 +117,8 @@ class DMOEADB(DMOEAD):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/base/dmoo/dmoeadde.py

@@ -52,7 +52,7 @@ class DMOEADDE(MOEADDE):
 
                 start_time = time.time()
 
-                pop = self._response_change()
+                pop = self._response_mechanism()
 
                 # reevaluate because we know there was a change
                 self.evaluator.eval(self.problem, pop)
@@ -69,8 +69,9 @@ class DMOEADDE(MOEADDE):
 
         return pop
 
-    def _response_change(self):
-        pass
+    def _response_mechanism(self):
+        """Response mechanism."""
+        raise NotImplementedError
 
 
 class DMOEADDEA(DMOEADDE):
@@ -86,7 +87,8 @@ class DMOEADDEA(DMOEADDE):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 
@@ -115,7 +117,8 @@ class DMOEADDEB(DMOEADDE):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/base/dmoo/dnsga2.py

@@ -59,7 +59,7 @@ class DNSGA2(NSGA2):
 
             start_time = time.time()
 
-            pop = self._response_change()
+            pop = self._response_mechanism()
 
             # reevaluate because we know there was a change
             self.evaluator.eval(self.problem, pop)
@@ -75,8 +75,9 @@ class DNSGA2(NSGA2):
 
         return pop
 
-    def _response_change(self):
-        pass
+    def _response_mechanism(self):
+        """Response mechanism."""
+        raise NotImplementedError
 
 
 class DNSGA2A(DNSGA2):
@@ -92,7 +93,8 @@ class DNSGA2A(DNSGA2):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 
@@ -121,7 +123,8 @@ class DNSGA2B(DNSGA2):
 
         self.perc_diversity = perc_diversity
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/base/moo/moead.py

@@ -105,6 +105,7 @@ class MOEAD(LoopwiseAlgorithm, GeneticAlgorithm):
         self.ideal = np.min(self.pop.get("F"), axis=0)
 
     def _next(self):
+        # Added by DynOpt Team on Dec 21, 2025
         pop = self._next_static_dynamic()
 
         # iterate for each member of the population in random order
@@ -124,7 +125,7 @@ class MOEAD(LoopwiseAlgorithm, GeneticAlgorithm):
             # now actually do the replacement of the individual is better
             self._replace(k, off)
 
-    # Added by DynOpt on Dec 21, 2025
+    # Added by DynOpt Team on Dec 21, 2025
     def _next_static_dynamic(self):
         pop = self.pop
 

pydmoo/algorithms/classic/moead_ae.py

@@ -0,0 +1,77 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.dmoo.dmoead import DMOEAD
+from pydmoo.core.inverse import closed_form_solution
+
+
+class MOEADAE(DMOEAD):
+    """Autoencoding.
+
+    References
+    ----------
+    Feng, L., Zhou, W., Liu, W., Ong, Y.-S., and Tan, K. C. (2022).
+    Solving dynamic multiobjective problem via autoencoding evolutionary search.
+    IEEE Transactions on Cybernetics, 52(5), 2649–2662.
+    https://doi.org/10.1109/TCYB.2020.3017017
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # predict via denoising autoencoding
+        PSs = self.data.get("PSs", [])
+        PSs.append(self.opt.get("X"))  # Parate Set
+        PSs = PSs[-2:]
+        self.data["PSs"] = PSs
+
+        a = 0
+        if len(PSs) == 2:
+            # Pareto Set
+            P, Q = PSs
+
+            # Q = PM
+            min_len = min(len(P), len(Q))
+            M = closed_form_solution(Q[:min_len], P[:min_len])
+
+            # X = QM
+            X = np.dot(Q, M)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+            # evalutate new population
+            samples = self.evaluator.eval(self.problem, Population.new(X=X))
+            a = min(int(self.pop_size / 2), len(samples))
+
+            # do a survival to recreate rank and crowding of all individuals
+            samples = RankAndCrowding().do(self.problem, samples, n_survive=a, random_state=self.random_state)
+
+            pop[:a] = samples[:a]
+
+        # randomly select solutions from previous Parate Set
+        # This is to, first, preserve the high-quality solutions found along the evolutionary search process
+        # second, to maintain the diversity of the population for further exploration of the evolutionary search.
+        Q = self.opt.get("X")  # no-dominated solutions
+        b = min(int(self.pop_size / 2), len(Q))
+        idx = self.random_state.choice(np.arange(len(Q)), size=b)
+        pop[a:(a + b)] = Population.new(X=Q[idx])
+
+        # randomly generated solutions will be used to fill the population
+        c = self.pop_size - a - b
+        if c > 0:
+            pop[(a + b):(a + b + c)] = self.initialization.sampling(self.problem, c, random_state=self.random_state)
+
+        return pop

pydmoo/algorithms/classic/moead_pps.py

@@ -0,0 +1,94 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.base.dmoo.dmoead import DMOEAD
+from pydmoo.core.ar_model import ARModel
+from pydmoo.core.bounds import matrix_conditional_update
+from pydmoo.core.manifold import manifold_prediction
+
+
+class MOEADPPS(DMOEAD):
+    """Population Prediction Strategy (Center point prediction and manifold prediction).
+
+    References
+    ----------
+    Zhou, A., Jin, Y., and Zhang, Q. (2014).
+    A population prediction strategy for evolutionary dynamic multiobjective optimization.
+    IEEE Transactions on Cybernetics, 44(1), 40–53.
+    https://doi.org/10.1109/TCYB.2013.2245892
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.p = 3  # the order of the AR model
+        self.M = 23  # the length of history mean point series
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # archive center points
+        center_points = self.data.get("center_points", [])
+        center_points.append(np.mean(self.opt.get("X"), axis=0))
+
+        # the maximum length
+        center_points = center_points[(-self.M):]
+        self.data["center_points"] = center_points
+
+        # archive populations
+        Xs = self.data.get("Xs", [])
+        Xs.append(self.pop.get("X"))  # pop
+        Xs = Xs[-2:]
+        self.data["Xs"] = Xs
+
+        if len(center_points) >= (self.p + 1):
+
+            C1, distance = manifold_prediction(Xs[0], Xs[1])
+            n = C1.shape[1]  # Dimensionality of the manifold
+            variance = (distance ** 2) / n
+
+            center, variances = self.center_points_prediction(center_points)
+
+            X = center + C1 + self.random_state.normal(loc=0, scale=np.sqrt(variances + variance), size=X.shape)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = matrix_conditional_update(X, xl, xu, self.pop.get("X"))
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+        else:
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+            # randomly sample half of the population and reuse half from the previous search
+            # when the history information is not enough to build an AR(p) model.
+
+            # randomly sample half of the population
+            a = int(self.pop_size / 2)
+            pop[:a] = self.initialization.sampling(self.problem, a, random_state=self.random_state)
+
+            # randomly reuse the other half from t Population
+            Q = self.pop.get("X")
+            b = self.pop_size - a
+            idx = self.random_state.choice(np.arange(len(Q)), size=b)
+            pop[a:] = Population.new(X=Q[idx])
+
+        return pop
+
+    def center_points_prediction(self, center_points):
+        n = len(center_points[0])
+        center = np.zeros(n)
+        variances = np.zeros(n)
+        for i in range(len(center)):
+            data = [c[i] for c in center_points]
+            model = ARModel(self.p).fit(data)
+            predictions = model.predict(data, 1)
+            center[i], variances[i] = predictions[0], np.mean(model.resid_ ** 2)
+        return center, variances

pydmoo/algorithms/classic/moeadde_ae.py

@@ -0,0 +1,77 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.dmoo.dmoeadde import DMOEADDE
+from pydmoo.core.inverse import closed_form_solution
+
+
+class MOEADDEAE(DMOEADDE):
+    """Autoencoding.
+
+    References
+    ----------
+    Feng, L., Zhou, W., Liu, W., Ong, Y.-S., and Tan, K. C. (2022).
+    Solving dynamic multiobjective problem via autoencoding evolutionary search.
+    IEEE Transactions on Cybernetics, 52(5), 2649–2662.
+    https://doi.org/10.1109/TCYB.2020.3017017
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # predict via denoising autoencoding
+        PSs = self.data.get("PSs", [])
+        PSs.append(self.opt.get("X"))  # Parate Set
+        PSs = PSs[-2:]
+        self.data["PSs"] = PSs
+
+        a = 0
+        if len(PSs) == 2:
+            # Pareto Set
+            P, Q = PSs
+
+            # Q = PM
+            min_len = min(len(P), len(Q))
+            M = closed_form_solution(Q[:min_len], P[:min_len])
+
+            # X = QM
+            X = np.dot(Q, M)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+            # evalutate new population
+            samples = self.evaluator.eval(self.problem, Population.new(X=X))
+            a = min(int(self.pop_size / 2), len(samples))
+
+            # do a survival to recreate rank and crowding of all individuals
+            samples = RankAndCrowding().do(self.problem, samples, n_survive=a, random_state=self.random_state)
+
+            pop[:a] = samples[:a]
+
+        # randomly select solutions from previous Parate Set
+        # This is to, first, preserve the high-quality solutions found along the evolutionary search process
+        # second, to maintain the diversity of the population for further exploration of the evolutionary search.
+        Q = self.opt.get("X")  # no-dominated solutions
+        b = min(int(self.pop_size / 2), len(Q))
+        idx = self.random_state.choice(np.arange(len(Q)), size=b)
+        pop[a:(a + b)] = Population.new(X=Q[idx])
+
+        # randomly generated solutions will be used to fill the population
+        c = self.pop_size - a - b
+        if c > 0:
+            pop[(a + b):(a + b + c)] = self.initialization.sampling(self.problem, c, random_state=self.random_state)
+
+        return pop

pydmoo/algorithms/classic/moeadde_pps.py

@@ -0,0 +1,94 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.base.dmoo.dmoeadde import DMOEADDE
+from pydmoo.core.ar_model import ARModel
+from pydmoo.core.bounds import matrix_conditional_update
+from pydmoo.core.manifold import manifold_prediction
+
+
+class MOEADDEPPS(DMOEADDE):
+    """Population Prediction Strategy (Center point prediction and manifold prediction).
+
+    References
+    ----------
+    Zhou, A., Jin, Y., and Zhang, Q. (2014).
+    A population prediction strategy for evolutionary dynamic multiobjective optimization.
+    IEEE Transactions on Cybernetics, 44(1), 40–53.
+    https://doi.org/10.1109/TCYB.2013.2245892
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.p = 3  # the order of the AR model
+        self.M = 23  # the length of history mean point series
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # archive center points
+        center_points = self.data.get("center_points", [])
+        center_points.append(np.mean(self.opt.get("X"), axis=0))
+
+        # the maximum length
+        center_points = center_points[(-self.M):]
+        self.data["center_points"] = center_points
+
+        # archive populations
+        Xs = self.data.get("Xs", [])
+        Xs.append(self.pop.get("X"))  # pop
+        Xs = Xs[-2:]
+        self.data["Xs"] = Xs
+
+        if len(center_points) >= (self.p + 1):
+
+            C1, distance = manifold_prediction(Xs[0], Xs[1])
+            n = C1.shape[1]  # Dimensionality of the manifold
+            variance = (distance ** 2) / n
+
+            center, variances = self.center_points_prediction(center_points)
+
+            X = center + C1 + self.random_state.normal(loc=0, scale=np.sqrt(variances + variance), size=X.shape)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = matrix_conditional_update(X, xl, xu, self.pop.get("X"))
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+        else:
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+            # randomly sample half of the population and reuse half from the previous search
+            # when the history information is not enough to build an AR(p) model.
+
+            # randomly sample half of the population
+            a = int(self.pop_size / 2)
+            pop[:a] = self.initialization.sampling(self.problem, a, random_state=self.random_state)
+
+            # randomly reuse the other half from t Population
+            Q = self.pop.get("X")
+            b = self.pop_size - a
+            idx = self.random_state.choice(np.arange(len(Q)), size=b)
+            pop[a:] = Population.new(X=Q[idx])
+
+        return pop
+
+    def center_points_prediction(self, center_points):
+        n = len(center_points[0])
+        center = np.zeros(n)
+        variances = np.zeros(n)
+        for i in range(len(center)):
+            data = [c[i] for c in center_points]
+            model = ARModel(self.p).fit(data)
+            predictions = model.predict(data, 1)
+            center[i], variances[i] = predictions[0], np.mean(model.resid_ ** 2)
+        return center, variances

pydmoo/algorithms/classic/nsga2_ae.py

@@ -0,0 +1,76 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+from pydmoo.core.inverse import closed_form_solution
+
+
+class NSGA2AE(DNSGA2):
+    """Autoencoding (AE).
+
+    References
+    ----------
+    Feng, L., Zhou, W., Liu, W., Ong, Y.-S., and Tan, K. C. (2022).
+    Solving dynamic multiobjective problem via autoencoding evolutionary search.
+    IEEE Transactions on Cybernetics, 52(5), 2649–2662.
+    https://doi.org/10.1109/TCYB.2020.3017017
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # predict via denoising autoencoding
+        PSs = self.data.get("PSs", [])
+        PSs.append(self.opt.get("X"))  # Parate Set
+        PSs = PSs[-2:]
+        self.data["PSs"] = PSs
+
+        a = 0
+        if len(PSs) == 2:
+            # Pareto Set
+            P, Q = PSs
+
+            # Q = PM
+            min_len = min(len(P), len(Q))
+            M = closed_form_solution(Q[:min_len], P[:min_len])
+
+            # X = QM
+            X = np.dot(Q, M)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+            # evalutate new population
+            samples = self.evaluator.eval(self.problem, Population.new(X=X))
+            a = min(int(self.pop_size / 2), len(samples))
+
+            # do a survival to recreate rank and crowding of all individuals
+            samples = self.survival.do(self.problem, samples, n_survive=a, random_state=self.random_state)
+
+            pop[:a] = samples[:a]
+
+        # randomly select solutions from previous Parate Set
+        # This is to, first, preserve the high-quality solutions found along the evolutionary search process
+        # second, to maintain the diversity of the population for further exploration of the evolutionary search.
+        Q = self.opt.get("X")  # no-dominated solutions
+        b = min(int(self.pop_size / 2), len(Q))
+        idx = self.random_state.choice(np.arange(len(Q)), size=b)
+        pop[a:(a + b)] = Population.new(X=Q[idx])
+
+        # randomly generated solutions will be used to fill the population
+        c = self.pop_size - a - b
+        if c > 0:
+            pop[(a + b):(a + b + c)] = self.initialization.sampling(self.problem, c, random_state=self.random_state)
+
+        return pop

pydmoo/algorithms/classic/nsga2_pps.py

@@ -0,0 +1,94 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+from pydmoo.core.ar_model import ARModel
+from pydmoo.core.bounds import matrix_conditional_update
+from pydmoo.core.manifold import manifold_prediction
+
+
+class NSGA2PPS(DNSGA2):
+    """Population Prediction Strategy (Center point prediction and manifold prediction).
+
+    References
+    ----------
+    Zhou, A., Jin, Y., and Zhang, Q. (2014).
+    A population prediction strategy for evolutionary dynamic multiobjective optimization.
+    IEEE Transactions on Cybernetics, 44(1), 40–53.
+    https://doi.org/10.1109/TCYB.2013.2245892
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.p = 3  # the order of the AR model
+        self.M = 23  # the length of history mean point series
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        # archive center points
+        center_points = self.data.get("center_points", [])
+        center_points.append(np.mean(self.opt.get("X"), axis=0))
+
+        # the maximum length
+        center_points = center_points[(-self.M):]
+        self.data["center_points"] = center_points
+
+        # archive populations
+        Xs = self.data.get("Xs", [])
+        Xs.append(self.pop.get("X"))  # pop
+        Xs = Xs[-2:]
+        self.data["Xs"] = Xs
+
+        if len(center_points) >= (self.p + 1):
+
+            C1, distance = manifold_prediction(Xs[0], Xs[1])
+            n = C1.shape[1]  # Dimensionality of the manifold
+            variance = (distance ** 2) / n
+
+            center, variances = self.center_points_prediction(center_points)
+
+            X = center + C1 + self.random_state.normal(loc=0, scale=np.sqrt(variances + variance), size=X.shape)
+
+            # bounds
+            if self.problem.has_bounds():
+                xl, xu = self.problem.bounds()
+                X = matrix_conditional_update(X, xl, xu, self.pop.get("X"))
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+        else:
+
+            # recreate the current population without being evaluated
+            pop = Population.new(X=X)
+
+            # randomly sample half of the population and reuse half from the previous search
+            # when the history information is not enough to build an AR(p) model.
+
+            # randomly sample half of the population
+            a = int(self.pop_size / 2)
+            pop[:a] = self.initialization.sampling(self.problem, a, random_state=self.random_state)
+
+            # randomly reuse the other half from t Population
+            Q = self.pop.get("X")
+            b = self.pop_size - a
+            idx = self.random_state.choice(np.arange(len(Q)), size=b)
+            pop[a:] = Population.new(X=Q[idx])
+
+        return pop
+
+    def center_points_prediction(self, center_points):
+        n = len(center_points[0])
+        center = np.zeros(n)
+        variances = np.zeros(n)
+        for i in range(len(center)):
+            data = [c[i] for c in center_points]
+            model = ARModel(self.p).fit(data)
+            predictions = model.predict(data, 1)
+            center[i], variances[i] = predictions[0], np.mean(model.resid_ ** 2)
+        return center, variances

pydmoo/algorithms/modern/moead_imkt.py

@@ -19,7 +19,8 @@ class MOEADIMKT(MOEADKTMM):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")