acceptodds
Under review as a conference paper at ICLR 2027

Learning While Inferring: Local and Parallel Learning for Edge SNNs across Sensing Modalities

Abstract

Edge intelligence requires models to sense continuously in real time and to keep adapting on-device, all under tight compute, energy, and memory budgets. Although spiking neural networks (SNNs) enable efficient event-driven inference, standard surrogate-gradient backpropagation (BP) serializes updates and blocks ongoing inference. We investigate Bidirectional Spike-Based Distillation (BSD) as an on-device learning principle that lets edge SNNs learn while inferring. BSD couples a stimulus-driven forward network with an independent target-driven reverse network and aligns their intermediate representations through local objectives. Because the two pathways have disjoint computation graphs until alignment, forward inference, reverse inference, and stage-wise updates can run concurrently. On 25 benchmarks spanning the five sensing modalities of SOUL, BSD stays within 3.8 percentage points of matched BP baselines on average, while only its forward branch is needed at deployment. The learned representations also transfer well to few-shot class-incremental learning without replaying past data. By removing the dense floating-point backward chain, BSD reduces the projected training latency to and the estimated training energy to that of BP.

Primary area:
applications to neuroscience & cognitive science
Keywords:
spiking neural networks, edge, local learning

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_8myEOpenReview ↗
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
  1. 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.

  2. 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.

  3. 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
  1. 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 PP, 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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
  1. 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?

  2. How does the parallelism PP 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 PP?

  3. What truncation length nn is used for each temporal task? How does it affect accuracy, gradient locality, memory usage, and achievable parallelism?

  4. 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?

  5. 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
AuthorsOpenReview ↗

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):

    1. Both branches run in parallel.
    2. The 6 local tasks (5 convolutional stages plus the readout) compute their losses and backward passes in parallel.
    3. One scalar reduction performs global-norm clipping.
    4. The 6 per-block updates run in parallel.

    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.

    • On GPUs, spikes are processed as dense tensors, so the operation-level energy estimate does not apply there.
    • With per-block updates, an inference pass that overlaps an update may combine old and new blocks. Double-buffering the forward weights avoids this at the cost of one weight copy.
AuthorsOpenReview ↗

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 (%):
n141664T
UCI-HAR (BP 92.69), 4 seeds90.94*92.83 ± 0.1093.20 ± 0.2092.63 ± 0.9293.10 ± 0.25
GSC (BP 92.33), 1 seed84.03*86.0487.9389.5091.15
Local tasks per layer (UCI-HAR / GSC)128 / 10132 / 268 / 72 / 21 / 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).

AuthorsOpenReview ↗

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.

Reviewer_SKAcOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper systematically evaluates and analyzes BSD-based training of SNN for edge device across 25 tasks spanning five modalities. The results suggest that BSD can reduce training time and energy consumption compared with BP. The paper also evaluates BSD-trained representation in a few-shot class-incremental learning setting with a frozen backbone and prototype-based adaptation.

Critical strengths
  1. Broad evaluation across 25 benchmarks and five modalities.
  2. Useful analysis of potential adavantages of BSD about training-time and energy saving.
  3. The FSCIL experiment shows that BSD-trained feature can support few-shot class incremental learning without retraining the backbone.
Critical weaknesses
  1. The paper does not clearly distinguish its algorithmic contribution from the existing BSD method.

  2. The paper lacks experiments on actual edge-device hardware.

  3. The FSCIL experiments do not demonstrate the ability to overcome catastrophic forgetting. Instead, they just show the transferability of representation learned by BSD.

  4. A substantial performance gap remains between BSD and BP.

Questions for authors

How does BSD compare with BP in terms of memory usage during training on resource-constrained edge device?

2 comments
AuthorsOpenReview ↗

Contribution, edge hardware, FSCIL, and training memory

Thank you for raising the practical costs of on-device training, which led to the new memory results.

W1. Algorithmic contribution vs. BSD. BSD was proposed as a biologically plausible learning rule (Wang et al., 2026). Our contribution is not a new rule but evidence that this rule brings substantial advantages to edge computing, together with optimizations for this setting. The new parts are:

  • the analysis showing that the stages of a BSD training step are independent and can train in parallel (critical path), and an operation-level energy model for both branches and BP;
  • BSD for temporal classification models (constant-label reverse recurrence, stacked spiking LSTMs, segment truncation);
  • the evaluation on 19 non-vision tasks;
  • edge-oriented optimizations: class-code negatives, which make ReCo robust to small batches while keeping the update local; and a stage-wise schedule, which brings training memory to BP's level.

The revised abstract and contribution list state this explicitly.

W2. No experiments on edge hardware. We do not have access to neuromorphic hardware with on-chip plasticity, which is where BSD's structure matters most: there, each stage can update in place from locally available forward and reverse activity, without storing activations for a backward sweep. On general-purpose processors, BP can use the same cores within each layer, so we do not claim latency gains there. We therefore remove the projected latency reduction from the abstract and keep Eq. (17) as a hardware-conditional bound. The energy figure remains an operation-level estimate for event-driven hardware and is labeled as such. The extended accounting in the general response shows that it holds when normalization, neuron updates and optimizer steps are included.

W3. FSCIL shows transfer, not resistance to forgetting. With a frozen backbone and fixed base prototypes, forgetting is avoided by construction, so the experiment is best read as a test of forward compatibility: new classes can be added from five examples without retraining. We retitle Section 5.5 ("Transfer of BSD features to few-shot class expansion") and remove the wording that suggests forgetting is overcome. We also add base- and novel-class accuracy per session (three runs). BSD's novel-class accuracy is at or above BP's in every session (session 1: 29.9% vs. 26.0%; session 5: 24.6% vs. 24.1%), while its base-class accuracy falls from 54.8% to 48.0% over the five sessions (BP: 56.9% to 51.4%), as the new prototypes take part of the decision space.

W4. Remaining gap to BP. The mean gap is 3.71 points after the Table 1 correction. It is below 3 points on 11/25 tasks and below 5 on 19/25. The remaining differences concentrate on tasks with small batches, many classes or long temporal credit assignment, which the revised Section 5.3 analyzes. For the small-batch case, class-code negatives raise CIFAR-10 accuracy at B = 8 from 56.5% to 61.0% (two seeds).

Q. Training memory. Because no error crosses a stage, BSD can be executed stage by stage:

  1. The label-driven reverse branch runs first without autograd and keeps only its binary spikes.
  2. Each stage and its reverse counterpart are then recomputed, updated and freed.
  3. No copies of pre-LIF tensors are kept.

This gives exactly the gradients of the reference implementation (relative difference < 3×10⁻⁷). Peak GPU memory for one training step (CIFAR-10 spiking CNN, T = 4, AdamW), in MB:

Batch48163264128
BP17523235559710862062
BSD (stage-wise)19125737864211592200
Ratio1.09×1.11×1.07×1.07×1.07×1.07×
  • The remaining 7–11% is mostly the second parameter set: weights, gradients and AdamW moments take 68 MB instead of 34 MB.
  • Every method's peak is set by the first full-resolution stage: a forward pass alone already reaches 72% of BP's training peak at B = 128. Activation checkpointing does not lower BP's peak here (2589 MB at B = 128).
  • The reference implementation keeps both branches' graphs until a single backward pass and therefore needs more memory, as Wang et al. (2026, App. N) report. The stage-wise schedule removes this overhead without changing the algorithm.
  • Memory can be reduced further. The reverse branch is driven only by the label, so all same-class samples share identical reverse activations. Storing them once per class in the batch (at most C instead of B, with BatchNorm statistics weighted by class counts) would shrink the reverse-branch memory and computation by up to B/C; this is a potential optimization that we have not yet evaluated.

So BSD's training memory is on par with BP's for this CNN, although it trains two networks, and its inference memory is identical, since only the forward branch is deployed. We add this table and the schedule to the appendix.

Thanks for the responses and the added memory comparison. The memory is given for a small model on CIFAR10. BSD has comparable memory overhead with BP. For practical medium to large models, the memory cost would make its on-device implementation impractical. I keep my original rating.

Reviewer_MD8fOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper applies Bidirectional Spike-Based Distillation (BSD), an existing local learning rule, to edge SNNs on 25 tasks spanning the five sensing modalities of SOUL. BSD pairs a stimulus-driven forward spiking network with a target-driven reverse network and aligns them with local ReCo objectives; only the forward branch is deployed. The authors add a prototype-based FSCIL protocol on CIFAR-100 and estimate training cost from operation counts and a projected concurrent schedule. BSD stays within 3.8 points of BP on average, with a 0.72× projected latency and 0.36× estimated energy. The cross-modal coverage is broad, but the algorithmic contribution is limited and the efficiency claims are projections rather than measurements.

Critical strengths

Twenty-five tasks across vision, motion, acoustic, wireless and neuromorphic sensing, with matched BP baselines and a clean forward-only deployment path.

Critical weaknesses

1.The decimal points in Table 4 are inconsistent.
2.BSD is from Wang et al. (2026), and the FSCIL adaptation follows SAFA-SNN-style prototype, subspace and TTA components. The contribution is an application/benchmark study, not a new method.
3.Widar3 falls from 78.51 to 65.82 (−12.7), BullyDetect from 69.23 to 60.54 (−8.7), and GSCL from 92.33 to 84.03 (−8.3); six of 25 tasks are worse by more than 5 points.

Questions for authors

What is new relative to Wang et al. (2026) and SAFA-SNN? Please separate reused components from the new contributions.

1 comment
AuthorsOpenReview ↗

Contribution, per-task results, and Table 4

Thank you for your comments on the positioning of our work; it helped us state our contribution more precisely.

W1. Table 4 decimals. This is fixed in the revision (Table 4 is Table 6 there). The original entries were rounded to three significant figures, so the number of decimals varied with magnitude (e.g., 0.0617 vs. 74.3 mJ). The revised table uses a fixed format per column: MACs and ACs in millions with one decimal, energy in mJ with three decimals, ratios with three decimals.

W2 / Q. What is new relative to Wang et al. (2026) and SAFA-SNN. The general response lists the components. In short:

  • Reused from Wang et al. (2026): the BSD rule (two branches, ReCo on pre-LIF potentials, detach-based locality, task loss at the top), the 5-layer CNN and its settings for the six vision rows, and the single-layer BSD-RNN with reverse-time recurrence.
  • Reused for FSCIL: prototype classifiers (Snell et al., 2017), SAFA-SNN's base-subspace projection (our Eq. 16), test-time view averaging and multi-layer cosine fusion. We do not use SAFA-SNN's main components (sparsity-aware threshold dynamics, zeroth-order training). The FSCIL pipeline is not a contribution, and Table 2 only shows which inference-time components BSD features need. We move it to Appendix C.5 (now Table 5) and say so.
  • New:
    1. The edge analysis: which BSD computations are mutually independent (the two branches, the per-level losses and updates), the critical path of a training step (Eq. 17), and an energy model that separates spike-driven accumulations from MACs in both branches and in the BP backward.
    2. BSD for temporal classification: a reverse recurrence driven by a constant label code, stacked spiking LSTMs with hidden-state-only alignment, and segment truncation. Wang et al. used one RNN layer with per-step targets (character prediction, forecasting).
    3. The cross-modal evaluation: 19 of the 25 tasks are new.
    4. Optimizations for edge training: class-code negatives for small batches, a stage-wise schedule that brings training memory to BP's level, the analysis of same-class pairs in ReCo, and an extended energy accounting.

BSD was proposed as a biologically plausible learning rule. Our contribution is to show that its structure brings substantial advantages to edge computing (stages that train in parallel, lower operation-level training energy, training memory on par with BP, and an inference cost identical to a BP-trained SNN) across five sensing modalities, and to optimize it for this setting. The revised abstract and contribution list now say so.

W3. Per-task results. The per-task view is indeed informative, and Section 5.3 now discusses it explicitly. BSD stays within 3 points of BP on 11 of the 25 tasks and within 5 points on 19. The remaining tasks share at least one of three properties:

  • (i) Small batches imposed by large input tensors (e.g., BullyDetect B = 16, Widar3 B = 32), while ReCo draws its negatives from the batch.
  • (ii) Many classes per batch (Tiny-ImageNet: 200 classes at B = 128).
  • (iii) Long temporal credit assignment (GSC: 35-class spiking LSTM). Our temporal models detach the recurrent state at every step (n = 1); relaxing this to n = T brings GSC to within 1.2 points of BP (accuracy rises from 84.0% at n = 1 to 91.2% at n = T; revised Appendix B.1).

For (i), class-code negatives add the C label codes to the reverse batch, so every sample gets C − 1 negatives at any batch size and the update stays local. On CIFAR-10 at B = 8, with the same 15-epoch schedule for both, this raises BSD's accuracy from 56.5% to 61.0% (two seeds); we will apply it to the small-batch tasks in the final version. For context, Wang et al. (2026, Table 1) report that, with identical CNNs on five vision datasets, BSD is 2.2 points below SNN-BP on average. The other rules evaluated there are 3.6–35.9 points below: predictive coding 3.6, CCL 4.4 and DLL 9.0 (all on non-spiking networks), and R-STDP 35.9.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response: scope of the contribution, new results, and revisions

We thank the reviewers for careful and constructive reviews. They share three concerns: (i) what is new relative to BSD (Wang et al., 2026) and SAFA-SNN; (ii) the latency and energy figures are projections; (iii) the accuracy gap and the memory cost. We summarize our answers here.

1. What is reused and what is new

  • Reused unchanged from Wang et al. (2026): the BSD rule, i.e. forward and reverse spiking branches, ReCo on pre-LIF potentials, and layer-local updates.
  • Adapted from Wang et al. (2026): their single-layer BSD-RNN (per-step targets), which we adapt to sequence classification with a constant label code, extend to stacked spiking LSTMs, and truncate in time.
  • Reused for FSCIL: prototypes (Snell et al., 2017), SAFA-SNN's base-subspace projection (Eq. 16 only), view averaging and multi-layer cosine fusion. FSCIL is an evaluation probe, not a claimed method.
  • New for edge computing: the analysis showing that the stages of a BSD step are independent and can train in parallel (critical path, Eq. 17); the operation-level energy model for both branches and BP; and the evaluation of 19 non-vision SOUL tasks against matched BP.
  • Edge-oriented optimizations: class-code negatives for small batches, a stage-wise schedule that brings training memory to BP's level, and an extended energy accounting.

BSD was proposed as a biologically plausible learning rule; its value for edge computing had not been examined. We show that its structure gives edge SNNs substantial advantages (stages that train in parallel, an estimated 0.38× the training energy of BP, and training memory on par with BP) while accuracy stays close to BP across five sensing modalities, and we optimize it for this setting. The revised abstract and contribution list state this.

2. New results (on the CIFAR-10 spiking CNN of our vision rows, 5 conv layers, T = 4, unless noted; details in the individual responses; scripts will be released)

  • Small batches. ReCo draws its negatives from the batch, which makes it sensitive to small batches. Adding the C label codes to the reverse batch gives every sample C − 1 negatives at any batch size and keeps the update local. On CIFAR-10 at B = 8 it raises accuracy from 56.5% to 61.0% under the same budget (two seeds, each within 0.1 points of the mean).
  • Same-class pairs in ReCo. Same-class pairs turn the positive term into a calibrated target rather than a conflict. Removing them costs 7.2 points of CIFAR-10 accuracy, so the original design is justified.
  • Memory. The reference implementation keeps both branches' graphs until one backward pass and needs more memory than BP (as in Wang et al., 2026, App. N). Because no error crosses a stage, BSD can run stage by stage with identical gradients; its peak memory is then within 7–11% of BP's (B = 4–128) although it trains two networks. As the reverse branch depends only on the label, same-class samples share their reverse activations, which can be stored once per class to save further memory.
  • Truncation length. All temporal tasks use n = 1 (strictly time-local). Relaxing it to n = T brings GSC to within 1.2 points of BP (revised Appendix B.1).
  • Energy. Adding BatchNorm, LIF updates and optimizer steps for both methods moves the CIFAR-10 per-step ratio only from 0.31× to 0.37×. The revised Section 5.4 also reports the total cost to reach a given accuracy.

3. Revised claims

  • (a) Eq. (17) is a critical-path bound. On general-purpose CPUs and GPUs, BP can use the same parallel resources within each layer, so the bound is not representative there. It applies when stages are mapped to separate compute units, as in layer-per-core neuromorphic processors. We therefore present Eq. (17) as a hardware-conditional bound and remove "reduces the projected training latency to 0.72×" from the abstract and contributions.
  • (b) Energy remains an operation-level estimate for event-driven hardware that turns binary inputs into accumulations. On GPUs, spikes are processed as dense tensors and the estimate does not apply; we state this explicitly.
  • (c) "Learning while inferring" refers to a structural property: the forward branch never waits for the reverse branch or for a global backward pass. Demonstrating uninterrupted on-device learning on neuromorphic hardware is future work. FSCIL is presented as a probe of feature transfer.
  • (d) Correction: the six vision rows of Table 1 are the results of Wang et al. (2026) for the same architecture; the revised caption and Table 3 now say so. For five of them we had listed that study's ANN-BP baseline instead of its surrogate-gradient SNN-BP baseline, and its Tiny-ImageNet result is a single run, so we drop the std there. With the matched SNN-BP values the mean gap is 3.71 points (was 3.76); 11/25 tasks are within 3 points and 19/25 within 5.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.