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

pydmoo/algorithms/modern/moead_imkt_n_igp.py

@@ -0,0 +1,56 @@
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.moead_imkt_n import MOEADIMKTN
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.predictions import igp_based_predictor
+from pydmoo.core.sample_gaussian import multivariate_gaussian_sample
+
+
+class MOEADIMKTNIGP(MOEADIMKTN):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+        self.delta_s = 0.01
+        self.sigma_n = 0.01
+        self.sigma_n_2 = self.sigma_n ** 2
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, cov = self._in_decision_or_objective_space_nd(samples, "objective_space")
+        mean_new, cov_new = self._select_means_covs(means_stds, mean, cov)
+
+        # sample self.pop_size individuals in objective space
+        F = multivariate_gaussian_sample(mean_new, cov_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        X = igp_based_predictor(samples.get("X"), samples.get("F"), F, self.sigma_n_2)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+
+class MOEADIMKTNIGP0(MOEADIMKTNIGP):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

pydmoo/algorithms/modern/moead_imkt_n_lstm.py

@@ -0,0 +1,111 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.moead_imkt_n import MOEADIMKTN
+from pydmoo.algorithms.modern.nsga2_imkt_n_lstm import prepare_data_mean_cov
+from pydmoo.algorithms.utils.utils import make_semidefinite, reconstruct_covariance_from_triu
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.lstm.lstm import LSTMpredictor
+from pydmoo.core.sample_gaussian import multivariate_gaussian_sample
+
+
+class MOEADIMNLSTM(MOEADIMKTN):
+    """Inverse Modeling with LSTM (IMNLSTM).
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with Knowledge Transfer In objective Space.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+        self._n_timesteps = 10
+        self._sequence_length = 5  # Use 5 historical time steps to predict next step
+        self._incremental_learning = False
+
+    def _setup(self, problem, **kwargs):
+        super()._setup(problem, **kwargs)
+
+        # Must be here
+        self._lstm = LSTMpredictor(
+            self._sequence_length,
+            hidden_dim=64,
+            num_layers=1,
+            epochs=50,
+            batch_size=32,
+            lr=0.001,
+            device="cpu",  # for fair comparison
+            patience=5,
+            seed=self.seed,
+            model_type="lstm",
+            incremental_learning=self._incremental_learning,
+        )
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_covs, mean, cov = self._in_decision_or_objective_space_nd(samples, "objective_space")
+
+        # Check if sufficient historical data is available for LSTM prediction
+        if len(means_covs) > self._n_timesteps:
+            # Update pool
+            self.data["means_covs"] = means_covs[self._n_timesteps:]
+
+            # Prepare time series data from historical means and covariance matrices
+            time_series_data = prepare_data_mean_cov(self._n_timesteps, means_covs)
+
+            # Initialize predictor and generate prediction for next time step
+            next_prediction = self._lstm.convert_train_predict(time_series_data)
+
+            # Convert prediction tensor to numpy array for further processing
+            next_prediction = next_prediction.numpy()
+
+            # Split prediction into mean and covariance components
+            # First n_obj elements represent the mean vector, Remaining elements represent the flattened covariance matrix values
+            mean_new, cov_new_ = next_prediction[:self.problem.n_obj], next_prediction[self.problem.n_obj:]
+            cov_new = reconstruct_covariance_from_triu(cov_new_, len(mean_new))
+            cov_new = make_semidefinite(cov_new)
+
+        else:
+            mean_new, cov_new = self._select_means_covs(means_covs, mean, cov)
+
+        # sample self.pop_size individuals in objective space
+        F = multivariate_gaussian_sample(mean_new, cov_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+
+class MOEADIMNiLSTM(MOEADIMNLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self._incremental_learning = True

pydmoo/algorithms/modern/moead_ktmm.py

@@ -0,0 +1,112 @@
+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_change(self):
+        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/modern/moeadde_imkt.py

@@ -0,0 +1,161 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.modern.moeadde_ktmm import MOEADDEKTMM
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADDEIMKT(MOEADDEKTMM):
+    """Inverse Modeling with Knowledge Transfer.
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with Knowledge Transfer In objective Space.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, std = self._in_decision_or_objective_space_1d(samples, "objective_space")
+        mean_new, std_new = self._select_means_stds(means_stds, mean, std)
+
+        # sample self.pop_size individuals in objective space
+        F = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def sampling_new_pop(self):
+        X = self.pop.get("X")
+
+        if not self.problem.has_constraints():
+
+            last_X = self.data.get("last_X", [])
+            if len(last_X) == 0:
+                last_X = X
+            self.data["last_X"] = X
+
+            d = np.mean(X - last_X, axis=0)
+
+            radius = max(np.linalg.norm(d) / self.problem.n_obj, 0.1)
+
+            X = X + d + self.random_state.uniform(low=-radius, high=radius, size=X.shape)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        samples = Population.new(X=X)
+        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
+
+
+class MOEADDEIMKT0(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+class MOEADDEIMKT1(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 2
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT2(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 4
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT3(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 6
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT4(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 8
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT5(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT6(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 12
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT7(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 14
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT8(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 16
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT9(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 18
+        self.denominator = 0.5
+
+
+class MOEADDEIMKT10(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 20
+        self.denominator = 0.5

pydmoo/algorithms/modern/moeadde_imkt_clstm.py

@@ -0,0 +1,223 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.modern.moeadde_imkt import MOEADDEIMKT
+from pydmoo.algorithms.modern.nsga2_imkt_lstm import prepare_data_means_std
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.lstm.lstm import LSTMpredictor
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class MOEADDEIMcLSTM(MOEADDEIMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self._n_timesteps = 10
+        self._sequence_length = 5  # Use 5 historical time steps to predict next step
+        self._incremental_learning = False
+
+    def _setup(self, problem, **kwargs):
+        super()._setup(problem, **kwargs)
+
+        # Must be here
+        self._lstm = LSTMpredictor(
+            self._sequence_length,
+            hidden_dim=64,
+            num_layers=1,
+            epochs=50,
+            batch_size=32,
+            lr=0.001,
+            device="cpu",  # for fair comparison
+            patience=5,
+            seed=self.seed,
+            model_type="lstm",
+            incremental_learning=self._incremental_learning,
+        )
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # sample self.pop_size individuals 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 objective space
+        means_stds, mean, std = self._in_decision_or_objective_space_1d(samples, "objective_space")
+
+        # Check if sufficient historical data is available for LSTM prediction
+        if len(means_stds) > self._n_timesteps:
+            # Update pool
+            self.data["means_stds"] = means_stds[self._n_timesteps:]
+
+            # Prepare time series data from historical means and standard deviations
+            time_series_data = prepare_data_means_std(self._n_timesteps, means_stds)
+
+            # Initialize predictor and generate prediction for next time step
+            next_prediction = self._lstm.convert_train_predict(time_series_data)
+
+            # Convert prediction tensor to numpy array for further processing
+            next_prediction = next_prediction.numpy()
+
+            # Split prediction into mean and standard deviation components
+            # First n_obj elements represent mean values, remaining elements represent standard deviations
+            mean_new, std_new = next_prediction[:self.problem.n_obj], next_prediction[self.problem.n_obj:]
+            std_new = np.abs(std_new)
+
+        else:
+            mean_new, std_new = self._select_means_stds(means_stds, mean, std)
+
+        # sample self.pop_size individuals in objective space
+        F = univariate_gaussian_sample(mean_new, std_new, self.pop_size, random_state=self.random_state)
+
+        # TODO
+        # inverse mapping
+        # X = FB
+        B = closed_form_solution(samples.get("X"), samples.get("F"))
+
+        # X = FB
+        X = np.dot(F, B)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        # merge
+        pop = Population.merge(samples_old, Population.new(X=X))
+
+        return pop
+
+    def sampling_new_pop(self):
+        ps = self.opt.get("X")
+        X = self.pop.get("X")
+
+        if not self.problem.has_constraints():
+
+            last_ps = self.data.get("last_ps", [])
+            if len(last_ps) == 0:
+                last_ps = ps
+            self.data["last_ps"] = ps
+
+            d = np.mean(ps, axis=0) - np.mean(last_ps, axis=0)
+
+            radius = max(np.linalg.norm(d) / self.problem.n_obj, 0.1)
+
+            X = X + d + self.random_state.uniform(low=-radius, high=radius, size=X.shape)
+
+        # bounds
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            X = clip_and_randomize(X, xl, xu, random_state=self.random_state)
+
+        samples = Population.new(X=X)
+        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])
+
+        # Weighted combination
+        mean_new = 0.5 * mean_new + 0.5 * means[-1]
+        std_new = 0.5 * std_new + 0.5 * stds[-1]
+        return mean_new, std_new
+
+
+class MOEADDEIMicLSTM(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1003(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1005(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1007(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1009(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1503(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1505(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1507(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1509(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1511(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 11
+        self._incremental_learning = True
+
+
+class MOEADDEIMicLSTM1513(MOEADDEIMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 13
+        self._incremental_learning = True