Underfitting

Underfitting is what happens when a model is too simple, or hasn't trained long enough, to capture the real structure in its own training data — and the diagnostic is unambiguous: an underfit model performs badly even on the data it was trained on, not just on new data. That single fact separates it cleanly from overfitting, where a model aces its training set and only fails on new data; underfitting fails everywhere, because it genuinely never learned the pattern in the first place. At a high level, underfitting and its fix sit at one end of a single dial:

The single most common real-world cause of underfitting isn't a model that's too simple in the abstract — it's a team that over-applied overfitting remedies out of caution and accidentally starved a model that actually needed more room to learn. Heavy regularization, aggressive dropout, or stopping training too early are all legitimate defenses against overfitting, but applied by default without checking whether overfitting was ever actually the risk, they produce a model that can't even fit its own training set well. This is why the training-error check matters as a first diagnostic step, not an afterthought: it tells you immediately which direction to turn the capacity dial, and turning it the wrong way (adding more regularization to an already-underfit model) makes the real problem strictly worse.

Underfitting shows up in forms beyond "the model is too small," and recognizing the non-obvious versions is where real diagnostic skill matters. A model with plenty of raw capacity can still underfit if it hasn't trained for enough epochs to converge, if the learning rate is set too low for training to make meaningful progress in a practical amount of time, or if the input features themselves don't contain the signal needed to predict the target at all — in that last case, no amount of added model capacity will fix anything, because the problem isn't the model's expressiveness, it's that the features were never sufficient to begin with, which is a data problem wearing an underfitting-shaped symptom.

The bias-variance decomposition is the formal reason underfitting and overfitting fixes point in strictly opposite directions, and it's worth stating precisely rather than as a rule of thumb. A model's expected error splits into bias (systematic error from being too simple to represent the true relationship) and variance (error from being too sensitive to the specific noise in one training sample); adding capacity reduces bias but increases variance, and regularizing reduces variance but increases bias — there is no capacity setting that minimizes both simultaneously for a fixed amount of training data, only a tradeoff point that depends on how much data is actually available to constrain a more flexible model.

Read underfitting as the half of the capacity tradeoff that gets far less attention in ML education than overfitting does, despite being at least as common a real deployment mistake: the fix is a direct reversal of every overfitting remedy, and the training-set error check that distinguishes the two takes thirty seconds to run but prevents an engineer from making an already-struggling model worse by reaching for the wrong half of the toolbox.