Classification, Cross-Entropy, and How Not to Fool Yourself

Same factory as Chapter 1, harder question. Instead of accept or reject, the question is is this part defective — and defects are rare, which makes the measuring half of this chapter hard and the modelling half deceptively easy.

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

Three splits, not two. The reason is worth its own section and gets one below; for now, train on the first, tune on the second, and do not look at the third.

The features are standardised — mean subtracted, divided by the standard deviation — using the training statistics only, for the reason Chapter 1 demonstrated with the perceptron's convergence bound: uncentred data makes the geometry hostile. Which rows you are allowed to compute that mean from becomes a live question later in this chapter.

The perceptron returned a sign. A sign cannot distinguish reject from reject, but only just, and that difference is exactly what a factory needs to decide which parts a human should re-inspect first.

So follow Chapter 2's recipe literally. Write down what you claim about how a label is produced, take the likelihood, take the log, negate it, and you have a loss. For a yes/no outcome the claim is a Bernoulli distribution: there is a probability $p$ that the part is defective, and

which is just a compact way of writing "$p$ if $y = 1$, and $1-p$ if $y = 0$". Take the log of that and negate it, and the loss for one example is

This is binary cross-entropy. It was not chosen because it is convenient; it is the negative log-likelihood of the only distribution a coin flip can have. Nothing else was available.

What is still missing is where $p$ comes from. The model computes a weighted sum $s = \mathbf{w}\cdot\mathbf{x} + b$, which is a real number and ranges over the whole line, and a probability has to live in $(0,1)$. The function that moves between them is the logistic sigmoid:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

Read the right-hand column as a price list. Being right with 90 % confidence costs 0.105. Refusing to commit costs 0.693 — which is $\log 2$, the price of a shrug. Being confidently wrong costs 4.6, forty-four times more, and the price rises without limit as the model grows more certain about a mistake. Cross-entropy does not merely count errors: it charges for arrogance.

Chapter 3 said: to train anything, get the derivative of the loss with respect to each parameter. Do it for one example. With $s = \mathbf{w}\cdot\mathbf{x} + b$ and $p = \sigma(s)$:

So the update is prediction minus truth, times the input. Nothing else. Here is the entire trainer, which is Chapter 3's descent with one line changed:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

The np.where in sigmoid is not cosmetic. Computing $1/(1+e^{-s})$ directly overflows for large negative $s$; the branch picks whichever algebraically identical form keeps the exponent negative. This is Chapter 2's floating-point box collecting its first debt, and it will collect a bigger one two sections from now.

The standard explanation for preferring cross-entropy over squared error is the likelihood argument above: squared error is what you get from assuming Gaussian noise, labels are not Gaussian, therefore do not. It is correct and it convinces nobody, because you can write $L = (p - y)^2$ over a sigmoid and it will train.

The argument that lands is about the gradient. Put squared error on top of a sigmoid and the chain rule gives

That extra $p(1-p)$ is the one that cancelled before. Now it does not, and it goes to zero whenever the model is confident — including when the model is confidently wrong. Evaluate both at a few scores, for an example whose true label is 1:

At $s = -8$ the model is as wrong as it is possible to be, and squared error responds with a gradient 1,491 times smaller than cross-entropy's. The worse the mistake, the less the model learns from it. Cross-entropy's gradient, meanwhile, saturates at $-1$: maximally wrong produces a maximally large signal, and no larger.

Run the race. Two thousand balanced points, identical starting weights chosen to be confidently wrong ($\mathbf{w} = [-6, -6]$), identical learning rate, only the loss differs. Both runs are scored with cross-entropy so the columns are comparable.

Cross-entropy is finished by epoch 50. Squared error is still at 24 % accuracy at epoch 100 — and had not moved from 23 % at epoch 10 — — worse than guessing, because it started confidently wrong and the gradient that would rescue it has been multiplied by 0.0007. It escapes at around epoch 500 and lands in the same place. So the honest summary is that squared error over a sigmoid is not incorrect; it is slow exactly where speed matters most. On a two-parameter model you lose 450 epochs. On a network with a hundred layers, where some unit somewhere is always confidently wrong, you lose the training run.

Three quantities, needed properly in Chapter 8 for perplexity and in Chapter 11 for the penalty that keeps a fine-tuned policy near its reference. They are easier than their reputation.²

Entropy is the average number of bits you must spend to communicate a draw from a distribution, if you use the best possible code for it:

Cross-entropy is what you spend when you use a code built for $q$ on data that actually comes from $p$:

KL divergence is the excess — the waste, in bits, caused by believing $q$ when the truth is $p$:

Check all three on the belt:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Two things are visible there. First, a model that simply reports the training base rate, 1.69 %, achieves a cross-entropy of 0.1330 bits, almost exactly the entropy of the test labels — as it must, since it has the right distribution and no other information. Entropy is the floor that ignorance-of-the-individual buys you. Second, a model that shrugs and says 0.5 pays exactly 1 bit, and the gap between the two, 0.8671 bits, is precisely the KL divergence. $H + D_{\mathrm{KL}} = H(p,q)$ is not an identity to memorise; it is a bill you can watch being added up.

And the connection back to training: when the label is a single known class, the "true" distribution is one-hot, its entropy is zero, and cross-entropy equals the KL divergence. Minimising cross-entropy and pulling the model's distribution toward the truth are the same act.

Defective is not one thing. In moulding, a part can come out as a short shot (not enough material), flash (too much, squeezed out of the mould), or burn. Four outcomes, so four logits, and they must become four probabilities that sum to one. That is softmax:

It has a property that looks like an accident and is in fact the whole implementation:

for any constant $c$, because $e^{z_i + c} = e^{c} e^{z_i}$ and the $e^c$ cancels top and bottom. Only differences between logits mean anything. The absolute level is not information.

Fortunately so, because the absolute level is what breaks the computer:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

$e^{800}$ overflows a 64-bit float, the sum becomes infinity, and infinity divided by infinity is nan — not an error, not a crash, just a silent hole where three probabilities used to be. Subtracting the maximum logit changes nothing mathematically and everything numerically, because the largest exponent becomes exactly $e^0 = 1$. This is Chapter 2's logsumexp trick wearing its work clothes, and every serious implementation does it:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

The gradient is again prediction minus truth, now with $Y$ one-hot. The binary case was a special case all along.

Trained on 3,000 parts and tested on 1,000, with three measurements each (width, weight, melt temperature), it reaches 94.00 % accuracy. Here is what that number is hiding:

The model finds fewer than half the short shots. Accuracy cannot see this, because 86 % of the parts are fine and getting those right is enough to carry the average. Macro F1 — the mean of the per-class F1 scores, which weights a rare class the same as a common one — is 0.7983, against a micro F1 of 0.9400 that is by definition identical to accuracy. Whenever someone reports one F1 number, ask which.

That is the last of the modelling. The rest of the chapter is about the numbers.

Take the trained binary model and make two variants by multiplying every logit by a constant: 0.35 for a hesitant version, 4 for an overconfident one. Multiplying by a positive number cannot change any sign, so all three models predict exactly the same label for all 4,000 test parts. Accuracy cannot tell them apart. Cross-entropy has no trouble at all:

The hesitant model pays a small tax on every part, including the thousands it gets right. The overconfident one is nearly free when right and catastrophic when wrong — one part in that test set costs it 27.63 nats on its own. The two land at almost the same total by opposite routes, and the trained model, whose probabilities are calibrated to the data, sits three times below both.

This is the sharpest way to state the difference between a loss and a metric. The loss is what you optimise: it must be differentiable, and it sees everything the model said, including how sure it was. The metric is what you are judged on: it can be a step function, a business rule, a count of missed defects. They are not the same object and they do not always agree — which is why you define both before you start, and never let the loss stand in for the metric because it happens to be on the screen.

Before any model, the requirement: what does the laziest possible answer score? On this belt, always say fine:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98.15 %. Now the trained logistic model, at the default threshold of 0.5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98.30 %. It beat the baseline by 0.15 of a percentage point, and any report that stops at accuracy will call that a win. The confusion matrix says what actually happened:

It found 8 defective parts out of 74 and let 66 through. Three numbers name the three ways of reading that table:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Of the parts it flagged, how many were really defective. This is the cost of wasted inspections.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Of the defective parts, how many it caught. This is the cost of shipping a bad part to a customer.
• F1 $= 2PR/(P+R) = 0.190$, their harmonic mean, which stays near the smaller of the two and therefore refuses to be flattered by one of them alone.

Which matters depends on the factory, not on the mathematics: an inspection costs a few seconds and a shipped defect costs a recall notice, so here recall dominates and 0.108 is a failure.

But the model is not the problem. The threshold is, and the threshold is not part of the model — it is a business decision applied afterwards to a probability. Sweep it:

Read the accuracy column downward. It falls the whole way — from 98.30 % to 65.93 % — while the model goes from catching 8 defects to catching 71 of 74. Every useful thing this model can do makes its accuracy worse. A team optimising the headline number would ship the version that finds nothing.

Why three splits and not two? Because the moment you use a set of examples to choose anything — a threshold, a learning rate, which of six models to ship — that set has been used for fitting, and its score stops being unbiased.³ Measured on this belt: sweeping the threshold on the validation set picks 0.196, and the model then scores F1 = 0.4122 on the untouched test set. Had the sweep been run on the test set directly, the best achievable there was 0.4186 — a number nobody is entitled to report.

The gap is small here, 0.006, because that is one hyperparameter swept once against 4,000 validation examples. It grows with every extra decision and every shrink of the validation set. Note also that the direction is not guaranteed on a single run: the chosen threshold scored 0.3902 on validation and 0.4122 on test, so validation understated it this time. The bias is systematic across many decisions, not visible in one.⁴

Now the exercise. The belt log arrives with a third column, station_seconds: how long each part spent at the inspection station. Adding it is a one-line change to the preprocessing. Here is what it does:

Recall goes from 10.8 % to 77.0 %. F1 more than quadruples. And notice what accuracy did: 98.30 % → 99.20 %, a gain of nine tenths of a point, which is the kind of number that gets rounded to "about 99 % either way" in a summary slide. Accuracy failed to see the failure earlier and now fails to see the fraud.

Before reading on: the model is cheating. Find out how.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

The highlighted line is the leak: a defective part's dwell time is drawn from a different distribution, because a human took it off the belt. This is the most common serious bug in applied machine learning, and it has a name: target leakage — information in the training features that would not be available at the moment the prediction has to be made.⁵ It throws no exception. It produces a better number. Every incentive in a project points toward keeping it.

The defence is one question, asked of every column: at the instant I need this prediction, does this value exist yet? On a live belt, station_seconds is unknown until after the part has been inspected — which is the thing the model was supposed to replace.

Suppose you score a model on 20 examples and it gets 17 right. You report 85 %.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

The honest reading of 17/20 is somewhere between 64 % and 95 %. A genuinely 65 % model produces this result 4.4 % of the time — one run in twenty-three — and if you tried a handful of prompts and reported the best, you manufactured that run yourself. Seventeen out of twenty cannot distinguish an 85 % model from a 65 % one.

Two ways to put an interval on a rate, and both belong in your toolkit:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Use Wilson⁶ for a plain success rate; it stays well behaved at any $n$ and needs no randomness. Note above that at $n = 20$ the bootstrap's upper end is 1.0000 — resampling 20 points can easily draw 20 correct ones, so it cannot represent an interval narrower than its own granularity. Use the bootstrap⁷ where no formula exists, which is most of the interesting cases: F1, macro-averages, BLEU, pass@1, the score of a rubric-based judge. On this belt, the tuned model's F1 of 0.4122 carries a bootstrap interval of [0.3009, 0.5156] — which is the number that should appear in the report, because the point estimate alone invites a comparison it cannot support.

One more measurement, because it changes how you should compare two models. Two models scored on the same 500 examples:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Their intervals overlap, and the folk rule — overlapping error bars means no significant difference — would call the comparison inconclusive. It is not. The two models ran on the same examples, so the right quantity is the per-example difference, whose interval is [0.0260, 0.0680], comfortably above zero. They disagree on only 31 of 500 items, and A wins 27 of those disagreements; the shared examples, easy and hard alike, cancel out instead of adding noise. Compare models paired, and you reach the same conclusion from a fraction of the data.

You now have a model that outputs calibrated probabilities, a loss derived from a claim about the data rather than chosen for convenience, a gradient that is literally prediction minus truth, and — more importantly — the machinery to find out whether any of it works. The ten-line Wilson interval above is reused verbatim: it carries the prompt variants in Chapter 15, the retrieval tables in Chapter 19, and the golden set in Chapter 29. The bootstrap is what you reach for when no formula exists.

But the model is still one layer. It draws a line, and Chapter 1 proved with four rows of XOR that a line is not enough. The fix is to stack: a first layer that bends the space, a second that draws the line in the bent space.

That is where the tidy gradient of this chapter runs out. Everything above worked because $\partial L/\partial s = p - y$ could be written down by hand, once, for a model with one layer between the input and the loss. Put a second layer in the middle and the question changes shape: what is the derivative of the loss with respect to a weight that does not touch the output at all — one whose influence arrives only through another layer, possibly along several paths at once?

That derivative exists. Computing it by hand is hopeless for anything larger than a toy, and computing it one parameter at a time is hopeless at a different scale. What is needed is a procedure that gets every derivative in the network from a single backward pass over the same graph the forward pass just walked.

That is Chapter 5, and it is the engine the rest of this course runs on.

Also worth reading alongside this chapter: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 and §4.3, which covers probability, decision theory, information theory and linear classification in the order this chapter follows; Murphy, Probabilistic Machine Learning: An Introduction, chapters 6 and 10; Prince, Understanding Deep Learning §5.4–5.7; and Saito and Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — why the AUC quoted above should not be the only threshold-free number you look at when 1.7 % of the parts are defective.