pydmoo 0.1.0__tar.gz → 0.1.1__tar.gz

{pydmoo-0.1.0 → pydmoo-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydmoo
-Version: 0.1.0
+Version: 0.1.1
 Summary: Dynamic Multi-Objective Optimization in Python (pydmoo).
 Project-URL: Homepage, https://github.com/dynoptimization/pydmoo
 Project-URL: Repository, https://github.com/dynoptimization/pydmoo

pydmoo-0.1.1/docs/index.md

@@ -0,0 +1,7 @@
+# pydmoo
+
+Dynamic Multi-Objective Optimization in Python
+
+This library is built upon the widely used multi-objective optimization framework [pymoo](https://github.com/anyoptimization/pymoo), with a primary focus on **dynamic multi-objective optimization**. Accordingly, the main emphasis here is on **response mechanisms**, while the static multi-objective optimization algorithms are adopted from well-established and widely recognized sources.
+
+---

pydmoo-0.1.1/docs/user-guide/algorithms/algorithms.classic.nsga2_ae.md

@@ -0,0 +1,9 @@
+# algorithms.classic.nsga2_ae
+
+::: pydmoo.algorithms.classic.nsga2_ae
+    options:
+      show_root_heading: false
+      show_submodules: true
+      heading_level: 2
+      show_source: true
+      show_category_heading: true

pydmoo-0.1.1/docs/user-guide/algorithms/algorithms.classic.nsga2_pps.md

@@ -0,0 +1,9 @@
+# algorithms.classic.nsga2_pps
+
+::: pydmoo.algorithms.classic.nsga2_pps
+    options:
+      show_root_heading: false
+      show_submodules: true
+      heading_level: 2
+      show_source: true
+      show_category_heading: true

{pydmoo-0.1.0 → pydmoo-0.1.1}/docs/user-guide/algorithms.md

@@ -1,5 +1,15 @@
 # Algorithms
 
+## Classic Response Mechanisms
+
+- [algorithms.classic.nsga2_ae](algorithms/algorithms.classic.nsga2_ae.md)
+- [algorithms.classic.nsga2_pps](algorithms/algorithms.classic.nsga2_pps.md)
+
+## Knowledge-Based Response Mechanisms
+
 - [algorithms.modern.nsga2_imkt](algorithms/algorithms.modern.nsga2_imkt.md)
+
+## Learning-Based Response Mechanisms
+
 - [algorithms.modern.nsga2_imkt_lstm](algorithms/algorithms.modern.nsga2_imkt_lstm.md)
 - [algorithms.modern.nsga2_imkt_clstm](algorithms/algorithms.modern.nsga2_imkt_clstm.md)

pydmoo-0.1.1/docs/user-guide/index.md

@@ -0,0 +1,34 @@
+# API
+
+## Example
+
+```python
+from pymoo.optimize import minimize
+
+from pydmoo.algorithms.classic.nsga2_ae import NSGA2AE as DMOEA
+from pydmoo.problems import DF1, GTS1
+from pydmoo.problems.dyn import TimeSimulation
+
+
+n_var = 10      # dimension of the decision variable
+t0 = 100        # generations before the first environmental change
+nc = 50         # total number of environmental changes
+nt = 10         # severity of change
+taut = 10       # frequency of change (generations between changes)
+pop_size = 100  # population size
+
+problem = GTS1(n_var=n_var, nt=nt, taut=taut, t0=t0)
+algorithm = DMOEA(pop_size=pop_size)
+
+seed = 2026
+verbose = True
+
+res = minimize(
+    problem,
+    algorithm,
+    termination=("n_gen", taut * nc + t0),
+    callback=TimeSimulation(),
+    seed=seed,
+    verbose=verbose,
+)
+```

pydmoo-0.1.1/docs/user-guide/problems/problems.dyn.md

@@ -0,0 +1,9 @@
+# problems.dyn
+
+::: pydmoo.problems.dyn
+    options:
+      show_root_heading: false
+      show_submodules: true
+      heading_level: 2
+      show_source: true
+      show_category_heading: true

{pydmoo-0.1.0 → pydmoo-0.1.1}/docs/user-guide/problems.md

@@ -1,3 +1,4 @@
 # Problems
 
+- [problems.dyn](problems/problems.dyn.md)
 - [problems.dynamic.gts](problems/problems.dynamic.gts.md)

{pydmoo-0.1.0 → pydmoo-0.1.1}/mkdocs.yml

@@ -12,7 +12,7 @@ repo_url: https://github.com/dynoptimization/pydmoo
 
 # Copyright
 copyright: >-
-  Copyright © 2025 - 2026 DynOpt Team.
+  Copyright © 2026 DynOpt Team.
   All rights reserved.
 
 # Configuration

pydmoo-0.1.1/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_change(self):
+        """Response."""
+        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-0.1.1/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_change(self):
+        """Response."""
+        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-0.1.1/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_change(self):
+        """Response."""
+        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-0.1.1/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_change(self):
+        """Response."""
+        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-0.1.1/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_change(self):
+        """Response."""
+        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-0.1.1/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_change(self):
+        """Response."""
+        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