Evaluating Models on Unseen Data

When people first train a machine learning model, they often judge it by how well it does on the examples it was trained on. If the predictions match the training data closely, it feels as though the model has learned something useful. That feeling can be wrong. The real goal of a model is different from matching the data it has already seen.

A very common misconception is that a model which performs perfectly on its training data is a good model. Under this belief, the best model is whichever one makes the fewest mistakes on the examples it studied. But a model is not built to repeat the past. It is built to make useful predictions on data that arrives later, data it has never seen.

Two models can have identical scores on the training examples and still behave very differently on new inputs. Only the new inputs reveal which model has learned the underlying relationship and which has simply stored what it was shown. This is why generalization, meaning performance on new, previously unseen data, is the central target.

To make both failure modes visible, consider a tiny made-up dataset. Each training input is paired with a target value, and the targets follow a clear upward pattern, here $y = 2x + 1$. We compare two deliberately poor models. The first is too simple: it always predicts the same number, so it cannot follow the rising trend. The second is too rigid in the other direction: it simply stores the training pairs and has nothing to say about inputs it has never stored.

Read the output carefully. On the four training inputs, the memorizer is perfect, matching every stored target. The too-simple model is wrong on every one of those inputs: its answer of 6 misses the targets 3, 5, 7, and 9 by 3, 1, 1, and 3. A constant cannot follow a rising pattern, so this model fails even on the data it was shown.

The memorizer in the previous example illustrates the gap. It is perfect on every training input, yet it has no answer for input 5. Its training score tells you it stored the examples correctly; it says nothing about whether it learned the pattern that produced them. The too-simple model shows the opposite gap: its training score is poor, so the failure is visible before any new data is involved.

Underfitting describes a model that is too simple to capture the variations present in the training data. Its key feature is that the failure shows up before any new data is involved. If the training examples clearly rise and fall in a way the model ignores, its predictions will be wrong on those training examples too. The model has not learned enough to describe what it was shown.

Overfitting describes a model that focuses too much on the training data and cannot generalize to new data, even when it looks strong on training examples. Overfitting is the reverse of underfitting in one important way: an overfitted model often looks excellent when you check it against its training examples, because it has adapted to those examples closely.

The trouble appears when the model meets inputs it did not study. The memorizer is the clearest case: it reproduces every training target exactly, but on input 5 it has no answer at all. An overfitted model's answers on unfamiliar inputs can be far from useful, even though its training record looks flawless.

The two failures sit at opposite ends of a range of model complexity, and they are told apart by where they show their weakness. A model that is too simple for the data tends toward underfitting. A model that is too complex for the data and fixed to the training examples tends toward overfitting. The goal is a model whose complexity matches the problem well enough to capture the real pattern without memorizing noise.

Many algorithms have settings that control complexity, and choosing the right parameter values matters for good performance. Model selection is therefore not a matter of picking a famous algorithm and trusting it. Blindly applying an algorithm without understanding its assumptions and the meaning of its parameter settings will rarely produce an accurate model.

Because generalization is measured on new data, an evaluation has to include inputs that the model did not study during training. The idea is to split the available examples so that some are used to fit the model and others are kept aside. The model is then scored on the set-aside examples, which it never saw while learning.

The held-out examples play the role that input 5 played in the tracing example. Only a score on examples the model never studied can reveal whether it generalizes, and only that score can show whether a model failed by missing the pattern or by memorizing it.

Return to the two models and ask what each one does when the input is new. Before reading on, predict the answers for input 5.

The reverse case is diagnosed the same way. A model that is poor on its training examples has shown underfitting before any new data arrives, and adding new inputs to the evaluation will not change that conclusion.