Advanced Features

from sklearn.base import BaseEstimator, TransformerMixin

class OutlierClipper(BaseEstimator, TransformerMixin):
    """Clip outliers beyond n standard deviations."""

    def __init__(self, n_std=3):
        self.n_std = n_std

    def fit(self, X, y=None):
        self.mean_ = X.mean(axis=0)
        self.std_ = X.std(axis=0)
        return self

    def transform(self, X):
        lower = self.mean_ - self.n_std * self.std_
        upper = self.mean_ + self.n_std * self.std_
        return np.clip(X, lower, upper)

# Use in a pipeline just like any sklearn transformer
pipe = make_pipeline(OutlierClipper(n_std=3), StandardScaler(), Ridge())

import joblib

# Save the entire pipeline (including preprocessing)
joblib.dump(pipe, "model_pipeline.joblib")

# Load and use immediately
loaded_pipe = joblib.load("model_pipeline.joblib")
predictions = loaded_pipe.predict(new_data)

# For sklearn-specific format (newer, safer)
from sklearn.utils import estimator_html_repr
# Also available: skops for secure serialization

from sklearn.ensemble import VotingClassifier, StackingClassifier

# Voting: combine multiple models
voting = VotingClassifier(estimators=[
    ("rf", RandomForestClassifier(n_estimators=100)),
    ("svc", SVC(probability=True)),
    ("lr", LogisticRegression())
], voting="soft")

# Stacking: use a meta-learner
stacking = StackingClassifier(estimators=[
    ("rf", RandomForestClassifier()),
    ("svc", SVC(probability=True))
], final_estimator=LogisticRegression(), cv=5)

stacking.fit(X_train, y_train)

from sklearn.feature_selection import (
    SelectKBest, f_classif, RFECV
)

# Statistical feature selection
selector = SelectKBest(f_classif, k=10)
X_selected = selector.fit_transform(X, y)

# Recursive Feature Elimination with CV
rfecv = RFECV(RandomForestClassifier(), step=1, cv=5, scoring="accuracy")
rfecv.fit(X, y)
print(f"Optimal features: {rfecv.n_features_}")
print(f"Selected: {rfecv.support_}")