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

pydmoo/algorithms/modern/nsga2_imkt_n_lstm.py

@@ -0,0 +1,154 @@
+import numpy as np
+from pymoo.core.population import Population
+
+from pydmoo.algorithms.modern.nsga2_imkt_n import NSGA2IMKTN
+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 NSGA2IMNLSTM(NSGA2IMKTN):
+    """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
+
+
+def prepare_data_mean_cov(n_timesteps, means_covs):
+    """Prepare time series data from means and covariance matrices.
+
+    This function converts a sequence of mean vectors and covariance matrices
+    into a time series format suitable for LSTM training. It extracts the mean
+    values and the upper triangular elements of the covariance matrix (including
+    diagonal) to create feature vectors for each time step.
+
+    Parameters
+    ----------
+    means_covs : list of tuples
+        List containing (mean, cov, n_iter) pairs for each time step, where:
+        - mean: 1D numpy array of mean values
+        - cov: 2D numpy array representing covariance matrix
+        - 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, cov_11, cov_12, ..., cov_nn]
+    """
+    # Create time series data
+    time_series_data = []  # shape: (n_timesteps, n_features)
+
+    # Process only the most recent n_timesteps
+    for m, c, _ in means_covs[-n_timesteps:]:
+        # Extract upper triangular indices including diagonal
+        # np.triu_indices_from(c) returns row and column indices of upper triangle
+        rows, cols = np.triu_indices_from(c)
+
+        # Combine mean vector and upper triangular covariance elements
+        # [*m] unpacks all mean values
+        # [*c[rows, cols]] unpacks all upper triangular covariance elements
+        feature_vector = [*m, *c[rows, cols]]
+        time_series_data.append(feature_vector)
+
+    return time_series_data
+
+
+class NSGA2IMNiLSTM(NSGA2IMNLSTM):
+    def __init__(self, **kwargs) -> None:
+        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 = True

pydmoo/algorithms/modern/nsga2_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.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_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/utils/utils.py

@@ -0,0 +1,166 @@
+import numpy as np
+
+
+def reconstruct_covariance_from_triu(triu_elements, n_features):
+    """
+    Reconstruct a symmetric covariance matrix from upper triangular elements.
+
+    This function takes the flattened upper triangular elements (including diagonal)
+    of a covariance matrix and reconstructs the full symmetric matrix by leveraging
+    the symmetry property of covariance matrices.
+
+    Parameters
+    ----------
+    triu_elements : array_like
+        Flattened array containing the upper triangular elements of the covariance matrix,
+        including the diagonal elements. The elements should be in row-major order.
+        Shape: (n_triu_elements,) where n_triu_elements = n_features * (n_features + 1) // 2
+    n_features : int
+        Dimensionality of the feature space, which determines the size of the
+        output covariance matrix (n_features x n_features)
+
+    Returns
+    -------
+    cov_matrix : ndarray
+        Reconstructed symmetric covariance matrix of shape (n_features, n_features).
+        The matrix satisfies cov_matrix[i, j] == cov_matrix[j, i] for all i, j.
+
+    Raises
+    ------
+    ValueError
+        If the length of triu_elements does not match the expected number of
+        upper triangular elements for the given n_features
+
+    Notes
+    -----
+    The number of upper triangular elements (including diagonal) for an n x n matrix
+    is given by: n_triu_elements = n * (n + 1) // 2
+
+    Examples
+    --------
+    >>> triu_elements = np.array([1.0, 0.5, 0.3, 2.0, 0.4, 3.0])
+    >>> n_features = 3
+    >>> reconstruct_covariance_from_triu(triu_elements, n_features)
+    array([[1. , 0.5, 0.3],
+           [0.5, 2. , 0.4],
+           [0.3, 0.4, 3. ]])
+    """
+    # Validate input dimensions
+    expected_triu_elements = n_features * (n_features + 1) // 2
+    if len(triu_elements) != expected_triu_elements:
+        raise ValueError(
+            f"Invalid number of triu_elements: expected {expected_triu_elements}, "
+            f"got {len(triu_elements)}"
+        )
+
+    # Initialize output matrix with zeros
+    # Shape: (n_features, n_features)
+    cov_matrix = np.zeros((n_features, n_features), dtype=np.float64)
+
+    # Get indices for upper triangular portion (including diagonal)
+    # rows, cols: arrays of indices where row <= col
+    rows, cols = np.triu_indices(n_features)
+
+    # Fill upper triangular portion with input elements
+    # This sets cov_matrix[i, j] for all i <= j
+    cov_matrix[rows, cols] = triu_elements
+
+    # Fill lower triangular portion using symmetry
+    # Since covariance matrix is symmetric: cov_matrix[i, j] = cov_matrix[j, i]
+    # This sets cov_matrix[j, i] = cov_matrix[i, j] for all i < j
+    mask = rows != cols
+    cov_matrix[cols[mask], rows[mask]] = cov_matrix[rows[mask], cols[mask]]
+
+    return cov_matrix
+
+
+def make_semidefinite(matrix, tol=1e-8):
+    """
+    Convert a symmetric matrix to positive semi-definite form.
+
+    This function takes a symmetric matrix and ensures it is positive semi-definite
+    by eigen-decomposition and thresholding of negative eigenvalues. The input matrix
+    is first symmetrized, then any negative eigenvalues are set to zero.
+
+    Parameters
+    ----------
+    matrix : array_like
+        Input matrix to be converted to positive semi-definite form.
+        Should be square and approximately symmetric.
+        Shape: (n, n)
+    tol : float, optional
+        Tolerance for eigenvalue thresholding and symmetry check.
+        Eigenvalues less than this value will be set to zero.
+        Default: 1e-8
+
+    Returns
+    -------
+    psd_matrix : ndarray
+        Positive semi-definite matrix with the same shape as input.
+        All eigenvalues are guaranteed to be >= 0.
+        Shape: (n, n)
+
+    Raises
+    ------
+    LinAlgError
+        If the eigen-decomposition fails (e.g., matrix is not numerically symmetric)
+    ValueError
+        If input matrix is not square
+
+    Notes
+    -----
+    The algorithm proceeds in three steps:
+    1. Symmetrize the input matrix: (matrix + matrix.T) / 2
+    2. Compute eigen-decomposition using eigh (optimized for symmetric matrices)
+    3. Threshold negative eigenvalues to zero and reconstruct
+
+    This method preserves the eigenvectors while modifying only the eigenvalues
+    that violate positive semi-definiteness.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> matrix = np.array([[1.0, 0.5], [0.5, 1.0]])
+    >>> make_semidefinite(matrix)
+    array([[1. , 0.5],
+           [0.5, 1. ]])
+
+    >>> # Example with negative eigenvalues
+    >>> matrix_indefinite = np.array([[1.0, 2.0], [2.0, 1.0]])
+    >>> print("Original eigenvalues:", np.linalg.eigvalsh(matrix_indefinite))
+    Original eigenvalues: [-1.  3.]
+    >>> psd_matrix = make_semidefinite(matrix_indefinite)
+    >>> print("PSD eigenvalues:", np.linalg.eigvalsh(psd_matrix))
+    PSD eigenvalues: [0. 3.]
+
+    See Also
+    --------
+    numpy.linalg.eigh : Eigen decomposition for symmetric/Hermitian matrices
+    numpy.diag : Create diagonal matrix from vector
+    """
+    # Input validation
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ValueError(f"Input matrix must be square, got shape {matrix.shape}")
+
+    # Step 1: Ensure matrix is symmetric
+    # Average with transpose to eliminate numerical asymmetry
+    # Result: symmetric_matrix = (matrix + matrix.T) / 2
+    symmetric_matrix = (matrix + matrix.T) / 2
+
+    # Step 2: Compute eigen-decomposition
+    # eigh is preferred over eig for symmetric matrices (faster, more stable)
+    # Returns:
+    #   eigvals : 1D array of eigenvalues in ascending order
+    #   eigvecs : 2D array where columns are corresponding eigenvectors
+    eigvals, eigvecs = np.linalg.eigh(symmetric_matrix)
+
+    # Step 3: Threshold negative eigenvalues to zero
+    # Preserve eigenvalues >= tol, set others to 0
+    # This ensures positive semi-definiteness while minimizing distortion
+    eigvals_psd = np.where(eigvals < tol, 0.0, eigvals)
+
+    # Step 4: Reconstruct matrix from modified eigenvalues
+    # Matrix = V * diag(λ) * V.T where V contains eigenvectors as columns
+    psd_matrix = eigvecs @ np.diag(eigvals_psd) @ eigvecs.T
+
+    return psd_matrix

pydmoo/{response → core}/ar_model.py

@@ -38,9 +38,9 @@ class ARModel:
         # Construct design matrix X and target vector Y
         X = np.zeros((M - self.p, self.p))
         for i in range(self.p):
-            X[:, i] = y[(self.p - i - 1) : (M - i - 1)]
+            X[:, i] = y[(self.p - i - 1): (M - i - 1)]
 
-        Y = y[self.p :]
+        Y = y[self.p:]
 
         # Add intercept if specified
         if trend == "c":
@@ -76,11 +76,11 @@ class ARModel:
             raise ValueError("Model must be fitted before prediction")
 
         predictions = np.zeros(steps)
-        history = y[-self.p :].copy()  # Last p observations
+        history = y[-self.p:].copy()  # Last p observations
 
         for i in range(steps):
             # Prepare input vector
-            x = history[-self.p :][::-1]  # Latest p observations in reverse order
+            x = history[-self.p:][::-1]  # Latest p observations in reverse order
 
             # Add intercept if present (coef[0] is intercept)
             if len(self.coef_) == self.p + 1:

pydmoo/{response → core}/bounds.py

@@ -1,6 +1,39 @@
 import numpy as np
 
 
+def do_degeneration(PF, F, eps=1e-10):
+    min_pf = np.min(PF, axis=0)
+    max_pf = np.max(PF, axis=0)
+
+    mask = (max_pf - min_pf) >= eps
+    PF = PF[:, mask]
+    F = F[:, mask]
+    return PF, F
+
+
+def failure_count(PF, F):
+    min_pf = np.min(PF, axis=0)
+    max_pf = np.max(PF, axis=0)
+
+    # Check if any element in each row exceeds the bounds
+    # (data < lb) creates boolean matrix for lower bound violations
+    # (data > ub) creates boolean matrix for upper bound violations
+    # | combines both violations (OR operation)
+    # np.any(..., axis=1) checks if any violation exists in each row
+    out_of_bounds_mask = np.any((F < min_pf) | (F > max_pf), axis=1)
+
+    # Count number of invalid solutions (rows with at least one violation)
+    # True values are counted as 1, False as 0
+    num_invalid = np.sum(out_of_bounds_mask)
+
+    # Get indices of invalid rows
+    # np.where returns a tuple (we take first element with [0])
+    invalid_indices = np.where(out_of_bounds_mask)[0]
+
+    valid_indices = np.where(~out_of_bounds_mask)[0]
+    return num_invalid, valid_indices, invalid_indices
+
+
 def matrix_conditional_update(x_curr, lb, ub, x_prev):
     """
     Vectorized conditional matrix update with bounded interpolation.
@@ -44,7 +77,7 @@ def matrix_conditional_update(x_curr, lb, ub, x_prev):
     return x_new
 
 
-def clip_and_randomize(x, lb, ub):
+def clip_and_randomize(x, lb, ub, random_state=None):
     """
     Clip values to bounds with random replacement for out-of-bounds values.
 
@@ -68,7 +101,7 @@ def clip_and_randomize(x, lb, ub):
     numpy.random.uniform : Used for random value generation.
     """
     out_of_bounds = (x < lb) | (x > ub)
-    random_samples = np.random.uniform(low=lb, high=ub, size=x.shape)
+    random_samples = random_state.uniform(low=lb, high=ub, size=x.shape)
     return np.where(out_of_bounds, random_samples, x)
 
 

pydmoo/core/distance.py

@@ -0,0 +1,45 @@
+import numpy as np
+from scipy.linalg import logm, sqrtm
+
+
+def wasserstein_distance(mean1, cov1, mean2, cov2):
+    diff = mean1 - mean2
+    sqrt_cov1 = sqrtm(cov1)
+    cross_term = sqrtm(sqrt_cov1 @ cov2 @ sqrt_cov1)
+    return np.sqrt(diff @ diff + np.trace(cov1 + cov2 - 2 * cross_term))
+
+
+def kl_div_distance(mean1, cov1, mean2, cov2):
+    inv_cov2 = np.linalg.inv(cov2)
+    diff = mean2 - mean1
+    logdet = np.log(np.linalg.det(cov2) / np.linalg.det(cov1))
+    return 0.5 * (np.trace(inv_cov2 @ cov1) + diff.T @ inv_cov2 @ diff - len(mean1) + logdet)
+
+
+def bhattacharyya_distance(mean1, cov1, mean2, cov2):
+    avg_cov = 0.5 * (cov1 + cov2)
+    inv_avg = np.linalg.inv(avg_cov)
+    diff = mean1 - mean2
+    return 0.125 * diff.T @ inv_avg @ diff + 0.5 * np.log(
+        np.linalg.det(avg_cov) / np.sqrt(np.linalg.det(cov1) * np.linalg.det(cov2))
+    )
+
+
+def mahalanobis_distance(mean1, cov1, mean2, cov2):
+    inv_cov = np.linalg.inv(0.5 * (cov1 + cov2))
+    return np.sqrt((mean1 - mean2).T @ inv_cov @ (mean1 - mean2))
+
+
+def riemannian_distance(cov1, cov2):
+    return np.linalg.norm(logm(np.linalg.inv(sqrtm(cov1)) @ cov2 @ np.linalg.inv(sqrtm(cov1))), "fro")
+
+
+def frobenius_distance(cov1, cov2):
+    return np.linalg.norm(cov1 - cov2, "fro")
+
+
+# Used in NSGA2-IMKT-N
+# def norm_mean_frobenius_distance(mean, cov, target_mean, target_cov):
+#     return np.linalg.norm(mean - target_mean) + frobenius_distance(cov, target_cov)
+def norm_mean_frobenius_distance(mean, cov, target_mean, target_cov):
+    return frobenius_distance(cov, target_cov)

pydmoo/core/inverse.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+
+def closed_form_solution(X, Y):
+    """
+    Compute the least squares solution B = (YᵀY)⁻¹(YᵀX) for the linear system X ≈ YB.
+
+    Parameters
+    ----------
+    X : ndarray, shape (m, n)
+        Target matrix containing dependent variables.
+    Y : ndarray, shape (m, p)
+        Design matrix containing independent variables.
+
+    Returns
+    -------
+    B : ndarray, shape (p, n)
+        Coefficient matrix that minimizes the Frobenius norm of (X - YB).
+
+    Raises
+    ------
+    LinAlgError
+        If YᵀY is singular and cannot be inverted, falls back to pseudo-inverse.
+
+    Notes
+    -----
+    1. Solves the ordinary least squares problem in closed form.
+    2. Automatically handles singular matrices by using pseudo-inverse when necessary.
+    3. For numerical stability, consider using np.linalg.lstsq() in production code.
+
+    """
+    # Method 1
+    # # Compute Y transpose multiplied by X: YᵀX (p x n)
+    # YTX = np.dot(Y.T, X)
+
+    # # Compute Y transpose multiplied by Y: YᵀY (p x p)
+    # YTY = np.dot(Y.T, Y)
+
+    # # Compute inverse of YᵀY with fallback to pseudo-inverse
+    # try:
+    #     YTY_inv = np.linalg.inv(YTY)
+    # except np.linalg.LinAlgError:
+    #     YTY_inv = np.linalg.pinv(YTY)
+
+    # # Compute final solution: B = (YᵀY)⁻¹(YᵀX)
+    # B = np.dot(YTY_inv, YTX)
+
+    # Method 2
+    B, residuals, rank, s = np.linalg.lstsq(Y, X, rcond=None)
+
+    # Method 3
+    # from scipy.linalg import lstsq
+    # B = lstsq(Y, X, cond=None)[0]
+
+    return B