classifier-toolkit 0.3.6__tar.gz → 0.4.0__tar.gz

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/.gitignore

@@ -178,4 +178,8 @@ cython_debug/
 catboost_info/
 
 # Gitkeep
-!/**/.gitkeep
+!/**/.gitkeep
+
+# Claude Code local state (worktrees, personal settings)
+.claude/worktrees/
+.claude/settings.local.json

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: classifier-toolkit
-Version: 0.3.6
+Version: 0.4.0
 Project-URL: Documentation, https://supreme-adventure-jg5qkyr.pages.github.io/
 Author-email: "senih.yilmaz" <senih.yilmaz@qonto.com>, "jeremy.fraoua" <jeremy.fraoua@qonto.com>, "gauthier.marquand" <gauthier.marquand@qonto.com>, "arnaud.alepee" <arnaud.alepee@qonto.com>
 License-File: LICENSE
@@ -18,6 +18,7 @@ Requires-Dist: polars<2.0.0,>=1.2.1
 Requires-Dist: pyarrow>=18.0.0
 Requires-Dist: scikit-learn<2.0.0,>=1.4.0
 Requires-Dist: scipy>=1.11.0
+Requires-Dist: seaborn<0.14.0,>=0.13.0
 Requires-Dist: shap>=0.46.0
 Requires-Dist: statsmodels<0.15.0,>=0.14.2
 Requires-Dist: tabulate<0.10.0,>=0.9.0
@@ -60,13 +61,17 @@ This library is published in the PyPI directory. To install, users can run pip i
 
 ### Usage
 
-This library automates binary classification tasks in the finance domain, specifically for default and fraud labeling. It includes several packages designed to address the main steps in any machine learning/data science task:
+This library automates binary and multiclass classification workflows. It is independent of the modelled problem: the class of interest is configured through `pos_label` (the positive class for binary targets, the class of interest for multiclass ones). It includes several packages designed to address the main steps in any machine learning/data science task:
 
-1. **EDA**: accessible via `EDA_Toolkit`. Provides EDA and feature engineering functionality with all necessary visualizations.
+1. **EDA**: accessible via `EDAToolkit`. Provides EDA and feature engineering functionality with all necessary visualizations.
 2. **Feature Reduction**: filter-style pre-selection pipeline (expert rules, low variance, drift, predictive power, counter-intuitive direction, high correlation).
 3. **Feature Selection**: wrapper and embedded methods (RFE, Boruta, Sequential, Bayesian, ElasticNet, MetaSelector).
-4. **Model Training**: accessible via `Tuner`. Hyperparameter optimization (grid search, Bayesian via Optuna) for LightGBM and CatBoost with train/val/test evaluation.
-5. Evaluation and reporting: To be implemented.
+4. **Model Training**: accessible via `Tuner`. Hyperparameter optimization (grid search, Bayesian via Optuna) for LightGBM and CatBoost with train/val/test evaluation, including multiclass objectives and class weights.
+5. **Risk Class**: `RiskClassBuilderDP` / `RiskClassBuilder` turn model scores into risk classes with statistically validated, ordered event rates.
+6. **Model Validation**: `Evaluator` computes metrics, calibration and stability checks for any model exposing `predict_proba`.
+7. **Calibration**: `OVRHistogramCalibrator` and `plot_reliability_curves` for One-vs-Rest probability calibration.
+8. **Explainability**: SHAP-based explanations, interactions and misclassification diagnostics.
+9. **Data Partition**: temporal-aware train/test splitting, preprocessing and dtype optimization.
 
 For detailed usage, refer to the documentation.
 
@@ -139,16 +144,46 @@ For detailed usage, refer to the documentation.
 - **Model Training**: Hyperparameter optimization for LightGBM and CatBoost, with support for grid search and Bayesian optimization (via Optuna).
 
   ```python
-  from classifier_toolkit.model_training.hyper_parameter_tuning import Tuner
+  from classifier_toolkit.model_training.hyper_parameter_tuning.tuner import Tuner
+
+  tuner = Tuner(
+      X=X_train, y=y_train,
+      model_name="lightgbm",
+      X_val=X_val, y_val=y_val,
+      X_test=X_test, y_test=y_test,
+      search_method="bayesian",
+      n_trials=50,
+      optimization_metric="prauc",
+  )
+  result = tuner.tune()
+
+  best_model = result["best_model"]
+  result["trials_results"]  # full trial results (DataFrame)
+  ```
+
+  Reported metrics are `auc`, `prauc`, `ks`, `log_loss` and `brier` (`ks`/`brier` are binary-only). Custom parameter search spaces can be defined via `ModelParams` and `ParamRange`.
+
+- **Risk Class**: Builds risk classes from model scores. `RiskClassBuilderDP` searches bin edges with dynamic programming so that each class' observed event rate falls in a target band (`target_ranges`, required), then checks that adjacent classes are statistically distinguishable; `RiskClassBuilder` discovers classes with KMeans.
 
-  tuner = Tuner(model_name="lightgbm", metric="auc", search_type="bayesian", n_trials=50)
-  tuner.fit(X_train, y_train, X_val, y_val, X_test=X_test, y_test=y_test)
+  ```python
+  from classifier_toolkit.risk_class import RiskClassBuilderDP
 
-  best_model = tuner.best_model
-  tuner.results_df  # full trial results
+  builder = RiskClassBuilderDP(
+      target_col="target",
+      target_ranges=[(0.00, 0.02), (0.02, 0.05), (0.05, 0.10)],
+      min_obs_per_bin=200,
+  )
+  result = builder.build(train_proba, y_train)
+  print(result.bins, result.n_classes)
   ```
 
-  Custom parameter search spaces can be defined via `ModelParams` and `ParamRange`.
+- **Model Validation**: `Evaluator` evaluates any model with `predict_proba` (metrics, ROC/PR/calibration/threshold plots), `score_distribution_psi` and `compare_score_distributions` compare a reference score distribution with a current one, and `evaluate_risk_classes_dp` checks calibration within each risk class.
+
+- **Calibration**: `OVRHistogramCalibrator` calibrates multiclass (or binary) probabilities One-vs-Rest with histogram binning; `plot_reliability_curves` shows raw vs calibrated reliability per class.
+
+- **Explainability**: `TreeSHAPExplainer`, `ExplainabilityToolkit`, SHAP plots, pairwise interaction analysis and a `MisclassificationAnalyzer` that explains confusion-matrix quadrants (per-class SHAP for multiclass models).
+
+- **Data Partition**: Temporal-aware train/test splitting, preprocessing helpers and dtype optimization.
 
 ### Development & CI/CD
 
@@ -162,8 +197,8 @@ This project uses modern tooling for fast and efficient development workflows:
 #### CI/CD Pipeline
 Our CI/CD pipeline is optimized for speed and efficiency:
 
-- **Parallel Test Execution**: Tests are split into two groups (`eda` and `feature_selection`) that run simultaneously, reducing test time by ~50%
-- **Shared Caching**: Both parallel jobs share the same dependency cache (~1.7GB), avoiding duplicate downloads
+- **Parallel Test Execution**: One test job per directory under `tests/` (discovered automatically, so new test groups are picked up without editing the workflow), all running simultaneously
+- **Shared Caching**: The parallel jobs share the same dependency cache, avoiding duplicate downloads
 - **Smart Test Reruns**: Failed tests run first (`pytest --lf --ff`) for faster feedback on fixes
 - **Master Protection**: Build tests only run on `master` branch and PRs targeting `master`, saving CI resources on feature branches
 - **Automatic Linting**: Code quality checks (Ruff, SQLFluff) run on every push
@@ -188,5 +223,5 @@ uv build
 
 ### Future Work
 The next planned improvements and additions to the library include:
-* Developing comprehensive evaluation and reporting tools to assist with model assessment.
+* Extending the evaluation and reporting tools in `model_validation` (more checks and report formats).
 * Expanding documentation to include architecture diagrams and detailed usage examples.

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/README.md

@@ -29,13 +29,17 @@ This library is published in the PyPI directory. To install, users can run pip i
 
 ### Usage
 
-This library automates binary classification tasks in the finance domain, specifically for default and fraud labeling. It includes several packages designed to address the main steps in any machine learning/data science task:
+This library automates binary and multiclass classification workflows. It is independent of the modelled problem: the class of interest is configured through `pos_label` (the positive class for binary targets, the class of interest for multiclass ones). It includes several packages designed to address the main steps in any machine learning/data science task:
 
-1. **EDA**: accessible via `EDA_Toolkit`. Provides EDA and feature engineering functionality with all necessary visualizations.
+1. **EDA**: accessible via `EDAToolkit`. Provides EDA and feature engineering functionality with all necessary visualizations.
 2. **Feature Reduction**: filter-style pre-selection pipeline (expert rules, low variance, drift, predictive power, counter-intuitive direction, high correlation).
 3. **Feature Selection**: wrapper and embedded methods (RFE, Boruta, Sequential, Bayesian, ElasticNet, MetaSelector).
-4. **Model Training**: accessible via `Tuner`. Hyperparameter optimization (grid search, Bayesian via Optuna) for LightGBM and CatBoost with train/val/test evaluation.
-5. Evaluation and reporting: To be implemented.
+4. **Model Training**: accessible via `Tuner`. Hyperparameter optimization (grid search, Bayesian via Optuna) for LightGBM and CatBoost with train/val/test evaluation, including multiclass objectives and class weights.
+5. **Risk Class**: `RiskClassBuilderDP` / `RiskClassBuilder` turn model scores into risk classes with statistically validated, ordered event rates.
+6. **Model Validation**: `Evaluator` computes metrics, calibration and stability checks for any model exposing `predict_proba`.
+7. **Calibration**: `OVRHistogramCalibrator` and `plot_reliability_curves` for One-vs-Rest probability calibration.
+8. **Explainability**: SHAP-based explanations, interactions and misclassification diagnostics.
+9. **Data Partition**: temporal-aware train/test splitting, preprocessing and dtype optimization.
 
 For detailed usage, refer to the documentation.
 
@@ -108,16 +112,46 @@ For detailed usage, refer to the documentation.
 - **Model Training**: Hyperparameter optimization for LightGBM and CatBoost, with support for grid search and Bayesian optimization (via Optuna).
 
   ```python
-  from classifier_toolkit.model_training.hyper_parameter_tuning import Tuner
+  from classifier_toolkit.model_training.hyper_parameter_tuning.tuner import Tuner
+
+  tuner = Tuner(
+      X=X_train, y=y_train,
+      model_name="lightgbm",
+      X_val=X_val, y_val=y_val,
+      X_test=X_test, y_test=y_test,
+      search_method="bayesian",
+      n_trials=50,
+      optimization_metric="prauc",
+  )
+  result = tuner.tune()
+
+  best_model = result["best_model"]
+  result["trials_results"]  # full trial results (DataFrame)
+  ```
+
+  Reported metrics are `auc`, `prauc`, `ks`, `log_loss` and `brier` (`ks`/`brier` are binary-only). Custom parameter search spaces can be defined via `ModelParams` and `ParamRange`.
+
+- **Risk Class**: Builds risk classes from model scores. `RiskClassBuilderDP` searches bin edges with dynamic programming so that each class' observed event rate falls in a target band (`target_ranges`, required), then checks that adjacent classes are statistically distinguishable; `RiskClassBuilder` discovers classes with KMeans.
 
-  tuner = Tuner(model_name="lightgbm", metric="auc", search_type="bayesian", n_trials=50)
-  tuner.fit(X_train, y_train, X_val, y_val, X_test=X_test, y_test=y_test)
+  ```python
+  from classifier_toolkit.risk_class import RiskClassBuilderDP
 
-  best_model = tuner.best_model
-  tuner.results_df  # full trial results
+  builder = RiskClassBuilderDP(
+      target_col="target",
+      target_ranges=[(0.00, 0.02), (0.02, 0.05), (0.05, 0.10)],
+      min_obs_per_bin=200,
+  )
+  result = builder.build(train_proba, y_train)
+  print(result.bins, result.n_classes)
   ```
 
-  Custom parameter search spaces can be defined via `ModelParams` and `ParamRange`.
+- **Model Validation**: `Evaluator` evaluates any model with `predict_proba` (metrics, ROC/PR/calibration/threshold plots), `score_distribution_psi` and `compare_score_distributions` compare a reference score distribution with a current one, and `evaluate_risk_classes_dp` checks calibration within each risk class.
+
+- **Calibration**: `OVRHistogramCalibrator` calibrates multiclass (or binary) probabilities One-vs-Rest with histogram binning; `plot_reliability_curves` shows raw vs calibrated reliability per class.
+
+- **Explainability**: `TreeSHAPExplainer`, `ExplainabilityToolkit`, SHAP plots, pairwise interaction analysis and a `MisclassificationAnalyzer` that explains confusion-matrix quadrants (per-class SHAP for multiclass models).
+
+- **Data Partition**: Temporal-aware train/test splitting, preprocessing helpers and dtype optimization.
 
 ### Development & CI/CD
 
@@ -131,8 +165,8 @@ This project uses modern tooling for fast and efficient development workflows:
 #### CI/CD Pipeline
 Our CI/CD pipeline is optimized for speed and efficiency:
 
-- **Parallel Test Execution**: Tests are split into two groups (`eda` and `feature_selection`) that run simultaneously, reducing test time by ~50%
-- **Shared Caching**: Both parallel jobs share the same dependency cache (~1.7GB), avoiding duplicate downloads
+- **Parallel Test Execution**: One test job per directory under `tests/` (discovered automatically, so new test groups are picked up without editing the workflow), all running simultaneously
+- **Shared Caching**: The parallel jobs share the same dependency cache, avoiding duplicate downloads
 - **Smart Test Reruns**: Failed tests run first (`pytest --lf --ff`) for faster feedback on fixes
 - **Master Protection**: Build tests only run on `master` branch and PRs targeting `master`, saving CI resources on feature branches
 - **Automatic Linting**: Code quality checks (Ruff, SQLFluff) run on every push
@@ -157,5 +191,5 @@ uv build
 
 ### Future Work
 The next planned improvements and additions to the library include:
-* Developing comprehensive evaluation and reporting tools to assist with model assessment.
+* Extending the evaluation and reporting tools in `model_validation` (more checks and report formats).
 * Expanding documentation to include architecture diagrams and detailed usage examples.

classifier_toolkit-0.4.0/classifier_toolkit/datasets/__init__.py

@@ -0,0 +1,3 @@
+from ._demo import ID_COLS, TARGET_COL, make_demo_data
+
+__all__ = ["ID_COLS", "TARGET_COL", "make_demo_data"]

classifier_toolkit-0.4.0/classifier_toolkit/datasets/_demo.py

@@ -0,0 +1,178 @@
+"""Synthetic panel data for the examples and the documentation."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+ID_COLS = ["entity_id", "observation_date"]
+TARGET_COL = "target"
+
+_SECTORS = {
+    "retail": 0.3,
+    "construction": 0.5,
+    "hospitality": 0.6,
+    "services": 0.0,
+    "tech": -0.4,
+    "health": -0.3,
+    "transport": 0.2,
+    "manufacturing": -0.1,
+}
+_LEGAL_FORMS = {"ltd": 0.0, "sole_trader": 0.3, "partnership": 0.1, "cooperative": -0.2}
+_COUNTRIES = ["FR", "DE", "IT", "ES"]
+
+
+def make_demo_data(
+    n_samples: int = 20_000,
+    event_rate: float = 0.05,
+    n_months: int = 24,
+    start_date: str = "2023-01-01",
+    random_state: int | None = 0,
+) -> pd.DataFrame:
+    """Generate a synthetic binary-classification panel for the examples.
+
+    Each row is one entity observed at one month. Entities have a hidden risk
+    level that drives both their features and the target, so the features carry
+    a realistic, noisy signal. The columns are built so that every tool in the
+    toolkit has something to find:
+
+    - informative numerical features, with the sign of their relation to the
+      target given by their name (``*_balance_*``, ``inflow_*`` lower the risk;
+      ``declined_*``, ``low_balance_days_*`` raise it)
+    - near-duplicates (``low_balance_days_cnt_3m`` vs ``_1m``,
+      ``min_balance_3m`` vs ``mean_balance_3m``) for correlation analysis
+    - a counter-intuitive feature: ``max_balance_3m`` *raises* the risk,
+      unlike the other balance features
+    - a drifting feature: ``card_spend_sum_1m`` grows over time, the target
+      relation doesn't
+    - near-constant features (``has_rare_flag``, ``reporting_version``,
+      ``segment``) for variance filters
+    - pure noise (``noise_0`` … ``noise_4``)
+    - categorical features with an effect (``sector``, ``legal_form``) and
+      without one (``country``)
+
+    The data is entirely synthetic. It contains no real entity.
+
+    Parameters
+    ----------
+    n_samples : int
+        Number of rows.
+    event_rate : float
+        Expected share of positive targets, between 0 and 1.
+    n_months : int
+        Number of monthly observation dates, starting at ``start_date``.
+    start_date : str
+        First observation date.
+    random_state : int or None
+        Seed, for reproducible data.
+
+    Returns
+    -------
+    pd.DataFrame
+        One row per (entity, observation date), sorted by date. ``entity_id``
+        and ``observation_date`` identify a row, ``target`` is 0/1, the other
+        columns are features.
+
+    Examples
+    --------
+    >>> from classifier_toolkit.datasets import make_demo_data
+    >>> df = make_demo_data(n_samples=1_000)
+    >>> df["target"].mean()  # doctest: +SKIP
+    0.05
+    """
+    if not 0 < event_rate < 1:
+        raise ValueError(f"event_rate must be between 0 and 1, got {event_rate}.")
+    if n_samples < 1 or n_months < 1:
+        raise ValueError("n_samples and n_months must be at least 1.")
+
+    rng = np.random.default_rng(random_state)
+
+    # Entities: about 4 observations each, at distinct months.
+    n_entities = -(-n_samples // min(4, n_months))
+    cell = rng.choice(n_entities * n_months, n_samples, replace=False)
+    entity, month = np.divmod(cell, n_months)
+    dates = pd.date_range(start_date, periods=n_months, freq="MS")
+
+    sector = rng.choice(list(_SECTORS), n_entities)
+    legal_form = rng.choice(list(_LEGAL_FORMS), n_entities, p=[0.5, 0.3, 0.15, 0.05])
+    country = rng.choice(_COUNTRIES, n_entities, p=[0.4, 0.3, 0.2, 0.1])
+    age_months = rng.gamma(2.0, 30.0, n_entities)
+
+    # Hidden risk: entity level plus a monthly shock.
+    entity_risk = rng.normal(0, 1, n_entities)
+    risk = entity_risk[entity] + rng.normal(0, 0.6, n_samples)
+
+    def noisy(scale: float) -> np.ndarray:
+        return rng.normal(0, scale, n_samples)
+
+    mean_balance = np.exp(9.0 - 0.6 * risk + noisy(0.5))
+    inflow = np.exp(10.0 - 0.4 * risk + noisy(0.6))
+    outflow = inflow * np.exp(0.15 * risk + noisy(0.2))
+    low_days_3m = rng.poisson(np.exp(1.0 + 0.7 * risk).clip(max=60))
+    low_days_1m = np.minimum(
+        np.round(low_days_3m * rng.uniform(0.25, 0.45, n_samples)), 31
+    ).astype(int)
+    declined = rng.poisson(np.exp(-0.5 + 0.6 * risk + noisy(0.3)))
+    # Drift grows with the month index: about x1.75 after 24 months, x1.3 after 12.
+    inflation = 1.03 ** (month / 12 * 10)
+
+    df = pd.DataFrame(
+        {
+            "entity_id": pd.Series(entity).map(lambda i: f"E{i:06d}"),
+            "observation_date": dates[month],
+            "mean_balance_3m": mean_balance.round(2),
+            "min_balance_3m": (mean_balance * np.exp(-0.8 + noisy(0.15))).round(2),
+            "max_balance_3m": np.exp(9.5 + 0.25 * risk + noisy(0.5)).round(2),
+            "inflow_sum_3m": inflow.round(2),
+            "outflow_sum_3m": outflow.round(2),
+            "inflow_outflow_ratio_3m": (inflow / outflow).round(4),
+            "declined_payments_cnt_3m": declined,
+            "low_balance_days_cnt_3m": low_days_3m,
+            "low_balance_days_cnt_1m": low_days_1m,
+            "card_spend_sum_1m": (np.exp(7.0 + noisy(0.7)) * inflation).round(2),
+            "account_age_months": (
+                age_months[entity] + month - 0.15 * risk * 10 + noisy(2)
+            )
+            .clip(0)
+            .round(1),
+            "n_users": rng.poisson(1.5, n_samples) + 1,
+            "has_rare_flag": (rng.random(n_samples) < 0.003).astype(int),
+            "reporting_version": np.ones(n_samples, dtype=int),
+            **{f"noise_{i}": noisy(1).round(4) for i in range(5)},
+            "sector": sector[entity],
+            "legal_form": legal_form[entity],
+            "country": country[entity],
+            "segment": np.where(rng.random(n_samples) < 0.97, "standard", "pilot"),
+        }
+    )
+
+    logit = (
+        1.1 * risk
+        + pd.Series(sector[entity]).map(_SECTORS).to_numpy()
+        + pd.Series(legal_form[entity]).map(_LEGAL_FORMS).to_numpy()
+        + noisy(0.3)
+    )
+    df[TARGET_COL] = (
+        rng.random(n_samples) < _sigmoid(logit + _intercept(logit, event_rate))
+    ).astype(int)
+
+    for col in ["sector", "legal_form", "country", "segment"]:
+        df[col] = df[col].astype("category")
+
+    return df.sort_values(["observation_date", "entity_id"]).reset_index(drop=True)
+
+
+def _sigmoid(x: np.ndarray) -> np.ndarray:
+    return 1 / (1 + np.exp(-x))
+
+
+def _intercept(logit: np.ndarray, event_rate: float) -> float:
+    """Shift that makes the mean predicted probability equal ``event_rate``."""
+    low, high = -30.0, 30.0
+    for _ in range(60):
+        mid = (low + high) / 2
+        if _sigmoid(logit + mid).mean() < event_rate:
+            low = mid
+        else:
+            high = mid
+    return (low + high) / 2

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/explainability/__init__.py

@@ -1,7 +1,7 @@
 """Model explainability public API with lazy imports.
 
 Exposes SHAP-based global, local, and interaction explanations for tree
-models, mirroring the paylater production explainability workflow.
+models.
 """
 
 import logging

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/explainability/misclassification.py

@@ -40,8 +40,8 @@ _OUTPUT_COLUMNS = ("y_true", "y_pred_proba", "y_pred")
 class MisclassificationAnalyzer:
     """Filter confusion-matrix quadrants and explain individual predictions.
 
-    Mirrors the bin-analysis workflow from the paylater explainability
-    notebook (false negatives, false positives, true positives, true negatives).
+    The quadrants are false negatives, false positives, true positives and
+    true negatives.
 
     For a multiclass target, the confusion-matrix-quadrant concept only
     makes sense once collapsed to a single yes/no question — so this
@@ -158,7 +158,7 @@ class MisclassificationAnalyzer:
         For a multiclass model, ``y_true``/``y_pred``/``y_pred_proba`` are
         the pos_label-vs-rest collapse described in the class docstring.
 
-        ``extra_columns`` (e.g. identifiers such as ``org_id``) are attached
+        ``extra_columns`` (e.g. identifiers such as ``entity_id``) are attached
         for traceability and never passed to the model. Rows are matched to
         ``X`` by index; names may not clash with model features or the
         output columns.

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/explainability/plots.py

@@ -99,11 +99,7 @@ def plot_shap_dependence_grid(
     is_categorical: bool = False,
     show: bool = False,
 ) -> Optional[plt.Figure]:
-    """Plot SHAP dependence plots for a list of features in a grid layout.
-
-    Ported from the paylater production workflow to provide the same
-    grid-layout dependence analysis inside classifier_toolkit.
-    """
+    """Plot SHAP dependence plots for a list of features in a grid layout."""
     if isinstance(feature_list, str):
         feature_list = [feature_list]
     feature_list = list(feature_list)

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/feature_reduction/counter_intuitive.py

@@ -7,7 +7,7 @@ a business prior. Each prior is expressed as a *direction rule*:
 
     {
         "name": "Balance features",          # human-readable label
-        "patterns": ["balance_eur"],         # substrings matched against feature names
+        "patterns": ["balance"],             # substrings matched against feature names
         "expected_direction": "negative",    # "positive" or "negative"
         "exclude_patterns": ["pct", "ratio"],  # optional — substrings that veto a match
     }

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/feature_reduction/drift.py

@@ -36,6 +36,7 @@ Consider this a sensible starting point, not a formal statistical test.
 """
 
 import logging
+import warnings
 from typing import Dict, List, Optional, Tuple
 
 import numpy as np
@@ -160,24 +161,17 @@ def _js_numerical(
     baseline: pd.Series,
     current: pd.Series,
     bins: int,
-    bin_method: str,  # noqa: ARG001
+    bin_method: str,
     min_obs_per_bin: int,
     auto_adjust_bins: bool,
 ) -> float:
-    # Use independent bins per dataset to match paylater DriftDetector behaviour.
-    baseline = baseline.dropna()
-    current = current.dropna()
-    if len(baseline) == 0 or len(current) == 0:
-        return np.nan
-    try:
-        n_bins = _effective_bins(baseline, bins, min_obs_per_bin, auto_adjust_bins)
-        b_hist, _ = np.histogram(baseline, bins=n_bins, density=True)
-        c_hist, _ = np.histogram(current, bins=n_bins, density=True)
-        b_hist = b_hist / (b_hist.sum() + 1e-10)
-        c_hist = c_hist / (c_hist.sum() + 1e-10)
-        return float(jensenshannon(b_hist, c_hist))
-    except Exception:
+    """Jensen-Shannon distance via binned histograms. Drift if >= threshold."""
+    p_b, p_c = _binned_probs(
+        baseline, current, bins, bin_method, min_obs_per_bin, auto_adjust_bins
+    )
+    if p_b is None:
         return np.nan
+    return float(jensenshannon(p_b, p_c))
 
 
 def _ks_numerical(baseline: pd.Series, current: pd.Series) -> Tuple[float, float]:
@@ -267,13 +261,30 @@ def _hellinger_categorical(baseline: pd.Series, current: pd.Series) -> float:
         return np.nan
 
 
-def _ad_numerical(_baseline: pd.Series, _current: pd.Series) -> float:
+def _ad_numerical(baseline: pd.Series, current: pd.Series) -> float:
     """Anderson-Darling 2-sample p-value (numerical only). Drift if p_value < threshold.
 
-    Returns np.nan unconditionally to match paylater DriftDetector, where
-    anderson_ksamp unpacking produces a TypeError and AD never votes.
+    SciPy interpolates the p-value from tabulated critical values, so it is
+    capped to ``[0.001, 0.25]``.
     """
-    return np.nan
+    baseline = baseline.dropna()
+    current = current.dropna()
+    # SciPy raises IndexError (not ValueError) when each sample has a single
+    # value, so samples that small are reported as undefined up front.
+    if len(baseline) < 2 or len(current) < 2:
+        return np.nan
+    try:
+        with warnings.catch_warnings():
+            # SciPy warns whenever the p-value hits the cap or the floor.
+            warnings.simplefilter("ignore")
+            result = scipy_stats.anderson_ksamp([baseline.values, current.values])
+        return float(result.pvalue)
+    except ValueError as exc:
+        # Raised for degenerate samples, e.g. no distinct observations. Any
+        # other exception propagates: a blanket `except Exception` here is
+        # what used to hide an always-NaN bug.
+        logger.debug("Anderson-Darling drift undefined: %s", exc)
+        return np.nan
 
 
 def _bhattacharyya_numerical(

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/feature_reduction/reducer.py

@@ -1,8 +1,7 @@
 """FeatureReducer — orchestrates all six filter steps in sequence.
 
-The six steps mirror the ``FeatureReducer`` in *paylater-risk-model-v2*
-(``utils_std/FeatureReducer.py``) but expose a standard sklearn-compatible
-``fit`` / ``transform`` API instead of mutating datasets in place.
+The six steps run in a fixed order behind a standard sklearn-compatible
+``fit`` / ``transform`` API, without mutating the input datasets.
 
 Steps:
 
@@ -93,7 +92,8 @@ class FeatureReducer(BaseFeatureReducer):
         Tie-break metric for categorical correlation (step 6): ``"prauc"``
         (default), ``"auc"``, or ``"target_assoc"``.
     numerical_features : List[str], optional
-        Override auto-detected numerical columns (steps 2, 3, 4, 6).
+        Override auto-detected numerical columns (steps 2, 3, 4, 6). Step 4
+        scores numerical columns only; the other columns are kept by it.
     categorical_features : List[str], optional
         Override auto-detected categorical columns (steps 2, 3, 6).
     apply_expert_rules : bool, optional
@@ -304,8 +304,18 @@ class FeatureReducer(BaseFeatureReducer):
                     stacklevel=2,
                 )
             else:
+                num_features = _num(X_current)
+                if num_features is None:
+                    # Score numeric columns only: left to auto-detect, the
+                    # filter would also drop every non-numeric column unscored.
+                    cat_features = set(_cat(X_current) or [])
+                    num_features = [
+                        c
+                        for c in X_current.select_dtypes(include="number").columns
+                        if c not in cat_features
+                    ]
                 f = WeakPredictiveFilter(
-                    numerical_features=_num(X_current),
+                    numerical_features=num_features,
                     gini_threshold=self.gini_threshold,
                     prauc_lift_threshold=self.prauc_lift_threshold,
                 )
@@ -362,6 +372,8 @@ class FeatureReducer(BaseFeatureReducer):
                 self.removed_by_step_["low_variance_categorical"] = list(low_var_cat)
                 self.steps_["correlation"] = f
                 X_current = f.transform(X_current)
+                # The correlation filter only reports these (it keeps them).
+                X_current = X_current.drop(columns=low_var_cat)
                 self._log_step("correlation", f.dropped_features_)
                 if low_var_cat:
                     self._log_step("low_variance_categorical", low_var_cat)

{classifier_toolkit-0.3.6 → classifier_toolkit-0.4.0}/classifier_toolkit/feature_selection/utils/scoring.py

@@ -132,7 +132,10 @@ def macro_average_precision_score(
     y_pred_proba = np.asarray(y_pred_proba)
     if y_pred_proba.ndim == 1 or y_pred_proba.shape[1] <= 2:
         proba = _positive_column(y_pred_proba, classes)
-        return float(average_precision_score(y_true, proba))
+        # The positive class is the greater label (as for ROC-AUC); sklearn's
+        # default pos_label=1 would pick the *lesser* label for {1, 2} targets.
+        positive = np.unique(classes if classes is not None else np.asarray(y_true))[-1]
+        return float(average_precision_score(y_true, proba, pos_label=positive))
 
     if classes is not None:
         scores = [
@@ -233,11 +236,11 @@ def make_d_class_auc_scorer(d_class_label: Union[str, int]) -> Callable:
 
     .. deprecated:: 0.3.6
         Use :func:`make_pos_label_auc_scorer` instead; this alias will be
-        removed in the next minor release.
+        removed in 0.5.0.
     """
     warnings.warn(
         "make_d_class_auc_scorer is deprecated; use make_pos_label_auc_scorer "
-        "instead. It will be removed in the next minor release.",
+        "instead. It will be removed in 0.5.0.",
         DeprecationWarning,
         stacklevel=2,
     )
@@ -249,12 +252,11 @@ def make_d_class_pr_auc_scorer(d_class_label: Union[str, int]) -> Callable:
 
     .. deprecated:: 0.3.6
         Use :func:`make_pos_label_pr_auc_scorer` instead; this alias will be
-        removed in the next minor release.
+        removed in 0.5.0.
     """
     warnings.warn(
         "make_d_class_pr_auc_scorer is deprecated; use "
-        "make_pos_label_pr_auc_scorer instead. It will be removed in the next "
-        "minor release.",
+        "make_pos_label_pr_auc_scorer instead. It will be removed in 0.5.0.",
         DeprecationWarning,
         stacklevel=2,
     )