chemotools 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

chemotools/augmentation/__init__.py

@@ -1,6 +1,7 @@
 from ._add_noise import AddNoise
 from ._baseline_shift import BaselineShift
 from ._fractional_shift import FractionalShift
+from ._gaussian_broadening import GaussianBroadening
 from ._index_shift import IndexShift
 from ._spectrum_scale import SpectrumScale
 
@@ -9,6 +10,7 @@ __all__ = [
     "AddNoise",
     "BaselineShift",
     "FractionalShift",
+    "GaussianBroadening",
     "IndexShift",
     "SpectrumScale",
 ]

chemotools/augmentation/_gaussian_broadening.py

@@ -0,0 +1,136 @@
+from typing import Literal, Optional
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
+from sklearn.utils.validation import check_is_fitted, validate_data
+
+
+class GaussianBroadening(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
+    """
+    Transform spectral data by broadening peaks using Gaussian convolution.
+
+    This transformer applies Gaussian smoothing to broaden peaks in spectral data.
+    For each signal, a random sigma is chosen between 0 and the specified sigma value.
+
+    Parameters
+    ----------
+    sigma : float, default=1.0
+        Maximum standard deviation for the Gaussian kernel.
+        The actual sigma used will be randomly chosen between 0 and this value.
+
+    mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, default='reflect'
+        The mode parameter determines how the input array is extended when
+        the filter overlaps a border. Default is 'reflect'.
+
+    pad_value : float, default=0.0
+        Value to fill past edges of input if mode is 'constant'.
+
+    random_state : int, optional, default=None
+        Random state for reproducible sigma selection.
+
+    truncate : float, default=4.0
+        Truncate the filter at this many standard deviations.
+        Larger values increase computation time but improve accuracy.
+    """
+
+    def __init__(
+        self,
+        sigma: float = 1.0,
+        mode: Literal["reflect", "constant", "nearest", "mirror", "wrap"] = "reflect",
+        pad_value: float = 0.0,
+        random_state: Optional[int] = None,
+        truncate: float = 4.0,
+    ):
+        self.sigma = sigma
+        self.mode = mode
+        self.pad_value = pad_value
+        self.random_state = random_state
+        self.truncate = truncate
+
+    def fit(self, X: np.ndarray, y=None) -> "GaussianBroadening":
+        """
+        Fit the transformer to the data (in this case, only validates input).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input data to validate.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        self : GaussianBroadening
+            The fitted transformer.
+        """
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
+
+        # Validate sigma parameter
+        if not isinstance(self.sigma, (int, float)):
+            raise ValueError("sigma must be a number")
+        if self.sigma < 0:
+            raise ValueError("sigma must be non-negative")
+
+        # Initialize random number generator
+        self._rng = np.random.default_rng(self.random_state)
+
+        return self
+
+    def transform(self, X: np.ndarray, y=None) -> np.ndarray:
+        """
+        Apply Gaussian broadening to the input data.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data to transform.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        X_transformed : ndarray of shape (n_samples, n_features)
+            The transformed data with broadened peaks.
+        """
+        check_is_fitted(self, "n_features_in_")
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
+
+        # Transform each sample
+        for i, x in enumerate(X_):
+            X_[i] = self._broaden_signal(x)
+
+        return X_
+
+    def _broaden_signal(self, x: np.ndarray) -> np.ndarray:
+        """
+        Apply Gaussian broadening to a single signal.
+
+        Parameters
+        ----------
+        x : ndarray of shape (n_features,)
+            The input signal to broaden.
+
+        Returns
+        -------
+        broadened_signal : ndarray of shape (n_features,)
+            The broadened signal.
+        """
+        # Randomly choose sigma between 0 and max sigma
+        sigma = self._rng.uniform(0, self.sigma)
+
+        # Apply Gaussian filter
+        return gaussian_filter1d(
+            x, sigma=sigma, mode=self.mode, cval=self.pad_value, truncate=self.truncate
+        )

chemotools/feature_selection/__init__.py

@@ -1,4 +1,6 @@
 from ._index_selector import IndexSelector
 from ._range_cut import RangeCut
+from ._sr_selector import SRSelector
+from ._vip_selector import VIPSelector
 
-__all__ = ["IndexSelector", "RangeCut"]
+__all__ = ["IndexSelector", "RangeCut", "SRSelector", "VIPSelector"]

chemotools/feature_selection/_base.py

@@ -0,0 +1,88 @@
+from abc import ABC, abstractmethod
+from typing import Union
+
+import numpy as np
+
+from sklearn.base import BaseEstimator
+from sklearn.cross_decomposition._pls import _PLS
+from sklearn.feature_selection._base import SelectorMixin
+from sklearn.pipeline import Pipeline
+from sklearn.utils.validation import check_is_fitted
+
+ModelTypes = Union[_PLS, Pipeline]
+
+
+class _PLSFeatureSelectorBase(ABC, BaseEstimator, SelectorMixin):
+    """Feature selection base class for _PLS-like models.
+
+
+    Parameters
+    ----------
+    model : Union[_PLS, Pipeline]
+        A fitted  _PLS models or Pipeline ending with such a model
+
+    threshold : float
+        The threshold for feature selection. Features with importance
+        above this threshold will be selected.
+
+    Attributes
+    ----------
+    estimator_ : ModelTypes
+        The fitted model of type _BasePCA or _PLS
+
+    feature_scores_ : np.ndarray
+        The calculated feature scores based on the selected method.
+
+    support_mask : np.ndarray
+        The boolean mask indicating which features are selected.
+    """
+
+    def __init__(
+        self,
+        model: Union[_PLS, Pipeline],
+    ) -> None:
+        self.estimator_ = _validate_and_extract_model(model)
+
+    @abstractmethod
+    def _calculate_features(self, X: np.ndarray) -> np.ndarray:
+        """Calculate the residuals of the model.
+
+        Returns
+        -------
+        ndarray of shape (n_samples,)
+            The residuals of the model
+        """
+
+
+def _validate_and_extract_model(
+    model: Union[_PLS, Pipeline],
+) -> _PLS:
+    """Validate and extract the model.
+
+    Parameters
+    ----------
+    model : Union[_PLS, Pipeline]
+        A fitted _PLS model or Pipeline ending with such a model
+
+    Returns
+    -------
+    _PLS
+        The extracted estimator
+
+    Raises
+    ------
+    TypeError
+        If the model is not of type _BasePCA or _PLS or a Pipeline ending with one of these types or if the model is not fitted
+    """
+    if isinstance(model, Pipeline):
+        estimator = model[-1]
+    else:
+        estimator = model
+
+    if not isinstance(estimator, _PLS):
+        raise TypeError(
+            "Model not a valid model. Must be of base type _BasePCA or _PLS or a Pipeline ending with one of these types."
+        )
+
+    check_is_fitted(model)
+    return estimator

chemotools/feature_selection/_sr_selector.py

@@ -0,0 +1,137 @@
+import numpy as np
+from sklearn.utils.validation import validate_data
+
+from ._base import _PLSFeatureSelectorBase
+
+
+class SRSelector(_PLSFeatureSelectorBase):
+    """
+    This selector is used to select features that contribute significantly
+    to the latent variables in a PLS regression model using the Selectivity
+    Ratio (SR) method.
+
+    Parameters
+    ----------
+    - model: Union[_PLS, Pipeline]
+        The PLS regression model or a pipeline with a PLS regression model as last step.
+
+    - threshold: float, default=1.0
+        The threshold for feature selection. Features with importance
+        above this threshold will be selected.
+
+    Attributes
+    ----------
+    estimator_ : ModelTypes
+        The fitted model of type _BasePCA or _PLS
+
+    feature_scores_ : np.ndarray
+        The calculated feature scores based on the selected method.
+
+    support_mask_ : np.ndarray
+        The boolean mask indicating which features are selected.
+
+    Methods
+    -------
+    fit(X, y=None)
+        Fit the transformer to the input data. It calculates the feature scores and the feature_mask.
+    """
+
+    def __init__(
+        self,
+        model,
+        threshold: float = 1.0,
+    ):
+        self.model = model
+        self.threshold = threshold
+        super().__init__(self.model)
+
+    def fit(self, X: np.ndarray, y=None) -> "SRSelector":
+        """
+        Fit the transformer to calculate the feature scores and the support mask.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The input data to fit the transformer to.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        self : SRSelector
+            The fitted transformer.
+        """
+        # Check that X is a 2D array and has only finite values
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
+
+        # Calculate the SR scores
+        self.feature_scores_ = self._calculate_features(X)
+
+        # Calculate the support mask
+        self.support_mask_ = self._get_support_mask()
+
+        return self
+
+    def _get_support_mask(self) -> np.ndarray:
+        """
+        Get the support mask based on the feature scores and threshold.
+        Features with scores above the threshold are selected.
+        Parameters
+        ----------
+        self : SRSelector
+            The fitted transformer.
+
+        Returns
+        -------
+        support_mask_ : np.ndarray
+            The boolean mask indicating which features are selected.
+        """
+        return self.feature_scores_ > self.threshold
+
+    def _calculate_features(self, X: np.ndarray) -> np.ndarray:
+        """
+        Vectorized Selectivity Ratio calculation from a fitted _PLS
+        like model.
+
+        Parameters:
+        ----------
+        - self: SRSelector
+            The fitted transformer.
+
+        - X: array-like of shape (n_samples, n_features)
+            The input training data to calculate the feature scores from.
+
+        Returns
+        -------
+        feature_scores_ : np.ndarray
+            The calculated feature scores based on the selected method.
+        """
+        bpls = self.estimator_.coef_
+        bpls_norm = bpls.T / np.linalg.norm(bpls)
+
+        # Handle 1D case correctly
+        if bpls.ndim == 1:
+            bpls_norm = bpls_norm.reshape(-1, 1)
+
+        # Project X onto the regression vector
+        ttp = X @ bpls_norm
+        ptp = X.T @ np.linalg.pinv(ttp).T
+
+        # Predicted part of X
+        X_hat = ttp @ ptp.T
+
+        # Compute squared norms directly
+        total_ss = np.linalg.norm(X, axis=0) ** 2
+        explained_ss = np.linalg.norm(X_hat, axis=0) ** 2
+
+        # Calculate residual sum of squares
+        residual_ss = total_ss - explained_ss
+
+        # Stability: avoid division by zero
+        epsilon = 1e-12
+
+        # Calculate Selectivity Ratio
+        return explained_ss / (residual_ss + epsilon)

chemotools/feature_selection/_vip_selector.py

@@ -0,0 +1,129 @@
+import numpy as np
+from sklearn.utils.validation import validate_data
+
+from ._base import _PLSFeatureSelectorBase
+
+
+class VIPSelector(_PLSFeatureSelectorBase):
+    """
+    This selector is used to select features that contribute significantly
+    to the latent variables in a PLS regression model using the Variables
+    Importance in Projection (VIP) method.
+
+    Parameters
+    ----------
+    - model: Union[_PLS, Pipeline]
+        The PLS regression model or a pipeline with a PLS regression model as last step.
+
+    - threshold: float, default=1.0
+        The threshold for feature selection. Features with importance
+        above this threshold will be selected.
+
+    Attributes
+    ----------
+    estimator_ : ModelTypes
+        The fitted model of type _BasePCA or _PLS
+
+    feature_scores_ : np.ndarray
+        The calculated feature scores based on the selected method.
+
+    support_mask_ : np.ndarray
+        The boolean mask indicating which features are selected.
+
+    Methods
+    -------
+    fit(X, y=None)
+        Fit the transformer to the input data. It calculates the feature scores and the feature_mask.
+    """
+
+    def __init__(
+        self,
+        model,
+        threshold: float = 1.0,
+    ):
+        self.model = model
+        self.threshold = threshold
+        super().__init__(self.model)
+
+    def fit(self, X: np.ndarray, y=None) -> "VIPSelector":
+        """
+        Fit the transformer to calculate the feature scores and the support mask.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The input data to fit the transformer to.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        self : VIPSelector
+            The fitted transformer.
+        """
+        # Check that X is a 2D array and has only finite values
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
+
+        # Calculate the VIP scores
+        self.feature_scores_ = self._calculate_features(X)
+
+        # Calculate the support mask
+        self.support_mask_ = self._get_support_mask()
+
+        return self
+
+    def _get_support_mask(self) -> np.ndarray:
+        """
+        Get the support mask based on the feature scores and threshold.
+        Features with scores above the threshold are selected.
+        Parameters
+        ----------
+        self : VIPSelector
+            The fitted transformer.
+
+        Returns
+        -------
+        support_mask_ : np.ndarray
+            The boolean mask indicating which features are selected.
+        """
+        return self.feature_scores_ > self.threshold
+
+    def _calculate_features(self, X: np.ndarray) -> np.ndarray:
+        """
+        Calculate the VIP scores based on the fitted model.
+
+        Parameters
+        ----------
+        self : VIPSelector
+            The fitted transformer.
+
+        Returns
+        -------
+        feature_scores_ : np.ndarray
+            The calculated feature scores based on the selected method.
+        """
+        # Calculate sum of squares of y_loadings and x_scores
+        sum_of_squares_y_loadings = (
+            np.linalg.norm(self.estimator_.y_loadings_, ord=2, axis=0) ** 2
+        )
+        sum_of_squares_x_scores = (
+            np.linalg.norm(self.estimator_.x_scores_, ord=2, axis=0) ** 2
+        )
+
+        # Calculate the sum of squares
+        sum_of_squares = sum_of_squares_y_loadings * sum_of_squares_x_scores
+
+        # Calculate the numerator
+        numerator = self.estimator_.n_features_in_ * np.sum(
+            sum_of_squares * self.estimator_.x_weights_**2,
+            axis=1,
+        )
+
+        # Calculate the denominator
+        denominator = np.sum(sum_of_squares, axis=0)
+
+        # Calculate the VIP scores
+        return np.sqrt(numerator / denominator)

chemotools/outliers/__init__.py

@@ -0,0 +1,7 @@
+from .dmodx import DModX
+from .hotelling_t2 import HotellingT2
+from .q_residuals import QResiduals
+from .leverage import Leverage
+from .studentized_residuals import StudentizedResiduals
+
+__all__ = ["DModX", "HotellingT2", "QResiduals", "Leverage", "StudentizedResiduals"]