chemotools 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

chemotools/feature_selection/_index_selector.py

@@ -1,13 +1,13 @@
+from typing import Optional, Union
+
 import numpy as np
 from sklearn.base import BaseEstimator
 from sklearn.feature_selection._base import SelectorMixin
 
-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 IndexSelector(BaseEstimator, SelectorMixin):
+class IndexSelector(SelectorMixin, BaseEstimator):
     """
     A transformer that Selects the spectral data to a specified array of features. This
     array can be continuous or discontinuous. The array of features is specified by:
@@ -42,8 +42,8 @@ class IndexSelector(BaseEstimator, SelectorMixin):
 
     def __init__(
         self,
-        features: np.ndarray = None,
-        wavenumbers: np.ndarray = None,
+        features: Optional[np.ndarray] = None,
+        wavenumbers: Optional[np.ndarray] = None,
     ):
         self.features = features
         self.wavenumbers = wavenumbers
@@ -66,8 +66,9 @@ class IndexSelector(BaseEstimator, SelectorMixin):
             The fitted transformer.
         """
         # validate that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
         # Set the fitted attribute to True
         self._is_fitted = True
 
@@ -76,13 +77,13 @@ class IndexSelector(BaseEstimator, SelectorMixin):
             self.features_index_ = self.features
             return self
 
-        if self.wavenumbers is None:
+        elif self.wavenumbers is None:
             self.features_index_ = self.features
             return self
 
-        self.features_index_ = self._find_indices()
-
-        return self
+        else:
+            self.features_index_ = self._find_indices(self.features)
+            return self
 
     def _get_support_mask(self):
         """
@@ -102,11 +103,11 @@ class IndexSelector(BaseEstimator, SelectorMixin):
 
         return mask
 
-    def _find_index(self, target: float) -> int:
+    def _find_index(self, target: Union[float, int]) -> int:
         if self.wavenumbers is None:
-            return target
+            return int(target)
         wavenumbers = np.array(self.wavenumbers)
-        return np.argmin(np.abs(wavenumbers - target))
+        return int(np.argmin(np.abs(wavenumbers - target)))
 
-    def _find_indices(self) -> np.ndarray:
-        return np.array([self._find_index(feature) for feature in self.features])
+    def _find_indices(self, features: np.ndarray) -> np.ndarray:
+        return np.array([self._find_index(feature) for feature in features])

chemotools/feature_selection/_range_cut.py

@@ -1,10 +1,12 @@
+from typing import Optional
+
 import numpy as np
 from sklearn.base import BaseEstimator
 from sklearn.feature_selection._base import SelectorMixin
-from sklearn.utils.validation import check_is_fitted
+from sklearn.utils.validation import check_is_fitted, validate_data
 
 
-class RangeCut(BaseEstimator, SelectorMixin):
+class RangeCut(SelectorMixin, BaseEstimator):
     """
     A selector that cuts the input data to a specified range. The range is specified:
     - by the indices of the start and end of the range,
@@ -47,7 +49,7 @@ class RangeCut(BaseEstimator, SelectorMixin):
         self,
         start: int = 0,
         end: int = -1,
-        wavenumbers: np.ndarray = None,
+        wavenumbers: Optional[np.ndarray] = None,
     ):
         self.start = start
         self.end = end
@@ -71,8 +73,9 @@ class RangeCut(BaseEstimator, SelectorMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
             self.start_index_ = self.start
@@ -84,7 +87,6 @@ class RangeCut(BaseEstimator, SelectorMixin):
             self.wavenumbers_ = self.wavenumbers[self.start_index_ : self.end_index_]
 
         return self
-    
 
     def _get_support_mask(self):
         """
@@ -106,4 +108,4 @@ class RangeCut(BaseEstimator, SelectorMixin):
 
     def _find_index(self, target: float) -> int:
         wavenumbers = np.array(self.wavenumbers)
-        return np.argmin(np.abs(wavenumbers - target))
+        return int(np.argmin(np.abs(wavenumbers - target)))

chemotools/scale/__init__.py

@@ -1,3 +1,5 @@
 from ._min_max_scaler import MinMaxScaler
 from ._norm_scaler import NormScaler
 from ._point_scaler import PointScaler
+
+__all__ = ["MinMaxScaler", "NormScaler", "PointScaler"]

chemotools/scale/_min_max_scaler.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 MinMaxScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class MinMaxScaler(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that scales the input data by subtracting the minimum and dividing by
     the difference between the maximum and the minimum. When the use_min parameter is False,
@@ -47,8 +45,9 @@ class MinMaxScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
@@ -72,8 +71,15 @@ class MinMaxScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         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_:

chemotools/scale/_norm_scaler.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 NormScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class NormScaler(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that scales the input data by the L-norm of the spectrum.
 
@@ -44,8 +42,9 @@ class NormScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
@@ -69,8 +68,15 @@ class NormScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         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_:

chemotools/scale/_point_scaler.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 PointScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class PointScaler(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that scales the input data by the intensity value at a given point.
     The point can be specified by an index or by a wavenumber.
@@ -34,7 +34,7 @@ class PointScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         Transform the input data by scaling by the value at a given Point.
     """
 
-    def __init__(self, point: int = 0, wavenumbers: np.ndarray = None):
+    def __init__(self, point: int = 0, wavenumbers: Optional[np.ndarray] = None):
         self.point = point
         self.wavenumbers = wavenumbers
 
@@ -56,8 +56,9 @@ class PointScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
         # Set the point index
         if self.wavenumbers is None:
             self.point_index_ = self.point
@@ -87,8 +88,15 @@ class PointScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         check_is_fitted(self, "point_index_")
 
         # 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_:
@@ -104,4 +112,4 @@ class PointScaler(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
 
     def _find_index(self, target: float) -> int:
         wavenumbers = np.array(self.wavenumbers)
-        return np.argmin(np.abs(wavenumbers - target))
+        return int(np.argmin(np.abs(wavenumbers - target)))

chemotools/scatter/__init__.py

@@ -1,4 +1,13 @@
-from ._extended_multiplicative_scatter_correction import ExtendedMultiplicativeScatterCorrection
+from ._extended_multiplicative_scatter_correction import (
+    ExtendedMultiplicativeScatterCorrection,
+)
 from ._multiplicative_scatter_correction import MultiplicativeScatterCorrection
 from ._robust_normal_variate import RobustNormalVariate
-from ._standard_normal_variate import StandardNormalVariate
+from ._standard_normal_variate import StandardNormalVariate
+
+__all__ = [
+    "ExtendedMultiplicativeScatterCorrection",
+    "MultiplicativeScatterCorrection",
+    "RobustNormalVariate",
+    "StandardNormalVariate",
+]

chemotools/scatter/_extended_multiplicative_scatter_correction.py

@@ -1,13 +1,12 @@
+from typing import Literal, Optional
+
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
-from sklearn.preprocessing import StandardScaler
-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 ExtendedMultiplicativeScatterCorrection(
-    OneToOneFeatureMixin, BaseEstimator, TransformerMixin
+    TransformerMixin, OneToOneFeatureMixin, BaseEstimator
 ):
     """Extended multiplicative scatter correction (EMSC) is a preprocessing technique for
     removing non linear scatter effects from spectra. It is based on fitting a polynomial
@@ -47,18 +46,20 @@ class ExtendedMultiplicativeScatterCorrection(
     model-based pre-processing, doi:10.1016/j.chemolab.2021.104350
     """
 
+    ALLOWED_METHODS = ["mean", "median"]
+
+    # TODO: Check method is valid in instantiation. Right now it is check on fit because it breaks the scikitlearn check_estimator()
+
     def __init__(
         self,
-        reference: np.ndarray = None,
-        use_mean: bool = True,
-        use_median: bool = False,
+        method: Literal["mean", "median"] = "mean",
         order: int = 2,
-        weights: np.ndarray = None,
+        reference: Optional[np.ndarray] = None,
+        weights: Optional[np.ndarray] = None,
     ):
-        self.reference = reference
-        self.use_mean = use_mean
-        self.use_median = use_median
+        self.method = method
         self.order = order
+        self.reference = reference
         self.weights = weights
 
     def fit(self, X: np.ndarray, y=None) -> "ExtendedMultiplicativeScatterCorrection":
@@ -80,7 +81,9 @@ class ExtendedMultiplicativeScatterCorrection(
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
 
         # Check that the length of the reference is the same as the number of features
         if self.reference is not None:
@@ -103,21 +106,24 @@ class ExtendedMultiplicativeScatterCorrection(
             self.weights_ = np.array(self.weights)
             return self
 
-        if self.use_median:
-            self.reference_ = np.median(X, axis=0)
+        if self.method == "mean":
+            self.reference_ = X.mean(axis=0)
             self.indices_ = self._calculate_indices(X[0])
             self.A_ = self._calculate_A(self.indices_, self.reference_)
             self.weights_ = np.array(self.weights)
             return self
 
-        if self.use_mean:
-            self.reference_ = X.mean(axis=0)
+        elif self.method == "median":
+            self.reference_ = np.median(X, axis=0)
             self.indices_ = self._calculate_indices(X[0])
             self.A_ = self._calculate_A(self.indices_, self.reference_)
             self.weights_ = np.array(self.weights)
             return self
 
-        raise ValueError("No reference was provided")
+        else:
+            raise ValueError(
+                f"Invalid method: {self.method}. Must be one of {self.ALLOWED_METHODS}"
+            )
 
     def transform(self, X: np.ndarray, y=None) -> np.ndarray:
         """
@@ -141,17 +147,15 @@ class ExtendedMultiplicativeScatterCorrection(
         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]}"
-            )
-
-        # Calculate the extended multiplicative scatter correction
-        X_ = X.copy()
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
 
         if self.weights is None:
             for i, x in enumerate(X_):

chemotools/scatter/_multiplicative_scatter_correction.py

@@ -1,12 +1,12 @@
+from typing import Literal, 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 MultiplicativeScatterCorrection(
-    OneToOneFeatureMixin, BaseEstimator, TransformerMixin
+    TransformerMixin, OneToOneFeatureMixin, BaseEstimator
 ):
     """Multiplicative scatter correction (MSC) is a preprocessing technique for
     removing scatter effects from spectra. It is based on fitting a linear
@@ -37,16 +37,18 @@ class MultiplicativeScatterCorrection(
 
     """
 
+    ALLOWED_METHODS = ["mean", "median"]
+
+    # TODO: Check method is valid in instantiation. Right now it is check on fit because it breaks the scikitlearn check_estimator()
+
     def __init__(
         self,
-        reference: np.ndarray = None,
-        use_mean: bool = True,
-        use_median: bool = False,
-        weights: np.ndarray = None,
+        method: Literal["mean", "median"] = "mean",
+        reference: Optional[np.ndarray] = None,
+        weights: Optional[np.ndarray] = None,
     ):
+        self.method = method
         self.reference = reference
-        self.use_mean = use_mean
-        self.use_median = use_median
         self.weights = weights
 
     def fit(self, X: np.ndarray, y=None) -> "MultiplicativeScatterCorrection":
@@ -68,8 +70,9 @@ class MultiplicativeScatterCorrection(
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
         # Check that the length of the reference is the same as the number of features
         if self.reference is not None:
             if len(self.reference) != self.n_features_in_:
@@ -90,18 +93,23 @@ class MultiplicativeScatterCorrection(
             self.weights_ = np.array(self.weights)
             return self
 
-        if self.use_median:
-            self.reference_ = np.median(X, axis=0)
+        if self.method == "mean":
+            self.reference_ = X.mean(axis=0)
             self.A_ = self._calculate_A(self.reference_)
             self.weights_ = np.array(self.weights)
             return self
 
-        if self.use_mean:
-            self.reference_ = X.mean(axis=0)
+        elif self.method == "median":
+            self.reference_ = np.median(X, axis=0)
             self.A_ = self._calculate_A(self.reference_)
             self.weights_ = np.array(self.weights)
             return self
 
+        else:
+            raise ValueError(
+                f"Invalid method: {self.method}. Must be one of {self.ALLOWED_METHODS}"
+            )
+
         raise ValueError("No reference was provided")
 
     def transform(self, X: np.ndarray, y=None) -> np.ndarray:
@@ -126,8 +134,15 @@ class MultiplicativeScatterCorrection(
         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_:

chemotools/scatter/_robust_normal_variate.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 RobustNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class RobustNormalVariate(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that calculates the robust normal variate of the input data.
 
@@ -50,8 +48,9 @@ class RobustNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixin)
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
@@ -75,8 +74,15 @@ class RobustNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixin)
         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_:

chemotools/scatter/_standard_normal_variate.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 StandardNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class StandardNormalVariate(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that calculates the standard normal variate of the input data.
 
@@ -36,8 +34,9 @@ class StandardNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
@@ -61,8 +60,15 @@ class StandardNormalVariate(OneToOneFeatureMixin, BaseEstimator, TransformerMixi
         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_:

chemotools/smooth/__init__.py

@@ -1,4 +1,6 @@
 from ._mean_filter import MeanFilter
 from ._median_filter import MedianFilter
 from ._savitzky_golay_filter import SavitzkyGolayFilter
-from ._whittaker_smooth import WhittakerSmooth
+from ._whittaker_smooth import WhittakerSmooth
+
+__all__ = ["MeanFilter", "MedianFilter", "SavitzkyGolayFilter", "WhittakerSmooth"]

chemotools/smooth/_mean_filter.py

@@ -1,12 +1,10 @@
 import numpy as np
 from scipy.ndimage import uniform_filter1d
 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 MeanFilter(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
+class MeanFilter(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
     A transformer that calculates the mean filter of the input data.
 
@@ -50,8 +48,9 @@ class MeanFilter(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
             The fitted transformer.
         """
         # Check that X is a 2D array and has only finite values
-        X = self._validate_data(X)
-
+        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:
@@ -75,8 +74,15 @@ class MeanFilter(OneToOneFeatureMixin, BaseEstimator, TransformerMixin):
         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,
+        )
 
         if X_.shape[1] != self.n_features_in_:
             raise ValueError(