Encoding Categorical Variables

Why Machines Cannot Read Text Labels

Every machine learning algorithm is fundamentally a mathematical function — it multiplies, adds, takes derivatives, and computes distances. Numbers are the only currency it understands. When your dataset contains columns like "city", "gender", "product_category", or "education_level", you are holding data in a format that a model cannot process directly. Encoding categorical variables is the process of translating human-readable text labels into numeric representations that preserve the right information — and crucially, that do not introduce false mathematical relationships that don't actually exist.

Label Encoding — Integers for Categories

Label Encoding assigns each unique category value an integer, starting from 0. It is the simplest encoding method and the most frequently misused one. The integers are assigned in alphabetical order by default, which means the model sees a mathematical ranking that has no relationship to the actual data.

Label Encoding — Code

from sklearn.preprocessing import LabelEncoder
import pandas as pd

# ── Simple LabelEncoder ───────────────────────────────
le = LabelEncoder()
df['gender_enc'] = le.fit_transform(df['gender'])

# See the mapping
mapping = dict(zip(le.classes_, le.transform(le.classes_)))
print(mapping)   # {'Female': 0, 'Male': 1, 'Other': 2}

# ── Pandas map (explicit — always safer) ─────────────
gender_map = {'Female': 0, 'Male': 1, 'Other': 2}
df['gender_enc'] = df['gender'].map(gender_map)

# ── Encode multiple columns at once ──────────────────
binary_cols = ['is_returned', 'gender', 'has_discount']
for col in binary_cols:
    le = LabelEncoder()
    df[col + '_enc'] = le.fit_transform(df[col].astype('str'))

# ── Inverse transform: numbers back to labels ─────────
df['gender_original'] = le.inverse_transform(df['gender_enc'])

One-Hot Encoding — The Gold Standard for Nominal Categories

One-Hot Encoding (OHE) creates one new binary column for each unique category value. Each row has exactly one 1 and all other values are 0 — indicating which category this row belongs to. No ordering is implied. No false mathematical distance is created. It is the correct default for any nominal (unordered) categorical feature going into a linear model, neural network, or SVM.

One-Hot Encoding — Three Ways in Python

from sklearn.preprocessing import OneHotEncoder
import pandas as pd

# ── Method 1: pd.get_dummies (quickest for notebooks) ─
df_enc = pd.get_dummies(df, columns=['city', 'gender'], dtype=int)
print(df_enc.columns.tolist())
# ['amount','city_Bengaluru','city_Chennai','city_Delhi','city_Mumbai','city_Pune','gender_Female',...]

# ── Method 2: pd.get_dummies with drop_first ──────────
# Drop one column to avoid multicollinearity (dummy variable trap)
df_enc = pd.get_dummies(df, columns=['city'], drop_first=True, dtype=int)
# 5 cities → 4 columns (Bengaluru is the reference/baseline)

# ── Method 3: sklearn OneHotEncoder (pipeline-friendly) ─
ohe = OneHotEncoder(
    sparse_output=False,       # return dense array (not sparse matrix)
    handle_unknown='ignore',   # unseen categories → all zeros (safe for test data)
    drop='first'               # drop first category to avoid multicollinearity
)
ohe.fit(X_train[['city']])
encoded = ohe.transform(X_test[['city']])

# Get column names for the encoded matrix
feature_names = ohe.get_feature_names_out(['city'])
print(feature_names)   # ['city_Chennai','city_Delhi','city_Mumbai','city_Pune']

# ── Convert back to DataFrame ─────────────────────────
df_ohe = pd.DataFrame(encoded, columns=feature_names, index=X_test.index)
X_test  = pd.concat([X_test.drop(columns=['city']), df_ohe], axis=1)

Ordinal Encoding — When Order Genuinely Exists

Ordinal Encoding is the correct choice when your categorical variable has a natural, meaningful order that you want the model to learn from. Unlike Label Encoding, you specify the order explicitly — so the integers assigned reflect actual rank, not alphabetical accident.

from sklearn.preprocessing import OrdinalEncoder

# ── Define the explicit order ─────────────────────────
income_order    = [['Low', 'Medium', 'High', 'Very High']]
education_order = [['High School', 'Bachelor', 'Master', 'PhD']]
size_order      = [['XS', 'S', 'M', 'L', 'XL', 'XXL']]

# ── Fit OrdinalEncoder with specified order ───────────
oe = OrdinalEncoder(
    categories=income_order,
    handle_unknown='use_encoded_value',
    unknown_value=-1          # unseen categories → -1
)
df[['income_encoded']] = oe.fit_transform(df[['income_bracket']])
# Low→0  Medium→1  High→2  Very High→3

# ── Verify the mapping ────────────────────────────────
for cat, code in zip(oe.categories_[0], range(len(oe.categories_[0]))):
    print(f"  {cat:12} → {code}")

# ── Pandas equivalent (simpler for notebooks) ─────────
income_map = {'Low':0, 'Medium':1, 'High':2, 'Very High':3}
df['income_encoded'] = df['income_bracket'].map(income_map)

Target Encoding — For High-Cardinality Categories

When a categorical column has many unique values — 28 cities, 500 product SKUs, 10,000 user IDs — One-Hot Encoding creates a sparse, high-dimensional matrix that causes the curse of dimensionality. Target Encoding replaces each category with the mean of the target variable for that category. It produces a single numeric column that directly encodes the relationship between category and outcome.

# ── Basic Target Encoding (risk: leakage on train set) ─
target_means = df.groupby('city')['purchase_amount'].mean()
df['city_target'] = df['city'].map(target_means)

# ── Proper Target Encoding with K-Fold (no leakage) ───
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    df = df.copy()
    df[col + '_te'] = np.nan
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)
    for train_idx, val_idx in kf.split(df):
        means = df.iloc[train_idx].groupby(col)[target].mean()
        df.iloc[val_idx, df.columns.get_loc(col + '_te')] = (
            df.iloc[val_idx][col].map(means)
        )
    # Fill any unseen categories with global mean
    global_mean = df[target].mean()
    df[col + '_te'] = df[col + '_te'].fillna(global_mean)
    return df

df = target_encode_kfold(df, col='city', target='purchase_amount')

# ── Using category_encoders library (recommended) ─────
# pip install category_encoders
import category_encoders as ce
te = ce.TargetEncoder(cols=['city'], smoothing=10)
te.fit(X_train[['city']], y_train)
X_train['city_te'] = te.transform(X_train[['city']])
X_test['city_te']  = te.transform(X_test[['city']])

Frequency Encoding — Safe High-Cardinality Alternative

Frequency Encoding replaces each category with the proportion of rows that belong to that category. It captures the idea that rarer categories are different from common ones, without using the target variable — so there is no leakage risk. It is particularly effective for tree-based models.

# ── Frequency encoding ────────────────────────────────
freq_map = df['city'].value_counts(normalize=True)  # proportion of total rows
df['city_freq'] = df['city'].map(freq_map)

# ── Count encoding (raw counts instead of proportion) ─
count_map = df['city'].value_counts()
df['city_count'] = df['city'].map(count_map)

# ── Apply to multiple high-cardinality columns ────────
high_card_cols = ['city', 'product_sku', 'agent_id']
for col in high_card_cols:
    freq = df[col].value_counts(normalize=True)
    df[col + '_freq'] = df[col].map(freq).fillna(0)   # unseen → 0

print(df[['city', 'city_freq']].drop_duplicates().sort_values('city_freq', ascending=False))

Encoding Methods — Side-by-Side Comparison

Complete Encoding Pipeline with sklearn

from sklearn.pipeline      import Pipeline
from sklearn.compose       import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
from sklearn.impute         import SimpleImputer
from sklearn.ensemble       import RandomForestClassifier

# ── Column groups ─────────────────────────────────────
numeric_cols = ['age', 'purchase_amount', 'delivery_days']
nominal_cols = ['city', 'gender', 'product_category']   # unordered
ordinal_cols = ['income_bracket']                         # ordered

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

# ── Nominal pipeline ─────────────────────────────────
nom_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('ohe',     OneHotEncoder(
        handle_unknown='ignore',
        sparse_output=False,
        drop='first'
    ))
])

# ── Ordinal pipeline ─────────────────────────────────
ord_pipe = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('ordinal', OrdinalEncoder(
        categories=[['Low', 'Medium', 'High', 'Very High']],
        handle_unknown='use_encoded_value',
        unknown_value=-1
    ))
])

# ── Combine all transformers ──────────────────────────
preprocessor = ColumnTransformer([
    ('numeric',  num_pipe, numeric_cols),
    ('nominal',  nom_pipe, nominal_cols),
    ('ordinal',  ord_pipe, ordinal_cols),
], remainder='drop')

# ── Full model pipeline ───────────────────────────────
full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('model',        RandomForestClassifier(n_estimators=200, random_state=42))
])

full_pipeline.fit(X_train, y_train)
print(f"Test accuracy: {full_pipeline.score(X_test, y_test):.3f}")

# ── Save and reload the pipeline ─────────────────────
import joblib
joblib.dump(full_pipeline, 'model_pipeline.pkl')
pipeline_loaded = joblib.load('model_pipeline.pkl')
predictions = pipeline_loaded.predict(new_data)          # raw data → predictions

Golden Rules of Categorical Encoding