- Rating
- 3(+1)
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 3(+1)
- Soundness
- 3(+1)
Read review
Paper summary
This paper studies BSD for learning and adaptation in edge spiking neural networks. It uses separate forward sensing and label-driven backward branches, and aligns local representations in the middle layers to reduce reliance on global backpropagation. The authors test it on five sensing modalities and 25 tasks in SOUL, and also look at few-shot class-incremental learning. Results show BSD's average accuracy is about 3.8 points lower than a matched BP baseline, but its predicted training latency and estimated energy under ideal parallel conditions are only 0.72x and 0.36x those of BP.
Critical strengths
-
The experiments cover visual, motion, acoustic, wireless, and neuromorphic sensing, and include CNN, RNN, and LSTM, which helps assess how well local learning methods work with different input structures.
-
BSD and BP use matched forward architectures and the same data processing pipeline, and results report the mean and standard deviation over three runs. The performance gap on most tasks is relatively small, suggesting BSD has some practical potential.
-
The authors provide full stage-by-stage latency and operation counts, and clearly state that the efficiency results are predicted or estimated, not measured on real edge hardware. The few-shot incremental experiments also give early evidence that BSD representations can transfer.
Critical weaknesses
-
Section 5.4 shows serial BSD is slower than BP on 24 of 25 tasks; the speedup comes from GPU timing and an ideal parallel formula, not real concurrent execution. Eq. (17) just divides by parallelism , ignoring load imbalance, synchronization, and resource contention. The paper also does not measure inference latency, throughput, or weight consistency during training, so it is unclear whether the predicted gains hold in continuous sensing.
-
The dual-branch structure, ReCo alignment, and local updates come from earlier work; the new value here is mainly cross-modal evaluation, cost analysis, and incremental learning. But the experiments mainly compare with BP and lack other local or online SNN methods, so BSD's advantages over similar approaches are unclear. Ablations focus on the prototype adaptation component, not the core learning mechanism.
-
The incremental stage freezes the backbone and only adds new class prototypes. This supports few-shot transfer of BSD features, but not that the system can keep inferring without interruption when BSD continuously updates weights after deployment.
-
In Table 6, CIFAR-10 accuracy drops from 81.5% to 36.1% when batch size falls from 64 to 4. This matters for low-memory, few-sample scenarios. Peak training memory is not reported, so the total cost of dual branches, local losses, and optimizer states is not shown to fit target devices.
-
The average gap hides large losses on some tasks, such as Widar3, GSC, and CIFAR10-DVS, which drop by about 12.7, 8.3, and 8.0 points. Also, the cost analysis covers only one training step, with no total training time or energy to reach similar accuracy, limiting judgment of real benefits.
Questions for authors
-
Can real concurrent execution be achieved on the same hardware and under the same compute and memory budget, and can you report inference tail latency, throughput, peak memory, and actual energy under continuous input? Should the BP baseline also be allowed to use concurrent scheduling or independent inference replicas?
-
How does the parallelism in Eq. (17) map to actual compute resources? For RNN/LSTM with shared temporal weights, how are gradient reduction and parameter updates scheduled? How large is the gap between actual speedup and predicted values at different ?
-
What truncation length is used for each temporal task? How does it affect accuracy, gradient locality, memory usage, and achievable parallelism?
-
Does the energy accounting fully cover the local weight gradients of both branches, normalization, optimizer updates, and other necessary computation? If the goal is comparable accuracy, is the total training cost still advantageous?
-
Do the off-diagonal terms in Eq. (6) include same-class sample pairs? If the same label produces the same or similar backward representations, positive sample alignment and same-class off-diagonal penalties may conflict. Does the implementation use label masking or some other treatment?
4 comments
Truncation length, energy coverage, and same-class pairs
Q3. Truncation length n. All temporal tasks use n = 1: the recurrent state is detached at every step, so each time step of each layer is its own local task. The revised Table 3 states this. Its effects:
- (i) Locality: n = 1 is strictly time-local. The forward pass still carries the recurrent state, but no gradient crosses a time step through the recurrent weights or the LIF state. A larger n lets gradients flow within a segment.
- (ii) Parallelism: there are T/n independent tasks per layer, i.e. T at n = 1, which is the "P = sequence length" of Table 5.
- (iii) Memory: the reference schedule keeps all steps until the loss is complete, so its memory equals that of BPTT plus the reverse branch. Because no gradient crosses a step at n = 1, a step-wise schedule can back-propagate each step's alignment losses as soon as the step ends, which makes activation memory independent of T.
- (iv) Accuracy. We ran the ablation on UCI-HAR (BSD-RNN, T = 128) and GSC (spiking LSTM, T = 101; n = T means no truncation). Test accuracy (%):
| n | 1 | 4 | 16 | 64 | T |
|---|---|---|---|---|---|
| UCI-HAR (BP 92.69), 4 seeds | 90.94* | 92.83 ± 0.10 | 93.20 ± 0.20 | 92.63 ± 0.92 | 93.10 ± 0.25 |
| GSC (BP 92.33), 1 seed | 84.03* | 86.04 | 87.93 | 89.50 | 91.15 |
| Local tasks per layer (UCI-HAR / GSC) | 128 / 101 | 32 / 26 | 8 / 7 | 2 / 2 | 1 / 1 |
* n = 1 values are those of Table 1 (three runs).
On GSC, accuracy rises monotonically with n and the gap to BP shrinks from 8.3 to 1.2 points, so most of that gap comes from strict time locality rather than from the BSD alignment itself. On UCI-HAR, n = 4 already reaches BP's accuracy, and larger n brings no further gain beyond seed variation. n therefore trades accuracy against locality and parallelism (T/n local tasks per layer) and can be set per task. Table 1 keeps n = 1, the most local setting; the appendix now reports this ablation.
Q4. Energy coverage and total cost.
- Counted for BSD: both branches' forward passes, the backward computation within every level of both branches, and the ReCo similarity matrices with their backward.
- Counted for BP: the forward pass, plus a backward counted as twice the rate-scaled forward operation count at MAC energy. This favors BP, because a real BP backward computes dense input gradients that cannot exploit input sparsity.
- Not counted for either method: BatchNorm, LIF state updates and optimizer steps. Adding them for CIFAR-10, all at the 4.6 pJ MAC energy, gives 0.881 mJ for BP and 0.324 mJ for BSD, so the ratio moves only from 0.31× to 0.37×. Assumptions per operation:
- BN: 14 ops per element (forward plus backward);
- LIF forward: 5 ops per neuron-step;
- LIF backward: 10 ops per neuron-step, BP only, since BSD's CNN losses are pre-LIF;
- AdamW with clipping: 16 ops per parameter at B = 128, including BSD's doubled parameter count.
- Total cost to reach a given accuracy. BSD converges more slowly than BP, which offsets part of its per-step saving.
- We measure progress against each method's own final accuracy. On CIFAR-10 with the same schedule, both reach about 91% of it after 12 epochs (BSD, 75.0%) and 9 epochs (BP, 80.0%), so BSD's total estimated training energy up to this point is 0.41× BP's (0.49× with the extended accounting).
- The saving narrows towards the end of training, where BSD's slower convergence weighs most; faster convergence of the local objectives is the main lever. Section 5.4 reports this trade-off.
These are operation-level estimates for hardware that turns binary inputs into accumulations. On a GPU, spikes are dense floating-point tensors, so the estimate does not transfer; Section 5.4 now says so.
Q5. Same-class pairs in Eq. (6). Yes: the off-diagonal term includes same-class pairs, and there is no label masking, as in Wang et al. (2026). Because the label code e(y) is deterministic, same-class samples share one reverse representation. Take a sample with k same-class partners in the batch and let s = cos(q_n, r_{y_n}). Its objective in s is (1 − s)² + γk·max(0, s)², minimized at s* = 1/(1 + γk). So the conflict does not cancel the signal; it turns the positive term into a calibrated target. For CIFAR-10 at B = 128 (k ≈ 12.7) the target is about 0.12. Other-class similarities are still pushed to ≤ 0, so the ranking that drives discrimination is preserved. A side effect is that the target depends on B/C, which contributes to the batch-size sensitivity (W4).
We also tested label masking, which excludes same-class off-diagonal pairs. It lowers CIFAR-10 accuracy by 7.2 points (B = 128, otherwise identical), so the same-class term helps rather than conflicts. Our reading is that it acts as a regularizer: by keeping s* < 1, it stops every stage from collapsing all samples of a class onto the class code. We add the analysis and this result to Appendix F (Appendix E in the submission).
Local baselines, FSCIL, batch size, and per-task results
W2. Other local or online SNN methods; ablations of the core mechanism.
- Comparison. Wang et al. (2026) compare BSD with predictive coding, CCL, DLL and R-STDP under identical architectures on five vision datasets. BSD is 2.2 points below SNN-BP on average there, while the other rules are 3.6–35.9 points below. Our contribution is the evaluation across edge modalities; extending the comparison with other local SNN rules to all 25 tasks is valuable future work. Among local rules, BSD's distinguishing property is that the learning signal reaching each stage is a spike train from a second spiking network, not a signed error from an auxiliary classifier. This is what makes it attractive for neuromorphic on-chip plasticity.
- Core-mechanism ablations. New here: same-class masking in ReCo (Q5), class-code negatives (W4) and the truncation length of temporal BSD (Q3). For the loss choice (ReCo vs. MSE vs. InfoNCE), λ, firing threshold, T and BN, we cite the ablations in Wang et al. (2026). The FSCIL component ablation moves to the appendix.
W3. The FSCIL stage freezes the backbone. The revision makes this explicit: the experiment is designed to show that BSD features transfer to new classes; uninterrupted inference while BSD keeps updating weights is a separate question. We reframe Section 5.5 as a transfer probe and no longer cite it as evidence for learning while inferring. The right test is online adaptation: BSD updates the network on a labeled stream while serving predictions, with inference latency measured on device. We list it as the main open item.
W4. Batch size 4 and peak memory.
- Peak memory: the general response and the new Appendix E report it. With stage-wise execution, BSD's peak memory is within 7–11% of BP's with identical gradients; the excess is the second parameter set and its optimizer state.
- Batch sensitivity: it comes from ReCo's batch-drawn negatives and from the B/C-dependent target (Q5). Class-code negatives add the C label codes to the reverse batch, so every sample has C − 1 negatives at any batch size, for C extra label-driven samples per step. On CIFAR-10 at B = 8, with the same 15-epoch schedule for both, accuracy rises from 56.5% to 61.0% (two seeds), and the update stays local.
W5. Per-task results; cost per step only. The revised Section 5.3 names the tasks with larger differences and their likely causes: small batches imposed by large inputs (e.g., Widar3, BullyDetect), many classes per batch (Tiny-ImageNet) and long temporal credit assignment (GSC, see Q3). For the total cost to reach a given accuracy, see Q4.
We hope these answers address your concerns and are glad to provide more detail.
Thank you to the author for the detailed response; most of my questions have been addressed. I hope these points will be incorporated into the revised manuscript. I will update my score.
Concurrent execution and the meaning of P
Thank you for the detailed questions on our efficiency analysis; they made our claims more careful and better grounded.
W1 / Q1 / Q2. Concurrent execution and the meaning of P.
Scope of Eq. (17). Eq. (17) is a critical-path bound that assumes each local task runs on its own compute unit. We implemented the concurrent schedule for the CIFAR-10 spiking CNN of our vision rows (5 conv layers, T = 4):
Its gradients are exactly those of the reference implementation. So the independence that Eq. (17) assumes does hold; what the bound leaves out is how a given processor executes these tasks.
Same resources for BP (Q1). BP should indeed be given the same resources. On general-purpose CPUs and GPUs, BP uses the same cores, or the whole device, within each layer, so BSD's shorter dependency chain does not translate into a lower step latency there. BSD's advantage is structural: after the forward pass every stage can update without a backward sweep, and no activations need to be kept for one. This pays off on hardware that maps stages to separate compute units and cannot parallelize a single layer arbitrarily, such as layer-per-core neuromorphic processors. We therefore remove the projected 0.72× from the abstract and contributions and present Eq. (17) as a hardware-conditional bound.
Mapping of P and gap to the prediction (Q2). P is the number of concurrently executing local tasks, i.e. the number of compute units; in this CNN it is capped at 6 (the 5 convolutional layers plus the readout, as in Table 5, which is Table 7 in the revision). The speedup realized on a general-purpose processor falls short of Eq. (17) for three reasons: load imbalance (the first level holds most of the local work, and the forward branch sets the critical path); the clipping barrier; and contention for memory bandwidth. On a GPU, each local task already occupies the device.
Recurrent models (Q2). Time-shared weights receive one gradient per segment. These are summed before one update per layer (Algorithm 2, line 7), with tree depth ⌈log₂ P⌉, so there are T/n tasks per layer. All our temporal tasks use n = 1 (Q3), which gives the "P = sequence length" of Table 5.
Tail latency, throughput, actual energy, weight consistency (Q1). Meaningful values require the target event-driven hardware, which we do not have; the revised Section 5.4 states this limitation.