classifier-toolkit 0.2.0__tar.gz → 0.2.2__tar.gz

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Olinda SAS
+Copyright (c) 2025 Olinda SAS
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: classifier-toolkit
-Version: 0.2.0
+Version: 0.2.2
 Summary: 
-Author: gauthier.marquand
-Author-email: gauthier.marquand@qonto.com
+Author: senih.yilmaz
+Author-email: senih.yilmaz@qonto.com
 Requires-Python: >=3.9,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -19,14 +19,22 @@ Requires-Dist: numpy (<2.0)
 Requires-Dist: optuna (>=3.5.0,<4.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: polars (>=1.2.1,<2.0.0)
+Requires-Dist: pyarrow (>=18.0.0,<19.0.0)
 Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
 Requires-Dist: scipy (<1.14)
 Requires-Dist: shap (>=0.44.1,<0.45.0)
 Requires-Dist: statsmodels (>=0.14.2,<0.15.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: tqdm (>=4.66.0,<5.0.0)
 Requires-Dist: xgboost (>=2.1.1,<3.0.0)
 Description-Content-Type: text/markdown
 
+[PyPI: classifier-toolkit](https://pypi.org/project/classifier-toolkit/)
+
+```bash
+pip install classifier-toolkit
+```
+
 # Classifier Toolkit
 
 [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/README.md

@@ -1,3 +1,9 @@
+[PyPI: classifier-toolkit](https://pypi.org/project/classifier-toolkit/)
+
+```bash
+pip install classifier-toolkit
+```
+
 # Classifier Toolkit
 
 [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/classifier_toolkit/eda/visualizations.py

@@ -1260,11 +1260,15 @@ class Visualizations:
 
     def plot_boxplots(self):
         """
-        Plot boxplots for numerical columns by target variable.
+        Plot boxplots for numerical columns by target variable with one random column initially visible.
         """
-
         fig = make_subplots(rows=1, cols=1)
 
+        # Randomly select one column to be initially visible
+        import random
+
+        initial_visible_column = random.choice(self.numerical_columns)
+
         for numeric in self.numerical_columns:
             fig.add_trace(
                 go.Box(
@@ -1272,7 +1276,7 @@ class Visualizations:
                     x=self.data[self.target_column],
                     name=numeric,
                     boxmean=True,
-                    visible="legendonly",  # Make boxplots initially invisible
+                    visible=True if numeric == initial_visible_column else "legendonly",
                 )
             )
 

classifier_toolkit-0.2.2/classifier_toolkit/feature_selection/__init__.py

@@ -0,0 +1,59 @@
+"""Feature selection public API with lazy imports to avoid heavy dependencies at import time.
+
+This module exposes a stable public API while delaying imports of optional heavy
+backends (e.g., LightGBM, XGBoost, CatBoost, Matplotlib) until the corresponding
+symbols are actually accessed. This prevents import-time failures in
+environments where optional system libraries are not present and speeds up
+package import for utilities.
+"""
+
+from importlib import import_module
+from typing import Any, Dict
+
+_EXPORTS: Dict[str, str] = {
+    # Core/base and meta
+    "BaseFeatureSelector": "classifier_toolkit.feature_selection.base",
+    "MetaSelector": "classifier_toolkit.feature_selection.meta_selector",
+    "FeatureStability": "classifier_toolkit.feature_selection.feature_stability",
+    # Embedded methods
+    "ElasticNetLogisticSelector": "classifier_toolkit.feature_selection.embedded_methods.elastic_net",
+    # Utils
+    "plot_feature_importances": "classifier_toolkit.feature_selection.utils.plottings",
+    "plot_rfecv_results": "classifier_toolkit.feature_selection.utils.plottings",
+    "get_scorer": "classifier_toolkit.feature_selection.utils.scoring",
+    "false_positive_rate": "classifier_toolkit.feature_selection.utils.scoring",
+    "true_positive_rate": "classifier_toolkit.feature_selection.utils.scoring",
+    # Wrapper methods
+    "BayesianFeatureSelector": "classifier_toolkit.feature_selection.wrapper_methods.bayesian_search",
+    "BorutaSelector": "classifier_toolkit.feature_selection.wrapper_methods.boruta",
+    "RFESelector": "classifier_toolkit.feature_selection.wrapper_methods.rfe",
+    "RFECatBoostSelector": "classifier_toolkit.feature_selection.wrapper_methods.rfe_catboost",
+    "SequentialSelector": "classifier_toolkit.feature_selection.wrapper_methods.sequential_selection",
+}
+
+__all__ = list(_EXPORTS.keys())
+
+
+def __getattr__(name: str) -> Any:  # pragma: no cover - simple lazy loader
+    """Dynamically import and return the requested symbol on first access.
+
+    This keeps the package import light and avoids importing optional
+    dependencies unless they are actually needed by the user.
+    """
+    module_path = _EXPORTS.get(name)
+    if module_path is None:
+        raise AttributeError(
+            f"module 'classifier_toolkit.feature_selection' has no attribute '{name}'"
+        )
+
+    module = import_module(module_path)
+    try:
+        return getattr(module, name)
+    except AttributeError as exc:  # Provide a clearer error if symbol moved/renamed
+        raise AttributeError(
+            f"'{name}' not found in '{module_path}'. The public API mapping may be outdated."
+        ) from exc
+
+
+def __dir__():  # pragma: no cover - trivial
+    return sorted(list(globals().keys()) + __all__)

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/classifier_toolkit/feature_selection/base.py

@@ -271,13 +271,20 @@ class BaseFeatureSelector(BaseEstimator, TransformerMixin, ABC):
         """
         Fit the selector using RFECV.
 
-        Args:
-            X (pd.DataFrame): The input features.
-            y (pd.Series): The target variable.
-            **rfecv_params: Additional parameters to  to RFECV.
+        Parameters
+        ----------
+        X : pd.DataFrame
+            The input features.
+        y : pd.Series
+            The target variable.
+        rfecv_params : dict, optional
+            Additional parameters to pass to RFECV.
+            See :class:`sklearn.feature_selection.RFECV` for details.
 
-        Returns:
-            self: The fitted selector.
+        Returns
+        -------
+        self : BaseFeatureSelector
+            The fitted selector.
         """
         if self.estimator is None:
             raise ValueError("Estimator is not set. Please provide an estimator.")

classifier_toolkit-0.2.2/classifier_toolkit/feature_selection/feature_stability.py

@@ -0,0 +1,246 @@
+import math
+import random
+from typing import Literal
+
+import pandas as pd
+from tqdm import tqdm
+
+from classifier_toolkit.feature_selection.utils.data_handling import (
+    prepare_data_for_modeling,
+)
+from classifier_toolkit.feature_selection.wrapper_methods.rfe import RFESelector
+
+
+class FeatureStability:
+    """
+    A class for assessing feature stability through various resampling methods.
+
+    This class implements feature stability assessment using different resampling techniques
+    like jackknife, and evaluates feature importance across different subsets of data.
+
+    Parameters
+    ----------
+    X : pd.DataFrame
+        The feature matrix.
+    y : pd.Series
+        The target variable.
+    target_col : str
+        Name of the target column.
+    model_params : dict
+        Parameters for the model to be used.
+    method_params : dict
+        Parameters for the resampling method.
+    model : {'xgboost', 'lightgbm', 'catboost', 'random_forest'}, optional
+        The model to use for feature selection, by default 'xgboost'.
+    method : str, optional
+        The resampling method to use, by default 'jackknife'.
+    seed : int, optional
+        Random seed for reproducibility, by default 42.
+    scoring : {'accuracy', 'f1', 'precision', 'recall', 'roc_auc', 'average_precision'}, optional
+        Scoring metric to use, by default 'average_precision'.
+    cutoff_ratio : float, optional
+        Ratio of features to select in each iteration, by default 0.33.
+
+    Attributes
+    ----------
+    importances : list
+        List of feature importance DataFrames from each iteration.
+    models : list
+        List of fitted RFE models from each iteration.
+    """
+
+    def __init__(
+        self,
+        X: pd.DataFrame,
+        y: pd.Series,
+        target_col: str,
+        model_params: dict,
+        method_params: dict,
+        model: Literal["xgboost", "lightgbm", "catboost", "random_forest"] = "xgboost",
+        method: str = "jackknife",
+        seed: int = 42,
+        scoring: Literal[
+            "accuracy", "f1", "precision", "recall", "roc_auc", "average_precision"
+        ] = "average_precision",
+        cutoff_ratio: float = 0.33,
+    ):
+        self.X = X
+        self.y = y
+        self.model = model
+        self.target_col = target_col
+        self.model_params = model_params
+        self.method = method
+        self.method_params = method_params
+        self.seed = seed
+        self.scoring = scoring
+        self.cutoff_ratio = cutoff_ratio
+
+    def jackknife(self, **kwargs):
+        """
+        Implementation of the Delete-d Jackknife method for feature selection.
+
+        This method creates n_sets from the original dataset by removing d random samples.
+        Theoretically, it can create d chooses n_sets different datasets.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Must include:
+                d : int
+                    Number of samples to be removed
+                n_sets : int
+                    Number of sets to be created
+
+        Returns
+        -------
+        dict
+            Dictionary of boolean masks for each jackknife sample
+
+        Raises
+        ------
+        ValueError
+            If d or n_sets are not provided
+            If d is larger than the number of samples
+            If n_sets is larger than possible combinations
+        """
+
+        d = kwargs.get("d")
+        n_sets = kwargs.get("n_sets")
+
+        if d is None or n_sets is None:
+            raise ValueError("d and n_sets should be provided.")
+
+        indices = {}
+
+        if d > len(self.X):
+            raise ValueError(
+                "d should be smaller than number of samples in the dataframe."
+            )
+        elif n_sets > math.comb(len(self.X), d):
+            raise ValueError(
+                "n_sets should be smaller than d chooses n_sets, which is math.comb(len(X), d)."
+            )
+        else:
+            random.seed(self.seed)
+            theta = len(self.X) - d
+            # Use range(len(X)) instead of X.index
+            positions = list(range(len(self.X) - 1))
+
+            for i in range(n_sets):
+                # Sample positions instead of index values
+                sampled_positions = random.sample(positions, theta)
+                # Convert positions to boolean mask
+                mask = pd.Series(False, index=range(len(self.X)))
+                mask[sampled_positions] = True
+                indices[i] = mask
+
+            return indices
+
+    def fit(self):
+        """
+        Fit the feature stability model using the specified resampling method.
+
+        This method performs feature selection on multiple subsets of the data
+        to assess feature stability. For each subset:
+
+        1. Creates a mask using the specified resampling method
+        2. Selects data using the mask
+        3. Prepares the data for modeling
+        4. Fits an RFE selector
+        5. Stores feature importances and the fitted model
+
+        Returns
+        -------
+        FeatureStability
+            The fitted FeatureStability instance
+
+        Raises
+        ------
+        ValueError
+            If the specified resampling method is not implemented
+        """
+        self.importances = []
+        self.models = []
+
+        if self.method == "jackknife":
+            indices = self.jackknife(**self.method_params)
+        else:
+            raise ValueError("Method not implemented.")
+
+        for i in tqdm(range(len(indices)), desc="Processing indices", unit="index"):
+            rfe_selector = RFESelector(
+                estimator_name=self.model,  # type: ignore
+                n_features_to_select=-1,
+                scoring=self.scoring,  # type: ignore
+                cv=5,
+                verbose=1,
+                model_params=self.model_params,
+                random_state=self.seed,
+                cross_validate_prauc=True,
+            )
+
+            print("Preparing the data for modeling...")
+
+            # Use boolean mask to select rows
+            mask = indices[i]
+            current_X = self.X[mask]
+            current_y = self.y[mask]
+
+            current_X = current_X.reset_index(drop=True)
+            current_y = current_y.reset_index(drop=True)
+
+            X_encoded, y_encoded, cv_folds = prepare_data_for_modeling(
+                current_X,
+                current_y,
+                y_name=self.target_col,
+                n_splits=5,
+                test_size=0.2,
+                random_state=self.seed,
+                encoding_method="distribution",
+                verbose=False,
+            )
+
+            print("Fitting the model...")
+            rfe_selector.fit(X_encoded, y_encoded, cv_folds)
+
+            feature_importances = rfe_selector.get_feature_importances()
+
+            self.importances.append(feature_importances)
+
+            self.models.append(rfe_selector)
+
+    def calculate_stability(self):
+        """
+        Calculate the stability scores for features across all iterations.
+
+        This method analyzes how consistently features are selected across different
+        subsets of the data. It:
+
+        1. Determines the cutoff point based on cutoff_ratio
+        2. Identifies selected features in each iteration
+        3. Calculates how many times each feature was selected
+
+        Returns
+        -------
+        pd.DataFrame
+            DataFrame containing feature names and their selection frequency,
+            sorted by frequency in descending order
+        """
+        cutoff = int(len(self.importances[0]) * self.cutoff_ratio)
+
+        selected = {}
+
+        for i in range(len(self.importances)):
+            selected[i] = list(self.importances[i][:cutoff].index)
+
+        selected_frequency = dict.fromkeys(list(self.X.columns), 0)
+
+        for i in range(len(selected)):
+            for col in selected[i]:
+                selected_frequency[col] += 1
+
+        df = pd.DataFrame(
+            selected_frequency.items(), columns=["Feature Name", "Times Selected"]
+        )
+        df = df.sort_values(by="Times Selected", ascending=False)
+        return df

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/classifier_toolkit/feature_selection/meta_selector.py

@@ -2,7 +2,30 @@ from typing import Dict, List, Literal, Optional, Tuple
 
 import numpy as np
 import pandas as pd
-from tqdm import tqdm
+
+# Optional progress bar dependency. Fall back to a no-op if tqdm is unavailable.
+try:
+    from tqdm import tqdm  # type: ignore
+except Exception:  # pragma: no cover - fallback only used in limited envs
+
+    class tqdm:  # type: ignore
+        def __init__(self, total=None, desc=None):
+            """No-op progress bar placeholder."""
+            self.total = total
+            self.desc = desc
+
+        def update(self, _):
+            """No-op update."""
+            return None
+
+        def set_description(self, *_args, **_kwargs) -> None:
+            """No-op description setter."""
+            return None
+
+        def close(self):
+            """No-op close."""
+            return None
+
 
 from classifier_toolkit.feature_selection.base import (
     BaseFeatureSelector,

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/classifier_toolkit/feature_selection/utils/data_handling.py

@@ -1,6 +1,3 @@
-# TODO: Implement the prequential validation shit
-# Allow users to select their train and test populations
-
 from typing import Dict, List, Literal, Optional, Tuple
 
 import numpy as np
@@ -167,19 +164,30 @@ def prepare_data_for_modeling(
     categorical_features: Optional[List[str]] = None,
     verbose: bool = False,
 ) -> Tuple[pd.DataFrame, pd.Series, Dict]:
-    """
-    Prepare data for modeling by creating cross-validation folds and encoding datasets.
-
-    Args:
-        X (pd.DataFrame): The feature dataframe.
-        y (pd.Series): The target series.
-        n_splits (int): Number of cross-validation splits.
-        test_size (float): Proportion of data to use for testing.
-        random_state (int): Random state for reproducibility.
-        encoding_method (str): Method to use for encoding categorical variables.
-
-    Returns:
-        Tuple[pd.DataFrame, pd.Series, Dict]: Encoded X, encoded y, and encoded cv_folds.
+    """Prepare data for modeling by creating cross-validation folds and encoding datasets.
+
+    Parameters
+    ----------
+    X : pd.DataFrame
+        The feature dataframe.
+    y : pd.Series
+        The target series.
+    n_splits : int
+        Number of cross-validation splits.
+    test_size : float
+        Proportion of data to use for testing.
+    random_state : int
+        Random state for reproducibility.
+    encoding_method : str
+        Method to use for encoding categorical variables.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - pd.DataFrame : Encoded X
+        - pd.Series : Encoded y
+        - dict : Encoded cv_folds
     """
     cv_folds = create_cross_validation_folds(X, y, n_splits, test_size, random_state)
 
@@ -242,3 +250,38 @@ def create_catboost_pools(
         "eval_pool": eval_pool,
         "test_pool": test_pool,
     }
+
+
+def basic_encoder(
+    X_train: pd.DataFrame,
+    X_test: pd.DataFrame,
+    y_train: pd.Series,
+    y_test: pd.Series,
+    target_col: str,
+    features_num: list,
+    features_cat: list,
+    encoding_method: Literal[
+        "one_hot", "distribution", "woe", "catboost"
+    ] = "distribution",
+    verbose: bool = False,
+):
+    encoded_train = X_train.copy()
+    encoded_train[target_col] = y_train
+
+    encoded_test = X_test.copy()
+    encoded_test[target_col] = y_test
+
+    fe = FeatureEngineering(encoded_train, target_col, features_num, features_cat)
+
+    # Encode train data
+    encoded_train = fe.encoding_categorical(encoding_method, fit=True, verbose=verbose)
+    encoded_train[features_cat] = encoded_train[features_cat]
+
+    # Encode test data
+    encoded_test = fe.encoding_categorical(
+        encoding_method, data=encoded_test, fit=False, verbose=verbose
+    )
+
+    encoded_test[features_cat] = encoded_test[features_cat]
+
+    return encoded_train, encoded_test

{classifier_toolkit-0.2.0 → classifier_toolkit-0.2.2}/classifier_toolkit/feature_selection/wrapper_methods/__init__.py

@@ -1,15 +1,23 @@
+from classifier_toolkit.feature_selection.wrapper_methods.bayesian_search import (
+    BayesianFeatureSelector,
+)
+from classifier_toolkit.feature_selection.wrapper_methods.boruta import (
+    BorutaSelector,
+)
 from classifier_toolkit.feature_selection.wrapper_methods.rfe import (
     RFESelector,
 )
 from classifier_toolkit.feature_selection.wrapper_methods.rfe_catboost import (
-    CatBoostClassifier,
+    RFECatBoostSelector,
 )
 from classifier_toolkit.feature_selection.wrapper_methods.sequential_selection import (
     SequentialSelector,
 )
 
 __all__ = [
+    "BayesianFeatureSelector",
+    "BorutaSelector",
     "RFESelector",
-    "CatBoostClassifier",
+    "RFECatBoostSelector",
     "SequentialSelector",
 ]