scikit-learn: Estimators, Pipelines, Preprocessing and Model Selection Reference Guide

# Install — core + the usual companions
pip install "scikit-learn>=1.5" numpy pandas scipy

# Conda (uses MKL by default)
conda install -c conda-forge scikit-learn

# Common extras
pip install joblib                          # parallel I/O for model persistence
pip install xgboost lightgbm catboost       # gradient-boosting drop-ins
pip install imbalanced-learn                # SMOTE + samplers
pip install scikit-learn-intelex            # Intel CPU accelerators

# Use the modern Pandas-aware output (DataFrames in / DataFrames out)
python -c "
from sklearn import set_config
set_config(transform_output='pandas',  # transformers return DataFrames
           display='diagram')           # pretty repr in notebooks
"

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression

num_cols = ["age", "income"]
cat_cols = ["country", "plan"]

# Per-column-group preprocessing
preprocess = ColumnTransformer(transformers=[
    ("num", Pipeline([
        ("impute", SimpleImputer(strategy="median")),
        ("scale",  StandardScaler()),
    ]), num_cols),
    ("cat", Pipeline([
        ("impute", SimpleImputer(strategy="most_frequent")),
        ("ohe",    OneHotEncoder(handle_unknown="ignore", sparse_output=False)),
    ]), cat_cols),
], remainder="drop", verbose_feature_names_out=False)

# Full estimator — preprocess + model
clf = Pipeline([
    ("pre",   preprocess),
    ("model", LogisticRegression(C=1.0, max_iter=1000, class_weight="balanced")),
])

clf.fit(X_train, y_train)
clf.predict_proba(X_test)[:, 1]

# Inspect the final feature names (set_config(transform_output='pandas') helps too)
preprocess.fit(X_train)
preprocess.get_feature_names_out()

from sklearn.model_selection import (
    train_test_split, StratifiedKFold, GridSearchCV, cross_val_score
)
from sklearn.metrics import classification_report

# 1. Train/test split — stratify keeps class balance
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42,
)

# 2. K-fold with stratification — the right default for classification
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# 3. Cheap baseline: cross-val score of a single model
scores = cross_val_score(clf, X_tr, y_tr, cv=cv, scoring="f1", n_jobs=-1)
print(f"CV f1 = {scores.mean():.3f} ± {scores.std():.3f}")

# 4. Tune hyperparameters — search over the whole Pipeline namespace
grid = {
    "pre__num__scale__with_mean": [True, False],          # double underscore = step__param
    "model__C":            [0.1, 1.0, 10.0],
    "model__class_weight": [None, "balanced"],
}
gs = GridSearchCV(
    clf, param_grid=grid, cv=cv, scoring="roc_auc",
    n_jobs=-1, refit=True, verbose=1,
)
gs.fit(X_tr, y_tr)
print("best:", gs.best_params_, gs.best_score_)

# 5. Held-out evaluation
print(classification_report(y_te, gs.predict(X_te)))

# End-to-end: load → split → preprocess + model in a Pipeline → tune → persist.
import joblib
import pandas as pd
from sklearn.datasets import fetch_openml
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import StratifiedKFold, RandomizedSearchCV
from sklearn.metrics import classification_report

df = fetch_openml("adult", version=2, as_frame=True).frame
y  = (df.pop("class") == ">50K").astype(int)
X  = df

num = X.select_dtypes("number").columns.tolist()
cat = X.select_dtypes(exclude="number").columns.tolist()

pre = ColumnTransformer([
    ("num", Pipeline([("imp", SimpleImputer("median")),
                      ("sc",  StandardScaler())]),                num),
    ("cat", Pipeline([("imp", SimpleImputer("most_frequent")),
                      ("ohe", OneHotEncoder(handle_unknown="ignore"))]), cat),
])

pipe = Pipeline([("pre", pre),
                 ("clf", HistGradientBoostingClassifier(random_state=0))])

search = RandomizedSearchCV(
    pipe,
    {"clf__learning_rate": [0.05, 0.1, 0.2],
     "clf__max_depth":     [None, 4, 6, 8],
     "clf__l2_regularization": [0, 0.1, 1.0]},
    n_iter=12, scoring="roc_auc", n_jobs=-1, random_state=0,
    cv=StratifiedKFold(5, shuffle=True, random_state=0),
)
search.fit(X, y)
print(classification_report(y, search.predict(X)))

joblib.dump(search.best_estimator_, "model.joblib")