Linear Regression

Mean Squared Error

Compute MSE = (1/n)Σ(y_trueᵢ−y_predᵢ)² over paired actual and predicted lists. A single loop accumulates squared differences; divide by n. Library: sklearn.metrics.mean_squared_error(y_true, y_pred). RESULT: MSE (rounded).

By hand

y_true=[2,4,4,4,6], y_pred=[2.4,3.2,4.0,4.8,6.4] (from normal-equation-1d, this chapter). Squared errors: 0.16, 0.64, 0.0, 0.64, 0.16. SSE=1.6. MSE=1.6/5=0.32.

naive.py
Replay: real traced execution (multi-file project)
y_true = [2, 4, 4, 4, 6]
y_pred = [2.4, 3.2, 4.0, 4.8, 6.4]
n = len(y_true)
sq_err = 0.0
for i in range(n):
    diff = y_true[i] - y_pred[i]
    sq_err = sq_err + diff * diff
mse = sq_err / n
print('RESULT:', round(mse, 4))

  1. y_true ← [2, 4, 4, 4, 6]

    1y_true = [2, 4, 4, 4, 6]2y_pred = [2.4, 3.2, 4.0, 4.8, 6.4]
    values this step[2, 4, 4, 4, 6]y_true

  2. y_pred ← [2.4, 3.2, 4.0, 4.8, 6.4]

    1y_true = [2, 4, 4, 4, 6]2y_pred = [2.4, 3.2, 4.0, 4.8, 6.4]3n = len(y_true)
    values this step[2.4, 3.2, 4.0, 4.8, 6.4]y_pred

  3. n ← 5

    2y_pred = [2.4, 3.2, 4.0, 4.8, 6.4]3n = len(y_true)4sq_err = 0.0
    values this step5n

  4. sq_err ← 0.0

    3n = len(y_true)4sq_err = 0.05for i in range(n):
    values this step0.0sq_err

  5. i ← 0

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]
    values this step0i

  6. diff ← -0.3999999999999999

    5for i in range(n):6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff
    values this step-0.3999999999999999diff

  7. sq_err ← 0.15999999999999992

    6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff8mse = sq_err / n
    values this step0.0 → 0.15999999999999992sq_err

  8. i ← 1

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]
    values this step0 → 1i

  9. diff ← 0.7999999999999998

    5for i in range(n):6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff
    values this step-0.3999999999999999 → 0.7999999999999998diff

  10. sq_err ← 0.7999999999999996

    6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff8mse = sq_err / n
    values this step0.15999999999999992 → 0.7999999999999996sq_err

  11. i ← 2

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]
    values this step1 → 2i

  12. diff ← 0.0

    5for i in range(n):6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff
    values this step0.7999999999999998 → 0.0diff

  13. sq_err = sq_err + diff * diff

    6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff8mse = sq_err / n

  14. i ← 3

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]
    values this step2 → 3i

  15. diff ← -0.7999999999999998

    5for i in range(n):6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff
    values this step0.0 → -0.7999999999999998diff

  16. sq_err ← 1.4399999999999993

    6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff8mse = sq_err / n
    values this step0.7999999999999996 → 1.4399999999999993sq_err

  17. i ← 4

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]
    values this step3 → 4i

  18. diff ← -0.40000000000000036

    5for i in range(n):6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff
    values this step-0.7999999999999998 → -0.40000000000000036diff

  19. sq_err ← 1.5999999999999996

    6    diff = y_true[i] - y_pred[i]7    sq_err = sq_err + diff * diff8mse = sq_err / n
    values this step1.4399999999999993 → 1.5999999999999996sq_err

  20. for i in range(n):

    4sq_err = 0.05for i in range(n):6    diff = y_true[i] - y_pred[i]

  21. mse ← 0.31999999999999995

    7    sq_err = sq_err + diff * diff8mse = sq_err / n9print('RESULT:', round(mse, 4))
    values this step0.31999999999999995mse

  22. stdout ← RESULT: 0.32

    8mse = sq_err / n9print('RESULT:', round(mse, 4))
    values this stepRESULT: 0.32stdout

With scikit-learn

mean_squared_error(y_true, y_pred) computes MSE directly. No model object needed — pass any paired lists of actuals and predictions.

library.py 
from sklearn.metrics import mean_squared_error
from dalib.display import set_display
set_display()

y_true = [2, 4, 4, 4, 6]
y_pred = [2.4, 3.2, 4.0, 4.8, 6.4]
mse = float(mean_squared_error(y_true, y_pred))
print('y_true:', y_true)
print('y_pred:', y_pred)
print('RESULT:', round(mse, 4))

y_true: [2, 4, 4, 4, 6]
y_pred: [2.4, 3.2, 4.0, 4.8, 6.4]
RESULT: 0.32

Honesty

This lesson shows the computation of MSE exactly, on a tiny pinned sample. The value is correct and reproducible, but on so few points it measures error on these specific in-sample points and overstates how the model would perform out of sample. Read it as the mechanism of how squared error is averaged, not as evidence the model generalizes; a real estimate of error needs held-out data and an adequate sample size.

Implementation notes

  • MSE = SSE/n: divides the total squared error by sample count. Cross-reference: residuals-and-sse (python-stats ch08) computes SSE=1.6 for this same data; MSE = SSE/5 = 0.32.
  • Squaring gives large errors disproportionate weight (a 2× error contributes 4× the penalty of a 1× error).
  • MSE units are squared (e.g. if y is in kg, MSE is in kg²). RMSE = √MSE restores original units at the cost of being less differentiable at 0.
  • y_pred here are the fitted values from normal-equation-1d (this chapter), making the connection between fitting and evaluation explicit.