acceptodds
Under review as a conference paper at ICLR 2027

Pairs or Bits: Two Repairs for the Binarized Convolution

Abstract

A binarized convolutional network computes each unit as a weighted count of input bits, one-bit activations against ternary weights. It deploys as a multiplier-free circuit and pays in accuracy, almost all of it charged to the activations and not the weights. Two repairs act inside the unit. One widens the activation to two or three bits, which widens every accumulator and the memory between layers. The other keeps one bit and lets each unit multiply its inputs in pairs as well as summing them, for four integer multiplies. The literature has developed the first. We develop the second and price both on what a circuit carries, logic area and the activation bits each layer passes on. We prove that the pair unit still compiles exactly, that neither repair's class contains the other, and that a rank condition on the pair-coefficient matrix, minimized over its diagonal, decides which degree-2 polynomials a rank- unit realizes. Under one recipe for every model the pair term returns of the that binarization costs on CIFAR-10 at equal parameters, and at equal logic. On that dataset and four more it returns between and while a second activation bit returns between and , so which repair pays depends on the task. On two of the five the pair term leads while storing a third of the activation bits where the bit stores twice as many. It also reaches its plateau in a little over half the epochs, because a pair term gives the integer its threshold compares far more values to take. Neither the stored bits nor the speed depends on the learning rate. The accuracy gap does, and a tuned baseline closes it. Where activation bits are affordable, add them. Where memory or interconnect binds rather than arithmetic, add the pair term instead.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
binarized neural networks, one-bit activations, multiplicative interactions, efficient inference

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_G5PVOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a low-rank degree-2 convolutional unit that uses pairwise interactions to improve binarized CNNs without increasing activation precision. The authors provide theoretical results on expressive power and exact integer compilation for one-bit inputs. Experiments on 5 datasets show accuracy gains of 1.46~2.11 under matched parameter budgets, with lower activation storage and faster convergence. The paper also compares this approach with increasing activation precision and examines their hardware cost trade-offs.

Critical strengths
  1. The rank characterization and exact compilation results provide a solid theoretical foundation for the proposed method. The authors also clarify how pairwise interactions can improve expressiveness without increasing activation precision.
  2. The paper compares models under similar parameter and estimated logic budgets across 5 datasets, supported by several ablations. The proposed method achieves consistent accuracy gains of 1.46~2.11 while using roughly 1/3 of the baseline's activation storage. The analysis of faster and more stable training also provides useful insights.
Critical weaknesses
  1. Hardware costs are based on analytical estimates rather than actual FPGA synthesis. The experiments also do not evaluate settings where activation memory is a limiting factor. Therefore, the practical benefits in terms of hardware resources, latency, and energy efficiency remain uncertain.
  2. On CIFAR-10, the reported 2.11 improvement decreases to 0.38 after learning rate tuning, with overlapping seed results. Although longer training at the shared learning rate still shows a 1.5 improvement, it remains unclear whether the advantage persists when both methods are fully trained and independently tuned.
Questions for authors
  1. Can the authors provide FPGA synthesis results to validate the estimated hardware costs, particularly logic and memory usage, multiplier utilization, and latency?
  2. Does the accuracy improvement remain when both methods are trained to convergence with independently optimized learning rates?
1 comment

We thank the reviewer for the positive assessment and the constructive feedback, and for acknowledging the strengths: "a solid theoretical foundation" (Strength 1), and "consistent accuracy gains" at "roughly 1/3 of the baseline's activation storage", with "useful insights" on training (Strength 2). The reviewer's summary raises no concern beyond W1 and W2. Synthesis of two layers is done (see [W1, Q1]). Compared at each model's best learning rate within Table 8's grid, the lead falls to 0.38 pp (see [W2, Q2]). In the revised PDF, revised and added text is shown in color.

[W1, Q1] Do the estimated hardware costs hold up in synthesis? Yes for the adder-tree logic, which synthesis reproduces. The multiplier costs more than the cost model assumed, which raises total logic to at least 1.175×1.175\times the baseline's against the predicted 1.028×1.028\times, and placement adds a cost in clock and latency. The adder tree is 2.82×2.82\times and 0.99×0.99\times the baseline's logic at the two synthesized layers, against the predicted 3.00×3.00\times and 1.00×1.00\times. The multiplier's synthesized price is in revised App. F and the reply to 4Uaf [cost model]. Memory needs no synthesis check: it counts the activation bits stored between layers, which the synthesized logic tiles do not contain, so Table 1's count stands. In memory, the pair unit (the degree-2 unit) stores 26 KiB of activations per image against the baseline's 78 (Table 1). In multipliers, it needs 2,560 across the network, and they are intrinsic at these fan-ins: building the products from AND gates would cost 86 times the factored form's logic (new, revised App. F). In clock and latency, placed and routed on a Xilinx Artix-7 (xc7a200t, speed grade -2), seed 0, the pair unit runs at 0.42 and 0.56 of the baseline's clock unpipelined. Pipelining adds registers that split the circuit into stages: the clock is set by the slowest stage, and each output takes several cycles while a new input still enters every cycle. Pipelined, with a register after every popcount and, in the pair unit, after every product as well, it runs at 0.77 and 0.95 of the baseline's clock. At layer 1 its throughput is therefore 95 percent of the baseline's, while an output takes 1.95 and 1.58 times as long (new, revised App. F; table in the reply to q1fS [W2, Q2]).

The pair unit trades added logic and multipliers for smaller activation memory, and where that exchange pays off is not yet measured. No run reaches the regime where memory binds. For the baseline it begins near 229 px inputs, where its largest activation map reaches the size of the weight memory (computed from Table 1's widths). At 64×6464 \times 64, the nearest measured point, the pair unit leads at the shared learning rate (reply to q1fS [W2, W3, Q4]). Energy is not measured. Revised App. F carries the synthesis and place-and-route results and the multiplier's synthesized price; see also the reply to 4Uaf [cost model].

[W2, Q2] Does the improvement remain when both are converged and independently tuned? Within Table 8's grid, the paper's tuning study, the pair unit leads at every rate, at 4e-3 by 0.17 pp, inside seed noise (Table 8). Converged at the shared rate, it leads by 1.50 pp (App. G). We have now also run the pair unit at 5e-4, the one rate the submitted Table 8 left blank for it: it reaches 86.76 ±\pm 0.24 over three seeds (new, revised App. G). Every other cell of Table R1 is from Table 8.

Table R1. CIFAR-10 test accuracy (%), mean of three seeds, at each learning rate (Table 8, revised App. G).

learning rate (Table 8)5e-41e-3 (shared)2e-34e-3
baseline (degree 1)83.7484.8485.7786.67
pair unit86.7686.9687.0586.84
lead at the same rate+3.02+2.11+1.28+0.17

What tuning shows is that the pair unit needs less tuning, not that it reaches a higher ceiling. Compared at each model's best rate, 87.05 against 86.67, the lead is 0.38 pp, inside seed noise. The pair unit at its weakest rate, 86.76, is level with the baseline at its best, and across the four rates the baseline's accuracy spans 2.93 pp, the pair unit's 0.29 (table above). The baseline's best accuracy has to be found by searching the learning rate; the pair unit's does not. Even at its best rate the baseline still gains 4.28 pp over its last 60 epochs, more than App. G's convergence criterion allows, so the 0.38 pp is an upper bound. App. G states that "the paper claims no accuracy gap over a tuned baseline".

What tuning does not change is memory: the baseline still stores three times the activations. For a degree-1 control at equal stored bits, see our reply to q1fS [W2, Q3]. Revised App. G carries the per-rate convergence numbers; see also the replies to 4Uaf [Q2] and q1fS [W1, Q1].

Reviewer_4UafOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper focuses on the costs incurred by the deployed BNN circuit rather than on accuracy alone. The idea is novel. The manuscript explicitly separates the precision axis from the degree axis, introduces a rank-R degree-2 unit, provides exact folding of BatchNorm and the threshold, and enables integer-circuit compilation. It also conducts matched-parameter and matched-logic comparisons across five datasets. These are valuable contributions. The paper further includes solid reproducibility statements and extensive control experiments. However, the core experimental conclusions are substantially affected by the tuning protocol, the cost model, and the scope of the comparisons, and some claims need to be weakened or strengthened.

Critical strengths

The paper’s research idea is interesting and well motivated. Instead of repairing BNNs only by increasing activation precision, it adds a low-rank degree-2 pair term while keeping one-bit activations. This is attractive for deployment because it preserves the one-bit interface, reduces activation memory, and compiles exactly to integer circuits. Overall, it offers a practical alternative to precision-only repair for BNN deployment.

Critical weaknesses

Q1: The experimental evaluation is seriously inadequate. First, BNN architectures commonly rely on ResNet and MobileNet; the authors should evaluate multiple architectures, preferably including ViT as well. Second, the authors evaluate only on small-scale datasets, which makes the resulting analysis and conclusions unreliable. Results on ImageNet are necessary.

Q2: The main conclusion relies on an unconverged baseline under a shared learning-rate protocol and therefore needs to be recentered.

Q3: The scope of the precision-repair comparison is incomplete, and the conclusion drawn across five datasets is overstated. The two-bit comparison in Section 4.3/Table 4 is conducted mainly on CIFAR-10 and SVHN; the other three datasets include only the one-bit pair comparison and the degree-1 ladder. Appendix A also acknowledges that the two-bit rungs are still improving, meaning that the bit-side results are lower bounds and that both reversals may diminish with a larger training budget.

Q4: The connection between the theoretical results and the rank-4 unit used in the experiments needs to be clarified. Theorem 3.4/Corollary 3.5 establish rank capacity for real-valued factors, but the authors acknowledge that necessity carries over to ternary factors while sufficiency does not.

Q5: End-to-end verification of exact compilation remains insufficient.

Questions for authors

The questions are shown in weakness.

3 comments
AuthorsOpenReview ↗

Part 1/3 (continued in the next comment)

We thank the reviewer for the constructive feedback and for acknowledging the strengths: the idea "is novel" and "interesting and well motivated", with "valuable contributions", "solid reproducibility statements and extensive control experiments", and "a practical alternative to precision-only repair for BNN deployment". The reviewer's summary concern is that the conclusions depend on "the tuning protocol, the cost model, and the scope of the comparisons", and that "some claims need to be weakened or strengthened". The conclusions hold under all three, and the revised PDF adjusts claims in both directions. On the protocol, the claim is strengthened: with training and test converged at the shared learning rate, the pair unit (the degree-2 unit) still leads (see [Q2]). On the cost model, it is narrowed: synthesis confirms the adder-tree cost and shows the multiplier costs more than assumed, so every equal-logic comparison is now scoped to the cost model (see [cost model]). On scope, it is strengthened: the precision grid is complete on all five datasets, and the lead holds with identity shortcuts and on Tiny-ImageNet-200 (see [Q3], [Q1]). Exact compilation is now measured end to end (see [Q5]), and the paragraph that sets the rank by the budget now sits beside the theorem it rests on (see [Presentation]). In the revised PDF, revised and added text is shown in color.

[Q1] Does the advantage hold on other architectures and on ImageNet? It holds at the shared rate, at one activation bit, on every architecture and dataset added during the rebuttal; ImageNet-1k and ViT are not run. For ResNet, we added its defining ingredient, identity shortcuts, to this network, and the pair unit leads by 2.39 pp, 85.41 against 83.02 (new, App. J). This is an upper bound, because the shortcut baseline is the least converged model. For MobileNet, whose depthwise filters have 9 inputs, App. H already measures the degree-2 gain at that fan-in, +9.02 pp with float weights. ViT is not tested, since this paper focuses on the convolutional unit, and we leave it to future work.

For ImageNet, we added Tiny-ImageNet-200, its 200-class 64×6464 \times 64 subset. There the pair unit leads by 0.64 pp at 120 epochs and 0.98 pp at 240 (new, App. J). Only the pair unit has converged at 240 epochs, so 0.98 is an upper bound. We also trained two seeds per model to 480 epochs. Training accuracy rises to 92 to 94 percent, while test accuracy falls for the baseline in both seeds and for the pair unit in one, staying level in the other. Both pair-unit runs score above both baseline runs, and a third seed of each will be added in the final version (new, App. J). New App. J gives each run's convergence state; see also the reply to q1fS [W2, W3, Q4

AuthorsOpenReview ↗

Part 2/3 (continued in the next comment)

[Q2] Does the conclusion rest on an "unconverged" baseline? No: with both models converged in training and test, the pair unit still leads at the shared rate, by 1.50 pp on CIFAR-10 (App. G). Every model trains with AdamW under a cosine schedule (App. G). Convergence is read by App. G's criterion: what a model still gains over its last 60 epochs. At twice the budget both CIFAR-10 models fit the training set, 99.46 and 99.83 percent (new, revised App. G), both meet that criterion on test, and the pair unit leads by 1.50 pp (App. G). On SVHN, KMNIST and Fashion-MNIST both models already meet it at the reported budget, and the pair unit leads on all three (Table 1; edges in [Q3]'s table). On CIFAR-100 neither does at 120 epochs, so its edge is read as an upper bound (App. G).

On tuning, the abstract already scopes the accuracy claim to the shared recipe: "Neither the stored bits nor the speed depends on the learning rate. The accuracy gap does, and a tuned baseline closes it." Of the two remedies for slower convergence, more epochs at the shared rate converge the baseline on CIFAR-10, and the pair unit still leads. On Tiny-ImageNet the baseline still does not meet the convergence criterion at 240 epochs (see [Q1]). A larger learning rate closes the gap, as the abstract says. Compared at each model's best rate within Table 8's grid, the lead falls to 0.38 pp, inside seed noise (Table 8; reply to G5PV [W2, Q2]). Tuning does not make the baseline steadier, though: at 4e-3 its accuracy still moves 0.69 pp per epoch, against 0.25 to 0.35 for every one-bit degree-2 model except the fixed all-ones pair control (App. G). Steadiness also bears on choosing the model to deploy. Whether the stopping epoch is chosen on a validation set or on the test set as its stand-in, the chosen accuracy depends on the epoch. Late in training the baseline moves 0.85 pp per epoch, with single-epoch swings of up to 2.71 pp, against 0.26 and 0.61 for the pair unit (App. G). The baseline's selected checkpoint therefore carries 3.3 times the pair unit's per-epoch movement and 4.4 times its largest single-epoch swing. The revised PDF replaces "unconverged" with each model's measured training and test convergence, keeping "still gaining" only where it is a measured gain. Revised App. G adds the training accuracies and per-rate convergence.

[Q3] Is the precision comparison complete, and is the five-dataset conclusion overstated? It is now complete, and the full grid supports the conclusion as the paper states it, "which repair pays depends on the task". We ran the remaining cells, so all five datasets have the one-, two- and three-bit comparison at matched parameters, three seeds per cell. Each cell of Table R1 is the pair unit's edge over the baseline at that precision: the one-bit column is Table 1, the CIFAR-10 and SVHN two- and three-bit cells are App. A, and the rest are new (Table 11, new App. J).

Table R1. Degree edge in pp, matched parameters, three seeds (Table 11, new App. J).

dataset1 bit2 bits3 bits
CIFAR-10+2.11+0.21+0.09
SVHN+1.71+1.81+1.89
CIFAR-100+2.05+0.13+0.42
Fashion-MNIST+1.46+0.05-0.02
KMNIST+1.59+0.84+0.73

At two bits the edge closes on CIFAR-10, CIFAR-100 and Fashion-MNIST and persists on SVHN and KMNIST, which is the task dependence the conclusion states. The two reversals are a different comparison: the pair term against a second activation bit on the one-bit baseline. On SVHN and KMNIST the pair term returns more (App. A, Figure 4). The reviewer cites App. A's statement that the two-bit rungs were still improving. By App. G's convergence criterion, they have not converged on CIFAR-10 and CIFAR-100. On SVHN and KMNIST, where both reversals are, every model compared meets it, so neither reversal rests on a model still improving (revised App. A). The matched two-bit model of App. A, trained to 240 epochs, agrees. There every model converges, and the pair term still returns more than the second bit: 1.52 against 0.61 pp on KMNIST and 1.64 against 0.46 on SVHN (new, revised App. A). New App. J carries the grid with per-cell convergence status and both cost counts.

[Q4] How does the theory connect to the rank-4 unit? It bounds the rank a ternary unit needs, and the trained unit sits far below both bounds. The proven scope is the one the reviewer states, and Section 3 says so beside the theorem: "Scope. The theorem quantifies over real factors, so necessity transfers to deployed ternary units and sufficiency does not; and it measures the polynomial, not the Boolean function the unit emits." The trained R = 4 is 0.7 percent of the 576 that suffices for every target and far below the 553 almost every target needs (Section 3.2). The unit is therefore used approximately, and its rank is a budget choice, as Section 3.2 states (reply to q1fS [W4]).

[Q5] Is exact compilation verified end to end? Yes, it is now measured. We checked every body activation of the CIFAR-10 pair-unit model over the whole test set. The folded integer threshold reproduces the trained model's output on all 2,129,920,000 binary activations, with zero disagreements and no tolerance (new, revised App. F). The accumulator's integer width is the bound Prop. 3.7 proves, and revised App. F carries the check.

[cost model] Does the cost model hold up? Its main cost item, the adder tree, does; synthesis shows that the one item it underestimated, the multiplier, costs 9 to 14 times what it assumed. The adder tree matches the prediction at both synthesized layers (reply to q1fS [W2, Q2]). A multiplier, however, costs 9 to 14 times the 45 LUT-equivalents App. F assumes. Re-synthesized in LUTs it takes 202 and 309 physical LUTs, about 421 and 644 LUT-equivalents once calibrated on the adder tap (new, revised App. F). At that multiplier price, the matched-parameter pair-unit model needs at least 1.175×1.175\times the baseline's logic, against Table 2's 1.028×1.028\times, in exchange for a third of the stored activations (revised App. F). The matched-logic pair of models moves from 1.011×1.011\times by the cost model (Table 2, 0.410 against 0.406) to at least 1.238×1.238\times. The synthesized multiplier price lies inside App. F's own stress case, a pessimistic multiplier price under which the matched-logic gap stays near 1.8 pp (App. F). The revised PDF therefore keeps every comparison, scopes each matched-logic one to the cost model, and states the measured price in Section 3.5 and App. F. See also the replies to q1fS [W2, Q2] and G5PV [W1, Q1].

[Presentation] How is the presentation revised? We revised the manuscript thoroughly for clarity of presentation. The revised PDF moves Section 3.2's rank-to-budget paragraph to after Corollary 3.5, beside Theorem 3.4, and states where Lemma 3.3 and Corollary 3.5 are used. It also states each claim where it holds: every matched-logic comparison names the cost model, Section 2.1 says which logic figures are synthesized, and Appendix A names which results come from the uniform ladder and which from the matched models. App. J collects the new controls and datasets.

Reviewer_q1fSOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper asks how to recover the accuracy lost when a convolutional network is binarized to ternary weights and one-bit activations. The usual fix is to give the activations more bits. The authors propose a second route: keep one-bit activations and add a low-rank pairwise product term to each unit, so that a unit can respond to two inputs being active together. They show three things in theory. The new unit still compiles exactly to an integer circuit. The two fixes can express different functions, and neither contains the other. A rank condition determines which degree-2 polynomials a unit with a given number of products can represent. The experiments compare the two fixes in a single codebase on several small image datasets, pricing each model by logic area and by the activation bits passed between layers. The authors conclude that the product term pays off where activation memory or interconnect is the bottleneck, and extra bits pay off otherwise. My overall impression is that the framing is useful and the work is careful, but the claimed deployment advantage has not yet been shown at a scale or in a setting where it would matter.

Critical strengths
  1. The paper does not judge the two repairs by accuracy alone. It prices each model on two costs that a deployed circuit actually carries, logic area and the activation bits passed between layers, and compares adding bits against adding a product term on that basis. This is a useful perspective for hardware-oriented work on binarized networks. Appendix F makes the point clearly: the two matched models are nearly identical in parameters, compute and logic, and differ only in stored activation bits, by a factor of three.
  2. The path from a trained model to an integer circuit is handled with care. The BatchNorm fold covers both negative and zero scales, and the accumulator width has an explicit bound. The factored and pair forms are also verified to agree layer by layer on real activations. I went through the main proofs and the key numbers and found no errors.
  3. The control experiments rule out several alternative explanations, including the parameter difference, fixed pairings, a fully integer readout, a deeper baseline and longer training. The authors also report results that go against their own story, such as the gain turning negative once the activation range is learnable. Explaining training stability through collision probability, that is, through how coarsely the thresholded integer is resolved, is a fresh idea.
Critical weaknesses
  1. The authors attribute the faster and steadier training of the degree-2 unit to collision probability, but the evidence for this mechanism is thin, since it rests on a correlation across only four configurations. A model with float weights and one-bit activations has an almost continuous pre-activation, yet it scores the same as the ternary-weight model (84.69 vs 84.84). In the float-weight grid of Appendix H, the degree-2 unit still gains 4.38 pp. Resolution therefore cannot explain the accuracy gain, and the paper never tests directly whether it explains stability. It also does not separate whether the gain comes from capacity or from optimization.
  2. The deployment advantage cannot be attributed to the product term, and it has not been validated. Activation storage drops to one third because matching parameters makes the network three times narrower, and there is no control that is equally narrow at the same parameter count but has no product term. At the scale studied, activation storage is far smaller than the roughly 1.2 MiB of weight storage, and the authors acknowledge it is not a bottleneck. Logic area comes only from an analytical model with assumed costs, and no synthesis results show how the added multipliers affect latency or throughput.
  3. The experimental scale and the baselines are weak. All results come from one custom five-block network on small datasets with inputs around 32×32. The degree-1 baseline reaches only 84.8% on CIFAR-10 and uses none of the common BNN training techniques that could still be folded into an integer threshold. The one-bit degree-2 model also beats the float reference on three datasets, which suggests the float reference itself is undertrained.
  4. The theory is only loosely connected to the experiments. Theorem 3.4 concerns the rank needed for exact representation, but the trained R = 4 is about 0.7% of that rank, and in practice R is set by the budget. The only genuinely new element is the observation that the diagonal can be chosen freely. The example in Prop. D.4 is equivalent to a linear threshold on the popcount, which a degree-1 unit already computes, so it does not show what the product term adds.
Questions for authors
  1. A model with float weights and one-bit activations has an almost continuous pre-activation. How much does its accuracy fluctuate per epoch late in training? If it is as unstable as the ternary baseline, can collision probability still explain the stability?
  2. Can you synthesize at least one layer on a specific FPGA and compare the two units in resource usage, clock frequency, latency and throughput?
  3. Can you add a degree-1 control with the same parameter count and a width of about 64 but no product term, for example by using larger kernels? This would separate the contribution of the product term from that of narrowing the network.
  4. Do the accuracy and storage advantages of the product term still hold where activation storage is genuinely tight, such as with high-resolution inputs or an ImageNet subset, and against stronger integer-compatible baselines?
3 comments
AuthorsOpenReview ↗

Part 1/3 (continued in the next comment)

We thank the reviewer for the constructive feedback and for acknowledging the strengths: "the framing is useful and the work is careful" (summary), "a useful perspective for hardware-oriented work on binarized networks" (Strength 1), the integer path "handled with care" with proofs and key numbers showing "no errors" (Strength 2), and controls that "rule out several alternative explanations" (Strength 3). On the summary concern about the "deployment advantage" at "scale", the advantage is an exchange: the pair unit (the degree-2 unit) stores a third of the activation bits and pays for it in added logic and multipliers. The narrower network gives the saving, and the product term keeps the accuracy at that width (see [W2, Q3]). Synthesis confirms the adder-tree logic and shows that the multiplier costs more than the cost model assumed (see [W2, Q2]). The exchange is expected to pay off where activation memory is the limiting resource, at larger inputs than trained here, because the logic ratio stays fixed while the saving grows with the feature maps. At the largest inputs measured, the pair unit still leads at the shared learning rate (see [W2, W3, Q4]). In the revised PDF, revised and added text is shown in color.

[W1, Q1] Does resolution explain the steadier training, and is the gain capacity or optimization? Resolution explains the steadier training among ternary-weight units but not across weight types, and the two models differ in optimization, not in capacity to fit the training set. The float-weight test the reviewer proposes in Q1 shows the first part. A float-weight one-bit unit resolves its threshold input more finely than the pair unit, at collision probability 0.00002 against 0.00063 (new, revised App. B). Yet late in training its accuracy moves 0.74 pp per epoch, close to the baseline's 0.85 (new, revised App. B). Resolution therefore tracks steadiness only among ternary weight units, where the correlation is 0.86 (App. B). The revised abstract, Section 4.2 and App. B state that scope. The paper ties resolution to the steadier training, not to the accuracy gain, so App. H's +4.38 does not test it.

On capacity, neither model is short of it. Ternary weights with float activations fit the training set at 100.00 percent (new, revised App. G) and match the float reference, 89.60 against 89.56 (App. F). At twice the budget both one-bit models fit it, at 99.46 and 99.83 percent (new, revised App. G). What separates the two is optimization. The pair unit reaches 95 percent of its plateau at epoch 28 against the baseline's 49, and at 26 against 47 when each runs at its own best rate (Section 4.2, App. G). Late in training its accuracy moves 0.26 pp per epoch against 0.85 (App. G). The gradients are not what differ: their per-layer norms are similar across degrees (App. B). What differs is the forward integer: in the pair unit far fewer outputs flip together when it crosses its threshold (App. B). Revised App. B and G carry the float-weight results and the training fits; see also the replies to 4Uaf [Q2] and G5PV [W2, Q2].

[W2, Q3] Is the gain the product term or a narrower network? It is the product term, as the control the reviewer specified in Q3 shows. That equal-width control is degree 1 at width 64 with a larger kernel, as the reviewer suggested, here 9×99 \times 9. It matches the pair unit's width, parameter count (5,105,546 exactly) and activation memory, but lacks the product term. Its larger kernel raises the first block's fan-in from 216 to 1,944 (new, App. J). Without the product term, accuracy at the shared rate drops from 86.96 (Table 1) to 79.63 ±\pm 0.26 (new, App. J). The gap stays when both are trained to convergence at twice the budget: 80.53 ±\pm 0.09 (new, App. J) against 87.42 (App. G). Tuning does not close it either: within Table 8's learning-rate grid the control gains only 0.40 pp, reaching 80.03 ±\pm 0.56 at 4e-3, while the pair unit at its best rate leads it by 7.02 pp (new, App. J). That lead is an upper bound, because the control has not converged at 120 epochs. Spending the same parameters on width instead gives 84.84 (width 192, Table 1), and on depth 85.93 (depth 7, width 181, App. H); both are below the pair unit. See also the reply to G5PV [W2, Q2].

AuthorsOpenReview ↗

Part 2/3 (continued in the next comment)

[W2, Q2] Does synthesis support the analytical cost, with latency and throughput? Yes for the adder-tree logic, which matches the cost model at the two synthesized layers. The multiplier costs more than the cost model assumed, and the pair unit pays in clock and latency. Placed and routed on a Xilinx Artix-7 (xc7a200t, speed grade -2, Vivado 2025.2), the unpipelined pair unit runs at 0.42 and 0.56 of the baseline's clock at the two layers. Pipelining adds registers that split the circuit into stages: the clock is set by the slowest stage, and each output takes several cycles while a new input still enters every cycle. Pipelined, with a register after every popcount and, in the pair unit, after every product as well (2 and 3 cycles), it runs at 0.77 and 0.95 of the baseline's clock. At layer 1 its throughput is therefore 95 percent of the baseline's, while each output takes 1.95 and 1.58 times as long to arrive (new, revised App. F).

Table R1 gives yosys 0.70 synthesis for the Xilinx 7-series family (6-input LUTs, DSP48), on no specific part. Each row is one 16-channel output tile at one spatial position, from the trained seed-0 CIFAR-10 models A1d1R0w192 (baseline) and A1d2R4w64 (pair unit).

Table R1. Synthesis of one 16-channel output tile at one spatial position, yosys 0.70, Xilinx 7-series, seed-0 CIFAR-10 models (the synthesis table of revised App. F).

layerunitfan-inLUTDSP48logic depth
0baseline (degree 1)2163,317016
0pair unit (degree 2)21628,1106436
1baseline (degree 1)1,72826,731022
1pair unit (degree 2)57679,4086432

The baseline deploys twelve such tiles per layer and the pair unit four, so the pair unit's logic is 2.82×2.82\times and 0.99×0.99\times the baseline's (synthesis, revised App. F), where App. F's cost model predicts 3.00×3.00\times and 1.00×1.00\times. Layer 1 is at parity by construction. The baseline is three times as wide, so it has three times as many units, each reading three times as many inputs: nine times the adder taps. The pair unit makes up the same factor with nine popcounts per unit, 2R+1 at R = 4. Neither ratio grows with input size, since both are fixed by width.

What synthesis adds is the true price of the multiplier, which is intrinsic at these fan-ins. Trained pair matrices are 75 to 77 percent dense, so building the products from AND gates would cost 86 times the factored form's logic (new, revised App. F). Priced at its synthesized cost, the multiplier raises the network to at least 1.175×1.175\times the baseline's logic, the ratio Table 1's caption now states (revised App. F; reply to 4Uaf [cost model]).

Table R2 gives the same seed-0 tiles placed and routed. Each clock is the fastest the routed design meets, 1 / (target period minus worst slack), from runs targeting 10 ns unpipelined and 4 ns pipelined. The layer-0 baseline met the 10 ns target, which gives only a floor on its clock, so its unpipelined row is from a 5 ns run. Each tile produces one output position per cycle, so its throughput is its clock. Routed LUT counts move with the clock target and with how the tool maps multiplies. At layer 0, Vivado builds the pair unit's 64 multiplies from LUTs rather than DSP48 blocks, so its DSP48 count there is 0. The routed LUT ratios are therefore 2.89 and 0.86 unpipelined and 2.92 and 1.05 pipelined, and the logic ratios above stay on synthesis, where both units map multiplies the same way (revised App. F).

Table R2. The Table R1 tiles placed and routed on an Artix-7 with Vivado 2025.2, seed 0; latency in cycles and ns (the place-and route table of revised App. F, whose third, retimed setting lowers the pair unit's clock at both layers).

settinglayerunitLUTFFDSP48clock (MHz)latency
unpipelined0baseline3,4653210109.21 cycle, 9.2 ns
0pair unit30,020856046.01 cycle, 21.7 ns
1baseline25,2361,783072.41 cycle, 13.8 ns
1pair unit64,9642,0286440.51 cycle, 24.7 ns
pipelined0baseline3,4565590123.52 cycles, 16.2 ns
0pair unit30,2793,359095.23 cycles, 31.5 ns
1baseline23,3611,978073.62 cycles, 27.2 ns
1pair unit73,6013,4926469.83 cycles, 43.0 ns

Latency is now measured directly instead of estimated from logic depth. Unpipelined, the routed pair unit takes 2.37 and 1.79 times as long per output, against logic-depth ratios of 2.25 and 1.45 in synthesis, so synthesis understates the latency cost at layer 1 (revised App. F). These figures cover the first two of the five blocks; the other three remain modeled. See also the reply to G5PV [W1, Q1].

[W2, W3, Q4] Does the advantage hold where storage is tight, at larger scale, and against stronger baselines? At the largest inputs measured it holds at the shared rate, but no run reaches the regime where activation storage is tight, and no stronger integer-compatible baseline was run. As App. F states, activation storage is small at this scale, 78 KiB against 1.20 MiB of weights (Table 1). The largest single activation map reaches the size of the weight memory only near 229 px inputs for the baseline and 400 px for the pair unit, larger than any run here (computed from Table 1's widths).

The nearest measured points are 64×6464 \times 64 inputs. On CIFAR-10 at that size, the pair unit leads both the wide baseline and the equal-width control, 83.65 against 79.27 and 82.48 (new, App. J). Its lead over the control narrows, though, from 7.33 pp at 32×3232 \times 32 to 1.17 (new, App. J). On Tiny-ImageNet-200, also 64×6464 \times 64, the pair unit leads the wide baseline by 0.98 pp at 240 epochs (new, App. J; reply to 4Uaf [Q1]). That is an upper bound, because only the pair unit has converged there. New App. J gives the convergence state of every 64×6464 \times 64 model.

The degree-1 baseline is reported both at the shared recipe, 84.84 (Table 1), and tuned, 86.67 at its best rate in Table 8. The float reference, which the pair unit reaches on SVHN, Fashion-MNIST and KMNIST (Table 1), fits its training set at 99.99 to 100.00 percent, so it is converged (new, revised App. G). The thermometer input encoding that every model shares costs it 2.59 pp (App. I). We did not run stronger BNN training techniques that keep the integer threshold fold. On scale, revised App. I states that every result comes from one network family and that ImageNet-1k is outside what was trained.

[W4] Is the theory connected to the experiments? Yes. The rank result tells what four products cannot do, and Section 3.2 draws the consequence for the trained R = 4: "this unit does not reach its target exactly and is not meant to: what it adds is a graded co-activation signal used approximately". The rank is therefore chosen by the parameter budget, not by what the unit must represent exactly, and the experiments test the two results that do reach the trained unit. Prop. D.1 separates the two repairs: a degree-2 unit computes an exclusive-or that no additive unit computes at any activation precision. Section 3 ties it to the exchange: "Section 4.3 measures it". Prop. 3.7 makes every deployed one-bit model an exact compiled circuit. Prop. D.4 does reduce to a linear threshold and is offered as a caveat on the rank result's reach. Section 3 states the contribution: "The operator is not new (Section 2.2); its capacity on the cube and its exact compilation are what this paper adds." The free diagonal the reviewer singles out is the part Section 3 claims: "the free diagonal of Theorem 3.4 is what is ours". See also the reply to 4Uaf [Q4].

[Presentation] How is the presentation revised? We revised the manuscript thoroughly for clarity of presentation. The revised PDF moves Section 3.2's rank-to-budget paragraph to after Corollary 3.5, beside Theorem 3.4. It also states where Lemma 3.3 and Corollary 3.5 are used and collects the new controls and datasets in App. J.

Comments on the paper

1 comment

We thank the reviewers for their feedback and the Area Chair for handling this submission. Every point the reviewers raised is answered in the individual replies, and the main concerns are summarized below with their results. Section, appendix and result numbers refer to the revised PDF, where revised and added text is shown in color; "new" marks an appendix added in the rebuttal.

Significance. The paper repairs a binarized CNN by degree instead of precision. Rather than adding activation bits, which widens every accumulator and the memory between layers, it keeps one-bit activations and adds a low-rank pair term to each unit. It prices both repairs on what a deployed circuit carries, logic and stored activation bits. It proves the two repairs distinct (Prop. D.1), the unit exactly compilable to an integer circuit (Prop. 3.7), and which functions a given rank reaches (Theorem 3.4). At matched parameters and the shared training recipe, the pair term improves accuracy at one activation bit on all five datasets while storing fewer activation bits. The paper estimates both costs with an analytical cost model, which the rebuttal checks by synthesis, place-and-route and placement for Artix-7 FPGAs (items 3 and 4).

Strengths the reviewers noted. 4Uaf finds the idea "novel" and "interesting and well motivated", and "a practical alternative to precision only repair for BNN deployment". q1fS finds the pricing "a useful perspective for hardware-oriented work on binarized networks" and the controls ones that "rule out several alternative explanations". G5PV finds "a solid theoretical foundation" and "consistent accuracy gains" at "roughly 1/3 of the baseline's activation storage".

Main concerns.

  1. Product term or narrower network (q1fS). Against a degree-1 control of equal width, parameters and activation memory, both converged, the pair unit leads, 87.42 against 80.53 (new App. J; q1fS [W2, Q3]).

  2. Convergence (4Uaf, G5PV). The submitted 240-epoch runs, trained with AdamW under a cosine schedule at the shared rate, are now shown converged in training and test, and the pair unit leads by 1.50 pp; the stored activation bits do not depend on tuning (revised App. G; 4Uaf [Q2], G5PV [W2, Q2]).

  3. Synthesized logic (q1fS, G5PV, 4Uaf). At both synthesized layers, synthesis matches the cost model's adder-tree prediction, and both models' layers are placed and routed on an Artix-7 (revised App. F; q1fS [W2, Q2], G5PV [W1, Q1], 4Uaf [cost model]).

  4. Memory-constrained hardware (G5PV, q1fS). Placed on four Artix-7 FPGAs, the pair unit's activation buffers fit inputs 1.731.73 to 1.74×1.74\times as large on a side as the baseline's (reply to G5PV's follow-up; G5PV [W1, Q1], q1fS [W2, W3, Q4]).

  5. Scale and architectures (4Uaf, q1fS). Under the shared training recipe and at the budgets run, the pair unit is more accurate than the baseline at 64×6464 \times 64 inputs on CIFAR-10, 83.65 against 79.27, on Tiny-ImageNet-200, and with identity shortcuts added to this network. On Tiny-ImageNet-200, training each model to 480 epochs keeps both pair-unit runs above both baseline runs (new App. J; 4Uaf [Q1], q1fS [W2, W3, Q4]).

Other points. The one-, two- and three-bit precision grid is now complete on all five datasets, three seeds per cell (revised App. A, new App. J; 4Uaf [Q3]). The folded integer model is now shown to reproduce the trained model on all 2,129,920,000 body activations of the CIFAR-10 test set, with zero disagreements (revised App. F; 4Uaf [Q5]). Training steadiness (q1fS [W1, Q1]), theory (q1fS [W4], 4Uaf [Q4]) and presentation (q1fS, 4Uaf [Presentation]) are answered in the individual replies.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.