Pith. sign in

REVIEW 2 major objections 4 minor 48 references

FPGA LUTs can act as full neural neurons and deliver nanosecond inference when trained, wired, and compiled as hardware.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-10 07:37 UTC pith:PYU2K2IH

load-bearing objection Solid full-stack co-design that turns 6-LUTs into trainable neurons with real post-P&R ns latency; the 205× headline is inflated by spatial vs time-multiplexed comparison, but the residual architectural edge and compiler fidelity still make it worth reading. the 2 major comments →

arxiv 2607.08427 v1 pith:PYU2K2IH submitted 2026-07-09 cs.AR cs.LG

FPGN: Redefining Ultra-Fast Programmable Gate-based Neural Acceleration with Differentiable LUTs

Jiawei Liang , Haotong Qin , Linfeng Du , Xingyu Liu , Shangkun Li , Hui Yu , Michele Magno , Xinyu Chen
show 2 more authors
Jiang Xu Wei Zhang
This is my paper
classification cs.AR cs.LG
keywords differentiable LUTsLUT-native neural networksFPGA acceleratorsnanosecond inferencestreaming architecturelatency-driven compilerbinary neural networkshardware-algorithm co-design
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

This paper argues that the path to nanosecond-scale neural inference on FPGAs is not faster arithmetic, but treating the FPGA’s look-up tables themselves as the neurons. Prior LUT-native networks stayed mostly algorithmic: their training did not match real FPGA LUTs, their free-form wiring wrecked routing and clock speed, and no compiler systematically mapped them onto silicon. FPGN closes that stack with three pieces—a differentiable decoder that trains true k-LUT truth tables, a structured CNN-style topology and streaming datapath that keep wires local, and a latency-driven compiler that automatically chooses unrolling under resource limits. On the same platforms used by binary-network baselines, the resulting designs cut end-to-end latency by up to two orders of magnitude and raise LUT efficiency several-fold while keeping fully binary accuracy competitive. The claim matters for any domain where a few hundred nanoseconds of response is the difference between usable and unusable—triggers, trading, line-rate networking.

Core claim

An end-to-end co-design that trains FPGA-native 6-LUT neurons with a continuous decoder relaxation and progressive binarization, places them in a locality-preserving structured streaming topology, and compiles them with high-fidelity analytical QoR models yields fully binary accelerators whose measured latency is up to 205 imes lower than same-platform BNN baselines and whose LUT efficiency is up to 30 imes higher than prior differentiable LUT-native networks, at competitive accuracy.

What carries the argument

The hardware-aligned differentiable LUT: a continuous product-of-indicators decoder of the LUT address that is exact on binary inputs, combined with progressive temperature annealing and bimodal initialization so gradients can explore the full 2^{2^k} Boolean space yet deploy as ordinary FPGA configuration bits.

Load-bearing premise

That the continuous training bridge still finds expressive truth tables once connectivity is forced to be local and structured for FPGA routing; if locality kills accuracy, the latency wins do not transfer.

What would settle it

Train the same FPGN topology under the authors’ continuous schedule and under a pure discrete baseline on CIFAR-10 or JSC; if the continuous schedule cannot recover accuracy within a few points of the reported numbers once the network is forced into the structured connectivity used for the 658 ns design, the claimed Pareto front collapses.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Nanosecond-scale fully binary inference becomes a practical target on commercial FPGAs without DSPs or weight memory.
  • LUT utilization, not DSP or BRAM count, becomes the primary design knob for ultra-low-latency accelerators.
  • Latency-driven compilers with analytical LUT-centric QoR models can replace hand-tuned RTL for this class of networks.
  • The same LUT-vector / LUT-tree primitives can be reused for linear layers inside larger architectures once the training and routing stack is fixed.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the training–topology coupling holds, the same stack could push other fully binary or low-precision models into the sub-microsecond regime without custom ASICs.
  • The reported energy-efficiency gains follow mainly from eliminating weight memory traffic; any future residual multi-bit path would have to re-justify that traffic.
  • A natural next measurement is whether depth-scaled FPGN networks continue to dominate width-scaled ones once accuracy targets exceed the mid-80 % range on CIFAR-scale tasks.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper presents FPGN, an end-to-end co-design framework that treats FPGA k-LUTs as learnable neurons rather than arithmetic building blocks. It contributes (i) a product-decoder continuous relaxation of LUT truth tables with progressive temperature annealing and bimodal initialization that recovers exact discrete LUT logic at binary boundaries (Eqs. 2–7, §III), (ii) a hierarchical structured topology (LUT-vector/tree micro-units, locality-aware padding, residual CNN-style macro-blocks) mapped to a fully streaming architecture with adaptive pipelining and stationary-window circular line buffers (§IV), and (iii) a latency-driven compiler that uses analytical LUT/register/latency QoR models plus hybrid heuristic–MILP DSE to generate synthesizable RTL (§V). Post-P&R results on Versal VP1902 and VU9P claim up to 205× lower latency and 75× higher FPS versus same-platform FINN, up to 30× higher FPS/LUT versus LUTNet, and competitive fully-binary accuracy (e.g., 82.9 % CIFAR-10 at 658 ns / 3.21 M FPS) against DWN, PolyLUT, NeuraLUT and related LUT-as-neuron baselines (Tables IV–V).

Significance. If the claims hold, FPGN supplies a concrete full-stack path from differentiable 6-LUT training to nanosecond-scale FPGA inference for latency-critical domains (HEP triggers, HFT, line-rate classification). Strengths that raise the contribution above pure algorithmic LUT-native work include: bit-exact recovery of hardware LUT logic at binary points, explicit post-P&R evidence that structured connectivity improves HPWL and Fmax (Fig. 2), high-fidelity analytical QoR models (Pearson >0.99 vs. Vivado, Fig. 10), and automated generation of streaming RTL under resource constraints. The work therefore advances both the training methodology and the physical realization of LUT-as-neuron networks, even if the absolute latency factor versus time-multiplexed BNNs must be interpreted carefully.

major comments (2)
  1. Table IV (CIFAR-10/SVHN rows): the headline 205× latency / 75× FPS advantage is obtained by comparing a 2.46 M-LUT fully-unrolled streaming design against a 49.6 k-LUT time-multiplexed FINN baseline on the same VP1902. The paper correctly reports a 1.51× FPS/LUT edge, yet this single scalar does not isolate how much of the residual gap would remain under an iso-LUT (or iso-power) re-implementation of FINN with additional PEs. Without that control, or an explicit statement that FINN’s architecture cannot usefully absorb the extra LUTs, the absolute latency claim overstates the pure architectural advantage of the LUT-as-neuron paradigm.
  2. §IV-B / Fig. 4 and Table III: residual blocks still rely on popcount + integer comparison after the LUT-vector stage. While this is hardware-friendly, it re-introduces arithmetic reduction that the pure LUT-as-neuron narrative (Fig. 1d) claims to eliminate. The manuscript should quantify how much of the final accuracy and latency is attributable to these residual arithmetic units versus the pure Boolean LUT layers, otherwise the comparison with fully Boolean baselines (DWN, LTN/DLN) is partially confounded.
minor comments (4)
  1. Fig. 3 caption and §III-B: the bimodal initialization is described as μ=±1, yet the ablation in Fig. 7 only varies the positive center; a short note clarifying that the negative mode is the symmetric counterpart would avoid ambiguity.
  2. Table V: power numbers are reported only for the CIFAR-10 DWN comparison; adding Vivado-estimated power for the JSC/KWS rows would make energy-efficiency claims more complete.
  3. §V-A / Table II: the analytical equations for N_buffer and T_startup are summarized but not fully expanded; a short appendix derivation or reference to the template library would improve reproducibility of the QoR model.
  4. Minor typographical issues: “T opology” (space) in Challenge 2 heading; “arXiv:2607.08427v1” date line appears as “9 Jul 2026” (future year).

Circularity Check

0 steps flagged

No significant circularity: empirical latency/efficiency claims rest on external baselines and post-P&R measurements, not on quantities forced by construction or self-citation.

full rationale

FPGN is a systems co-design paper whose load-bearing claims (205 imes latency vs same-platform FINN, 30 imes LUT efficiency vs prior LUT-native nets, competitive fully-binary accuracy) are obtained from concrete post-place-and-route implementations and re-implemented external baselines (FINN on VP1902, published DWN/LUTNet/PolyLUT numbers). The differentiable LUT relaxation (Eqs. 2–6) is shown to recover exact discrete hardware lookup at binary points by algebraic identity, not by fitting the target metric; progressive annealing and bimodal init (Fig. 3/7) are free hyperparameters whose effect is ablated, not algebraically forced into the latency numbers. The analytical QoR models (Tables I–II) are used only for DSE and are validated by high Pearson correlation against Vivado (Fig. 10); final reported latencies and FPS/LUT are measured, not predicted from the model. Structured topology and streaming architecture are design choices whose benefits are quantified by physical metrics (HPWL, Fmax, resource counts), not derived from a uniqueness theorem or self-citation chain. No step reduces a claimed prediction to its own fitted input or definitional identity. Minor self-reference to the authors’ own design decisions is ordinary systems engineering and does not load-bear the central results.

Axiom & Free-Parameter Ledger

5 free parameters · 5 axioms · 4 invented entities

The central latency and efficiency claims rest on standard FPGA Boolean/LUT facts, domain assumptions about streaming CNN dataflow and binary networks, several hand-chosen training and architecture hyperparameters, and newly named hardware/software constructs (LUT-vector/tree, locality-aware padding, stationary circular buffers, LUT-centric QoR models) whose value is evidenced only by this paper’s ablations and post-P&R runs.

free parameters (5)
  • sigmoid temperature annealing schedule τ
    Controls continuous-to-binary transition; schedule is chosen for stable training (Fig. 3, §III-B), not derived.
  • bimodal weight init centers μ=±1
    Empirically selected compromise between multiplicative gradient strength and sigmoid saturation (Fig. 7).
  • network scale knobs m and k (S/M/L/G widths, FC LUT counts)
    Table III sets channel multipliers and 2000/3000-class FC widths by design choice to trade accuracy vs LUTs.
  • layer unroll factors {w_i, h_i}
    Primary DSE variables; optimal values are search outputs under resource limits, not unique physical constants.
  • pipeline register insertion thresholds (LUT depth / Carry-Chain stages)
    Heuristic timing policy to hit target Fmax; thresholds are engineering choices in the streaming template.
axioms (5)
  • domain assumption A hardware k-LUT can realize any Boolean function of k bits and is selected by a binary address decoder.
    Foundation of Eq. (2)–(3) and the claim that LUT-as-neuron maps directly onto FPGA fabric.
  • standard math At binary inputs the continuous product decoder δ(x;u) recovers exact discrete LUT lookup and sparse weight gradients (Eq. 6).
    Used to assert training–hardware consistency versus DWN’s EFD mismatch (§III-A).
  • domain assumption Structured local connectivity (CNN-style receptive fields, in-order flatten, locality-aware padding) is place-and-route friendly on commercial FPGA fabrics and preserves competitive accuracy.
    Load-bearing for Challenge 2 solution and Fig. 2 Fmax/HPWL argument.
  • domain assumption Popcount/adder trees and residual BN+binarize can be fused to integer compare and mapped with Carry-Chains without DSPs/BRAMs for weights.
    Enables the DSP/memory-free streaming claim in §IV-B/C.
  • ad hoc to paper Analytical LUT/Reg/latency models with fixed structural templates are faithful enough (after linear calibration) for MILP DSE to rank true post-P&R optima.
    Justifies automated compiler results; supported by Pearson correlations in Fig. 10 but absolute counts still need calibration.
invented entities (4)
  • Hardware-aligned differentiable k-LUT neuron (product decoder + progressive binarization) no independent evidence
    purpose: Train 6-LUT truth tables with dense gradients while recovering exact FPGA logic at binary points.
    Core training construct; independent evidence limited to ablations vs EFD inside this paper.
  • LUT-vector / LUT-tree micro-topologies with locality-aware padding no independent evidence
    purpose: Provide structured parallel and reduction primitives that keep routing local.
    Named building blocks of the physically-aware topology (§IV-A).
  • Stationary-window circular line buffer streaming architecture no independent evidence
    purpose: Decouple layers and reduce MUX fan-in under spatial unrolling.
    Hardware template claimed to cut LUT footprint and aid Fmax (§IV-C).
  • Latency-driven compiler with LUT-centric analytical QoR + hybrid heuristic/MILP DSE no independent evidence
    purpose: Automate unroll selection and RTL generation under resource limits.
    Closes the training-to-bitstream gap; fidelity shown only on authors’ designs.

pith-pipeline@v1.1.0-grok45 · 26565 in / 3849 out tokens · 54512 ms · 2026-07-10T07:37:01.836219+00:00 · methodology

0 comments
read the original abstract

Achieving nanosecond-scale inference latency for deep neural networks (DNNs) has become a primary architectural concern for latency-critical applications. While Field-Programmable Gate Arrays (FPGAs) offer a promising substrate for low-latency inference, conventional FPGA accelerators remain arithmetic-centric, using LUTs primarily as building blocks for numerical operators and peripheral logic. In contrast, recent LUT-native neural networks treat LUTs as learnable neurons, revealing promising theoretical potential to exploit their intrinsic logic expressivity. However, existing methods are largely confined to algorithmic optimizations, failing to translate this theoretical potential into high-performance FPGA accelerators. Specifically, their differentiable formulations do not faithfully match FPGA LUT primitives, their physically-unaware topologies compromise routability and timing closure, and their lack of automated optimization flow hinders systematic design space exploration (DSE) and efficient hardware implementation. In this paper, we propose FPGN, an end-to-end physically-aware framework that closes the gap between LUT-native learning and latency-optimized FPGA implementation. FPGN addresses these challenges through (i) a hardware-aligned differentiable formulation for training FPGA-native LUT neurons, (ii) a structured LUT-native topology with a streaming hardware architecture to improve routing locality and timing closure, and (iii) a latency-driven compiler that leverages high-fidelity analytical Quality of Results models to automate DSE and hardware generation. Experiments show that FPGN achieves up to 205$\times$ latency reduction compared to representative FPGA-based BNN accelerators and up to 30$\times$ higher LUT efficiency than prior differentiable LUT-native networks, while maintaining competitive inference accuracy.

Figures

Figures reproduced from arXiv: 2607.08427 by Haotong Qin, Hui Yu, Jiang Xu, Jiawei Liang, Linfeng Du, Michele Magno, Shangkun Li, Wei Zhang, Xingyu Liu, Xinyu Chen.

Figure 1
Figure 1. Figure 1: Evolution of neural paradigms on FPGA. (a) MAC in CNN. (b) [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Profiling of connection topologies. (a, b) Post-P&R layout of unstruc [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Sigmoid and its derivative for different temperatures [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: FPGN’s network topology. The network consists of hardware-friendly [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Overview of the FPGN streaming dataflow architecture. Inter-layer circular buffers decouple adjacent layers to sustain concurrency. At the intra-layer [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Training loss and accuracy trajectories. Compared to the discrete [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Training loss curves of FPGN under different initialization and staging [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Accuracy and LUT usage of FPGN networks on CIFAR-10 dataset [PITH_FULL_IMAGE:figures/full_fig_p010_8.png] view at source ↗
Figure 10
Figure 10. Figure 10: Correlation between compiler-estimated and Vivado post [PITH_FULL_IMAGE:figures/full_fig_p011_10.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

48 extracted references · 48 canonical work pages · 2 internal anchors

  1. [1]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,”Advances in neural information processing systems, vol. 30, 2017

    work page 2017

  2. [2]

    Deep residual learning for image recognition,

    K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” inProceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016

    work page 2016

  3. [3]

    Klinq: Knowledge distillation-assisted lightweight neural network for qubit readout on fpga,

    X. Guo, T. Bunarjyan, D. Liu, B. Lienhard, and M. Schulz, “Klinq: Knowledge distillation-assisted lightweight neural network for qubit readout on fpga,” in2025 62nd ACM/IEEE Design Automation Con- ference (DAC), pp. 1–7, IEEE, 2025

    work page 2025

  4. [4]

    Computing systems for superconducting qubits: Challenges and oppor- tunities,

    V . Le, N. V ora, D. Brahmbhatt, Y . Xu, G. Huang, and P. V . Nguyen, “Computing systems for superconducting qubits: Challenges and oppor- tunities,” inProceedings of the 23rd Annual International Conference on Mobile Systems, Applications and Services, pp. 771–774, 2025

    work page 2025

  5. [5]

    A domain-specific accelerator for ultralow latency market data distribution system,

    H. Jia, Y . Huan, C. Ding, Y . Yan, J. Cui, J. Wang, C. Cai, L. Xu, Z. Zou, and L. Zheng, “A domain-specific accelerator for ultralow latency market data distribution system,”IEEE Transactions on Industrial Informatics, vol. 19, no. 4, pp. 5465–5475, 2022

    work page 2022

  6. [6]

    Lighttrader: A standalone high-frequency trading system with deep learning inference accelerators and proactive scheduler,

    S. Yoo, H. Kim, J. Kim, S. Park, J.-Y . Kim, and J. Oh, “Lighttrader: A standalone high-frequency trading system with deep learning inference accelerators and proactive scheduler,” in2023 IEEE International Sym- posium on High-Performance Computer Architecture (HPCA), pp. 1017– 1030, IEEE, 2023

    work page 2023

  7. [7]

    Taurus: a data plane architecture for per-packet ml,

    T. Swamy, A. Rucker, M. Shahbaz, I. Gaur, and K. Olukotun, “Taurus: a data plane architecture for per-packet ml,” inProceedings of the 27th ACM International Conference on Architectural Support for Program- ming Languages and Operating Systems, pp. 1099–1114, 2022

    work page 2022

  8. [8]

    Leo: Online {ML-based}traffic classification at{Multi-Terabit}line rate,

    S. U. Jafri, S. Rao, V . Shrivastav, and M. Tawarmalani, “Leo: Online {ML-based}traffic classification at{Multi-Terabit}line rate,” in21st USENIX Symposium on Networked Systems Design and Implementation (NSDI 24), pp. 1573–1591, 2024

    work page 2024

  9. [9]

    Field-programmable gate array ar- chitecture for deep learning: Survey and future directions,

    A. Boutros, A. Arora, and V . Betz, “Field-programmable gate array ar- chitecture for deep learning: Survey and future directions,”Proceedings of the IEEE, 2025

    work page 2025

  10. [10]

    Optimizing fpga-based accelerator design for deep convolutional neural networks,

    C. Zhang, P. Li, G. Sun, Y . Guan, B. Xiao, and J. Cong, “Optimizing fpga-based accelerator design for deep convolutional neural networks,” inProceedings of the 2015 ACM/SIGDA international symposium on field-programmable gate arrays, pp. 161–170, 2015

    work page 2015

  11. [11]

    Rebnet: Residual binarized neural network,

    M. Ghasemzadeh, M. Samragh, and F. Koushanfar, “Rebnet: Residual binarized neural network,” in2018 IEEE 26th annual international sym- posium on field-programmable custom computing machines (FCCM), pp. 57–64, IEEE, 2018

    work page 2018

  12. [12]

    Microscopiq: Acceler- ating foundational models through outlier-aware microscaling quantiza- tion,

    A. Ramachandran, S. Kundu, and T. Krishna, “Microscopiq: Acceler- ating foundational models through outlier-aware microscaling quantiza- tion,” inProceedings of the 52nd Annual International Symposium on Computer Architecture, pp. 1193–1209, 2025

    work page 2025

  13. [13]

    2.5 a 16nm 5.7 tops cnn processor supporting bi-directional fpn for small-object detection on high-resolution videos,

    Y .-C. Ding, C.-Y . Chang, C.-Y . Lin, H.-Y . Tsai, H.-J. Tu, K.-F. Chang, Y .-C. Su, T.-H. Hsieh, Y .-K. Jian, W.-C. Chen,et al., “2.5 a 16nm 5.7 tops cnn processor supporting bi-directional fpn for small-object detection on high-resolution videos,” in2025 IEEE International Solid- State Circuits Conference (ISSCC), vol. 68, pp. 1–3, IEEE, 2025

    work page 2025

  14. [14]

    Why compete when you can work together: Fpga-asic integration for persistent rnns,

    E. Nurvitadhi, D. Kwon, A. Jafari, A. Boutros, J. Sim, P. Tomson, H. Sumbul, G. Chen, P. Knag, R. Kumar,et al., “Why compete when you can work together: Fpga-asic integration for persistent rnns,” in2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM), pp. 199–207, IEEE, 2019

    work page 2019

  15. [15]

    Acceleration of fpga based convolutional neural network for human activity classification using millimeter-wave radar,

    P. Lei, J. Liang, Z. Guan, J. Wang, and T. Zheng, “Acceleration of fpga based convolutional neural network for human activity classification using millimeter-wave radar,”IEEE Access, vol. 7, pp. 88917–88926, 2019

    work page 2019

  16. [16]

    Xnor-net: Imagenet classification using binary convolutional neural networks,

    M. Rastegari, V . Ordonez, J. Redmon, and A. Farhadi, “Xnor-net: Imagenet classification using binary convolutional neural networks,” in European conference on computer vision, pp. 525–542, Springer, 2016

    work page 2016

  17. [17]

    Lutnet: Learning fpga configurations for highly efficient neural network infer- ence,

    E. Wang, J. J. Davis, P. Y . Cheung, and G. A. Constantinides, “Lutnet: Learning fpga configurations for highly efficient neural network infer- ence,”IEEE Transactions on Computers, vol. 69, no. 12, pp. 1795–1808, 2020

    work page 2020

  18. [18]

    Polylut: learning piecewise polynomials for ultra-low latency fpga lut-based inference,

    M. Andronic and G. A. Constantinides, “Polylut: learning piecewise polynomials for ultra-low latency fpga lut-based inference,” in2023 International Conference on Field Programmable Technology (ICFPT), pp. 60–68, IEEE, 2023

    work page 2023

  19. [19]

    Neuralut: Hiding neural net- work density in boolean synthesizable functions,

    M. Andronic and G. A. Constantinides, “Neuralut: Hiding neural net- work density in boolean synthesizable functions,” in2024 34th Inter- national Conference on Field-Programmable Logic and Applications (FPL), pp. 140–148, 2024

    work page 2024

  20. [20]

    Neuralut-assemble: Hardware- aware assembling of sub-neural networks for efficient lut infer- ence,

    M. Andronic and G. A. Constantinides, “Neuralut-assemble: Hardware- aware assembling of sub-neural networks for efficient lut infer- ence,” in2025 IEEE 33rd Annual International Symposium on Field- Programmable Custom Computing Machines (FCCM), pp. 208–216, IEEE, 2025

    work page 2025

  21. [21]

    Deep differen- tiable logic gate networks,

    F. Petersen, C. Borgelt, H. Kuehne, and O. Deussen, “Deep differen- tiable logic gate networks,”Advances in Neural Information Processing Systems, vol. 35, pp. 2006–2018, 2022

    work page 2006

  22. [22]

    Con- volutional differentiable logic gate networks,

    F. Petersen, H. Kuehne, C. Borgelt, J. Welzel, and S. Ermon, “Con- volutional differentiable logic gate networks,”Advances in Neural Information Processing Systems, vol. 37, pp. 121185–121203, 2024

    work page 2024

  23. [23]

    Differentiable Weightless Neural Networks

    A. T. Bacellar, Z. Susskind, M. Breternitz Jr, E. John, L. K. John, P. Lima, and F. M. Franc ¸a, “Differentiable weightless neural networks,” arXiv preprint arXiv:2410.11112, 2024

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  24. [24]

    92.45% on cifar-10 in torch

    S. Zagoruyko, “92.45% on cifar-10 in torch.” http://torch.ch/blog/2015/ 07/30/cifar.html. 14

    work page 2015

  25. [25]

    Fpga architecture: Principles and progression,

    A. Boutros and V . Betz, “Fpga architecture: Principles and progression,” IEEE Circuits and Systems Magazine, vol. 21, no. 2, pp. 4–29, 2021

    work page 2021

  26. [26]

    Kanel ´e: Kolmogorov–arnold networks for efficient lut-based evaluation,

    D. Hoang, A. Gupta, and P. C. Harris, “Kanel ´e: Kolmogorov–arnold networks for efficient lut-based evaluation,” inProceedings of the 2026 ACM/SIGDA International Symposium on Field Programmable Gate Arrays, pp. 44–55, 2026

    work page 2026

  27. [27]

    Finn: A framework for fast, scalable binarized neural network inference,

    Y . Umuroglu, N. J. Fraser, G. Gambardella, M. Blott, P. Leong, M. Jahre, and K. Vissers, “Finn: A framework for fast, scalable binarized neural network inference,” inProceedings of the 2017 ACM/SIGDA interna- tional symposium on field-programmable gate arrays, pp. 65–74, 2017

    work page 2017

  28. [28]

    Packing techniques for virtex-5 fpgas,

    T. Ahmed, P. D. Kundarewich, and J. H. Anderson, “Packing techniques for virtex-5 fpgas,”ACM Transactions on Reconfigurable Technology and Systems (TRETS), vol. 2, no. 3, pp. 1–24, 2009

    work page 2009

  29. [29]

    J. C. Strikwerda,Finite difference schemes and partial differential equations. SIAM, 2004

    work page 2004

  30. [30]

    Binaryconnect: Training deep neural networks with binary weights during propagations,

    M. Courbariaux, Y . Bengio, and J.-P. David, “Binaryconnect: Training deep neural networks with binary weights during propagations,”Ad- vances in neural information processing systems, vol. 28, 2015

    work page 2015

  31. [31]

    Bi-real net: Enhancing the performance of 1-bit cnns with improved representational capability and advanced training algorithm,

    Z. Liu, B. Wu, W. Luo, X. Yang, W. Liu, and K.-T. Cheng, “Bi-real net: Enhancing the performance of 1-bit cnns with improved representational capability and advanced training algorithm,” inProceedings of the European conference on computer vision (ECCV), pp. 722–737, 2018

    work page 2018

  32. [32]

    Throughput- optimized fpga accelerator for deep convolutional neural networks,

    Z. Liu, Y . Dou, J. Jiang, J. Xu, S. Li, Y . Zhou, and Y . Xu, “Throughput- optimized fpga accelerator for deep convolutional neural networks,” ACM Transactions on Reconfigurable Technology and Systems (TRETS), vol. 10, no. 3, pp. 1–23, 2017

    work page 2017

  33. [33]

    Performance modeling for cnn inference accelerators on fpga,

    Y . Ma, Y . Cao, S. Vrudhula, and J.-S. Seo, “Performance modeling for cnn inference accelerators on fpga,”IEEE Transactions on Computer- Aided Design of Integrated Circuits and Systems, vol. 39, no. 4, pp. 843– 856, 2019

    work page 2019

  34. [34]

    Fpga- based high-throughput cnn hardware accelerator with high computing resource utilization ratio,

    W. Huang, H. Wu, Q. Chen, C. Luo, S. Zeng, T. Li, and Y . Huang, “Fpga- based high-throughput cnn hardware accelerator with high computing resource utilization ratio,”IEEE Transactions on Neural Networks and Learning Systems, vol. 33, no. 8, pp. 4069–4083, 2021

    work page 2021

  35. [35]

    Forward and backward information retention for accurate binary neural networks,

    H. Qin, R. Gong, X. Liu, M. Shen, Z. Wei, F. Yu, and J. Song, “Forward and backward information retention for accurate binary neural networks,” inProceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 2250–2259, 2020

    work page 2020

  36. [36]

    Identity mappings in deep residual networks,

    K. He, X. Zhang, S. Ren, and J. Sun, “Identity mappings in deep residual networks,” inEuropean conference on computer vision, pp. 630–645, Springer, 2016

    work page 2016

  37. [37]

    7 series fpgas configurable logic block user guide (ug474)

    Advanced Micro Devices, Inc., “7 series fpgas configurable logic block user guide (ug474).” https://docs.amd.com/r/en-US/ug474 7Series CLB, 2025

    work page 2025

  38. [38]

    Reading digits in natural images with unsupervised feature learning,

    Y . Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, A. Y . Ng,et al., “Reading digits in natural images with unsupervised feature learning,” inNIPS workshop on deep learning and unsupervised feature learning, vol. 2011, p. 7, Granada, 2011

    work page 2011

  39. [39]

    Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition

    P. Warden, “Speech commands: A dataset for limited-vocabulary speech recognition,”arXiv preprint arXiv:1804.03209, 2018

    work page internal anchor Pith review Pith/arXiv arXiv 2018

  40. [40]

    CERNBox LHC Jets Dataset

    CERN Collaboration, “CERNBox LHC Jets Dataset.” https://cernbox. cern.ch/s/jvFd5MoWhGs1l5v/download, 2025. Accessed: 2024-11-01

    work page 2025

  41. [41]

    hls4ml lhc jets hlf (OpenML Dataset 42468)

    OpenML Contributors and LHC Jets HLF Curators, “hls4ml lhc jets hlf (OpenML Dataset 42468).” https://www.openml. org/d/42468, 2020. Accessed: 2024-11-01

    work page 2020

  42. [42]

    Greater than the sum of its luts: Scaling up lut-based neural networks with amigolut,

    O. Weng, M. Andronic, D. Zuberi, J. Chen, C. Geniesse, G. A. Constantinides, N. Tran, N. J. Fraser, J. M. Duarte, and R. Kastner, “Greater than the sum of its luts: Scaling up lut-based neural networks with amigolut,” inProceedings of the 2025 ACM/SIGDA International Symposium on Field Programmable Gate Arrays, pp. 25–35, 2025

    work page 2025

  43. [43]

    Fado: Floorplan-aware directive optimization based on synthesis and analytical models for high-level synthesis designs on multi-die fpgas,

    L. Du, T. Liang, X. Zhou, J. Ge, S. Li, S. Sinha, J. Zhao, Z. Xie, and W. Zhang, “Fado: Floorplan-aware directive optimization based on synthesis and analytical models for high-level synthesis designs on multi-die fpgas,”ACM Transactions on Reconfigurable Technology and Systems, vol. 17, no. 3, pp. 1–33, 2024

    work page 2024

  44. [44]

    Autobridge: Coupling coarse-grained floorplanning and pipelining for high-frequency hls design on multi-die fpgas,

    L. Guo, Y . Chi, J. Wang, J. Lau, W. Qiao, E. Ustun, Z. Zhang, and J. Cong, “Autobridge: Coupling coarse-grained floorplanning and pipelining for high-frequency hls design on multi-die fpgas,” inThe 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, pp. 81–92, 2021

    work page 2021

  45. [45]

    Wsq- addernet: Efficient weight standardization based quantized addernet fpga accelerator design with high-density int8 dsp-lut co-packing optimiza- tion,

    Y . Zhang, B. Sun, W. Jiang, Y . Ha, M. Hu, and W. Zhao, “Wsq- addernet: Efficient weight standardization based quantized addernet fpga accelerator design with high-density int8 dsp-lut co-packing optimiza- tion,” inProceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design, pp. 1–9, 2022

    work page 2022

  46. [46]

    Going deeper with embedded fpga platform for convolutional neural network,

    J. Qiu, J. Wang, S. Yao, K. Guo, B. Li, E. Zhou, J. Yu, T. Tang, N. Xu, S. Song,et al., “Going deeper with embedded fpga platform for convolutional neural network,” inProceedings of the 2016 ACM/SIGDA international symposium on field-programmable gate arrays, pp. 26–35, 2016

    work page 2016

  47. [47]

    Neuroblend: Towards low-power yet accurate neural network-based inference engine blending binary and fixed-point convolutions,

    A. Fayyazi, M. Nazemi, A. Fayyazi, and M. Pedram, “Neuroblend: Towards low-power yet accurate neural network-based inference engine blending binary and fixed-point convolutions,” inProceedings of the Great Lakes Symposium on VLSI 2024, pp. 730–735, 2024

    work page 2024

  48. [48]

    Fracbnn: Accurate and fpga-efficient binary neural networks with fractional acti- vations,

    Y . Zhang, J. Pan, X. Liu, H. Chen, D. Chen, and Z. Zhang, “Fracbnn: Accurate and fpga-efficient binary neural networks with fractional acti- vations,” inThe 2021 ACM/SIGDA International Symposium on Field- Programmable Gate Arrays, pp. 171–182, 2021

    work page 2021