Data Preprocessing — Encoding & Scaling

Why Raw Data Usually Isn't ML-Ready

A typical pandas DataFrame straight out of a CSV mixes numbers, text categories, and inconsistent ranges — all in one table. Two problems come up constantly:

By the end of this lesson, that table needs to become: city converted into numeric columns, subscribed converted into a numeric target, and age/income rescaled onto a comparable range — all without letting any information from the test set influence how those transforms are learned.

Categorical Encoding

There are two encoders you'll reach for constantly, and picking the wrong one for the job silently damages a model.

OneHotEncoder — for unordered (nominal) categories

One-hot encoding creates a separate binary (0/1) column for each category. Use it for features where the categories have no natural order — like city or payment_method — so the model doesn't assume "Karachi" is somehow greater than "Lahore" the way it would if you encoded them as 0 and 1 on a single column.

from sklearn.preprocessing import OneHotEncoder
import numpy as np

cities = np.array([['Lahore'], ['Karachi'], ['Lahore'], ['Islamabad']])

# sparse_output=False returns a plain NumPy array (sklearn >= 1.2;
# use sparse=False on older versions)
encoder = OneHotEncoder(sparse_output=False)
encoded = encoder.fit_transform(cities)

print(encoded)
print(encoder.categories_)

LabelEncoder — mainly for the target column

LabelEncoder converts categories into a single column of integers (0, 1, 2, …). It's the right tool for encoding a classification target (y), where a single integer column is exactly what's expected. It's generally the WRONG tool for an input feature with unordered categories, because a single numeric column implies an order and a distance between categories that usually isn't real.

from sklearn.preprocessing import LabelEncoder

# A typical use: encoding the target column y, not a feature
labels = ['no', 'yes', 'yes', 'no']

le = LabelEncoder()
y_encoded = le.fit_transform(labels)

print(y_encoded)         # [0 1 1 0]
print(le.classes_)      # ['no' 'yes'] — alphabetical order by default

Feature Scaling

Once every column is numeric, the columns still might live on very different scales. Scaling rewrites each numeric column onto a comparable range without changing the relationships within that column.

StandardScaler — zero mean, unit variance

MinMaxScaler — squeeze into a fixed range

from sklearn.preprocessing import StandardScaler, MinMaxScaler

standard = StandardScaler()
X_train_std = standard.fit_transform(X_train)

minmax = MinMaxScaler()
X_train_mm = minmax.fit_transform(X_train)

print("Standardized mean ≈ 0:", X_train_std.mean(axis=0).round(2))
print("MinMax range is [0, 1]:", X_train_mm.min(), X_train_mm.max())

Why scaling matters for some algorithms and not others:

The Fit-on-Train-Only Rule

Every encoder and scaler in scikit-learn has both a .fit() step (learn parameters — the mean/std for a scaler, the category list for an encoder) and a .transform() step (apply those learned parameters). The rule that prevents data leakage: fit only on the training set, then use that same fitted object to transform both the training set and the test set.

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

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

scaler = StandardScaler()

# CORRECT: fit_transform on train, transform (no fit!) on test
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# WRONG — do not do this:
# X_test_scaled = scaler.fit_transform(X_test)  # refits on test stats!

This is exactly what scikit-learn's Pipeline class from Lesson 2 protects you from — inside a Pipeline, .fit() is only ever called on training folds, and .transform() is applied everywhere else automatically.

Lesson Summary