Evaluating and Diagnosing a Regression Model

1 Learning objectives

2 Motivating example

Here are two regression models, both fitted to real data, both reported with the same headline number.

Identical R². Completely different models. Model A has captured a relationship that is not linear and is reporting a good score while being wrong in a structured, predictable way. Model B may be genuinely capturing the relationship, or it may have a different problem — overfitting, leakage, or simply a lucky split. You cannot tell from the number.

This is the central lesson of the tutorial, and it is worth stating plainly: a single summary statistic is never sufficient evidence that a model is good. Evaluation is not the act of Computing a number. It is the discipline of gathering several kinds of evidence, on data the model has not seen, and looking at the evidence rather than just the score.

Four questions have to be answered before you can trust a regression model, and each one requires a different piece of evidence:

1. How wrong is it, typically? RMSE and MAE. Both measured on held-out data, never on the training set.
2. Is it wrong in a structured way? The residual plot. This is where non-linearity, heteroscedasticity and outliers reveal themselves.
3. Will it keep working on new data? A train/validation gap, and a learning curve. This distinguishes a model that has learned from one that has memorised.
4. Where is it valid? The range of the training features. Outside that range, no regression model has any evidence to offer.

Everything in this tutorial is machinery for answering one of those four.

3 Concept explanation

3.1 RMSE and MAE

Two metrics answer the question "how wrong is this model, typically?" They differ only in how they combine the residuals.

Both metrics measure the typical size of the error. The difference is how they weight large errors relative to small ones.

The ratio RMSE/MAE is itself informative. If all residuals were identical in magnitude, RMSE would equal MAE and the ratio would be 1. If a small number of residuals are much larger than the rest, RMSE is pulled upward while MAE barely moves, and the ratio rises.

This ratio is a one-line diagnostic that costs nothing and catches a whole class of problems. Compute it every time.

3.2 R² and adjusted R²

R², the coefficient of determination, measures the proportion of the target's variance that the model explains. It is defined as one minus the ratio of the residual sum of squares to the total sum of squares:

This makes R² easy to interpret:

• R² = 1 — perfect prediction. The model makes zero error.
• R² = 0 — the model is exactly as good as predicting the mean. It has learned nothing.
• R² < 0 — the model is worse than the mean baseline. This happens on validation data surprisingly often, and it is always a warning sign.
• R² = 0.7 — the model explains 70% of the variance in the target. The remaining 30% is either noise or structure the model has not captured.

There is a fourth problem, and it is mechanical. R² can never decrease when you add a feature. Even a feature of pure random noise will increase R² slightly, because the model can use it to fit a little of the training set's idiosyncratic variation. The mean baseline is a special case of the model with all weights set to zero, so the model's optimum can only be at least as good.

Adjusted R² corrects for this by penalising the number of parameters:

Adjusted R² can decrease when a feature is added, if the feature does not earn its parameter. That makes it a more honest basis for comparing models of different sizes. It does not, however, replace held-out validation — a model can still overfit while its adjusted R² looks reasonable on the training data.

3.3 Training, validation and test sets

Every metric discussed so far is optimistic if computed on the data the model was fitted to. The model has been chosen specifically to minimise error on those examples, and a sufficiently flexible model can achieve arbitrarily low training error by memorising.

The standard solution is to split the data into three parts:

The distinction between validation and test is the one that people get wrong. The validation set is used — you look at it repeatedly, and each time you make a decision based on it, you leak a little information from it into the model. After enough decisions, the validation set is no longer a fair estimate of performance on genuinely new data. The test set is the one you touch once.

When data are limited, a single validation split wastes examples and produces a noisy estimate. k-fold cross-validation addresses both problems: the data are partitioned into k folds, the model is trained k times, each time holding out a different fold, and the k validation scores are averaged. This uses every example for validation exactly once, and the spread across folds gives an estimate of how much the score varies.

The mechanics of cross-validation — stratified folds, nested selection, why preprocessing must live inside each fold — are covered in Module 2's Unit 6. For this tutorial, the important point is that any honest estimate of a regression model's performance must come from data the model did not train on.

3.4 The residual plot

This is the single most useful diagnostic in regression, and it takes ten seconds to produce.

Plot the residuals e_i on the vertical axis against the fitted values ŷ_i on the horizontal axis. What you are looking for is nothing. If the model has captured all the systematic structure in the data, the residuals should look like unstructured noise — a random cloud centred on zero, with no pattern, no trend and no change in spread.

Any visible structure in a residual plot is the model telling you what it missed.

A fifth pattern worth knowing is a long tail of large residuals with no obvious shape. That usually indicates that the target has a skewed distribution and a small number of very large values are being badly mispredicted. Log-transforming the target often helps.

3.5 Learning curves

The residual plot tells you whether the model's functional form is appropriate. The learning curve tells you whether the model has seen enough data, and whether it is too simple or too complex.

A learning curve plots the training error and the validation error against the size of the training set. The model is trained on progressively larger subsets and evaluated each time. Two curves result, and their relationship diagnoses the problem.

The crucial insight is the asymmetry. If the model has high bias, the training and validation errors converge to the same high value, and collecting more data will not move either curve — you are already at the model's ceiling. If the model has high variance, the two curves are far apart and the validation curve is still descending as the training set grows, which means more data will help.

This is why the learning curve is worth producing before you spend money collecting data. It answers the question "would more data help?" directly, and it frequently says no.

3.6 Validation curves

A validation curve plots the training and validation error against a measure of model complexity rather than against the training set size. Complexity might be the degree of a polynomial, the number of features, or the strength of a regularisation penalty.

The typical shape is a U:

• At low complexity, both curves are high — the model is too simple to capture the signal. This is underfitting.
• At the minimum of the validation curve, the model is capturing the signal without fitting the noise. This is the sweet spot.
• At high complexity, the training curve continues to fall while the validation curve rises — the model is fitting noise. This is overfitting.

The gap between the two curves widens monotonically as complexity increases, because a more flexible model can always fit the training data better while generalising worse. The validation curve's minimum is the point at which the benefit of additional flexibility is exactly offset by the cost of additional variance.

3.7 Data leakage in regression

Tutorial 1 introduced leakage as a framing error: including a feature that will not be available at prediction time. Here is the evaluation-side version, which is subtler and much more common.

Leakage in evaluation means that information from outside the training set has influenced the model or its evaluation, producing scores that will not generalise. Three ways it happens:

3.8 Reporting a regression model

A number in isolation is not a report. A defensible report of a regression model contains, at minimum:

1. The headline metrics, computed on held-out data: RMSE, MAE and R².
2. The target's scale: its mean and standard deviation, so the metrics can be interpreted. "RMSE = 107 rentals against a mean of 325" is far more informative than "RMSE = 107".
3. The residual plot. A picture of what the model gets wrong is worth more than a paragraph of caveats.
4. A comparison against the baseline. The mean baseline's RMSE, so the reader can see how much the model actually bought you.
5. The range of validity. The observed range of each feature, with a statement that predictions outside it are not supported.
6. The known failure modes. Where the model is worst, and which kinds of examples it should not be used on.

That last item is the one most often omitted and most often consequential. A model that is excellent on average and catastrophic for a subgroup is not a good model, and reporting only the average conceals the harm. Tutorial 8 takes this up directly in the context of fairness.

4 Visual illustration

5 Worked example

We will do two things. First, compute the full set of metrics for the bike-share model from Tutorials 3 and 5 and inspect its residuals. Then we will fit a line to a dataset that is genuinely curved and watch the residual plot expose the problem.

n    = 8
ȳ    = 337.5
RMSE = √(831.19 / 8)     = √103.90  = 10.19 rentals
MAE  = 71.07 / 8                     =  8.88 rentals
R²   = 1 − 831.19 / 171,350          =  0.9951

Adjusted R² (p = 1 feature):
  = 1 − (1 − 0.9951) × (8 − 1) / (8 − 1 − 1)
  = 1 − 0.004851 × 7 / 6
  = 1 − 0.005660                     =  0.9943

RMSE / MAE  =  10.19 / 8.88          =  1.15

n    = 11
ȳ    = 325.45
RSS  = 126,044
TSS  = 188,923

RMSE = √(126,044 / 11)      = √11,458.5  = 107.05 rentals
MAE  = 1,041.10 / 11                      =  94.65 rentals
R²   = 1 − 126,044 / 188,923              =  0.333

RMSE / MAE  =  107.05 / 94.65             =  1.13

 x:   5     8     11    14    17    20    23    26    29    32    35
 e: −136   −85   −24   +42   +98  +130  +131   +97   +23   −81  −195

ŷ = −25.9 + 28.6x − 0.597x²

RMSE = 19.6 rentals      (down from 107.05)
MAE  = 16.1 rentals      (down from  94.65)
R²   = 0.978             (up   from  0.333)

Residuals now: −14, +8, +19, +20, +14, −4, −18, −14, +9, +11, −18
  → no visible pattern

The same computation in code

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# ------------------------------------------------------------------
# Part 1: metrics for the bike-share model
# ------------------------------------------------------------------
df = pd.DataFrame({
    "temp_c":  [ 8, 12, 15, 18, 21, 24, 27, 30],
    "rentals": [120, 180, 240, 300, 360, 430, 510, 560],
})
x = df["temp_c"].to_numpy()
y = df["rentals"].to_numpy()
n = len(y)

model = LinearRegression().fit(x.reshape(-1, 1), y)
y_hat = model.predict(x.reshape(-1, 1))
e = y - y_hat

rss  = (e ** 2).sum()
tss  = ((y - y.mean()) ** 2).sum()
rmse = np.sqrt(rss / n)
mae  = np.abs(e).mean()
r2   = 1 - rss / tss

p         = 1                                    # number of features
r2_adj    = 1 - (1 - r2) * (n - 1) / (n - p - 1)

print("=== bike-share model ===")
print(f"RMSE        : {rmse:8.2f} rentals")
print(f"MAE         : {mae:8.2f} rentals")
print(f"R²          : {r2:8.4f}")
print(f"Adjusted R² : {r2_adj:8.4f}")
print(f"RMSE / MAE  : {rmse / mae:8.4f}")
print(f"target mean : {y.mean():8.2f}   (RMSE = {100*rmse/y.mean():.1f}% of mean)")

# ------------------------------------------------------------------
# Part 2: a curved dataset — the linear model fails
# ------------------------------------------------------------------
df2 = pd.DataFrame({
    "temp_c":  [ 5,  8, 11, 14, 17, 20, 23, 26, 29, 32, 35],
    "rentals": [70, 145, 230, 320, 400, 455, 480, 470, 420, 340, 250],
})
x2 = df2["temp_c"].to_numpy()
y2 = df2["rentals"].to_numpy()
n2 = len(y2)

lin = LinearRegression().fit(x2.reshape(-1, 1), y2)
e2  = y2 - lin.predict(x2.reshape(-1, 1))

print("\n=== linear fit to curved data ===")
print(f"slope, intercept : {lin.coef_[0]:.3f}, {lin.intercept_:.3f}")
print(f"RMSE             : {np.sqrt((e2 ** 2).mean()):.2f}")
print(f"MAE              : {np.abs(e2).mean():.2f}")
print(f"R²               : {1 - (e2 ** 2).sum() / ((y2 - y2.mean()) ** 2).sum():.4f}")
print("residuals        :", np.round(e2, 1))

# ------------------------------------------------------------------
# Part 3: add x² and refit
# ------------------------------------------------------------------
X2 = np.column_stack([x2, x2 ** 2])
quad = LinearRegression().fit(X2, y2)
e3 = y2 - quad.predict(X2)

print("\n=== quadratic fit ===")
print(f"coefficients     : {quad.intercept_:.2f}, "
      f"{quad.coef_[0]:.2f}, {quad.coef_[1]:.4f}")
print(f"RMSE             : {np.sqrt((e3 ** 2).mean()):.2f}")
print(f"MAE              : {np.abs(e3).mean():.2f}")
print(f"R²               : {1 - (e3 ** 2).sum() / ((y2 - y2.mean()) ** 2).sum():.4f}")
print("residuals        :", np.round(e3, 1))

# ------------------------------------------------------------------
# Part 4: train / validation comparison
# ------------------------------------------------------------------
X_tr, X_va, y_tr, y_va = train_test_split(
    x2.reshape(-1, 1), y2, test_size=0.3, random_state=42
)

lin_cv = LinearRegression().fit(X_tr, y_tr)
print("\n=== held-out performance, 70/30 split ===")
print(f"linear  — train RMSE {np.sqrt(((y_tr - lin_cv.predict(X_tr)) ** 2).mean()):7.2f}"
      f"   validation RMSE {np.sqrt(((y_va - lin_cv.predict(X_va)) ** 2).mean()):7.2f}")

=== bike-share model ===
RMSE        :    10.19 rentals
MAE         :     8.88 rentals
R²          :   0.9951
Adjusted R² :   0.9943
RMSE / MAE  :   1.1475
target mean :   337.50   (RMSE = 3.0% of mean)

=== linear fit to curved data ===
slope, intercept : 7.970, 166.061
RMSE             : 107.05
MAE              : 94.65
R²               : 0.3329
residuals        : [-135.9  -84.8  -23.7   42.4   98.5  129.5  130.6   96.7   22.8  -81.1 -195.0]

=== quadratic fit ===
coefficients     : -25.90, 28.60, -0.5970
RMSE             : 19.60
MAE              : 16.10
R²               : 0.9780
residuals        : [-14.0   8.0  19.0  20.0  14.0  -4.0 -18.0 -14.0   9.0  11.0 -18.0]

=== held-out performance, 70/30 split ===
linear  — train RMSE   86.30   validation RMSE  146.20

The last two lines are the most instructive. The linear model's validation RMSE (146.20) is worse than its training RMSE (86.30) — a gap of 70%. On a dataset this small the split is noisy, but the direction of the gap is the same signal a learning curve would show: the model does not generalise, because it is systematically wrong.

6 Interactive activity

7 Self-check questions

Answer each question in your own words before revealing the answer.