Sklearn — Preprocessing

from sklearn.preprocessing import StandardScaler
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, random_state=42
)

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)  # fit on train, transform train
X_test_s  = scaler.transform(X_test)       # transform test with SAME params

# Inspect learned parameters
print(scaler.mean_)    # mean of each feature
print(scaler.scale_)   # std of each feature

# Invert scaling for predictions in original units
y_pred_scaled = model.predict(X_test_s)
# If target was also scaled:
target_scaler = StandardScaler().fit(y_train.values.reshape(-1, 1))
y_pred_orig = target_scaler.inverse_transform(y_pred_scaled.reshape(-1, 1))

from sklearn.preprocessing import MinMaxScaler, RobustScaler
import numpy as np

rng = np.random.default_rng(42)
X = rng.standard_normal((100, 5))
# Inject outliers
X[0, :] = 100

# StandardScaler — distorted by outlier
ss = StandardScaler().fit(X)
print('STD scale:', ss.scale_)   # inflated by outlier

# RobustScaler — resistant to outlier
rs = RobustScaler().fit(X)
print('Robust scale (IQR):', rs.scale_)

# MinMaxScaler for pixels/images → [0, 1]
mm = MinMaxScaler().fit(pixel_array)
pixels_norm = mm.transform(pixel_array)

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc  = le.transform(y_test)  # use fitted encoder on test

print(le.classes_)          # ['cat' 'dog' 'fish']
print(le.transform(['dog']))  # [1]

# Decode model predictions back to labels
y_pred = model.predict(X_test)
y_pred_labels = le.inverse_transform(y_pred)

from sklearn.preprocessing import OneHotEncoder
import numpy as np

cats = np.array([['cat'], ['dog'], ['cat'], ['fish']])
ohe = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
X_enc = ohe.fit_transform(cats)
print(X_enc)
# [[1. 0. 0.]   ← cat
#  [0. 1. 0.]   ← dog
#  [1. 0. 0.]   ← cat
#  [0. 0. 1.]]  ← fish

print(ohe.categories_)  # [array(['cat', 'dog', 'fish'])]

# Production: use inside Pipeline to handle unknown categories
ohe_prod = OneHotEncoder(
    handle_unknown='ignore',   # unknown → all zeros at inference
    min_frequency=100,         # rare cats < 100 occurrences → 'infrequent_sklearn'
    sparse_output=True          # save memory for high-cardinality
)

from sklearn.impute import SimpleImputer, KNNImputer

# Numeric imputer — median is outlier-robust
num_imputer = SimpleImputer(strategy='median')
X_train_imp = num_imputer.fit_transform(X_train[num_cols])
X_test_imp  = num_imputer.transform(X_test[num_cols])

# Categorical imputer
cat_imputer = SimpleImputer(strategy='most_frequent')

# KNN imputer — better accuracy, higher cost
knn_imp = KNNImputer(n_neighbors=5)
X_knn = knn_imp.fit_transform(X_train)   # uses kNN to fill NaN

# ✅ Always use inside Pipeline to prevent leakage
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler',  StandardScaler()),
    ('model',   LogisticRegression())
])
pipe.fit(X_train, y_train)
score = pipe.score(X_test, y_test)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

df = pd.read_csv('titanic.csv')
X = df.drop('survived', axis=1)
y = df['survived']

num_cols = ['age', 'fare', 'pclass']
cat_cols = ['sex', 'embarked']

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

# Numeric pipeline
num_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler',  StandardScaler())
])

# Categorical pipeline
cat_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# ColumnTransformer: apply different preprocessing per column type
preprocessor = ColumnTransformer([
    ('num', num_pipe, num_cols),
    ('cat', cat_pipe, cat_cols)
])

# Full pipeline: preprocessing + model
full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('model', RandomForestClassifier(n_estimators=100, random_state=42))
])

full_pipeline.fit(X_train, y_train)
y_pred = full_pipeline.predict(X_test)
print(classification_report(y_test, y_pred))

# GridSearchCV with pipeline params
from sklearn.model_selection import GridSearchCV

param_grid = {
    'model__n_estimators': [50, 100, 200],
    'model__max_depth': [None, 5, 10],
    'preprocessor__num__scaler__with_mean': [True]
}
gs = GridSearchCV(full_pipeline, param_grid, cv=5, n_jobs=-1)
gs.fit(X_train, y_train)
print(gs.best_params_)
print(gs.best_score_)

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import numpy as np
import matplotlib.pyplot as plt

# 1. Scale first (PCA is variance-based)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)

# 2. Fit PCA: keep 95% of variance
pca = PCA(n_components=0.95, random_state=42)
X_pca = pca.fit_transform(X_scaled)
print(f'Original: {X_scaled.shape[1]} features → PCA: {pca.n_components_}')

# Scree plot — find elbow
evr = pca95.explained_variance_ratio_
cum_evr = np.cumsum(evr)
fig, ax = plt.subplots(figsize=(8, 4))
ax.bar(range(len(evr)), evr, label='Individual')
ax.plot(range(len(evr)), cum_evr, 'r--', marker='o', label='Cumulative')
ax.axhline(0.95, ls='--', color='gray', label='95% threshold')
ax.legend(); ax.set_xlabel('Component'); ax.set_ylabel('Explained Variance')

# Use in Pipeline
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca',    PCA(n_components=0.95)),
    ('model',  LogisticRegression())
])
pipe.fit(X_train, y_train)

from sklearn.feature_selection import (
    SelectKBest, f_classif, mutual_info_classif,
    SelectFromModel, RFECV
)
from sklearn.ensemble import RandomForestClassifier
import pandas as pd

# ── Method 1: Univariate (ANOVA F-test)
selector = SelectKBest(f_classif, k=15)
X_sel = selector.fit_transform(X_train, y_train)
selected_mask  = selector.get_support()
selected_feats = X_train.columns[selected_mask].tolist()
print('Selected:', selected_feats)

# ── Method 2: Model-based (tree feature importances)
rf = RandomForestClassifier(n_estimators=100, random_state=42)
sfm = SelectFromModel(rf, threshold='0.5*mean')
sfm.fit(X_train, y_train)
X_sfm = sfm.transform(X_train)
feat_imp = pd.Series(rf.feature_importances_, index=X_train.columns)
print(feat_imp.sort_values(ascending=False).head(10))

# ── Method 3: RFECV — cross-validated RFE
rfecv = RFECV(
    estimator=RandomForestClassifier(50, random_state=42),
    cv=5, scoring='roc_auc', step=1, n_jobs=-1
)
rfecv.fit(X_train, y_train)
print(f'Optimal features: {rfecv.n_features_}')
X_rfecv = rfecv.transform(X_train)

# Use inside Pipeline to prevent leakage
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([
    ('selector', SelectKBest(f_classif, k=10)),
    ('scaler',   StandardScaler()),
    ('model',    LogisticRegression())
])
pipe.fit(X_train, y_train)