REVIEW 5 major objections 6 minor
A High Energy-Efficiency Multi-core Neuromorphic Architecture for Deep SNN Training
T0 review · 5 major / 6 minor · reviewed 2026-08-12 · deepseek-v4-flash
Pith's one-line read Each core of this neuromorphic design carries the full backpropagation pipeline, so deep spiking neural networks can be trained on-chip rather than on a GPU.
desk verdict A genuinely novel multi-core SNN training architecture with credible FPGA demos, but the headline efficiency numbers rest on unreleased simulators and need a serious referee. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
The load-bearing object is the three-engine computing core: an FP sub-core (selector-adder array for forward convolution, LIF soma/fire, pooling), a BP sub-core (16×16 MAC array for the gradient convolution plus Grad modules for membrane-potential and spike gradients), and a WG engine (output-stationary accumulator array for weight gradients). What makes the argument run is the combination of engine-level parallelism, weight-stationary dataflow in FP and BP, output-stationary dataflow in WG, single-bit spike storage, and gating circuits that skip computation and SRAM access whenever a spike, a surrogate-gradient flag, or a membrane-potential gradient is zero. The network-on-chip with three dedicated data channels and the compile-once deployment of the whole model onto cores are what allow a full batch to be trained with minimal DRAM traffic.
What would settle it
Run the same spiking ResNet18/50 and VGG16 training workloads on a fabricated 32-core chip or on a cycle-accurate RTL simulation with real data, and measure DRAM/HBM traffic and energy per sample; the central quantitative claim is refuted if measured DRAM savings fall below 55% versus an A100 GPU or if measured energy efficiency falls well short of 1.05 TFLOPS/W.
Extended reading notes
Core claim
The central claim is that backpropagation-based SNN training can be mapped entirely onto a multi-core, near-memory neuromorphic processor, with no GPU or off-chip training loop. Each core is a complete training pipeline: an FP engine turns binary spikes into weighted accumulations using selector-gated adders, a BP engine runs the transpose convolution with a 16×16 FP16 MAC array and computes membrane-potential and spike gradients, and a WG engine accumulates weight gradients in an output-stationary array. The three engines operate in parallel within a core, and different layers are placed on different cores, while the network-on-chip provides FP-FP, BP-BP, and FP-BP data channels so forward and backward passes of separate layers overlap. The quantitative claim is that this design reaches 1.05 TFLOPS/W at FP16 and 28nm, cuts DRAM access by roughly 55–85% compared with an A100 GPU on spiking ResNet and VGG training, and reduces core energy by 45–60% through sparse gating. The paper backs this with RTL-level area/power analysis, a custom simulation tool, and FPGA demonstrations of 20-core training and 5-worker federated learning.
Load-bearing premise
The reported efficiency and DRAM-savings numbers come from a computer simulation of the architecture and from power estimates, not from measurements of a finished chip; if that simulation is too optimistic, the headline numbers would not survive contact with real silicon.
Editorial extensions
If this is right
- Neuromorphic hardware can take over the full training loop for deep convolutional SNNs, eliminating the GPU/off-chip backpropagation step that current neuromorphic chips require.
- Deploying the entire model on chip cuts host-to-device instruction traffic to one round per batch, which is the mechanism behind the reported DRAM-access reduction.
- Because spike, surrogate-gradient, and membrane-potential sparsity are exploited in all three engines, energy per training step falls as sparsity rises, making larger models relatively cheaper to train.
- The 20-core FPGA training and 5-worker federated-learning demonstrations indicate the architecture can support continual learning and federated learning directly on edge neuromorphic nodes.
- An energy efficiency of 1.05 TFLOPS/W at 28nm, close to 7nm GPU-class accelerators, suggests a process-scaling path toward even more efficient edge training.
Reading between the lines
- The three-engine-per-core pattern is a template, not a bound: the same FP/BP/WG split could be adapted to surrogate-gradient SNNs beyond convolution, such as spiking transformers, once the instruction set grows the needed operators.
- The reported DRAM savings compare against a GPU baseline; a comparison against other sparse SNN accelerators (which also exploit spike sparsity) would clarify how much of the gain comes from the multi-core dataflow versus from sparsity-aware gating.
- Because the simulator and RTL are not released, independent reproduction requires re-implementing the design; a taped-out or cycle-accurate RTL run under real training workloads would be necessary to confirm the headline numbers.
- The 'first multi-core' status is a record claim that depends on the publication date; the durable contribution is the concrete architecture and its demonstrated-on-FPGA feasibility.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The paper presents a multi-core neuromorphic architecture for direct backpropagation-based training of deep spiking neural networks. Each core contains separate Feedforward-Propagation, Back-Propagation, and Weight-Gradient engines, and the 32-core design uses an 8x4 mesh network-on-chip with 64.78 MB of SRAM. The authors report RTL implementation and verification, a 20-core FPGA system that trains a spiking ResNet-18 on MNIST, CIFAR-10, and CIFAR-100, and a five-FPGA federated-learning demonstration. The headline quantitative claims are 1.05 TFLOPS/W at FP16 in 28nm, a 55-85% DRAM-access reduction relative to an A100 GPU, and 45-60% energy reduction from sparsity-aware gating. These quantitative results are obtained from an in-house simulator (S-ZigZag) and gate-level power analysis with Synopsys tools, rather than from measurements on a fabricated chip or from the FPGA implementation.
Significance. If the quantitative claims hold, the work would be a significant contribution: it would be the first multi-core architecture supporting direct BP training of deep convolutional SNNs on-chip, with an efficiency competitive with GPUs and much lower DRAM traffic. The paper has real strengths: a complete RTL-to-FPGA design flow, functional verification at module, core, and multi-core levels, converging FPGA training runs on three image datasets, and a working federated-learning demonstration. These support the functional viability of the architecture. However, the impact and the headline numbers currently rest on unreleased simulation tools and a power model whose normalization and denominator are not fully specified, so the quantitative claims are not yet independently checkable.
major comments (5)
- [Methods 4.2B, 4.2D and Section 2.5] The headline energy-efficiency and DRAM-access numbers are not verifiable as written. The 1.05 TFLOPS/W figure and the DRAM-access counts in Figures 3(m-o) come from S-ZigZag, an in-house simulator that is not released, and from gate-level power analysis performed on a single computing core. The paper does not report any validation of S-ZigZag's cycle, energy, or SRAM/DRAM-access estimates against the RTL simulation described in Section 4.2C or against FPGA measurements, nor does it state whether the power of DRAM/HBM, the 32-core NOC, and I/O is included in the TFLOPS/W denominator. Without this information, the efficiency is not comparable to the A100's system-level figure and cannot be reproduced. Please release the simulator and the area/power reports, validate S-ZigZag against RTL or FPGA data, and provide a power-breakdown table that states exactly which components are included in the denominator.
- [Methods 4.2D and Figures 4(d-f)] The sparsity-reduction metric is defined as (P0 - PSNN)/(P0 - P100) x 100%, where P100 is the power at 100% sparsity. This is the fraction of the maximum possible reduction between the 0%- and 100%-sparsity cases, not the actual power reduction relative to the no-sparsity baseline. Since P100 is non-zero, the formula overstates the improvement. The statements in Section 2.4 that the sparse design reduces energy consumption 'by 61.09%, 46.81%, and 51.69%', and the Discussion's '~45% to 60%' range, should therefore be re-derived using the standard definition (P0 - PSNN)/P0, with the raw P0, PSNN, and P100 values reported. The same issue affects the per-engine reduction percentages.
- [Section 2.3 and Methods 4.2B, Figures 3(m-o)] The DRAM/HBM-access comparison with the A100 is asymmetric. The A100 traffic is measured with PyTorch and Nsight Compute under the default software stack, while the proposed architecture is simulated by S-ZigZag with full-model on-chip deployment and weight-stationary/output-stationary dataflows. Differences in workspace allocation, operator fusion, and memory layout can shift DRAM traffic substantially, so the reported 55-85% reduction may reflect software and dataflow choices rather than the hardware alone. The paper should specify the exact workspace, buffer allocation, and algorithm settings used on both sides, and ideally compare against a GPU implementation that uses the same training algorithm and optimized memory reuse.
- [Discussion, third paragraph, versus Section 2.3] The Discussion states that the architecture achieves 'a 70~90% reduction of DRAM/HBM access compared to A100 GPU', while the abstract says 55-85% and Figures 3(m-o) report values of about 57% for ResNet-18 and 82-86% for ResNet-50 and VGG-16. These ranges are inconsistent. Please correct the Discussion to match the reported data or provide the additional measurements that justify the 70-90% range.
- [Abstract and Discussion, related-work paragraph] The claim to be 'the first multi-core neuromorphic architecture supporting the direct SNN training' is stronger than the evidence presented. The Discussion acknowledges that Renner et al. (2024) implemented a backpropagation algorithm on Loihi, which is a multi-core neuromorphic chip, albeit for a single hidden-layer fully connected network. The novelty claim should be qualified to 'first multi-core architecture for direct training of deep convolutional SNNs' or an equivalent precise statement.
minor comments (6)
- [Section 2.2] The phrase 'register-transistor level (RTL)' should be 'register-transfer level (RTL)'.
- [Methods 4.1] The equations contain garbled symbols (for example, Equations (4) and (6)), and the variables alpha and Vth are used without explicit definitions; please typeset the mathematics correctly and define all symbols.
- [Section 4.4] There are typos in the FPGA section: 'seneiro' should be 'scenario' and 'labeld' should be 'labeled'.
- [Reference list] Some listed references (e.g., [30], [42], [65], [77], [79]) do not appear to be cited in the main text; please check citation consistency.
- [Table 1] The comparison table would be more informative if it gave the measurement or evaluation methodology and technology node for each listed system, not only for the proposed architecture.
- [Section 2.2 and Supplementary Figure 1] The 'near-memory' terminology should be clarified: DRAM is shared by all cores, but the paper does not quantify how much weight/activation data is resident in SRAM versus DRAM during steady-state training; a memory-hierarchy diagram with capacities and bandwidths would help.
Circularity Check
No significant circularity: the hardware and energy claims are simulation and FPGA results, not fitted to or derived from the paper's own premises.
full rationale
The paper's central claims are (i) a multi-core architecture with FP/BP/WG engines, (ii) simulated energy efficiency of 1.05 TFLOPS/W at 28nm, (iii) 55–85% DRAM-access reduction versus A100, and (iv) FPGA demonstrations of 20-core training and federated learning. None of these reduce to the paper's inputs by construction. The training equations in Methods 4.1 are the standard surrogate-gradient spatio-temporal backpropagation algorithm and are cited to prior work, including the authors' own Wu et al. 2018/2019 and Gu et al. 2019. But these works are used as the algorithmic input the hardware must support, not as evidence for the hardware's efficiency; there is no fitted parameter that is later renamed as a prediction. The quantitative energy/DRAM figures come from RTL gate-level simulation with TSMC 28nm (Methods 4.2D), the S-ZigZag simulator built on the external ZigZag tool (Methods 4.2B), and measured NVIDIA A100 baselines via PyTorch and Nsight Compute (Methods 4.2B). These are independent estimation procedures producing the reported numbers, not outputs that the architecture was solved to match. The FPGA demonstrations in Section 2.6 and Methods 4.4 provide real external evidence that the design trains SNNs and supports continual/federated learning. The main weakness is that the simulator and RTL are not released, so the quantitative claims cannot currently be independently reproduced; that is a verifiability and correctness-risk issue, not a circularity issue. The self-citations are benign and not load-bearing: the algorithm citations are inputs, and no uniqueness theorem or ansatz is smuggled in from the authors' prior work to force the design choice.
Assumptions & free parameters
assumptions (4)
- domain assumption Surrogate-gradient spatio-temporal backpropagation (STBP) provides usable training gradients for deep convolutional SNNs.
- ad hoc to paper The S-ZigZag simulator accurately models the 32-core architecture's cycle counts, energy, SRAM and DRAM accesses, and data reuse.
- ad hoc to paper Gate-level power analysis using Synopsys DC and VCS with a TSMC 28nm library reflects the power of the full 32-core design at 500 MHz.
- domain assumption The 20-core FPGA implementation on five VCU128 boards is a faithful embodiment of the 32-core RTL architecture for training and applications.
Cite this review
Pith. "Pith review of A High Energy-Efficiency Multi-core Neuromorphic Architecture for Deep SNN Training." pith.science (2026). https://pith.science/paper/GRGG2BVR
@misc{pith2026241205302,
author = {Pith},
title = {Pith review of: A High Energy-Efficiency Multi-core Neuromorphic Architecture for Deep SNN Training},
year = {2026},
howpublished = {\url{https://pith.science/paper/GRGG2BVR}},
note = {Machine review of arXiv:2412.05302}
}
read the original abstract
There is a growing necessity for edge training to adapt to dynamically changing environment. Neuromorphic computing represents a significant pathway for high-efficiency intelligent computation in energy-constrained edges, but existing neuromorphic architectures lack the ability of directly training spiking neural networks (SNNs) based on backpropagation. We develop a multi-core neuromorphic architecture with Feedforward-Propagation, Back-Propagation, and Weight-Gradient engines in each core, supporting high efficient parallel computing at both the engine and core levels. It combines various data flows and sparse computation optimization by fully leveraging the sparsity in SNN training, obtaining a high energy efficiency of 1.05TFLOPS/W@ FP16 @ 28nm, 55 ~ 85% reduction of DRAM access compared to A100 GPU in SNN trainings, and a 20-core deep SNN training and a 5-worker federated learning on FPGAs. Our study develops the first multi-core neuromorphic architecture supporting the direct SNN training, facilitating the neuromorphic computing in edge-learnable applications.
Reviewed August 12, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.