Pith. sign in

REVIEW 3 major objections 4 minor 23 references

A Survey on LUT-based Deep Neural Networks Implemented in FPGAs

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This survey argues that FPGA lookup tables, not just DSP blocks, can carry DNN inference, and charts the designs that make it work.

desk verdict Useful survey of LUT-based FPGA inference, but Table I's quantitative comparison is unreliable and contains arithmetic errors. read the letter →

arxiv 2506.07367 v1 pith:ZF2KSM77 submitted 2025-06-09 cs.AR

Zeyu Guo This is my paper
classification cs.AR
keywords FPGAlookuptablesLUT-basedneuralnetworkslow-latencyinferenceweightlesslogicminimizationgradientboosteddecisiontreesedgeAI
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

FPGA-based neural-network accelerators usually rely on scarce DSP blocks for multiply-accumulate operations. This survey argues that lookup tables (LUTs), the FPGA's basic programmable logic, can carry the computation themselves, and that doing so lowers latency and improves resource use for edge inference. It traces the design arc from XNOR-based binarized networks through LUT-mapped neurons, polynomial and MLP-in-a-LUT designs, compression methods, and directly differentiable LUT training, then compares published accuracy and hardware-cost numbers across three benchmark tasks. The paper's central claim is that LUT-based DNNs have grown into a distinct design point worth mapping, evaluating, and scaling toward larger models.

What carries the argument

The central object is the FPGA lookup table treated as a K-input Boolean function that stores the full mapping from a quantized input window to a quantized output. The argument is carried by LUT complexity: a LUT with fan-in $F$ and input bit width $\beta$ needs a table of size $2^{\beta F}$, so the surveyed architectures trade fan-in, polynomial degree, sub-neuron adders, compression, and direct training to control exponential growth. A second mechanism is VC-dimension: an $n$-input LUT has VC-dimension $2^n$ compared with $n+1$ for a conventional neuron, which motivates training the LUTs themselves rather than converting a network into LUTs after training.

What would settle it

Re-implement two of the compared methods, for example DWN and PolyLUT, on the same FPGA part and dataset with a single synthesis flow and measure post-route LUT count and latency; if the ordering by area-delay product reverses, or a DSP-based design beats the LUT-based designs on the same resources, the survey's central comparison fails. A quicker check: in the reproduced PolyLUT MNIST row, multiplying 61,500 LUTs by 20 ns gives 1.23e6, not the printed 1.13e6, so the area-delay metric in Table I needs recomputation before the ranking is trusted.

Watch

Extended reading notes

Core claim

The paper's thesis is that treating FPGA LUTs as general computational elements, rather than simple gates for XNOR or Boolean operations, unlocks a different implementation style for DNN inference: quantized neuron computations are enumerated and stored in LUTs, so much of the multiply-accumulate work disappears into table lookups. The survey identifies two generations of work: an earlier one that trains a conventional DNN and then converts it into LUTs (LUTNet, NullaNet, LogicNets, PolyLUT, PolyLUT-Add, NeuraLUT, plus the compression schemes CompressedLUT and ReducedLUT), and a newer one that trains the LUTs directly as weightless neural networks (DiffLogicNet and DWN). Its comparative table shows all evaluated designs using zero DSP blocks, reports DWN as the best accuracy-versus-resource trade-off in the datasets considered, and reports TreeLUT, a gradient-boosted decision tree mapped to LUTs, as the lowest-latency option.

Load-bearing premise

The paper's cross-paper efficiency rankings assume the numbers reported in different original papers were measured in comparable settings, but most rows do not list the target FPGA device, and one reproduced row's area-delay product does not match its own LUT count and latency.

Editorial extensions

If this is right

  • DSP-free inference becomes practical: every design in the survey's comparison reports zero DSP blocks, so LUT-based networks can target FPGAs with few or no DSP resources.
  • Direct LUT training leads the comparison: DWN, trained as a weightless neural network, reports both the highest accuracy and the lowest area-delay product on the MNIST and jet-substructure tasks among the compared methods.
  • Decision trees are a viable low-latency alternative: TreeLUT reports the lowest latency on each dataset, positioning gradient-boosted trees as a complement to DNNs for tabular, ultra-low-latency applications.
  • The remaining bottleneck is table growth: LUT size still scales exponentially in fan-in, and the survey's future directions center on inter-layer LUT reuse, architecture search, and FPGA deployment of large language models.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If direct LUT training generalizes beyond the small datasets shown, the $2^n$ VC-dimension advantage suggests LUT-based weightless networks could reach a given accuracy with far fewer parameters than neuron-based networks on Boolean-like inputs; this is an extrapolation, not a result the survey demonstrates.
  • The survey's cross-paper comparison lists no target FPGA device for most rows, so the relative area-delay ranking should be read as indicative; a standardized benchmark on one FPGA and one synthesis flow would likely reorder some entries.
  • The compression ideas in CompressedLUT and ReducedLUT could be applied across LUTs that share inputs or across layers, not only inside a single LUT; the survey lists inter-layer redundancy as future work rather than showing it.
  • If LUT-based inference scales to LLM-sized models, the boundary between 'neural' and 'lookup' computing could blur, with sparse table lookups replacing dense matrix multiplications; this follows from the paper's scaling discussion but is not demonstrated.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. This paper surveys LUT-based deep neural network inference on FPGAs, tracing the evolution from DSP- and XNOR-based implementations through LUTNet, NullaNet, LogicNets, PolyLUT, PolyLUT-Add, NeuraLUT, AmigoLUT, CompressedLUT, ReducedLUT, DiffLogicNet, DWN, and TreeLUT. It describes each architecture's motivation, formulation, and reported limitations, and it provides a comparison table (Table I) of accuracy, LUT count, FF count, Fmax, latency, and area-delay product across MNIST, JSC, and NID datasets, followed by derived reduction factors in Section IV-B. The paper also lists future research directions and an appendix with model configurations.

Significance. If the comparison table were reliable, the survey would be a useful first-stop reference for practitioners choosing among LUT-based FPGA inference methods, because it consolidates a scattered literature and provides a qualitative taxonomy. The narrative faithfully tracks the cited original papers, and the survey covers a wide range of methods, including very recent work. It is a survey, not a research contribution, so its value lies in organization and critical synthesis; the paper's explicit quantitative comparison is its main added value beyond the individual abstracts.

major comments (3)
  1. [Table I and Section IV-B] Table I lacks a column for the target FPGA device, synthesis tool, and clock constraint, yet Section IV-B uses its area-delay products to compute reduction factors and rank methods. This is not a controlled comparison: different rows are likely from different FPGAs and different tool versions, making LUT counts and Fmax values not directly comparable. The two author-reproduced rows, labeled PolyLUT (HDR)1 and PolyLUT (JSC-XL)1, are inconsistent with their own LUT and latency entries: 61,500×20 ns = 1.23e+6, but the table lists 1.13e+6; 168,746×24 ns = 4.05e+6, but the table lists 4.97e+6. In both cases the listed ADP matches the original paper's row rather than the reproduced values, indicating the ADP was copied rather than recomputed. These errors directly propagate into the text's quantitative conclusions; for example, Section IV-B claims DWN (sm) reduces the MNIST area-delay product by 706.6× relative to PolyLUT, but 1.13e+6 / 1.66e+3 = 6.8e+2, not 706.6. The central claim of providing performance trade-offs is therefore not supported by the data as presented. Please add device/tool information for every row, recompute all area-delay products, and verify the reduction factors in Section IV-B.
  2. [Section III.E, Eq. (8) and the LUT-size example] The notation F is used inconsistently in the PolyLUT-Add resource example. The text says 'Assuming a neuron input of F=6' but then computes PolyLUT-Add's LUT cost as 2^(3β)+2^(3β)+2^(2(β+1)) = 3×2^6, which implicitly treats the per-sub-neuron fan-in as F=3, not the total fan-in of 6. This is confusing and makes the claimed 95% reduction difficult to verify. Please define the total fan-in and per-sub-neuron fan-in separately, or state explicitly that the example splits the 6 inputs into two groups of 3.
  3. [Footnote 1] The footnote says the PolyLUT rows were 'reproduced by the author' using a Xilinx xcku060ffva1156-2-i FPGA, but it does not report the synthesis tool, clock constraint, or any verification or simulation procedure. A reproduction without these details cannot be independently checked and is not sufficient to serve as a controlled comparison point in Table I. Please either provide the full reproduction methodology or remove the reproduced rows and rely only on the original papers' numbers with their device context.
minor comments (4)
  1. [Section IV.B] The text contains a repeated typo: 'DWN DWN attained 71.1% accuracy...' should read 'DWN attained 71.1% accuracy...'.
  2. [Table I] The survey discusses LUTNet and NullaNet in Section III but does not include them in Table I. If the original papers report comparable metrics, including them would make the claimed comprehensiveness stronger; if not, a sentence explaining their exclusion would help.
  3. [Section III.F] The subsection heading is rendered as 'F . NeuraLUT' with an extra space; this is a formatting issue.
  4. [Section IV.A] The description of the MNIST dataset says images are 'flattened into a 784-dimensional input vector' but does not mention that the survey's methods use only a subset of features; a brief note that the methods were evaluated on the full or reduced dataset would improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the survey's comparison is based on external published results and the author's own independent reproductions, with no fitted parameters, predictive claims, or load-bearing self-citations.

full rationale

This is a survey paper with no formal derivation chain, no fitted parameters, and no predictive claims. The experimental comparison in Table I quotes results directly from the original papers, as the table caption states: 'The results were quoted directly from their original papers.' The three rows reproduced by the author (flagged by footnote 1) are independent synthesis measurements on a stated Xilinx FPGA device, not predictions derived from the survey's own assumptions. Section IV-B computes reduction factors as arithmetic ratios of the quoted area-delay products; even if those products are internally inconsistent or not device-comparable, that is a data-quality and correctness concern, not circularity, because the comparison values are not defined in terms of the survey's conclusions. No load-bearing assertion is justified only by a self-citation; every algorithmic description cites prior external work by non-overlapping author teams, and the survey makes no uniqueness claims that would import an author's own theorem as a forced choice. The survey reorganizes and describes known results, but it does not rename a known pattern as a new derivation, and it does not fit any parameter that is later called a prediction. Therefore, no circular step is present.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

This is a review paper; it introduces no free parameters and no invented entities. The axioms are the premises on which the survey's comparative claims rest: that quoted per-paper results are accurate, that they are mutually comparable, and that the selection of works is representative. These are domain assumptions, not standard math axioms.

assumptions (4)
  • domain assumption Quoted results from original papers are accurate as reported.
    Table I is assembled from values 'quoted directly from their original papers' (Table I caption); the survey adds no independent verification.
  • domain assumption Results from different papers are comparable even though target FPGA devices are not listed for most rows.
    The paper compares LUT counts and latencies across methods without controlling for FPGA part or synthesis tool, implying comparability.
  • domain assumption The set of methods surveyed is representative of the field.
    The author states the survey is 'comprehensive' but does not describe a systematic search or inclusion criteria.
  • ad hoc to paper The author's reproduced PolyLUT results (Table I footnote) are valid despite lacking synthesis details.
    The footnote says the results were reproduced by the author, but no code, timing constraints, or tool version are given, and the area-delay product is inconsistent.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Survey on LUT-based Deep Neural Networks Implemented in FPGAs." pith.science (2026). https://pith.science/paper/ZF2KSM77

@misc{pith2026250607367,
  author       = {Pith},
  title        = {Pith review of: A Survey on LUT-based Deep Neural Networks Implemented in FPGAs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZF2KSM77}},
  note         = {Machine review of arXiv:2506.07367}
}
read the original abstract

Low-latency, energy-efficient deep neural networks (DNNs) inference are critical for edge applications, where traditional cloud-based deployment suffers from high latency and security risks. Field-Programmable Gate Arrays (FPGAs) offer a compelling solution, balancing reconfigurability, power efficiency, and real-time performance. However, conventional FPGA-based DNNs rely heavily on digital signal processing (DSP) blocks for multiply-accumulate (MAC) operations, limiting scalability. LUT-based DNNs address this challenge by fully leveraging FPGA lookup tables (LUTs) for computation, improving resource utilization and reducing inference latency. This survey provides a comprehensive review of LUT-based DNN architectures, including their evolution, design methodologies, and performance trade-offs, while outlining promising directions for future research.

Figures

Figures reproduced from arXiv: 2506.07367 by the authors.

Figure 1
Figure 1. Architectures of DSP-based fully connected DNNs and a single neuron [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Architecture of a XNOR-based neuron [6]. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Architecture of a LUTNet neuron [6]. where σ is the activation function, Ne represents the number of pruned connections (before pruning, it was N), typically Ne ≪ N. The term xe (n) represents a randomly selected subset of K elements from the input vector, serving as the input to the K-LUT function gn. Each trained gn is directly mapped to FPGA K-LUTs, rather than simply executing XNOR operations. BNNs can be consid… view at source ↗
Figures from the paper (13 more)
Figure 5
Figure 5. Figure 5: Examples of implementing logic gates using McCulloch-Pitts neurons: [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 6
Figure 6. Figure 6: High sparsity connection scheme of LogicNet [3]. [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 7
Figure 7. Figure 7: Architecture of a LogicNets neuron [4] [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]
Figure 8
Figure 8. Figure 8: Architecture of a PolyLUT neuron [4]. Unlike traditional DNN hardware accelerators, where re￾placing linear transformations with polynomial functions in￾creases the demand for multipliers or XNOR gates, LUT￾based DNN implementations encapsulate the additional mul￾tipli…
Figure 10
Figure 10. Figure 10: Architecture of a NeuraLUT neuron [9]. limitations. The blue lines represent the quantized inputs and outputs of the L-LUT. Since the MLPs within the L-LUT may be relatively deep, training may suffer from the vanishing gradient problem. To enhance training stability, …
Figure 11
Figure 11. Figure 11: Architecture of AmigoLUT model [10]. [10] does not focus on optimizing the performance of a single model. Instead, it integrates multiple small LUT-based DNNs (such as LogicNets, PolyLUT, and NeuraLUT), ensuring that LUT resource consumption scales linearly with the n…
Figure 13
Figure 13. Figure 13: Examples of self-similarities in sub-tables [12]. [PITH_FULL_IMAGE:figures/full_fig_p008_13.png]
Figure 12
Figure 12. Figure 12: Decomposition of T into Tbias and Tst [12] [PITH_FULL_IMAGE:figures/full_fig_p008_12.png]
Figure 15
Figure 15. Figure 15: Don’t care usage example [13]. for the least dependent sub-tables. The key difference is that ReducedLUT can modify the values of don’t care conditions, enabling more sub-tables to be reconstructed using existing ones. Additionally, it employs a Boolean mask to protec…
Figure 16
Figure 16. Figure 16: Overview of the DiffLogicNet & list of all real-valued binary logic ops [14]. [PITH_FULL_IMAGE:figures/full_fig_p010_16.png]
Figure 17
Figure 17. Figure 17: Learnable Mapping & Learnable Reduction in DWNs [16]. [PITH_FULL_IMAGE:figures/full_fig_p010_17.png]
Figure 18
Figure 18. Figure 18: The architecture of a decision tree [17]. [PITH_FULL_IMAGE:figures/full_fig_p011_18.png]
Figure 19
Figure 19. Figure 19: The overall TreeLUT architecture for binary classification tasks [17]. [PITH_FULL_IMAGE:figures/full_fig_p011_19.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

23 extracted references · 23 canonical work pages

  1. [1]

    Fast inference of deep neural networks in FPGAs for particle physics,

    J. Duarte, S. Han, P. Harris, S. Jindariani, E. Kreinar, B. Kreis, J. Ngadiuba, M. Pierini, R. Rivera, N. Tran, and Z. Wu, “Fast inference of deep neural networks in FPGAs for particle physics,”J. Inst., vol. 13, no. 07, pp. P07 027–P07 027, Jul. 2018

    work page 2018

  2. [2]

    Efficient Acceleration of Deep Learning Inference on Resource-Constrained Edge Devices: A Review,

    M. M. H. Shuvo, S. K. Islam, J. Cheng, and B. I. Morshed, “Efficient Acceleration of Deep Learning Inference on Resource-Constrained Edge Devices: A Review,”Proc. IEEE, vol. 111, no. 1, pp. 42–91, Jan. 2023

    work page 2023

  3. [3]

    LogicNets: Co- Designed Neural Networks and Circuits for Extreme-Throughput Appli- cations,

    Y . Umuroglu, Y . Akhauri, N. J. Fraser, and M. Blott, “LogicNets: Co- Designed Neural Networks and Circuits for Extreme-Throughput Appli- cations,” in2020 30th International Conference on Field-Programmable Logic and Applications (FPL), Aug. 2020, pp. 291–297

    work page 2020

  4. [4]

    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,” in 2023 International Conference on Field Programmable Technology (ICFPT), Dec. 2023, pp. 60–68

    work page 2023

  5. [5]

    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 International Symposium on Field-Programmable Gate Arrays, Feb. 2017, pp. 65–74

    work page 2017

  6. [6]

    LUTNet: Rethinking Inference in FPGA Soft Logic,

    E. Wang, J. J. Davis, P. Y . K. Cheung, and G. A. Constantinides, “LUTNet: Rethinking Inference in FPGA Soft Logic,” Apr. 2019

    work page 2019

  7. [7]

    Energy-efficient, low-latency realization of neural networks through boolean logic minimization,

    M. Nazemi, G. Pasandi, and M. Pedram, “Energy-efficient, low-latency realization of neural networks through boolean logic minimization,” in Proceedings of the 24th Asia and South Pacific Design Automation Conference, Jan. 2019, pp. 274–279

    work page 2019

  8. [8]

    PolyLUT-Add: FPGA-based LUT Inference with Wide Inputs

    B. Lou, R. Rademacher, D. Boland, and P. H. W. Leong, “PolyLUT-Add: FPGA-based LUT Inference with Wide Inputs.”

    work page

Show all 23 references
  1. [9]

    NeuraLUT: Hiding Neural Network Density in Boolean Synthesizable Functions,

    M. Andronic and G. A. Constantinides, “NeuraLUT: Hiding Neural Network Density in Boolean Synthesizable Functions,” in2024 34th In- ternational Conference on Field-Programmable Logic and Applications (FPL), Sep. 2024, pp. 140–148

    2024

  2. [10]

    Greater than the Sum of its LUTs: Scaling Up LUT-based Neural Networks with AmigoLUT,

    O. Weng, J. Chen, M. Andronic, C. Geniesse, D. Zuberi, 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,” 2025

    2025

  3. [11]

    A survey on ensemble learning,

    X. Dong, Z. Yu, W. Cao, Y . Shi, and Q. Ma, “A survey on ensemble learning,”Front. Comput. Sci., vol. 14, no. 2, pp. 241–258, Apr. 2020

    2020

  4. [12]

    CompressedLUT: An Open Source Tool for Lossless Compression of Lookup Tables for Function Evaluation and Beyond,

    A. Khataei and K. Bazargan, “CompressedLUT: An Open Source Tool for Lossless Compression of Lookup Tables for Function Evaluation and Beyond,” inProceedings of the 2024 ACM/SIGDA International Symposium on Field Programmable Gate Arrays, Apr. 2024, pp. 2–11

    2024

  5. [13]

    Re- ducedLUT: Table Decomposition with

    O. Cassidy, M. Andronic, S. Coward, and G. A. Constantinides, “Re- ducedLUT: Table Decomposition with ”Don’t Care” Conditions,” Dec. 2024

    2024

  6. [14]

    Deep Differen- tiable Logic Gate Networks,

    F. Petersen, C. Borgelt, H. Kuehne, and O. Deussen, “Deep Differen- tiable Logic Gate Networks,” Oct. 2022

    2022

  7. [15]

    The Exact VC Dimension of the WiSARD n-Tuple Classifier,

    H. C. C. Carneiro, C. E. Pedreira, F. M. G. Franc ¸a, and P. M. V . Lima, “The Exact VC Dimension of the WiSARD n-Tuple Classifier,”Neural Computation, vol. 31, no. 1, pp. 176–207, Jan. 2019

    2019

  8. [16]

    Differentiable Weightless Neural Networks,

    A. T. L. Bacellar, Z. Susskind, M. B. Jr, E. John, L. K. John, P. M. V . Lima, and F. M. G. Franc ¸a, “Differentiable Weightless Neural Networks,” Dec. 2024

    2024

  9. [17]

    TreeLUT: An Efficient Alternative to Deep Neural Networks for Inference Acceleration Using Gradient Boosted Decision Trees,

    A. Khataei and K. Bazargan, “TreeLUT: An Efficient Alternative to Deep Neural Networks for Inference Acceleration Using Gradient Boosted Decision Trees,” Jan. 2025

    2025

  10. [18]

    The MNIST Database of Handwritten Digit Images for Machine Learning Research [Best of the Web],

    Li Deng, “The MNIST Database of Handwritten Digit Images for Machine Learning Research [Best of the Web],”IEEE Signal Process. Mag., vol. 29, no. 6, pp. 141–142, Nov. 2012

    2012

  11. [19]

    UNSW-NB15: A comprehensive data set for network intrusion detection systems (UNSW-NB15 network data set),

    N. Moustafa and J. Slay, “UNSW-NB15: A comprehensive data set for network intrusion detection systems (UNSW-NB15 network data set),” in2015 Military Communications and Information Systems Conference (MilCIS), Nov. 2015, pp. 1–6

    2015

  12. [20]

    Codesign-NAS: Automatic FPGA/CNN Codesign Using Neural Architecture Search,

    M. S. Abdelfattah, L. Dudziak, T. Chau, R. Lee, H. Kim, and N. D. Lane, “Codesign-NAS: Automatic FPGA/CNN Codesign Using Neural Architecture Search,” inProceedings of the 2020 ACM/SIGDA Interna- tional Symposium on Field-Programmable Gate Arrays, Feb. 2020, pp. 315–315

    2020

  13. [21]

    DeepSeek- R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning,

    DeepSeek-AI, D. Guo, D. Yang, H. Zhang, J. Song, R. Zhang, R. Xu, Q. Zhu, S. Ma, P. Wang, X. Bi, X. Zhang, X. Yu, Y . Wu, Z. F. Wu, Z. Gou, Z. Shao, Z. Li, Z. Gao, A. Liu, B. Xue, B. Wang, B. Wu, B. Feng, C. Lu, C. Zhao, C. Deng, C. Zhang, C. Ruan, D. Dai, D. Chen, D. Ji, E. L...

    2025

  14. [22]

    Microscal- ing Data Formats for Deep Learning,

    B. D. Rouhani, R. Zhao, A. More, M. Hall, A. Khodamoradi, S. Deng, D. Choudhary, M. Cornea, E. Dellinger, K. Denolf, S. Dusan, V . Elango, M. Golub, A. Heinecke, P. James-Roxby, D. Jani, G. Kolhe, M. Lang- hammer, A. Li, L. Melnick, M. Mesmakhosroshahi, A. Rodriguez, M. Schult...

    2023

  15. [23]

    Explor- ing FPGA designs for MX and beyond,

    E. Samson, N. Mellempudi, W. Luk, and G. A. Constantinides, “Explor- ing FPGA designs for MX and beyond,” Jul. 2024. APPENDIX 15 TABLE II MODEL SETUPS OFLOGICNETS Dataset Model Name Nodes per Layerβ FExceptions Jet substructure JSC-L 32, 64, 192, 192, 16 3 4β i = 4,β o = 7,F o...

    2024

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.