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

pydmoo/algorithms/modern/moeadde_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.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_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/nsga2_imkt.py

@@ -0,0 +1,162 @@
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.modern.nsga2_ktmm import NSGA2KTMM
+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 NSGA2IMKT(NSGA2KTMM):
+    """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):
+        """Inverse Modeling with Knowledge Transfer."""
+        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 NSGA2IMKT0(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+class NSGA2IMKT1(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 2
+        self.denominator = 0.5
+
+
+class NSGA2IMKT2(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 4
+        self.denominator = 0.5
+
+
+class NSGA2IMKT3(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 6
+        self.denominator = 0.5
+
+
+class NSGA2IMKT4(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 8
+        self.denominator = 0.5
+
+
+class NSGA2IMKT5(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+
+
+class NSGA2IMKT6(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 12
+        self.denominator = 0.5
+
+
+class NSGA2IMKT7(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 14
+        self.denominator = 0.5
+
+
+class NSGA2IMKT8(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 16
+        self.denominator = 0.5
+
+
+class NSGA2IMKT9(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 18
+        self.denominator = 0.5
+
+
+class NSGA2IMKT10(NSGA2IMKT):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.size_pool = 20
+        self.denominator = 0.5

pydmoo/algorithms/modern/nsga2_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.nsga2_imkt import NSGA2IMKT
+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 NSGA2IMcLSTM(NSGA2IMKT):
+    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 NSGA2IMicLSTM(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 5  # Use 5 historical time steps to predict next step
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1003(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1005(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1007(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1009(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 10
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1503(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1505(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1507(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1509(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1511(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 11
+        self._incremental_learning = True
+
+
+class NSGA2IMicLSTM1513(NSGA2IMcLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._n_timesteps = 15
+        self._sequence_length = 13
+        self._incremental_learning = True

pydmoo/algorithms/modern/nsga2_imkt_igp.py

@@ -0,0 +1,56 @@
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.nsga2_imkt import NSGA2IMKT
+from pydmoo.core.bounds import clip_and_randomize
+from pydmoo.core.predictions import igp_based_predictor
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class NSGA2IMKTIGP(NSGA2IMKT):
+    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, 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 = 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 NSGA2IMKTIGP0(NSGA2IMKTIGP):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)