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

pydmoo/algorithms/base/dmoo/dmoead.py

@@ -8,7 +8,21 @@ from pydmoo.algorithms.base.moo.moead import MOEAD
 
 
 class DMOEAD(MOEAD):
-
+    """
+    Dynamic MOEA/D (DMOEAD).
+
+    Extension of MOEAD for dynamic optimization problems.
+
+    Parameters
+    ----------
+    perc_detect_change : float, default=0.1
+        Percentage of population to sample for change detection (0 to 1).
+    eps : float, default=0.0
+        Threshold for change detection. Change is detected when mean squared
+        difference exceeds this value.
+    **kwargs
+        Additional arguments passed to MOEAD parent class.
+    """
     def __init__(self,
                  perc_detect_change=0.1,
                  eps=0.0,
@@ -22,7 +36,15 @@ class DMOEAD(MOEAD):
         assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
         return super().setup(problem, **kwargs)
 
-    def _detect_change_sample_part_population(self):
+    def _detect_change_sample_part_population(self) -> bool:
+        """
+        Detect environmental changes by sampling part of the population.
+
+        Returns
+        -------
+        change_detected : bool
+            True if environmental change is detected, False otherwise.
+        """
         pop = self.pop
         X, F = pop.get("X", "F")
 
@@ -40,7 +62,15 @@ class DMOEAD(MOEAD):
         change_detected = delta > self.eps
         return change_detected
 
-    def _next_static_dynamic(self):
+    def _next_static_dynamic(self) -> Population:
+        """
+        Perform next with dynamic change detection and response.
+
+        Returns
+        -------
+        Population
+            Current population after potential response to environmental change.
+        """
         # for dynamic environment
         pop = self.pop
 
@@ -70,11 +100,24 @@ class DMOEAD(MOEAD):
         return pop
 
     def _response_mechanism(self):
-        """Response mechanism."""
+        """
+        Response mechanism for environmental change.
+
+        Returns
+        -------
+        Population
+            Population after applying response strategy.
+
+        Raises
+        ------
+        NotImplementedError
+            Must be implemented by subclasses.
+        """
         raise NotImplementedError
 
 
 class DMOEADA(DMOEAD):
+    """DMOEADA."""
 
     def __init__(self,
                  perc_detect_change=0.1,
@@ -105,6 +148,7 @@ class DMOEADA(DMOEAD):
 
 
 class DMOEADB(DMOEAD):
+    """DMOEADB."""
 
     def __init__(self,
                  perc_detect_change=0.1,

pydmoo/algorithms/base/dmoo/dmoeadde.py

@@ -8,6 +8,21 @@ from pydmoo.algorithms.base.moo.moeadde import MOEADDE
 
 
 class DMOEADDE(MOEADDE):
+    """
+    Dynamic MOEA/D-DE (DMOEADDE).
+
+    Extension of MOEADDE for dynamic optimization problems.
+
+    Parameters
+    ----------
+    perc_detect_change : float, default=0.1
+        Percentage of population to sample for change detection (0 to 1).
+    eps : float, default=0.0
+        Threshold for change detection. Change is detected when mean squared
+        difference exceeds this value.
+    **kwargs
+        Additional arguments passed to MOEADDE parent class.
+    """
 
     def __init__(self,
                  perc_detect_change=0.1,
@@ -22,7 +37,15 @@ class DMOEADDE(MOEADDE):
         assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
         return super().setup(problem, **kwargs)
 
-    def _detect_change_sample_part_population(self):
+    def _detect_change_sample_part_population(self) -> bool:
+        """
+        Detect environmental changes by sampling part of the population.
+
+        Returns
+        -------
+        change_detected : bool
+            True if environmental change is detected, False otherwise.
+        """
         pop = self.pop
         X, F = pop.get("X", "F")
 
@@ -40,7 +63,15 @@ class DMOEADDE(MOEADDE):
         change_detected = delta > self.eps
         return change_detected
 
-    def _next_static_dynamic(self):
+    def _next_static_dynamic(self) -> Population:
+        """
+        Perform next with dynamic change detection and response.
+
+        Returns
+        -------
+        Population
+            Current population after potential response to environmental change.
+        """
         # for dynamic environment
         pop = self.pop
 
@@ -69,12 +100,25 @@ class DMOEADDE(MOEADDE):
 
         return pop
 
-    def _response_mechanism(self):
-        """Response mechanism."""
+    def _response_mechanism(self) -> Population:
+        """
+        Response mechanism for environmental change.
+
+        Returns
+        -------
+        Population
+            Population after applying response strategy.
+
+        Raises
+        ------
+        NotImplementedError
+            Must be implemented by subclasses.
+        """
         raise NotImplementedError
 
 
 class DMOEADDEA(DMOEADDE):
+    """DMOEADDEA."""
 
     def __init__(self,
                  perc_detect_change=0.1,
@@ -105,6 +149,7 @@ class DMOEADDEA(DMOEADDE):
 
 
 class DMOEADDEB(DMOEADDE):
+    """DMOEADDEB."""
 
     def __init__(self,
                  perc_detect_change=0.1,

pydmoo/algorithms/base/dmoo/dnsga2.py

@@ -17,10 +17,25 @@ from pydmoo.algorithms.base.moo.nsga2 import NSGA2
 
 
 class DNSGA2(NSGA2):
+    """
+    Dynamic Non-dominated Sorting Genetic Algorithm II (DNSGA2).
+
+    Extension of NSGA2 for dynamic optimization problems.
+
+    Parameters
+    ----------
+    perc_detect_change : float, default=0.1
+        Percentage of population to sample for change detection (0 to 1).
+    eps : float, default=0.0
+        Threshold for change detection. Change is detected when mean squared
+        difference exceeds this value.
+    **kwargs
+        Additional arguments passed to NSGA2 parent class.
+    """
 
     def __init__(self,
-                 perc_detect_change=0.1,
-                 eps=0.0,
+                 perc_detect_change: float = 0.1,
+                 eps: float = 0.0,
                  **kwargs):
 
         super().__init__(**kwargs)
@@ -31,7 +46,15 @@ class DNSGA2(NSGA2):
         assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
         return super().setup(problem, **kwargs)
 
-    def _detect_change_sample_part_population(self):
+    def _detect_change_sample_part_population(self) -> bool:
+        """
+        Detect environmental changes by sampling part of the population.
+
+        Returns
+        -------
+        change_detected : bool
+            True if environmental change is detected, False otherwise.
+        """
         pop = self.pop
         X, F = pop.get("X", "F")
 
@@ -49,7 +72,15 @@ class DNSGA2(NSGA2):
         change_detected = delta > self.eps
         return change_detected
 
-    def _infill_static_dynamic(self):
+    def _infill_static_dynamic(self) -> Population:
+        """
+        Perform infill with dynamic change detection and response.
+
+        Returns
+        -------
+        Population
+            Current population after potential response to environmental change.
+        """
         # for dynamic environment
         pop = self.pop
 
@@ -75,17 +106,39 @@ class DNSGA2(NSGA2):
 
         return pop
 
-    def _response_mechanism(self):
-        """Response mechanism."""
+    def _response_mechanism(self) -> Population:
+        """
+        Response mechanism for environmental change.
+
+        Returns
+        -------
+        Population
+            Population after applying response strategy.
+
+        Raises
+        ------
+        NotImplementedError
+            Must be implemented by subclasses.
+        """
         raise NotImplementedError
 
 
 class DNSGA2A(DNSGA2):
+    """DNSGA2A.
+
+    References
+    ----------
+    Deb, K., Rao N., U. B., and Karthik, S. (2007).
+    Dynamic multi-objective optimization and decision-making using modified NSGA-II:
+        A case study on hydro-thermal power scheduling.
+    Evolutionary Multi-Criterion Optimization, 803–817.
+    https://doi.org/10.1007/978-3-540-70928-2_60
+    """
 
     def __init__(self,
-                 perc_detect_change=0.1,
-                 eps=0.0,
-                 perc_diversity=0.3,
+                 perc_detect_change: float = 0.1,
+                 eps: float = 0.0,
+                 perc_diversity: float = 0.3,
                  **kwargs):
         super().__init__(perc_detect_change=perc_detect_change,
                          eps=eps,
@@ -93,7 +146,7 @@ class DNSGA2A(DNSGA2):
 
         self.perc_diversity = perc_diversity
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")
@@ -111,11 +164,21 @@ class DNSGA2A(DNSGA2):
 
 
 class DNSGA2B(DNSGA2):
+    """DNSGA2B.
+
+    References
+    ----------
+    Deb, K., Rao N., U. B., and Karthik, S. (2007).
+    Dynamic multi-objective optimization and decision-making using modified NSGA-II:
+        A case study on hydro-thermal power scheduling.
+    Evolutionary Multi-Criterion Optimization, 803–817.
+    https://doi.org/10.1007/978-3-540-70928-2_60
+    """
 
     def __init__(self,
-                 perc_detect_change=0.1,
-                 eps=0.0,
-                 perc_diversity=0.3,
+                 perc_detect_change: float = 0.1,
+                 eps: float = 0.0,
+                 perc_diversity: float = 0.3,
                  **kwargs):
         super().__init__(perc_detect_change=perc_detect_change,
                          eps=eps,
@@ -123,7 +186,7 @@ class DNSGA2B(DNSGA2):
 
         self.perc_diversity = perc_diversity
 
-    def _response_mechanism(self):
+    def _response_mechanism(self) -> Population:
         """Response mechanism."""
         pop = self.pop
         X = pop.get("X")

pydmoo/algorithms/base/moo/moeadde.py

@@ -7,13 +7,18 @@ from pydmoo.algorithms.base.moo.moead import MOEAD
 
 
 class MOEADDE(MOEAD):
-    """MOEA/D-DE (Updated by Cao).
-
-    It is worth noting that there is a distinct modification in line 28 compared with the original framework of MOEA/D-DE.
-    The newly generated solution competes with each member from the corresponding mating neighborhood (denoted as Pool in Algorithm 2).
-    But in the original MOEA/D-DE framework, it only competes with two members from the corresponding mating neighborhood.
-    This modification expands the replacement neighborhood to enhance the exploitation capability that is extremely important in dealing with DMOPs.
-
+    """MOEA/D-DE.
+
+    Notes
+    -----
+    It is worth noting that there is a distinct modification in line 28 compared with the original framework of
+    MOEA/D-DE. The newly generated solution competes with each member from the corresponding mating neighborhood
+    (denoted as Pool in Algorithm 2). But in the original MOEA/D-DE framework, it only competes with two members from
+    the corresponding mating neighborhood. This modification expands the replacement neighborhood to enhance the
+    exploitation capability that is extremely important in dealing with DMOPs (Cao et al., 2020).
+
+    References
+    ----------
     Cao, L., Xu, L., Goodman, E. D., Bao, C., and Zhu, S. (2020).
     Evolutionary dynamic multiobjective optimization assisted by a support vector regression predictor.
     IEEE Transactions on Evolutionary Computation, 24(2), 305–319.

pydmoo/algorithms/classic/moead_svr.py

@@ -0,0 +1,86 @@
+import numpy as np
+from pymoo.core.population import Population
+from sklearn.svm import SVR
+
+from pydmoo.algorithms.base.dmoo.dmoead import DMOEAD
+
+
+class MOEADSVR(DMOEAD):
+    """Support Vector Regression (SVR).
+
+    Notes
+    -----
+    [Official Python Code](https://github.com/LeileiCao/MOEA-D-SVR/blob/master/MOEAD-SVR%20.py)
+
+    References
+    ----------
+    Cao, L., Xu, L., Goodman, E. D., Bao, C., and Zhu, S. (2020).
+    Evolutionary dynamic multiobjective optimization assisted by a support vector regression predictor.
+    IEEE Transactions on Evolutionary Computation, 24(2), 305–319.
+    https://doi.org/10.1109/TEVC.2019.2925722
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # SVR
+        self._q = 4  # the number of preceding values that are correlated with the target value (dimension of input samples in the SVR model)
+        self._C = 1000  # the regularization constant in SVR model
+        self._epsilon = 0.05  # the insensitive tube size in SVR model
+        # self._gamma = 1/d  # the Gaussian RBF kernel parameter used in SVR model, and d is the number of variables
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        old = self.data.get("stacked_X", None)
+        if old is None:
+            stacked_X = np.expand_dims(X, axis=0)
+        else:
+            stacked_X = np.concatenate((old, np.expand_dims(X, axis=0)), axis=0)
+        self.data["stacked_X"] = stacked_X
+
+        N, d = X.shape
+        sol = np.zeros((N, d))
+        K = len(stacked_X)
+
+        if K < self._q + 2:
+            # recreate the current population without being evaluated
+            # Re-evaluate the current population, and update the reference point
+            pop = Population.new(X=X)
+
+            return pop
+
+        # Precompute sliding window indices to avoid redundant calculations
+        window_indices = np.lib.stride_tricks.sliding_window_view(np.arange(K), self._q + 1)
+
+        for i in range(N):
+            for j in range(d):
+                # Extract the time series for this (i,j) position
+                ts = stacked_X[:K, i, j]
+
+                # Create training data using vectorized sliding windows
+                train = ts[window_indices]
+                x_train = train[:, :-1]
+                y_train = train[:, -1]
+
+                # Train SVR model (consider moving this outside loops if possible)
+                # gamma if 'auto', uses 1 / n_features (not provided in code but provided in paper)
+                # versionchanged:: 0.22
+                # The default value of ``gamma`` changed from 'auto' to 'scale'.
+                svr = SVR(kernel='rbf', epsilon=self._epsilon, C=self._C, gamma=1/d)
+                model = svr.fit(x_train, y_train)
+
+                # Make prediction
+                sol[i, j] = model.predict(ts[-self._q:].reshape(1, -1))
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            sol = np.clip(sol, xl, xu)  # provided in the original reference literature
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=sol)
+
+        return pop

pydmoo/algorithms/classic/moeadde_svr.py

@@ -0,0 +1,86 @@
+import numpy as np
+from pymoo.core.population import Population
+from sklearn.svm import SVR
+
+from pydmoo.algorithms.base.dmoo.dmoeadde import DMOEADDE
+
+
+class MOEADDESVR(DMOEADDE):
+    """Support Vector Regression (SVR).
+
+    Notes
+    -----
+    [Official Python Code](https://github.com/LeileiCao/MOEA-D-SVR/blob/master/MOEAD-SVR%20.py)
+
+    References
+    ----------
+    Cao, L., Xu, L., Goodman, E. D., Bao, C., and Zhu, S. (2020).
+    Evolutionary dynamic multiobjective optimization assisted by a support vector regression predictor.
+    IEEE Transactions on Evolutionary Computation, 24(2), 305–319.
+    https://doi.org/10.1109/TEVC.2019.2925722
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # SVR
+        self._q = 4  # the number of preceding values that are correlated with the target value (dimension of input samples in the SVR model)
+        self._C = 1000  # the regularization constant in SVR model
+        self._epsilon = 0.05  # the insensitive tube size in SVR model
+        # self._gamma = 1/d  # the Gaussian RBF kernel parameter used in SVR model, and d is the number of variables
+
+    def _response_mechanism(self):
+        """Response mechanism."""
+        pop = self.pop
+        X = pop.get("X")
+
+        old = self.data.get("stacked_X", None)
+        if old is None:
+            stacked_X = np.expand_dims(X, axis=0)
+        else:
+            stacked_X = np.concatenate((old, np.expand_dims(X, axis=0)), axis=0)
+        self.data["stacked_X"] = stacked_X
+
+        N, d = X.shape
+        sol = np.zeros((N, d))
+        K = len(stacked_X)
+
+        if K < self._q + 2:
+            # recreate the current population without being evaluated
+            # Re-evaluate the current population, and update the reference point
+            pop = Population.new(X=X)
+
+            return pop
+
+        # Precompute sliding window indices to avoid redundant calculations
+        window_indices = np.lib.stride_tricks.sliding_window_view(np.arange(K), self._q + 1)
+
+        for i in range(N):
+            for j in range(d):
+                # Extract the time series for this (i,j) position
+                ts = stacked_X[:K, i, j]
+
+                # Create training data using vectorized sliding windows
+                train = ts[window_indices]
+                x_train = train[:, :-1]
+                y_train = train[:, -1]
+
+                # Train SVR model (consider moving this outside loops if possible)
+                # gamma if 'auto', uses 1 / n_features (not provided in code but provided in paper)
+                # versionchanged:: 0.22
+                # The default value of ``gamma`` changed from 'auto' to 'scale'.
+                svr = SVR(kernel='rbf', epsilon=self._epsilon, C=self._C, gamma=1/d)
+                model = svr.fit(x_train, y_train)
+
+                # Make prediction
+                sol[i, j] = model.predict(ts[-self._q:].reshape(1, -1))[0]
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            sol = np.clip(sol, xl, xu)  # provided in the original reference literature
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=sol)
+
+        return pop

pydmoo/algorithms/knowledge/moead_ktmm.py

@@ -0,0 +1,113 @@
+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.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADKTMM(DMOEAD):
+    """Knowledge Transfer with Mixture Model.
+
+    Zou, J., Hou, Z., Jiang, S., Yang, S., Ruan, G., Xia, Y., and Liu, Y. (2025).
+    Knowledge transfer with mixture model in dynamic multi-objective optimization.
+    IEEE Transactions on Evolutionary Computation, in press.
+    https://doi.org/10.1109/TEVC.2025.3566481
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.size_pool = 14  # the size of knowledge pool
+        self.denominator = 0.5
+
+    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)
+
+        # sample self.pop_size solutions in decision space
+        samples_old = self.sampling_new_pop()
+
+        # select self.pop_size/2 individuals with better convergence and diversity
+        samples = samples_old[:int(len(samples_old)/2)]
+
+        # knowledge in decision space
+        means_stds_ps, mean, std = self._in_decision_or_objective_space_1d(samples, "decision_space")
+        mean_new, std_new = self._select_means_stds(means_stds_ps, mean, std)
+
+        # sample self.pop_size solutions in decision space
+        X = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def _in_decision_or_objective_space_1d(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_stds = self.data.get("means_stds", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        means_stds.append((np.mean(flag_value, axis=0), np.std(flag_value, axis=0), self.n_iter - 1))  # 1-based
+        self.data["means_stds"] = means_stds
+
+        flag_value = samples.get(flag)
+        mean, std = np.mean(flag_value, axis=0), np.std(flag_value, axis=0)
+        return means_stds, mean, std
+
+    def sampling_new_pop(self):
+        samples = self.initialization.sampling(self.problem, self.pop_size)
+        samples = self.evaluator.eval(self.problem, samples)
+
+        # do a survival to recreate rank and crowding of all individuals
+        samples = RankAndCrowding().do(self.problem, samples, n_survive=len(samples))
+        return samples
+
+    def _select_means_stds(self, means_stds, mean_new, std_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_stds])
+        stds = np.array([m[1] for m in means_stds])
+
+        # Calculate distances
+        mean_diffs = means - mean_new
+        std_diffs = stds - std_new
+
+        distances = np.sqrt(np.sum(mean_diffs**2, axis=1) + np.sum(std_diffs**2, axis=1))
+
+        # Get top K closest
+        top_k_idx = np.argsort(distances)[:self.size_pool]
+        top_k_dist = distances[top_k_idx]
+        top_k_means = means[top_k_idx]
+        top_k_stds = stds[top_k_idx]
+
+        # Update pool
+        self._update_means_stds_pool(means_stds, top_k_idx)
+
+        # Calculate weights
+        weights = 1 / (top_k_dist + 1e-8)  # Add small epsilon to avoid division by zero
+        weights = weights / (np.sum(weights) + self.denominator)
+
+        # Weighted combination
+        mean_new = (1 - np.sum(weights)) * mean_new + np.sum(weights[:, None] * top_k_means, axis=0)
+        std_new = (1 - np.sum(weights)) * std_new + np.sum(weights[:, None] * top_k_stds, axis=0)
+        return mean_new, std_new
+
+    def _update_means_stds_pool(self, means_stds, top_k_idx) -> None:
+        self.data["means_stds"] = [means_stds[i] for i in top_k_idx]
+        return None

pydmoo/algorithms/knowledge/moeadde_ktmm.py

@@ -0,0 +1,113 @@
+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.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADDEKTMM(DMOEADDE):
+    """Knowledge Transfer with Mixture Model.
+
+    Zou, J., Hou, Z., Jiang, S., Yang, S., Ruan, G., Xia, Y., and Liu, Y. (2025).
+    Knowledge transfer with mixture model in dynamic multi-objective optimization.
+    IEEE Transactions on Evolutionary Computation, in press.
+    https://doi.org/10.1109/TEVC.2025.3566481
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.size_pool = 14  # the size of knowledge pool
+        self.denominator = 0.5
+
+    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)
+
+        # sample self.pop_size solutions in decision space
+        samples_old = self.sampling_new_pop()
+
+        # select self.pop_size/2 individuals with better convergence and diversity
+        samples = samples_old[:int(len(samples_old)/2)]
+
+        # knowledge in decision space
+        means_stds_ps, mean, std = self._in_decision_or_objective_space_1d(samples, "decision_space")
+        mean_new, std_new = self._select_means_stds(means_stds_ps, mean, std)
+
+        # sample self.pop_size solutions in decision space
+        X = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def _in_decision_or_objective_space_1d(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_stds = self.data.get("means_stds", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        means_stds.append((np.mean(flag_value, axis=0), np.std(flag_value, axis=0), self.n_iter - 1))  # 1-based
+        self.data["means_stds"] = means_stds
+
+        flag_value = samples.get(flag)
+        mean, std = np.mean(flag_value, axis=0), np.std(flag_value, axis=0)
+        return means_stds, mean, std
+
+    def sampling_new_pop(self):
+        samples = self.initialization.sampling(self.problem, self.pop_size)
+        samples = self.evaluator.eval(self.problem, samples)
+
+        # do a survival to recreate rank and crowding of all individuals
+        samples = RankAndCrowding().do(self.problem, samples, n_survive=len(samples))
+        return samples
+
+    def _select_means_stds(self, means_stds, mean_new, std_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_stds])
+        stds = np.array([m[1] for m in means_stds])
+
+        # Calculate distances
+        mean_diffs = means - mean_new
+        std_diffs = stds - std_new
+
+        distances = np.sqrt(np.sum(mean_diffs**2, axis=1) + np.sum(std_diffs**2, axis=1))
+
+        # Get top K closest
+        top_k_idx = np.argsort(distances)[:self.size_pool]
+        top_k_dist = distances[top_k_idx]
+        top_k_means = means[top_k_idx]
+        top_k_stds = stds[top_k_idx]
+
+        # Update pool
+        self._update_means_stds_pool(means_stds, top_k_idx)
+
+        # Calculate weights
+        weights = 1 / (top_k_dist + 1e-8)  # Add small epsilon to avoid division by zero
+        weights = weights / (np.sum(weights) + self.denominator)
+
+        # Weighted combination
+        mean_new = (1 - np.sum(weights)) * mean_new + np.sum(weights[:, None] * top_k_means, axis=0)
+        std_new = (1 - np.sum(weights)) * std_new + np.sum(weights[:, None] * top_k_stds, axis=0)
+        return mean_new, std_new
+
+    def _update_means_stds_pool(self, means_stds, top_k_idx) -> None:
+        self.data["means_stds"] = [means_stds[i] for i in top_k_idx]
+        return None

pydmoo/algorithms/knowledge/nsga2_ktmm.py

@@ -0,0 +1,113 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.dmoo.dnsga2 import DNSGA2
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class NSGA2KTMM(DNSGA2):
+    """Knowledge Transfer with Mixture Model.
+
+    Zou, J., Hou, Z., Jiang, S., Yang, S., Ruan, G., Xia, Y., and Liu, Y. (2025).
+    Knowledge transfer with mixture model in dynamic multi-objective optimization.
+    IEEE Transactions on Evolutionary Computation, in press.
+    https://doi.org/10.1109/TEVC.2025.3566481
+    """
+
+    def __init__(self, **kwargs):
+
+        super().__init__(**kwargs)
+
+        self.size_pool = 14  # the size of knowledge pool
+        self.denominator = 0.5
+
+    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)
+
+        # sample self.pop_size solutions in decision space
+        samples_old = self.sampling_new_pop()
+
+        # select self.pop_size/2 individuals with better convergence and diversity
+        samples = samples_old[:int(len(samples_old)/2)]
+
+        # knowledge in decision space
+        means_stds_ps, mean, std = self._in_decision_or_objective_space_1d(samples, "decision_space")
+        mean_new, std_new = self._select_means_stds(means_stds_ps, mean, std)
+
+        # sample self.pop_size solutions in decision space
+        X = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = np.clip(X, xl, xu)  # not provided in the original reference literature
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def _in_decision_or_objective_space_1d(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_stds = self.data.get("means_stds", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        means_stds.append((np.mean(flag_value, axis=0), np.std(flag_value, axis=0), self.n_iter - 1))  # 1-based
+        self.data["means_stds"] = means_stds
+
+        flag_value = samples.get(flag)
+        mean, std = np.mean(flag_value, axis=0), np.std(flag_value, axis=0)
+        return means_stds, mean, std
+
+    def sampling_new_pop(self):
+        samples = self.initialization.sampling(self.problem, self.pop_size)
+        samples = self.evaluator.eval(self.problem, samples)
+
+        # do a survival to recreate rank and crowding of all individuals
+        samples = RankAndCrowding().do(self.problem, samples, n_survive=len(samples))
+        return samples
+
+    def _select_means_stds(self, means_stds, mean_new, std_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_stds])
+        stds = np.array([m[1] for m in means_stds])
+
+        # Calculate distances
+        mean_diffs = means - mean_new
+        std_diffs = stds - std_new
+
+        distances = np.sqrt(np.sum(mean_diffs**2, axis=1) + np.sum(std_diffs**2, axis=1))
+
+        # Get top K closest
+        top_k_idx = np.argsort(distances)[:self.size_pool]
+        top_k_dist = distances[top_k_idx]
+        top_k_means = means[top_k_idx]
+        top_k_stds = stds[top_k_idx]
+
+        # Update pool
+        self._update_means_stds_pool(means_stds, top_k_idx)
+
+        # Calculate weights
+        weights = 1 / (top_k_dist + 1e-8)  # Add small epsilon to avoid division by zero
+        weights = weights / (np.sum(weights) + self.denominator)
+
+        # Weighted combination
+        mean_new = (1 - np.sum(weights)) * mean_new + np.sum(weights[:, None] * top_k_means, axis=0)
+        std_new = (1 - np.sum(weights)) * std_new + np.sum(weights[:, None] * top_k_stds, axis=0)
+        return mean_new, std_new
+
+    def _update_means_stds_pool(self, means_stds, top_k_idx) -> None:
+        self.data["means_stds"] = [means_stds[i] for i in top_k_idx]
+        return None

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/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.2.dist-info → pydmoo-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydmoo
-Version: 0.1.2
+Version: 0.1.4
 Summary: Dynamic Multi-Objective Optimization in Python (pydmoo).
 Project-URL: Homepage, https://github.com/dynoptimization/pydmoo
 Project-URL: Repository, https://github.com/dynoptimization/pydmoo
@@ -44,5 +44,6 @@ Description-Content-Type: text/markdown
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydmoo)
 [![PyPI](https://img.shields.io/pypi/v/pydmoo)](https://pypi.org/project/pydmoo/)
 ![Visitors](https://visitor-badge.laobi.icu/badge?page_id=dynoptimization.pydmoo)
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 
 Please refer to the [documentation](https://dynoptimization.github.io/pydmoo/) for more details.

{pydmoo-0.1.2.dist-info → pydmoo-0.1.4.dist-info}/RECORD

@@ -5,22 +5,31 @@ pydmoo/algorithms/base/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 pydmoo/algorithms/base/core/algorithm.py,sha256=nFeyj1PECWk4q2W5_7utwqSjxVIx-DA3_8o-wzHxc50,12967
 pydmoo/algorithms/base/core/genetic.py,sha256=RH1MMkBbWqSQw_8pXvweTgdpCxFqUJZXaNUUh3oYUbg,4904
 pydmoo/algorithms/base/dmoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydmoo/algorithms/base/dmoo/dmoead.py,sha256=MB0RnYHmbd1fztC9EaezquaccK89B_egyIjaUp1xggA,4289
-pydmoo/algorithms/base/dmoo/dmoeadde.py,sha256=7jqEezFYl_kSEx1ytVy1OQtlBRZJQKHPJd7wsqoQTmk,4305
+pydmoo/algorithms/base/dmoo/dmoead.py,sha256=BvmggD99CjqHiGN-ujTVi2HiCBSExhsPJVKMfO5WpVo,5530
+pydmoo/algorithms/base/dmoo/dmoeadde.py,sha256=-TbM3lxn06-MKlGUuQxdZQO5RFqbRR0XdLH0EcsImsg,5574
 pydmoo/algorithms/base/dmoo/dmopso.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydmoo/algorithms/base/dmoo/dnsga2.py,sha256=AOK01k7T31Q-0wFMBA_AtHtTy4v2fnJ0RNW62YbsoFE,4465
+pydmoo/algorithms/base/dmoo/dnsga2.py,sha256=PDsgVF935YK0ULceV0qSQ-8fY7fpJttu0RZRKIIqGf8,6531
 pydmoo/algorithms/base/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydmoo/algorithms/base/moo/moead.py,sha256=yAymuaqVritcrUb-erJNHMpsDY_eaD-BXC-2zM7zwoc,8084
-pydmoo/algorithms/base/moo/moeadde.py,sha256=WKgCZF3odsZMs40OSefqPvxlMmvkdvqQskV_q4yfOec,5073
+pydmoo/algorithms/base/moo/moeadde.py,sha256=wm0aoiiogkY34ZHfJ1-dQuYWAscS7DPsqyxdp909O4E,5129
 pydmoo/algorithms/base/moo/mopso.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydmoo/algorithms/base/moo/nsga2.py,sha256=iwvP5Av-psbmDF89Kre3bLwJKQ8BPKR5rmG0EDxU-XE,4519
 pydmoo/algorithms/classic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydmoo/algorithms/classic/moead_ae.py,sha256=Ju4wrQNlDJb_z9Xoa1yFMLy9zMQJjyCbrT93Ik3ltmI,2701
 pydmoo/algorithms/classic/moead_pps.py,sha256=WbHmUOvJMMDe2YQwKyl5uP-Yykfz0Kwk5ADBm9CKQ_0,3321
+pydmoo/algorithms/classic/moead_svr.py,sha256=TLDBXOYiF9q0nZHswi7ZJCDVWJrzyz1U9Lg8oTjoPH8,3226
 pydmoo/algorithms/classic/moeadde_ae.py,sha256=yCSePEywxdo6bYIgpxm98QSyEfyDYMFIgKsV_wUy7Us,2709
 pydmoo/algorithms/classic/moeadde_pps.py,sha256=9wUgKZd6FbEanpbGZ6bAZiSk3wPE7xWQ2ahaMq9V0as,3329
+pydmoo/algorithms/classic/moeadde_svr.py,sha256=el6FQb3D_yhWTkrBo6yQ5sLWX31OTdGeFyPdEB2gzUk,3237
 pydmoo/algorithms/classic/nsga2_ae.py,sha256=iTxlT0pQUTnLP1ZUPGzj-L7mxqaQU2lSoMDkHF4Hthc,2631
 pydmoo/algorithms/classic/nsga2_pps.py,sha256=lyQXcBssY7r8uxRJt0NXTvCJ052qpqp5KE459V8xU7M,3321
+pydmoo/algorithms/knowledge/moead_ktmm.py,sha256=PHajdMbgpfq43ceLol2PAPixML1BgLLpIui22g13ItQ,4298
+pydmoo/algorithms/knowledge/moeadde_ktmm.py,sha256=j8Fembi9v7l0vYcqyuksH2kvqEkqm3f3-aQl4KzkyM4,4306
+pydmoo/algorithms/knowledge/nsga2_ktmm.py,sha256=i_Q8ffLUn1sp-ouAwzLmFqL9VHWz-G2f5aRsuts1TrQ,4298
+pydmoo/algorithms/learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydmoo/algorithms/learning/moead_tr.py,sha256=iDa3MqyZUaHq9JD_Om26Y5q2cbBm_DnHRprIrKWg-fY,3411
+pydmoo/algorithms/learning/moeadde_tr.py,sha256=qKmMTRQ7Ev2y1hr9e4dUh0slD5XsXTTlx6miJHfxk60,3419
+pydmoo/algorithms/learning/nsga2_tr.py,sha256=oV_l5P_fEPjs_UB8PHL8icOkToZStz8ekdqjyoPA0ls,3411
 pydmoo/algorithms/modern/__init__.py,sha256=RJDZoZaa1mp7hFQC4TkSpOxfBpqDnbXpLmMu2GFbv2o,3004
 pydmoo/algorithms/modern/moead_imkt.py,sha256=YqhqdUV4UEn6Y8s81GyNiP1yiZomHd-j67QOVW5KEFM,4597
 pydmoo/algorithms/modern/moead_imkt_igp.py,sha256=H4HQiT274UYzN_hM1HndLH1vdmG82nAX4hW9NJ5C-vg,1902
@@ -63,7 +72,7 @@ pydmoo/core/lstm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 pydmoo/core/lstm/base.py,sha256=h6dR-_qnNu9tjE-JmicUnGUs0Iey4I11ZD4kScRtXxk,11171
 pydmoo/core/lstm/lstm.py,sha256=S84YWwSn52g-NUfmZnG2i-4RmUjpXVb0kfABELut0bE,17591
 pydmoo/problems/__init__.py,sha256=Kp7HfoxJFcQBLqcD7sMclwAJVXILlkESHVA6DwCTKUY,1909
-pydmoo/problems/dyn.py,sha256=opsbVPn0GV-w_4CsLm9RVdrhYX8oOPohZobxwmZDKJY,9517
+pydmoo/problems/dyn.py,sha256=a7XCE4bKHYUc9XQhmXZl62Ry_yqEt8hICTUh2fiVRJU,10863
 pydmoo/problems/dynamic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydmoo/problems/dynamic/cec2015.py,sha256=jJVAuQjUwwsU-frvapuYtmVf4pQHkaXmw70WBGu4vtQ,4450
 pydmoo/problems/dynamic/df.py,sha256=5vfsCqbeF6APVaaVEMuj75p-k5OspsIqY9bRotAJcN8,15488
@@ -71,7 +80,7 @@ pydmoo/problems/dynamic/gts.py,sha256=QRJXfw2L2M-lRraCIop3jBHUjHJVRr7RRS2muaxGLE
 pydmoo/problems/real_world/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydmoo/problems/real_world/dsrp.py,sha256=XuF5fy1HbD6qDyBq8fOQP5ZAaNJgT4InkH2RqxH9TIk,5085
 pydmoo/problems/real_world/dwbdp.py,sha256=MUjSjH66_V3C8o4NEOSiz2uKmE-YrS9_vAEAdUHnZDs,6249
-pydmoo-0.1.2.dist-info/METADATA,sha256=YSJYvtpoIqF_WaRvaCeIUX9Kbn0xKb0CzdKyw-E6IGw,2163
-pydmoo-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pydmoo-0.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pydmoo-0.1.2.dist-info/RECORD,,
+pydmoo-0.1.4.dist-info/METADATA,sha256=htSTAcXLDykyCyvtFx0GNsFUFu8islCaWsH9yCK_Gf4,2291
+pydmoo-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pydmoo-0.1.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydmoo-0.1.4.dist-info/RECORD,,