99.5% Accuracy, Zero Fraud Caught — ML Metrics That Lie

# TheCodeForge — Mistake 1: Overfitting Detection and Fix
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import numpy as np

# Generate data
X, y = make_classification(n_samples=200, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# MISTAKE: Unrestricted Decision Tree (overfits)
dt_overfit = DecisionTreeClassifier(random_state=42)
dt_overfit.fit(X_train, y_train)
train_acc_overfit = accuracy_score(y_train, dt_overfit.predict(X_train))
test_acc_overfit = accuracy_score(y_test, dt_overfit.predict(X_test))
print('=== Overfitting Example ===')
print(f'Decision Tree (unrestricted)')
print(f'  Train accuracy: {train_acc_overfit:.2%}')
print(f'  Test accuracy:  {test_acc_overfit:.2%}')
print(f'  Gap:            {train_acc_overfit - test_acc_overfit:.2%}')

# FIX 1: Restrict tree depth (regularization)
dt_fixed = DecisionTreeClassifier(max_depth=5, min_samples_leaf=10, random_state=42)
dt_fixed.fit(X_train, y_train)
train_acc_fixed = accuracy_score(y_train, dt_fixed.predict(X_train))
test_acc_fixed = accuracy_score(y_test, dt_fixed.predict(X_test))
print(f'\nDecision Tree (max_depth=5, min_samples_leaf=10)')
print(f'  Train accuracy: {train_acc_fixed:.2%}')
print(f'  Test accuracy:  {test_acc_fixed:.2%}')
print(f'  Gap:            {train_acc_fixed - test_acc_fixed:.2%}')

# FIX 2: Use ensemble method (Random Forest)
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
train_acc_rf = accuracy_score(y_train, rf.predict(X_train))
test_acc_rf = accuracy_score(y_test, rf.predict(X_test))
print(f'\nRandom Forest (100 trees)')
print(f'  Train accuracy: {train_acc_rf:.2%}')
print(f'  Test accuracy:  {test_acc_rf:.2%}')
print(f'  Gap:            {train_acc_rf - test_acc_rf:.2%}')

# TheCodeForge — Mistake 2: Data Leakage Detection and Fix
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score
import numpy as np

X, y = make_classification(n_samples=500, n_features=10, random_state=42)

# MISTAKE: Fit scaler on ALL data before splitting (data leakage)
scaler_leaky = StandardScaler()
X_scaled_leaky = scaler_leaky.fit_transform(X)  # LEAKAGE: saw test data stats
X_train_leaky, X_test_leaky, y_train, y_test = train_test_split(
    X_scaled_leaky, y, test_size=0.2, random_state=42
)
model_leaky = LogisticRegression(random_state=42)
model_leaky.fit(X_train_leaky, y_train)
acc_leaky = accuracy_score(y_test, model_leaky.predict(X_test_leaky))
print('=== Data Leakage Example ===')
print(f'MISTAKE: Scaler fit on all data')
print(f'  Test accuracy: {acc_leaky:.2%}')
print(f'  (Inflated — scaler saw test data statistics)')

# CORRECT: Split first, then fit scaler on training data only
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
scaler_correct = StandardScaler()
X_train_scaled = scaler_correct.fit_transform(X_train)  # fit on train only
X_test_scaled = scaler_correct.transform(X_test)          # transform test
model_correct = LogisticRegression(random_state=42)
model_correct.fit(X_train_scaled, y_train)
acc_correct = accuracy_score(y_test, model_correct.predict(X_test_scaled))
print(f'\nCORRECT: Scaler fit on training data only')
print(f'  Test accuracy: {acc_correct:.2%}')
print(f'  (Honest — no leakage)')

# BEST: Use Pipeline to enforce correct order automatically
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression(random_state=42))
])
pipeline.fit(X_train, y_train)
acc_pipeline = accuracy_score(y_test, pipeline.predict(X_test))
print(f'\nBEST: Pipeline (leakage-proof by design)')
print(f'  Test accuracy: {acc_pipeline:.2%}')
print(f'\nDifference (leaky vs honest): {abs(acc_leaky - acc_correct):.2%}')

# TheCodeForge — Mistake 3: Wrong Metrics for Imbalanced Data
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, confusion_matrix, classification_report
)
import numpy as np

# Highly imbalanced dataset: 95% class 0, 5% class 1
X, y = make_classification(
    n_samples=2000, n_features=20, weights=[0.95, 0.05],
    flip_y=0, random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print('Class distribution:')
unique, counts = np.unique(y_train, return_counts=True)
for cls, cnt in zip(unique, counts):
    print(f'  Class {cls}: {cnt} samples ({cnt/len(y_train):.1%})')

# MISTAKE: Majority class baseline (always predicts 0)
baseline = DummyClassifier(strategy='most_frequent', random_state=42)
baseline.fit(X_train, y_train)
y_pred_baseline = baseline.predict(X_test)
print(f'\n=== Baseline: Always Predict Majority ===')
print(f'Accuracy: {accuracy_score(y_test, y_pred_baseline):.2%}  <- looks great')
print(f'F1 (class 1): {f1_score(y_test, y_pred_baseline):.2%}  <- model is useless')
print(f'Confusion Matrix:\n{confusion_matrix(y_test, y_pred_baseline)}')

# CORRECT: Use appropriate metrics and handle imbalance
model = RandomForestClassifier(
    n_estimators=100, class_weight='balanced', random_state=42
)
model.fit(X_train, y_train)
y_pred_model = model.predict(X_test)
print(f'\n=== Random Forest with class_weight=balanced ===')
print(f'Accuracy:  {accuracy_score(y_test, y_pred_model):.2%}')
print(f'Precision: {precision_score(y_test, y_pred_model):.2%}')
print(f'Recall:    {recall_score(y_test, y_pred_model):.2%}')
print(f'F1-score:  {f1_score(y_test, y_pred_model):.2%}')
print(f'\nClassification Report:\n{classification_report(y_test, y_pred_model)}')

# TheCodeForge — Mistake 4: Not Using Cross-Validation
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
import numpy as np

X, y = make_classification(n_samples=200, n_features=20, random_state=42)

# MISTAKE: Single train-test split — result depends on the split
print('=== Single Train-Test Split (Unreliable) ===')
for seed in [42, 7, 99, 123, 256]:
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=seed
    )
    model = DecisionTreeClassifier(max_depth=5, random_state=42)
    model.fit(X_train, y_train)
    acc = accuracy_score(y_test, model.predict(X_test))
    print(f'  random_state={seed:>3}: accuracy={acc:.2%}')

print('  -> Accuracy varies by up to 15% depending on split!')

# CORRECT: Cross-validation — reliable performance estimate
model = DecisionTreeClassifier(max_depth=5, random_state=42)
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f'\n=== 5-Fold Cross-Validation (Reliable) ===')
print(f'  Fold scores: {scores.round(4)}')
print(f'  Mean accuracy: {scores.mean():.2%}')
print(f'  Std deviation: {scores.std():.2%}')
print(f'  95% CI: {scores.mean():.2%} +/- {scores.std() * 2:.2%}')

# BEST: Stratified K-Fold for imbalanced data
from sklearn.model_selection import StratifiedKFold
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_strat = cross_val_score(model, X, y, cv=skf, scoring='accuracy')
print(f'\n=== Stratified 5-Fold (Best for Imbalanced) ===')
print(f'  Fold scores: {scores_strat.round(4)}')
print(f'  Mean accuracy: {scores_strat.mean():.2%}')
print(f'  Std deviation: {scores_strat.std():.2%}')

# TheCodeForge — Mistake 5: Not Scaling Features
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
import numpy as np

# Create data with very different feature scales
np.random.seed(42)
X, y = make_classification(n_samples=500, n_features=5, random_state=42)
# Artificially scale features to different ranges
X[:, 0] *= 1000    # feature 0: range ~[-3000, 3000]
X[:, 1] *= 0.001   # feature 1: range ~[-0.003, 0.003]
# features 2-4: range ~[-3, 3] (original scale)

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

print('Feature ranges (training set):')
for i in range(X_train.shape[1]):
    print(f'  Feature {i}: [{X_train[:, i].min():.3f}, {X_train[:, i].max():.3f}]')

# KNN WITHOUT scaling (MISTAKE for distance-based models)
knn_unscaled = KNeighborsClassifier(n_neighbors=5)
knn_unscaled.fit(X_train, y_train)
acc_unscaled = accuracy_score(y_test, knn_unscaled.predict(X_test))

# KNN WITH scaling (CORRECT)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
knn_scaled = KNeighborsClassifier(n_neighbors=5)
knn_scaled.fit(X_train_scaled, y_train)
acc_scaled = accuracy_score(y_test, knn_scaled.predict(X_test_scaled))

print(f'\n=== KNN (Distance-Based — Needs Scaling) ===')
print(f'  Without scaling: {acc_unscaled:.2%}')
print(f'  With scaling:    {acc_scaled:.2%}')
print(f'  Improvement:     {acc_scaled - acc_unscaled:.2%}')

# Decision Tree WITHOUT scaling (scaling not needed)
dt_unscaled = DecisionTreeClassifier(max_depth=5, random_state=42)
dt_unscaled.fit(X_train, y_train)
acc_dt_unscaled = accuracy_score(y_test, dt_unscaled.predict(X_test))

dt_scaled = DecisionTreeClassifier(max_depth=5, random_state=42)
dt_scaled.fit(X_train_scaled, y_train)
acc_dt_scaled = accuracy_score(y_test, dt_scaled.predict(X_test_scaled))

print(f'\n=== Decision Tree (Not Affected by Scaling) ===')
print(f'  Without scaling: {acc_dt_unscaled:.2%}')
print(f'  With scaling:    {acc_dt_scaled:.2%}')
print(f'  Difference:      {abs(acc_dt_scaled - acc_dt_unscaled):.2%}')

print('\nRule: Scale for KNN, SVM, Neural Networks. Not needed for trees.')

# TheCodeForge — Mistake 6: Ignoring the Baseline Model
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score
import numpy as np

X, y = make_classification(
    n_samples=1000, n_features=20, weights=[0.7, 0.3],
    random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# BASELINE 1: Always predict the majority class
baseline_majority = DummyClassifier(strategy='most_frequent', random_state=42)
baseline_majority.fit(X_train, y_train)
acc_majority = accuracy_score(y_test, baseline_majority.predict(X_test))

# BASELINE 2: Random prediction respecting class distribution
baseline_stratified = DummyClassifier(strategy='stratified', random_state=42)
baseline_stratified.fit(X_train, y_train)
acc_stratified = accuracy_score(y_test, baseline_stratified.predict(X_test))

print('=== Baseline Models ===')
print(f'Majority class:    accuracy={acc_majority:.2%}')
print(f'Stratified random: accuracy={acc_stratified:.2%}')

# Simple model
lr = LogisticRegression(random_state=42)
lr.fit(X_train, y_train)
acc_lr = accuracy_score(y_test, lr.predict(X_test))

# Complex model
dt = DecisionTreeClassifier(max_depth=5, random_state=42)
dt.fit(X_train, y_train)
acc_dt = accuracy_score(y_test, dt.predict(X_test))

print(f'\n=== Your Models ===')
print(f'Logistic Regression: accuracy={acc_lr:.2%}')
print(f'Decision Tree:       accuracy={acc_dt:.2%}')

print(f'\n=== Comparison ===')
for name, acc in [('Logistic Regression', acc_lr), ('Decision Tree', acc_dt)]:
    improvement = acc - acc_majority
    if improvement > 0:
        print(f'{name} beats baseline by {improvement:.2%} — worth using.')
    else:
        print(f'{name} does NOT beat baseline — it learned nothing useful.')

print('\nRule: Always compare against a baseline before deploying.')

# TheCodeForge — Mistake 7: Tuning on Test Data
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# MISTAKE: Manually tuning on test data
print('=== MISTAKE: Tuning on Test Data ===')
best_acc = 0
best_depth = 0
for depth in range(1, 20):
    model = DecisionTreeClassifier(max_depth=depth, random_state=42)
    model.fit(X_train, y_train)
    acc = accuracy_score(y_test, model.predict(X_test))  # LEAKAGE
    if acc > best_acc:
        best_acc = acc
        best_depth = depth
print(f'Best depth: {best_depth}, Test accuracy: {best_acc:.2%}')
print('Problem: test data influenced the hyperparameter choice.')
print('The reported accuracy is optimistic — it was selected to look good.')

# CORRECT: GridSearchCV with cross-validation on training data
print('\n=== CORRECT: GridSearchCV on Training Data ===')
param_grid = {'max_depth': range(1, 20)}
grid_search = GridSearchCV(
    DecisionTreeClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy'
)
grid_search.fit(X_train, y_train)  # only uses training data
print(f'Best depth: {grid_search.best_params_["max_depth"]}')
print(f'Best CV accuracy: {grid_search.best_score_:.2%}')

# Final evaluation on untouched test set
final_acc = accuracy_score(y_test, grid_search.predict(X_test))
print(f'Final test accuracy: {final_acc:.2%}')
print('\nRule: Tune with CV on train, evaluate once on test.')

# TheCodeForge — Mistake 8: Not Checking Feature Importance
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
import numpy as np

X, y = make_classification(
    n_samples=500, n_features=10, n_informative=5,
    n_redundant=3, random_state=42
)
feature_names = [f'feature_{i}' for i in range(10)]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

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

# CORRECT: Check built-in feature importance
importances = model.feature_importances_
indices = np.argsort(importances)[::-1]

print('=== Built-in Feature Importance (Gini) ===')
for i, idx in enumerate(indices):
    bar = '#' * int(importances[idx] * 50)
    print(f'{i+1}. {feature_names[idx]:>12}: {importances[idx]:.3f} {bar}')

print(f'\nTop 3 features account for {importances[indices[:3]].sum():.1%} of importance.')
print(f'Bottom 3 features account for {importances[indices[-3:]].sum():.1%} — consider removing.')

# BETTER: Permutation importance (model-agnostic, more reliable)
perm_imp = permutation_importance(
    model, X_test, y_test, n_repeats=10, random_state=42
)
print('\n=== Permutation Importance (more reliable) ===')
perm_indices = np.argsort(perm_imp.importances_mean)[::-1]
for i, idx in enumerate(perm_indices[:5]):
    print(f'{i+1}. {feature_names[idx]:>12}: '
          f'{perm_imp.importances_mean[idx]:.3f} '
          f'+/- {perm_imp.importances_std[idx]:.3f}')

print('\nRule: Check feature importance to detect leakage and remove noise.')

# TheCodeForge — Mistake 9: Data Distribution Shift
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from scipy import stats

# Simulate training data (2024 distribution)
np.random.seed(42)
X_train = np.random.randn(500, 2) + [0, 0]
y_train = (X_train[:, 0] + X_train[:, 1] > 0).astype(int)

# Simulate production data (2025 distribution shifted)
X_prod = np.random.randn(200, 2) + [2, -1]  # distribution shifted
y_prod = (X_prod[:, 0] + X_prod[:, 1] > 0).astype(int)

model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)

train_acc = accuracy_score(y_train, model.predict(X_train))
prod_acc = accuracy_score(y_prod, model.predict(X_prod))

print('=== Distribution Shift Problem ===')
print(f'Training accuracy (2024 data): {train_acc:.2%}')
print(f'Production accuracy (2025 data): {prod_acc:.2%}')
print(f'Performance drop: {train_acc - prod_acc:.2%}')

print(f'\nTraining feature means: {X_train.mean(axis=0).round(2)}')
print(f'Production feature means: {X_prod.mean(axis=0).round(2)}')
print(f'Means shifted — the model learned patterns that no longer hold.')

# Detect shift with statistical test (KS test)
print('\n=== Distribution Shift Detection ===')
for i in range(X_train.shape[1]):
    ks_stat, p_value = stats.ks_2samp(X_train[:, i], X_prod[:, i])
    shifted = 'SHIFTED' if p_value < 0.05 else 'OK'
    print(f'Feature {i}: KS stat={ks_stat:.3f}, p={p_value:.4f} -> {shifted}')

print('\nRule: Monitor production data distributions and retrain periodically.')

# TheCodeForge — Mistake 10: Wrong Loss Function
import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, HuberRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error

# Create regression data with outliers
np.random.seed(42)
X = np.random.randn(200, 1)
y = 3 * X.squeeze() + np.random.randn(200) * 0.5
# Add outliers — every 10th point has a large error
y[::10] += 10

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

# MISTAKE: MSE loss with outliers — model chases extreme values
lr = LinearRegression()
lr.fit(X_train, y_train)
pred_mse = lr.predict(X_test)
print('=== MSE Loss (MISTAKE for outlier data) ===')
print(f'MSE:         {mean_squared_error(y_test, pred_mse):.2f}')
print(f'MAE:         {mean_absolute_error(y_test, pred_mse):.2f}')
print(f'Coefficient: {lr.coef_[0]:.2f} (true value: 3.00)')
print(f'Intercept:   {lr.intercept_:.2f} (true value: 0.00)')

# CORRECT: Huber loss — robust to outliers
huber = HuberRegressor(epsilon=1.35)  # default epsilon
huber.fit(X_train, y_train)
pred_huber = huber.predict(X_test)
print(f'\n=== Huber Loss (CORRECT for outlier data) ===')
print(f'MSE:         {mean_squared_error(y_test, pred_huber):.2f}')
print(f'MAE:         {mean_absolute_error(y_test, pred_huber):.2f}')
print(f'Coefficient: {huber.coef_[0]:.2f} (true value: 3.00)')
print(f'Intercept:   {huber.intercept_:.2f} (true value: 0.00)')

print(f'\n=== Loss Function Guide ===')
print(f'Classification:        cross-entropy (log_loss)')
print(f'Regression (clean):    MSE')
print(f'Regression (outliers): Huber or MAE')
print(f'Imbalanced classes:    weighted cross-entropy or focal loss')

# TheCodeForge — Mistake 11: Not Using sklearn Pipeline
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
import numpy as np
import joblib

X, y = make_classification(n_samples=500, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# MISTAKE: Manual preprocessing (error-prone, leakage risk)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
pca = PCA(n_components=10)
X_train_pca = pca.fit_transform(X_train_scaled)
model = LogisticRegression(random_state=42)
model.fit(X_train_pca, y_train)

# Must remember to apply same transforms to test data
X_test_scaled = scaler.transform(X_test)
X_test_pca = pca.transform(X_test_scaled)
print('=== Manual Preprocessing (MISTAKE) ===')
print(f'Accuracy: {model.score(X_test_pca, y_test):.2%}')
print('Problem: easy to forget steps, apply in wrong order, or fit on wrong data.')

# CORRECT: Pipeline — leakage-proof by design
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=10)),
    ('classifier', LogisticRegression(random_state=42))
])
pipeline.fit(X_train, y_train)
print(f'\n=== sklearn Pipeline (CORRECT) ===')
print(f'Accuracy: {pipeline.score(X_test, y_test):.2%}')

# Cross-validation works seamlessly with Pipeline
cv_scores = cross_val_score(pipeline, X, y, cv=5)
print(f'CV accuracy: {cv_scores.mean():.2%} (+/- {cv_scores.std():.2%})')

# Deployment: serialize the entire pipeline — one file, one predict call
joblib.dump(pipeline, 'model_pipeline.joblib')
loaded_pipeline = joblib.load('model_pipeline.joblib')
print(f'\nLoaded pipeline accuracy: {loaded_pipeline.score(X_test, y_test):.2%}')
print('Deployment: one file contains scaler + PCA + model.')

print('\nRule: Always use Pipeline — it prevents leakage and simplifies deployment.')

# TheCodeForge — Mistake 12: No Domain Expert Validation
# Example: A model predicts house prices using zip code as a numeric feature
# The model achieves high R-squared but makes nonsensical predictions

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_absolute_error

# Simulated data: house prices
np.random.seed(42)
n_samples = 500
zip_code = np.random.randint(10000, 99999, n_samples)
sqft = np.random.randint(500, 5000, n_samples)
price = sqft * 150 + np.random.randn(n_samples) * 10000

X = np.column_stack([zip_code, sqft])
X_train, X_test, y_train, y_test = train_test_split(
    X, price, test_size=0.2, random_state=42
)

model = LinearRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print('=== Technical Metrics Look Good ===')
print(f'R-squared: {r2_score(y_test, predictions):.2%}')
print(f'MAE:       ${mean_absolute_error(y_test, predictions):,.0f}')
print(f'\nModel coefficients:')
print(f'  zip_code: {model.coef_[0]:.4f} per unit')
print(f'  sqft:     {model.coef_[1]:.2f} per unit')

print(f'\n=== Domain Expert Would Catch This ===')
print(f'The model treats zip_code as a continuous number.')
print(f'Zip code 99998 is not "worth more" than zip code 10001.')
print(f'This is nonsensical — zip code is categorical, not numeric.')
print(f'Fix: one-hot encode zip_code or use target encoding.')

# What a domain expert review should include:
print(f'\n=== Domain Expert Review Checklist ===')
print(f'1. Are feature types correct? (categorical vs numeric)')
print(f'2. Do feature importances make domain sense?')
print(f'3. Do sample predictions pass the sanity test?')
print(f'4. Are there edge cases the model handles incorrectly?')
print(f'5. Would you trust this prediction if it were your money?')

print('\nRule: Always validate predictions with domain experts before deployment.')

// io.thecodeforge
import torch.nn as nn

class WeightedBinaryCrossEntropy(nn.Module):
    def __init__(self, fp_cost=50.0, fn_cost=500.0):
        super().__init__()
        # fp_cost: false positive cost to business
        # fn_cost: false negative cost to business
        pos_weight = torch.tensor([fn_cost / fp_cost])  # ratio matters
        self.loss = nn.BCEWithLogitsLoss(pos_weight=pos_weight)

    def forward(self, logits, targets):
        return self.loss(logits, targets)

// io.thecodeforge
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.externals import joblib

# Build pipeline once
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])
pipe.fit(X_train, y_train)

# Serialize entire pipeline
joblib.dump(pipe, '20190805_loan_default_pipeline.pkl')

# Inference loads the pipeline — never just weights
loaded_pipe = joblib.load('20190805_loan_default_pipeline.pkl')
preds = loaded_pipe.predict(X_new)

// io.thecodeforge
# Step 1: deploy v2 as shadow alongside v1
kubectl set image deployment/model-serving \
  model-v1=myregistry/model:v1 \
  model-v2=myregistry/model:v2 \
  --shadow

# Step 2: wait 30 minutes, monitor prediction drift
kubectl logs -l app=model-serving -c shadow-container | \
  grep 'prediction_diff' > /tmp/shadow_drift.csv

# Step 3: if max absolute difference < 0.05, promote
if awk -F',' '{if ($1 > 0.05) exit 1}' /tmp/shadow_drift.csv; then
  kubectl set image deployment/model-serving \
    model=myregistry/model:v2
fi