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

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/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/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/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/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/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

pydmoo/problems/dyn.py

@@ -1,10 +1,11 @@
 """
 Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
 
-Sources:
-    - [dyn.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dyn.py)
-
-Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+> Sources:
+>
+> - [dyn.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dyn.py)
+>
+> Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
 """
 
 from abc import ABC
@@ -16,20 +17,66 @@ from pymoo.core.problem import Problem
 
 
 class DynamicProblem(Problem, ABC):
+    """Abstract base class for dynamic optimization problems."""
     pass
 
 
 class DynamicApplProblem(DynamicProblem):
+    """Dynamic optimization problem for real-world applications.
+
+    This class defines dynamic optimization problems that model practical, real-world scenarios where the problem
+    characteristics change systematically over time.
+
+    Parameters
+    ----------
+    nt : int
+        Severity of change. Controls how significantly the problem changes
+        at each change point. Higher values indicate more substantial changes
+        in problem characteristics.
+    taut : int
+        Frequency of change. Specifies how often (in generations) the problem
+        undergoes changes. Lower values mean more frequent changes.
+    t0 : int, optional
+        The first change occurs after t0 generations, by default 50.
+        That is, the generation at which a change occurs is (t0+1), (t0+taut+1), etc.
+        This allows for an initial stabilization period before the first change.
+    tau : int, optional
+        Current simulation time counter (in generations), by default 1.
+    time : float, optional
+        Explicit simulation time value (overrides calculated time), by default None.
+        Used for manual time control in specific scenarios.
+    **kwargs : dict
+        Additional keyword arguments passed to the parent Problem class.
+
+    Attributes
+    ----------
+    tau : int
+        Current simulation time counter in generations.
+    nt : int
+        Severity of change at each change point.
+    taut : int
+        Frequency of change between consecutive changes.
+    t0 : int
+        Initial stabilization period before first change occurs.
+
+    Notes
+    -----
+    This class models real-world dynamic scenarios where:
+
+    - Changes occur at predictable intervals (every `taut` generations)
+    - Change severity is controlled by `nt` parameter
+    - Initial period `t0` allows for system stabilization
+    """
 
-    def __init__(self, nt, taut, t0=50, tau=1, time=None, **kwargs):
+    def __init__(self, nt: int, taut: int, t0: int = 50, tau: int = 1, time: float | None = None, **kwargs):
         super().__init__(**kwargs)
-        self.tau = tau
-        self.nt = nt
-        self.taut = taut
-        self.t0 = t0
+        self.tau = tau  # time counter
+        self.nt = nt  # severity of change
+        self.taut = taut  # frequency of change
+        self.t0 = t0  # Initial time offset
         self._time = time
 
-    def tic(self, elapsed=1):
+    def tic(self, elapsed: int = 1) -> None:
 
         # increase the time counter by one
         self.tau += elapsed
@@ -38,7 +85,7 @@ class DynamicApplProblem(DynamicProblem):
         self.__dict__["cache"] = {}
 
     @property
-    def time(self):
+    def time(self) -> float:
         if self._time is not None:
             return self._time
         else:
@@ -54,7 +101,7 @@ class DynamicApplProblem(DynamicProblem):
             return delta_time * count
 
     @time.setter
-    def time(self, value):
+    def time(self, value: float) -> None:
         self._time = value
 
     def update_to_next_time(self):
@@ -77,12 +124,60 @@ class DynamicApplProblem(DynamicProblem):
 
 
 class DynamicTestProblem(DynamicProblem):
+    """Dynamic optimization problem for testing and benchmarking.
+
+    Parameters
+    ----------
+    nt : int
+        Severity of change. Controls how significantly the problem changes
+        at each change point. Higher values indicate more substantial changes
+        in problem characteristics.
+    taut : int
+        Frequency of change. Specifies how often (in generations) the problem
+        undergoes changes. Lower values mean more frequent changes.
+    t0 : int, optional
+        The first change occurs after t0 generations, by default 50.
+        That is, the generation at which a change occurs is (t0+1), (t0+taut+1), etc.
+        This allows for an initial stabilization period before the first change.
+    tau : int, optional
+        Current simulation time counter (in generations), by default 1.
+    time : float, optional
+        Explicit simulation time value (overrides calculated time), by default None.
+        Used for manual time control in specific scenarios.
+    add_time_perturbation : bool, optional
+        If True, adds perturbations to the time calculation, by default False.
+    **kwargs : dict
+        Additional keyword arguments passed to the parent Problem class.
+
+    Attributes
+    ----------
+    tau : int
+        Current simulation time counter in generations.
+    nt : int
+        Severity of change at each change point.
+    taut : int
+        Frequency of change between consecutive changes.
+    t0 : int
+        Initial stabilization period before first change occurs.
+    add_time_perturbation : bool
+        Flag indicating whether to add stochastic perturbations.
+
+    Notes
+    -----
+    This class is designed for testing scenarios where:
+
+    - Changes occur at predictable intervals (every `taut` generations)
+    - Change severity is controlled by `nt` parameter
+    - Initial period `t0` allows for system stabilization
+    - Stochastic perturbations can be added for more complex testing
+    - Reproducibility is important for benchmarking
+    """
 
     def __init__(self, nt, taut, t0=50, tau=1, time=None, add_time_perturbation=False, **kwargs):
         super().__init__(**kwargs)
-        self.tau = tau
-        self.nt = nt
-        self.taut = taut
+        self.tau = tau  # time counter
+        self.nt = nt  # severity of change
+        self.taut = taut  # frequency of change
         self.t0 = t0  # Initial time offset - added by DynOpt Team
         self._time = time