ResoLUT: Distilling Residual Networks into Lookup-Table Networks

Katarzyna Fojcik, Aidas Mikalauskas, Matthias Kampa, Renaldas Zioma, Jogundas ArmaitisarXiv 2026 · arXiv

TL;DR

ResoLUT is a novel framework that distills deep, pre-trained Residual Networks (ResNets) into efficient Lookup-Table (LUT) networks for hardware inference. By introducing a multi-bit integer residual stream and a layer-wise distillation process, it overcomes the "depth wall" that has historically limited logic-based neural networks, achieving state-of-the-art accuracy and massive throughput (189k FPS) on FPGAs.

What Problem Does This Paper Address?

Deep learning on the edge often requires specialized hardware like FPGAs. While standard networks rely on power-hungry multipliers and floating-point operations, Logic Gate Networks (LGNs) and LUT networks offer a tempting alternative: they represent the model as a massive circuit of simple Boolean operations.

However, two major hurdles have prevented these networks from scaling:

  1. The Depth Wall: As logic networks get deeper, they suffer from vanishing gradients and a "discretization gap"—the difference between the "soft" logic used during training and the "hard" logic used in hardware.
  2. Connectivity: Deciding which bits should connect to which gates is a combinatorial nightmare that is incredibly difficult to learn from scratch.

Methods

The authors propose ResoLUT, which shifts the paradigm from training logic from scratch to distilling it from a "teacher" ResNet.

1. Layer-wise Distillation

Instead of training the whole network at once, ResoLUT converts a pre-trained ResNet one layer at a time. Each new LUT layer is trained to mimic the output of the corresponding numerical layer in the teacher, while the previous layers remain frozen.

2. The Multi-bit Residual Stream

This is the paper's "secret sauce." Traditional logic networks usually carry only a single bit along residual paths. ResoLUT maintains a low-precision integer stream (e.g., 3-8 bits). This "graded" value allows the network to apply small corrections at each layer, preventing the information loss that typically kills deep logic networks.

3. LUT Convolutions

The standard multiply-accumulate (MAC) operation is replaced by a three-step process:

  • Comparators: Input integers are converted into "thermometer bits" (e.g., a value of 3 becomes 11100...).
  • LUT4 Trees: These bits are fed into trees of 4-input Lookup Tables. The wiring of these trees is extracted directly from the teacher's weights rather than being learned.
  • Vote Count & Decode: The outputs of the LUT trees are summed and rescaled (folding in BatchNorm) to update the residual stream.
Figure 2. The LUT convolution (a), its place in a residual block (b), and a complete network (c). Comparators turn the integer residual stream into thermometer bits; each tree reads 16 of them from one input channel’s window and its five LUT outputs are counted; channels mix only in this count. A per-channel affine map decodes the count back into the convolution’s output, and BatchNorm, the shortcut addition and ReLU are the teacher’s own, in fixed point. Pink: LUT4 truth tables, the only learned bits; slate: comparator bits; gold: integers; green: per-channel numbers.

Datasets

The authors evaluated ResoLUT on three standard computer vision benchmarks:

  • CIFAR-10: Used for primary benchmarking and FPGA implementation.
  • CIFAR-100: Used to demonstrate scaling to more complex classification tasks.
  • ImageNet-64: A downsampled version of the massive ImageNet dataset (64x64 pixels) to test scalability to large-scale data.

Key Insights and Ideas

  • Residuals are Mandatory for Depth: The authors found that without the multi-bit residual stream, accuracy collapses as depth increases. For a 32-layer network, adding residuals reduced the conversion error from 15.8 points to just 3.2 points on CIFAR-100.
  • Connectivity from the Teacher: By using the teacher's weight correlations to decide LUT wiring, the authors bypassed the expensive combinatorial search that plagues other logic networks.
  • No Discretization Gap: Because the forward pass uses hard LUT lookups during training (with straight-through estimators for the backward pass), the model performs exactly the same during training as it does on hardware.

Key Results

ResoLUT sets new records for logic-based networks across several metrics:

  • Accuracy: ResoLUT-20 achieved 95.66% on CIFAR-10, significantly outperforming previous logic-gate and LUT-based approaches.
  • Scalability: ResoLUT-56 reached 78.87% on CIFAR-100 and 53.69% on ImageNet-64, proving that logic networks can finally scale in depth.
  • Hardware Performance: An optimized ResoLUT-8 model was implemented on a Xilinx VU35P FPGA. It achieved 90.04% accuracy on CIFAR-10 while processing 189,000 images per second—a throughput 66x to 1,180x higher than other high-accuracy competitors.
Figure 1. CIFAR-10 test accuracy against gate operations per image: ResoLUT at several tree budgets (red) and published networks (bars and binary or hybrid networks: estimated gate operations).

Limitations and Future Work

  • The Teacher-Student Gap: While ResoLUT is highly accurate, there is still a small performance gap compared to the original floating-point teacher, and this gap grows with depth.
  • Optimization Scope: Many of the most aggressive optimizations (like aggressive tree pruning) were only tested on the smaller ResoLUT-8 model.
  • FPGA Resources: While the ResoLUT-8 fits comfortably on an FPGA, the deeper ResoLUT-56 models would require significantly larger hardware resources, which the authors have not yet tested.

Future work could involve closing the teacher-student gap through better optimization and exploring how these LUT-based architectures might apply to non-convolutional models like Transformers.

Summary updated

Abstract

Logic networks built from Boolean gates or lookup tables (LUTs) promise efficient hardware inference, but training them at depth and learning their connectivity remain difficult. We do not train logic as logic. Instead, ResoLUT distills a trained residual network (ResNet) layer by layer into LUT trees, preserving its multi-bit residual stream and BatchNorm while extracting connectivity from the teacher rather than learning it. To our knowledge, ResoLUT is the first convolutional logic network in computer vision to retain a ResNet-style multi-bit residual stream. Hard LUT decisions are used throughout training and inference, avoiding a discretization gap in the logic. ResoLUT-20 reaches 95.66% on CIFAR-10 with twice the trees, and ResoLUT-56 reaches 78.87% on CIFAR-100 and 53.69% on ImageNet at 64px, the best results of logic and lookup-table networks on CIFAR-10 and CIFAR-100, showing that LUT networks can scale in depth. We explore and quantify the role of the residuals and the tree budget and shape. The most optimized model, a ResoLUT-8 with one eighth of the trees and further optimizations, fits on an FPGA and reaches 90.04% at 189k images per second, the highest throughput among the compared models above 85% on CIFAR-10.
BibTeX
@misc{fojcik2026resolut,
  author = {Katarzyna Fojcik and Aidas Mikalauskas and Matthias Kampa and Renaldas Zioma and Jogundas Armaitis},
  title = {{ResoLUT: Distilling Residual Networks into Lookup-Table Networks}},
  year = {2026},
  eprint = {2611.22955},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.22955},
}
Figure