scikit-extensions 0.2.2__tar.gz → 0.2.5__tar.gz

{scikit_extensions-0.2.2 → scikit_extensions-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-extensions
-Version: 0.2.2
+Version: 0.2.5
 Summary: A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities.
 Keywords: scikit-learn,transformers,preprocessing,pipeline
 Author: sh99
@@ -95,6 +95,15 @@ mlb = MultiLabelBinarizerTransformer(sparse_output=False)
 transformed = mlb.fit_transform(data)
 ```
 
+Each column can contain label iterables or delimiter-separated strings. String
+values are split on commas by default; pass `delimiter` to use another separator.
+
+```python
+data = pd.DataFrame({'tags': ['python|ml', 'python', 'ml|deep-learning']})
+mlb = MultiLabelBinarizerTransformer(delimiter='|')
+transformed = mlb.fit_transform(data)
+```
+
 ## Development
 
 1. Clone the repository:

{scikit_extensions-0.2.2 → scikit_extensions-0.2.5}/README.md

@@ -76,6 +76,15 @@ mlb = MultiLabelBinarizerTransformer(sparse_output=False)
 transformed = mlb.fit_transform(data)
 ```
 
+Each column can contain label iterables or delimiter-separated strings. String
+values are split on commas by default; pass `delimiter` to use another separator.
+
+```python
+data = pd.DataFrame({'tags': ['python|ml', 'python', 'ml|deep-learning']})
+mlb = MultiLabelBinarizerTransformer(delimiter='|')
+transformed = mlb.fit_transform(data)
+```
+
 ## Development
 
 1. Clone the repository:

{scikit_extensions-0.2.2 → scikit_extensions-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scikit-extensions"
-version = "0.2.2"
+version = "0.2.5"
 description = "A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities."
 readme = "README.md"
 license = "MIT"

{scikit_extensions-0.2.2 → scikit_extensions-0.2.5}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "scikit-extensions"
-version = "0.2.2"
+version = "0.2.5"
 description = "A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities."
 authors = [{ name = "sh99", email = "shriramh99@gmail.com" }]
 readme = "README.md"

scikit_extensions-0.2.5/skext/__init__.py

@@ -0,0 +1,13 @@
+from .multilabels import MultiLabelBinarizerTransformer
+from .multicolinerity import MultiCollinearityReducer
+from .linear_model import OLSRegressor
+from .feature_engineering import RareCategoryEncoder, TargetEncoder, TimeFeatureExtractor
+
+__all__ = [
+    "MultiLabelBinarizerTransformer",
+    "MultiCollinearityReducer",
+    "OLSRegressor",
+    "RareCategoryEncoder",
+    "TargetEncoder",
+    "TimeFeatureExtractor",
+]

scikit_extensions-0.2.5/skext/feature_engineering.py

@@ -0,0 +1,201 @@
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+
+
+class RareCategoryEncoder(BaseEstimator, TransformerMixin):
+    """Replace infrequent categorical values with a fallback label."""
+
+    def __init__(self, min_frequency=0.05, replacement="other", columns=None):
+        self.min_frequency = min_frequency
+        self.replacement = replacement
+        self.columns = columns
+
+    def fit(self, X, y=None):
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+
+        if self.columns is None:
+            self.columns_ = [
+                col for col in X.columns
+                if not pd.api.types.is_numeric_dtype(X[col])
+                and not pd.api.types.is_bool_dtype(X[col])
+            ]
+        else:
+            self.columns_ = list(self.columns)
+            missing = [col for col in self.columns_ if col not in X.columns]
+            if missing:
+                raise ValueError(f"Column '{missing[0]}' is not present in X.")
+
+        self.rare_categories_ = {}
+        for col in self.columns_:
+            values = X[col].astype("object").fillna("__missing__")
+            counts = values.value_counts(normalize=True)
+            threshold = self.min_frequency
+            rare = counts[counts < threshold].index
+            self.rare_categories_[col] = set(rare)
+        return self
+
+    def transform(self, X):
+        if not hasattr(self, "rare_categories_"):
+            raise ValueError("Encoder has not been fitted yet.")
+
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+        transformed = X.copy()
+
+        for col in self.columns_:
+            if col not in transformed.columns:
+                raise ValueError(f"Column '{col}' is not present in X.")
+            values = transformed[col].astype("object").fillna("__missing__")
+            transformed[col] = values.map(
+                lambda value: self.replacement if value in self.rare_categories_[col] else value
+            )
+            transformed[col] = transformed[col].replace("__missing__", self.replacement)
+        return transformed
+
+    def get_feature_names_out(self, input_features=None):
+        if input_features is None:
+            input_features = list(self.columns_)
+        return np.asarray(input_features, dtype=object)
+
+
+class TargetEncoder(BaseEstimator, TransformerMixin):
+    """Encode categorical columns using the mean target value."""
+
+    def __init__(self, columns=None, handle_unknown="mean"):
+        self.columns = columns
+        self.handle_unknown = handle_unknown
+
+    def fit(self, X, y):
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+        y = pd.Series(np.asarray(y)).reset_index(drop=True)
+
+        if self.columns is None:
+            self.columns_ = [
+                col for col in X.columns
+                if not pd.api.types.is_numeric_dtype(X[col])
+                and not pd.api.types.is_bool_dtype(X[col])
+            ]
+        else:
+            self.columns_ = list(self.columns)
+            missing = [col for col in self.columns_ if col not in X.columns]
+            if missing:
+                raise ValueError(f"Column '{missing[0]}' is not present in X.")
+
+        self.global_mean_ = float(y.mean()) if len(y) else 0.0
+        self.mapping_ = {}
+
+        for col in self.columns_:
+            mapping = pd.Series(y.values, index=X[col].astype("object").fillna("__missing__")).groupby(level=0).mean()
+            self.mapping_[col] = mapping.to_dict()
+        return self
+
+    def transform(self, X):
+        if not hasattr(self, "mapping_"):
+            raise ValueError("Encoder has not been fitted yet.")
+
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+        transformed = X.copy()
+
+        for col in self.columns_:
+            if col not in transformed.columns:
+                raise ValueError(f"Column '{col}' is not present in X.")
+            values = transformed[col].astype("object").fillna("__missing__")
+            transformed[col] = values.map(self.mapping_[col]).fillna(self.global_mean_)
+        return transformed
+
+    def get_feature_names_out(self, input_features=None):
+        if input_features is None:
+            input_features = list(self.columns_)
+        return np.asarray(input_features, dtype=object)
+
+
+class TimeFeatureExtractor(BaseEstimator, TransformerMixin):
+    """Extract calendar features from datetime columns."""
+
+    VALID_FEATURES = {
+        "month",
+        "day_of_month",
+        "day_of_week",
+        "hour",
+        "minute",
+        "is_weekend",
+        "quarter",
+        "year",
+    }
+
+    def __init__(self, features=None, columns=None):
+        if features is None:
+            features = ["month", "day_of_week", "hour", "is_weekend"]
+        self.features = list(features)
+        self.columns = columns
+
+    def fit(self, X, y=None):
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+
+        invalid = [feature for feature in self.features if feature not in self.VALID_FEATURES]
+        if invalid:
+            raise ValueError(f"Unsupported time features: {invalid}")
+
+        if self.columns is None:
+            candidate_columns = []
+            for col in X.columns:
+                try:
+                    pd.to_datetime(X[col])
+                    candidate_columns.append(col)
+                except (TypeError, ValueError):
+                    pass
+            self.columns_ = candidate_columns
+        else:
+            self.columns_ = list(self.columns)
+            missing = [col for col in self.columns_ if col not in X.columns]
+            if missing:
+                raise ValueError(f"Column '{missing[0]}' is not present in X.")
+
+        return self
+
+    def transform(self, X):
+        if not hasattr(self, "columns_"):
+            raise ValueError("Transformer has not been fitted yet.")
+
+        X = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+        output = pd.DataFrame(index=X.index)
+
+        for col in self.columns_:
+            if col not in X.columns:
+                raise ValueError(f"Column '{col}' is not present in X.")
+            series = pd.to_datetime(X[col], errors="coerce")
+
+            for feature in self.features:
+                if feature == "month":
+                    values = series.dt.month
+                elif feature == "day_of_month":
+                    values = series.dt.day
+                elif feature == "day_of_week":
+                    values = series.dt.dayofweek
+                elif feature == "hour":
+                    values = series.dt.hour
+                elif feature == "minute":
+                    values = series.dt.minute
+                elif feature == "is_weekend":
+                    values = series.dt.dayofweek.isin([5, 6])
+                elif feature == "quarter":
+                    values = series.dt.quarter
+                elif feature == "year":
+                    values = series.dt.year
+                else:
+                    continue
+
+                name = feature if len(self.columns_) == 1 else f"{col}__{feature}"
+                output[name] = values
+
+        return output
+
+    def get_feature_names_out(self, input_features=None):
+        if not hasattr(self, "columns_"):
+            raise ValueError("Transformer has not been fitted yet.")
+
+        names = []
+        for col in self.columns_:
+            for feature in self.features:
+                names.append(feature if len(self.columns_) == 1 else f"{col}__{feature}")
+        return np.asarray(names, dtype=object)

{scikit_extensions-0.2.2 → scikit_extensions-0.2.5}/skext/multilabels.py

@@ -9,23 +9,27 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
     """
     A custom transformer that wraps sklearn's MultiLabelBinarizer to integrate seamlessly into scikit-learn pipelines.
 
-    This transformer converts a collection of label sets (iterables of iterables) into a binary indicator matrix.
-    It is particularly useful for multi-label classification tasks where each sample can belong to multiple classes.
+    This transformer converts columns containing label iterables or delimiter-separated
+    strings into a binary indicator matrix. String values are split using ``delimiter``.
+    It is particularly useful for multi-label classification tasks where each sample
+    can belong to multiple classes.
 
     Parameters
     ----------
     sparse_output : bool, default=False
         If True, the output will be a sparse matrix in Compressed Sparse Row (CSR) format. Otherwise, a dense NumPy array is returned.
+    delimiter : str, default=","
+        Delimiter used to split string values in input columns.
 
     Attributes
     ----------
-    mlbs : dict
+    mlbs_ : dict
         A dictionary mapping column names to fitted MultiLabelBinarizer instances.
-    feature_names_in_ : list
-        List of input feature names (column names) during fitting.
+    feature_names_in_ : ndarray of shape (n_features_in_,)
+        Input feature names seen during fitting, when all column names are strings.
     """
 
-    def __init__(self, sparse_output=False):
+    def __init__(self, sparse_output=False, delimiter=","):
         """
         Initializes the transformer with the specified parameters.
 
@@ -33,8 +37,18 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         ----------
         sparse_output : bool, default=False
             If True, the output will be a sparse matrix in Compressed Sparse Row (CSR) format. Otherwise, a dense NumPy array is returned.
+        delimiter : str, default=","
+            Delimiter used to split string values in input columns.
         """
         self.sparse_output = sparse_output
+        self.delimiter = delimiter
+
+    def _prepare_column(self, values):
+        return values.map(
+            lambda value: [label.strip() for label in value.split(self.delimiter) if label.strip()]
+            if isinstance(value, str)
+            else value
+        )
 
     def fit(self, X, y=None):
         """
@@ -43,7 +57,8 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         Parameters
         ----------
         X : pandas DataFrame of shape (n_samples, n_features)
-            A collection of label sets, where each set contains the labels for a single sample.
+            Each column contains label iterables or delimiter-separated strings,
+            where each cell contains the labels for one sample.
 
         y : None
             Ignored. This parameter exists for compatibility with scikit-learn pipelines.
@@ -62,7 +77,9 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         elif hasattr(self, "feature_names_in_"):
             del self.feature_names_in_
         self.mlbs_ = {
-            col: MultiLabelBinarizer(sparse_output=self.sparse_output).fit(X[col])
+            col: MultiLabelBinarizer(sparse_output=self.sparse_output).fit(
+                self._prepare_column(X[col])
+            )
             for col in self.input_columns_
         }
         return self
@@ -74,7 +91,8 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         Parameters
         ----------
         X : pandas DataFrame of shape (n_samples, n_features)
-            A collection of label sets to transform.
+            Each column contains label iterables or delimiter-separated strings,
+            where each cell contains the labels for one sample.
 
         Returns
         -------
@@ -90,7 +108,7 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         transformed_parts = []
         for col in self.input_columns_:
             mlb = self.mlbs_[col]
-            part = mlb.transform(X[col])
+            part = mlb.transform(self._prepare_column(X[col]))
             if not self.sparse_output:
                 part = pd.DataFrame(
                     part,

scikit_extensions-0.2.2/skext/__init__.py

@@ -1,5 +0,0 @@
-from .multilabels import MultiLabelBinarizerTransformer
-from .multicolinerity import MultiCollinearityReducer
-from .linear_model import OLSRegressor
-
-__all__ = ["MultiLabelBinarizerTransformer", "MultiCollinearityReducer", "OLSRegressor"]