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

The core insight is deceptively simple: a method that is valid in one review setting may be invalid in another. A fully cold-start project with no validated trace links, a project with a partially validated trace matrix, a review constrained by a fixed effort budget, and an analyst-in-the-loop session do not expose the same information. They also do not require the same operating assumption. A technique that exploits validated historical links should never be compared as if it were a cold-start method. Likewise, a procedure that updates its rankings after analyst feedback is fundamentally different from a static ranking produced before review begins. TraceRank makes these assumptions explicit through a deterministic configuration rule: each recovery mode is enabled only when the evidence it requires is actually available under the declared task setting.

Technically, TraceRank organizes its evidence through a trace evidence hypergraph, a representation that connects requirements, requirement facets, candidate artifacts, artifact roles, evidence sources, validation states, and evidence-status descriptors. Requirement facets capture local parts of a requirement, such as actions, entities, conditions, constraints, or validation concerns, while artifact-role nodes describe implementation responsibilities like controller, interface, database, validator, or graphical user interface components. Evidence-source nodes record the type of support behind each candidate link, whether lexical retrieval, semantic matching, grouped-ranker support, dependency evidence, validated-link evidence, or analyst feedback. A trace-set hyperedge connects each requirement to its facets, candidate artifacts, and evidence bundle. This structure keeps heterogeneous support signals visible without forcing them all into one uninterpreted ranking score, which the authors argue is essential for review support rather than mere retrieval.

The cold-start foundation relies on a 42-dimensional candidate feature vector built from eight normalized retrieval and fusion scores, including TF-IDF, BM25, LSI, segment-maximum TF-IDF, specificity-adjusted TF-IDF, simple average, and reciprocal-rank fusion, together with ten scalar lexical, identifier, length, specificity, and score-dispersion features and rank-based features for each score family. Three training-only supervised models are fitted on these inputs: a class-balanced Logistic learning-to-rank model, a grouped LightGBM ranker, and a grouped XGBoost ranker. A conservative recovery-policy gate then accepts an objective-specific fusion only when its calibration utility improves by at least one percent and its critical recall measure does not decrease. On the frozen seed-42 split, this yields XGBoost for LibEST, LightGBM for SMOS, ranker-aware fusion for eANCI and iTrust, and an accepted objective-specific fusion for eTour. The best cold-start extension is a semantic-structural rescue that blends word-level and character-level semantic signals with structural cues such as direct artifact-name mentions, interface and implementation cues, package proximity, and artifact-name overlap, with calibrated weights selected per dataset.

The algorithmic centerpiece is the Validated Trace Responsibility Graph, or VTRG, enabled only when a project contains a partially validated trace matrix. The idea is that validated links reveal trace responsibility neighborhoods: requirements similar to a new requirement may share related artifacts, and artifacts that co-occur in validated trace sets may participate in the same implementation responsibility. VTRG constructs requirement-neighbor scores using label-free text similarity, builds artifact co-trace responsibility weights from validated trace sets, selects weak anchor artifacts from the cold-start base score, and optionally fits a latent trace-neighborhood representation through truncated singular value decomposition with at most eight components. The final score is a calibrated blend of cold-start and partial-trace evidence, with the globally selected Top-30 configuration using neighbor depth K equal to 10, anchor depth M equal to 10, and evidence weights of 0.45, 0.25, 0.20, and 0.10 for the base, requirement-neighbor, co-trace, and latent components respectively. Test labels are never used for weight selection, graph construction, or scoring.

The empirical evaluation spans five established traceability benchmark datasets: eTour, iTrust, SMOS, eANCI, and LibEST, totaling 447 requirements, 511 artifacts, 2,409 true links, and 51,407 candidate pairs. The primary point estimates use one frozen requirement-level 60/20/20 train/calibration/test split with random seed 42, ensuring that candidate pairs from the same requirement always remain in the same partition. In the cold-start setting, the best retained configuration recovers 404 of 501 true links at Top-30, achieving a LinkRecall@30 of 80.6 percent and completing 33 of 60 held-out requirements, compared with 381 links and 27 complete requirements for the base policy. Classical baselines fare considerably worse: TF-IDF recovers 293 links, BM25 only 252, and LSI 301, while the strongest learned ranker, LightGBM, recovers 380 links and is statistically indistinguishable from the base policy under paired requirement-level analysis.

The partial-trace results are striking. Under the partial-trace assumption, VTRG recovers 465 of 501 links, a LinkRecall@30 of 92.8 percent, completes 43 of 60 requirements, and reduces severe misses to just 12, where a severe miss is a true link ranked beyond the review depth plus a frozen boundary window of 10. Across the same five requirement-level split seeds used for the split-robustness analysis, VTRG achieves a mean LinkRecall@30 of 91.3 percent with a standard deviation of 4.0 percentage points and a mean CompleteRate@30 of 76.5 percent with a standard deviation of 8.1 percentage points. Dataset-level heterogeneity is substantial: LibEST is essentially saturated, SMOS gains most from VTRG, recovering 220 of 233 links with only one severe miss, eTour benefits from both rescue and VTRG, eANCI remains harder for complete recovery, and iTrust shows a smaller gain. The authors are careful to note that this gain is interpreted only under the partial-trace assumption; VTRG is not a cold-start ranker.

Selective validation makes the partial-trace setting more practical when analyst time is limited. The study evaluates validation budgets from zero to 100 percent of calibration requirements, using selection strategies including random, uncertainty-based, density-proxy, centrality-based, diversity-based, and VTRG-active selection. Training links alone already provide strong partial-trace evidence, recovering 458 of 501 links, and selected validation can approach the full-calibration result: 40 percent diversity-based selection reaches 465 links with a LinkRecall@30 of 92.8 percent, and 60 percent VTRG-active selection reaches 466 links at 93.0 percent. Paired hierarchical requirement-cluster bootstrap intervals with 10,000 replicates quantify uncertainty, treating the 60 positive requirements rather than the 501 nested links as the independent review units. The supported conclusion is that selected validation can approach full calibration, not that every strategy or budget is superior.

Zero-shot neural representation baselines strengthen the evidence that the reported results are not merely an artifact of comparing against classical lexical retrieval. On the identical seed-42 test requirements, CodeBERT recovers 192 of 501 links, GraphCodeBERT 203, UniXcoder 241, and SBERT-MPNet 265, all scored by cosine similarity of unit-normalized embeddings without trace labels or task-specific fine-tuning. The reproducible base recovery policy on the same requirements recovers 381 links, and the semantic-structural rescue recovers 404. The authors explicitly bound this comparison: TraceBERT itself was not executed, and these frozen representation baselines do not establish a universal ceiling for fine-tuned neural traceability models or LLM-based recovery. Archived diagnostic families, including multi-view neural semantic closure, fielded passage retrieval, pseudo-relevance feedback, coverage diversification, entity-role graph evidence, and a zero-shot cross-encoder reranker, produce only modest changes relative to the reproducible cold-start configurations.

Perhaps the most consequential contribution is the honest treatment of evidence status. Archived fixed-budget and simulated-feedback outputs record 50 of 60 complete requirements with 483 of 501 links and 48 of 60 with 482 of 501 respectively, but they are retained only as exploratory review-process sensitivity evidence because the originating row-level priority queue and sequential update history are not preserved in the clean archive. They are therefore not treated as confirmatory evidence in the primary conclusions. The results support a configuration-aware interpretation of trace recovery: cold-start, partial-trace, fixed-budget, and feedback-based recovery are different operating settings and should not be interpreted as one universal static ranking problem. For practitioners, the implication is that trace recovery should be treated as review support rather than automatic completion of the trace matrix, with analysts needing to know which evidence supports each candidate link and which requirements deserve deeper inspection. TraceRank supports analyst review, but it does not certify complete recovery or replace analyst judgment.

Subject of Research: TraceRank: configurable review support for requirements traceability recovery

Article Title: TraceRank: configurable review support for requirements traceability recovery

Article References: Alsawalqah, H., Abadleh, A., Alshamaileh, Y., Al-Tawil, M., Aljarah, I., & Alaydaa, M. S. (2026). TraceRank: configurable review support for requirements traceability recovery. Frontiers in Computer Science, 8, Article 1960635. https://doi.org/10.3389/fcomp.2026.1960635

Image Credits: AI Generated

DOI: 10.3389/fcomp.2026.1960635

Keywords: TraceRank, configurable, review, support, requirements, traceability, recovery, scientific research