scikit-learn

uv add scikit-learn pandas skops  # or pip install in a venv
uv run python -c "import sklearn; sklearn.show_versions()"

import numpy as np
from sklearn.base import clone
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
 
rng = np.random.default_rng(0)
X = rng.normal(size=(200, 3))       # (n_samples, n_features)
y = (X[:, 0] + X[:, 1] > 0).astype(int)
 
scaler = StandardScaler()           # hyperparameters only
Xs = scaler.fit_transform(X)        # learn mean/std, apply
print(scaler.mean_, scaler.scale_)  # learned: trailing _
 
clf = LogisticRegression(C=1.0).fit(Xs, y)  # returns self
clf.predict(Xs[:3])                 # array([1, 0, 1])
clf.predict_proba(Xs[:3])           # (3, 2), rows sum to 1
clf.score(Xs, y)                    # mean accuracy
clf.coef_, clf.intercept_, clf.classes_
 
fresh = clone(clf).set_params(C=0.1)  # unfitted copy

from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,       # float = fraction, int = rows
    stratify=y,          # keep class ratios in both parts
    random_state=42,     # reproducible shuffle
)

import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import (
    OneHotEncoder,
    StandardScaler,
)
 
rng = np.random.default_rng(0)
n = 400
df = pd.DataFrame({
    "age": rng.integers(18, 80, n).astype(float),
    "income": rng.lognormal(10, 0.5, n),
    "city": rng.choice(["ams", "ber", "par"], n),
})
df.loc[rng.random(n) < 0.1, "age"] = np.nan
noise = rng.lognormal(0, 0.3, n)
target = (df["income"] * noise > 25_000).astype(int)
 
num = make_pipeline(
    SimpleImputer(strategy="median"), StandardScaler()
)
cat = OneHotEncoder(
    handle_unknown="ignore", sparse_output=False
)
pre = ColumnTransformer(
    [
        ("num", num, ["age", "income"]),
        ("cat", cat, ["city"]),
    ],
    remainder="drop",   # or "passthrough"
)
model = Pipeline(
    [("pre", pre), ("clf", LogisticRegression())]
)
model.fit(df, target)

from sklearn.model_selection import (
    StratifiedKFold,
    cross_val_predict,
    cross_val_score,
)
 
cv = StratifiedKFold(
    n_splits=5, shuffle=True, random_state=0
)
scores = cross_val_score(
    model, df, target, cv=cv, scoring="roc_auc"
)
print(f"{scores.mean():.3f} ± {scores.std():.3f}")
oof = cross_val_predict(model, df, target, cv=cv)  # per row

from scipy.stats import loguniform
from sklearn.model_selection import RandomizedSearchCV
 
search = RandomizedSearchCV(
    model,
    {"clf__C": loguniform(1e-3, 1e2)},  # step__param
    n_iter=20,
    cv=5,
    scoring="roc_auc",
    n_jobs=-1,
    random_state=0,
)
search.fit(df, target)
search.best_params_, search.best_score_
best = search.best_estimator_   # refit on all data

from sklearn.model_selection import (
    TunedThresholdClassifierCV,
)
 
tuned = TunedThresholdClassifierCV(
    model.set_params(clf__class_weight="balanced"),
    scoring="balanced_accuracy",
    cv=5,
).fit(df, target)
tuned.best_threshold_, tuned.best_score_

from sklearn.inspection import permutation_importance
 
r = permutation_importance(
    model, df, target,     # use a held-out set in practice
    n_repeats=10, scoring="roc_auc", random_state=0,
)
ranked = sorted(
    zip(df.columns, r.importances_mean, r.importances_std),
    key=lambda t: -t[1],
)
for name, mean, std in ranked:
    print(f"{name:8} {mean:.3f} ± {std:.3f}")

from sklearn.calibration import CalibratedClassifierCV
from sklearn.frozen import FrozenEstimator
from sklearn.svm import SVC
 
X_fit, X_cal, y_fit, y_cal = train_test_split(
    Xs, y, test_size=0.3, stratify=y, random_state=0
)
svc = SVC().fit(X_fit, y_fit)  # probability=True deprecated
calibrated = CalibratedClassifierCV(
    FrozenEstimator(svc), method="sigmoid"
).fit(X_cal, y_cal)
calibrated.predict_proba(Xs[:3])

import skops.io as sio
 
sio.dump(model, "model.skops")
unknown = sio.get_untrusted_types(file="model.skops")
print(unknown)               # review before trusting
loaded = sio.load("model.skops", trusted=unknown)
assert (loaded.predict(df) == model.predict(df)).all()

import sklearn
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
 
pre.set_output(transform="pandas")
pre.fit_transform(df).head()     # named DataFrame columns
 
with sklearn.config_context(enable_metadata_routing=True):
    w = np.where(y == 1, 2.0, 1.0)
    scaler = StandardScaler().set_fit_request(
        sample_weight=False           # opt out explicitly
    )
    lr = (
        LogisticRegression()
        .set_fit_request(sample_weight=True)
        .set_score_request(sample_weight=True)
    )
    routed = make_pipeline(scaler, lr)
    routed.fit(X, y, sample_weight=w)  # reaches only LR
    cross_validate(
        routed, X, y, params={"sample_weight": w}
    )

import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import train_test_split
 
rng = np.random.default_rng(1)
n = 1_000
X = pd.DataFrame({
    "age": rng.integers(18, 80, n).astype(float),
    "plan": pd.Categorical(rng.choice(["free", "pro"], n)),
    "visits": rng.poisson(5, n).astype(float),
})
X.loc[rng.random(n) < 0.1, "age"] = np.nan   # NaN is fine
rule = (X["plan"] == "pro") & (X["visits"] > 4)
y = (rule ^ (rng.random(n) < 0.05)).astype(int)  # noise
 
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, stratify=y, random_state=0
)
hgb = HistGradientBoostingClassifier(
    categorical_features="from_dtype",  # category dtype
    random_state=0,
).fit(X_tr, y_tr)
print(f"test accuracy {hgb.score(X_te, y_te):.3f}")

import pandas as pd
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_validate
 
X, y = make_classification(
    n_samples=600, weights=[0.8], random_state=0
)
res = cross_validate(
    RandomForestClassifier(random_state=0),
    X, y,
    cv=5,
    scoring=["roc_auc", "balanced_accuracy", "f1"],
    return_train_score=True,
    n_jobs=-1,
)
summary = pd.DataFrame(res).mean().round(3)
print(summary)   # fit_time, test_roc_auc, train_roc_auc...

from scipy.stats import loguniform, randint
from sklearn.datasets import make_classification
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.experimental import (
    enable_halving_search_cv,  # noqa: F401 (side effect)
)
from sklearn.model_selection import HalvingRandomSearchCV
 
X, y = make_classification(n_samples=2_000, random_state=0)
space = {
    "learning_rate": loguniform(0.01, 0.3),
    "max_leaf_nodes": randint(8, 64),
    "min_samples_leaf": randint(5, 50),
    "l2_regularization": loguniform(1e-4, 1.0),
}
search = HalvingRandomSearchCV(
    HistGradientBoostingClassifier(random_state=0),
    space,
    factor=3,              # keep the best third each round
    scoring="roc_auc",
    random_state=0,
    n_jobs=-1,
).fit(X, y)
print(search.best_params_, round(search.best_score_, 3))

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    classification_report,
    confusion_matrix,
)
from sklearn.model_selection import train_test_split
 
X, y = make_classification(
    n_samples=800, n_classes=3, n_informative=4,
    random_state=0,
)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, stratify=y, random_state=0
)
pred = LogisticRegression().fit(X_tr, y_tr).predict(X_te)
print(confusion_matrix(y_te, pred))  # rows true, cols pred
print(classification_report(y_te, pred, digits=3))
# plot: ConfusionMatrixDisplay.from_predictions(y_te, pred)

from pathlib import Path
 
import skops.io as sio
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
 
X, y = make_classification(random_state=0)
pipe = make_pipeline(StandardScaler(), LogisticRegression())
pipe.fit(X, y)
 
path = Path("pipe.skops")
sio.dump(pipe, path)
# later, in the serving process:
untrusted = sio.get_untrusted_types(file=path)
assert untrusted == [], f"review: {untrusted}"
restored = sio.load(path)
assert (restored.predict(X) == pipe.predict(X)).all()

import numpy as np
from numpy.typing import ArrayLike, NDArray
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.utils.validation import (
    check_is_fitted,
    validate_data,
)
 
class QuantileClipper(TransformerMixin, BaseEstimator):
    """Clip each column to its fitted quantile range."""
 
    def __init__(self, q: float = 0.01) -> None:
        self.q = q          # store params as given, no logic
 
    def fit(self, X: ArrayLike, y: object = None):
        Xv = validate_data(self, X)   # sets n_features_in_
        self.low_ = np.quantile(Xv, self.q, axis=0)
        self.high_ = np.quantile(Xv, 1 - self.q, axis=0)
        return self
 
    def transform(self, X: ArrayLike) -> NDArray[np.float64]:
        check_is_fitted(self)
        Xv = validate_data(self, X, reset=False)
        return np.clip(Xv, self.low_, self.high_)