Measuring a Model

A model that does nothing, and scores 99.7%

Suppose you are building a fraud detector. In your data, 3 transactions in every 1,000 are fraudulent. You train a model, and it comes back with 99.7% accuracy. That sounds like a finished project.

Now here is a model that also scores 99.7%, which you can write in one line:

It is right 997 times out of 1,000, because it never has to do anything. It also catches exactly zero fraud, which was the entire point of building it.

Four ways a yes-or-no prediction can land

Before any formula, get the outcomes straight. Your model says yes or no. Reality is yes or no. That is four combinations, and each one costs something different.

Arranged in a grid, these four counts are called a confusion matrix. It is not a thing to memorise — it is just these four numbers in a box. Precision and recall are each built from two of them, and they share one: the true positives.

Precision: of everything I flagged, how much was real?

Precision looks only at the cases your model raised its hand for, and asks what fraction of them deserved it.

Its failure mode is crying wolf. Low precision means most of your alerts are noise, and the humans downstream will start ignoring all of them — which quietly destroys the value of the alerts that were correct. Precision is owned entirely by false positives.

Recall: of everything real, how much did I catch?

Recall ignores your alerts and looks at reality instead: of all the fraud that actually happened, how much did the model find?

Its failure mode is missing the thing. Low recall means the problem is still happening and your dashboard is calm about it. Recall is owned entirely by false negatives — and false negatives are invisible unless you go looking for them.

Notice that the one-line fraud model from earlier has a recall of 0. That is the number that would have caught the problem immediately.

The dial between them

You can max out either metric on its own, trivially, and the result is useless both times. Flag every single case and recall is a perfect 1.0. Flag only the one case you are most certain about and precision is a perfect 1.0. Neither model is worth shipping.

What connects them is the threshold. A classifier does not really output yes or no — it outputs a confidence score, and you choose the cutoff above which that score becomes a yes. Move the cutoff and you are trading one metric for the other.

Two things to notice

Drag the threshold slowly from left to right. Recall falls smoothly and predictably — every step right abandons a few more real positives, and they never come back.

Precision does not behave nearly as politely. It climbs, but it jumps around as it goes, especially at the high end. That is not a bug in the chart. Once you are flagging only a handful of cases, a single mistake swings the ratio hard. It is exactly why “just pick a high-precision threshold” is bad advice: up there, the number is measured on so few cases that it barely means anything.

Why F1 is a harmonic mean

F1 combines the two into one number so you can compare models at a glance. It deliberately is not a plain average. Consider the flag-everything model: precision 0.32, recall 1.0. Averaged normally, that is a respectable-looking 0.66 for a model with no judgement at all.

The harmonic mean is dragged toward the smaller of the two numbers, so it punishes lopsidedness. Take the extreme case — precision 1.0, recall 0.0. A normal average reports 0.5. F1 reports 0.

Now with a thousand made-up transactions and a model’s confidence score for each. Choose a threshold, count the four boxes, and build precision, recall and F1 from them by hand.

import numpy as npfrom sklearn.metrics import confusion_matrix, precision_score, recall_score rng = np.random.default_rng(3)fraud = rng.random(1000) < 0.1      # about 100 real frauds in 1,000# The model's confidence: higher for fraud on average, but the two overlap.score = np.where(fraud, rng.normal(0.65, 0.15, 1000), rng.normal(0.35, 0.15, 1000)) threshold = 0.5   # try 0.3, then 0.7flagged = score >= threshold tn, fp, fn, tp = confusion_matrix(fraud, flagged).ravel()print(f"TP {tp}   FP {fp}   FN {fn}   TN {tn}") precision = tp / (tp + fp)recall = tp / (tp + fn)f1 = 2 * precision * recall / (precision + recall)print(f"precision {precision:.2f}   recall {recall:.2f}   F1 {f1:.2f}")print(f"sklearn agrees: {precision_score(fraud, flagged):.2f}, {recall_score(fraud, flagged):.2f}")

At 0.5 it finds 87 of the 102 frauds (recall 0.85) while 142 legitimate transactions get flagged too (precision 0.38). Set the threshold to 0.3 and recall reaches 0.99 as precision drops to 0.15; at 0.7 precision rises to 0.89 and recall falls to 0.48.

So which one do you optimise?

There is no general answer, and anyone who gives you one is skipping the actual question: which mistake is more expensive for the people using this?

Same maths, three different answers. Choosing a metric is a product decision that happens to be expressed in numbers — it is not something the maths can decide for you.

Computing these yourself

You will rarely write these by hand. In Python:

The thing worth building a habit around is not the function call. It is printing the confusion matrix before you trust any single score.