Scikit-Learn Cheat Sheet — ML Pipeline Reference — Scikit Le

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")
print(classification_report(y_test, y_pred))

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression(random_state=42, max_iter=1000))
])

# Cross-validation automatically fits scaler on each fold's train data
scores = cross_val_score(pipe, X, y, cv=5, scoring='accuracy')
print(f"CV scores: {scores}")
print(f"Mean: {scores.mean():.3f} (+/- {scores.std():.3f})")

# Retrain on full data
pipe.fit(X, y)
y_pred = pipe.predict(X_test)

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import GradientBoostingClassifier

param_grid = {
    'n_estimators': [50, 100, 200],
    'learning_rate': [0.01, 0.05, 0.1],
    'max_depth': [3, 5, 7]
}

grid = GridSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1  # Use all cores
)

grid.fit(X_train, y_train)
print(f"Best params: {grid.best_params_}")
print(f"Best CV score: {grid.best_score_:.3f}")
print(f"Test score: {grid.score(X_test, y_test):.3f}")

from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline

# StandardScaler: (x - mean) / std → mean=0, std=1
scaler_standard = StandardScaler()
X_scaled_std = scaler_standard.fit_transform(X_train)

# MinMaxScaler: (x - min) / (max - min) → range [0, 1]
scaler_minmax = MinMaxScaler()
X_scaled_minmax = scaler_minmax.fit_transform(X_train)

# Use in pipeline to avoid leakage
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC(kernel='rbf', gamma='scale'))
])
pipe.fit(X_train, y_train)
print(f"Score: {pipe.score(X_test, y_test):.3f}")

from sklearn.ensemble import RandomForestClassifier
from sklearn.utils.class_weight import compute_class_weight
import numpy as np

# Check imbalance
print(f"Class distribution: {np.bincount(y)}")

# Option 1: Auto-balance
model = RandomForestClassifier(
    n_estimators=100,
    class_weight='balanced',  # Inverse frequency weighting
    random_state=42
)

# Option 2: Manual weights
weights = compute_class_weight('balanced', classes=np.unique(y), y=y)
class_weights_dict = {i: w for i, w in enumerate(weights)}
model = RandomForestClassifier(
    n_estimators=100,
    class_weight=class_weights_dict,
    random_state=42
)

model.fit(X_train, y_train)
print(f"Score: {model.score(X_test, y_test):.3f}")

from sklearn.ensemble import GradientBoostingRegressor
import pandas as pd

model = GradientBoostingRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Get feature importances
importances = model.feature_importances_
feature_names = X_train.columns  # Assumes pandas DataFrame

fi_df = pd.DataFrame({
    'feature': feature_names,
    'importance': importances
}).sort_values('importance', ascending=False)

print(fi_df.head(10))

# Top 5 features
top_features = fi_df.head(5)['feature'].tolist()
X_train_selected = X_train[top_features]
model.fit(X_train_selected, y_train)