Introduction

Scikit-learn’s ordinary linear regression models do not accept missing values in the input matrix, so you need to clean or impute them before fitting. The safest approach is usually not to fill values manually in a dataframe and hope for the best, but to build an explicit preprocessing pipeline that handles missing data during both training and prediction.

Why Imputation Belongs in the Pipeline

A common beginner pattern is to fill missing values in the training dataframe, fit a model, and then forget to apply the same logic to future data. That leads to inconsistent preprocessing and broken predictions.

Scikit-learn gives you a better pattern: combine an imputer and a regression model in a Pipeline.

1import numpy as np
2from sklearn.impute import SimpleImputer
3from sklearn.linear_model import LinearRegression
4from sklearn.pipeline import Pipeline
5
6X = np.array([
7    [1200, 3],
8    [1500, np.nan],
9    [np.nan, 2],
10    [1800, 4],
11], dtype=float)
12
13y = np.array([200000, 250000, 180000, 300000], dtype=float)
14
15model = Pipeline([
16    ("imputer", SimpleImputer(strategy="mean")),
17    ("regressor", LinearRegression()),
18])
19
20model.fit(X, y)
21predictions = model.predict([[1600, np.nan]])
22print(predictions)

Here the imputer learns replacement values from the training data and applies the same transformation during prediction.

Choosing an Imputation Strategy

The simplest imputation strategies are:

• 'mean for numeric columns'
• 'median for numeric columns with outliers'
• 'most_frequent for categorical columns'
• 'constant when you want a fixed placeholder'

For linear regression, mean or median is often a reasonable baseline for numeric features:

SimpleImputer(strategy="median")

There is no universal best choice. Use a strategy that matches the data and the missingness pattern.

Handling Mixed Numeric and Categorical Data

Real datasets often contain both numeric and categorical columns. In that case, use a ColumnTransformer so each group gets the right preprocessing.

1import pandas as pd
2from sklearn.compose import ColumnTransformer
3from sklearn.impute import SimpleImputer
4from sklearn.linear_model import LinearRegression
5from sklearn.pipeline import Pipeline
6from sklearn.preprocessing import OneHotEncoder
7
8df = pd.DataFrame({
9    "sqft": [1200, 1500, None, 1800],
10    "bedrooms": [3, None, 2, 4],
11    "neighborhood": ["A", "B", "A", None],
12    "price": [200000, 250000, 180000, 300000],
13})
14
15X = df[["sqft", "bedrooms", "neighborhood"]]
16y = df["price"]
17
18numeric_features = ["sqft", "bedrooms"]
19categorical_features = ["neighborhood"]
20
21preprocess = ColumnTransformer([
22    ("num", SimpleImputer(strategy="median"), numeric_features),
23    ("cat", Pipeline([
24        ("imputer", SimpleImputer(strategy="most_frequent")),
25        ("encoder", OneHotEncoder(handle_unknown="ignore")),
26    ]), categorical_features),
27])
28
29model = Pipeline([
30    ("preprocess", preprocess),
31    ("regressor", LinearRegression()),
32])
33
34model.fit(X, y)
35print(model.predict(pd.DataFrame([{
36    "sqft": 1600,
37    "bedrooms": None,
38    "neighborhood": "B",
39}])))

This keeps the preprocessing logic explicit and consistent.

Should You Drop Missing Rows Instead

Dropping rows can be acceptable when:

• only a tiny fraction of rows are missing
• the missingness is close to random
• removing those rows does not distort the dataset

Example:

clean_df = df.dropna()

The problem is that this can throw away useful signal or bias the training data if the missingness is systematic. Imputation is usually safer than aggressive row deletion unless the dataset is large and the missingness is minor.

Add Missingness Indicators When It Matters

Sometimes the fact that a value is missing is itself predictive. For example, missing income data may correlate with a specific customer behavior.

Scikit-learn can add indicator columns:

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="median", add_indicator=True)

That tells the model not only the filled-in numeric value, but also whether the original value was missing.

This can help linear models when missingness is informative rather than random.

Validate the Whole Pipeline

Because imputation learns values from training data, cross-validation should evaluate the entire pipeline, not a manually pre-imputed dataset created before the split.

Correct:

1from sklearn.model_selection import cross_val_score
2
3scores = cross_val_score(model, X, y, cv=5, scoring="neg_mean_squared_error")
4print(scores)

That ensures the imputer is fitted separately inside each training fold. If you impute before cross-validation, you leak information from validation data into training.

Common Pitfalls

The biggest pitfall is filling missing values before the train-test split. That leaks information from future or validation rows into the preprocessing step.

Another common mistake is using one imputation rule for every column without considering data type or distribution. Numeric and categorical features usually need different handling.

People also sometimes forget prediction-time behavior. If you fill missing values manually during training but not in production, the model pipeline is incomplete.

Finally, simple imputation is only a baseline. If a feature is mostly missing or if missingness is structurally meaningful, you may need better feature engineering rather than a different fill value.

Summary

• Linear regression in scikit-learn needs missing values handled before fitting.
• Use a Pipeline so imputation and prediction stay tied together.
• 'SimpleImputer is a common baseline for numeric and categorical features.'
• 'ColumnTransformer is the right tool for mixed-type datasets.'
• Fit and validate the full preprocessing pipeline to avoid data leakage.