🤖 AI

Coverage Aware Active Evaluation for Failure Discovery with Paired Systems

This paper proposes an adaptive failure discovery method that leverages proxy system evaluations to guide target system testing through control-variate-inspired risk prediction and support-aware mutual information, effectively uncovering significantly more diverse and severe failures than random sampling or active learning baselines across autonomous driving, manipulation, and quadruped tasks.

Original authors: Anjali Parashar, Rachel Luo, Apoorva Sharma, Sushant Veer, Edward Schmerling, Carson Sobolewski, Mingxin Yu, Chuchu Fan, Marco Pavone

Published 2026-08-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Anjali Parashar, Rachel Luo, Apoorva Sharma, Sushant Veer, Edward Schmerling, Carson Sobolewski, Mingxin Yu, Chuchu Fan, Marco Pavone

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a safety inspector for a fleet of futuristic self-driving cars, robot dogs, and robotic arms. Your job is to find out when these machines might break or act dangerously. The problem is that testing them in the real world is expensive, slow, and sometimes dangerous. If a robot dog falls off a cliff during a test, you can't just fix it and try again instantly; you might break the robot or the cliff. So, engineers often use "cheap proxies"—like video game simulations or simpler, lower-quality versions of the robot—to run thousands of tests quickly.

However, there's a catch. Just because a robot fails in a video game doesn't mean it will fail in real life. The game might have weird physics that don't exist in reality, or the robot might be too perfect in the simulation. This is called the "sim-to-real gap." If you only trust the game, you might waste your time testing scenarios that are actually safe, or worse, you might miss the real, dangerous failures that only happen in the messy, unpredictable real world. The big question is: How do you use the cheap, fast game tests to guide your expensive, slow real-world tests so you find the real dangers without wasting your budget?

This paper, titled "Coverage Aware Active Evaluation for Failure Discovery with Paired Systems," proposes a clever new way to solve this puzzle. The authors, a team from MIT and NVIDIA, suggest a method that treats the cheap simulation tests not as the final answer, but as a helpful, albeit slightly biased, hint. They call their approach an "adaptive failure discovery" method. Instead of blindly guessing which scenarios to test, their system learns from a few real-world tests to correct the simulation's mistakes.

Here is how it works, using a simple analogy: Imagine you are trying to find hidden treasure on a massive island, but you only have a limited number of gold coins to spend on digging. You have a map (the proxy system) that shows where treasure might be, but the map is old and has some errors. If you just follow the map, you might dig in the wrong spots. Instead, the authors' method acts like a smart detective. It looks at the map, but then it sends a few scouts to dig in specific spots to see what the ground actually looks like. By comparing the map's prediction with the scout's report, the detective learns how to "correct" the map locally. If the map says "dig here" but the scout says "it's just sand," the detective learns to ignore that part of the map for now.

The paper introduces two main tricks to make this work. First, they use a "control-variate" technique. Think of this as a mathematical way to say, "The map is usually right, but let's adjust its score based on what we just learned from the real ground." This helps them predict where the real system is likely to fail, even if the simulation was wrong about that specific spot. Second, they use a "support-aware mutual information" strategy. This is a fancy way of saying, "Don't just dig where you think the treasure is; also dig in places you haven't looked at yet to make sure you aren't missing a whole new type of treasure." This ensures they find a wide variety of different failures, not just the same one over and over again.

The researchers tested this method on three very different types of robots: self-driving cars (using the nuPlan dataset), robotic arms that pick up objects (using the SIMPLER task), and a four-legged robot dog tracking a moving target (using a quadruped task). In every case, they compared their method against random guessing and other standard testing tools. The results were promising: their method found up to twice as many real-world failures as the other methods. For example, in the self-driving car tests, they discovered more scenarios where the car would crash or get too close to other vehicles. In the robot dog tests, they found more instances where the dog would stumble or lose its balance, including some very severe failures that the other methods completely missed.

Crucially, the paper argues against the idea that you can just trust the simulation or that you should only test the real world without any guidance. They show that ignoring the simulation wastes time, but trusting it blindly is dangerous. Their method sits right in the middle, using the cheap tests to guide the expensive ones. They also found that their approach works well even when the simulation and the real world are quite different, as long as they can pair them up to learn the differences.

The authors are careful to note that this isn't a magic bullet that solves all testing problems forever. They acknowledge that their method still needs some real-world tests to learn the corrections, and it works best when the scenarios can be described in a way that makes sense to the computer (like a list of numbers describing the environment). However, their findings suggest that by combining cheap proxies with smart, adaptive learning, we can find more dangerous failures with fewer resources. This could mean safer robots and cars in the future, because we can find the "edge cases"—the weird, rare situations where things go wrong—much faster and more efficiently than before.

Technical Summary: Coverage Aware Active Evaluation for Failure Discovery with Paired Systems

Problem Statement
Autonomous systems face a critical challenge in safety evaluation: discovering rare, severe, and heterogeneous failures under limited testing budgets. Direct evaluation of high-fidelity target systems (e.g., real-world robots or vehicles) is often expensive, time-consuming, and resource-constrained. While cheaper proxy systems (simulators, lower-fidelity platforms, or related policies) allow for extensive sampling, they suffer from "sim-to-real" or system-to-system gaps. Failures identified in proxies often do not transfer to the target system, and conversely, scenarios appearing safe in proxies may induce severe failures in the target. Existing methods either rely solely on proxies (risking inaccurate estimation) or target-only active learning (ignoring abundant proxy data), failing to effectively leverage proxy information to predict specific target-system failures.

Methodology
The authors propose an adaptive failure discovery method that combines cheap proxy evaluations with a limited budget of target-system tests. The core objective is to select scenarios that are both likely to fail on the target system and diverse enough to cover distinct failure modes. The approach is formulated as an adaptive scenario selection problem using Bayesian Experimental Design (BED).

The acquisition strategy, $\alpha(x)$ , balances two objectives:

Failure Estimation (Risk Prediction): The method learns a local predictor of target risk, $\mu_{CV}(x)$ , using a Control Variate (CV) inspired approach. Instead of treating proxy failures as ground truth, the method models the target risk by correcting proxy signals using limited paired target evaluations.
- For a candidate scenario $x$ , a local neighborhood is defined.
- A surrogate model $q_\theta$ (trained on limited target data) predicts target metrics.
- Proxy metrics are used to adjust the target estimate based on the correlation between target and proxy distributions within that local region.
- The estimator $\mu_{CV}(x)$ minimizes variance by leveraging the correlation between the cheap proxy signal and the expensive target signal, effectively correcting for local proxy-target mismatches.
Scenario Diversity (Support Awareness): To ensure the discovery of diverse failure modes rather than redundant ones, the method introduces a Support-Aware Mutual Information (MI) term, $I(Z_x; R_x | x, D_t)$ .
- This term quantifies the potential for a candidate scenario to expand the "support" of the explored scenario space.
- It favors scenarios that lie in under-explored regions or have ambiguous cluster assignments relative to existing data, encouraging the exploration of novel operating conditions.

The final acquisition function combines these terms: $\alpha(x) = \mu_{CV}(x) + I(Z_x; R_x | x, D_t)$ . In practice, for discrete scenario spaces, the algorithm selects top candidates maximizing MI, filters them by a severity threshold ( $\mu_{CV} \ge \gamma$ ), and uses clustering to select a diverse batch for evaluation.

Key Contributions

Formulation: The paper frames proxy-guided failure discovery as an adaptive scenario selection problem aimed at finding distinct target failure modes under a fixed budget.
Local Proxy-Corrected Predictor: It proposes a local failure predictor that uses limited paired proxy-target evaluations to estimate target risk, correcting proxy signals rather than assuming they are ground truth.
Support-Aware Acquisition: It introduces a mutual-information-based acquisition strategy that balances the likelihood of target failure with the coverage of realistic and under-explored regions.
Empirical Validation: The method is evaluated across four diverse tasks: autonomous driving (nuPlan), language-conditioned manipulation (SIMPLER), quadruped velocity tracking, and perception failure analysis (KITTI).

Results
Across all evaluated domains, the proposed method demonstrated superior performance compared to random sampling and active learning baselines (including BAMS, BNN-C/GP-C, and ablated versions of the proposed method):

Failure Discovery: The method discovered up to 2x as many target-system failures as the strongest baselines under the same target-evaluation budget.
Severity and Diversity: It successfully identified severe failures that competing methods missed. It achieved the highest diversity across all tasks, measured by pairwise distance coverage among discovered failures.
Component Analysis: Ablation studies confirmed that the Control Variate component improves failure targeting, while the Mutual Information component promotes support coverage. Clustering within batches further preserved diversity.
Proxy Utility: In tasks with higher proxy-target correlation (e.g., KITTI), the proxy guidance significantly improved failure recall and utility. In tasks with weak correlation (e.g., nuPlan), the method still provided gains by adaptively learning the relationship.

Significance and Claims
The paper claims that its approach demonstrates that cheap proxy evaluations can substantially improve failure discovery when used to guide target-system testing adaptively, rather than serving as direct substitutes for target evaluation. By combining proxy guidance with local correction and diversity-aware acquisition, the method enables sample-efficient discovery of distinct, severe target-system failures. The authors emphasize that their approach scales to high-dimensional scenarios and does not rely on restrictive model choices (like Gaussian Processes) for the surrogate, making it applicable to complex autonomous systems. The work highlights that accurate risk estimation and scenario diversity are intertwined; lacking diversity leads to redundant failures, while lacking accurate risk estimates wastes evaluation budgets.

Technical Summary: Coverage Aware Active Evaluation for Failure Discovery with Paired Systems

More like this