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

pydmoo/algorithms/classic/nsga2_ae.py

@@ -20,8 +20,8 @@ class NSGA2AE(DNSGA2):
 
         super().__init__(**kwargs)
 
-    def _response_change(self):
-        """Response."""
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/classic/nsga2_pps.py

@@ -25,8 +25,8 @@ class NSGA2PPS(DNSGA2):
         self.p = 3  # the order of the AR model
         self.M = 23  # the length of history mean point series
 
-    def _response_change(self):
-        """Response."""
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/learning/moead_tr.py

@@ -0,0 +1,98 @@
+import copy
+
+import numpy as np
+from pymoo.core.population import Population
+from scipy.optimize import Bounds, minimize
+
+from pydmoo.algorithms.base.dmoo.dmoead import DMOEAD
+from pydmoo.core.transfer import TCA
+
+
+class MOEADTr(DMOEAD):
+    """Transfer learning (Tr).
+
+    Transfer Learning-based Initial Population Generator (Tr-IPG)
+
+    References
+    ----------
+    Jiang, M., Huang, Z., Qiu, L., Huang, W., and Yen, G. G. (2018).
+    Transfer learning-based dynamic multiobjective optimization algorithms.
+    IEEE Transactions on Evolutionary Computation, 22(4), 501–514.
+    https://doi.org/10.1109/TEVC.2017.2771451
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.ndim_ls = 20  # the dimension of latent space
+        self.mu = 0.5
+
+        #
+        self._maxiter = max(self.pop_size, 100)  # default is 1000
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X, F = pop.get("X", "F")
+
+        last_time = self.data.get("last_time", 0)
+        self.data["last_time"] = self.problem.time
+
+        # source domain
+        problem_ = copy.deepcopy(self.problem)
+        problem_.time = last_time
+        pop_s = self.initialization.sampling(problem_, self.pop_size, random_state=self.random_state)
+        pop_s = self.evaluator.eval(problem_, pop_s)
+
+        # target domain
+        pop_t = self.initialization.sampling(self.problem, self.pop_size, random_state=self.random_state)
+        pop_t = self.evaluator.eval(self.problem, pop_t)
+
+        # Algorithm 1: TCA
+        model = TCA(dim=self.ndim_ls, mu=self.mu)
+        model.fit(pop_s.get("F"), pop_t.get("F"))
+
+        # Remark3
+        particles_latent_saace = model.transform(self.opt.get("F"))
+
+        def dist_px(p, x, xl, xu):
+            x = np.clip(x, xl, xu)
+            pop_temp = Population.new(X=[x])
+            pop_temp = self.evaluator.eval(self.problem, pop_temp)
+            F = pop_temp.get("F")
+            return np.sum((model.transform(F) - p) ** 2)
+
+        X_ = []
+        xl, xu = self.problem.bounds()
+        for particle in particles_latent_saace:
+            start = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+            start = np.clip(start, xl, xu)
+
+            try:
+                res = minimize(
+                    lambda x: dist_px(particle, x, xl, xu),
+                    start,
+                    bounds=Bounds(xl, xu),
+                    method="trust-constr",  # SLSQP, trust-constr, L-BFGS-B; In this paper, we use the interior point algorithm to solve the problem.
+                    options={
+                        "maxiter": self._maxiter,
+                    },
+                )
+                x_opt = np.clip(res.x, xl, xu)
+                X_.append(x_opt)
+
+            except Exception as e:
+                random_point = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+                X_.append(np.clip(random_point, xl, xu))
+
+        # bounds
+        X_ = np.array(X_)
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X_ = np.clip(X_, xl, xu)  # not provided in the original reference literature
+
+        # recreate the current population without being evaluated
+        # merge
+        pop = Population.merge(pop_t, Population.new(X=X_))
+
+        return pop

pydmoo/algorithms/learning/moeadde_tr.py

@@ -0,0 +1,98 @@
+import copy
+
+import numpy as np
+from pymoo.core.population import Population
+from scipy.optimize import Bounds, minimize
+
+from pydmoo.algorithms.base.dmoo.dmoeadde import DMOEADDE
+from pydmoo.core.transfer import TCA
+
+
+class MOEADDETr(DMOEADDE):
+    """Transfer learning (Tr).
+
+    Transfer Learning-based Initial Population Generator (Tr-IPG)
+
+    References
+    ----------
+    Jiang, M., Huang, Z., Qiu, L., Huang, W., and Yen, G. G. (2018).
+    Transfer learning-based dynamic multiobjective optimization algorithms.
+    IEEE Transactions on Evolutionary Computation, 22(4), 501–514.
+    https://doi.org/10.1109/TEVC.2017.2771451
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.ndim_ls = 20  # the dimension of latent space
+        self.mu = 0.5
+
+        #
+        self._maxiter = max(self.pop_size, 100)  # default is 1000
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X, F = pop.get("X", "F")
+
+        last_time = self.data.get("last_time", 0)
+        self.data["last_time"] = self.problem.time
+
+        # source domain
+        problem_ = copy.deepcopy(self.problem)
+        problem_.time = last_time
+        pop_s = self.initialization.sampling(problem_, self.pop_size, random_state=self.random_state)
+        pop_s = self.evaluator.eval(problem_, pop_s)
+
+        # target domain
+        pop_t = self.initialization.sampling(self.problem, self.pop_size, random_state=self.random_state)
+        pop_t = self.evaluator.eval(self.problem, pop_t)
+
+        # Algorithm 1: TCA
+        model = TCA(dim=self.ndim_ls, mu=self.mu)
+        model.fit(pop_s.get("F"), pop_t.get("F"))
+
+        # Remark3
+        particles_latent_saace = model.transform(self.opt.get("F"))
+
+        def dist_px(p, x, xl, xu):
+            x = np.clip(x, xl, xu)
+            pop_temp = Population.new(X=[x])
+            pop_temp = self.evaluator.eval(self.problem, pop_temp)
+            F = pop_temp.get("F")
+            return np.sum((model.transform(F) - p) ** 2)
+
+        X_ = []
+        xl, xu = self.problem.bounds()
+        for particle in particles_latent_saace:
+            start = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+            start = np.clip(start, xl, xu)
+
+            try:
+                res = minimize(
+                    lambda x: dist_px(particle, x, xl, xu),
+                    start,
+                    bounds=Bounds(xl, xu),
+                    method="trust-constr",  # SLSQP, trust-constr, L-BFGS-B; In this paper, we use the interior point algorithm to solve the problem.
+                    options={
+                        "maxiter": self._maxiter,
+                    },
+                )
+                x_opt = np.clip(res.x, xl, xu)
+                X_.append(x_opt)
+
+            except Exception as e:
+                random_point = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+                X_.append(np.clip(random_point, xl, xu))
+
+        # bounds
+        X_ = np.array(X_)
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X_ = np.clip(X_, xl, xu)  # not provided in the original reference literature
+
+        # recreate the current population without being evaluated
+        # merge
+        pop = Population.merge(pop_t, Population.new(X=X_))
+
+        return pop

pydmoo/algorithms/learning/nsga2_tr.py

@@ -0,0 +1,98 @@
+import copy
+
+import numpy as np
+from pymoo.core.population import Population
+from scipy.optimize import Bounds, minimize
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+from pydmoo.core.transfer import TCA
+
+
+class NSGA2Tr(DNSGA2):
+    """Transfer learning (Tr).
+
+    Transfer Learning-based Initial Population Generator (Tr-IPG)
+
+    References
+    ----------
+    Jiang, M., Huang, Z., Qiu, L., Huang, W., and Yen, G. G. (2018).
+    Transfer learning-based dynamic multiobjective optimization algorithms.
+    IEEE Transactions on Evolutionary Computation, 22(4), 501–514.
+    https://doi.org/10.1109/TEVC.2017.2771451
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.ndim_ls = 20  # the dimension of latent space
+        self.mu = 0.5
+
+        #
+        self._maxiter = max(self.pop_size, 100)  # default is 1000
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X, F = pop.get("X", "F")
+
+        last_time = self.data.get("last_time", 0)
+        self.data["last_time"] = self.problem.time
+
+        # source domain
+        problem_ = copy.deepcopy(self.problem)
+        problem_.time = last_time
+        pop_s = self.initialization.sampling(problem_, self.pop_size, random_state=self.random_state)
+        pop_s = self.evaluator.eval(problem_, pop_s)
+
+        # target domain
+        pop_t = self.initialization.sampling(self.problem, self.pop_size, random_state=self.random_state)
+        pop_t = self.evaluator.eval(self.problem, pop_t)
+
+        # Algorithm 1: TCA
+        model = TCA(dim=self.ndim_ls, mu=self.mu)
+        model.fit(pop_s.get("F"), pop_t.get("F"))
+
+        # Remark3
+        particles_latent_saace = model.transform(self.opt.get("F"))
+
+        def dist_px(p, x, xl, xu):
+            x = np.clip(x, xl, xu)
+            pop_temp = Population.new(X=[x])
+            pop_temp = self.evaluator.eval(self.problem, pop_temp)
+            F = pop_temp.get("F")
+            return np.sum((model.transform(F) - p) ** 2)
+
+        X_ = []
+        xl, xu = self.problem.bounds()
+        for particle in particles_latent_saace:
+            start = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+            start = np.clip(start, xl, xu)
+
+            try:
+                res = minimize(
+                    lambda x: dist_px(particle, x, xl, xu),
+                    start,
+                    bounds=Bounds(xl, xu),
+                    method="trust-constr",  # SLSQP, trust-constr, L-BFGS-B; In this paper, we use the interior point algorithm to solve the problem.
+                    options={
+                        "maxiter": self._maxiter,
+                    },
+                )
+                x_opt = np.clip(res.x, xl, xu)
+                X_.append(x_opt)
+
+            except Exception as e:
+                random_point = self.initialization.sampling(self.problem, 1, random_state=self.random_state).get("X")[0]
+                X_.append(np.clip(random_point, xl, xu))
+
+        # bounds
+        X_ = np.array(X_)
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X_ = np.clip(X_, xl, xu)  # not provided in the original reference literature
+
+        # recreate the current population without being evaluated
+        # merge
+        pop = Population.merge(pop_t, Population.new(X=X_))
+
+        return pop

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")
 

pydmoo/algorithms/modern/moead_imkt_igp.py

@@ -16,7 +16,8 @@ class MOEADIMKTIGP(MOEADIMKT):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moead_imkt_lstm.py

@@ -42,7 +42,8 @@ class MOEADIMLSTM(MOEADIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moead_imkt_n.py

@@ -19,7 +19,8 @@ class MOEADIMKTN(MOEADIMKT):
         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")
 

pydmoo/algorithms/modern/moead_imkt_n_igp.py

@@ -16,7 +16,8 @@ class MOEADIMKTNIGP(MOEADIMKTN):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moead_imkt_n_lstm.py

@@ -43,7 +43,8 @@ class MOEADIMNLSTM(MOEADIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moead_ktmm.py

@@ -22,7 +22,8 @@ class MOEADKTMM(DMOEAD):
         self.size_pool = 14  # the size of knowledge pool
         self.denominator = 0.5
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt.py

@@ -19,7 +19,8 @@ class MOEADDEIMKT(MOEADDEKTMM):
         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")
 

pydmoo/algorithms/modern/moeadde_imkt_clstm.py

@@ -36,7 +36,8 @@ class MOEADDEIMcLSTM(MOEADDEIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt_igp.py

@@ -16,7 +16,8 @@ class MOEADDEIMKTIGP(MOEADDEIMKT):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt_lstm.py

@@ -42,7 +42,8 @@ class MOEADDEIMLSTM(MOEADDEIMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt_n.py

@@ -19,7 +19,8 @@ class MOEADDEIMKTN(MOEADDEIMKT):
         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")
 

pydmoo/algorithms/modern/moeadde_imkt_n_clstm.py

@@ -37,7 +37,8 @@ class MOEADDEIMNcLSTM(MOEADDEIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt_n_igp.py

@@ -16,7 +16,8 @@ class MOEADDEIMKTNIGP(MOEADDEIMKTN):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_imkt_n_lstm.py

@@ -43,7 +43,8 @@ class MOEADDEIMNLSTM(MOEADDEIMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/moeadde_ktmm.py

@@ -22,7 +22,8 @@ class MOEADDEKTMM(DMOEADDE):
         self.size_pool = 14  # the size of knowledge pool
         self.denominator = 0.5
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt.py

@@ -19,7 +19,8 @@ class NSGA2IMKT(NSGA2KTMM):
         self.size_pool = 10
         self.denominator = 0.5
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         """Inverse Modeling with Knowledge Transfer."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/modern/nsga2_imkt_clstm.py

@@ -36,7 +36,8 @@ class NSGA2IMcLSTM(NSGA2IMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt_igp.py

@@ -16,7 +16,8 @@ class NSGA2IMKTIGP(NSGA2IMKT):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt_lstm.py

@@ -41,7 +41,8 @@ class NSGA2IMLSTM(NSGA2IMKT):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt_n.py

@@ -19,7 +19,8 @@ class NSGA2IMKTN(NSGA2IMKT):
         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")
 

pydmoo/algorithms/modern/nsga2_imkt_n_clstm.py

@@ -37,7 +37,8 @@ class NSGA2IMNcLSTM(NSGA2IMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt_n_igp.py

@@ -16,7 +16,8 @@ class NSGA2IMKTNIGP(NSGA2IMKTN):
         self.sigma_n = 0.01
         self.sigma_n_2 = self.sigma_n ** 2
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_imkt_n_lstm.py

@@ -42,7 +42,8 @@ class NSGA2IMNLSTM(NSGA2IMKTN):
             incremental_learning=self._incremental_learning,
         )
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/algorithms/modern/nsga2_ktmm.py

@@ -22,7 +22,8 @@ class NSGA2KTMM(DNSGA2):
         self.size_pool = 14  # the size of knowledge pool
         self.denominator = 0.5
 
-    def _response_change(self):
+    def _response_mechanism(self):
+        """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
 

pydmoo/problems/dyn.py

@@ -193,6 +193,34 @@ class DynamicTestProblem(DynamicProblem):
 
     @property
     def time(self):
+        r"""Time.
+
+        Notes
+        -----
+        The discrete time $t$ is defined as follows:
+
+        \begin{equation}
+            t = \frac{1}{n_t} \left\lfloor \frac{\tau}{\tau_t} \right\rfloor + \frac{1}{n_t} \left(0.5 \times \frac{\pi_{\tau}}{9}\right), \ \tau = 0, 1, 2, \dots
+        \end{equation}
+
+        Here, $\pi_{\tau}$ is given by:
+
+        \begin{equation}
+            \pi_{\tau} =
+            \begin{cases}
+                0,                                                                                          & \text{if } \left\lfloor \frac{\tau}{\tau_t} \right\rfloor = 0, \\
+                \text{the } \left\lfloor \frac{\tau}{\tau_t} \right\rfloor\text{-th decimal digit of } \pi, & \text{otherwise.}
+            \end{cases}
+        \end{equation}
+
+        This formulation introduces a dynamic environment with an irregular change pattern. When $\pi_{\tau} = 0$, the time variation reduces to the commonly used form with a regular change pattern:
+
+        \begin{equation} \label{eq:time_regular}
+            t = \frac{1}{n_t} \left\lfloor \frac{\tau}{\tau_t} \right\rfloor, \ \tau = 0, 1, 2, \dots
+        \end{equation}
+
+        In the above expressions, $\tau$ denotes the generation counter, $n_t$ controls the severity of change, and $\tau_t$ represents the number of generations per time step.
+        """
         if self._time is not None:
             return self._time
         else:

{pydmoo-0.1.1.dist-info → pydmoo-0.1.3.dist-info}/METADATA

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