rejectkit 0.3.0__py3-none-any.whl

rejectkit/__init__.py

@@ -0,0 +1,47 @@
+"""rejectkit — reject inference for credit scoring, scikit-learn style.
+
+Reject inference corrects the sampling bias that arises when a credit model is
+trained only on *accepted* applicants whose good/bad outcome is observed, while
+the *rejected* applicants — who are also part of the through-the-door
+population the model must score — are silently dropped.
+
+``rejectkit`` provides the classic reject inference methods behind a single,
+scikit-learn-compatible API, plus a benchmark harness that lets you measure —
+on your own data — whether reject inference actually helps.
+"""
+
+from . import datasets, diagnostics, plotting
+from .base import BaseRejectInferencer
+from .benchmark import MaskedRejectBenchmark
+from .estimator import RejectInferenceClassifier, get_inferencer
+from .methods import (
+    Extrapolation,
+    FuzzyAugmentation,
+    HeckmanClassifier,
+    Parcelling,
+    Reclassification,
+    Reweighting,
+    SelfLearning,
+    SimpleAugmentation,
+)
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "BaseRejectInferencer",
+    "SimpleAugmentation",
+    "FuzzyAugmentation",
+    "Parcelling",
+    "Reweighting",
+    "Reclassification",
+    "Extrapolation",
+    "SelfLearning",
+    "HeckmanClassifier",
+    "RejectInferenceClassifier",
+    "get_inferencer",
+    "MaskedRejectBenchmark",
+    "diagnostics",
+    "datasets",
+    "plotting",
+    "__version__",
+]

rejectkit/_compat.py

@@ -0,0 +1,19 @@
+"""Input coercion so rejectkit accepts pandas, polars, or plain numpy."""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def to_numpy_2d(X):
+    """Coerce a 2D array-like (pandas/polars DataFrame, ndarray, list) to float ndarray."""
+    if hasattr(X, "to_numpy"):  # pandas / polars DataFrame
+        X = X.to_numpy()
+    return np.asarray(X, dtype=float)
+
+
+def to_numpy_1d(y):
+    """Coerce a 1D array-like (pandas/polars Series, ndarray, list) to a 1D ndarray."""
+    if hasattr(y, "to_numpy"):  # pandas / polars Series
+        y = y.to_numpy()
+    return np.asarray(y).ravel()

rejectkit/base.py

@@ -0,0 +1,94 @@
+"""Base class shared by all reject inference methods."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+from sklearn.base import BaseEstimator, clone
+from sklearn.linear_model import LogisticRegression
+from sklearn.utils import check_array
+
+from ._compat import to_numpy_1d, to_numpy_2d
+
+ArrayTriple = tuple[np.ndarray, np.ndarray, np.ndarray]
+
+
+class BaseRejectInferencer(BaseEstimator, ABC):
+    """Abstract base class for reject inference methods.
+
+    A reject inferencer takes the accepted applicants ``(X_accept, y_accept)``,
+    whose good/bad outcome is known, together with the rejected applicants
+    ``X_reject``, whose outcome is unknown, and produces an augmented, weighted
+    training sample ``(X, y, sample_weight)`` that approximates the full
+    "through-the-door" population.
+
+    The label convention is ``1 = bad`` (the event of interest, e.g. default)
+    and ``0 = good``, matching ``predict_proba(...)[:, 1] = P(bad)``.
+
+    Accepts pandas, polars, or numpy inputs.
+
+    Parameters
+    ----------
+    base_estimator : sklearn classifier, optional
+        Probabilistic model used internally by the method. Must implement
+        ``predict_proba``. Defaults to LogisticRegression.
+    """
+
+    def __init__(self, base_estimator: BaseEstimator | None = None):
+        self.base_estimator = base_estimator
+
+    def _make_base(self) -> BaseEstimator:
+        if self.base_estimator is None:
+            return LogisticRegression(max_iter=1000)
+        return clone(self.base_estimator)
+
+    def _validate(self, X_accept, y_accept, X_reject):
+        X_accept = check_array(to_numpy_2d(X_accept), dtype=float)
+        X_reject = check_array(to_numpy_2d(X_reject), dtype=float)
+        y_accept = to_numpy_1d(y_accept)
+        try:
+            y_accept = y_accept.astype(int)
+        except (ValueError, TypeError) as exc:  # pragma: no cover - defensive
+            raise ValueError("y_accept must be coercible to integers 0/1.") from exc
+        if X_accept.shape[1] != X_reject.shape[1]:
+            raise ValueError(
+                f"X_accept has {X_accept.shape[1]} features but X_reject has "
+                f"{X_reject.shape[1]}."
+            )
+        classes = set(np.unique(y_accept).tolist())
+        if classes != {0, 1}:
+            raise ValueError(
+                "y_accept must be binary with both labels present, where "
+                f"1 = bad (event) and 0 = good. Got classes {sorted(classes)}."
+            )
+        return X_accept, y_accept, X_reject
+
+    def _reject_bad_proba(self) -> np.ndarray:
+        """P(bad) for rejected applicants from the good/bad scorer."""
+        return self.scorer_.predict_proba(self.X_reject_)[:, 1]
+
+    def fit(self, X_accept, y_accept, X_reject):
+        """Fit any internal models on the accepts (and rejects, if needed)."""
+        X_accept, y_accept, X_reject = self._validate(X_accept, y_accept, X_reject)
+        self.X_accept_ = X_accept
+        self.y_accept_ = y_accept
+        self.X_reject_ = X_reject
+        self.n_features_in_ = X_accept.shape[1]
+        self._fit()
+        self.is_fitted_ = True
+        return self
+
+    def _fit(self) -> None:
+        """Hook for method-specific fitting; default fits the good/bad scorer."""
+        self.scorer_ = self._make_base()
+        self.scorer_.fit(self.X_accept_, self.y_accept_)
+
+    @abstractmethod
+    def resample(self) -> ArrayTriple:
+        """Return the augmented training sample ``(X, y, sample_weight)``."""
+        raise NotImplementedError
+
+    def fit_resample(self, X_accept, y_accept, X_reject) -> ArrayTriple:
+        """Convenience: :meth:`fit` followed by :meth:`resample`."""
+        return self.fit(X_accept, y_accept, X_reject).resample()

rejectkit/benchmark.py

@@ -0,0 +1,141 @@
+"""Benchmark harness for reject inference methods.
+
+The core difficulty of reject inference is that you never observe the outcome
+of rejected applicants, so you cannot directly validate any method on real
+data. :class:`MaskedRejectBenchmark` sidesteps this on a *fully labelled*
+dataset: it hides the labels of a synthetically "rejected" subset of the
+training data, asks each method to recover a model, and scores every model on
+an untouched test set representing the true through-the-door population.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+import pandas as pd
+from sklearn.base import clone
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+from ._compat import to_numpy_1d, to_numpy_2d
+from .diagnostics import auc, gini, ks_statistic
+from .estimator import RejectInferenceClassifier
+from .methods import HeckmanClassifier
+
+
+class MaskedRejectBenchmark:
+    """Compare reject inference methods by masking labels on labelled data.
+
+    Parameters
+    ----------
+    selection : {'mar', 'mnar', 'cutoff'}, default='mnar'
+        Acceptance mechanism applied to the training set.
+        ``'mar'`` — acceptance depends only on observed features.
+        ``'mnar'`` — acceptance also depends on the hidden outcome.
+        ``'cutoff'`` — accept the lowest-PD fraction under a quick model, the
+        realistic credit-policy mechanism (strong, score-based truncation).
+    accept_rate : float, default=0.6
+        Fraction of training applicants accepted.
+    test_size : float, default=0.3
+        Fraction held out as the unbiased evaluation population.
+    selection_strength : float, default=2.0
+        Strength of the feature (and, under MNAR, outcome) dependence. Unused
+        for ``'cutoff'``.
+    random_state : int, default=0
+    """
+
+    def __init__(self, selection="mnar", accept_rate=0.6, test_size=0.3,
+                 selection_strength=2.0, random_state=0):
+        self.selection = selection
+        self.accept_rate = accept_rate
+        self.test_size = test_size
+        self.selection_strength = selection_strength
+        self.random_state = random_state
+
+    def _selection_scores(self, X_std, y, rng):
+        n, d = X_std.shape
+        w = rng.normal(size=d)
+        feat = X_std @ w
+        feat = feat / (feat.std() + 1e-12)
+        noise = rng.normal(size=n)
+        if self.selection == "mar":
+            return self.selection_strength * feat + noise
+        if self.selection == "mnar":
+            y_term = self.selection_strength * (0.5 - y) * 2.0
+            return feat + y_term + noise
+        raise ValueError("selection must be 'mar', 'mnar', or 'cutoff'.")
+
+    def _accept_mask(self, X_train, y_train) -> np.ndarray:
+        if self.selection == "cutoff":
+            risk = (
+                LogisticRegression(max_iter=1000)
+                .fit(X_train, y_train)
+                .predict_proba(X_train)[:, 1]
+            )
+            accepted = risk <= np.quantile(risk, self.accept_rate)
+        else:
+            rng = np.random.default_rng(self.random_state)
+            X_std = StandardScaler().fit_transform(X_train)
+            z = self._selection_scores(X_std, y_train, rng)
+            accepted = z >= np.quantile(z, 1.0 - self.accept_rate)
+        if len(np.unique(y_train[accepted])) < 2:
+            raise ValueError(
+                "The accepted subset contains a single class; lower "
+                "selection_strength or change accept_rate."
+            )
+        return accepted
+
+    def compare(self, methods: Sequence[str], X, y, estimator=None,
+                method_params: dict | None = None) -> pd.DataFrame:
+        """Run the benchmark and return a tidy results table.
+
+        Methods may include ``'heckman'`` (uses :class:`HeckmanClassifier`) as
+        well as any resampling method name. Returns a DataFrame indexed by
+        ``['oracle', 'naive', *methods]`` with columns ``auc``, ``ks``, ``gini``
+        and ``auc_recovery`` (0 = no better than naive, 1 = matches oracle).
+        Sample sizes are in ``df.attrs``.
+        """
+        X = to_numpy_2d(X)
+        y = to_numpy_1d(y).astype(int)
+        method_params = method_params or {}
+        est = estimator if estimator is not None else LogisticRegression(max_iter=1000)
+
+        X_tr, X_te, y_tr, y_te = train_test_split(
+            X, y, test_size=self.test_size, random_state=self.random_state, stratify=y
+        )
+        accepted = self._accept_mask(X_tr, y_tr)
+        X_a, y_a, X_r = X_tr[accepted], y_tr[accepted], X_tr[~accepted]
+
+        def _scores(model):
+            p = model.predict_proba(X_te)[:, 1]
+            return {"auc": auc(y_te, p), "ks": ks_statistic(y_te, p), "gini": gini(y_te, p)}
+
+        rows = {"oracle": _scores(clone(est).fit(X_tr, y_tr)),
+                "naive": _scores(clone(est).fit(X_a, y_a))}
+        for m in methods:
+            if str(m).lower() == "heckman":
+                clf = HeckmanClassifier(outcome_estimator=clone(est))
+            else:
+                clf = RejectInferenceClassifier(
+                    estimator=clone(est), method=m, method_params=method_params.get(m, {})
+                )
+            clf.fit(X_a, y_a, X_r)
+            rows[m] = _scores(clf)
+
+        df = pd.DataFrame(rows).T[["auc", "ks", "gini"]]
+        gap = rows["oracle"]["auc"] - rows["naive"]["auc"]
+        # Recovery is only meaningful when the oracle clearly beats the naive
+        # model; if there is no gap to recover, report NaN rather than a ratio
+        # that explodes around a near-zero denominator.
+        df["auc_recovery"] = (
+            (df["auc"] - rows["naive"]["auc"]) / gap if gap > 5e-3 else np.nan
+        )
+        df.attrs.update(
+            n_accept=int(accepted.sum()),
+            n_reject=int((~accepted).sum()),
+            n_test=int(len(y_te)),
+            selection=self.selection,
+        )
+        return df

rejectkit/datasets.py

@@ -0,0 +1,97 @@
+"""Synthetic data generators for examples, tests and demos."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def _sigmoid(z: np.ndarray) -> np.ndarray:
+    """Numerically stable logistic sigmoid."""
+    out = np.empty_like(z, dtype=float)
+    pos = z >= 0
+    out[pos] = 1.0 / (1.0 + np.exp(-z[pos]))
+    ez = np.exp(z[~pos])
+    out[~pos] = ez / (1.0 + ez)
+    return out
+
+
+def _solve_intercept(logit: np.ndarray, target: float, iters: int = 60) -> float:
+    """Bisection for the intercept that yields a target mean event rate."""
+    lo, hi = -20.0, 20.0
+    for _ in range(iters):
+        mid = 0.5 * (lo + hi)
+        if _sigmoid(logit + mid).mean() < target:
+            lo = mid
+        else:
+            hi = mid
+    return 0.5 * (lo + hi)
+
+
+def make_credit_data(
+    n_samples: int = 3000,
+    n_features: int = 8,
+    bad_rate: float = 0.3,
+    random_state: int = 0,
+) -> tuple[pd.DataFrame, pd.Series]:
+    """Generate a synthetic, fully labelled credit dataset.
+
+    Returns
+    -------
+    X : pandas.DataFrame, shape (n_samples, n_features)
+    y : pandas.Series
+        ``1 = bad`` (default), ``0 = good``. The mean of ``y`` is approximately
+        ``bad_rate``.
+    """
+    rng = np.random.default_rng(random_state)
+    X = rng.normal(size=(n_samples, n_features))
+    beta = rng.normal(size=n_features)
+    beta[n_features // 2:] *= 0.2  # second half weakly informative
+    logit = X @ beta
+    logit = 1.5 * (logit - logit.mean()) / (logit.std() + 1e-12)
+    intercept = _solve_intercept(logit, bad_rate)
+    p_bad = _sigmoid(logit + intercept)
+    y = (rng.random(n_samples) < p_bad).astype(int)
+    cols = [f"x{i + 1}" for i in range(n_features)]
+    return pd.DataFrame(X, columns=cols), pd.Series(y, name="bad")
+
+
+def make_accept_reject(
+    n_samples: int = 3000,
+    n_features: int = 8,
+    bad_rate: float = 0.3,
+    accept_rate: float = 0.6,
+    selection: str = "mnar",
+    selection_strength: float = 1.5,
+    random_state: int = 0,
+) -> tuple[pd.DataFrame, pd.Series, pd.DataFrame, pd.Series]:
+    """Generate accept/reject data with the reject labels hidden.
+
+    Returns
+    -------
+    X_accept, y_accept : the accepted applicants and their observed outcomes.
+    X_reject : the rejected applicants (features only).
+    y_reject_true : the rejects' true outcomes — **hidden** in practice, returned
+        only so demos and tests can quantify how well a method recovers them.
+    """
+    X, y = make_credit_data(n_samples, n_features, bad_rate, random_state)
+    rng = np.random.default_rng(random_state + 1)
+    Xv = X.to_numpy()
+    Xs = (Xv - Xv.mean(0)) / (Xv.std(0) + 1e-12)
+    w = rng.normal(size=n_features)
+    feat = Xs @ w
+    feat = feat / (feat.std() + 1e-12)
+    noise = rng.normal(size=n_samples)
+    if selection == "mnar":
+        z = feat + selection_strength * (0.5 - y.to_numpy()) * 2.0 + noise
+    elif selection == "mar":
+        z = selection_strength * feat + noise
+    else:
+        raise ValueError("selection must be 'mar' or 'mnar'.")
+    accepted = z >= np.quantile(z, 1.0 - accept_rate)
+    return (
+        X[accepted].reset_index(drop=True),
+        y[accepted].reset_index(drop=True),
+        X[~accepted].reset_index(drop=True),
+        y[~accepted].reset_index(drop=True),
+    )

rejectkit/diagnostics.py

@@ -0,0 +1,109 @@
+"""Lightweight evaluation and drift metrics used across rejectkit.
+
+Dependency-free (numpy + scikit-learn + pandas) and using the ``1 = bad``
+convention, so ``y_score`` is always interpreted as P(bad).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from ._compat import to_numpy_1d, to_numpy_2d
+
+
+def _check_arrays(y_true, y_score):
+    y_true = to_numpy_1d(y_true)
+    y_score = to_numpy_1d(y_score).astype(float)
+    if y_true.shape[0] != y_score.shape[0]:
+        raise ValueError("y_true and y_score must have the same length.")
+    return y_true, y_score
+
+
+def auc(y_true, y_score) -> float:
+    """Area under the ROC curve."""
+    from sklearn.metrics import roc_auc_score
+
+    y_true, y_score = _check_arrays(y_true, y_score)
+    return float(roc_auc_score(y_true, y_score))
+
+
+def gini(y_true, y_score) -> float:
+    """Gini coefficient, ``2 * AUC - 1``."""
+    return 2.0 * auc(y_true, y_score) - 1.0
+
+
+def ks_statistic(y_true, y_score) -> float:
+    """Kolmogorov-Smirnov statistic: max separation of good/bad CDFs."""
+    from sklearn.metrics import roc_curve
+
+    y_true, y_score = _check_arrays(y_true, y_score)
+    fpr, tpr, _ = roc_curve(y_true, y_score)
+    return float(np.max(tpr - fpr))
+
+
+def psi(expected, actual, n_bins: int = 10, eps: float = 1e-6) -> float:
+    """Population Stability Index between two distributions.
+
+    Bins are quantiles of ``expected``. Rule of thumb: < 0.1 no shift,
+    0.1-0.25 moderate, > 0.25 major.
+    """
+    expected = to_numpy_1d(expected).astype(float)
+    actual = to_numpy_1d(actual).astype(float)
+    edges = np.unique(np.quantile(expected, np.linspace(0, 1, n_bins + 1)))
+    if edges.size < 2:
+        return 0.0
+    edges[0], edges[-1] = -np.inf, np.inf
+    e_counts, _ = np.histogram(expected, bins=edges)
+    a_counts, _ = np.histogram(actual, bins=edges)
+    e_perc = np.clip(e_counts / max(e_counts.sum(), 1), eps, None)
+    a_perc = np.clip(a_counts / max(a_counts.sum(), 1), eps, None)
+    return float(np.sum((a_perc - e_perc) * np.log(a_perc / e_perc)))
+
+
+def feature_drift(X_accept, X_reject, n_bins: int = 10) -> pd.Series:
+    """Per-feature PSI between the accept and reject populations.
+
+    A quick read on how unrepresentative your accepts are: large values flag
+    features whose distribution differs most between accepts and rejects.
+    """
+    cols = list(X_accept.columns) if hasattr(X_accept, "columns") else None
+    A = to_numpy_2d(X_accept)
+    R = to_numpy_2d(X_reject)
+    if cols is None:
+        cols = [f"x{i + 1}" for i in range(A.shape[1])]
+    values = {c: psi(A[:, i], R[:, i], n_bins=n_bins) for i, c in enumerate(cols)}
+    return pd.Series(values, name="psi").sort_values(ascending=False)
+
+
+def swap_set(
+    y_true,
+    score_reference,
+    score_challenger,
+    cutoff_reference,
+    cutoff_challenger,
+    lower_is_safer: bool = True,
+) -> pd.DataFrame:
+    """Swap-set analysis between a reference and a challenger scorecard.
+
+    Compares which applicants each policy accepts (accept if the score is on the
+    safe side of its cutoff) and reports counts and bad rates for the four
+    groups: kept-accept, kept-reject, swap-in (reference rejects, challenger
+    accepts) and swap-out (reference accepts, challenger rejects).
+    """
+    y = to_numpy_1d(y_true).astype(int)
+    sr = to_numpy_1d(score_reference).astype(float)
+    sc = to_numpy_1d(score_challenger).astype(float)
+    acc_r = sr <= cutoff_reference if lower_is_safer else sr >= cutoff_reference
+    acc_c = sc <= cutoff_challenger if lower_is_safer else sc >= cutoff_challenger
+    groups = {
+        "kept_accept": acc_r & acc_c,
+        "swap_out": acc_r & ~acc_c,
+        "swap_in": ~acc_r & acc_c,
+        "kept_reject": ~acc_r & ~acc_c,
+    }
+    rows = {}
+    for name, mask in groups.items():
+        n = int(mask.sum())
+        rows[name] = {"n": n, "bad_rate": float(y[mask].mean()) if n else float("nan")}
+    return pd.DataFrame(rows).T[["n", "bad_rate"]]

rejectkit/estimator.py

@@ -0,0 +1,105 @@
+"""High-level estimator that wraps any classifier with reject inference."""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.base import BaseEstimator, ClassifierMixin, clone
+from sklearn.linear_model import LogisticRegression
+
+from ._compat import to_numpy_2d
+from .methods import (
+    Extrapolation,
+    FuzzyAugmentation,
+    Parcelling,
+    Reclassification,
+    Reweighting,
+    SelfLearning,
+    SimpleAugmentation,
+)
+
+_METHODS = {
+    "simple": SimpleAugmentation,
+    "fuzzy": FuzzyAugmentation,
+    "parcelling": Parcelling,
+    "reweighting": Reweighting,
+    "reclassification": Reclassification,
+    "extrapolation": Extrapolation,
+    "twins": Extrapolation,
+    "selflearning": SelfLearning,
+    "self-learning": SelfLearning,
+}
+
+
+def get_inferencer(method: str, base_estimator: BaseEstimator | None = None, **params):
+    """Build a reject inferencer by name.
+
+    Parameters
+    ----------
+    method : str
+        One of: simple, fuzzy, parcelling, reweighting, reclassification,
+        extrapolation (alias twins), selflearning.
+    base_estimator : sklearn classifier, optional
+    **params
+        Extra keyword arguments for the chosen method (e.g. ``uplift=1.5``).
+    """
+    key = str(method).lower()
+    if key not in _METHODS:
+        raise ValueError(f"Unknown method {method!r}. Available: {sorted(_METHODS)}.")
+    return _METHODS[key](base_estimator=base_estimator, **params)
+
+
+class RejectInferenceClassifier(BaseEstimator, ClassifierMixin):
+    """Wrap a scikit-learn classifier with reject inference.
+
+    Infers labels/weights for the rejected applicants using ``method``, builds
+    the augmented through-the-door sample, and fits ``estimator`` on it
+    (passing ``sample_weight``). It then behaves like an ordinary fitted
+    classifier via :meth:`predict` / :meth:`predict_proba`.
+
+    Note the non-standard ``fit`` signature: it takes accepts and rejects
+    separately. Accepts pandas, polars, or numpy inputs.
+
+    Parameters
+    ----------
+    estimator : sklearn classifier, optional
+        Final model trained on the augmented sample. Must accept
+        ``sample_weight``. Defaults to LogisticRegression.
+    method : str, default='fuzzy'
+        See :func:`get_inferencer`.
+    base_scorer : sklearn classifier, optional
+        Internal model used by the reject inference method.
+    method_params : dict, optional
+        Extra keyword arguments forwarded to the method, e.g. ``{'uplift': 1.5}``.
+    """
+
+    def __init__(self, estimator=None, method="fuzzy", base_scorer=None, method_params=None):
+        self.estimator = estimator
+        self.method = method
+        self.base_scorer = base_scorer
+        self.method_params = method_params
+
+    def fit(self, X_accept, y_accept, X_reject):
+        params = self.method_params or {}
+        inferencer = get_inferencer(self.method, base_estimator=self.base_scorer, **params)
+        X_aug, y_aug, w_aug = inferencer.fit_resample(X_accept, y_accept, X_reject)
+        self.inferencer_ = inferencer
+        self.estimator_ = (
+            clone(self.estimator) if self.estimator is not None
+            else LogisticRegression(max_iter=1000)
+        )
+        self.estimator_.fit(X_aug, y_aug, sample_weight=w_aug)
+        self.classes_ = getattr(self.estimator_, "classes_", np.array([0, 1]))
+        self.n_features_in_ = X_aug.shape[1]
+        return self
+
+    def predict(self, X):
+        return self.estimator_.predict(to_numpy_2d(X))
+
+    def predict_proba(self, X):
+        return self.estimator_.predict_proba(to_numpy_2d(X))
+
+    def decision_function(self, X):
+        Xa = to_numpy_2d(X)
+        if hasattr(self.estimator_, "decision_function"):
+            return self.estimator_.decision_function(Xa)
+        return self.predict_proba(Xa)[:, 1]

rejectkit/methods/__init__.py

@@ -0,0 +1,20 @@
+"""Reject inference methods."""
+
+from .augmentation import FuzzyAugmentation, SimpleAugmentation
+from .extrapolation import Extrapolation
+from .heckman import HeckmanClassifier
+from .parcelling import Parcelling
+from .reclassification import Reclassification
+from .reweighting import Reweighting
+from .semi_supervised import SelfLearning
+
+__all__ = [
+    "SimpleAugmentation",
+    "FuzzyAugmentation",
+    "Parcelling",
+    "Reweighting",
+    "Reclassification",
+    "Extrapolation",
+    "SelfLearning",
+    "HeckmanClassifier",
+]