Scikit-Learn — Avoiding 24% Accuracy Drop from Data Leak

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# io.thecodeforge: Standardizing the Iris Classification Workflow
iris = load_iris()
X = iris.data    # Features: sepal length, sepal width, petal length, petal width
y = iris.target  # Labels: 0=setosa, 1=versicolor, 2=virginica

# Split: 80% for training, 20% for testing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train a K-Nearest Neighbours classifier
classifier = KNeighborsClassifier(n_neighbors=3)
classifier.fit(X_train, y_train)  # Learn from training data

# Predict on unseen test data
predictions = classifier.predict(X_test)

# Evaluate
accuracy = accuracy_score(y_test, predictions)
print(f"Test accuracy: {accuracy:.2%}")

# Swap to a different algorithm — only ONE line changes
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
print(f"Random Forest accuracy: {accuracy_score(y_test, rf.predict(X_test)):.2%}")

# io.thecodeforge: Production-grade Scikit-Learn Environment
FROM python:3.11-slim

# Install system-level dependencies for scientific computing
RUN apt-get update && apt-get install -y \
    build-essential \
    libatlas-base-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "first_classifier.py"]

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

iris = load_iris()
X, y = iris.data, iris.target

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

# Unlimited depth tree — will memorise every training example
overfitted_tree = DecisionTreeClassifier(max_depth=None)
overfitted_tree.fit(X_train, y_train)

train_acc = accuracy_score(y_train, overfitted_tree.predict(X_train))
test_acc  = accuracy_score(y_test,  overfitted_tree.predict(X_test))

print(f"Training accuracy: {train_acc:.2%}")  # Perfect — it memorised
print(f"Test accuracy:     {test_acc:.2%}")   # Lower — it can't generalise
print(f"Overfitting gap:   {train_acc - test_acc:.2%}")

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# io.thecodeforge: A production-ready pipeline with preprocessing and model
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

# Build pipeline: scale -> classify
pipeline = Pipeline([
    ('scaler', StandardScaler()),  # fit on training data only
    ('classifier', RandomForestClassifier(n_estimators=50, random_state=42))
])

# Fit entire pipeline — scaler fits only on X_train
pipeline.fit(X_train, y_train)

# Predict on test — scaler.transform is called automatically
preds = pipeline.predict(X_test)
print(f"Pipeline accuracy: {accuracy_score(y_test, preds):.2%}")

# Access individual steps:
# pipeline.named_steps['scaler'].mean_  # mean used for scaling
# pipeline.named_steps['classifier'].feature_importances_

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

# io.thecodeforge: Robust cross-validation with pipeline
data = load_wine()
X, y = data.data, data.target

pipeline = make_pipeline(StandardScaler(), RandomForestClassifier(n_estimators=50, random_state=42))

# 5-fold stratified cross-validation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipeline, X, y, cv=cv, scoring='accuracy')

print(f"CV Accuracies: {scores}")
print(f"Mean: {scores.mean():.2%} ± {scores.std():.2%}")

# Compare with single holdout
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)
pipeline.fit(X_train, y_train)
single_score = pipeline.score(X_test, y_test)
print(f"Single holdout: {single_score:.2%}")
print(f"Lesson: CV mean is more reliable than a single split.")