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

pydmoo/algorithms/modern/nsga2_imkt_lstm.py

@@ -0,0 +1,248 @@
+import numpy as np
+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.inverse import closed_form_solution
+from pydmoo.core.lstm.lstm import LSTMpredictor
+from pydmoo.core.sample_gaussian import univariate_gaussian_sample
+
+
+class NSGA2IMLSTM(NSGA2IMKT):
+    """Inverse Modeling with LSTM (IMLSTM).
+
+    Inverse Modeling for Dynamic Multiobjective Optimization with LSTM prediction 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_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 prepare_data_means_std(n_timesteps, means_stds):
+    """Prepare time series data from means and standard deviations.
+
+    This function converts a sequence of mean vectors and standard deviation vectors
+    into a time series format suitable for machine learning models. It concatenates
+    mean values and standard deviation values to create feature vectors for each time step.
+
+    Parameters
+    ----------
+    means_stds : list of tuples
+        List containing (mean, std, n_iter) pairs for each time step, where:
+        - mean: 1D numpy array of mean values
+        - std: 1D numpy array of standard deviation values
+        - n_iter: number of iterations (not used in feature extraction)
+
+    Returns
+    -------
+    time_series_data : list
+        Combined feature data with shape (n_timesteps, n_features)
+        Each row represents a time step containing:
+        [mean_1, mean_2, ..., mean_n, std_1, std_2, ..., std_n]
+    """
+    # Create time series data
+    time_series_data = []  # shape: (n_timesteps, n_features)
+
+    # Process only the most recent n_timesteps
+    for m, s, _ in means_stds[-n_timesteps:]:
+        # Combine mean vector and standard deviation vector
+        # [*m] unpacks all mean values
+        # [*s] unpacks all standard deviation values
+        feature_vector = [*m, *s]
+
+        time_series_data.append(feature_vector)
+
+    return time_series_data
+
+
+class NSGA2IMiLSTM(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+        self._n_timesteps = 10
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1003(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+        self._n_timesteps = 10
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1005(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+        self._n_timesteps = 10
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1007(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+        self._n_timesteps = 10
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1009(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 10
+        self.denominator = 0.5
+        self._n_timesteps = 10
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1503(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 3
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1505(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 5
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1507(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 7
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1509(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 9
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1511(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 11
+        self._incremental_learning = True
+
+
+class NSGA2IMiLSTM1513(NSGA2IMLSTM):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.size_pool = 15
+        self.denominator = 0.5
+        self._n_timesteps = 15
+        self._sequence_length = 13
+        self._incremental_learning = True

pydmoo/algorithms/modern/nsga2_imkt_n.py

@@ -0,0 +1,117 @@
+import numpy as np
+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.distance import norm_mean_frobenius_distance
+from pydmoo.core.inverse import closed_form_solution
+from pydmoo.core.sample_gaussian import multivariate_gaussian_sample
+
+
+class NSGA2IMKTN(NSGA2IMKT):
+    """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, 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 = 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 _in_decision_or_objective_space_nd(self, samples, decision_or_objective="decision_space"):
+        # decision space or objective space
+        flag = "X" if decision_or_objective == "decision_space" else "F"
+
+        means_covs = self.data.get("means_covs", [])
+
+        flag_value = self.opt.get(flag)
+        if len(flag_value) <= 1:
+            flag_value = self.pop.get(flag)
+            flag_value = flag_value[:2]
+
+        m, c = np.mean(flag_value, axis=0), np.cov(flag_value.T)
+        means_covs.append((m, 0.5 * (c.T + c), self.n_iter - 1))  # 1-based
+        self.data["means_covs"] = means_covs
+
+        flag_value = samples.get(flag)
+        mean, cov = np.mean(flag_value, axis=0), np.cov(flag_value.T)
+        return means_covs, mean, 0.5 * (cov.T + cov)
+
+    def _select_means_covs(self, means_covs, mean_new, cov_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_covs])
+        covs = np.array([m[1] for m in means_covs])
+
+        # Calculate distances
+        distances = np.array([
+            norm_mean_frobenius_distance(mean, cov, mean_new, cov_new) for mean, cov in zip(means, covs)
+        ])
+
+        # 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_covs = covs[top_k_idx]
+
+        # Update pool
+        self._update_means_covs_pool(means_covs, 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)
+        cov_new = (1 - np.sum(weights)) * cov_new + np.sum(weights[:, None, None] * top_k_covs, axis=0)
+
+        # Symmetric matrix
+        cov_new = 0.5 * (cov_new.T + cov_new)
+        return mean_new, cov_new
+
+    def _update_means_covs_pool(self, means_covs, top_k_idx) -> None:
+        self.data["means_covs"] = [means_covs[i] for i in top_k_idx]
+        return None
+
+
+class NSGA2IMKTN0(NSGA2IMKTN):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

pydmoo/algorithms/modern/nsga2_imkt_n_clstm.py

@@ -0,0 +1,146 @@
+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_n import NSGA2IMKTN
+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 NSGA2IMNcLSTM(NSGA2IMKTN):
+    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_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
+
+    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_covs(self, means_covs, mean_new, cov_new):
+        # Unpack means and stds
+        means = np.array([m[0] for m in means_covs])
+        covs = np.array([m[1] for m in means_covs])
+
+        # Weighted combination
+        mean_new = 0.5 * mean_new + 0.5 * means[-1]
+        cov_new = 0.5 * cov_new + 0.5 * covs[-1]
+
+        return mean_new, cov_new
+
+
+class NSGA2IMNicLSTM(NSGA2IMNcLSTM):
+    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

pydmoo/algorithms/modern/nsga2_imkt_n_igp.py

@@ -0,0 +1,57 @@
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.nsga2_imkt_n import NSGA2IMKTN
+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 NSGA2IMKTNIGP(NSGA2IMKTN):
+    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 = FB
+        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 NSGA2IMKTNIGP0(NSGA2IMKTNIGP):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)