PODImodels 0.0.3__py3-none-any.whl

PODImodels/PODImodels.py

@@ -0,0 +1,1033 @@
+"""
+POD-based Interpolation Models Implementation
+=============================================
+
+This module contains concrete implementations of POD-based interpolation models
+that inherit from PODImodelAbstract. These models combine Proper Orthogonal
+Decomposition with various machine learning techniques for reduced-order modeling
+of high-dimensional field data.
+
+The models are categorized into two types:
+1. Direct field models (fields*): Learn direct mapping from parameters to field values
+2. POD coefficient models (POD*): Learn mapping from parameters to POD coefficients
+
+Available Models
+----------------
+Linear Regression Models:
+- fieldsLinear: Direct field prediction using linear regression
+- PODLinear: POD coefficient prediction using linear regression
+- fieldsRidge: Direct field prediction using Ridge regression
+- PODRidge: POD coefficient prediction using Ridge regression
+
+Gaussian Process Regression Models:
+- fieldsGPR: Direct field prediction using Gaussian Process Regression
+- PODGPR: POD coefficient prediction using Gaussian Process Regression
+- fieldsRidgeGPR: Field prediction with Ridge regularization and GPR
+- PODRidgeGPR: POD coefficient prediction with Ridge regularization and GPR
+
+Radial Basis Function Models:
+- fieldsRBF: Direct field prediction using Radial Basis Function interpolation
+- PODRBF: POD coefficient prediction using Radial Basis Function interpolation
+- fieldsRidgeRBF: Field prediction with Ridge regularization and RBF
+- PODRidgeRBF: POD coefficient prediction with Ridge regularization and RBF
+
+Neural Network Models:
+- PODANN: POD coefficient prediction using Artificial Neural Networks
+
+Examples
+--------
+>>> # Gaussian Process Regression for POD coefficients
+>>> model = PODGPR(rank=15, with_scaler_x=True, with_scaler_y=True)
+>>> model.fit(parameters, field_snapshots)
+>>> predictions = model.predict(new_parameters)
+
+>>> # Direct field prediction with RBF
+>>> model = fieldsRBF(kernel='thin_plate_spline', degree=2)
+>>> model.fit(parameters, field_snapshots)
+>>> field_prediction = model.predict(test_parameters)
+"""
+
+import numpy as np
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import RBF, ConstantKernel
+from typing import Optional, List, Tuple, Union, Any
+from sklearn.gaussian_process.kernels import Kernel
+from sklearn.linear_model import Ridge
+from sklearn.linear_model import LinearRegression
+from scipy.linalg import svd
+from scipy.interpolate import RBFInterpolator
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import MinMaxScaler
+from .podImodelabstract import PODImodelAbstract
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import random
+
+
+class fieldsLinear(PODImodelAbstract):
+    """
+    Linear regression model for direct field prediction.
+
+    This model learns a direct linear mapping from input parameters to field values
+    without dimensionality reduction. It's suitable for problems where the full
+    field can be effectively approximated by linear combinations of the input parameters.
+
+    Parameters
+    ----------
+    **kwargs
+        Additional keyword arguments passed to the parent PODImodelAbstract class.
+        Common parameters include:
+        - rank : int, Number of POD modes (not used for direct field models)
+        - with_scaler_x : bool, Whether to scale input features
+        - with_scaler_y : bool, Whether to scale target values
+
+    Attributes
+    ----------
+    lin : LinearRegression
+        The underlying scikit-learn LinearRegression model.
+
+    Notes
+    -----
+    This model does not perform POD decomposition since it predicts fields directly.
+    It uses ordinary least squares to find the linear mapping: y = Xβ + ε.
+
+    Examples
+    --------
+    >>> model = fieldsLinear(with_scaler_x=True, with_scaler_y=True)
+    >>> model.fit(parameters, field_data)
+    >>> predictions = model.predict(new_parameters)
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the fieldsLinear model.
+
+        Parameters
+        ----------
+        **kwargs
+            Keyword arguments passed to parent PODImodelAbstract class.
+        """
+        super().__init__(**kwargs)
+
+        self.lin: LinearRegression = LinearRegression()
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        """
+        Fit the linear regression model to the training data.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Preprocessed input features of shape (n_samples, n_features).
+        y : np.ndarray
+            Preprocessed target values of shape (n_samples, n_targets).
+        """
+        self.lin.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        """
+        Make predictions using the trained linear model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input features for prediction.
+
+        Returns
+        -------
+        np.ndarray
+            Predicted field values with appropriate scaling applied.
+        """
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.lin.predict(x))
+        else:
+            return self.lin.predict(x)
+
+
+class PODLinear(PODImodelAbstract):
+    """
+    Linear regression model for POD coefficient prediction.
+
+    This model performs POD decomposition to reduce the dimensionality of field data,
+    then learns a linear mapping from input parameters to POD coefficients. The final
+    field predictions are reconstructed by combining the predicted coefficients with
+    the POD modes.
+
+    Parameters
+    ----------
+    **kwargs
+        Additional keyword arguments passed to the parent PODImodelAbstract class.
+        Important parameters include:
+        - rank : int, Number of POD modes to retain
+        - with_scaler_x : bool, Whether to scale input features
+        - with_scaler_y : bool, Whether to scale POD coefficients
+        - POD_algo : str, POD algorithm ('svd' or 'eigen')
+
+    Attributes
+    ----------
+    lin : LinearRegression
+        The underlying scikit-learn LinearRegression model.
+
+    Notes
+    -----
+    This model first applies POD to reduce field data to coefficients, then uses
+    linear regression to learn the parameter-coefficient mapping. Field reconstruction
+    follows: y_pred = coeffs_pred @ modes, where modes are the POD basis functions.
+
+    Examples
+    --------
+    >>> model = PODLinear(rank=20, POD_algo='svd')
+    >>> model.fit(parameters, field_snapshots)
+    >>> field_predictions = model.predict(new_parameters)
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the PODLinear model.
+
+        Parameters
+        ----------
+        **kwargs
+            Keyword arguments passed to parent PODImodelAbstract class.
+        """
+        super().__init__(**kwargs)
+
+        self.lin: LinearRegression = LinearRegression()
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        """
+        Fit the linear regression model to POD coefficients.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Preprocessed input features of shape (n_samples, n_features).
+        y : np.ndarray
+            Preprocessed POD coefficients of shape (n_samples, rank).
+        """
+        self.lin.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        """
+        Predict field values by first predicting POD coefficients then reconstructing.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input features for prediction.
+
+        Returns
+        -------
+        np.ndarray
+            Reconstructed field values with appropriate scaling applied.
+        """
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.lin.predict(x)) @ self.v
+        else:
+            return self.lin.predict(x) @ self.v
+
+
+class fieldsRidge(PODImodelAbstract):
+    """A Ridge regression model for fields."""
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the fieldsRidge model.
+        """
+        super().__init__(**kwargs)
+
+        self.lin: Ridge = Ridge()
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.lin.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.lin.predict(x))
+        else:
+            return self.lin.predict(x)
+
+
+class PODRidge(PODImodelAbstract):
+    """A Ridge regression model for POD coefficients."""
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the PODRidge model.
+        """
+        super().__init__(**kwargs)
+
+        self.lin: Ridge = Ridge()
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.lin.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.lin.predict(x)) @ self.v
+        else:
+            return self.lin.predict(x) @ self.v
+
+
+class fieldsGPR(PODImodelAbstract):
+    """
+    Gaussian Process Regression model for direct field prediction.
+
+    This model applies Gaussian Process Regression directly to field data without
+    dimensionality reduction. It's particularly effective for problems with smooth
+    parameter-field relationships and when uncertainty quantification is important.
+
+    Parameters
+    ----------
+    kernel : sklearn.gaussian_process.kernels.Kernel, optional
+        The kernel specifying the covariance function for the GP. If None,
+        uses RBF kernel with fixed length scale. Default is None.
+    alpha : float, optional
+        Value added to the diagonal of the kernel matrix during fitting for
+        numerical stability. Represents the expected amount of noise in the
+        observations. Default is 1e-10.
+    **kwargs
+        Additional keyword arguments passed to the parent PODImodelAbstract class.
+
+    Attributes
+    ----------
+    kernel : sklearn.gaussian_process.kernels.Kernel
+        The covariance kernel for the Gaussian Process.
+    alpha : float
+        The noise regularization parameter.
+    gpr : GaussianProcessRegressor
+        The underlying scikit-learn Gaussian Process Regressor.
+
+    Notes
+    -----
+    GPR provides probabilistic predictions and can quantify uncertainty in
+    predictions. The computational complexity scales as O(n³) where n is the
+    number of training samples, making it more suitable for smaller datasets.
+
+    Examples
+    --------
+    >>> from sklearn.gaussian_process.kernels import RBF, Matern
+    >>> kernel = RBF(length_scale=1.0) + Matern(length_scale=2.0)
+    >>> model = fieldsGPR(kernel=kernel, alpha=1e-6)
+    >>> model.fit(parameters, field_data)
+    >>> predictions, std = model.gpr.predict(new_parameters, return_std=True)
+    """
+
+    def __init__(
+        self, kernel: Optional[Kernel] = None, alpha: float = 1.0e-10, **kwargs
+    ):
+        """
+        Initialize the fieldsGPR model.
+
+        Parameters
+        ----------
+        kernel : sklearn.gaussian_process.kernels.Kernel, optional
+            The covariance kernel for the Gaussian Process. If None, uses
+            RBF kernel with fixed length scale.
+        alpha : float, optional
+            Noise regularization parameter. Default is 1e-10.
+        **kwargs
+            Additional arguments passed to parent class.
+        """
+        super().__init__(**kwargs)
+
+        if kernel is None:
+            self.kernel: Kernel = RBF(length_scale=1.0e0, length_scale_bounds="fixed")
+        else:
+            self.kernel: Kernel = kernel
+
+        self.alpha: float = alpha
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        """
+        Fit the Gaussian Process Regression model to the training data.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Preprocessed input features of shape (n_samples, n_features).
+        y : np.ndarray
+            Preprocessed target values of shape (n_samples, n_targets).
+        """
+        self.gpr: GaussianProcessRegressor = GaussianProcessRegressor(
+            kernel=self.kernel, alpha=self.alpha
+        )
+        self.gpr.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        """
+        Make predictions using the trained Gaussian Process model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input features for prediction.
+
+        Returns
+        -------
+        np.ndarray
+            Predicted field values with appropriate scaling applied.
+
+        Notes
+        -----
+        For uncertainty quantification, use self.gpr.predict(x, return_std=True)
+        directly after fitting the model.
+        """
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.gpr.predict(x))
+        else:
+            return self.gpr.predict(x)
+
+
+class PODGPR(PODImodelAbstract):
+    """
+    Gaussian Process Regression model for POD coefficient prediction.
+
+    This model combines POD dimensionality reduction with Gaussian Process Regression.
+    It first applies POD to reduce field data to coefficients, then uses GPR to learn
+    the parameter-coefficient mapping. This approach is more computationally efficient
+    than direct field GPR for high-dimensional problems while preserving the
+    probabilistic nature of GP predictions.
+
+    Parameters
+    ----------
+    kernel : sklearn.gaussian_process.kernels.Kernel, optional
+        The covariance kernel for the Gaussian Process. If None, uses RBF kernel
+        with length scale bounds from 1e-3 to 1e3. Default is None.
+    alpha : float, optional
+        Noise regularization parameter for the GP. Default is 1e-10.
+    **kwargs
+        Additional keyword arguments passed to the parent PODImodelAbstract class.
+        Important parameters include:
+        - rank : int, Number of POD modes to retain
+        - POD_algo : str, POD algorithm ('svd' or 'eigen')
+
+    Attributes
+    ----------
+    kernel : sklearn.gaussian_process.kernels.Kernel
+        The covariance kernel for the Gaussian Process.
+    alpha : float
+        The noise regularization parameter.
+    gpr : GaussianProcessRegressor
+        The underlying scikit-learn Gaussian Process Regressor.
+
+    Notes
+    -----
+    This model offers several advantages:
+    - Computational efficiency through dimensionality reduction
+    - Uncertainty quantification for predictions
+    - Automatic hyperparameter optimization via marginal likelihood
+    - Suitable for nonlinear parameter-field relationships
+
+    The computational complexity scales as O(n³r) where n is the number of training
+    samples and r is the POD rank, making it more efficient than direct field GPR.
+
+    Examples
+    --------
+    >>> from sklearn.gaussian_process.kernels import RBF, WhiteKernel
+    >>> kernel = RBF(length_scale=1.0) + WhiteKernel(noise_level=1e-5)
+    >>> model = PODGPR(rank=15, kernel=kernel, alpha=1e-8)
+    >>> model.fit(parameters, field_snapshots)
+    >>> predictions = model.predict(new_parameters)
+    >>> # Get uncertainty estimates
+    >>> coeffs_pred, coeffs_std = model.gpr.predict(new_parameters, return_std=True)
+    """
+
+    def __init__(
+        self, kernel: Optional[Kernel] = None, alpha: float = 1.0e-10, **kwargs
+    ):
+        """
+        Initialize the PODGPR model.
+
+        Args:
+            kernel (Optional[Kernel]): The kernel to use for the GPR.
+            alpha (float): The noise level for the GPR.
+        """
+        super().__init__(**kwargs)
+
+        if kernel is None:
+            self.kernel: Kernel = RBF(length_scale=1.0e0, length_scale_bounds="fixed")
+        else:
+            self.kernel: Kernel = kernel
+        self.alpha: float = alpha
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.gpr: GaussianProcessRegressor = GaussianProcessRegressor(
+            kernel=self.kernel, alpha=self.alpha
+        )
+        self.gpr.fit(x, y)
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.gpr.predict(x)) @ self.v
+        else:
+            return self.gpr.predict(x) @ self.v
+
+
+class fieldsRidgeGPR(PODImodelAbstract):
+    def __init__(
+        self, kernel: Optional[Kernel] = None, alpha: float = 1.0e-10, **kwargs
+    ):
+        """
+        Initialize the fieldsRidgeGPR model.
+
+        Args:
+            kernel (Optional[Kernel]): The kernel to use for the GPR.
+            alpha (float): The noise level for the GPR.
+        """
+        super().__init__(**kwargs)
+
+        if kernel is None:
+            self.kernel: Kernel = RBF(length_scale=1.0e0, length_scale_bounds="fixed")
+        else:
+            self.kernel: Kernel = kernel
+
+        self.alpha: float = alpha
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.gpr: GaussianProcessRegressor = GaussianProcessRegressor(
+            kernel=self.kernel, alpha=self.alpha
+        )
+        self.lin: Ridge = Ridge()
+
+        self.lin.fit(x, y)
+        self.gpr.fit(x, y - self.lin.predict(x))
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(
+                self.gpr.predict(x) + self.lin.predict(x)
+            )
+        else:
+            return self.gpr.predict(x) + self.lin.predict(x)
+
+
+class PODRidgeGPR(PODImodelAbstract):
+    def __init__(
+        self, kernel: Optional[Kernel] = None, alpha: float = 1.0e-10, **kwargs
+    ):
+        """
+        Initialize the PODRidgeGPR model.
+
+        Args:
+            kernel (Optional[Kernel]): The kernel to use for the GPR.
+            alpha (float): The noise level for the GPR.
+        """
+        super().__init__(**kwargs)
+
+        if kernel is None:
+            self.kernel: Kernel = RBF(length_scale=1.0e0, length_scale_bounds="fixed")
+        else:
+            self.kernel: Kernel = kernel
+        self.alpha: float = alpha
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.gpr: GaussianProcessRegressor = GaussianProcessRegressor(
+            kernel=self.kernel, alpha=self.alpha
+        )
+        self.lin: Ridge = Ridge()
+
+        self.lin.fit(x, y)
+        self.gpr.fit(x, y - self.lin.predict(x))
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            tmp = self.scalar_Y.inverse_transform(
+                self.lin.predict(x) + self.gpr.predict(x)
+            )
+            return tmp @ self.v
+        else:
+            return (self.lin.predict(x) + self.gpr.predict(x)) @ self.v
+
+
+class fieldsRBF(PODImodelAbstract):
+    def __init__(
+        self,
+        kernel: str = "linear",
+        epsilon: float = 1.0,
+        neighbors: Optional[int] = None,
+        **kwargs,
+    ):
+        """
+        Initialize the fieldsRBF model.
+        Args:
+            kernel (str): The kernel to use for the RBF interpolator.
+            epsilon (float): The epsilon parameter for the RBF interpolator.
+            neighbors (int): The number of neighbors for the RBF interpolator.
+        """
+        super().__init__(**kwargs)
+
+        self.kernel: str = kernel
+        self.epsilon: float = epsilon
+        self.neighbors: Optional[int] = neighbors
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.rbf: RBFInterpolator = RBFInterpolator(
+            x, y, kernel=self.kernel, epsilon=self.epsilon, neighbors=self.neighbors
+        )
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            return self.scalar_Y.inverse_transform(self.rbf(x))
+        else:
+            return self.rbf(x)
+
+
+class PODRBF(PODImodelAbstract):
+    def __init__(
+        self,
+        kernel: str = "linear",
+        epsilon: float = 1.0,
+        neighbors: Optional[int] = None,
+        **kwargs,
+    ):
+        """
+        Initialize the PODRBF model.
+
+        Args:
+            kernel (str): The kernel to use for the RBF interpolator.
+            epsilon (float): The epsilon parameter for the RBF interpolator.
+            neighbors (int): The number of neighbors for the RBF interpolator.
+        """
+        super().__init__(**kwargs)
+
+        self.kernel: str = kernel
+        self.epsilon: float = epsilon
+        self.neighbors: Optional[int] = neighbors
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.rbf: RBFInterpolator = RBFInterpolator(
+            x, y, kernel=self.kernel, epsilon=self.epsilon, neighbors=self.neighbors
+        )
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            tmp = self.scalar_Y.inverse_transform(self.rbf(x))
+            return tmp @ self.v
+        else:
+            return self.rbf(x) @ self.v
+
+
+class fieldsRidgeRBF(PODImodelAbstract):
+    def __init__(
+        self,
+        kernel: str = "linear",
+        epsilon: float = 1.0,
+        neighbors: Optional[int] = None,
+        **kwargs,
+    ):
+        """
+        Initialize the fieldsRidgeRBF model.
+
+        Args:
+            kernel (str): The kernel to use for the RBF interpolator.
+            epsilon (float): The epsilon parameter for the RBF interpolator.
+            neighbors (int): The number of neighbors for the RBF interpolator.
+        """
+        super().__init__(**kwargs)
+
+        self.kernel: str = kernel
+        self.epsilon: float = epsilon
+        self.lin: Ridge = Ridge()
+        self.neighbors: Optional[int] = neighbors
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.lin.fit(x, y)
+        self.rbf: RBFInterpolator = RBFInterpolator(
+            x,
+            y - self.lin.predict(x),
+            kernel=self.kernel,
+            epsilon=self.epsilon,
+            neighbors=self.neighbors,
+        )
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            tmp = self.scalar_Y.inverse_transform(self.rbf(x) + self.lin.predict(x))
+            return tmp
+        else:
+            return self.rbf(x) + self.lin.predict(x)
+
+
+class PODRidgeRBF(PODImodelAbstract):
+    def __init__(
+        self,
+        kernel: str = "linear",
+        epsilon: float = 1.0,
+        neighbors: Optional[int] = None,
+        **kwargs,
+    ):
+        """
+        Initialize the PODRidgeRBF model.
+
+        Args:
+            kernel (str): The kernel to use for the RBF interpolator.
+            epsilon (float): The epsilon parameter for the RBF interpolator.
+            neighbors (int): The number of neighbors for the RBF interpolator.
+        """
+        super().__init__(**kwargs)
+
+        self.kernel: str = kernel
+        self.epsilon: float = epsilon
+        self.lin: Ridge = Ridge()
+        self.neighbors: Optional[int] = neighbors
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        self.lin.fit(x, y)
+        self.rbf: RBFInterpolator = RBFInterpolator(
+            x,
+            y - self.lin.predict(x),
+            kernel=self.kernel,
+            epsilon=self.epsilon,
+            neighbors=self.neighbors,
+        )
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+        if self.with_scaler_y:
+            tmp = self.scalar_Y.inverse_transform(self.lin.predict(x) + self.rbf(x))
+            return tmp @ self.v
+        else:
+            return (self.lin.predict(x) + self.rbf(x)) @ self.v
+
+
+class PODANN(PODImodelAbstract):
+    """
+    A PyTorch-based Artificial Neural Network for interpolating POD coefficients.
+
+    This class builds, trains, and uses a fully connected neural network
+    to map input parameters (e.g., CFD boundary conditions) to POD coefficients.
+    It handles data normalization, various activation functions, loss functions,
+    and optimizers.
+    """
+
+    def __init__(
+        self,
+        hidden_layer_sizes: Optional[List[int]] = None,
+        activation_function_name: str = "relu",
+        activation_function: Optional[nn.Module] = None,
+        learning_rate: float = 0.001,
+        loss_function_name: str = "mse",
+        optimizer_name: str = "adam",
+        num_epochs: int = 1000,
+        stop_threshold: float = 1e-4,
+        random_seed: int = 42,
+        with_weight: bool = True,
+        **kwargs,
+    ):
+        """
+        Initializes the PODANN.
+
+        Args:
+            hidden_layer_sizes (list): A list where each element is the number
+                                       of neurons in a corresponding hidden layer.
+                                       Example: [32, 16] for two hidden layers
+                                       with 32 and 16 neurons respectively.
+                                       Defaults to [32, 16] if None.
+            activation_function_name (str): Name of the activation function to use
+                                            in hidden layers ('relu', 'sigmoid', 'tanh').
+                                            Defaults to 'relu'.
+            learning_rate (float): The learning rate for the optimizer. Defaults to 0.001.
+            loss_function_name (str): Name of the loss function ('mse' for Mean Squared Error,
+                                      'l1' for Mean Absolute Error). Defaults to 'mse'.
+            optimizer_name (str): Name of the optimizer ('adam', 'sgd'). Defaults to 'adam'.
+            num_epochs (int): The number of training epochs. Defaults to 1000.
+            stop_threshold (float): Threshold for early stopping based on loss value.
+                                   Defaults to 1e-6.
+            random_seed (int): Random seed for reproducibility. Defaults to 42.
+            with_weight (bool): Whether to use weights in the loss function.
+                                Defaults to True.
+        """
+        super().__init__(**kwargs)
+
+        self.hidden_layer_sizes: Optional[List[int]] = (
+            hidden_layer_sizes if hidden_layer_sizes is not None else [32, 16]
+        )
+        self.activation_function_name: str = activation_function_name.lower()
+        self.activation_function: Optional[nn.Module] = activation_function
+        self.learning_rate: float = learning_rate
+        self.loss_function_name: str = loss_function_name.lower()
+        self.optimizer_name: str = optimizer_name.lower()
+        self.num_epochs: int = num_epochs
+        self.stop_threshold: float = stop_threshold
+        self.random_seed: int = random_seed
+        self.with_weight: bool = with_weight
+
+        # Determine the device to use (GPU if available, otherwise CPU)
+        self.device: torch.device = torch.device(
+            "cuda" if torch.cuda.is_available() else "cpu"
+        )
+        print(f"Using device: {self.device}")
+        if self.device.type == "cuda":
+            print(f"GPU Info: {torch.cuda.get_device_name(0)}")
+        else:
+            print(f"CPU Info: {torch.get_num_threads()} threads")
+
+        # Initialize model and scalers to None, they will be set during fit
+        self.model: Optional[nn.Sequential] = None
+
+        # Set random seed for reproducibility
+        self._set_all_seeds()
+
+    def _get_activation_function(self) -> nn.Module:
+        if (
+            self.activation_function is not None
+            and self.activation_function_name is not None
+        ):
+            raise ValueError(
+                "Both activation_function and activation_function_name are set. "
+                "Please use only one."
+            )
+        elif self.activation_function is not None:
+            return self.activation_function
+        elif self.activation_function_name is not None:
+            if self.activation_function_name == "relu":
+                return nn.ReLU()
+            elif self.activation_function_name == "sigmoid":
+                return nn.Sigmoid()
+            elif self.activation_function_name == "tanh":
+                return nn.Tanh()
+            elif self.activation_function_name == "leaky_relu":
+                return nn.LeakyReLU()
+            elif self.activation_function_name == "elu":
+                return nn.ELU()
+            elif self.activation_function_name == "softmax":
+                return nn.Softmax(dim=1)
+            elif self.activation_function_name == "softplus":
+                return nn.Softplus()
+            else:
+                raise ValueError(
+                    f"Unsupported activation function: {self.activation_function_name}"
+                )
+
+    def _get_loss_function(self) -> nn.Module:
+        """Returns the PyTorch loss function module based on its name."""
+        if self.loss_function_name == "mse":
+            if self.with_weight:
+                return nn.MSELoss(reduction="none")
+            else:
+                return nn.MSELoss()
+        elif self.loss_function_name == "l1":
+            return nn.L1Loss()
+        else:
+            raise ValueError(f"Unsupported loss function: {self.loss_function_name}")
+
+    def _get_optimizer(self, model_parameters) -> optim.Optimizer:
+        """Returns the PyTorch optimizer based on its name and model parameters."""
+        if self.optimizer_name == "adam":
+            return optim.Adam(model_parameters, lr=self.learning_rate)
+        elif self.optimizer_name == "sgd":
+            return optim.SGD(model_parameters, lr=self.learning_rate)
+        else:
+            raise ValueError(f"Unsupported optimizer: {self.optimizer_name}")
+
+    def _build_model(self, input_dim: int, output_dim: int) -> None:
+        """
+        Builds the neural network model dynamically based on specified hidden layers.
+
+        Args:
+            input_dim (int): The number of input features.
+            output_dim (int): The number of output features (POD coefficients).
+        """
+        layers = []
+        current_dim = input_dim
+        activation = self._get_activation_function()
+
+        for h_size in self.hidden_layer_sizes:
+            layers.append(nn.Linear(current_dim, h_size))
+            layers.append(activation)
+            current_dim = h_size
+
+        # Output layer with linear activation (regression problem)
+        layers.append(nn.Linear(current_dim, output_dim))
+
+        self.model = nn.Sequential(*layers).to(self.device)
+        print("\n--- Model Architecture ---")
+        print(self.model)
+        print("--------------------------\n")
+
+    def _set_all_seeds(self) -> None:
+        """
+        Sets the random seed for reproducibility across different libraries.
+        """
+        seed = self.random_seed
+        np.random.seed(seed)  # NumPy seed
+        random.seed(seed)  # Python's built-in random module seed
+        torch.manual_seed(seed)  # PyTorch CPU seed
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(seed)  # PyTorch GPU seed
+            torch.cuda.manual_seed_all(seed)  # PyTorch Multi-GPU seed
+            # Optional: For deterministic CUDA operations, but can slow down training
+            # If you encounter issues, you might need to comment these out.
+            torch.backends.cudnn.deterministic = True
+            torch.backends.cudnn.benchmark = False
+            print(f"CUDA deterministic set to {torch.backends.cudnn.deterministic}")
+
+    def fit_tmp(self, x: np.ndarray, y: np.ndarray) -> None:
+        """
+        Trains the neural network model.
+
+        Args:
+            X_train (np.ndarray): Training input data (parameters).
+                                  Shape: (num_samples, input_dim).
+            y_train (np.ndarray): Training output data (high fidelity data).
+                                  Shape: (num_samples, output_dim).
+        """
+        input_dim = x.shape[1]
+        output_dim = y.shape[1]
+
+        # Convert numpy arrays to PyTorch tensors
+        X_train_tensor = torch.tensor(x, dtype=torch.float32).to(self.device)
+        y_train_tensor = torch.tensor(y, dtype=torch.float32).to(self.device)
+
+        # 2. Build the model
+        self._build_model(input_dim, output_dim)
+
+        # 3. Define loss function and optimizer
+        criterion = self._get_loss_function()
+        optimizer = self._get_optimizer(self.model.parameters())
+
+        # Compute loss
+        if self.with_weight:
+            # set coefficient_weights for weighted loss as the singular values from POD
+            self.coefficient_weights: np.ndarray = self.s
+            if len(self.coefficient_weights) != output_dim:
+                raise ValueError(
+                    f"Length of coefficient_weights ({len(self.coefficient_weights)}) must match output_dim ({output_dim})."
+                )
+            weights_tensor: torch.Tensor = torch.tensor(
+                self.coefficient_weights, dtype=torch.float32
+            ).to(self.device)
+            # Ensure weights are positive
+            if (weights_tensor < 0).any():
+                raise ValueError("Coefficient weights must be non-negative.")
+
+        # 4. Training loop
+        print("Starting model training...")
+        for epoch in range(self.num_epochs):
+            # Set model to training mode
+            self.model.train()
+
+            # Forward pass
+            outputs = self.model(X_train_tensor)
+
+            # Ensure weighting is only applied if loss is MSE
+            if self.with_weight:
+                if self.loss_function_name == "mse":
+                    # Calculate squared error for each element
+                    loss_per_element = criterion(
+                        outputs, y_train_tensor
+                    )  # Use targets from batch (unscaled)
+                    # Apply weights
+                    weighted_loss_per_element = loss_per_element * weights_tensor
+                    # Take the mean of the weighted squared error over all elements
+                    loss = weighted_loss_per_element.mean()
+                else:
+                    # Fallback for other loss functions if implemented without specific weighting logic
+                    print(
+                        "Warning: Coefficient weights are set but loss function is not MSE. Using unweighted loss."
+                    )
+                    loss = criterion(outputs, y_train_tensor)
+            else:
+                # Calculate loss without weights
+                loss = criterion(outputs, y_train_tensor)
+
+            # Backward and optimize
+            optimizer.zero_grad()  # Clear gradients
+            loss.backward()  # Compute gradients
+            optimizer.step()  # Update weights
+
+            if (epoch + 1) % 1000 == 0 or epoch == 0:
+                # Relative L2 norm loss (optional)
+                relative_loss = torch.sqrt(loss) / torch.norm(y_train_tensor)
+                print(
+                    f"Epoch [{epoch+1}/{self.num_epochs}], Loss: {loss.item():.6f}, Relative L2 norm loss: {relative_loss.item():.6f}"
+                )
+
+                # Early stopping condition (optional)
+                if (
+                    relative_loss < self.stop_threshold
+                ):  # Arbitrary threshold for early stopping
+                    print("Early stopping triggered.")
+                    break
+
+        print("Model training finished.")
+
+    def predict_tmp(self, x: np.ndarray) -> np.ndarray:
+        """
+        Predicts POD coefficients for new input data using the trained model.
+
+        Args:
+            x (np.ndarray): Test input data (parameters).
+                                 Shape: (num_samples, input_dim).
+
+        Returns:
+            np.ndarray: Predicted POD coefficients.
+                        Shape: (num_samples, output_dim).
+        """
+
+        if self.model is None:
+            raise RuntimeError("Model has not been trained. Call .fit() first.")
+        if x.ndim != 2:
+            raise ValueError("Test input data must be a 2D numpy array.")
+
+        # Set model to evaluation mode (important for layers like Dropout if they were used)
+        self.model.eval()
+
+        # Normalize test input data
+        if self.with_scaler_x:
+            x = self.scalar_X.transform(x)
+            x = self.check_input(x)
+
+        # Convert to PyTorch tensor
+        X_test_tensor: torch.Tensor = torch.tensor(x, dtype=torch.float32).to(
+            self.device
+        )
+
+        with torch.no_grad():  # Disable gradient calculation during inference
+            predictions = self.model(X_test_tensor).cpu().numpy()
+
+        # De-normalize the predictions
+        if self.with_scaler_y:
+            predictions = self.scalar_Y.inverse_transform(predictions)
+        else:
+            predictions = predictions
+
+        # return high fidelity predictions
+        return predictions @ self.v