PrioriFI: More Informed Fault Injection for Edge Neural Networks

To know whether a neural network running on an edge chip will still work when a hardware glitch flips a bit, engineers "inject" faults — flip bits and see what breaks — but there are far too many bits to test them all, and the usual shortcut of assuming higher-order bits matter most is often wrong; this paper (UC San Diego and Fermilab — Olivia Weng, Ryan Kastner, and colleagues) presents PrioriFI, which ranks bits by how much they actually matter using the model's curvature and learns from each injection to find the truly critical bits first.

The argument in one glance

Problem

Finding the bits that break an edge neural network is a huge search

Neural networks increasingly run on edge devices — small, low-power chips in sensors, instruments, and embedded systems — where they must keep working even when the hardware glitches. Hardware faults happen: radiation, aging, and voltage problems can flip a bit in the memory that stores the network's weights or in the logic that computes with them. If a flipped bit corrupts the wrong value, the network's prediction can go badly wrong, which matters when the device is doing something important in a harsh environment. So designers need to know, before deployment, how robust a given edge network is to such faults. The standard way to measure this is fault injection (FI): deliberately flip bits in the model and observe how the output degrades, running many such experiments (an "FI campaign") to characterize which bits are dangerous. The catch is scale. An edge network has enormous numbers of parameter bits, and you cannot afford to test them all — especially on edge devices with strict limits on power, energy, latency, memory, and compute, which is exactly why edge networks are made small and quantized in the first place. What designers really want to find are the highly fault-sensitive bits: the small set of bits most critical to the network's correctness. Finding those quickly, out of a vast space, is the problem.
What people did

Assume the most significant bits are the most sensitive

A common shortcut in fault-injection tools is to rank bits by their positional significance and assume bit-level monotonicity: that a more significant bit is always more sensitive than a less significant one. The reasoning is intuitive — flipping the most significant bit of a number changes its value by a lot, while flipping the least significant bit changes it only a little — so tools prioritize testing high-order bits and treat them as the dangerous ones. This gives a cheap, fixed ordering of which bits to worry about, without having to actually measure each bit's effect.
Why it fell short

Bit significance does not reliably predict fault sensitivity

The trouble is that bit-level monotonicity has many exceptions, so ranking bits by significance misranks their true fault sensitivity. Whether flipping a particular bit actually harms the network depends on far more than the magnitude of the numerical change: it depends on which parameter the bit belongs to, how important that parameter is to the network's output, how the network's downstream computation and nonlinearities respond to the perturbation, and how quantization shapes the value. As a result, a flip in a less significant bit of a critical parameter can matter more than a flip in a more significant bit of an unimportant one — precisely the case the monotonicity assumption gets backwards. A tool that trusts significance as a proxy therefore spends its limited fault-injection budget testing bits it assumes are dangerous while missing the bits that truly are, giving a misleading picture of robustness. And because the space of bits is so large, you cannot simply test everything to correct the ranking. What was missing was a way to prioritize fault injection by each bit's real sensitivity — informed by the model itself and by evidence gathered as the campaign runs — rather than by a positional heuristic that is often wrong.
This paper's idea

Rank bits by real sensitivity, using curvature and past results

PrioriFI is a more informed fault-injection algorithm that ranks a network's bits by their actual fault sensitivity and prioritizes finding the most sensitive bits — the ones most critical to correctness — first. It does this in two complementary ways. First, for the initial ranking, PrioriFI uses the Hessian: a second-order, curvature-based measure of how sharply the network's loss responds to perturbing each parameter. Parameters whose loss curvature is high are ones where a small change causes a large effect, so the Hessian gives a principled prior on which parameters — and thus which bits — are likely to be fault-sensitive, rather than assuming significance decides it. Second, during the fault-injection campaign itself, PrioriFI learns as it goes: it uses the information gained from past fault injections as a heuristic to steer future injections toward the bits likely to be the next most sensitive. So the campaign is adaptive, concentrating its limited budget where the evidence says the dangerous bits are, instead of following a fixed positional order. With this, designers can quickly evaluate the robustness of different edge networks and better co-design fault-tolerant edge NN systems — spending fault-injection effort where it reveals the most about a model's true vulnerabilities.

Why this problem is worth solving

Edge neural networks are being trusted in settings where hardware faults are real and consequences are serious, so measuring their fault robustness efficiently is a practical necessity.

As neural networks move onto small edge devices to provide on-device intelligence, they are increasingly deployed in environments where the hardware is exposed to faults — embedded sensors, scientific instruments, and systems in the field or in radiation-prone settings. In such places a bit flip is not a hypothetical: soft errors and hardware degradation can and do corrupt stored weights or in-flight computations, and a corrupted value can flip a prediction with real consequences. Yet edge devices cannot simply add heavy redundancy to protect every bit, because they operate under strict budgets for power, energy, latency, throughput, memory, and compute — the same budgets that force edge networks to be quantized and shrunk in the first place. That tension makes it essential to understand exactly where a given network is vulnerable, so protection can be applied selectively to the bits that matter. Fault injection is how designers gain that understanding, but only if it can efficiently surface the truly dangerous bits rather than exhausting its budget on the wrong ones. A better-informed fault-injection method therefore directly improves the ability to build reliable edge AI: it lets designers compare candidate networks for robustness quickly and co-design fault tolerance that fits the device’s limits, spending protection only where it counts.

The key realization is that a convenient positional proxy for sensitivity is often wrong, and real sensitivity must be estimated from the model and from evidence.

It is tempting to equate a bit’s importance with its numerical significance, because the arithmetic seems obvious: the most significant bit carries the largest magnitude. But fault sensitivity is not about the size of the numerical change alone; it is about how much that change propagates through the network to corrupt the output, which depends on the role of the parameter and the behavior of everything downstream. The monotonicity assumption collapses all of that into a single positional rule, and the paper’s point is that the rule has many exceptions — so a tool built on it is confidently ordering bits in a way that does not match reality. PrioriFI’s insight is to stop treating significance as a stand-in for sensitivity and instead estimate sensitivity directly: use the Hessian, which measures the curvature of the loss and therefore how sharply the model reacts to perturbing each parameter, as a principled starting rank; then refine that rank with the actual outcomes of fault injections as they accumulate. This is the difference between guessing importance from position and learning it from the model’s own structure and from evidence. Because the search space is far too large to cover exhaustively, getting the prioritization right is what makes a limited fault-injection budget actually find the critical bits — which is the whole point of the exercise.

What people did before, and where it broke

Rank bits by significance (assume monotonicity). Prioritize testing the most significant bits, assuming they are the most fault-sensitive. Where it broke. Bit-level monotonicity has many exceptions, so significance misranks true sensitivity and misses critical low-order bits of important parameters.
Inject faults exhaustively. Test every bit to be sure. Where it broke. The space of parameter bits is enormous, so exhaustive fault injection is infeasible within an edge design’s time and compute budget.
Inject faults randomly. Sample bits at random across a campaign. Where it broke. Random sampling wastes budget on the overwhelming majority of insensitive bits and is slow to surface the rare critical ones.
Use a fixed, static ordering. Follow one predetermined priority order for the whole campaign. Where it broke. A static order cannot use what the campaign learns as it runs, so it keeps testing where evidence already suggests little is to be found.
The gap. No approach ranked bits by their real fault sensitivity — informed by the model’s curvature and refined by the outcomes of past injections — so the limited fault-injection budget was not steered toward the truly critical bits.

How PrioriFI works

From a positional guess to an evidence-guided sensitivity ranking

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Rank by measured sensitivity, not by a convenient positional proxy. PrioriFI’s foundation is refusing to equate a bit’s numerical significance with its fault sensitivity, and instead ranking bits by how much they actually affect the network’s correctness. Discarding an easy-to-compute but weakly-predictive proxy in favor of directly assessing each element’s true impact on the outcome is the same methodological move the work on criticality-first tiered memory placement (PACT) covered elsewhere on this site makes, replacing a positional or frequency stand-in with a direct measure of what really matters. PrioriFI brings that criticality-first mindset to fault injection, where the tempting proxy is bit significance and the real quantity is fault sensitivity.

Use the model’s own structure to prioritize its important parameters. PrioriFI turns to the Hessian to identify, from the network’s loss geometry, which parameters are most sensitive to perturbation — a principled, model-derived prior rather than a hand-set rule. Treating some parameters as far more important than others based on a curvature or importance measure of the model, and allocating scarce resources accordingly, is the same principle the work on an importance-aware microscaling format for low-bit edge networks (M2XFP) covered elsewhere on this site is built on, where respecting which values matter most preserves quality under tight budgets. PrioriFI uses that importance signal to decide where faults are most worth injecting rather than where bits should be most precisely stored.

Guide a search of a huge space with feedback from what you have already found. Because there are far too many bits to test, PrioriFI runs an adaptive campaign, using the results of past fault injections to steer the next ones toward the bits likely to be most sensitive. Exploring an intractably large space efficiently by feeding back the outcomes of prior trials to bias future exploration toward the interesting regions is the same strategy the work on greybox fuzzing for concurrency testing (greybox fuzzing) covered elsewhere on this site relies on, letting observed evidence direct where to probe next. PrioriFI applies this feedback-guided search to fault injection, so the campaign concentrates on the critical bits instead of blindly enumerating.

Following a fault-injection campaign through PrioriFI

Prioritizing which bits to fault-inject

An illustration, drawn from the paper's abstract, of how PrioriFI ranks and refines. Internal mechanism details are the paper's.

Step 1 of 5

Compute a Hessian-based initial ranking

PrioriFI starts by using the Hessian to rank the network's parameters by how sharply the loss responds to perturbing them, producing a principled initial ordering of which bits are likely most fault-sensitive.

High loss curvature flags parameters where a small change has a large effect.

Why it works

Sensitivity depends on the model, not just bit position. Numerical significance ignores how a perturbation propagates → but a flip in a critical parameter’s low bit can outweigh a high bit of an unimportant one → so ranking by real sensitivity catches what significance misses.
The Hessian is a principled sensitivity prior. A hand-set positional rule is a guess → but loss curvature measures how sharply the model reacts to perturbing each parameter → so it gives a model-informed starting rank of likely-sensitive bits.
Feedback focuses a budget too small to cover everything. The bit space is far too large to test exhaustively → but using past injection outcomes to steer future ones → so the limited budget concentrates on the bits evidence says are dangerous.
Adapting beats a fixed order. A static priority list cannot learn from the campaign → but re-ranking as evidence accumulates → so PrioriFI stops probing unproductive regions and follows the vulnerability structure.
Finding critical bits first makes evaluation fast and useful. Random or positional search surfaces the rare critical bits slowly → but prioritizing the most sensitive bits up front → so designers get an accurate robustness picture quickly and can target fault tolerance.

What it costs (trade-offs and scope)

Computing the Hessian has a cost. The principled initial ranking relies on a second-order measure of the loss, which is more expensive to compute than a positional heuristic, so PrioriFI trades some up-front computation for a much better ranking.
The heuristic is a prioritization, not a guarantee. Using past injections to predict the next most sensitive bits steers the search well but is still a heuristic; it improves the odds of finding critical bits early rather than proving it has found them all.
It evaluates robustness, it does not add fault tolerance. PrioriFI helps designers find and rank vulnerable bits so they can co-design protection; it is an analysis and prioritization tool, not itself a hardening mechanism.
It targets edge, quantized networks. The method is aimed at edge NNs with their quantization and small-layer constraints; its framing and value are tied to that setting rather than to arbitrary large models.
Details and results come from the paper. This page is based on the abstract and public materials; the exact Hessian formulation, the campaign heuristic, and the quantitative evaluation should be read from the paper.

The comparison

Choosing which bits to fault-inject in an edge neural network

Property	Significance order (monotonicity)	Random / exhaustive	PrioriFI
Ranking basis
Catches low-bit critical flips
Uses model information
Adapts during the campaign
Budget efficiency

A comparison of ways to choose which bits to fault-inject when evaluating an edge neural network's robustness. Significance-ordered injection assumes bit-level monotonicity, which has many exceptions; random or exhaustive injection wastes a scarce budget. PrioriFI ranks bits by real fault sensitivity using the Hessian for a principled prior and past injection results as a heuristic, prioritizing the most critical bits first so robustness is evaluated efficiently. Exact figures should be read from the paper.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s abstract and public materials (including the authors’ project page and open-source repository), not its full text, which was not available at the time of writing. The high-level claims are the authors’: PrioriFI is a more informed fault-injection (FI) algorithm that evaluates edge neural network robustness by ranking network bits based on their fault sensitivity, prioritizing finding the highly fault-sensitive bits — those most critical to correctness — first. The authors argue that fault-injection tools should be mindful of relying on bit-level monotonicity (the assumption that a more significant bit is more sensitive than a less significant one), which has many exceptions. To rank bits, PrioriFI uses the Hessian for the initial parameter ranking, and then, during an FI campaign, uses information gained from past fault injections as a heuristic so future injections target the bits likely to be the next most sensitive. The stated benefit is that designers can quickly evaluate different networks and better co-design fault-tolerant edge NN systems. The paper is set in the context of edge NNs that require architectural changes such as quantization and fewer, smaller layers under strict power, energy, latency, throughput, memory, and compute constraints; the repository demonstrates PrioriFI on QKeras models, including networks trained on a high-energy-physics “Smart Pixel” dataset. The background above on fault injection, bit sensitivity, quantization, and the Hessian is standard context provided to make the approach intuitive. The Flow, the step-by-step walkthrough, and the “Why it works” reasoning are illustrations built from the abstract’s description, not detailed accounts from the paper — the exact Hessian formulation, the campaign heuristic, and the quantitative evaluation should be read from the paper. Do not treat specific procedural details here as established beyond what the abstract states.

Background

Why reliable machine learning keeps coming down to finding what actually matters

It helps to see PrioriFI within a broad pattern in reliable and efficient machine learning: the parameters and bits of a neural network are far from equally important, and a great deal of progress comes from identifying the few that truly matter and treating them differently from the rest. Quantization schemes protect the important values with more precision; pruning removes the unimportant ones; robustness work hardens the critical bits. In every case the hard part is the same — telling which elements are important — and the recurring lesson is that cheap positional or uniform assumptions mislead, while model-informed measures (like loss curvature) and evidence gathered from the system’s own behavior do much better. PrioriFI is a clean instance for fault tolerance: it rejects the assumption that bit significance equals fault sensitivity, and instead ranks bits by their real effect using the Hessian and feedback from injections. The broader goal it serves — keeping neural networks correct despite hardware faults, so that machine learning can be trusted in demanding deployments — is the same terrain the work on efficient fault tolerance for large neural network models (MoC-System) covered elsewhere on this site occupies, protecting NN computation against failures without unaffordable overhead. PrioriFI’s particular contribution is to make the evaluation step efficient and honest, surfacing the bits that genuinely threaten correctness so that fault tolerance can be co-designed to fit an edge device’s tight budgets.

If you remember only three things

1. Neural networks on edge devices must keep working when hardware faults — from radiation, aging, or voltage problems — flip bits in stored weights or in-flight computation, but they cannot afford heavy redundancy because of strict power, energy, latency, memory, and compute budgets (the same limits that force edge networks to be quantized and small). To know where a network is vulnerable, designers use fault injection: deliberately flip bits and measure the damage across a campaign. The problem is scale — the space of parameter bits is enormous, so tools must find the most fault-sensitive bits efficiently. The common shortcut is to assume bit-level monotonicity, that a more significant bit is always more sensitive than a less significant one, but this assumption has many exceptions, so it misranks which bits actually matter and wastes the injection budget.
2. PrioriFI is a more informed fault-injection algorithm that ranks bits by their real fault sensitivity and prioritizes finding the most critical bits first. It uses two complementary signals. For the initial ranking it uses the Hessian — a second-order, curvature-based measure of how sharply the network's loss responds to perturbing each parameter — so parameters where a small change has a large effect are flagged as likely fault-sensitive, a principled model-derived prior rather than a positional guess. Then, during the campaign, it learns as it goes: it uses the information from past fault injections as a heuristic to steer future injections toward the bits likely to be the next most sensitive, adaptively concentrating its limited budget where the evidence points instead of following a fixed order.
3. By prioritizing the truly critical bits, PrioriFI lets designers quickly evaluate and compare edge networks for robustness and better co-design fault-tolerant edge NN systems, applying protection where it counts under tight budgets. The trade-offs and scope: computing the Hessian costs more up front than a positional heuristic, the feedback heuristic improves the odds of finding critical bits early rather than guaranteeing completeness, and PrioriFI evaluates and ranks vulnerabilities rather than itself adding fault tolerance; it is aimed at edge, quantized networks. This explainer is based on the paper's abstract and public materials (project page and open-source repository); the exact Hessian formulation, the campaign heuristic, and the quantitative evaluation should be confirmed in the paper.

Check yourself

Check your understanding

1. Why is evaluating an edge neural network's fault robustness hard?
2. What is "bit-level monotonicity," and why is relying on it a mistake?
3. How does PrioriFI rank bits by their real fault sensitivity?
4. What does PrioriFI provide, and what are its limits?

Sources

The paper is “PrioriFI: More Informed Fault Injection for Edge Neural Networks” by Olivia Weng, Andres Meza, Nhan Tran, and Ryan Kastner (University of California San Diego, and Fermilab), published at ASPLOS 2026, DOI 10.1145/3779212.3790204. The authors provide a project page and an open-source repository (github.com/KastnerRG/priorifi).

This explainer is written from the paper’s abstract and public materials; the full text was not available at the time of writing, so the page is marked a draft. As reported there, PrioriFI is a more informed fault-injection algorithm that evaluates edge neural network robustness by ranking bits based on their fault sensitivity, prioritizing the most critical bits first, and it cautions against relying on bit-level monotonicity (the assumption that a more significant bit is more sensitive), which has many exceptions. PrioriFI uses the Hessian for the initial parameter ranking, then uses information from past fault injections as a heuristic to steer future injections toward the next most sensitive bits, so designers can quickly evaluate networks and co-design fault-tolerant edge NN systems. Background on fault injection, bit sensitivity, quantization, and the Hessian is standard context. The specific claims are the paper’s own; the mechanism details and full evaluation should be confirmed in the paper.