The research, led by Marc Ordoñez and Franyell Silfa together with Antonio González, targets state-of-the-art binary models such as ReActNet and PokeBNN, which have recently closed the accuracy gap with full-precision networks designed for edge devices. ReActNet, for instance, achieves a top-1 accuracy of 69.4 percent on the ImageNet benchmark, within striking distance of the 72 percent obtained by MobileNet V2, a convolutional network explicitly tailored to constrained hardware. But the storage story is less flattering: ReActNet requires 29 million bits, actually slightly more than the 27 million bits of its full-precision rival. The Barcelona group observed that most of this footprint comes from two places: the 3 by 3 binary convolutional kernels, which account for 55.6 percent of ReActNet’s storage, and the output layer, which consumes another 36.3 percent. In PokeBNN the imbalance is even more dramatic, with the output layer alone representing 47.1 percent of the entire model.

The first key insight emerged from a simple frequency analysis. In a binarized 3 by 3 kernel, each channel consists of nine one-bit values, so there are exactly 512 possible bit sequences. In theory, all of them could appear with equal likelihood. In practice, the distribution is heavily skewed. For ReActNet, the 16 most common sequences account for 46 percent of all sequences in a representative block, and in some layers just 32 individual sequences cover more than half of everything. Across all blocks, the 256 most frequent sequences reach up to 92 and 96 percent of usage in the two models. Sequences composed entirely of zeros or ones alone represent a quarter of the total. This long-tailed distribution is precisely the kind of statistical structure that compression schemes exploit best.

To capitalize on it, the researchers designed a variable-length encoding based on a deliberately simplified Huffman tree. Rather than building a full Huffman tree with hundreds of nodes, which would demand complex decoding hardware or optimized lookup tables, they limited each tree to just four nodes. The first bits of each encoded sequence identify which node, and therefore which decode table, it belongs to, while the remaining bits address the table directly. For the chosen allocation, codeword lengths of 6, 8, 9, and 12 bits emerge, with the shortest codes reserved for the very-high-frequency tier. The result is that nearly half of all sequences can be stored using only 6 bits instead of the canonical 9. On its own, this Huffman encoding compresses the binary kernels by roughly 1.2 times.

The team then added a second, more aggressive optimization. They noticed that many rarely used bit sequences could be replaced by more common ones that differ by only a single bit, corresponding to flipping just one weight, without any measurable impact on network accuracy. Using a greedy nearest-neighbor heuristic based on Hamming distance, each uncommon sequence is paired with its most frequent one-bit-different counterpart, and the replacement is accepted only if validation accuracy remains unchanged. This conservative substitution raises the frequency of the top 32 sequences to 65 percent on average, pushing the kernel compression ratio to 1.32 times for ReActNet and 1.3 times for PokeBNN. Because the scheme works entirely offline and the network’s original accuracy is preserved, the transformation is essentially free.

The output layer posed a different and thornier challenge. To maintain competitive accuracy, binary networks conventionally store their final fully connected classifier weights as 16-bit floating-point values, which magnifies storage and slows execution. The Barcelona group found that applying traditional symmetric linear quantization to this layer severely damages accuracy, even at high bit widths of 16 bits, because the weight distribution is heavily skewed: more than 90 percent of ReActNet’s output weights are negative, while more than 70 percent of PokeBNN’s are positive. Symmetric quantization wastes half of its representable range on values that barely exist. Clipping the outliers, a common remedy, is also harmful; in ReActNet, treating 2.5 percent of the largest weights as outliers and clipping them drops accuracy by 1.2 percent even at 16-bit precision.

The solution, which the authors call split quantization, divides the output-layer weights into three regions: normal values clustered around the mean, positive outliers, and negative outliers. The boundary is set systematically using the standard deviation of the weight distribution, with a constant k of 1.5 classifying roughly 12 percent of weights as outliers. Normal values receive a very small bit-width, while outliers are quantized with a symmetric range split into separate positive and negative intervals, each with its own quantization step. The weight distribution is centered by shifting it by the group average before rounding, and an extra half-step shift corrects a subtle rounding error that becomes significant at low precision. Two bit-masks, one marking outliers and one marking their sign, allow the hardware to route each value to the correct accumulator during the dot product. Operating at 8 bits for normal values and 4 bits for outliers, split quantization compresses the output layer by 2.8 times with no accuracy loss at all, and by up to 4.9 times for PokeBNN with accuracy loss below 1 percent. The scheme is entirely post-training, requiring no retraining or fine-tuning of the published models.

Software alone, however, could not deliver these gains. When the researchers implemented kernel compression on the ARM Cortex-A9 processor of their test board, the overhead of decoding and repacking the variable-length sequences made execution 1.47 times slower than the uncompressed baseline. Similarly, split quantization on the CPU suffered a 1.3 times slowdown because standard instruction sets cannot efficiently handle bit-widths below 8 bits. The team therefore extended a previously proposed FPGA accelerator, based on the FracBNN design, with dedicated hardware. A new decoding unit streams compressed sequences from main memory, parses the node prefix, reads the sequence length from a small table, and retrieves the uncompressed 9-bit value from a 1-kilobyte BRAM-backed scratchpad, all while overlapping the next memory fetch with ongoing computation. A packing unit then channel-packs the decoded sequences into 128-bit registers for the convolution engine. For the output layer, the matrix-vector multiplication engine was extended with mask buffers and a runtime quantization unit for the input activations, which themselves can be compressed by up to 6 times without affecting accuracy.

The complete system was synthesized for a PYNQ-Z1 board containing a Xilinx Zynq-7000 SoC and evaluated end-to-end on ImageNet. The results are striking. The output layer, which the analysis showed accounts for nearly 50 percent of storage and 60 percent of execution latency in these models, runs 13 to 55 times faster depending on the chosen bit-width, thanks to fewer bytes fetched from memory and smaller multipliers in the vector engine. End-to-end speedups of 2.2 times for ReActNet and 2.3 times for PokeBNN were achieved, while combined kernel compression and output-layer quantization reduced overall model storage by 1.55 and 1.51 times respectively, without any accuracy loss. The added hardware is remarkably frugal: the decoding unit requires only about 1.5 kilobytes of internal storage, and the modified matrix-vector unit uses just 12 to 27 percent of the board’s lookup tables, far less than an equivalent floating-point implementation would demand.

The implications reach well beyond image classification. The researchers are careful to note that split quantization is most beneficial when the output layer represents a large fraction of the model, as in tasks with many classes like ImageNet’s 1000 categories; for a 200-class classifier the projected overall compression drops to about 1.32 times, and for a 10-class task to 1.26 times, with the remaining benefit coming almost entirely from kernel compression, which remains effective regardless of class count. Conversely, in large-vocabulary applications such as face recognition or speech recognition, the gains would grow. Because both techniques reduce the bytes moved per inference, energy per inference is expected to improve roughly in proportion to the 2.2 times latency gain, even though peak power remains dominated by the unchanged convolution engine. As edge devices proliferate and neural inference migrates from data centers to doorbells, hearing aids, and medical sensors, this work suggests that the humble binary network, properly compressed, may finally deliver on its founding bargain: full-precision accuracy at one-bit cost.

Subject of Research: Enhancing BNN storage and performance requirements via efficient quantization and variable encoding

Article Title: Enhancing BNN storage and performance requirements via efficient quantization and variable encoding

Article References: Enhancing BNN storage and performance requirements via efficient quantization and variable encoding. (n.d.). https://doi.org/10.3389/fhpcp.2026.1853655

Image Credits: AI Generated

DOI: 10.3389/fhpcp.2026.1853655

Keywords: Enhancing, storage, performance, requirements, efficient, quantization, variable, encoding, scientific research