Google

Error analysis is the practice of studying a model’s mistakes to decide what should be improved next. There is no single mandatory procedure; teams often use familiar patterns, but they can also adapt the approach to fit the problem and try other ways of examining errors.

Error Analysis

In a review table for misclassified support tickets, a single example can receive more than one tag. For instance, Ticket #12 might be marked both "Wrong Category" and "Missing Context." Because the same example can appear in multiple tags, the percentages shown at the bottom of the table do not have to total 100%.

One Example May Fit Several Error Tags

When you inspect examples the model got wrong, you often notice patterns that were not part of your original checklist. For example, if many failures come from dim indoor photos, you might add a separate "low light" column to your review table. A useful habit is to ask whether a person could have handled the case correctly, since that question can reveal both new error categories and possible fixes.

New Error Categories Can Appear During Review

The most useful error buckets are the ones that suggest a realistic improvement. For example, if a photo classifier often fails because product labels cover part of the object, that category is especially valuable when the team has a plausible way to remove the obstruction or make the model more robust to it. Even so, it can still be worthwhile to track some categories you cannot fix immediately, because the main purpose is to learn where the system is weakest and where effort is most likely to pay off.

Choose Error Categories You Can Act On

Error review usually begins with a rough first pass. You inspect a small set of mistakes, notice patterns, create tentative categories, label more examples, and then revisit earlier errors using the updated categories. If a new pattern appears, the categories can be revised and the review repeated.

Error Review Improves Through Repeated Passes

Suppose you review 200 misclassified photos from a warehouse robot. Seal-reading mistakes account for 6% of the errors, poor lighting accounts for 14%, and object-occlusion accounts for 25%. If fixing one category perfectly can remove at most that category's share of the total errors, then object-occlusion is the best place to start because it offers the largest possible reduction.

Using Error Counts to Decide Where to Focus Next

If the team has enough staff to split up, one group can investigate missed detections in nighttime scenes while another group studies false alarms on storefront signs.

Working on Several Error Buckets at Once

Error analysis does not give a single fixed formula for choosing the top improvement task. You still need to judge the likely gain from each error category and compare that with the effort required to address it.

Error Analysis Is Not an Automatic Ranking Rule

If you measure what fraction of all mistakes comes from one specific cause, that fraction is the most you could hope to remove by fixing only that cause. For example, suppose a document classifier makes 12% errors, and 25% of those errors happen on low-resolution scans. Even if low-resolution cases were solved perfectly, the total error could fall by no more than 25% of 12%, or 3 percentage points, from 12% to 9%. If instead 60% of the errors came from that one cause, the same task could potentially cut the total error from 12% to about 4.8%. The category share tells you whether that target is worth prioritizing, but it does not guarantee the full gain will be achieved.

A Category's Share of Errors Sets an Upper Bound on Improvement

Before spending substantial engineering time on a possible improvement, error analysis can provide a fast estimate of how much the change might move validation performance. That estimate gives a practical basis for deciding whether the work is likely worth the effort or whether resources should go to a different task.

Error Analysis Helps Estimate Whether a Proposed Change Is Worth the Effort

Engineers often avoid a quick error review because building a new feature feels more active and rewarding than checking whether the idea is actually promising. That hesitation can be expensive: a short manual review of, say, 80 mistakes at about 90 seconds each takes only around two hours, yet it can prevent many days or weeks of work on a fix that would not help much.

Why Quick Error Review Is Often Skipped

During error analysis, you may notice that some validation examples carry the wrong target label. In this situation, the example was mislabeled by a person before the model ever saw it, so the pair $(x, y)$ contains an inaccurate value of $y$. For instance, a photo of a scooter might be tagged as a bicycle, or a street-view image of a bus might be marked as a truck.

Incorrect Labels in a Validation Set

When a development set is large, manual inspection can become a bottleneck. For example, if a set contains 8,000 cases and the model makes mistakes on about 15% of them, there may be roughly 1,200 errors to inspect. Rather than examining all of them by hand, the team can divide the development set into two parts. One part is reserved for human review of errors, and the other part is kept untouched for choosing model settings. The reviewed portion will be adapted to more quickly, so separating the two roles makes it easier to notice when manual analysis is starting to bias decisions. The untouched portion then provides a cleaner signal for tuning.

Splitting a large development set into a review subset and a tuning subset

In a new problem area, it is usually difficult to know in advance which design changes will matter most. A better approach is to get a working baseline model built and trained as soon as possible, even if it is simple. After that, examine the model's mistakes to decide which improvements are most promising, and then refine the system step by step.

Build a Simple Baseline First, Then Use Error Analysis to Prioritize Improvements

If a model has high bias and is still performing poorly on the training set, reviewing training-set errors can help uncover systematic weaknesses in what the model is learning.

Using Training-Set Mistakes to Diagnose High Bias

A practical error-analysis routine is to inspect about 100 validation examples the model gets wrong, group the failures by type, and use the counts to decide which problems deserve attention first.

Reviewing a Sample of Validation Errors

When an inference system produces an incorrect result, first determine whether the search procedure failed to find a strong candidate or whether the scoring model assigned the wrong values. The next debugging step depends on that diagnosis: improve the search method if candidates are being missed, or improve the model that ranks or scores candidates if the scoring is unreliable.

Separating Search Errors from Scoring Errors in Inference

Component-wise error review helps identify which stage of a system deserves the most improvement effort. It can also be done informally by comparing each stage and the full system against a human or expert baseline.

Component-Wise Error Review

Error analysis is like applying data science to an ML system’s mistakes so you can decide what improvement to make next.

Error Analysis as a Data-Science Lens on Model Mistakes

Error analysis does not have a single correct workflow. Standard patterns are useful starting points for finding what is going wrong, but a team can also try other methods if they lead to better insight into model failures.

Multiple Valid Approaches to Error Analysis

Error analysis is most informative when the system is trying to do something people can also do, because human performance offers a practical reference point. If a model’s outputs or internal subtasks depend on abilities people do not reliably have, some standard error-analysis methods become less useful.

Tasks Humans Can Perform Give Stronger Error Analysis Benchmarks

When diagnosing a model, what should error analysis focus on first?

Error analysis on a machine learning system must follow one fixed procedure.

Name the practice of reviewing mistakes to understand why predictions failed.

Match each error-analysis idea to the description that best fits it.

Put the steps of a simple dev-set error review in the right order.

Why is it useful to inspect misclassified examples during error analysis, even for error types you cannot immediately repair?

Error analysis is usually repeated after each round of model changes.

Error analysis can help you judge which improvement paths look most _____.

Match each error-analysis activity with the benefit it can provide.

Order the steps for deciding which error types to target after a first pass of error review.

Question:
A team building a spam filter reviews messages the system labels incorrectly. What is the strategic purpose of this review process? Why is it useful to study failure types even when the team does not yet have a fix, and how does that help decide what to work on next?

Sample answer:
Error review is not only about patching a known bug. It helps the team build a clearer picture of what the model is getting wrong and where the biggest opportunities lie. By examining mistaken predictions, the team can uncover failure patterns they had not noticed before and sometimes identify new remedies worth trying. Even when there is no immediate solution for a particular failure type, counting how often it appears tells the team whether that problem is rare or widespread. That information is valuable because it shows which improvements are most likely to matter. In this way, error review supports better prioritization: the team can choose the next experiments or engineering tasks based on likely impact instead of guesswork. The process is cyclical, with each round of analysis informing the next round of work.

Key points:
- Builds a better understanding of model weaknesses
- Reveals previously unrecognized failure patterns
- Helps estimate how common each problem is
- Supports choosing the highest-impact next task
- Works as a repeated, iterative process

Rubric:
The response should explain that error review improves understanding of model failures, can reveal new categories of mistakes and possible fixes, helps estimate the frequency and importance of each problem, and guides project prioritization. It should also emphasize that this is an iterative process rather than a one-time checklist.

Why Error Review Helps Set the Right Next Priorities

Case context:
A team is developing a model that recognizes road signs from dashcam images. During manual review of dev set errors, they find that many mistakes come from images that are heavily blurred by motion. The team does not yet know a practical method for fixing blur-related failures. Some people want to stop discussing those examples and focus only on error types they already know how to address.

Question:
According to sound error-analysis practice, what should the team do about the blurred images, and why?

Sample answer:
They should keep the blurred images in the analysis. The team should count how often blur appears among the errors and examine those examples carefully, even if there is no immediate fix. The purpose of reviewing mistakes is to discover where the system is weak and to uncover promising directions for improvement, not only to track problems that are already easy to solve. Looking closely at the blurred cases may suggest new ideas, and measuring their frequency helps the team decide whether a dedicated effort to reduce blur-related errors is worth pursuing.

Key points:
- Do not exclude errors just because they are hard to fix right away.
- Error analysis is meant to reveal promising improvement opportunities.
- Reviewing the blurred examples may lead to new ideas.
- Counting how common blur is helps with prioritization.

Rubric:
The response should advise keeping the blurred images in the error analysis, explain that the review is meant to identify promising directions rather than only easy fixes, and note that the frequency of blur-related errors helps the team decide whether to invest in a targeted solution.

Plan the next review step after repeated image-classifier mistakes.

Question:
In a few sentences, explain what error analysis is and why teams use it when improving a model.

Sample answer:
Error analysis is the practice of reviewing examples the model got wrong, usually from the development set, to look for patterns in its mistakes. Teams use it to figure out why errors happen, decide where improvements will matter most, and choose the next work to focus on.

Key points:
- Reviewing misclassified examples by hand
- Looking for causes or patterns in the errors
- Using that insight to prioritize the next improvement

Rubric:
The answer should mention manually inspecting incorrect examples and explain that the goal is to understand error sources and guide future work.

Learn Before

Related