ColumnTransformer for mixed data

Setup#

pip install scikit-learn pandas

Tested against scikit-learn 1.7 and pandas 2.2.

Route columns, then train as one unit#

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

flats = pd.DataFrame({
    "city":  ["mumbai", "delhi", "mumbai", "pune", "delhi", "pune"],
    "rooms": [2, 3, 1, 2, 4, 3],
    "sqft":  [650, 900, 400, 750, 1200, 850],
})
pricey = pd.Series([1, 1, 0, 0, 1, 0])   # 1 = expensive flat

prep = ColumnTransformer([
    ("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
    ("num", StandardScaler(), ["rooms", "sqft"]),
])

model = Pipeline([("prep", prep), ("clf", LogisticRegression())])
model.fit(flats, pricey)

print(model.named_steps["prep"].get_feature_names_out())
new_flat = pd.DataFrame({"city": ["mumbai"], "rooms": [3], "sqft": [1100]})
print("pricey?", model.predict(new_flat))

['cat__city_delhi' 'cat__city_mumbai' 'cat__city_pune' 'num__rooms'
 'num__sqft']
pricey? [1]

The walkthrough#

Each entry is (name, transformer, columns). The name is yours, and it prefixes the output feature names — cat__city_delhi came from the cat branch. Column lists use DataFrame column names, which is the main reason to feed pipelines DataFrames rather than bare arrays.

The model never sees "mumbai". By the time LogisticRegression gets the data, the city column has become three 0/1 columns and the numbers are scaled. Five columns in total, matching the printed names.

Prediction takes a raw row. new_flat looks exactly like the training table. All the routing replays inside predict, using what each branch learned during fit.

Selecting columns by type instead of by name scales better than maintaining lists:

import numpy as np
from sklearn.compose import make_column_selector

prep = ColumnTransformer([
    ("cat", OneHotEncoder(handle_unknown="ignore"),
     make_column_selector(dtype_include=object)),
    ("num", StandardScaler(),
     make_column_selector(dtype_include=np.number)),
])

This picks every text column for encoding and every numeric column for scaling, whatever the table grows into.

Common mistakes#

Unlisted columns vanish. The default is remainder="drop": any column not routed anywhere is silently removed. If the model's accuracy is mysteriously poor, count your output columns. Pass remainder="passthrough" to keep the rest untouched — those come through named remainder__sqft and so on.

Scaling one-hot columns. Routing the encoder's 0/1 output through a scaler turns clean indicators into odd values and helps nothing. Branches run in parallel on the raw columns, so this mistake usually appears when people chain two ColumnTransformers. One layer of routing is almost always enough.

Feeding numpy arrays but selecting by name. Name-based selection needs a DataFrame. With a bare array you must select by column index, and index lists rot the moment someone reorders columns. Keep data in pandas until it enters the pipeline.

Assuming output column order matches the input table. Output order follows the transformer list order: all cat columns, then all num columns. Never index the output positionally; use get_feature_names_out() when you need to find a column.

Try it yourself#

Add a furnished column with values "yes" and "no", and route it through the encoder branch. Before running, predict the new output of get_feature_names_out(). Then set remainder="passthrough" with furnished unrouted, and see how the names differ.

What to learn next#

• Encoders and scalers, and the unknown-category trap — what each branch tool actually does.
• Writing your own transformer — when no built-in branch fits your data.
• Feature engineering — deciding what columns deserve to exist.