Overfitting is a situation where a machine learning model learns the training data too closely and performs poorly on new data. The model may look very accurate during training, but it fails when it meets examples it has not seen before.

In machine learning, a model is trained on examples and then used to make predictions on new cases. The goal is not to memorise the training data. The goal is to learn patterns that also work outside the training dataset.

Overfitting happens when the model learns not only the useful patterns, but also noise, random details, rare accidents, duplicates or specific quirks of the training data. It becomes too attached to the past examples. As a result, it may perform well in a controlled training environment, but badly in real business use.

What overfitting means

Overfitting means that a model has learned the training data in too much detail. It has found patterns, but not all of them are useful. Some of them may exist only in the training dataset and not in the real world.

Imagine that a model is trained to recognise fraudulent transactions. It may correctly identify fraud in the training data. But if it learns that a specific internal ID, temporary campaign tag or accidental formatting issue is associated with fraud, it may fail on future transactions. The signal looked useful during training, but it was not a reliable pattern.

This is the core problem. An overfitted model can appear intelligent, accurate and precise, but only because it has become too specialised for the data it already saw.

A simple example of overfitting

Imagine a student preparing for an exam. One student understands the topic and can solve new questions. Another student only memorises the exact answers from a practice test. If the real exam contains the same questions, the second student may look excellent. But if the questions change even slightly, the student fails.

An overfitted model behaves like the second student. It remembers the training data too precisely instead of learning a robust rule.

In machine learning, this can happen with customer behaviour, image recognition, fraud detection, credit scoring, medical prediction, search ranking or recommendation systems. The model works well on examples it has seen before, but it cannot handle new examples reliably.

Training data vs new data

To understand overfitting, it is important to separate training performance from real performance.

Training data is the data used to teach the model. The model adjusts itself based on these examples.

Validation data is used during development to check whether the model is improving or starting to overfit.

Test data is used for a final, more independent evaluation. It should represent data the model has not seen during training or tuning.

If a model performs extremely well on training data but much worse on validation or test data, that is a warning sign. The model may have memorised the training set instead of learning patterns that generalise.

Overfitting vs underfitting

Overfitting is not the only problem. The opposite problem is underfitting.

Overfitting means that the model is too sensitive to the training data. It learns too much detail, including noise and accidental patterns.

Underfitting means that the model is too simple or poorly trained. It does not learn enough even from the training data.

A useful model sits between these two extremes. It is complex enough to capture real patterns, but not so complex that it memorises noise.

Why overfitting matters

Overfitting matters because it creates false confidence. A team may believe that a model is ready for production because the training metrics look excellent. But once the model meets new data, the performance drops.

This can cause real problems. A marketing model may target the wrong customers. A fraud model may flag normal transactions. A credit model may misjudge risk. A recommendation system may produce irrelevant suggestions. A medical support model may rely on signals that do not generalise to other hospitals, devices or patient groups.

Overfitting is dangerous because it is not always visible immediately. The model may look successful in internal tests, especially if the evaluation process is weak, the test data is too similar to the training data or the same benchmark is reused too many times.

How to recognise overfitting

Overfitting usually appears as a gap between training performance and validation or test performance.

A model may show:

• very high training accuracy – but much lower validation or test accuracy,
• low training loss – but validation loss stops improving or starts increasing,
• excellent results on old data – but weak results on fresh data,
• unstable predictions – small changes in input cause large changes in output,
• too much sensitivity to noise – the model reacts to details that should not matter,
• poor real-world performance – even though the model looked good in development.

In practice, overfitting is often discovered through validation curves, learning curves, cross-validation, out-of-sample testing and monitoring after deployment.

Why overfitting happens

Overfitting can happen for several reasons. The most common reason is that the model is too complex for the amount and quality of available data.

A very flexible model can learn many patterns. That is useful when the patterns are real. But the same flexibility can also make the model learn noise, random coincidences or rare exceptions.

Overfitting is more likely when:

• the dataset is small – the model has too few examples to learn stable patterns,
• the model is too complex – it has more capacity than the task requires,
• there are too many features – some features may be irrelevant, redundant or noisy,
• the data contains duplicates – the model may be tested on examples too similar to training examples,
• the data contains noise – wrong labels, outliers or tracking errors can be learned as patterns,
• the evaluation process is weak – the model is not tested on truly unseen data,
• the team tunes too much on one test set – the test set slowly becomes part of the development process.

Example: overfitting in customer churn prediction

Imagine an e-commerce company builds a model to predict customer churn. The model is trained on historical customer data. It uses signals such as last purchase date, number of visits, newsletter engagement, support tickets, discount usage and product category.

A reasonable model may learn that customers who have not bought anything for a long time and stopped opening emails are more likely to churn. That is a plausible pattern.

But an overfitted model may learn much weaker details. It may notice that many churned customers in the training data used an old browser version, came from one temporary campaign or had a specific internal tracking value. These signals may not have any stable meaning in the future.

The model may perform very well on historical data, but badly on new customers. It has learned the past too precisely.

Example: overfitting in image recognition

Overfitting can also appear in image recognition. Suppose a model is trained to recognise a certain type of object in photos. If most training images of that object have the same background, lighting, watermark or camera angle, the model may learn those details instead of the object itself.

For example, it may learn that a certain object always appears on a white table. When the same object appears on a darker background, the model may fail. It did not truly learn the object. It learned a shortcut.

This is why image models often need varied training data, data augmentation and careful testing on images that differ from the training set.

Overfitting and the bias-variance trade-off

Overfitting is closely connected to the bias-variance trade-off.

Bias is error caused by overly simple assumptions. A model with high bias may underfit because it cannot capture the real pattern.

Variance is sensitivity to changes in the training data. A model with high variance may overfit because it reacts too strongly to the specific examples it was trained on.

A very simple model may have high bias and low variance. A very complex model may have low bias and high variance. In many projects, the goal is to find a model that has enough flexibility to learn useful relationships, but not so much flexibility that it becomes unstable.

Training, validation and test sets

One of the most important protections against overfitting is proper data splitting.

The training set is used to fit the model. The validation set is used to compare model versions, tune hyperparameters and decide when training should stop. The test set is used only at the end to estimate how the model may perform on unseen data.

This separation matters. If the same data is used for training and evaluation, the result can be misleading. The model may look good because it has already seen the examples.

A good test set should be representative of real-world data. It should not contain duplicates from the training set. It should also reflect the type of data the model will actually face after deployment.

Cross-validation

Cross-validation is another common method for checking whether model performance is stable. Instead of relying on a single train-test split, the data is divided into several parts. The model is trained and evaluated multiple times on different splits.

This helps estimate how much the model performance depends on a particular split of the data. If the model performs well on one split but poorly on another, that may indicate instability.

Cross-validation is especially useful when the dataset is not very large. It gives a more robust view of model behaviour, but it does not solve every problem. If the dataset itself is biased, outdated or affected by leakage, cross-validation can still produce misleading results.

Regularization

Regularization is a set of techniques used to reduce overfitting by limiting how freely the model can adapt to the training data.

The basic idea is simple: the model should not become unnecessarily complex. Regularization adds constraints or penalties that discourage overly complex solutions.

Common forms include:

• L1 regularization – can push some feature weights toward zero and make the model simpler,
• L2 regularization – discourages very large weights and usually makes the model smoother,
• dropout – randomly disables parts of a neural network during training so the model does not depend too heavily on specific neurons,
• early stopping – stops training when validation performance stops improving,
• tree pruning – limits the growth of decision trees so they do not memorise the training data.

Regularization does not mean making the model weak. It means forcing the model to learn more stable patterns.

Early stopping

Early stopping is commonly used when a model is trained over many iterations or epochs. During training, the model usually improves on the training data. But after some point, it may start learning details that do not help validation performance.

With early stopping, the training process is monitored on validation data. If validation performance stops improving or begins to get worse, training is stopped.

This is especially useful for neural networks. A neural network may continue reducing training loss for a long time, but that does not always mean it is becoming better for new data. Early stopping helps preserve the model at a point where it still generalises reasonably well.

Feature selection and overfitting

Feature selection can help reduce overfitting when the dataset contains many irrelevant, redundant or noisy features.

If a model receives too many input variables, it may find accidental relationships. Some variables may look predictive only by chance. This is especially risky when the number of features is high compared with the number of examples.

Feature selection tries to keep the features that carry useful signal and remove those that add noise or unnecessary complexity. It can make the model easier to train, easier to interpret and less likely to depend on random details.

However, feature selection must be done correctly. If features are selected using information from the full dataset before splitting into training and test sets, this can create data leakage.

Overfitting and dimensionality

High-dimensional data can make overfitting more likely. When a dataset has many variables, the model has more opportunities to find patterns that are not real.

This is sometimes connected to the curse of dimensionality. In high-dimensional spaces, data points can become sparse, distances can become less intuitive and models may need more data to learn reliable patterns.

Dimensionality reduction and feature selection can help, but they are not the same thing. Feature selection keeps some of the original features. Dimensionality reduction often creates a new lower-dimensional representation of the data.

Both approaches can reduce complexity, but they must be validated carefully. Removing too much information can cause underfitting. Keeping too much noise can cause overfitting.

Overfitting in neural networks

Neural networks can be powerful because they can learn complex patterns. That same power can also make them prone to overfitting, especially when the training dataset is small or narrow.

Common ways to reduce overfitting in neural networks include more training data, data augmentation, smaller network architecture, dropout, weight regularization, batch normalization and early stopping.

For example, in image classification, data augmentation may create modified versions of training images by changing crop, rotation, brightness or scale. This helps the model see more variation and reduces the chance that it memorises only the original examples.

In text models, overfitting may appear when the model becomes too adapted to one dataset, one domain or one evaluation benchmark. The model may perform well on familiar examples but fail on more diverse language.

Overfitting in decision trees

Decision trees are easy to understand, but they can overfit strongly if they are allowed to grow too deep.

A deep decision tree can split the data again and again until it captures very specific cases. It may create rules that work perfectly on the training set, but not on new data.

For example, a decision tree may learn a rule that applies to only one or two training examples. That rule may not represent a real pattern. It may only describe a coincidence.

To reduce overfitting in trees, teams often use maximum depth limits, minimum samples per leaf, pruning or ensemble methods.

Bagging and overfitting

Bagging, short for bootstrap aggregating, can help reduce variance in unstable models. It trains multiple versions of a model on different samples of the data and combines their predictions.

This is useful for models such as decision trees, which can change a lot when the training data changes. Instead of relying on one tree, bagging combines many trees. This can make predictions more stable.

Random forests are a well-known example of this idea. They combine many decision trees and add randomness to reduce dependence on one specific training sample or one specific set of features.

Bagging does not automatically remove every form of overfitting. But it can help when the main problem is high variance.

Overfitting and data leakage

Data leakage is not exactly the same as overfitting, but it can create similar false confidence.

Data leakage happens when the model uses information during training that would not be available in real use. For example, a model predicting customer churn might accidentally use a field created after the customer already churned.

The model may achieve excellent validation results, but only because it had access to future or unrealistic information. Once deployed, that information is not available, and performance collapses.

This is why overfitting checks should always include leakage checks. A model can look overfitted because it memorised noise, but it can also look unrealistically good because the evaluation setup was contaminated.

Overfitting in large language models

Overfitting can also be discussed in the context of large language models, but the situation is more complex than in a small supervised model.

A language model may memorise parts of its training data, become too adapted to certain benchmark formats or perform better on tasks that are very similar to data it has seen before. In real use, however, users ask messy, ambiguous and context-dependent questions.

There is also a practical form of evaluation overfitting. If a team repeatedly adjusts prompts, retrieval rules or model settings to perform well on the same small evaluation set, the system may become tuned to that test set. It may not improve in broader use.

For LLM-based systems, overfitting prevention is not only about model training. It also involves diverse evaluation sets, realistic prompts, source checking, human review, monitoring and careful separation between development examples and final evaluation examples.

Overfitting and prompt engineering

Prompt engineering can also create a smaller version of the same problem. A prompt may be tuned to work perfectly on a few examples, but fail when the user asks the same task in a slightly different way.

For example, a team may build a prompt for classifying support tickets. It works well on twenty internal examples. But once real users send longer, shorter, emotional, multilingual or incomplete messages, the prompt becomes unreliable.

This is not model overfitting in the strict training sense. The model weights are not being changed. But from a product perspective, the system has been over-optimised for a narrow test sample.

The solution is similar: use diverse test cases, include edge cases, avoid tuning only for examples that are already known and monitor production behaviour.

Overfitting in business analytics

In business analytics, overfitting often appears when a model is built on limited historical data and too many variables.

A marketing model may find that customers who clicked a specific banner during one campaign had higher purchase probability. A sales model may learn that leads from one event had higher conversion. A pricing model may learn seasonal effects that existed only during an unusual year.

These patterns can be real in the past and still unreliable for the future. Business conditions change. Campaigns change. Competitors change. Tracking systems change. Customer behaviour changes.

That is why business models need regular monitoring. Even a model that was not overfitted at launch can become unreliable later if the environment changes.

How to reduce overfitting

There is no single universal fix for overfitting. The right solution depends on the model, data, task and business risk.

Common ways to reduce overfitting include:

• use more data – more diverse and representative examples can help the model learn stable patterns,
• simplify the model – reduce unnecessary model complexity,
• remove noisy features – use feature selection, domain knowledge and data quality checks,
• use regularization – penalise overly complex model behaviour,
• use early stopping – stop training when validation performance stops improving,
• use cross-validation – check whether model performance is stable across different splits,
• clean the data – remove duplicates, fix labels and check outliers,
• prevent data leakage – make sure the model uses only information available at prediction time,
• test on realistic data – evaluate the model on data that resembles real deployment conditions,
• monitor after deployment – check whether performance changes over time.

Common mistakes with overfitting

Overfitting is a technical problem, but many of its causes are procedural. Teams often create overfitting risk through weak evaluation habits.

Common mistakes include:

• judging the model only by training accuracy – training performance is not enough,
• using the test set too often – repeated tuning can make the test set less independent,
• forgetting duplicates – duplicate or near-duplicate records can make evaluation too optimistic,
• splitting time-based data randomly – future information may leak into training when the task is chronological,
• ignoring business context – a pattern may be statistically useful but operationally meaningless,
• using too many weak features – more variables do not automatically mean a better model,
• trusting one metric – accuracy alone may hide poor generalisation for important segments,
• not monitoring the model after launch – real-world data can drift away from training data.

Overfitting is not always obvious

A model does not announce that it is overfitted. It may produce confident predictions, clean dashboards and impressive metrics.

That is why teams need deliberate checks. Compare training and validation performance. Use fresh test data. Investigate strange feature importance. Check whether performance is stable across segments. Look at errors, not only averages.

A model may perform well overall and still overfit in a specific group, product category, location, time period or customer type. This matters especially in high-impact decisions.

Why overfitting matters for model explainability

Model explainability can help detect overfitting. If explanations show that the model depends on strange, unstable or meaningless signals, this can reveal a problem.

For example, a model may predict high customer value because of a tracking parameter, not because of real buying behaviour. A medical model may rely on scanner metadata instead of patient characteristics. A fraud model may rely on a rare formatting issue that appeared only in the training data.

Explanations do not prove that a model generalises. But they can help people see whether the model is using reasonable signals.

How to remember overfitting

Overfitting can be compared to tailoring a suit so precisely to one person that nobody else can wear it. The suit fits the training data perfectly, but it does not fit the real world.

A good model should not be tailored only to the training examples. It should capture the underlying structure well enough to handle new examples.

Related terms

• Machine learning – the broader field in which models learn patterns from data and use them for prediction, classification or decision support.
• Generalisation – the ability of a model to perform well on new, unseen data.
• Underfitting – a situation where the model is too simple or poorly trained and performs badly even on training data.
• Training data – the dataset used to fit the model.
• Validation data – data used during model development to tune and compare models.
• Test data – data used for final evaluation of model performance on unseen examples.
• Cross-validation – a method for evaluating model performance across multiple train-test splits.
• Regularization – techniques that discourage unnecessary model complexity and help reduce overfitting.
• Early stopping – stopping model training when validation performance stops improving.
• Feature selection – selecting useful input variables and removing irrelevant or redundant ones.
• Bagging – an ensemble method that can reduce variance by combining multiple models trained on different samples.
• Data leakage – a situation where the model uses information during training that would not be available in real use.
• Bias-variance trade-off – the balance between a model that is too simple and a model that is too sensitive to training data.
• Large language model (LLM) – a language-focused AI model where evaluation overfitting, benchmark familiarity and prompt over-optimisation can also matter.
• Prompt engineering – the practice of designing prompts for language models, which should also be tested on diverse examples, not only on a narrow sample.

Sources and further reading

• Overfitting – developers.google.com – June 2026 – explains overfitting as a model matching the training set too closely and failing on new data.
• Dividing the original dataset – developers.google.com – June 2026 – explains why machine learning data is commonly split into training, validation and test sets.
• Machine Learning Glossary: ML Fundamentals – developers.google.com – June 2026 – defines validation, validation set and related terms used to guard against overfitting.
• Cross-validation: evaluating estimator performance – scikit-learn.org – June 2026 – describes cross-validation and the practice of evaluating models on unseen data.
• Glossary of Common Terms and API Elements – scikit-learn.org – June 2026 – includes definitions related to cross-validation, estimators and model evaluation.
• Overfit and underfit – tensorflow.org – June 2026 – explains common ways to reduce overfitting in neural networks, including more data, smaller models, regularization and dropout.
• Dropout: A Simple Way to Prevent Neural Networks from Overfitting – jmlr.org – June 2026 – the original research paper introducing dropout as a regularization technique for neural networks.