ZeroBN: Fault Tolerance & Latency in Edge NNs

• ZeroBN is a deployment-centric concept that covers fault-tolerant binary neural network design and BN-based zeroization for latency-sensitive edge applications.
• It employs deliberate quantization of vulnerable floating-point parameters to restrict error propagation without incurring additional inference overhead.
• The BN zeroization approach dynamically prunes low-importance channels and supports recovery training, enabling hardware-aware optimization of model latency.

Searching arXiv for papers relevant to “ZeroBN,” including the provided ids and closely related terminology. Searching arXiv for “ZeroBN” and the cited paper titles. ZeroBN is a term used in recent arXiv literature in two distinct senses associated with deployment-oriented neural network design for edge systems. In one sense, it denotes fault-tolerant binary neural network design with zero inference-time overhead, formalized through ZOBNN, where deliberately quantized non-binary parameters improve robustness to memory faults without extra computation or memory overhead. In another sense, it denotes Zerorized Batch Normalization, a latency-constrained architecture learning method that uses batch-normalization parameters for dynamic zeroization, recovery, and structured pruning in a one-shot training process. The two usages share an emphasis on resource efficiency and hardware-aware deployment, but they address different failure modes and optimization targets: fault propagation in binarized models on the one hand, and hard latency compliance on edge devices on the other (Ghavami et al., 2024, Huai et al., 8 Jul 2026).

1. Terminology and scope

In the supplied literature, ZeroBN does not refer to a single universally fixed algorithmic object. Instead, it names two technically different lines of work.

Usage	Core meaning
ZeroBN in ZOBNN	Fault-tolerant binary neural network design with zero overhead
ZeroBN as Zerorized Batch Normalization	BN-parameter zeroization and recovery for latency-constrained architecture learning

The first usage appears in the context of binary neural networks (BNNs), where the central problem is that state-of-the-art BNNs still contain some floating-point parameters, especially in S-type layers such as batch normalization and in the first and last non-binarized layers. These floating-point parameters remain susceptible to large error amplification under memory faults, so ZeroBN is framed as a way to improve dependability without resorting to redundancy such as TMR or ECC (Ghavami et al., 2024).

The second usage appears in edge deployment under strict latency budgets. There, ZeroBN is short for Zerorized Batch Normalization, a framework that uses the batch-normalization scale and shift parameters to zeroize low-importance channels and later allow recovery, thereby learning a model that satisfies a hardware-specific latency constraint in a single training process (Huai et al., 8 Jul 2026).

A naming distinction is also important. ZorBA, despite superficial similarity in spelling, is a separate framework for zeroth-order federated fine-tuning of LLMs with heterogeneous block activation, and it is not a ZeroBN method (Meng et al., 19 Feb 2026).

2. ZeroBN as zero-overhead dependability in binary neural networks

In the dependable-BNN usage, ZeroBN is motivated by a limitation of contemporary BNN design. Although low-precision weights and activations reduce memory consumption and accelerate inference, state-of-the-art BNNs often preserve some floating-point parameters to recover accuracy. The ZOBNN work identifies these floating-point parameters as the main vulnerability under memory faults, because even a single bit-flip in floating-point storage may induce arbitrarily large numerical deviation. This finding shifts the fault-tolerance question away from the already-binarized convolutional parameters and toward the residual floating-point components (Ghavami et al., 2024).

This formulation is explicitly positioned against conventional dependable design strategies based on redundancy or specialized error-correcting architectures. The claim is not that BNNs are automatically dependable by virtue of binarization alone; rather, standard BNNs remain fragile where floating-point S-type layers or non-binarized boundary layers are retained. ZeroBN therefore refers to a design principle in which those vulnerable parameters are deliberately quantized so that their dynamic range is confined, fault propagation is limited, and the resulting robustness gain is obtained without modifying the inference-time computation.

The emphasis on “zero overhead” has a precise meaning in this context. It does not imply the absence of training-time processing or representational changes. It means that the robustness mechanism does not introduce extra hardware, extra MACs, or extra quantization/dequantization computation in the inference path. A plausible implication is that the method is intended as a deployment-compatible modification of existing BNN pipelines rather than as a separate fault-recovery subsystem.

3. Deliberate uniform quantization and the zero-overhead mechanism

The key technical device in ZOBNN is a deliberate uniform quantization applied selectively to the floating-point parameters. Conventional quantization, exemplified in the summary by integer-only mapping with

$r = \Delta(q - Z),$

uses an explicit scale $\Delta$ and zero-point $Z$, and typically introduces quantization and dequantization operators into the inference path. ZOBNN instead pre-quantizes parameters during training and stores them in that form, so the inference graph no longer includes paired quantization/dequantization functions (Ghavami et al., 2024).

For a real-valued parameter $x_r$, the deliberate uniform quantization is defined as

$Q(x_r) = \text{round}(x_r / \Delta) = x_q,$

with

$\Delta = \frac{\max(\theta)}{2^{\#bits-1} - 1},$

where $\max(\theta)$ is the largest parameter value to be represented. The corresponding dequantization is

$D(x_q) = \Delta \times x_q \approx x_r,$

and the construction is chosen so that

$Q(D(x_q)) = x_q.$

This reciprocal property underwrites the zero-overhead claim. Because paired quantization and dequantization stages satisfy $Q(D(x)) = x$, they can be canceled from the deployed model, leaving no extra quantizing or dequantizing computation at inference. The arithmetic remains the same as in the original BNN; only the representation of the selectively quantized parameters changes.

The selective scope is also central. The method targets only the floating-point parameters in S-type layers, such as batch normalization, and the non-binarized first and last layers. Parameters in already-binarized convolution layers are left untouched. This suggests that ZeroBN is designed as a targeted intervention on the numerically fragile portion of a BNN rather than as a blanket re-quantization of the entire network.

4. Fault model, robustness gains, and memory effects in ZOBNN

The dependability claims are supported by experimental fault simulation in which random bit-flips are injected with probability $\Delta$0 ranging from $\Delta$1 to $\Delta$2. The experiments are reported on FracBNN and DoReFaNet, with CIFAR-10 and ImageNet as datasets. Under this setup, ZOBNN is reported to maintain substantially higher accuracy than baseline BNNs and floating-point DNNs when fault rates increase (Ghavami et al., 2024).

At a fault rate of $\Delta$3 for DoReFaNet, ZOBNN maintains more than $\Delta$4 accuracy, while the baseline BNN drops below $\Delta$5. For FracBNN, ZOBNN maintains $\Delta$6–$\Delta$7 at high fault rates, while the baseline drops to $\Delta$8–$\Delta$9. Floating-point DNNs degrade to random guessing under the same conditions. The reported average robustness improvement reaches up to 5× higher robustness compared to floating-point DNNs, and up to 32.3\% and 24.8\% improvement over baseline BNNs at high fault rates. The accuracy distribution is also reported to narrow significantly, reducing the likelihood of catastrophic failure.

The same experiments support the claim that robustness is obtained without measurable inference penalty. Table-level results in the summary state that inference time is unchanged, with less than $Z$0 difference relative to baseline BNNs, whereas conventional quantization incurs more than $Z$1 overhead. Memory consumption is also reduced: up to 20.1\% memory reduction on CIFAR-10 with 8-bit quantization, and up to 34\% memory reduction on ImageNet with 12-bit quantization, while retaining more than $Z$2 baseline accuracy for 8–16 bits and showing degradation only under extreme quantization.

These results are tied to deployment scenarios characterized by limited computational resources, harsh or unstable hardware conditions, and strict real-time requirements. The examples explicitly mentioned include autonomous vehicles, IoT, and medical devices, as well as SRAM fault rate up to $Z$3 and DRAM up to $Z$4 in cited works.

5. ZeroBN as Zerorized Batch Normalization

In the latency-oriented usage, ZeroBN is an architecture learning framework built around batch normalization. The central observation is that the BN scale parameter $Z$5 carries information about channel importance: small $Z$6 indicates a relatively unimportant channel. Standard BN applies

$Z$7

while ZeroBN repurposes $Z$8 and $Z$9 as explicit controls for structured channel removal by setting $x_r$0 and $x_r$1 for low-importance channels (Huai et al., 8 Jul 2026).

For a layer $x_r$2, the formulation is expressed as

$x_r$3

Zero training globally sorts all $x_r$4 values by $x_r$5, determines a threshold guided by the latency predictor, and zeroizes channels below that threshold. Recovery training then allows the previously zeroed parameters to update and potentially reactivate. This is a defining difference from irreversible pruning methods: ZeroBN alternates between effective pruning and regrowth.

The recovery mechanism is motivated by the possibility of “missing” important features during aggressive pruning. The summary notes a gradient deadlock issue when $x_r$6 and $x_r$7 are both zero and ReLU is also at zero, implying zero current gradients for those parameters. The framework relies on optimizer momentum so that accumulated past gradients can move parameters away from zero if recovery is beneficial:

$x_r$8

This alternating zero-recovery dynamic is presented as increasing the search space and improving adaptability in the latency-accuracy tradeoff.

The overall process has three steps: initial sparsity-aware training, alternating zero training and recovery training, and final compaction by removing channels whose $x_r$9 and $Q(x_r) = \text{round}(x_r / \Delta) = x_q,$0 remain zeroed. The method also extends from channels to entire layers by adding branch connections and summing importance per layer; if total importance is below a threshold, the whole layer can be pruned.

6. Latency prediction, edge deployment results, and interpretive issues

A distinctive feature of Zerorized Batch Normalization is that pruning is driven by a hardware-customized latency predictor rather than by indirect proxies such as FLOPs or parameter count. The predictor is a BP neural network trained on sampled operator configurations executed on the target hardware. It takes tensor or channel shapes as input and estimates forward-pass latency per layer; overall model latency is then obtained by summing the layer-wise predictions. This design is intended to avoid repeated on-device measurements and to align training directly with a hard latency target (Huai et al., 8 Jul 2026).

This latency-aware training enables both pruning and scaling. If a model is too slow, ZeroBN zeroizes and removes channels or layers until the predicted latency meets the target. If a model is too lightweight, it can first be uniformly scaled up and then pruned back to the budget, with the goal of using available hardware more effectively. Post-training quantization, such as FP16, can be combined with ZeroBN; the reported effect is even lower latency and higher accuracy under the same latency constraint.

The reported experiments are centered on a 34 ms latency constraint. On the NVIDIA Jetson Nano with ImageNet-100, GoogLeNet is reduced from 40.32 ms to 34 ms with only 0.14\% accuracy reduction, and when coupled with quantization the drop becomes 0.04\%. On the NVIDIA Jetson TX2, VGG-19 is compressed from 119.98 ms to 34 ms with a 0.5\% accuracy improvement, and GoogLeNet is scaled up from 20.27 ms to 34 ms with a 0.78\% accuracy improvement. The framework is also reported to incur only 1–2\% training overhead per epoch relative to standard training and to reach the latency goal in one single training run, whereas other methods often require 6–7 iterative retrials.

Several interpretive issues follow from these results. First, “ZeroBN” in this sense is not merely a modification of BN normalization statistics; it is a dynamic architecture learning mechanism using BN parameters as structured pruning variables. Second, the method is not equivalent to irreversible channel pruning because recovery training explicitly allows reactivation. Third, the framework is designed for real hardware latency rather than surrogate efficiency metrics, which is why it is compared against Network Slimming, SFP, FPGM, PGMPF, OTO, EfficientNet Scaling, and LUT or simulator-based methods. The official implementation is stated to be open-sourced at https://github.com/ntuliuteam/ZeroBN.

Taken together, the two major usages of ZeroBN describe a family resemblance rather than a single formalism. In ZOBNN, the term centers on zero-overhead dependability through deliberate quantization of non-binary parameters in BNNs (Ghavami et al., 2024). In Zerorized Batch Normalization, it centers on zeroization and recovery of BN parameters for one-shot, hardware-aware architecture adaptation under strict latency constraints (Huai et al., 8 Jul 2026). The common thread is deployment-centric optimization for edge settings, but the operational mechanisms, target metrics, and mathematical objects involved are different.