betaFeedback

WorksComputer Science

ConvLUT: Rethinking Convolutional Architectures for Ultra-Low-Latency LUT-Based Inference

Abstract

Lookup-table (LUT)-based neural networks (NNs) offer a compelling path to ultra-low-latency inference on FPGAs. However, existing LUT-based neural networks have largely been restricted to MLP-style topologies, leaving structured vision and audio tasks underexplored. We present ConvLUT, a family of fully unrolled LUT-mappable convolutional architectures targeting the MLPerf Tiny benchmarks. It is comprised of a standard convolutional model built around a hierarchical tree of LUTs and a depthwise separable model following the MobileNet design philosophy. These architectures are enabled by four key contributions: a unified LUT-based convolutional framework supporting standard, depthwise, and pointwise convolutions under explicit fan-in constraints; a LUT-tree that addresses the k2ck^2c receptive field dimensionality bottleneck; a channel-partitioned LUT pooling layer that replaces conventional spatial pooling; and a hardware-aware iterative pruning strategy for stable convergence at scale. Evaluated on CIFAR-10, Visual Wake Words, and Keyword Spotting, ConvLUT achieves competitive accuracy with fully unrolled inference latencies below ∼50\sim 50 ns. On CIFAR-10 it reaches at least a 8844×8844\times latency reduction over non-logic-based prior implementations, and outperforms existing MLP-style LUT-based models on the same task by at least 2020 pp in test accuracy.

Introduction and Motivation

LUT-based NNs are a promising alternative to multiply-accumulate-centric architectures, particularly in hardware-constrained environments requiring ultra-low latency. By replacing arithmetic operations with discrete function approximators, LUT-based models eliminate costly multiplications and enable efficient mapping to FPGA platforms.

Differentiable weightless neural networks (DWNs) [5] and differentiable logic gate networks (DiffLogicNets) [17] train LUT/gate networks using differentiable relaxations of discrete Boolean functions. In contrast, works such as LogicNets [20] and NeuraLUT [2] follow a different strategy: neural networks are trained under structural constraints—bounded fan-in and quantized activations—such that the model compiles directly into Logic LUTs (L-LUTs), i.e., lookup tables of arbitrary size rather than FPGA LUT primitives. NeuraLUT-Assemble [3] extends this approach by incorporating tree-structured LUT compositions and the one-shot magnitude pruning from [4], thereby improving scalability in MLP-style architectures.

Despite these advances, existing LUT-based architectures use relatively simple layers and do not scale to tasks that traditionally require convolutional operations [3, 5]. Logic-gate-based architectures that do support convolutions [18] exist, but their reliance on 2-input gates does not directly exploit the larger fan-in of native FPGA LUT primitives. Thus, extending LUT-based networks to convolutional architectures in a hardware-aware manner remains an open problem.

In NeuraLUT, each L-LUT absorbs a fully connected MLP with skip connections, but is subject to a bounded input fan-in constraint FF and bitwidth BB. Keeping FF and BB small is crucial for mapping L-LUTs to FPGAs because the L-LUT size grows as 2BF2^{BF}. Scaling the L-LUT construction to full convolutional networks thus introduces three key challenges. First, a k×kk \times k kernel over cc channels induces an input dimensionality of k2c≫Fk^2c \gg F. If we set F=k2cF = k^2c, we would quickly run out of LUTs on the FPGA. Naïvely pruning to satisfy this constraint severely restricts the receptive field, decreasing accuracy. Second, classical pooling operations feature large fan-in, exploding resource usage. Third, one-shot pruning, sufficient for MLPs, does not converge well at convolutional scale, as seen in our experiments. These three challenges prevent us from constructing convolutional L-LUT models with competitive accuracy within an FPGA’s resource constraints.

We address these challenges from an architectural perspective. We develop a unified L-LUT convolutional framework called ConvLUT that supports standard, depthwise, and pointwise convolutions under explicit fan-in constraints, with each output channel maintaining its own learned sparsity pattern shared across spatial positions. In ConvLUT, the standard convolution presents the hardest case: its k2ck^2c input dimensionality far exceeds FF, requiring a dedicated solution (Figure 1). We therefore introduce a hierarchical LUT tree construction in which structured sparse pointwise layers compose multiple fan-in-bounded units, aggregating an extended portion of the receptive field while preserving LUT-mappability. Depthwise convolution, whose dimensionality scales only with k2k^2, and pointwise convolution, whose dimensionality scales with cc, require no such decomposition and can be brought within hardware limits with modest pruning.

Figure 1. Traditional and proposed convolutional kernels. Top row: a standard dot-product kernel connects every input within the kc2k_c^2 receptive field. Bottom row: the proposed L-LUT kernel replaces the dot product with a NeuraLUT surrogate [2]. Each output channel learns its own sparsity pattern, which is shared across all spatial positions during the sliding operation. Fan-in is kept at FF inputs per L-LUT.

To replace classical pooling, we propose a channel-partitioned LUT-based spatial pooling layer implemented as a structured sparse fully connected layer in which each L-LUT neuron aggregates inputs from a single channel, preserving spatial separation while enabling a richer learned aggregation function.

Scaling these architectures further requires careful sparsification. Direct one-shot pruning, which was sufficient in earlier small-scale NeuraLUT-Assemble models [3], becomes unusable at larger scales because accuracy falls dramatically. Thus, we introduce a hardware-aware iterative pruning strategy that progressively enforces fan-in constraints during training.

With ConvLUT, we construct two families of LUT-mappable CNN architectures. The first follows a standard convolutional design, leveraging the hierarchical LUT tree. The second adopts a depthwise separable design inspired by MobileNet [10], combining depthwise and pointwise convolutions to reduce computational complexity.

This combination of architectural restructuring and iterative hardware-aware pruning enables NeuraLUT to scale beyond MLP-style networks and tackle MLPerf Tiny benchmarks, including CIFAR-10, Visual Wake Words, and Keyword Spotting. These tasks require spatial or spectro-temporal processing and have historically been difficult to address with LUT-mappable MLPs without significant accuracy degradation. In the spirit of LUT-based neural networks, all models are implemented fully unrolled, instantiating each L-LUT for all spatial windows to achieve ultra-low latency inference. Our focus is to demonstrate that ConvLUT scales to significantly harder tasks than previously attempted.

In this paper, we make the following novel contributions:

  • We introduce ConvLUT, a family of LUT-based convolutional architectures, comprising both standard and depthwise separable models, enabled by a unified framework supporting standard, depthwise, and pointwise L-LUT convolutions under explicit fan-in constraints.

  • We propose a hierarchical LUT tree construction for standard convolution, where structured sparse pointwise layers compose fan-in-bounded L-LUTs to extend the effective receptive field without violating hardware constraints.

  • We introduce a channel-partitioned LUT pooling layer that replaces spatial pooling with a learned, channel-wise aggregation.

  • We propose a hardware-aware iterative pruning strategy that progressively enforces fan-in constraints during training, enabling stable convergence at the scale of convolutional networks where one-shot pruning fails.

  • We demonstrate competitive accuracy on three MLPerf Tiny benchmarks—CIFAR-10, Visual Wake Words, and Keyword Spotting—while achieving inference latencies below ∼\sim50 ns, representing a minimum of 1850× reduction over non-LUT-based prior implementations.

Background

LUT-Based and Logic-Based Neural Networks

Ultra-low latency accelerators can be broadly divided into two categories. The first trains models directly in the logic domain using differentiable relaxations of Boolean operators, as in DWN [5] and LUTNet [21, 22]. DiffLogicNets [17] constructs networks from primitive operations such as AND and XOR, and have been extended to convolutional architectures [18] through tree-structured compositions of logic gates.

The second category follows a constraint-based approach, as in LogicNets [20], PolyLUT [1], PolyLUT-Add [14], AmigoLUT [24], and NeuraLUT [2]. Here, neural networks are trained with bounded fan-in and quantized activations, such that the resulting model can be mapped to a circuit of L-LUTs.

A key distinction between these paradigms lies in how well their computational primitives match the underlying hardware primitives. LUT-based approaches map efficiently to the FPGA fabric, while logic gate networks require synthesis into circuits of larger LUT primitives that can introduce routing overhead at scale. This limitation was observed by the authors of DWN [5], who reported that neither their larger networks of 2-input gates nor DiffLogicNets could be successfully synthesized. As a result, logic-gate networks may be better suited to ASIC platforms, where such fine-grained primitives are native.

Convolutional Neural Networks (CNNs)

CNNs form the foundation of modern vision and audio models. Extending LUT-based neural networks to convolutional architectures presents several fundamental challenges. First, the receptive field of a standard convolution scales as k2ck^2c, which is typically much larger than the allowable fan-in FF. Enforcing this constraint through pruning severely restricts each neuron’s connectivity, limiting its ability to capture information from the full receptive field.

SymbolDescription
ccNumber of input channels
NNNumber of output channels
kkSpatial kernel size (k×kk \times k)
h,wh,wInput feature map height and width
FFL-LUT input fan-in
BBActivation bitwidth

Table 1. Summary of convolutional notation.

The PolyLUT [4] extension introduced a hardware-aware regularization scheme that incorporates fan-in constraints into training and performs one-shot pruning. NeuraLUT-Assemble [3] extends the scalability of this framework by introducing tree-structured compositions of L-LUTs, enabling the effective fan-in of a neuron to be increased without exceeding hardware limits. Unfortunately, neither approach generalizes directly to convolutional layers, where the receptive field is shared across spatial locations and channels.

Second, classical pooling operations are incompatible with LUT-based implementations because they require aggregating over large input windows, leading to fan-in requirements that exceed what can be implemented efficiently using LUTs.

Taken together, these limitations highlight a gap in existing approaches. Methods that enforce hardware constraints, such as NeuraLUT or NeuraLUT-Assemble [3], do not scale to convolutional architectures, and methods that support convolutional structures, such as DiffLogicNets [18], do not explicitly align with FPGA LUT primitives.

Hardware Constraints for LUT-based Inference

LUT-based inference imposes strict architectural constraints that fundamentally shape network design. Each neuron is implemented as an L-LUT with fan-in FF and input bitwidth BB making the corresponding truth table contain 2BF2^{BF} entries. This exponential scaling makes large fan-in infeasible in practice, requiring networks to operate under tight connectivity budgets. Consequently, the primary design challenge is not computational complexity within each LUT but the ability to express the desired function under strict fan-in and connectivity constraints while maintaining efficient mapping to hardware.

In addition, LUT-based designs are typically deployed in a fully unrolled configuration, where all operations are instantiated spatially and executed in parallel. In this regime, latency is determined by circuit depth rather than sequential computation, and throughput is maximized by eliminating control flow and data reuse.

ConvLUT

L-LUT Convolution

A standard convolutional layer computes each output activation as a dot product between a learned weight vector and a local input patch. In ConvLUT, we replace this dot product with a NeuraLUT computational block [2], which is trained using a skip-connected MLP as a differentiable surrogate and compiled into an L-LUT for inference (shown in Figure 1).

A key insight of this construction is that the sparsity pattern and the L-LUT function can be shared across spatial positions during the sliding operation, directly analogous to weight sharing in standard convolutions. As in Figure 2, each of the NN output channels has its own distinct learned sparsity pattern and function over the k2ck^2c receptive field, but applies it identically at every spatial location. In a fully unrolled implementation, one L-LUT is instantiated per output channel per spatial window, achieving throughput equal to clock frequency. This unrolling factor, equal to the number of spatial windows, directly determines the resource cost of each layer (Table 2).

Figure 2. A sparse L-LUT convolutional layer with 3 input channels and NN output channels. Each channel maintains its own learned sparsity pattern over the k2ck^2c receptive field. The resulting output volume has NN channels, each encoding a distinct sparse projection of the local neighbourhood.

Table 2: Architecture configurations. The unrolling factor denotes the number of spatial windows per resolution stage, i.e. the number of parallel L-LUT instances implementing the same sparse kernel. The total number of L-LUTs equals the number of channels (or neurons), as each is mapped to a single L-LUT. Theoretically, each L-LUT occupies Y3(2X−4−(−1)X)\frac{Y}{3}(2^{X-4}-(-1)^X) 6-LUTs as per [20]. For the input convolution: Y=BhY=B_h, X=BinFinX=B_{\mathrm{in}}F_{\mathrm{in}}; for hidden convolutions: Y=BhY=B_h, X=BhFconvX=B_hF_{\mathrm{conv}}; for pooling: Y=BhY=B_h, X=BhFfcX=B_hF_{\mathrm{fc}}; and for the final FC layer: Y=BoutY=B_{\mathrm{out}}, X=BhFfcX=B_hF_{\mathrm{fc}}.

Model (Dataset)Bitwidth Bin/Bh/BoutB_{\mathrm{in}}/B_h/B_{\mathrm{out}}Fan-in Fin/Fconv/FfcF_{\mathrm{in}}/F_{\mathrm{conv}}/F_{\mathrm{fc}}Conv layers: unrolling factor × (channels per layer) unrolling factor × L-LUTs per layerPool L-LUTsFC L-LUTs
CNN-S4/2/32/4/4256 × (14 + 56 + 14); 64 × (112 + 28); 16 × (224 + 56)2,2402,240
CNN-M4/2/32/4/4256 × (28 + 224 + 56 + 14); 64 × (448 + 112 + 28); 16 × (896 + 224 + 56)2,2402,240
CNN-L4/2/32/4/5256 × (50 + 400 + 100 + 25); 64 × (800 + 200 + 50); 16 × (1600 + 400 + 100)4,000(4,000)×2
DS-CNN-A4/2/42/4/480 × (32 + 32 + 64); 20 × (64 + 128); 10 × (128 + 256)1,5361,536
DS-CNN-B4/2/42/4/480 × (64 + 64 + 128); 20 × (128 + 256); 10 × (256 + 512)3,0723,072
DS-CNN-C3/2/32/3/32304 × (8 + 8 + 16); 576 × (16 + 32); 144 × (32 + 64); 36 × (64 + 128)3,8403,840
DS-CNN-D4/2/22/4/42304 × (8 + 8 + 16); 576 × (16 + 32); 144 × ((32) × 3 + 64); 36 × ((64) × 3 + 128)3,8403,840

Table 2.

We extend this construction to all three convolution types used in modern efficient architectures, illustrated in Figure 3. Standard convolution assigns each L-LUT neuron a sparse subset of the full k2ck^2c receptive field, spanning both spatial and channel dimensions. Depthwise convolution restricts each neuron to a single input channel, with sparsity over the k2k^2 spatial locations only, naturally reducing receptive field dimensionality. Pointwise convolution operates across all input channels at a single spatial location, with sparsity over the channel dimension. Supporting all three types within a unified fan-in-constrained framework is a prerequisite for realizing CNN architectures as fully LUT-mappable networks.

Figure 3. Convolution types supported by ConvLUT. In standard convolution (a), each L-LUT neuron selects a sparse subset of the full k2ck^2c receptive field. In depthwise convolution (b), neurons are restricted to a single input channel, with sparsity over the k2k^2 spatial locations. In pointwise convolution (c), neurons operate across all channels at a single spatial location, with sparsity over the channel dimension. In all cases, each output channel maintains its own learned sparsity pattern, which is shared across spatial positions during the sliding operation.

Although our analysis and results use NeuraLUT as the LUT primitive, the architectural principles introduced in this work are not specific to this formulation. Any LUT-based surrogate can be embedded within ConvLUT. Our contributions therefore extend beyond NeuraLUT and provide general guidelines for scaling LUT-based models to structured vision and audio tasks.

LUT Tree Convolution

A key challenge in LUT-based convolution is the receptive field dimensionality. In standard convolution, each output neuron receives k2ck^2c inputs. Since each neuron is implemented as an L-LUT with a fixed fan-in F≪k2cF \ll k^2c, aggressive pruning is required to reduce connectivity to within the hardware budget. When k2ck^2c is large, the information discarded by pruning is substantial, limiting the expressiveness of each layer.

To address this, we propose LUT tree convolution: a multi-layer construction that expands the effective receptive field without violating the fan-in constraint. The key observation is that in a standard convolutional layer, all output channels share the same spatial receptive field. Multiple output channels can therefore learn different sparse connectivity patterns over the same k2ck^2c-dimensional input patch, each capturing a complementary view of the local neighborhood. A subsequent pointwise layer with structured fixed sparsity aggregates groups of these channels into each output neuron, forming the second level of the tree (Figure 4). Since each input channel to the pointwise layer has already distilled a distinct sparse projection of the shared receptive field, the pointwise neuron effectively combines information from a much larger portion of the original patch than any single L-LUT could handle.

LUT Tree Convolution showing sparse channel patterns and effective receptive-field coverage

Figure 4. LUT Tree Convolution: A standard convolutional layer produces NN output channels, each learning a distinct sparse pattern over the shared k2ck^{2}c-dimensional receptive field (colored dots indicate active connections per channel). A subsequent pointwise layer with fixed structured sparsity aggregates groups of G=FG = F channels into single L-LUT neurons (each channel occupies one fan-in input, so the group size is bounded by the fan-in budget FF). The effective receptive field (bottom bar) covers the union of all those channel patterns and some locations remain uncovered due to the finite fan-in budget FF.

Formally, let output channel nn have sparsity mask mn∈{0,1}k2cm_n \in\{0,1\}^{k^2c} with FF non-zero entries. The pointwise layer groups channels into blocks of size GG, with each output neuron connected to one block via a fixed structured mask. Since the L-LUT is constrained by fan-in FF, at most FF channels can be aggregated, i.e. G≤FG \le F. We therefore set G=FG = F. The effective receptive field therefore spans up to G⋅F=F2G \cdot F = F^2 input locations, compared to FF for a single-stage L-LUT (Figure 4). This construction can be extended by stacking additional pointwise layers to further expand the receptive field.

This construction is specific to standard convolutions. In depthwise convolutions, each output channel operates over a single input channel, so different output channels correspond to entirely different input patches. Aggregating across depthwise channels via a pointwise layer does not produce the same receptive field expansion, as the channels carry spatially disjoint information.

LUT-Based Spatial Pooling Layer

In LUT-based frameworks, deploying a conventional pooling layer presents a fundamental incompatibility: average and max pooling operate over potentially large input windows that do not map naturally onto the L-LUT abstraction, requiring fan-ins far beyond the 4-6 inputs practical for FPGA implementation. A direct implementation would introduce a bottleneck that undermines the uniform, ultra-low latency design that makes LUT-based inference attractive in the first place.

We propose replacing the pooling layer with a structured, sparse fully connected L-LUT layer (Figure 5). This approach offers two complementary advantages. First, by constraining each output neuron to receive inputs exclusively from the spatial feature map of a single convolutional channel, we preserve the channel-wise spatial aggregation behavior of classical pooling. Second, rather than applying a fixed max or average operation, each neuron implements a learned surrogate function, enabling increased expressivity in spatial aggregation. The result is a pooling replacement that is both architecturally consistent with the surrounding LUT layers and capable of learning richer aggregation functions than standard fixed pooling operators.

Figure 5. Channel-partitioned LUT pooling layer: The flattened convolutional output is partitioned by channel, with each L-LUT neuron constrained to receive inputs exclusively from a single channel’s spatial feature map. Output neurons are assigned to channels in an interleaved fashion, so that multiple neurons attend to each channel, compensating for information lost through pruning. Solid arrows indicate active connections after pruning to fan-in FF; dashed arrows indicate pruned connections. Each neuron implements a learned sparse spatial aggregation via the NeuraLUT surrogate [2], replacing fixed max or average pooling.

Channel-Partitioned Connectivity Mask

Let the input after the final convolutional layer have cc channels and a spatial resolution of h×wh \times w, yielding a flattened feature vector of dimension c⋅h⋅wc \cdot h \cdot w. The subsequent fully connected layer maps this to NN output neurons. We define a binary connectivity mask M∈{0,1}N×c⋅h⋅wM \in\{0,1\}^{N \times c \cdot h \cdot w} that enforces a strict channel-partitioned structure. Specifically, we partition the NN output neurons into cc interleaved groups of K=N/cK = N/c neurons each, enforcing that cc divides NN. Neuron ii is assigned to channel ci=i mod cc_i = i \bmod c, and its receptive field is restricted to the P=h⋅wP = h \cdot w inputs corresponding to that channel:

Mi,j={1if ⌊j/P⌋=(i mod c)0otherwise(1)M_{i,j} = \begin{cases} 1 & \text{if } \lfloor j/P \rfloor= (i \bmod c) \\ 0 & \text{otherwise} \end{cases} \tag*{(1)}

where j∈{0,…,c⋅P−1}j \in\{0,\ldots,c \cdot P - 1\} indexes the flattened input. This interleaved assignment ensures that each channel is attended to by exactly KK output neurons, distributing representational capacity across channels.

Learned Sparse Spatial Aggregation

Within each neuron’s receptive field of PP spatial inputs, the connectivity is further sparsified through our iterative magnitude pruning. Starting from the full channel receptive field, connections are pruned to a target fan-in F≪PF \ll P.

The redundancy introduced by assigning K>1K > 1 neurons to each channel is intentional. Since each neuron ultimately observes only FF of the PP spatial locations, multiple neurons per channel allow the network to collectively cover the spatial extent of each feature map more richly. Different neurons assigned to the same channel learn to specialize on different sparse subsets of spatial locations, providing complementary views of each channel’s feature map.

Architectures

CIFAR-10: Standard Convolutional Models

The CIFAR-10 architecture follows a plain convolutional backbone in which all spatial mixing is performed by standard 3×33 \times3 L-LUT convolutional layers, interleaved with pointwise layers that serve as LUT tree aggregators as described in § 3.2. The network takes a 32×3232 \times32 RGB image as input and progressively reduces the spatial resolution through strided convolutions while expanding the channel dimension (Figure 3).

The backbone begins with two standard 3×33 \times3 convolutional layers. The first applies a stride of two to halve the spatial resolution; the second operates at stride one. The remainder of the backbone consists of repeated blocks, each comprising one or more 1×11 \times1 pointwise layers followed by a strided 3×33 \times3 standard convolution. The pointwise layers act as the aggregation stage of the LUT tree, combining the complementary sparse views of the receptive field assembled by the preceding standard convolution. The strided convolution then halves the spatial resolution and doubles the number of channels, following the standard practice of trading spatial resolution for channel depth as the network deepens. A final pointwise layer projects the features to the desired channel count before the spatial dimensions are collapsed.

We consider two variants that differ in the depth of the LUT tree (Figure 6). In the first variant, each block contains a single pointwise layer, forming a depth-2 tree. In the second variant, each block contains two consecutive pointwise layers, forming a depth-3 tree, allowing a larger effective receptive field.

Figure 6. Architecture overview of the two model families. Left: the CIFAR-10 CNN model, in which each block comprises one or two pointwise layers acting as LUT tree aggregators, as seen in § 3.2, followed by a strided standard convolution. The faded second pointwise layer is present only in the depth-3 variant. Right: the DS-CNN model used for VWW and KWS, following the MobileNet [10] structure, in which each block pairs a pointwise layer for cross-channel mixing with a strided depthwise convolution for spatial downsampling. The LUT tree construction does not apply here. Both architectures share the same classifier head: a channel-partitioned LUT pooling layer (as described in § 3.3), a fully connected L-LUT layer, and a group sum producing the final class scores.

After the convolutional backbone the feature map is flattened and passed through the channel-partitioned LUT pooling layer described in § 3.3, which replaces the conventional spatial pooling operation. A fully connected L-LUT layer follows, and the final classification scores are computed by a group sum over the output neurons, with one group per class.

VWW and KWS: Depthwise Separable Models

The depthwise separable models (Figure 6) take inspiration from MobileNet [10], factorizing each standard convolution into a depthwise convolution that performs spatial mixing within each channel independently, followed by a pointwise convolution that mixes across channels at a single spatial location. This factorization reduces the receptive field dimensionality from k2ck^2c to k2+ck^2+c, substantially reducing the information discarded by fan-in pruning and making the architecture well suited to highly resource-constrained LUT budgets. Note that because depthwise convolutions operate channel-wise, the LUT tree construction of § 3.2 does not apply here.

The backbone opens with a standard convolutional layer, followed by a depthwise convolution at stride one. The remainder of the backbone consists of repeated depthwise-separable blocks, each comprising a pointwise layer followed by a strided depthwise convolution. Each strided convolution halves the spatial resolution and each pointwise convolution doubles the channel count, progressively concentrating spatial information into the channel dimension. A final pointwise layer produces the output feature map before the spatial dimensions are collapsed.

The VWW and KWS models differ primarily in their input modality and first-layer design. The VWW model takes 96×9696 \times96 RGB images as input, and the initial convolution uses a standard 3×33 \times3 kernel. The KWS model operates on single-channel mel spectrograms and uses a 40×440 \times4 first-layer kernel, whose tall, narrow shape is tailored to the frequency–time structure of the spectrogram representation.

Following the convolutional backbone, both models pass the flattened features through the channel-partitioned LUT pooling layer, a fully connected L-LUT layer, and a final group sum.

Algorithm 1: Hardware-aware iterative pruning. The schedule SS progressively tightens the fan-in across TT stages, F1>F2>⋯>FT=F∗F_1 > F_2 > \cdots> F_T = F^*, to the target fan-in F∗F^*. After each prune step, the model retrains for EtE_t epochs with masks frozen, allowing weights to recover before connectivity is reduced further.

Input: Model M\mathcal{M}; pruning schedule S={(Ft,Et)}t=1TS = \{(F_t, E_t)\}_{t=1}^{T}, where FtF_t is the fan-in target and EtE_t the number of retraining epochs for stage tt, with F1>⋯>FT=F∗F_1 > \cdots> F_T = F^*

Output: All masks M(l)\mathbf{M}^{(l)} satisfy the hardware fan-in FF

foreach stage (Ft,Et)∈S(F_t, E_t) \in S do

    foreach prunable layer ll, each neuron nn do

        Mn(l)←TopK⁡(∣wn(l)⊙Mn(l)∣,Ft)\mathbf{M}^{(l)}_n \leftarrow\operatorname{TopK}(\lvert\mathbf{w}^{(l)}_n \odot\mathbf{M}^{(l)}_n\rvert, F_t)

    for epoch =1= 1 to EtE_t do

        Train M\mathcal{M} with LCE+Ω(W)\mathcal{L}_{\mathrm{CE}} + \Omega(W), masks frozen;

Fine-tune M\mathcal{M} without regularization (Ω(W))(\Omega(W)).

Iterative pruning

Direct one-shot pruning, sufficient for the smaller MLP-style models in NeuraLUT-Assemble [3], becomes unstable at convolutional scale. We therefore adopt a hardware-aware iterative pruning strategy, summarized in Algorithm 1.

Rather than enforcing the target fan-in F∗F^* immediately, the pruning schedule progressively tightens connectivity across TT stages. At each stage, pruning is applied to all prunable layers, i.e., all layers except the pointwise layers part of the LUT tree construction. For each neuron nn in layer ll, only the FtF_t highest-magnitude active connections are retained, and the mask is updated based on the currently active weights wn(l)⊙Mn(l)\mathbf{w}^{(l)}_n \odot\mathbf{M}^{(l)}_n.

Following each prune step, the model retrains for EtE_t epochs with all masks frozen, minimizing the objective

L=LCE+Ω(W),(2)\mathcal{L} = \mathcal{L}_{\mathrm{CE}} + \Omega(W), \tag*{(2)}

where LCE\mathcal{L}_{\mathrm{CE}} is cross entropy loss and Ω(W)\Omega(W) is the exponential regularizer of PolyLUT [4].

After the final stage reaches F∗F^*, the model undergoes a final fine-tune without regularization.

Toolflow

ConvLUT builds upon the NeuraLUT toolflow [2], which provides an end-to-end pipeline from quantization-aware training (QAT) through L-LUT conversion, and RTL generation and compilation. The implementation has been extended to support convolutional layers, the channel-partitioned pooling layer, and the iterative pruning described in § 3.6.

QAT

Training is implemented in PyTorch. The model is trained using the Adam optimizer with a cosine annealing schedule, with quantization applied via Brevitas [16]. Input bitwidth BinB_{\mathrm{in}}, hidden bitwidth BhB_h, output bitwidth BoutB_{\mathrm{out}}, and fan-in FF are specified per model as listed in Table 2.

L-LUT conversion and verification

After training, each L-LUT is materialized by exhaustive enumeration: all 2B⋅F2^{B \cdot F} input combinations are evaluated through the trained sub-network to populate the lookup table. Functional correctness is verified at two levels: first, by running inference through the LUT logic model in place of PyTorch operations and confirming the accuracy; second, by using an Icarus Verilog [25] simulation of the generated Verilog to validate the RTL against the same test vectors.

RTL generation and synthesis

Synthesis and place-and-route are performed using Vivado 2020.1, with PerformanceOptimized and out-of-context. This follows prior works [1, 2, 12, 20, 24]. The goal is to isolate the neural network computation from platform-dependent infrastructure, such as memory controllers and external I/O, enabling consistent comparisons of the computational designs. Consequently, reported latency characterizes the implemented inference datapath rather than complete system-level inference latency.

Evaluation metrics

ConvLUT adopts the established open-source hardware implementation and evaluation framework used by prior ultra-low-latency LUT-based neural networks [1, 3, 14, 20, 24], including register placement, out-of-context (OOC) synthesis, latency and throughput definitions, and FPGA resource reporting. This deliberate choice preserves direct comparability with prior work while isolating the impact of ConvLUT’s architectural and training innovations.

Our evaluation addresses a fundamental question: can the ultra-low-latency LUT-based inference paradigm scale beyond relatively simple, MLP-oriented architectures to substantially more complex CNN workloads while preserving its defining hardware properties? Specifically, we investigate whether LUT-based inference can support MLPerf Tiny [6] workloads while maintaining nanosecond-scale latency, deterministic execution, and fully-unrolled computation.

The objective is therefore not to introduce a new hardware evaluation methodology, but to quantify the architectural implications of extending the established LUT-based paradigm to convolutional networks. In particular, our evaluation demonstrates the latency and area trade-offs associated with replacing conventional MAC-based convolution with LUT-based computation.

ConvLUT employs a fully-unrolled architecture, with computational operators spatially instantiated rather than time-multiplexed. With the adopted register placement and pipelining, this enables an initiation interval of one clock cycle (II=1), allowing a new input to be accepted every clock cycle. We distinguish inference latency, defined by the number of pipeline stages and clock period, from throughput, determined by the initiation interval and clock frequency.

We additionally report Area×Delay Product (ADP), following prior LUT-based work, as a combined measure of the two principal optimization objectives: FPGA resource utilization and inference latency. Since fully-unrolled implementations inherently trade increased spatial resources for reduced latency, ADP provides a complementary metric for characterizing this trade-off alongside the individual area and latency measurements.

Evaluation

We evaluate ConvLUT on 3 MLPerf Tiny benchmarks [6]:

CIFAR-10 [13]: 32 × 32 RGB images, 10 classes. The 50,000 training images are split 80/20 into train and validation subsets; the 10,000-image test set is held out for final evaluation.

Keyword Spotting (KWS): The MLPerf Tiny adaptation of Google Speech Commands [23], accessed via TensorFlow Datasets [19], targeting 12 classes. The training set is class-imbalanced; we apply loss scaling to compensate. Audio is preprocessed into mel spectrograms.

Visual Wake Words (VWW): vw_coco2014_96 [8], distributed as part of the MLPerf Tiny benchmark. Binary person detection at 96 × 96 resolution, split 80/10/10 into train, validation, and test subsets.

Comparison with prior work

We evaluate ConvLUT against two complementary classes of prior work: ultra-low-latency LUT-based neural networks and conventional FPGA CNN accelerators. The former establish the implementation methodology and hardware regime that ConvLUT seeks to preserve, while the latter represent the more complex application domain that ConvLUT aims to address. No single baseline fully captures both dimensions.

Accordingly, comparisons with prior LUT-based networks demonstrate the architectural progression toward more complex workloads, whereas comparisons with conventional CNN accelerators quantify the latency and resource trade-offs of adopting a fully-unrolled LUT-based implementation.

These comparisons are intended to characterize distinct architectural design points rather than imply equivalent implementation constraints. In particular, ConvLUT prioritizes ultra-low inference latency through extensive spatial parallelism, at the expense of increased hardware resource utilization.

Across all benchmarks, ConvLUT achieves the lowest reported area–delay product, reaching latencies as low as 9 ns (Table 3–Table 4–Table 5). Model architecture details are provided in Table 2. For each model, we report two operating points: a minimally pipelined design minimizing latency, and a more pipelined variant trading latency for higher frequency. Here, latency is reported as pipeline depth times clock period, while throughput assumes an initiation interval of one cycle (II=1).

Table 3: Comparison of FPGA implementations on CIFAR-10. N/R = not reported. {sup}§No pipeline registers reported; single-cycle inference assumed. {sup}†Theoretical gate count without the group sum layer; FPGA utilization not reported. {sup}∗`Results taken from out-of-context. The area delay column represents the product of LUTs and latency.

WorkAcc. (%)LUT (% util)FFBRAMDSPLatency (ns)Throughput (FPS)Fmax⁡F_{\max} (MHz)Area×DelayFPGA
LL-ViT [15]95.5589,000229,0001,42505,330,000,0001,0832003.14×10153.14 \times10^{15}VU9P
H-WNN L{sup}∗ {citep}[11]`88.2320,720N/R235N/R6,840,000,000N/R1001.42×10131.42 \times10^{13}Pynq-Z1
H-WNN S{sup}∗ {citep}[11]`84.6222,870N/R110N/R1,600,000,000N/R1003.66×10123.66 \times10^{12}Pynq-Z1
hls4ml TinyML [7]83.528,54449,21542427,300,000N/RN/R8.82×10118.82 \times10^{11}Pynq-Z2
FINN TinyML [7]84.524,50234,35410001,500,000N/RN/R3.99×10103.99 \times10^{10}Pynq-Z2
fpgaconvnet [9]86.047,000N/R93211410,000N/R1431.93×10101.93 \times10^{10}Z-7020
FINN [26]80.146,253N/R186N/R283,00021.9K2001.31×10101.31 \times10^{10}Z-7045
DWN{sup}∗ ($n=6$) {citep}[5]`57.4216,700N/RN/RN/RN/R250M250N/RZ-7045
LogicTreeNet-B{sup}∗ {citep}[18]`80.1716M{sup}†`N/RN/RN/R24{sup}§`41.6M41.63.84×1083.84 \times10^{8}VU13P
LogicTreeNet-M{sup}∗ {citep}[18]`71.013M{sup}†`N/RN/RN/R9{sup}§`111.1M111.12.70×1072.70 \times10^{7}VU13P
ConvLUT CNN-S{sup}∗` (2 cycles)70.78290,715 (25%)9,061009216M2162.62×1062.62 \times10^{6}VU9P
ConvLUT CNN-S{sup}∗` (10 cycles)70.78308,895 (26%)90,1910030337M3379.27×1069.27 \times10^{6}VU9P
ConvLUT CNN-M{sup}∗` (2 cycles)75.861,015,299 (40%)16,7490020101M1012.03×1072.03 \times10^{7}VU440
ConvLUT CNN-M{sup}∗` (13 cycles)75.861,157,752 (46%)303,7640078167M1679.03×1069.03 \times10^{6}VU440
ConvLUT CNN-L{sup}∗` (2 cycles)80.082,130,538 (84%)28,176003262M626.82×1076.82 \times10^{7}VU440
ConvLUT CNN-L{sup}∗` (14 cycles)80.082,454,784 (97%)539,4720018277M774.47×1084.47 \times10^{8}VU440

Table 3.

Table 4: Comparison of FPGA implementations on keyword spotting (KWS) using the Speech Commands dataset. N/R = not reported. {sup}∗`Results taken from out-of-context.

WorkAcc. (%)LUT (% util)FFBRAMDSPLatency (ns)Throughput (FPS)Fmax⁡F_{\max} (MHz)Area×DelayFPGA
H-WNN L{sup}∗ {citep}[11]`81.5222,870N/R110N/R1,600,000,000N/R1003.66×10133.66 \times10^{13}Pynq-Z1
H-WNN S{sup}∗ {citep}[11]`78.2217,740N/R42N/R640,000,000N/R1001.14×10131.14 \times10^{13}Pynq-Z1
fpgaconvnet [9]91.137,000N/R97188320,000N/R1431.18×10101.18 \times10^{10}Z-7020
FINN TinyML [7]82.533,73234,40537017,000N/RN/R5.91×1085.91 \times10^{8}Pynq-Z2
DWN{sup}∗ ($n=6$) {citep}[5]`71.524,800N/RN/RN/RN/R250M250N/RZ-7045
ConvLUT DS-CNN-A{sup}∗` (2 cycles)88.99144,711 (12%)9,615009208M2081.30×1061.30 \times10^{6}VU9P
ConvLUT DS-CNN-A{sup}∗` (10 cycles)88.99146,886 (12%)50,7450021481M4813.08×1063.08 \times10^{6}VU9P
ConvLUT DS-CNN-B{sup}∗` (2 cycles)91.53286,306 (24%)15,5540012173M1733.44×1063.44 \times10^{6}VU9P
ConvLUT DS-CNN-B{sup}∗` (10 cycles)91.53286,611 (24%)92,0500030338M3388.60×1068.60 \times10^{6}VU9P

Table 4.

WorkAcc. (%)LUT (% util)FFBRAMDSPLatency (ns)Throughput (FPS)Fmax⁡F_{\max} (MHz)Area×\timesDelayFPGA
fpgaconvnet [9]84.834,000123N/R1899,490,000N/R1113.23×10113.23 \times10^{11}Z-7020
ConvLUT DS-CNN-C∗^{*} (2 cycles)76.70216,093 (18%)35,059007302M3021.43×1061.43 \times10^{6}VU9P
ConvLUT DS-CNN-C∗^{*} (12 cycles)76.70388,163 (33%)275,1340027450M4501.05×1071.05 \times10^{7}VU9P
ConvLUT DS-CNN-D∗^{*} (3 cycles)80.01927,118 (37%)37,2360023129M1292.13×1072.13 \times10^{7}VU440
ConvLUT DS-CNN-D∗^{*} (16 cycles)80.011,107,470 (44%)333,3590063256M2566.98×1076.98 \times10^{7}VU440

Table 5. Comparison of FPGA-based inference implementations on visual wakeword (VWW). N/R = not reported.

On CIFAR-10 (Table 3), ConvLUT achieves up to 80.08% accuracy, and latency as low as 9 ns across different operating points. Compared to the fastest arithmetic-based FPGA accelerator (FINN [26]), ConvLUT reduces latency by at least ∼8844× at comparable accuracy. Compared to LUT-based neural networks such as DWN [5], ConvLUT improves accuracy by over 20 percentage points while maintaining nanosecond-scale latency.

Figure 7 shows that the design naturally maps compactly onto the FPGA fabric, showing the advantage of closely aligning the model structure with the underlying LUT primitives. This alignment directly enables the achieved timing and allows successful placement and routing even at extreme utilization. In particular, we are able to place and route the largest CIFAR-10 model despite exceeding 95% LUT utilization.

Implementation results for the CNN-S model

Figure 7. (a) FPGA floorplan of the CNN-S model on a Xilinx VU9P. Convolutional layers are in red, the LUT pooling in yellow, the fully connected layer in blue, and group sum in green. (b) Per-layer LUT utilization for the CNN-S model on a Xilinx VU9P. Implementation results for the CNN-S model. By designing the network architecture around the native LUT primitive, the resulting circuit maps compactly and efficiently onto the FPGA fabric, demonstrating that co-designing neural network architectures with the target hardware abstraction is key to achieving high resource efficiency and ultra-low latency.

On KWS (Table 4), ConvLUT achieves state-of-the-art 91.53% accuracy while having the lowest latencies and area-delay products. Compared to LUT-based neural networks such as DWN, ConvLUT again improves accuracy by over 20 percentage points. Compared to prior FPGA accelerators, such as fpga convnet [9], ConvLUT provides comparable accuracy while reducing latency by over 4 orders of magnitude.

On VWW (Table 5), ConvLUT achieves the MLPerf Tiny accuracy target of 80%, which is lower than fpga convnet by 4.8 pp. Latency is reduced by over 106×10^{6}\times and area–delay product by 5 orders of magnitude.

Although LUT utilization is high, this reflects the fully unrolled design required for ultra-low latency. The resulting increase in parallelism comes at the cost of area, but the LUT-based design eliminates the need for DSPs and BRAM, with the entire computation mapped to LUT fabric. While this increases area, the latency gains more than offset the cost, yielding the lowest area–delay products across all benchmarks.

Effect of Iterative Pruning Retraining Budget

Figure 8 shows the CIFAR-10 validation accuracy throughout the iterative pruning schedule for three per-stage retraining budgets: Et∈{10,20,40}E_t \in\{10, 20, 40\} epochs. The characteristic sawtooth pattern confirms the expected behavior of the algorithm: each pruning step causes an immediate accuracy drop as connectivity is tightened, followed by recovery during the subsequent retraining window. Longer retraining budgets (Et=40E_t = 40, green) allow greater recovery at each stage, yielding higher final accuracy after the concluding fine-tune phase. Shorter budgets (Et=10E_t = 10, blue; Et=20E_t = 20, orange) accumulate unrecovered accuracy loss across stages, converging to a lower final value. The overall trend is clear: the larger the per-stage budget, the higher the final accuracy as longer retraining allows greater recovery before the next connectivity reduction. However, using Et=40E_t = 40 slows down training in practice. To speed it up, we adopt a non-uniform schedule in our evaluation results: 40 epochs for the first five stages where fan-in reductions are largest, 10 for intermediate stages, and 20 for the final five stages before the concluding fine-tune.

Figure 8. Effect of the per-stage retraining budget EtE_t on CIFAR-10 validation accuracy during iterative pruning. Each sawtooth corresponds to one pruning stage: accuracy drops sharply as the fan-in is tightened from FtF_t to Ft+1F_{t+1}, then recovers during the EtE_t-epoch retraining window. The dashed lines indicate the projected final accuracy for each schedule.

LUT-based vs Classical Pooling

Table 6 compares the proposed LUT pooling layer with classical max and average pooling. The size column reports the equivalent LUT representation, highlighting the hardware incompatibility: max and average pooling induce fan-ins of 32, 20, and 72 inputs, resulting in theoretical L-LUT sizes that are infeasible on any FPGA; hence, they could not be synthesised.

PoolingMetricCIFAR-10KWSVWW
MaxVal Acc (%)55.7877.7774.50
Size232×562^{32} \times56220×2562^{20} \times256272×1282^{72} \times128
AvgVal Acc (%)60.2982.2174.91
Size232×562^{32} \times56220×2562^{20} \times256272×1282^{72} \times128
LUT (Ours)Val Acc (%)61.2083.1477.47
Size28×22402^{8} \times224028×15362^{8} \times153626×38402^{6} \times3840

Table 6. Comparison of pooling strategies for each dataset using toy model architectures. The L-LUT size is calculated based on the fan-in and bitwidth of each neuron. The number of L-LUTs is equal to the number of neurons in the pooling layer. Size is expressed as 2FB×2^{F B} \times number of L-LUTs.

In contrast, the proposed LUT pooling layer respects the hardware fan-in budget, reducing table size by several orders of magnitude. Despite this constraint, expressivity is preserved through a learned sparse aggregation function and channel expansion (K>1K > 1). As a result, LUT pooling outperforms both classical alternatives on CIFAR-10, VWW, and KWS, confirming this construction’s expressiveness while satisfying the hardware fan-in constraints.

Conclusion

We presented ConvLUT, a family of LUT-mappable convolutional architectures that scale LUT-based neural networks beyond MLP-style models to structured vision and audio tasks. ConvLUT introduces several architectural innovations for convolutions and pooling. Coupled with a hardware-aware iterative pruning strategy, ConvLUT achieves ultra-low latency CNN implementations under strict fan-in constraints. Across CIFAR-10, Keyword Spotting, and Visual Wake Words, ConvLUT achieves competitive accuracy while delivering latencies down to 9 ns and the lowest area-delay products. These results demonstrate that convolutional architectures can be co-designed with FPGA LUT primitives to achieve both scalability and extreme efficiency. This performance is achieved through fully

unrolled implementations, representing the low-latency end of the area-latency design space. Alternative trade-offs can be explored by reducing the unrolling factor through rolling.

Acknowledgements

We thank BoolSi for providing Marta Andronic with an internship opportunity that helped lay the groundwork for the initial proof of concept of this project.

References

References

  1. [1]Marta Andronic and George A. Constantinides. 2023. PolyLUT: Learning Piecewise Polynomials for Ultra-Low Latency FPGA LUT-based Inference. In 2023 International Conference on Field Programmable Technology (ICFPT). IEEE, Yokohama, Japan, 60–68. doi: 10.1109/ICFPT59805.2023.00012.DOI
  2. [2]Marta Andronic and George A. Constantinides. 2024. NeuraLUT: Hiding Neural Network Density in Boolean Synthesizable Functions. In 2024 34th International Conference on Field-Programmable Logic and Applications (FPL). IEEE, 140–148. doi: 10.1109/FPL64840.2024.00028.DOI
  3. [3]Marta Andronic and George A. Constantinides. 2025. NeuraLUT-Assembly: Hardware-Aware Assembling of Sub-Neural Networks for Efficient LUT Inference. In 2025 IEEE 33rd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 208–216. doi: 10.1109/FCCM62733.2025.00077DOI
  4. [4]Marta Andronic, Jiawen Li, and George A. Constantinides. 2025. PolyLUT: Ultra-Low Latency Polynomial Inference With Hardware-Aware Structured Pruning. IEEE Trans. Comput. 74, 9 (2025), 3181–3194. doi:10.1109/TC.2025.3586311DOI
  5. [5]Alan Teinder Leibel, Zachary Susskind, Mauricio Breternitz Jr, Eugene John, Lizy Kurian John, Priscila Machado Vieira Lima, and Felipe M.G. França. 2024. Differentiable Weightless Neural Networks. In Proceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 235), Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (Eds.). PMLR, 2277–2295.
  6. [6]Colby Banbury, Vijay Janapa Reddi, Max Loh, Wengong Fu, Amin Fazel, Jeremy Holleman, Xinyuan Huang, Robert Hurtado, Mark Moskewicz, Kevin O’Brien, et al. 2021. MLPerf Tiny Benchmark. arXiv:2106.07597arxiv.org/abs/2106.07597
  7. [7]Hendrikz Borras, Giuseppe Di Guglielmo, Javier Duarte, Nicolò Ghhielmetti, Ben Hawks, Scott Hauck, Shih-Chieh Hsu, Ryan Kastner, Jason Liang, Andres Meza, Jules Muhizi, Tai Nguyen, Rushil Roy, Nhan Tran, Yaman Umuroglu, Olivia Weng, Aidan Yokuda, and Michaela Blott. 2022. Open-source FPGA-ML codesign for the MLPerf Tiny Benchmark. arXiv:2206.11791 [cs.LG] https://arxiv.org/abs/2206.11791
  8. [8]Aakanksha Chowdhery, Pete Warden, Jonathon Shlens, Andrew Howard, and Rocky Rhodes. 2019. Visual Wake Words Dataset. arXiv preprint arXiv:1906.05721 (2019).arxiv.org/abs/1906.05721
  9. [9]fpgaConvNet. 2024. fpgaConvNet Results MLPerf submission. Accessed: 2026-03-23. https://github.com/mlcommons/tiny_results_v1.1/tree/main/closed/fpgaconvnet
  10. [10]Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. 2017. MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications. arXiv:1704.04861 [cs.CV] https://arxiv.org/abs/1704.04861
  11. [11]Mugdha Jadhao, Alan Bacellar, Shashank Nag, Igor Miranda, Felipe França, and Lizy John. 2025. Hybrid Weightless Neural Networks for Efficient Edge Inference. In 35th International Conference on Field-Programmable Logic and Applications (FPL). IEEE Computer Society, Leiden, Netherlands.DOI
  12. [12]Alireza Khataeı and Kia Bazargan. 2025. TreeLUT: An Efficient Alternative to Deep Neural Networks for Inference Acceleration Using Gradient Boosted Decision Trees. arXiv:2501.01511 [cs.LG] https://arxiv.org/abs/2501.01511
  13. [13]Alex Krizhevsky. 2009. Large Multilayer Neural Networks for Image Classification. Technical Report. University of Toronto.
  14. [14]Binglei Lou, Richard Rademacher, David Boland, and Philip HW Leong. 2024. PolyLUT-Add: FPGA-based LUT Inference with Wide Inputs. In 2024 34th International Conference on Field-Programmable Logic and Applications (FPL). IEEE, 149–155. doi: 10.1109/FPL64840.2024.00029.DOI
  15. [15]Shashank Nag, Alan T.L. Bacellar, Zachary Susskind, Anshul Jha, Logan Liberty, Aishwarya Sivakumar, Eugene B. John, Krishnan Kailas, Priscila M.V. Lima, Neeraja J. Yadawadkar, Felipe M.G. França, and Lizy K. John. 2025. LL-ViT: Edge Deployable Vision Transformers with Look Up Table Neurons. In 2025 International Conference on Field Programmable Technology (ICFPT). 19–29. doi:10.1109/ICFPT67023.2025.00013DOI
  16. [16]Alessandro Pappalardo. 2020. Brevitas: neural network quantization in PyTorch. [Accessed: May 12, 2023]. https://github.com/Xilinx/brevitas
  17. [17]Felix Petersen, Christian Borgelt, Hilde Kuehne, and Oliver Deussen. 2022. Deep differentiable logic gate networks. Advances in Neural Information Processing Systems 35 (2022), 2006–2018.arxiv.org/abs/2210.08277
  18. [18]Felix Petersen, Hilde Kuehne, Christian Borgelt, Julian Welzel, and Stefano Ermon. 2024. Convolutional Differentiable Logic Gate Networks. In The Thirty-eighth Annual Conference on Neural Information Processing Systems. https://openreview.net/forum?id=4bKEFyUHT4arxiv.org/abs/2411.04732
  19. [19]TensorFlow Datasets Authors. 2019. Speech Commands dataset via TensorFlow Datasets. https://www.tensorflow.org/datasets/catalog/speech_commands.
  20. [20]Yaman Umuroglu, Yash Akhauri, Nicholas J. Fraser, and Michaela Blott. 2020. LogicNets: Co-Designed Neural Networks and Circuits for Extreme-Throughput Applications. In 2020 30th International Conference on Field-Programmable Logic and Applications (FPL). IEEE Computer Society, Gothenburg, Sweden, 291–297. doi: 10.1109/FPL50879.2020.00055.DOI
  21. [21]Erwei Wang, James J. Davis, Peter Y. K. Cheung, and George A. Constantinides. 2019. LUTNet: Rethinking Inference in FPGA Soft Logic. In 2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE Computer Society, San Diego, CA, USA, 26–34. doi: 10.1109/FCCM.2019.00014.DOI
  22. [22]Erwei Wang, James J. Davis, Peter Y. K. Cheung, and George A. Constantinides. 2020. LUTNet: Learning FPGA Configurations for Highly Efficient Neural Network Inference. arXiv:1910.12625 [cs.LG]arxiv.org/abs/1910.12625
  23. [23]Pete Warden. 2018. Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition. arXiv:1804.03209arxiv.org/abs/1804.03209
  24. [24]Olivia Weng, Marta Andronic, Danial Zuberi, Jiaqing Chen, Caleb Geniesse, George A. Constantinides, Nhan Tran, Nicholas J. Fraser, Javier Mauricio Duarte, and Ryan Kastner. 2025. Greater than the Sum of its LUTs: Scaling Up LUT-based Neural Networks with AmigoLUT. Accessed: 2025-01-15. https://kastner.ucsd.edu/wp-content/uploads/2025/01/admin/fpga25-amigoLUT.pdfDOI
  25. [25]Stephen Williams. 2002. Icarus Verilog. https://github.com/steveicarus/iverilog. Accessed: 2026-03-25.
  26. [26]Y. Umuroglu et al. 2017. FINN: A Framework for Fast, Scalable Binarized Neural Network Inference. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA ’17). Association for Computing Machinery, Monterey, CA, USA, 65–74. doi: 10.1145/3020078.3021744.DOI

Paper details

vlnc:W_8tpuueca
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents