chemotools 0.0.27__py3-none-any.whl → 0.1.6__py3-none-any.whl

chemotools/augmentation/uniform_noise.py

@@ -0,0 +1,124 @@
+from typing import Optional
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
+from sklearn.utils.validation import check_is_fitted, validate_data
+
+
+class UniformNoise(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
+    """
+    Add uniform noise to the input data.
+
+    Parameters
+    ----------
+    min : float, default=0.0
+        The lower bound of the uniform distribution.
+
+    max : float, default=0.0
+        The upper bound of the uniform distribution.
+
+    random_state : int, default=None
+        The random state to use for the random number generator.
+
+    Attributes
+    ----------
+    n_features_in_ : int
+        The number of features in the input data.
+
+    _is_fitted : bool
+        Whether the transformer has been fitted to data.
+
+    Methods
+    -------
+    fit(X, y=None)
+        Fit the transformer to the input data.
+
+    transform(X, y=0, copy=True)
+        Transform the input data by adding random noise.
+    """
+
+    def __init__(
+        self, min: float = 0.0, max: float = 0.0, random_state: Optional[int] = None
+    ):
+        self.min = min
+        self.max = max
+        self.random_state = random_state
+
+    def fit(self, X: np.ndarray, y=None) -> "UniformNoise":
+        """
+        Fit the transformer to the input data.
+
+        Parameters
+        ----------
+        X : np.ndarray of shape (n_samples, n_features)
+            The input data to fit the transformer to.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        self : UniformNoise
+            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
+        )
+
+        # Set the number of features
+        self.n_features_in_ = X.shape[1]
+
+        # Set the fitted attribute to True
+        self._is_fitted = True
+
+        # Instantiate the random number generator
+        self._rng = np.random.default_rng(self.random_state)
+
+        return self
+
+    def transform(self, X: np.ndarray, y=None) -> np.ndarray:
+        """
+        Transform the input data by adding random uniform noise.
+
+        Parameters
+        ----------
+        X : np.ndarray of shape (n_samples, n_features)
+            The input data to transform.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        X_ : np.ndarray of shape (n_samples, n_features)
+            The transformed data.
+        """
+        # Check that the estimator is fitted
+        check_is_fitted(self, "_is_fitted")
+
+        # Check that X is a 2D array and has only finite values
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
+
+        # Check that the number of features is the same as the fitted data
+        if X_.shape[1] != self.n_features_in_:
+            raise ValueError(
+                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
+            )
+
+        # Calculate the standard uniform variate
+        for i, x in enumerate(X_):
+            X_[i] = self._add_random_noise(x)
+
+        return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+
+    def _add_random_noise(self, x) -> np.ndarray:
+        return x + self._rng.uniform(self.min, self.max, size=x.shape)

chemotools/baseline/__init__.py

@@ -1,8 +1,20 @@
-from .air_pls import AirPls
-from .ar_pls import ArPls
-from .constant_baseline_correction import ConstantBaselineCorrection
-from .cubic_spline_correction import CubicSplineCorrection
-from .linear_correction import LinearCorrection
-from .non_negative import NonNegative
-from .polynomial_correction import PolynomialCorrection
-from .subtract_reference import SubtractReference
+from ._air_pls import AirPls
+from ._ar_pls import ArPls
+from ._constant_baseline_correction import ConstantBaselineCorrection
+from ._cubic_spline_correction import CubicSplineCorrection
+from ._linear_correction import LinearCorrection
+from ._non_negative import NonNegative
+from ._polynomial_correction import PolynomialCorrection
+from ._subtract_reference import SubtractReference
+
+
+__all__ = [
+    "AirPls",
+    "ArPls",
+    "ConstantBaselineCorrection",
+    "CubicSplineCorrection",
+    "LinearCorrection",
+    "NonNegative",
+    "PolynomialCorrection",
+    "SubtractReference",
+]

chemotools/baseline/{air_pls.py → _air_pls.py}

@@ -3,14 +3,12 @@ import numpy as np
 from scipy.sparse import csc_matrix, eye, diags
 from scipy.sparse.linalg import spsolve
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
-
-from chemotools.utils.check_inputs import check_input
+from sklearn.utils.validation import check_is_fitted, validate_data
 
 logger = logging.getLogger(__name__)
 
 
-class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class AirPls(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     This class implements the AirPLS (Adaptive Iteratively Reweighted Penalized Least Squares) algorithm for baseline
     correction of spectra data. AirPLS is a common approach for removing the baseline from spectra, which can be useful
@@ -30,14 +28,6 @@ class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         The number of iterations used to calculate the baseline. Increasing the number of iterations can improve the
         accuracy of the baseline correction, but also increases the computation time.
 
-    Attributes
-    ----------
-    n_features_in_ : int
-        The number of features in the input data.
-
-    _is_fitted : bool
-        A flag indicating whether the estimator has been fitted to data.
-
     Methods
     -------
     fit(X, y=None)
@@ -48,7 +38,7 @@ class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
 
     _calculate_whittaker_smooth(x, w)
         Calculate the Whittaker smooth of a given input vector x, with weights w.
-        
+
     _calculate_air_pls(x)
         Calculate the AirPLS baseline of a given input vector x.
 
@@ -84,14 +74,11 @@ class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         self : AirPls
             Returns the instance itself.
         """
-        # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
 
-        # Set the fitted attribute to True
-        self._is_fitted = True
+        # 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
+        )
 
         return self
 
@@ -113,17 +100,18 @@ class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         """
 
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
-
-        # Check that the number of features is the same as the fitted data
-        if X_.shape[1] != self.n_features_in_:
-            raise ValueError(
-                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
-            )
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         # Calculate the air pls smooth
         for i, x in enumerate(X_):
@@ -132,14 +120,14 @@ class AirPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
     def _calculate_whittaker_smooth(self, x, w):
-        X = np.matrix(x)
+        X = np.array(x)
         m = X.size
         E = eye(m, format="csc")
         for i in range(self.polynomial_order):
             E = E[1:] - E[:-1]
         W = diags(w, 0, shape=(m, m))
-        A = csc_matrix(W + (self.lam * E.T * E))
-        B = csc_matrix(W * X.T)
+        A = csc_matrix(W + (self.lam * E.T @ E))
+        B = csc_matrix(W @ X.T).toarray().ravel()
         background = spsolve(A, B)
         return np.array(background)
 

chemotools/baseline/{ar_pls.py → _ar_pls.py}

@@ -5,14 +5,12 @@ from scipy.sparse import spdiags, csc_matrix
 from scipy.sparse.linalg import splu
 
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
-
-from chemotools.utils.check_inputs import check_input
+from sklearn.utils.validation import check_is_fitted, validate_data
 
 logger = logging.getLogger(__name__)
 
 
-class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class ArPls(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     This class implements the Assymmetrically Reweighted Penalized Least Squares (ArPls) is a baseline
     correction method for spectroscopy data. It uses an iterative process
@@ -29,13 +27,6 @@ class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
     nr_iterations : int, optional (default=100)
         The maximum number of iterations for the weight updating scheme.
 
-    Attributes
-    ----------
-    n_features_in_ : int
-        The number of input features.
-
-    _is_fitted : bool
-        Whether the estimator has been fitted.
 
     Methods
     -------
@@ -53,8 +44,8 @@ class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
 
     References
     ----------
-    - Sung-June Baek, Aaron Park, Young-Jin Ahn, Jaebum Choo 
-    Baseline correction using asymmetrically reweighted penalized 
+    - Sung-June Baek, Aaron Park, Young-Jin Ahn, Jaebum Choo
+    Baseline correction using asymmetrically reweighted penalized
     least squares smoothing
     """
 
@@ -86,13 +77,9 @@ class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         """
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
 
         return self
 
@@ -114,17 +101,17 @@ class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         """
 
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
-
-        # Check that the number of features is the same as the fitted data
-        if X_.shape[1] != self.n_features_in_:
-            raise ValueError(
-                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
-            )
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+        )
 
         # Calculate the ar pls baseline
         for i, x in enumerate(X_):
@@ -133,9 +120,9 @@ class ArPls(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
     def _calculate_diff(self, N):
-        I = sp.eye(N, format="csc")
+        identity_matrix = sp.eye(N, format="csc")
         D2 = sp.diags([1, -2, 1], [0, 1, 2], shape=(N - 2, N), format="csc")
-        return D2.dot(I).T
+        return D2.dot(identity_matrix).T
 
     def _calculate_ar_pls(self, x):
         N = len(x)

chemotools/baseline/{constant_baseline_correction.py → _constant_baseline_correction.py}

@@ -1,11 +1,11 @@
+from typing import Optional
+
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
-
-from chemotools.utils.check_inputs import check_input
+from sklearn.utils.validation import check_is_fitted, validate_data
 
 
-class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class ConstantBaselineCorrection(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that corrects a baseline by subtracting a constant value.
     The constant value is taken by the mean of the features between the start
@@ -30,12 +30,6 @@ class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, Transforme
     end_index_ : int
         The index of the end of the range. It is 1 if the wavenumbers are not provided.
 
-    n_features_in_ : int
-        The number of features in the input data.
-
-    _is_fitted : bool
-        Whether the transformer has been fitted to data.
-
     Methods
     -------
     fit(X, y=None)
@@ -46,7 +40,10 @@ class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, Transforme
     """
 
     def __init__(
-        self, start: int = 0, end: int = 1, wavenumbers: np.ndarray = None,
+        self,
+        start: int = 0,
+        end: int = 1,
+        wavenumbers: Optional[np.ndarray] = None,
     ) -> None:
         self.start = start
         self.end = end
@@ -70,13 +67,9 @@ class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, Transforme
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
 
         # Set the start and end indices
         if self.wavenumbers is None:
@@ -109,17 +102,18 @@ class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, Transforme
             The transformed input data.
         """
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
-
-        # Check that the number of features is the same as the fitted data
-        if X_.shape[1] != self.n_features_in_:
-            raise ValueError(
-                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
-            )
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         # Base line correct the spectra
         for i, x in enumerate(X_):
@@ -128,7 +122,5 @@ class ConstantBaselineCorrection(OneToOneFeatureMixin, BaseEstimator, Transforme
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
     def _find_index(self, target: float) -> int:
-        if self.wavenumbers is None:
-            return target
         wavenumbers = np.array(self.wavenumbers)
-        return np.argmin(np.abs(wavenumbers - target))
+        return np.argmin(np.abs(wavenumbers - target)).astype(int)

chemotools/baseline/{cubic_spline_correction.py → _cubic_spline_correction.py}

@@ -1,13 +1,14 @@
+from typing import Optional
+
 import numpy as np
 from scipy.interpolate import CubicSpline
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
+from sklearn.utils.validation import check_is_fitted, validate_data
 
-from chemotools.utils.check_inputs import check_input
 
-class CubicSplineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class CubicSplineCorrection(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
-    A transformer that corrects a baseline by subtracting a cubic spline through the 
+    A transformer that corrects a baseline by subtracting a cubic spline through the
     points defined by the indices.
 
     Parameters
@@ -32,7 +33,8 @@ class CubicSplineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
         Transform the input data by subtracting the constant baseline value.
 
     """
-    def __init__(self, indices: list = None) -> None:
+
+    def __init__(self, indices: Optional[list] = None) -> None:
         self.indices = indices
 
     def fit(self, X: np.ndarray, y=None) -> "CubicSplineCorrection":
@@ -53,13 +55,9 @@ class CubicSplineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
 
         if self.indices is None:
             self.indices_ = [0, len(X[0]) - 1]
@@ -89,15 +87,24 @@ class CubicSplineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
             The transformed data.
         """
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "indices_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         # Check that the number of features is the same as the fitted data
         if X_.shape[1] != self.n_features_in_:
-            raise ValueError(f"Expected {self.n_features_in_} features but got {X_.shape[1]}")
+            raise ValueError(
+                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
+            )
 
         # Calculate spline baseline correction
         for i, x in enumerate(X_):
@@ -106,7 +113,7 @@ class CubicSplineCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
 
     def _spline_baseline_correct(self, x: np.ndarray) -> np.ndarray:
         indices = self.indices_
-        intensity = x[indices]  
+        intensity = x[indices]
         spl = CubicSpline(indices, intensity)
-        baseline = spl(range(len(x)))      
-        return x - baseline
+        baseline = spl(range(len(x)))
+        return x - baseline

chemotools/baseline/{linear_correction.py → _linear_correction.py}

@@ -1,26 +1,13 @@
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
+from sklearn.utils.validation import check_is_fitted, validate_data
 
-from chemotools.utils.check_inputs import check_input
 
-
-class LinearCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class LinearCorrection(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that corrects a baseline by subtracting a linear baseline through the
     initial and final points of the spectrum.
 
-    Parameters
-    ----------
-
-    Attributes
-    ----------
-    n_features_in_ : int
-        The number of features in the input data.
-
-    _is_fitted : bool
-        Whether the transformer has been fitted to data.
-
     Methods
     -------
     fit(X, y=None)
@@ -31,7 +18,6 @@ class LinearCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
     """
 
     def _drift_correct_spectrum(self, x: np.ndarray) -> np.ndarray:
-
         # Can take any array and returns with a linear baseline correction
         # Find the x values at the edges of the spectrum
         y1: float = x[0]
@@ -68,13 +54,9 @@ class LinearCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
 
         return self
 
@@ -99,17 +81,26 @@ class LinearCorrection(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The transformed data.
         """
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         # Check that the number of features is the same as the fitted data
         if X_.shape[1] != self.n_features_in_:
-            raise ValueError(f"Expected {self.n_features_in_} features but got {X_.shape[1]}")
+            raise ValueError(
+                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
+            )
 
         # Calculate non-negative values
         for i, x in enumerate(X_):
             X_[i, :] = self._drift_correct_spectrum(x)
-        return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+        return X_.reshape(-1, 1) if X_.ndim == 1 else X_

chemotools/baseline/{non_negative.py → _non_negative.py}

@@ -1,11 +1,9 @@
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.utils.validation import check_is_fitted
+from sklearn.utils.validation import check_is_fitted, validate_data
 
-from chemotools.utils.check_inputs import check_input
 
-
-class NonNegative(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class NonNegative(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that sets all negative values to zero or to abs.
 
@@ -14,14 +12,6 @@ class NonNegative(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
     mode : str, optional
         The mode to use for the non-negative values. Can be "zero" or "abs".
 
-    Attributes
-    ----------
-    n_features_in_ : int
-        The number of features in the input data.
-
-    _is_fitted : bool
-        Whether the transformer has been fitted to data.
-
     Methods
     -------
     fit(X, y=None)
@@ -52,14 +42,9 @@ class NonNegative(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
-
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
         return self
 
     def transform(self, X: np.ndarray, y=None) -> np.ndarray:
@@ -80,11 +65,18 @@ class NonNegative(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The transformed data.
         """
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
-        X = check_input(X)
-        X_ = X.copy()
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         # Check that the number of features is the same as the fitted data
         if X_.shape[1] != self.n_features_in_: