acceptodds
Under review as a conference paper at ICLR 2027

STRIDE: An Efficient SNN Training-to-Deployment Framework on Real-World Vision Tasks

Abstract

Spiking Neural Networks (SNNs) have attracted increasing attention in recent years for their potential for high-efficiency and low-energy computation. The community largely agrees that realizing this potential depends on improvements in SNN training, including low-bit computing and sparse excitation, and adaptation to dedicated hardware platforms. However, evidence connecting SNN training to practical deployment benefits remains fragmented: algorithmic studies often use synaptic-operation-based analytical energy estimates, while hardware-focused studies often provide limited validation of deployed accuracy on practical tasks. In this paper, we bridge this gap with an efficient SNN TRaIning-to-DEployment (STRIDE) framework. STRIDE combines low-bit weights with Integer-LIF neurons to represent activations as compact integer codes, which are unfolded into binary temporal spikes for native, event-driven execution on dedicated SNN hardware. During training, we apply quantization-aware distillation to optimize low-bit weights under task and teacher supervision without backpropagation through time. During deployment, we develop native 1-bit spike 4-bit weight execution on a jointly developed 28-nm SNN accelerator, skipping redundant spike-weight computations when later spikes match the first-timestep reference. This work evaluates the effectiveness of STRIDE on three real-world vision tasks, achieving 61.95% mIoU on UDD6 segmentation, 31.71%/16.04% mAP/mAP on UDD detection, and 67.88% top-1 accuracy on ImageNet classification. It outperforms the strongest evaluated compact-code baselines by 3.82, 1.05/0.03, and 1.28 percentage points, respectively, while the evaluated BPTT baseline requires , , and as much peak training memory. We also evaluate hardware energy consumption by deploying one frozen STRIDE-trained SpikingLETNet checkpoint across the accelerator, GPU, and CPU. Command-block measurements yield an accelerator energy of 2.15 mJ per inference, 97.64% and 99.96% lower than on the evaluated INT8 GPU and CPU, respectively. These results also show that hardware-based energy measurements are far more accurate and reliable than conventional operation-count estimates, which capture some relative energy trends but show significant differences across architectures. Our work provides a feasible SNN implementation for real-world vision tasks and opens the door to developing the training-to-deployment collaboration scheme of SNNs.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
spiking neural networks, quantization-aware distillation, software–hardware co-design, SNN accelerator, event-driven computation, energy efficiency, hardware-based energy evaluation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_Gc8YOpenReview ↗
Rating
2(−1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper aims to improve the training efficiency of spiking neural networks in the compact-code domain and their energy efficiency in practical hardware deployments. The authors find that existing methods provide fragmented evidence linking SNN training to practical deployment benefits. The authors then propose the STRIDE framework, which contains two phases of STRIDE-T and STRIDE-D. The STRIDE-T combines Integer-LIF neurons with Quantization-Aware Distillation (QAD) to achieve BPTT-free W4A4 compact-code training. Also, the STRIDE-D maps compact integer codes to binary temporal spikes to support native event-driven execution on dedicated SNN hardware. Experiments based on image classification, object detection, and semantic segmentation tasks show performance in task accuracy, peak training memory, and energy per inference.

Critical strengths

Overall, the main strength of this paper lies in combining low-bit SNN training with hardware deployment and showing experiments on different computer vision tasks and hardware platforms.

(1) This paper focuses on the task accuracy and energy efficiency of low-bit SNNs in practical hardware deployment. By combining compact-code training with native event-driven execution, it reduces inference energy consumption while retaining task accuracy as much as possible, thereby offering practical value.

(2) The experiments in this paper cover three real-world vision tasks (e.g., image classification, object detection, and semantic segmentation) on three models. These results help to show the performance generalization of common computer vision tasks.

Critical weaknesses

This paper has some merit, but it still has the following two main issues.

(1) The technical contributions of the software-hardware collaboration framework lack sufficient validation. STRIDE combines low-bit SNN training, compact integer codes, and native event-driven execution on dedicated SNN hardware. However, the existing experiments lack a comparison with other training methods deployed on the same SNN accelerator, making it difficult to highlight the unique advantages of the proposed collaboration framework for training and deployment.

(2) The experiments struggle to accurately attribute energy-saving benefits. Table 3 compares the energy per inference of a dedicated SNN accelerator with that of a GPU/CPU; however, significant differences exist among these platforms in terms of execution architecture, numerical precision, and the ability to exploit spike sparsity, making it difficult to distinguish the energy-saving contributions of low-bit quantization, skipping redundant spike-weight computations, and the dedicated hardware itself. Also, the energy per inference of the SNN accelerator was extrapolated from sampled command-block measurements and lacks validation through direct end-to-end energy measurements, which further limits the persuasiveness of the cross-platform energy comparison.

Questions for authors

(1) As to the energy consumption measurement, could you directly measure the energy per inference of the dedicated SNN accelerator when executing the full model, but instead extrapolate from sampled command-block measurements to layer totals and sum them across layers? Can this method accurately reflect actual energy consumption?

(2) The proposed STRIDE has demonstrated the feasibility of deploying trained models on dedicated SNN hardware, but what are the unique advantages of its collaboration framework compared to other train-then-deploy approaches? We recommend including a comparison of models trained using other low-bit training methods on the same SNN accelerator to further validate the technical contributions of the collaboration framework.

(3) I suggest the authors conduct energy consumption ablation experiments on the same hardware platform to separately evaluate the energy-saving contributions of low-bit quantization, skipping redundant spike-weight computations, and the dedicated hardware itself.

(4) The current experiments are primarily based on static image datasets and selected models. Is STRIDE applicable to directly trained SNN architectures (e.g., SEW-ResNet, Spikformer) and DVS event-based datasets (e.g., CIFAR10-DVS, DVS128 Gesture)? We recommend supplementing the study with relevant experiments to validate its effectiveness across different SNN architectures and event-based vision tasks.

1 comment
AuthorsOpenReview ↗

Response to Reviewer Gc8Y

We thank the reviewer for the constructive comments and address each point below.

[R1] Direct full-model energy measurement and accuracy of the command-block extrapolation

Thank you for your question. We directly measure the fabricated 28-nm accelerator’s energy over a full SpikingLETNet inference. At 0.8 V and 340 MHz, the accelerator consumes 2.29 mJ per inference above idle, excluding host-computer power. At the same operating point, the end-to-end pipeline achieves 16.12 FPS, corresponding to 62.03 ms per inference, including communication with the host. Table 3 now reports the directly measured energy and latency.

[R2] Advantages of STRIDE over models trained with other low-bit methods and deployed on the same accelerator

Thank you for your question. The primary contribution of the training stage in STRIDE’s co-design is higher task accuracy under the representation constraints of the target accelerator. A model trained by any method can use the same deployment path if its operators, bit widths, and activation encoding are supported by the target backend. For models with the same architecture, we expect comparable inference energy on a given backend when their execution patterns, including temporal skipping on the accelerator, are also comparable. The training-side benefit can therefore be assessed by comparing task accuracy under the same W4A4 representation constraints, without deploying each checkpoint on the accelerator. Table 1 provides this comparison and shows that STRIDE-T achieves higher task accuracy than all the evaluated quantization baselines.

[R3] Energy ablations for low-bit quantization, temporal skipping, and dedicated hardware execution

Thank you for your question. We compare dense W4A4 and W4A1T8 execution on the same chip. With both modes using 4-bit weights, measured power decreases from 174.64 mW in dense W4A4 mode to 123.46 mW in W4A1T8 mode, a 29.31% reduction.

To isolate the effect of temporal skipping, we measure the computation power of a single core with skipping enabled and disabled at each input spike sparsity. At 80% sparsity, enabling skipping reduces power from 84.90 to 67.46 µW. At 100% sparsity, it reduces power from 83.26 to 47.26 µW. These measurements are taken at 0.8 V and 340 MHz and exclude memory accesses.

Low-bit arithmetic is integral to the accelerator’s execution path. The accelerator exploits spike sparsity through native accumulation of 4-bit weights gated by 1-bit spikes. W8A8 is the lowest-precision integer configuration supported end to end for SpikingLETNet on the evaluated GPU and CPU backends. In Table 3, these GPU and CPU deployments consume 39.76× and 2,288× as much energy per inference as the W4A1T8 accelerator, respectively. These ratios quantify the energy advantage of the accelerator’s execution path relative to the most energy-efficient GPU and CPU configurations we evaluate. The same-chip measurements separately show how temporal skipping reduces compute-core power.

[R4] Applicability to directly trained SNN architectures and event-based datasets

Thank you for your question. We add event-based classification on CIFAR10-DVS using SpikingResNet-18. As reported in Table 1, STRIDE-T achieves (80.10±0.95)(80.10 \pm 0.95)% test top-1 accuracy across three seeds, outperforming all the evaluated baselines while requiring less peak training memory than all the BPTT baselines.

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

This paper presents STRIDE, a framework for training low bit SNNs and running them on custom hardware. Instead of training with spikes, the authors train SNNs using integer codes, with a teacher network. They test it on drone image segmentation, drone object detection and ImageNet, and compare it against standard quantisation methods and one BPTT based SNN method. Finally, they run one segmentation model on their accelerator, a GPU and a CPU, and report that the accelerator uses about 97% less energy than the GPU. Interestingly, they also show that the usual theoretical energy estimates based on counting operations don’t match the real hardware measurements. They underestimate energy by anywhere from about 5 to over 3000 times depending on the hardware and quantisation.

Critical strengths

• The evaluation covers segmentation, detection and ImageNet rather than only small datasets, and training in the compact code domain gives a clear memory advantage over the BPTT baseline. • The authors show that operation count estimates can be off from about 5 to over 3000 times depending on the hardware and quantisation.

Critical weaknesses

• The authors state that “hardware-focused studies often provide limited validation of deployed accuracy on practical tasks”, but their full model is never run and scored on the accelerator. As far as I can see only estimates of accuracy are given. • In Table 3 the authors compare their own chip using W4 and GPU/CPU configs on W8, so the savings could come partly from quantisation. • No latency is reported. • In Table 1 STRIDE-T is the only method that uses distillation. Distillation for quantised SNNs already exists (QAD-SNN and MD-SNN in Section 2), and neither of these baselines are added. Table 1 shows that a teacher helps, but not that STRIDE-T’s approach is better than existing distillation methods. • The small performance gains quoted in Table 1 are too small to accept without error bars. • Methods the paper itself lists under “Low-bit SNN training” (MINT, Q-SNN, HardF-SNN) aren’t compared. The only SNN specific training method in the experiments is LIF-SQUAT, which seems to fail on UDD. This suggests a stronger baseline should be used.

Questions for authors
  1. Can you run the full SpikingLETNet on the accelerator and report its actual mIoU, rather than the expected value in Table 3?
  2. How much of the energy saving remains when quantisation is matched? For example, can you report GPU results at 4 bit quantisation?
  3. Can you report latency for the accelerator, GPU and CPU alongside energy?
  4. Can you use methods that include distillation, to the compact code baselines, to show what STRIDE-T adds beyond distillation? For example, QAD-SNN and MD-SNN.
  5. Can you compare against the methods listed in Section 2 under “Low-bit SNN training”. For example, MINT, Q-SNN, HardF-SNN?
  6. Can you report errors for Table 1?
2 comments
AuthorsOpenReview ↗

Response to Reviewer CKdR

We thank the reviewer for the constructive comments and address each point below.

[R1] End-to-end SpikingLETNet mIoU on the accelerator

Thank you for your question. For deployment accuracy, the software simulator and the fabricated accelerator use the same model weights, operator execution order, spike encoding, and low-precision arithmetic rules. Given the same input, both paths produce the same prediction provided that the accelerator correctly executes these operations. We run the full network on both paths and verify that their final outputs match on the inputs tested on hardware. Based on this agreement, we use end-to-end software simulation to evaluate the deployment mIoU of SpikingLETNet on UDD6.

[R2] Energy savings at matched 4-bit precision, including a 4-bit GPU baseline

Thank you for your question. INT8 is the lowest integer precision at which GPU and CPU backends can run SpikingLETNet end to end with quantized weights, quantized activations, and integer arithmetic. On the GPU, TensorRT’s INT4 support is limited to weight-only GEMM. This path stores weights in INT4, keeps activations in floating point, and dequantizes the weights before performing floating-point arithmetic[1]. On the CPU, AVX-VNNI dot-product instructions require at least 8-bit integer operands, so packed INT4 values must be unpacked into 8-bit operands before computation[2]. An end-to-end energy measurement with native INT4 weight and activation storage and arithmetic is therefore unavailable on either evaluated backend.

[1] NVIDIA Corporation. Explicit Quantization. NVIDIA TensorRT 11.4.1 Documentation, 2026. Section “Weight-Only Quantization.”

[2] Intel Corporation. Intel 64 and IA-32 Architectures Software Developer’s Manual, Volume 2: Instruction Set Reference, A–Z. 2023. Vol. 2C, p. 5-455.

[R3] Inference latency on the accelerator, GPU, and CPU alongside energy

Thank you for your question. At 0.8 V and 340 MHz, our accelerator runs SpikingLETNet at 16.12 FPS, corresponding to 62.03 ms per inference, including communication with the host. We also directly measure 2.29 mJ per inference on the accelerator over a full SpikingLETNet run. Table 3 reports these results alongside inference latency and energy measurements for the GPU and CPU.

[R4] Comparison with additional distillation-based methods and low-bit SNN baselines

Thank you for your question. We add two temporal-domain baselines, MINT and QAD-SNN, to Table 1. QAD-SNN also applies knowledge distillation, using teacher logits to supervise the quantized student. MINT achieves the best results among the BPTT baselines on UDD6 segmentation and CIFAR10-DVS classification, with 56.50% mIoU and 73.30% top-1 accuracy, respectively. Across all four tasks, the best compact-code method, STRIDE-T, consistently outperforms the best BPTT baseline.

[R5] Results across random seeds in Table 1

Thank you for your question. To assess the variability of the performance gains over the compact-code baselines, we repeat training with three random seeds and report the mean and standard deviation in the revised Table 1. STRIDE-T achieves the highest mean performance among the evaluated compact-code methods on all four tasks.

Thank you for your response and the additional material in the paper. I do not feel that the updated version is sufficiently more clear and rigorously evaluated to update my rating, however.

Reviewer_wSYJOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2(+1)
Read review
Paper summary

This paper proposes STRIDE, an end-to-end framework connecting low-bit SNN training to deployment on dedicated neuromorphic/SNN hardware. STRIDE has two components. STRIDE-T trains W4A4 SNNs in a compact integer-code domain using Integer-LIF neurons and quantization-aware feature distillation, thereby avoiding temporal unfolding and BPTT during training. At deployment, each 4-bit neuronal code is deterministically unfolded into eight binary timesteps, producing a W4A1T8 workload. STRIDE-D maps this workload to a jointly developed 28-nm SNN accelerator and exploits temporal similarity by skipping spike-weight computations when a later spike equals its first-timestep reference. The framework is evaluated on semantic segmentation (UDD6/SpikingLETNet), object detection (UDD/SpikingYOLOv5), and ImageNet classification (SpikingResNet-18).

Critical strengths

(+) The paper addresses the gap between SNN algorithms and deployment on a dedicated SNN hardware.

(+) The work adopts Integer-LIF training of prior work, which avoid unrolling timesteps.

(+) The paper argues, using measured energy across platforms, that operation-count (SOP/MAC) estimates alone are insufficient evidence for practical SNN efficiency.

(+) Evaluation covers three realistic tasks (segmentation, detection, classification).

Critical weaknesses

(-) The novelty of the paper is somewhat limited. The paper is based of many concepts that already exist. A component-wise ablation would be helpful to understand where the accuracy improvement comes from. Example, authors could show same Integer-LIF + same quantizer + same architecture + same training, with vs. without the proposed distillation. It is not clear whether adding the same KD to LSQ/EWGS gives similar gains. Also, the teacher in STRIDE is extra supervision the baselines never get. Finally, Appendix sets T_train = 1. Wouldn’t this make Eq. 1 a W4A4 quantized ANN? Please clarify.

(-) The BPTT comparison needs more discussion. The performance of BPTT baseline LIF-SQUAT in Table 1 is poor. It is not clear if this baseline has been tuned via hyperparameter search. So, STRIDE’s general accuracy advantage is not clear.

(-) The accelerator results are not convincing. The paper never mentions a tape-out, test board, clock frequency, or supply voltage. Table 4 tests only six standard convolution configurations. SpikingLETNet also has transposed convolutions, transformer matmuls, and a first layer with real-valued input. Are any of these run on the host? Are their energy included in the energy report? Accuracy is not measured end-to-end. The reported accelerator energy is also an extrapolated estimate rather than direct full-network energy measurement. Finally, no latency or throughput is reported for the accelerator.

(-) The energy measurements are not comparable across platforms. The comparison doesn’t separate STRIDE’s contribution from the generic benefit of any 4-bit ASIC.

(-) The proposed temporal skipping mechanism needs stronger characterization. Important statistics are missing such as percentage of spike-weight operations skipped per layer, firing/sparsity patterns, and energy with and without skipping.

Questions for authors
  1. Is the 28-nm accelerator fabricated silicon, or are the energy numbers from post-layout power simulation? Please report clock frequency, supply voltage, and latency per inference.

  2. Which SpikingLETNet layers run on the accelerator and which on the host (e.g., transposed convolutions, transformer matmuls, the first layer)? Does the 2.15 mJ include host-side computation and host–accelerator transfers?

  3. Can you report energy on the same chip for a dense W4A4 integer mode, or for W4A1T8 without skipping, to isolate the benefit of spike unfolding and skipping?

3 comments
AuthorsOpenReview ↗

Response to Reviewer wSYJ [1/2]

We thank the reviewer for the constructive comments and address each point below.

[R1] Fabricated silicon, inference energy, latency, and deployment accuracy

Thank you for your question. We evaluate SpikingLETNet on a fabricated 28-nm accelerator. The original 2.15 mJ per inference comes from extrapolating measurements of sampled command blocks. At 0.8 V and 340 MHz, we directly measure 2.29 mJ per inference on the accelerator over a full SpikingLETNet run, above idle and excluding host-computer power. At the same operating point, the end-to-end pipeline achieves 16.12 FPS, corresponding to 62.03 ms per frame, including communication with the host. The revised manuscript reports the new energy measurement and shows the test-board setup.

For deployment accuracy, the software simulator and the fabricated accelerator use the same model weights, operator execution order, spike encoding, and low-precision arithmetic rules. Given the same input, both paths produce the same prediction provided that the accelerator correctly executes these operations. We run the full network on both paths and verify that their final outputs match on the inputs tested on hardware. Based on this agreement, we use end-to-end software simulation to evaluate the deployment mIoU of SpikingLETNet on UDD6.

[R2] Layer placement and energy measurement scope

Thank you for your question. Both the previous 2.15 mJ and the newly measured 2.29 mJ represent the accelerator’s net inference energy, excluding host-computer power. All linear operations after the first layer, including convolutions, transposed convolutions, and GEMM operations, execute on the accelerator. The first convolution executes on the host because its input precision exceeds the accelerator’s 4-bit input requirement.

This measurement scope is applied consistently across all three platforms. For the CPU and GPU measurements, we also report the inference device’s energy increment above its idle baseline, excluding external host-computer power.

We hope this clarifies the scope of the energy measurements and the basis for comparing the three platforms.

[R3] On-chip energy ablation of spike unfolding and temporal skipping

Thank you for your question. We conduct two on-chip measurements to characterize the power benefits of spike-based execution and temporal sparsity.

Dense W4A4 versus W4A1T8. At 1.0 V and 600 MHz, the accelerator consumes 174.64 mW in dense W4A4 mode and 123.46 mW in W4A1T8 mode, corresponding to a 29.31% power reduction under the same voltage and frequency.

Power consumption at different input sparsities in W4A1T8 mode. We measure the power consumption of a single compute core at different input spike sparsities. As reported in Table 4, increasing input sparsity reduces compute-core power by up to 45.29%, demonstrating the hardware’s ability to translate sparse spike activity into power savings.

AuthorsOpenReview ↗

Response to Reviewer wSYJ [2/2]

[R4] Per-layer spike sparsity and skipping rate

Thank you for your question. Appendix B.2 reports input spike sparsity and temporal skipping rates for each of the 59 convolutional and transposed convolutional layers in SpikingLETNet. Across the 59 layers, the overall spike sparsity is 96.96%, and the skipping rate is 70.29%.

[R5] More detailed discussion on the performance of BPTT baselines

Thank you for your question. We expand the BPTT comparison to include MINT and QAD-SNN and evaluate LIF-SQUAT at three initial learning rates on UDD detection.

As shown in the revised Table 1, MINT is the strongest BPTT baseline on UDD6 segmentation and CIFAR10-DVS classification. It achieves 56.50% mIoU and 73.30% top-1 accuracy, respectively, compared with 61.75% and 80.10% for STRIDE-T. LIF-SQUAT remains the strongest BPTT baseline on UDD detection and ImageNet classification. On ImageNet, it reaches 53.81% top-1 accuracy, compared with 68.10% for STRIDE-T and 65.71–67.80% for the other compact-code baselines.

To test whether convergence issues related to the learning rate explain LIF-SQUAT’s poor performance on UDD detection, we fine-tune it from the same pretrained binary-LIF checkpoint at three initial learning rates of 10−210^{-2}, 3×10−23\times 10^{-2}, and 3×10−33\times 10^{-3}. The corresponding checkpoints achieve 1.02%/0.21%, 1.60%/0.33%, and 1.31%/0.30% in mAP50\mathrm{mAP}_{50}/mAP50:95\mathrm{mAP}_{50:95}, respectively.

STRIDE-T outperforms the evaluated BPTT baselines on all four benchmarks. On UDD detection, the performance gap persists across the three BPTT baselines and all three initial learning rates tested for LIF-SQUAT. One possible explanation for the detection gap is that binary-spike dynamics make it harder to learn the fine-grained spatial features needed to localize objects in crowded scenes.

[R6] Equivalence to a W4A4 ANN when Ttrain=1T_{\mathrm{train}} = 1

Thank you for your question. We agree that, with Ttrain=1T_{\mathrm{train}} = 1 and a zero initial membrane state, the activation output CC in Eq. (1) is equivalent to that of a W4A4-quantized ANN using the same rounding and clipping rule. This equivalence is intentional. STRIDE-T trains the model directly in the compact-code domain using quantization-aware distillation within a standard quantization-aware training workflow. The eight binary timesteps are generated from each integer code only at deployment, so training requires neither temporal unrolling nor BPTT.

Thank you for the detailed response. Confirming fabricated silicon and the direct full-network measurement (2.29 mJ, 62 ms) resolves my main soundness concern, and I have raised my Soundness score.

Some concerns remain.

  1. The dense W4A4 vs. W4A1T8 comparison reports power, not energy per inference. Since W4A1T8 may need more cycles, it does not show an energy benefit. Even taken at face value, it suggests most of the gain over the GPU comes from the ASIC rather than from spike execution.

  2. With 96.96% spike sparsity, simple zero-spike gating would evaluate about 3% of terms, versus about 30% with reference-based skipping. Please clarify what skipping adds, and report energy with skipping disabled.

  3. Since the trained model is a W4A4 quantized ANN, the training contribution rests on the distillation, but the KD ablation is still missing.

  4. LIF-SQUAT remains below 2% mAP50 at all learning rates tested, so it does not appear to be a meaningful baseline for detection.

I am keeping my overall rating.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to Reviewers

We thank all the reviewers for their careful reading and detailed feedback. We appreciate their recognition of the importance of connecting low-bit SNN training with practical hardware deployment.

Based on the feedback, we conduct additional experiments and revise the manuscript accordingly. We mark all revisions and additions in blue in the revised manuscript.

1. Additional Experiments and Results

  • Training and baselines. We add MINT and QAD-SNN as BPTT baselines, evaluate LIF-SQUAT at three initial learning rates on UDD detection, and repeat compact-code training across random seeds. STRIDE-T outperforms the strongest evaluated BPTT baseline on each of the four tasks and achieves (80.10±0.95)(80.10 \pm 0.95)% top-1 accuracy on CIFAR10-DVS.
  • Full-model silicon measurements. At 0.8 V and 340 MHz, the fabricated 28-nm accelerator consumes 2.29 mJ per SpikingLETNet inference above idle, excluding host-computer power. The end-to-end pipeline achieves 16.12 FPS, corresponding to 62.03 ms per inference, including host communication.
  • Temporal skipping. In a single-core experiment at 80% input spike sparsity, enabling temporal skipping reduces compute power from 84.90 to 67.46 µW. Across 59 convolutional and transposed convolutional layers, the software trace analysis gives 96.96% overall spike sparsity and a 70.29% skipping rate.

2. Summary of Main Revisions

  • Table 1 adds CIFAR10-DVS, MINT and QAD-SNN results, and mean and standard deviation across seeds for the compact-code methods. It also reports the updated LIF-SQUAT detection result.
  • Tables 3 and 4 report directly measured accelerator energy, inference latency across the accelerator, GPU, and CPU, and single-core power with temporal skipping enabled and disabled.
  • The appendices add the CIFAR10-DVS preprocessing protocol, per-layer spike sparsity and skipping statistics, the accelerator test-board setup and energy measurement protocol, and a comparison with prior accelerators.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.