Hours studied vs quiz score
The two knobs
The exact best line is score = 5.22 × hours + 39.82. It still misses, because real scores are noisy.
Loss if you only turned one knob
Each curve is a valley, and the dashed line is where you are. Training means walking to the bottom of the valley. The next lesson does that automatically.
Why squared error?
Every miss counts as positive. Missing by +10 and −10 shouldn't cancel out to "perfect".
Big misses count much more. One miss of 20 costs 400, but four misses of 5 cost only 100. Turn on "Draw the squares" and the big red squares show you which students the line is failing hardest.
It's a smooth valley. Look at the MSE curve: a smooth bowl with one bottom. That smoothness is what lets gradient descent slide down it. MAE's valley has a sharp point at the bottom, which is harder to slide into.
LLMs use a different loss (cross-entropy, lesson 5 onward) because they predict a word, not a number. But the idea is identical: one number for "how wrong", and every knob gets turned to make it smaller.
Every residual, one by one
| Hours | Real score | Line says | Miss | Miss² |
|---|---|---|---|---|
| 1.0 | 45.1 | 61.0 | −15.9 | 253 |
| 3.3 | 62.8 | 63.3 | −0.5 | 0 |
| 7.1 | 82.4 | 67.1 | 15.3 | 234 |
| 3.2 | 54.1 | 63.2 | −9.1 | 83 |
| 5.0 | 75.9 | 65.0 | 10.9 | 119 |
| 4.2 | 69.5 | 64.2 | 5.3 | 28 |
| 5.0 | 61.1 | 65.0 | −3.9 | 15 |
| 8.5 | 80.3 | 68.5 | 11.8 | 139 |
| 3.9 | 65.8 | 63.9 | 1.9 | 4 |
| 6.6 | 67.9 | 66.6 | 1.3 | 2 |
| 8.9 | 85.4 | 68.9 | 16.5 | 272 |
| 3.6 | 63.6 | 63.6 | 0.0 | 0 |
| 9.1 | 95.0 | 69.1 | 25.9 | 671 |
| 7.4 | 76.3 | 67.4 | 8.9 | 79 |
| 9.2 | 86.3 | 69.2 | 17.1 | 292 |
| 1.9 | 49.5 | 61.9 | −12.4 | 154 |
| 8.8 | 85.2 | 68.8 | 16.4 | 269 |
| 4.5 | 56.3 | 64.5 | −8.2 | 67 |
| 7.4 | 72.3 | 67.4 | 4.9 | 24 |
| 2.1 | 54.9 | 62.1 | −7.2 | 52 |
| 2.2 | 42.2 | 62.2 | −20.0 | 400 |
| 6.1 | 77.8 | 66.1 | 11.7 | 137 |
| 4.8 | 57.2 | 64.8 | −7.6 | 58 |
| 2.9 | 49.7 | 62.9 | −13.2 | 174 |
| Average of the last column = MSE | 146.9 | |||
The code that just ran
Everything on this page came from calling this code, which lives at the top of this same file.
Show or hide the source
final class Line
{
public function __construct(public float $m, public float $b) {}
// The model itself. That's it: one multiplication and one addition.
public function predict(float $x): float
{
return $this->m * $x + $this->b;
}
// Residual = how far each real point is from the line (real − predicted).
public function residuals(array $points): array
{
return array_map(fn($p) => $p['y'] - $this->predict($p['x']), $points);
}
// MEAN SQUARED ERROR: square every miss, then average.
// Squaring makes every miss positive and punishes big misses much more.
public function mse(array $points): float
{
$sum = 0.0;
foreach ($this->residuals($points) as $r) $sum += $r * $r;
return $sum / count($points);
}
// MEAN ABSOLUTE ERROR: the plain average size of a miss.
public function mae(array $points): float
{
$sum = 0.0;
foreach ($this->residuals($points) as $r) $sum += abs($r);
return $sum / count($points);
}
// For a straight line there is an exact formula for the lowest-MSE line
// ("least squares"). Most models have no such formula, which is why the
// next lesson, gradient descent, exists.
public static function bestFit(array $points): self
{
$n = count($points);
$mx = array_sum(array_column($points, 'x')) / $n;
$my = array_sum(array_column($points, 'y')) / $n;
$num = 0.0; $den = 0.0;
foreach ($points as $p) {
$num += ($p['x'] - $mx) * ($p['y'] - $my);
$den += ($p['x'] - $mx) ** 2;
}
$m = $den ? $num / $den : 0.0;
return new self($m, $my - $m * $mx);
}
}