A Practical Tutorial on Spiking Neural Networks: Comprehensive Review, Models, Experiments, Software Tools, and Implementation Guidelines

1. Introduction

Modern AI systems—especially deep neural networks—have delivered impressive accuracy across vision, language, and control, but at rapidly growing computational and energy costs [1,2]. Mitigation strategies such as pruning and quantization reduce multiply–accumulate (MAC) counts and memory traffic [3,4,5]. Yet, the overall footprint of state-of-the-art models continues to raise sustainability concerns [6]. This tension motivates exploration of alternatives that are accurate and power-aware. Recent studies show conventional ML tackling embedded and industrial tasks under tight resource and latency constraints [7,8,9], underscoring the need for more event-driven, energy-efficient approaches.

Spiking neural networks (SNNs) offer a biologically inspired, event-driven paradigm in which information is conveyed by discrete spikes over time [10,11]. Their sparse, asynchronous computation and temporal coding can translate to lower energy on neuromorphic substrates, while naturally capturing temporal structure [12,13,14,15]. At the same time, practical deployment remains challenging: spikes are non-differentiable, complicating gradient-based optimization [16,17,18]; performance depends critically on the choice of encoding scheme [19,20]; and toolchains and benchmarks for fair SNN–ANN comparisons are still maturing.

Gap. The key gap lies in the lack of a unified, practice-oriented analysis: existing surveys often treat neuron models, encodings, learning rules, and software stacks in isolation, providing limited apples-to-apples evidence on accuracy–energy trade-offs against equivalent ANN baselines across both shallow and deep regimes. A comprehensive perspective that links design choices to measurable performance and power remains scarce.[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33]

This work. We address this gap by combining a comprehensive, critical review with a hands-on tutorial and standardized benchmarking:

• We systematize SNN components: neuron models (Integrate-and-Fire (IF) / Leaky Integrate-and-Fire (LIF), Adaptive Leaky Integrate-and-Fire (ALIF), Exponential Integrate-and-Fire / Adaptive Exponential integrate-and-fire (EIF/AdEx), Resonate-and-Fire (RF), Hodgkin–Huxley (HH), Izhikevich, Resonate-and-Fire–Izhikevich hybrid (RF–Iz), Current-Based neuron (CUBA), Sigma–Delta ($\Sigma \Delta$)), neural encodings (direct/single-value encoding, rate coding, temporal variants including Time-to-First-Spike (TTFS), Rank-Order with Number-of-Spikes (R–NoM), population coding, phase-of-firing coding (PoFC), burst coding, Sigma–Delta encoding ($\Sigma \Delta$)), and learning paradigms(review scope): supervised ( backpropagation-through-time (BPTT) with surrogate gradients; e.g., SLAYER, SuperSpike, EventProp), unsupervised (spike-timing–dependent plasticity(STDP) and variants), reinforcement (reward-modulated (R-STDP), e-prop), hybrid supervised STDP (SSTDP), and ANN→SNN conversion. and Practical pipeline used here: supervised training via BPTT with surrogate gradients (aTan by default; SLAYER/SuperSpike-style updates) for the tutorial and benchmarks. [16,17,18,19].
• We provide a practical tutorial (with reference to a representative neuromorphic software stack, e.g., Lava) covering model construction, encoding choices, and training/inference workflows suitable for resource-constrained deployment.
• We establish a side-by-side evaluation protocol that compares SNNs with architecturally matched ANNs on a shallow setting (MNIST) and a deeper convolutional setting (CIFAR-10 with VGG-style backbones [34]). Metrics include task accuracy/timesteps, spike activity, and power-oriented proxies to illuminate accuracy–efficiency trade-offs.
• We distill design guidelines that map application goals—accuracy targets and per-inference energy budgets—onto actionable choices of neuron model, encoding scheme, number of time steps, and supervised surrogate-gradient training (e.g., SLAYER, SuperSpike, aTan).

Scope and structure.Section 2 reviews encoding strategies, covers neuron models, and outlines learning paradigms and training methods. Section 3 details the experimental setup, the evaluation protocol, and software setup; Section 4 presents comparative results on MNIST and CIFAR-10; Section 4.4 discusses implications; Section 5 concludes with recommendations and future directions. We aim to offer a coherent pathway from principles to practice, helping readers design SNNs that balance accuracy with energy efficiency in real-world settings.

Scope and structure.Section 2 reviews spiking neural network fundamentals, including encoding strategies, neuron models, and learning paradigms. Section 3 presents the datasets, experimental setup, model architectures, and software tools. Section 4 reports the comparative performance and energy analyses on MNIST and CIFAR-10, and provides an integrated discussion of accuracy–energy trade-offs and design implications. Finally, Section 5 summarizes key findings and offers recommendations for future research. Our aim is to provide a coherent pathway from principles to practice, guiding the design of SNNs that balance accuracy with energy efficiency in real-world deployments.

2. Background of Spiking Neural Networks

SNNs are widely regarded as the “third generation” of neural models, narrowing the gap between artificial neural networks (ANNs) and biological computation by representing information with discrete spike events over time [10,35]. Whereas ANNs operate with continuous activations and synchronous MAC operations [36], SNNs exploit sparse, event-driven accumulate updates. This temporal, asynchronous processing aligns with neural physiology and can yield substantial energy savings—particularly on neuromorphic hardware—while natively handling time-dependent signals.

2.0.0.1. Processing pipeline:

Figure 1 outlines a generic SNN workflow comprising encoding, network processing, decoding, and learning. In the encoding stage, external signals are transformed into spike trains. Common strategies include rate codes, time-based codes (e.g., TTFS or inter-spike intervals), and population codes, chosen according to signal statistics and latency/energy constraints. For instance, image intensities can be converted to Poisson spike trains whose rates are proportional to pixel values [37]. During network processing, spikes propagate through layers of model neurons—e.g., LIF, AdEx, Iz, or HH—whose subthreshold dynamics and thresholds shape temporal integration and spike generation [38,39]. Decoding then maps output spike activity to decisions, using spike counts (rate), precise timing (temporal), or pooled population activity, depending on task requirements [37]. Learning rules—supervised, unsupervised, reinforcement, or hybrids—adjust synapses to meet behavioral goals.

2.0.0.2. Power efficiency: mechanisms and practice:

SNN efficiency stems from sparsity (computation occurs only on spike events), lower-cost AC updates in place of dense MACs, and event-driven memory traffic that reduces data movement—often the dominant energy term in modern systems [40,41]. On neuromorphic substrates (e.g., Intel Loihi neuromorphic processor, IBM TrueNorth, SpiNNaker), these properties translate into significant system-level gains via fine-grained parallelism, on-chip routing of spikes, and local memory near compute [42,43,44,45,46,47]. Empirically, energy per inference scales with the total number of synaptic events and the average firing rate; thus design knobs—encoding sparsity (e.g., TTFS, $\Sigma \Delta$), neuron/leaky constants, thresholds, rate regularizers, and time-window length—directly trade accuracy for energy [28,37,48]. Comparative studies report multi× efficiency improvements for SNNs in event-rich settings and on dedicated hardware [42,45,49], while highlighting the importance of maintaining low spike rates and co-optimizing algorithms with hardware constraints.

2.0.0.3. Advantages and challenges:

By construction, SNNs capture temporal dependencies with high timing resolution. They can compute efficiently in sparse regimes, enabling low-latency, low-power inference in settings such as event-based sensing and edge computing [25,28,48]. However, three obstacles temper widespread adoption. First, spike non-differentiability complicates gradient-based training; practical solutions rely on surrogate gradients, exact adjoints, local plasticity, or ANN-to-SNN conversion, each with trade-offs in accuracy, stability, or hardware fit [16,17,18]. Second, performance can lag ANN baselines if encoders/decoders and neuron models are not co-designed with the task [50]. Third, software and hardware ecosystems are still maturing, and standardized, energy-aware benchmarks remain limited.

2.0.0.4. Learning and encoding:

Unsupervised learning often uses spike-timing–dependent plasticity (STDP) to uncover structure from temporal correlations [51]. Supervised training employs BPTT with surrogate gradients to approximate spike derivatives, enabling deep SNN optimization [16]. Reinforcement learning modulates synaptic changes via reward signals, supporting closed-loop control and robotics [52]. Encoding choices strongly influence latency and energy: rate codes are robust but can be spike-heavy; time-based codes reduce spikes and latency but demand precise timing; population codes improve separability and noise tolerance at added computational cost.

2.0.0.5. Real-world applications:

SNNs have been validated across domains where temporal precision and energy constraints dominate. In event-based vision, SNNs on neuromorphic hardware achieve real-time gesture recognition on Dynamic Vision Sensor Gesture with milliwatt-scale budgets [42,53],

robust object/gesture processing on mobile platforms [54,55], and low-latency tracking/control [56,57]. Beyond human-centric vision, embedded deep models are used for animal affect recognition [9]; here SNNs offer a path to lower-latency, lower-power inference for on-animal or field-deployed sensors.

In robotics and closed-loop control,while conventional ANN-based controllers remain prevalent in practice [58,59] spike-based policies run on-chip for responsive, power-aware navigation and manipulation [53,56]. In biomedical signal processing, SNNs support wearable ECG/EEG analytics and brain–computer interfaces with stringent energy and latency requirements [60,61,62,63].

In industrial monitoring and tribology, neural models estimate lubrication parameters from sensor data [7], a setting where spike-based, event-driven inference could reduce power and latency at the edge.

For time-series forecasting, SNNs model nonstationary environmental and energy signals, with conventional ML baselines in subsurface/energy operations providing context for accuracy–efficiency comparisons [8] (e.g., wind/solar) while keeping inference costs low [64,65,66,67,68]. In finance and IoT/edge analytics, event-driven SNNs process sparse, asynchronous streams for anomaly detection and prediction under tight power budgets [69,70,71,72]. These deployments underscore SNNs’ capacity to convert biological inspiration into practical, energy-efficient intelligence—particularly when learning rules, encoding schemes, and neuron models are co-designed with the target hardware and workload.

2.1. Encoding in SNNs

Encoding is a pivotal process in SNNs, transforming continuous-valued inputs into discrete spike events and thereby bridging the gap between external stimuli and spike-based information processing [73]. This transformation is central to leveraging the distinctive advantages of SNNs, including temporal dynamics, event-driven computation, and energy efficiency [74]. The choice of encoding strategy directly affects how effectively information is represented, how temporal patterns are captured, and how power-efficiently the network operates—properties that are crucial for real-time processing and deployment on neuromorphic hardware [75].

Despite their importance, encoding schemes face several design challenges. These include balancing representational accuracy with computational complexity, maintaining biological plausibility, and ensuring compatibility with neuromorphic circuits [76,77]. Furthermore, encoding decisions strongly influence system robustness, as some strategies offer greater resilience to noise or adversarial perturbations than others [78]. As a result, encoding research has increasingly focused on systematically exploring and optimizing strategies to enhance scalability and efficiency, thereby positioning SNNs as viable alternatives to traditional ANNs in energy-constrained and real-time environments [79].

This subsection reviews the main categories of encoding schemes used in SNNs, emphasizing their respective strengths and limitations. Table 1 provides a comparative overview, while Figure 2 and Figure 3 illustrate representative examples. The first figure highlights three fundamental approaches—rate, TTFS, and burst coding—while the second figure expands the view to include inter-spike interval, N-of-M, population, and PoFC coding. Together, these visualizations and the summary table provide an integrated perspective on the diverse ways in which information can be encoded in SNNs.

2.1.1. Rate Coding

Rate coding represents stimulus intensity by the number of spikes emitted within a time window,

$$V={\displaystyle \frac{N_{\mathrm{spike}}}{T}}.$$

(1)

Its simplicity, biological plausibility, and the clean correspondence between firing rates and ANN activations make it a common choice for image/signal processing and embedded deployments where robustness and implementation ease are priorities [78]. Because it averages over a window T, however, it discards fine timing. It often requires longer windows or higher spike counts to reach accuracy—raising latency and energy—so it is less suited to rapid, event-driven scenarios [78,80].

2.1.2. Direct Input Encoding

Direct input encoding feeds continuous-valued signals (e.g., pixel intensities) directly to the input layer without synthesizing spikes [74,78]. By bypassing stochastic spike generation, it can cut timesteps and improve latency and accuracy—useful for deep architectures and large-scale vision or real-time decision tasks—while preserving input fidelity and simplifying the front end [76]. This convenience, however, forgoes event-driven sparsity: multi-bit input activity increases compute and energy versus spike-based schemes and reduces biological plausibility, making it a weaker fit for resource- or power-constrained neuromorphic deployments [73,74,78,81].

2.1.3. Temporal Coding

Temporal coding emphasizes the precise timing of spikes rather than their average rate, aligning with biological evidence that timing carries rich and rapidly accessible information [24,38,75]. By leveraging when spikes occur, this family of methods offers faster and potentially more energy-efficient information transfer compared to rate coding. Several variants exist:

• Time-to-First-Spike (TTFS): encodes stimulus strength in the latency of the first spike:

  $$t_{\mathrm{spike}}=t_{\mathrm{onset}}+\Delta t,$$

  (2)

  where $t_{\mathrm{onset}}$ is stimulus onset and $\Delta t$ the delay before firing [14]. TTFS is highly power-efficient, as minimal spiking activity can support rapid decisions, though it requires precise timing and complicates learning.
• Inter-Spike Interval (ISI): uses the time gap between consecutive spikes,

  $$IS{I}_i=t_{i+1}-t_i,$$

  (3)

  providing richer temporal detail at the cost of increased spiking and energy use [14].
• N-of-M (NoM) Coding: transmits only the first N of M possible spikes, enhancing hardware efficiency but discarding spike-order information [82].
• Rank Order Coding (ROC): exploits the sequence of spike arrivals according to synaptic weights, offering high discriminability but at the cost of computational intensity and sensitivity to precise timing [24].
• Ranked-N-of-M (R-NoM): integrates ROC and NoM by propagating the first N spikes while weighting their order:

  $$\mathrm{Activation}=\sum _{i=1}^N{\mathrm{Weight}}_i\times f\left(i\right)\times {\mathrm{Spike}}_i,$$

  (4)

  where $f\left(i\right)$ is a decreasing modulation with spike order [82].

Critically, temporal coding can yield more information per spike and support low-latency decisions, potentially reducing total energy if efficiently implemented. Yet, it introduces challenges in robustness: decoding is complex, schemes are sensitive to noise and spike-timing variability, and training deep SNNs with precise temporal codes remains difficult [76]. These trade-offs highlight temporal coding as a powerful but demanding alternative, most suitable when rapid responses and acceptable temporal resolution outweigh simplicity and energy stability.

2.1.4. Population Coding

Population coding distributes information over an ensemble, improving robustness and separability—useful for noisy, time-varying signals (e.g., speech/audio, sensor fusion)—but at the cost of more neurons, decoding overhead, and energy/memory traffic [83,84]. A common readout is the weighted population response.

$$R=\sum _{i=1}^n{w}_i{r}_i,$$

with neuron weights $w_i$ and responses $r_i$; this complements latency/phase-based schemes by pooling precise temporal cues while trading efficiency for reliability [83,84].

2.1.5. $\Sigma \Delta$ Encoding

$\Sigma \Delta$ encoding transmits changes rather than absolute values via a simple feedback loop,

$$\Delta x_t=x_t-x_{t-1},$$

(5)

$$y_t=\mathrm{Threshold}\left({\Sigma }_t+\Delta x_t\right),$$

(6)

$${\Sigma }_{t+1}={\Sigma }_t+\Delta x_t-y_t,$$

(7)

where $x_t$ is the input, $\Delta x_t$ the increment, $y_t$ the emitted spike, and ${\Sigma }_t$ an accumulated reconstruction error. Focusing on differences yields sparse spike trains with strong temporal fidelity and lower energy, suiting dynamic, streaming signals on neuromorphic and wearable/biomedical platforms [74,78]. Noise–shaping aids robust reconstruction [85,86,87], though effective deployment requires careful threshold/feedback tuning and circuit-aware trade-offs between fidelity, latency, and power [88].

2.1.6. Burst Coding

Burst coding represents information with short, high-frequency spike packets—mirroring rhythmic patterns observed in cortex and subcortex [13,75,89,90]. A burst for neuron i over a window $[t_{\mathrm{start}},t_{\mathrm{end}}]$ can be written as

$$B_i=\sum _{t=t_{\mathrm{start}}}^{t_{\mathrm{end}}}{s}_i\left(t\right),$$

(8)

where $s_i\left(t\right)\in \{0,1\}$ indicates a spike at time t. Packing spikes in brief episodes supports rapid information transfer and strong temporal cues with fewer decision windows, which is attractive for event-rich sensing and closed-loop control; at the same time, coordinating burst onset and network-wide timing complicates decoding and hardware scaling, and poorly tuned burst parameters can negate energy savings [13,75,89,90]. In practice, burst coding is most useful when biological realism and efficient processing of temporally complex signals are priorities, provided synchronization and parameterization are carefully managed.

2.1.7. PoFC Coding

PoFC encodes information by the phase of each spike relative to an ongoing oscillation (e.g., theta/gamma) [87,91,92,93]. The phase of the i-th spike is

$${\varphi }_i=mod\left(t_{{\mathrm{spike}}_i}-t_{\mathrm{osc}},T_{\mathrm{osc}}\right),$$

(9)

with $t_{\mathrm{osc}}$ the oscillation reference and $T_{\mathrm{osc}}$ its period. By leveraging phase locking observed in hippocampus and other circuits, PoFC can pack more information per spike than rate codes—enabling rich, low-count representations and potentially lower energy—yet it relies on precise synchronization and is sensitive to timing jitter; accurate phase extraction and integration with plasticity (e.g., STDP) add implementation complexity [91,92,93]. PoFC is most compelling for high-fidelity temporal discrimination and navigation/sensory tasks shaped by oscillatory dynamics, while resource-constrained neuromorphic deployments must balance its representational gains against robustness and hardware simplicity [87].

2.1.8. Impact of Encoding Schemes on SNN Performance and Power Efficiency

Encoding is a primary lever for both representation and compute/energy footprint. Foundational work spans $\Sigma \Delta$ modulation for efficient analog–to–spike conversion [85] and temporally rich schemes like rank–order coding [24]; subsequent surveys emphasize that the “best” code is application-dependent, balancing accuracy, latency, energy, robustness, and hardware constraints [73]. Recent refinements show (i) $\Sigma \Delta$ interfaces adapted to SNNs preserve fidelity over wide dynamics while cutting spikes, at the cost of feedback tuning and circuit complexity [86,87]; (ii) unified analyses of TTFS/ROC/NoM/R–NoM clarify discriminability under realistic noise and timing variability, and differentiable training narrows the gap to gradient-based optimization [76,82]; and (iii) hybrid/dynamic schemes (e.g., layer-wise burst+phase or attention-gated temporal codes) improve throughput-per-watt without sacrificing accuracy [13,94,95]. Comparative trends remain consistent: direct-input (analog) encoding lowers timesteps and can boost accuracy/latency on deep tasks but forgoes event-driven sparsity at the input stage [74]; rate coding is simple, conversion-friendly, and relatively robust yet loses fine timing and may need longer windows or higher spike counts [78]; temporal codes (TTFS/ISI) offer high information per spike and fast decisions but are jitter-sensitive and harder to train/deserialize at scale [14,82]; population coding strengthens separability and noise tolerance for temporally rich signals at the expense of neuron count and decoding cost [84]. Table 1 and Figure 2, Figure 3, and Figure 4 summarize these trade-offs.

2.1.8.1. Guidelines for Selecting an Encoding Scheme.

• Primary objective: For latency-critical workloads, prefer TTFS/ROC or layer-wise hybrids that surface fast temporal cues [13,14]. For energy-constrained continuous sensing, use $\Sigma \Delta$ or sparse rate coding [78,86,87].
• Noise/non-idealities: In noisy sensors or non-ideal hardware, population or burst coding can add robustness; fine temporal codes may need careful clocking/filtering [13,84].
• Model/hardware complexity: Favor rate or direct-input encoding for simplicity, ANN→SNN conversion, or tight device budgets; reserve $\Sigma \Delta$/temporal hybrids for platforms that support feedback loops or precise timing [74,78,87].
• Scalability/training: When end-to-end gradients are central, choose encodings with strong surrogate-gradient support (rate, TTFS, selected hybrids) and validated noise tolerance [76,82].

In sum, no single code dominates. Effective designs tailor (and often hybridize) encodings to the task’s accuracy–latency–energy envelope and the target hardware’s timing/circuit capabilities, as visualized in Figure 2, Figure 3, Figure 4 and summarized in Table 1.

2.2. SNN Neuron Models

Neuron models are the computational primitives of SNNs: they determine how synaptic events are integrated, how spikes are generated, and how signals propagate through a network. Their choice governs representational power, energy consumption, latency, and hardware suitability [10,38,96]. Broadly, models lie on a spectrum that trades biological detail for computational efficiency. At one extreme, biophysical formulations such as HH accurately reproduce membrane dynamics but are expensive at scale [97,98]. Toward the efficient end, families of integrate-and-fire models (IF, LIF and extensions such as ALIF, QIF/EIF, SRM) abstract spiking as filtered integration plus thresholding, enabling large networks and low-power deployment [38]. Intermediate phenomenological models (Izhikevich, AdEx, RF) reproduce rich firing patterns with moderate cost, offering a pragmatic balance for many tasks [39,99].

Selecting a neuron model is therefore an application-driven decision that weighs fidelity, efficiency, and implementation complexity. Detailed conductance-based models can be advantageous for tasks requiring precise subthreshold or adaptation dynamics; simplified IF variants often suffice for rate-based processing and fast, energy-aware inference; intermediate models are attractive when diverse temporal patterns are essential but resources are limited. Additional considerations include the availability of stable learning rules (e.g., surrogate-gradient training for LIF/AdEx/Izhikevich), robustness to noise and device non-idealities, and the target hardware’s support for state variables and synaptic dynamics [96,98,99]. A concise, per-model synopsis of mechanisms, advantages, and challenges is provided in Table 2.

2.2.1. Spike Response Model (SRM)

The SRM is a compact, kernel-based description of a spiking neuron in which the membrane potential is the superposition of post-synaptic response kernels and a spike-triggered afterpotential [38,100]:

$$V\left(t\right)=\eta (t-\widehat{t})+{\int }_{-\infty }^t\kappa (t-\widehat{t},s)I(t-s)ds,$$

(10)

where $\widehat{t}$ is the last spike time, $\eta (·)$ a refractory/after-spike kernel, $\kappa (·,·)$ a synaptic filter, and $I(·)$ the input drive. Spikes occur when $V\left(t\right)$ crosses a dynamic threshold,

$$\theta (t-\widehat{t})=\left\{\begin{array}{cc}\infty ,\hfill & t-\widehat{t}\le {\gamma }_{\mathrm{ref}},\hfill \\ {\theta }_0+{\theta }_1{e}^{-(t-\widehat{t})/{\tau }_{\theta }},\hfill & \mathrm{otherwise},\hfill \end{array}\right.$$

(11)

with absolute refractory period ${\gamma }_{\mathrm{ref}}$ and exponential recovery to ${\theta }_0$. SRM spans fixed-kernel variants (SRM₀) and versions with spike-triggered threshold adaptation/state-dependent kernels (SRM₊), unifying integrate-and-fire dynamics while remaining analytically tractable and efficient for event-driven simulation. This separation of synaptic and refractory effects makes SRM convenient for modeling STDP, probing computational properties, and hardware-friendly implementations. Being phenomenological, however, it lacks rich subthreshold biophysics (e.g., voltage-gated conductances or resonance) unless extended, and practical use requires careful calibration of $\eta$, $\kappa$, and $\theta (·)$ [38].

2.2.2. Integrate-and-Fire (IF) and Leaky Integrate-and-Fire (LIF)

The integrate-and-fire family models a neuron as a linear integrator with threshold-and-reset dynamics [38,101,102,103,104]: when $V\left(t\right)$ crosses $\vartheta$ from below, a spike is emitted and $V\leftarrow V_{\mathrm{reset}}$ (optionally with a refractory period). Its minimal state, analytical tractability, and event-driven simulation make it a staple for large-scale SNNs and neuromorphic deployment.

2.2.2.1. Perfect IF (PIF).

An ideal, non-leaky integrator accumulates input without passive decay,

$$C{\displaystyle \frac{dV\left(t\right)}{dt}}=I\left(t\right),$$

(12)

with capacitance C and input current $I\left(t\right)$. Once $V\left(t\right)\ge \vartheta$, a spike occurs and $V\leftarrow V_{\mathrm{reset}}$. PIF is computationally minimal but overestimates temporal integration by omitting leak.

2.2.2.2. Leaky IF (LIF).

illustarted in Figure 5 Incorporating passive leak yields

$${\tau }_m{\displaystyle \frac{dV\left(t\right)}{dt}}=-\left(V\left(t\right)-V_{\mathrm{rest}}\right)+RI\left(t\right),$$

(13)

with ${\tau }_m=RC$, membrane resistance R, and resting potential $V_{\mathrm{rest}}$. LIF captures membrane decay, supports stochastic analysis, and enables efficient event-driven updates [38,103].

IF/LIF deliver simplicity, stability, and compatibility with surrogate-gradient training, but their linear subthreshold dynamics lack conductance nonlinearities (e.g., adaptation, resonance). In practice they are often augmented (ALIF) or extended (EIF/AdEx) when richer temporal behavior is required.

2.2.3. Adaptive Leaky Integrate-and-Fire (ALIF)

ALIF augments LIF with spike-frequency adaptation, reproducing reduced firing under sustained drive via either a dynamic threshold or a spike-triggered hyperpolarizing current [38,100,105]. This adds history dependence while retaining efficient, event-driven simulation and surrogate-gradient trainability.

2.2.3.1. Dynamic-threshold ALIF.

$${\tau }_m{\displaystyle \frac{dv\left(t\right)}{dt}}=-\left(v\left(t\right)-V_{\mathrm{rest}}\right)+RI\left(t\right),\mathrm{spike}\mathrm{if}v\left(t\right)\ge \theta \left(t\right),$$

(14)

$$\theta \left(t\right)={\theta }_0+\beta \sum _{t_s<t}exp\left(-(t-t_s)/{\tau }_{\theta }\right),$$

(15)

where ${\tau }_m=RC$, ${\theta }_0$ is baseline threshold, $\beta$ adaptation strength, and ${\tau }_{\theta }$ its decay; on a spike at $t_s$, $v\left(t_s^{+}\right)=V_{\mathrm{reset}}$.

2.2.3.2. Current-based ALIF.

$${\tau }_m{\displaystyle \frac{dv\left(t\right)}{dt}}=-\left(v\left(t\right)-V_{\mathrm{rest}}\right)+RI\left(t\right)-w\left(t\right),\mathrm{spike}\mathrm{if}v\left(t\right)\ge \vartheta ,$$

(16)

$${\tau }_w{\displaystyle \frac{dw\left(t\right)}{dt}}=-w\left(t\right)+b\sum _{t_s<t}\delta (t-t_s),$$

(17)

with adaptation current $w\left(t\right)$, jump b per spike, and decay ${\tau }_w$; after a spike $v\left(t_s^{+}\right)=V_{\mathrm{reset}}$, $w\left(t_s^{+}\right)\leftarrow w\left(t_s^{-}\right)+b$.

ALIF improves sequence processing and temporal credit assignment with modest overhead but introduces extra state/parameters that need calibration; very slow or multi-timescale adaptation may call for extended variants (e.g., AdEx or multi-${\tau }_w$ ALIF) [102,103].

2.2.4. Exponential Integrate-and-Fire (EIF)

The EIF neuron sharpens spike initiation by adding an exponential term to the leaky membrane dynamics, providing a smooth, biophysically motivated threshold [38,106]. In current-based form,

$${\tau }_m{\displaystyle \frac{dV\left(t\right)}{dt}}=-\left(V\left(t\right)-V_{\mathrm{rest}}\right)+{\Delta }_{T}exp\left({\displaystyle \frac{V\left(t\right)-V_T}{{\Delta }_T}}\right)+RI\left(t\right),$$

(18)

where $V_{\mathrm{rest}}$ is the resting potential, $V_T$ the rheobase (effective spike-initiation) voltage, ${\Delta }_T$ the slope factor controlling the sharpness of onset, and $I\left(t\right)$ the input current. A spike is emitted when $V\left(t\right)$ diverges past a set peak (e.g., $V_{\mathrm{spike}}$), after which $V\leftarrow V_{\mathrm{reset}}$ and an absolute refractory period ${\tau }_{\mathrm{ref}}$ may be imposed.

Compared with LIF, EIF reproduces the rapid upstroke of action potentials and more accurate responses to fast, fluctuating inputs (gain, phase response, and f–I curves) while remaining far cheaper than conductance-based models [104,106]. The extra nonlinearity and parameters improve fidelity but require calibration (notably ${\Delta }_T$ and $V_T$) and can stiffen numerical integration near threshold. EIF serves as a practical compromise for studies of high-frequency synaptic integration, spike initiation, and neuromorphic implementations that need a smooth, differentiable surrogate of threshold dynamics [38].

2.2.5. Adaptive Exponential Integrate-and-Fire (AdEx)

AdEx extends LIF with an exponential spike-initiation term and a spike-triggered adaptation variable, yielding a compact neuron that reproduces regular-/fast-spiking, adapting, and bursting behaviors [107]:

$$C_m{\displaystyle \frac{d{V}_m}{dt}}=-G_L(V_m-E_L)+G_L{\Delta }_{T}exp\left({\displaystyle \frac{V_m-V_T}{{\Delta }_T}}\right)-w+I_{\mathrm{syn}},$$

(19)

$${\tau }_w{\displaystyle \frac{dw}{dt}}=a(V_m-E_L)-w,$$

(20)

where $V_m$ is membrane potential, $C_m$ capacitance, $G_L$ leak conductance, $E_L$ leak reversal, $V_T$ spike-initiation voltage, ${\Delta }_T$ slope factor, w the adaptation current, a subthreshold adaptation, ${\tau }_w$ its time constant, and $I_{\mathrm{syn}}$ synaptic current. A spike is registered when $V_m$ exceeds $V_{\mathrm{spike}}$, after which $V_m\leftarrow V_{\mathrm{reset}}$ and $w\leftarrow w+b$ (optional absolute refractory).

EIF-like sharp onset supports realistic spike initiation, while $(a,{\tau }_w,b)$ captures spike-frequency adaptation and bursting at modest cost, enabling efficient numerical integration and event-driven simulation. Hardware-oriented variants (fixed-point/high-accuracy arithmetic, power-of-two linearizations, CORDIC exponentials) further reduce runtime without sacrificing fidelity [108,109,110]. Careful calibration of ${\Delta }_T$, $V_T$, and adaptation parameters is essential; near-threshold stiffness may require smaller steps or dedicated solvers. In practice, AdEx is a good default when richer dynamics than LIF are needed with only a slight complexity increase.

2.2.6. Resonate-and-Fire (RF)

The RF neuron captures subthreshold oscillations and frequency selectivity—complementing integrator-style IF/LIF models—via a complex state with linear dynamics [111]:

$${\dot{z}}_i\left(t\right)=\left(b_i+i{\omega }_i\right)z_i\left(t\right)+\sum _{j=1}^n{c}_{ij}\delta \left(t-t_j^{\prime }\right),$$

(21)

where $z_i\in \mathbb{C}$ encodes the oscillatory state, ${\omega }_i$ is the intrinsic angular frequency, $b_i<0$ sets damping (stability requires $\mathrm{Re}\left\{b_i\right\}<0$), $c_{ij}$ are synaptic couplings, and $\delta (·)$ are pre-synaptic spike impulses at times $t_j^{\prime }$. A spike is emitted when a readout (e.g., $\mathrm{Im}\left\{z_i\right\}$ or a linear projection of $(\mathrm{Re}\left\{z_i\right\},\mathrm{Im}\left\{z_i\right\})$) crosses threshold ${\vartheta }_{\mathrm{RF}}$ from below, followed by a reset $z_i\leftarrow z_{\mathrm{reset}}$. Writing $z_i=x_i+i{y}_i$ reveals a damped resonator with eigenvalues $b_i\pm i{\omega }_i$, producing natural selectivity to inputs near ${\omega }_i$ and to spike phase—useful for tasks rich in temporal structure, resonance, and phase-/PoFC-style coding.

In practice, RF offers lightweight oscillatory dynamics that simulate efficiently and admit analysis; balanced RF (BRF) improves stability in recurrent SNNs by regulating excitation–inhibition [112], and analog realizations demonstrate direct signal-to-spike conversion for edge sensing without explicit A/D front-ends [113]. As a phenomenological model, however, spiking is threshold-based (not biophysical), channel nonlinearities are implicit, parameters (frequency, damping, reset) require calibration, and the second-order state increases per-neuron cost versus IF/LIF; for strongly nonlinear spiking such as complex bursting, AdEx or Izhikevich variants can be preferable.

2.2.7. Hodgkin–Huxley (HH)

The HH model gives a biophysical account of spike generation via voltage–gated ${\mathrm{Na}}^{+}$ and ${\mathrm{K}}^{+}$ channels plus leak, fit to voltage–clamp data from squid axon [97]. The membrane equation balances capacitive and ionic currents:

$$C_m{\displaystyle \frac{dV}{dt}}=-g_L(V-E_L)-g_{\mathrm{Na}}{m}^{3}h(V-E_{\mathrm{Na}})-g_{\mathrm{K}}{n}^4(V-E_{\mathrm{K}})+I_{\mathrm{syn}}+I_{\mathrm{ext}},$$

(22)

with gating kinetics

$$\dot{x}={\alpha }_x\left(V\right)\left(1-x\right)-{\beta }_x\left(V\right)x,x\in \{m,h,n\}.$$

(23)

As the gold standard for single–cell fidelity, HH reproduces subthreshold dynamics, spike upstroke, refractoriness, and pharmacological effects, making it ideal for mechanism studies and validating reduced models. Its computational cost (stiff ODEs, many parameters) limits large network use, so EIF/AdEx/LIF variants are typically preferred for SNN simulation [38]. Hardware–aware implementations (e.g., CORDIC-based exponentials/fractions on FPGAs) improve tractability [114], and conductance–based synapse extensions clarify information transfer under realistic inputs [115].

2.2.8. Izhikevich

The Izhikevich neuron is a two–state hybrid model that reproduces a wide repertoire of cortical firing patterns at very low computational cost [39,89]. With membrane potential V and recovery variable U,

$$\begin{array}{cc}\hfill {\displaystyle \frac{dV}{dt}}& =0.04V^2+5V+140-U+I\left(t\right),\hfill \end{array}$$

(24)

$$\begin{array}{cc}\hfill {\displaystyle \frac{dU}{dt}}& =a\left(bV-U\right),\hfill \end{array}$$

(25)

and after-spike reset

$$\mathrm{if}V\ge V_{\mathrm{peak}}\left(\mathrm{typically}30\mathrm{mV}\right),V\leftarrow c,U\leftarrow U+d.$$

(26)

Here $I\left(t\right)$ is the synaptic/injected current; $a,b,c,d$ control time scale, sensitivity, and reset. Proper tuning yields tonic/fast spiking, bursting, chattering, rebound, and Class I/II excitability while avoiding explicit action-potential integration, enabling large-scale simulations and neuromorphic emulation with good accuracy–efficiency trade-offs [39,89]. As a phenomenological model, parameters have limited biophysical interpretability and often require heuristic fitting; numerical care near $V_{\mathrm{peak}}$ is useful. In practice, it serves as a pragmatic middle ground—richer dynamics than IF/LIF at modest cost, though for detailed channel mechanisms HH/AdEx may be preferred, and for strict minimalism or gradient training pipelines LIF/ALIF remain common [38].

2.2.9. Resonate-and-Fire Izhikevich (RF–Iz)

RF–Iz augments the RF oscillator with a minimal hybrid spike/reset that preserves phase while simplifying post-spike dynamics [111]. The subthreshold state follows RF (cf. (21)):

$$\dot{z}\left(t\right)=\left(b+i\omega \right)z\left(t\right)+\sum _j{c}_j\delta \left(t-t_j^{\prime }\right),$$

(27)

with $z\in \mathbb{C}$ the oscillatory state, $\omega$ preferred frequency, $b<0$ damping, and $c_j$ synaptic couplings. Spiking is phase-sensitive, with a lightweight reset that retains the imaginary (phase) component:

$$\begin{array}{cc}\hfill & \mathrm{spike}\mathrm{if}Im\left\{z\right(t\left)\right\}\ge \vartheta ,\hfill \end{array}$$

(28)

$$\begin{array}{cc}\hfill & \mathrm{after}\mathrm{spike}\text{:}Re\left\{z\right(t\left)\right\}\leftarrow 0,z\left(t\right)\leftarrow iIm\left\{z\right(t\left)\right\},\hfill \end{array}$$

(29)

optionally followed by an absolute refractory period. This preserves resonance and phase continuity, yielding low-cost frequency selectivity and PoFC-style coding—more faithful to oscillatory timing than IF/LIF yet far cheaper than conductance-based neurons. As a phenomenological model, spike generation is thresholded and channel nonlinearities are implicit; parameters $(\omega ,b,\vartheta )$ require calibration, and for complex bursting, AdEx/Izhikevich or HH may be preferable. Efficient discrete-time updates with event-driven checks are available in neuromorphic toolchains (e.g., Lava) for large-scale simulation and deployment [116].

2.2.10. Current-Based Neuron (CUBA)

In the current-based (CUBA) formulation, synaptic events enter the membrane equation as additive currents independent of voltage, in contrast to conductance-based (COBA) synapses that scale with the driving force [98]. The membrane potential obeys

$${\displaystyle \frac{dV\left(t\right)}{dt}}=-{\displaystyle \frac{V\left(t\right)-V_{\mathrm{rest}}}{{\tau }_m}}+I_{\mathrm{syn}}\left(t\right),$$

(30)

with resting potential $V_{\mathrm{rest}}$, membrane time constant ${\tau }_m$, and total synaptic current $I_{\mathrm{syn}}\left(t\right)$ (typically a weighted sum of pre-synaptic spike kernels). A spike is emitted when $V\left(t\right)\ge V_{\mathrm{thresh}}$, followed by a reset $V\leftarrow V_{\mathrm{reset}}$ and an optional absolute refractory period.

CUBA is computationally efficient and analytically convenient for large-scale SNNs because synaptic drive does not depend on V. Its main limitation is reduced biological realism relative to COBA (e.g., no reversal potentials or shunting), which can bias gain and dynamics in high-conductance regimes [98].

2.2.11. $\Sigma \Delta$ Neuron ($\Sigma \Delta$)

The $\Sigma \Delta$ neuron realizes asynchronous pulsed $\Sigma \Delta$ modulation (APSDM), emitting spikes only when the discrepancy between the instantaneous drive $S\left(t\right)$ (e.g., filtered synaptic current) and its internal reconstruction $\widehat{S}\left(t\right)$ exceeds a dynamic threshold [117]. With error variable

$$u\left(t\right)=S\left(t\right)-\widehat{S}\left(t\right),$$

(31)

A spike is produced when

$$\mathrm{if}\left|u\left(t\right)\right|\ge \vartheta \left(t\right)\Rightarrow y\left(t\right)\in \{-1,+1\},\widehat{S}\left(t^{+}\right)\leftarrow \widehat{S}\left(t^{-}\right)+y\left(t\right)\vartheta \left(t\right),$$

(32)

and the adaptive threshold evolves via

$$\vartheta \left(t\right)={\vartheta }_0+\sum _{t_i<t}\beta exp\left(-(t-t_i)/{\tau }_{\vartheta }\right),$$

(33)

So spikes convey only significant changes, yielding sparse activity and low switching energy.

A practical discrete-time form (common in neuromorphic stacks) uses a dead-zone delta encoder with sigma reconstruction [116]:

$$\Delta x_t=x_t-{\widehat{x}}_{t-1},y_t=sgn\left(\Delta x_t\right)\mathbb{1}\left\{\right|\Delta x_t|>\theta \},{\widehat{x}}_t={\widehat{x}}_{t-1}+y_t\theta ,$$

(34)

optionally combined with LIF subthreshold dynamics (“$\Sigma \Delta$–LIF”). In dynamic sensing (audio/vision streams), this event-driven compressor achieves high-fidelity reconstructions with few spikes and strong energy efficiency [88,117].

Effective use hinges on feedback/threshold tuning and stability of the reconstruction; poorly chosen $\theta$ or kernels raise quantization noise or latency, and deployment may require careful calibration (step sizes, refractory handling). Reference implementations and layer abstractions are available in Lava for large-scale simulation and deployment [116].

2.2.12. Trade-offs in Neuron Model Selection for SNNs

Model choice balances biological fidelity, compute/energy, trainability, and hardware fit (see Table 2).

IF/LIF—Minimal state and event-driven efficiency make them the default for large, low-power systems; linear subthreshold dynamics limit adaptation/resonance [38,101,103,104].

ALIF—Adds spike-frequency adaptation (dynamic threshold or current) for better sequence processing with modest overhead; extra parameters need calibration [100,105].

EIF/AdEx—Smooth spike onset (exp term) and adaptation reproduce diverse cortical patterns at moderate cost; accuracy depends on careful tuning of ${\Delta }_T,V_T,a,b,{\tau }_w$ and can stiffen numerics near threshold [106,107].

SRM—Kernel superposition with spike-triggered refractoriness is analytically tractable and efficient; phenomenological nature limits rich subthreshold nonlinearities unless extended [38,100].

Izhikevich—2D hybrid yields rich firing at low cost; parameters are less biophysically interpretable and typically fit heuristically [39,89].

RF / RF–Iz—Resonator neurons capture phase/resonance for PoFC-like codes; lightweight but with added second-order state and calibration; BRF improves recurrent stability [111,112].

HH—Gold-standard ion-channel fidelity for mechanism studies; too costly/stiff for large or ultra–low-power networks; useful as a reference [97].

CUBA—Current-based synapses are simple and fast for scaling/analysis; reduced realism vs. COBA grows in high-conductance regimes [98].

$\Sigma \Delta$ neuron—Event-driven, error-based spiking transmits only significant changes for sparse, energy-efficient operation; performance hinges on feedback/threshold tuning; supported in Lava and low-power circuits [88,116,117].

2.2.12.1. Practical guidelines.

• Energy/scale: LIF/ALIF or $\Sigma \Delta$; use CUBA when speed > realism.
• Temporal richness: ALIF, EIF/AdEx, or RF/RF–Iz for adaptation/resonance/phase coding.
• Mechanistic fidelity: HH for channel-level questions; validate reduced models against HH.
• Trainability: Prefer models with robust surrogate-gradient practice; constrain parameters to avoid stiffness/instability.
• Hardware fit: Match state and nonlinearities to fabric (fixed-point, exponentials/CORDIC, event-driven kernels); layer-wise hybrids (e.g., LIF front-ends + AdEx/ALIF deeper) often win on accuracy–efficiency.

Overall, no single model is optimal; combine/stack models to meet the task’s accuracy–latency–energy envelope and hardware constraints.

2.3. Learning Paradigms in SNNs

Learning endows SNNs with the capacity to adapt and generalize while exploiting event-driven, temporally precise computation—an advantage over ANNs with static, continuous activations [18]. The same spiking discreteness, however, poses two central challenges: (i) the non-differentiability of spikes, which complicates gradient-based optimization, and (ii) temporal credit assignment across membrane dynamics and spike times [16,17]. Contemporary training strategies address these issues through several complementary paradigms. Supervised methods cast SNNs as recurrent systems and apply BPTT, often with surrogate gradients that replace the intractable spike derivative by smooth approximations; recent variants learn surrogate shapes or widths to mitigate vanishing/instability and improve convergence [118,119,120,121]. Unsupervised approaches—most prominently STDP—offer biologically plausible synaptic adaptation but may require additional signals or architectures to reach state-of-the-art accuracy [51,122]. Reinforcement learning leverages reward signals to shape spiking policies in interactive settings, while hybrid schemes combine supervision, self-organization, and reward to exploit their complementary strengths. Finally, ANN-to-SNN conversion transfers weights from trained ANNs to spiking counterparts, sidestepping non-differentiability at training time and enabling efficient deployment on neuromorphic hardware [16,18]. No single paradigm dominates across tasks; the appropriate choice depends on accuracy–latency–energy requirements, biological plausibility, data regime, and hardware constraints. A consolidated view of representative algorithms, their mechanisms, advantages, and limitations appears in Table 3.

2.3.1. Supervised Learning

Supervised learning trains SNNs on labeled datasets by pairing each input with a target output (e.g., class labels or desired spike statistics). Because spikes are discrete, standard backpropagation is impeded by the non-differentiability of spike events. Practical methods therefore unroll the network in time (as for recurrent nets) and optimize losses defined on spike-based readouts—such as spike counts, rates, or latencies—while replacing the intractable spike derivative with a smooth surrogate gradient [16]. This enables gradient-based training with BPTT and related variants, yielding high accuracy on classification and regression tasks, albeit with increased memory/computation from temporal unrolling and the need to tune surrogate functions and time constants.

2.3.1.1. SpikeProp

SpikeProp [123] was one of the earliest backpropagation-style algorithms for SNNs, extending temporal error backpropagation to learn precise spike times—particularly useful for temporal pattern recognition. The synaptic update is

$$\Delta w_{ij}=-\eta \sum _d{\displaystyle \frac{\partial E}{\partial t_i^d}}{\displaystyle \frac{\partial t_i^d}{\partial w_{ij}}},$$

(35)

where $\eta$ is the learning rate, E measures the mismatch between actual and desired spike times $t_i^d$, and $\partial t_i^d/\partial w_{ij}$ is the spike-time sensitivity. SpikeProp showed that backpropagation concepts can be carried into the temporal domain, enabling accurate nonlinear classification with fewer units than purely rate-based networks and foreshadowing modern surrogate-gradient and locality-aware rules.

2.3.1.2. SuperSpike

SuperSpike [124] generalizes SpikeProp by introducing surrogate gradients and eligibility traces for deep, multilayer SNNs trained on spatiotemporal inputs. The update takes the form

$$\Delta w_{ij}=\eta {\int }_{t_b}^{t_{b+1}}{e}_i\left(t\right)\left[\alpha *\left({\sigma }^{\prime }\left(U_i\left(t\right)\right)·(ϵ*S_j)\left(t\right)\right)\right]dt,$$

(36)

with error signal $e_i\left(t\right)$, surrogate derivative ${\sigma }^{\prime }\left(U_i\left(t\right)\right)$ of the spike function, and presynaptic trace $(ϵ*S_j)\left(t\right)$. By combining gradient approximation with local eligibility, SuperSpike enables end-to-end training despite spike non-differentiability.

2.3.1.3. SLAYER

SLAYER (Spike Layer Error Reassignment in Time) [120] tackles temporal credit assignment by propagating error signals backward through time and reassigning them to causal spike events. The generic update is

$$\Delta w=-\eta \sum _t{\displaystyle \frac{\partial E}{\partial s\left(t\right)}}{\displaystyle \frac{\partial s\left(t\right)}{\partial w}},$$

(37)

where $\partial s\left(t\right)/\partial w$ is a surrogate gradient of the spike train concerning the weight. SLAYER is effective for tasks that hinge on precise spike timing, such as sequence prediction and temporal classification.

2.3.1.4. EventProp

EventProp [125] computes exact gradients by explicitly handling derivative discontinuities at spike times via an adjoint method, avoiding surrogate approximations. The loss is

$$L=l_p\left(t_{\mathrm{post}}\right)+{\int }_0^T{l}_V(V\left(t\right),t)dt,$$

(38)

and its gradient w.r.t. a synapse $w_{ji}$ is

$${\displaystyle \frac{dL}{d{w}_{ji}}}=-{\tau }_{\mathrm{syn}}\sum _{\mathrm{spikes}\mathrm{from}i}{\left({\lambda }_I\right)}_j,$$

(39)

where ${\left({\lambda }_I\right)}_j$ is the adjoint for the synaptic current and ${\tau }_{\mathrm{syn}}$ a synaptic constant. The event-driven treatment lowers memory and compute overheads, making EventProp appealing for neuromorphic execution.

2.4. Unsupervised Learning in SNNs

Unsupervised learning discovers structure without labels, typically through local rules that exploit spike timing. The most prominent is STDP, with numerous extensions improving stability, hardware efficiency, and biological plausibility.

2.4.0.5. STDP

Classical STDP [51,122] modifies synapses by the relative timing of pre-/post-spikes:

$$\Delta w=\left\{\begin{array}{cc}{A}^{+}exp\left(\frac{t_{\mathrm{pre}}-t_{\mathrm{post}}}{{\tau }^{+}}\right),\hfill & t_{\mathrm{pre}}\le t_{\mathrm{post}},\hfill \\ A^{-}exp\left(-\frac{t_{\mathrm{pre}}-t_{\mathrm{post}}}{{\tau }^{-}}\right),\hfill & t_{\mathrm{pre}}>t_{\mathrm{post}},\hfill \end{array}\right.$$

(40)

with $(A^{+},A^{-})$ the potentiation/depression amplitudes and $({\tau }^{+},{\tau }^{-})$ the time constants.

2.4.0.6. Adaptive STDP (aSTDP)

aSTDP extends classical STDP by dynamically adjusting the parameters governing synaptic updates, thereby improving stability and robustness -—particularly in neuromorphic hardware with limited synaptic resolution [126]. The variant proposed by Gautam and Kohno simplifies the exponential weight-update function into a rectangular learning window, improving hardware efficiency. The update rule is:

$$\Delta w_j=\left\{\begin{array}{cc}+1\mathrm{bit},\hfill & \mathrm{if}{t}_j\le t_i\mathrm{and}{t}_i-t_j<t_{\mathrm{pre}}\left(\mathrm{LTP}\right),\hfill \\ -1\mathrm{bit},\hfill & \mathrm{if}{t}_j>t_i\mathrm{and}{t}_j-t_i<t_{\mathrm{post}}\left(\mathrm{LTD}\right),\hfill \end{array}\right.$$

(41)

where $t_{\mathrm{pre}}$ is the Maximum delay between a pre-synaptic spike followed by a post-synaptic spike that induces long-term potentiation (LTP), $t_{\mathrm{post}}$ Maximum delay between a post-synaptic spike followed by a pre-synaptic spike that induces long-term depression (LTD), adaptively increased during learning, $t_i$ and $t_j$ Post-synaptic and pre-synaptic spike times, respectively.

Alternative aSTDP formulations, such as that proposed by Li et al. [127], enhance biological plausibility using perturbation-based approximations of post-synaptic derivatives. These approaches facilitate biologically realistic, local unsupervised learning without global supervision.

2.4.0.7. Multiplicative STDP

Multiplicative STDP [128] incorporates the current synaptic weight into the learning rule, improving biological plausibility and preventing unbounded weight growth or decay. The update dynamics are:

$$\Delta w=A^{+}·x_{\mathrm{pre}}·{\delta }_{\mathrm{post}}-A^{-}·x_{\mathrm{post}}·{\delta }_{\mathrm{pre}},$$

(42)

$${\displaystyle \frac{d{x}_{\mathrm{pre}}}{dt}}=-{\displaystyle \frac{x_{\mathrm{pre}}\left(t\right)}{{\tau }^{+}}}+\delta \left(t\right),$$

(43)

$${\displaystyle \frac{d{x}_{\mathrm{post}}}{dt}}=-{\displaystyle \frac{x_{\mathrm{post}}\left(t\right)}{{\tau }^{-}}}+\delta \left(t\right),$$

(44)

where $A^{+}$ and $A^{-}$ Learning rate parameters for potentiation and depression,$x_{\mathrm{pre}}$ and $x_{\mathrm{post}}$ Pre- and post-synaptic spike traces,${\delta }_{\mathrm{pre}}$ and ${\delta }_{\mathrm{post}}$ Indicators for pre- and post-synaptic spike events,${\tau }^{+}$ and ${\tau }^{-}$ Time constants governing trace decay.

2.4.0.8. Triplet STDP

Triplet STDP [129] extends pair-based STDP by incorporating triplet interactions, such as two pre-synaptic spikes and one post-synaptic spike or vice versa. This extension accounts for the frequency dependence of synaptic changes, where high-frequency spiking produces stronger potentiation or depression due to cumulative intracellular calcium effects. The update rule is:

$$\Delta w=\eta (x_{\mathrm{pre}}-x_{\mathrm{tar}})(w_{\max }-w)u,$$

(45)

where $\eta$ Learning rate, $x_{\mathrm{pre}}$ is the Pre-synaptic trace value, and $x_{\mathrm{tar}}$ is the Target pre-synaptic trace at the time of a post-synaptic spike. $w_{\max }$ Maximum allowable synaptic weight,w Current synaptic weight,u Modulation term controlling dependence on the current weight. By integrating multi-spike interactions, Triplet STDP captures nonlinear dependencies and better reflects the complexity of biological synaptic plasticity.

2.5. Reinforcement Learning in SNNs

Reinforcement Learning modulates plasticity with evaluative feedback, enabling SNNs to learn action policies from rewards—well-suited to closed-loop, real-time settings.

2.5.0.9. R-STDP

R-STDP [52] extends classical STDP by incorporating a reward signal $R\left(t\right)$ that modulates synaptic weight changes according to whether the received feedback is positive or negative. The weight update rule is:

$$\Delta w=R\left(t\right)·\left\{\begin{array}{cc}{A}^{+}exp\left({\displaystyle \frac{-\Delta t}{{\tau }^{+}}}\right),\hfill & \mathrm{if}\Delta t>0,\hfill \\ A^{-}exp\left({\displaystyle \frac{\Delta t}{{\tau }^{-}}}\right),\hfill & \mathrm{if}\Delta t<0,\hfill \end{array}\right.$$

(46)

where $R\left(t\right)$ Reward signal at time t, $\Delta w$ Change in synaptic weight, $A^{+}$ and $A^{-}$ Learning rates for potentiation and depression, respectively,$\Delta t=t_{\mathrm{post}}-t_{\mathrm{pre}}$ Time difference between post-synaptic and pre-synaptic spikes, ${\tau }^{+}$ and ${\tau }^{-}$ Time constants defining the potentiation and depression windows.

By integrating temporal spike relationships with reward feedback, R-STDP enables adaptive learning in environments where the network’s behavior must evolve based on environmental cues, such as maze navigation or game playing, where purely supervised or unsupervised methods may be less effective.

2.5.0.10. ReSuMe (Rewarded Subspace Method)

ReSuMe [130] combines supervised learning principles with reinforcement signals, enabling synaptic weight adjustments that align target outputs with environmental rewards. The update rule is:

$$\Delta w=\eta ·(r-y)·x$$

(47)

where $\Delta w$ Change in synaptic weight, $\eta$ Learning rate, r Reward signal, y Actual neuron output, x Input signal.

By leveraging reinforcement-modulated weight updates, ReSuMe bridges the gap between biologically inspired learning and computational efficiency, making it suitable for tasks requiring both supervised target guidance and environmental adaptation.

2.5.0.11. Eligibility Propagation (e-prop)

e-prop [131] provides a biologically plausible alternative to backpropagation by using eligibility traces to capture the influence of past synaptic activity on current outputs. This approach is particularly effective for tasks involving long temporal dependencies. The eligibility trace is updated according to:

$$E_{t+1}=\lambda E_t+{\displaystyle \frac{\partial y_t}{\partial w}}$$

(48)

where $E_t$ Eligibility trace at time t, $\lambda$ Trace decay factor, $y_t$ Output at time t, w Synaptic weight.

e-prop allows error information to propagate backward through time without storing the entire history of network states, significantly reducing memory requirements while maintaining the ability to learn both synaptic weights and temporal dependencies in parallel.

2.6. Hybrid Learning Paradigms

Hybrid schemes combine global error signals with local spike-based plasticity or reward, aiming for better accuracy–efficiency trade-offs and hardware compatibility.

2.6.0.12. (SSTDP)

SSTDP [132] is a supervised learning rule designed to enhance training efficiency and accuracy in SNNs by uniting backpropagation-based global optimization with the local temporal dynamics of STDP. This hybrid approach bridges the gap between gradient-based learning and biologically plausible spike-based plasticity.

The synaptic weight update is:

$$\Delta w_{ij}^l=-\alpha {\displaystyle \frac{\partial E}{\partial w_{ij}^l}},\mathrm{where}{\displaystyle \frac{\partial E}{\partial w_{ij}^l}}={\displaystyle \frac{\partial E}{\partial t_j^l}}{\displaystyle \frac{\partial t_j^l}{\partial w_{ij}^l}},$$

(49)

where $\alpha$ Learning rate, ${\displaystyle \frac{\partial E}{\partial t_j^l}}$ Error signal propagated back to the firing time of the post-synaptic neuron,${\displaystyle \frac{\partial t_j^l}{\partial w_{ij}^l}}$ Partial derivative of post-synaptic firing time with respect to the synaptic weight.

The derivative ${\displaystyle \frac{\partial t_j^l}{\partial w_{ij}^l}}$ is defined as:

$${\displaystyle \frac{\partial t_j^l}{\partial w_{ij}^l}}=\left\{\begin{array}{cc}{ϵ}_1\left(e^{-{\displaystyle \frac{t_{\mathrm{post}}-t_{\mathrm{pre}}}{\tau }}}-\delta \right){(w_{\max }-w)}^{\mu },\hfill & t_{\mathrm{post}}>t_{\mathrm{pre}},\hfill \\ {ϵ}_2\left(e^{-{\displaystyle \frac{t_{\mathrm{pre}}-t_{\mathrm{post}}}{\tau }}}-\delta \right){(w_{\max }-w)}^{\mu },\hfill & t_{\mathrm{post}}<t_{\mathrm{pre}},\hfill \end{array}\right.$$

(50)

where $t_{\mathrm{pre}}$, $t_{\mathrm{post}}$ Pre- and post-synaptic firing times,${ϵ}_1,{ϵ}_2$ Scaling factors for potentiation and depression, $\tau$ Time constant for exponential decay of STDP effects,$\delta$ Temporal window parameter defining effective STDP update intervals,$w_{\max }$ Maximum allowable synaptic weight,w Current synaptic weight,$\mu$ Weight-dependence factor controlling the influence of $w_{\max }$ on update magnitude.

SSTDP achieves reduced inference latency, lower computational overhead, and improved energy efficiency for neuromorphic deployment by combining global error feedback with local spike-timing-based plasticity.

2.6.0.13. ANN-to-SNN Conversion

ANN-to-SNN conversion reduces the need to train SNNs from scratch by transforming pre-trained ANNs into equivalent spiking architectures [133,134]. This approach maps continuous neuron activations and synaptic weights to spike-based counterparts, minimizing performance degradation while preserving learned representations [31,135,136,137,138].

The general process involves:

• Training a conventional ANN using backpropagation.
• Converting neuron activations to spike rates or spike times.
• Adjusting weights, thresholds, and normalization parameters to match the target SNN framework.

Two main strategies exist:

• Rate-based conversion: Maps ANN activations to SNN firing rates using normalization and threshold adaptation, ensuring the spike rate approximates the ANN output [133,134].
• Temporal coding conversion: Encodes information in spike timing to capture temporal patterns, reducing latency and improving performance on dynamic datasets [89].

Enhancements such as Max Normalization for pooling layers and reset-by-subtraction mechanisms further mitigate performance loss, maintaining high accuracy on datasets like MNIST [139] and CIFAR-10 [140] while improving energy efficiency [137,141]. ANN-to-SNN conversion thus combines the mature training capabilities of ANNs with the deployment advantages of SNNs on neuromorphic hardware.

2.7. Evolution of Supervised Learning in SNNs and Broader Context

Supervised training for SNNs has progressed from early adaptations of backpropagation to methods that explicitly accommodate spike timing and discontinuities. Initial work by [143] applied backprop-like updates with adaptive learning rates, showing viability on small datasets (e.g., Iris) but exposing the difficulty of optimizing through non-differentiable spikes. ReSuMe [144] bridged supervised objectives with STDP-like timing rules, while perceptron-style temporal learners [145] and multi-spike gradient methods [146] improved efficiency and support for richer temporal patterns. Meta-heuristic enhancements—e.g., SpikeProp with PSO [147]—demonstrated accuracy and convergence gains, and biologically inspired approaches such as the tempotron [148] underscored the utility of precise temporal coding.

A major inflection came with surrogate gradients, which replace the intractable spike derivative by smooth approximations, enabling BPTT in deep SNNs [16,149]. Temporal-coding supervision with direct gradient descent [76] aligned learning with event-driven dynamics; SuperSpike [124] combined surrogate gradients with eligibility traces for multilayer training; and SLAYER [120] reassigned errors across space and time to address temporal credit assignment. EventProp [125] later showed exact gradients in continuous-time SNNs via an adjoint approach, avoiding surrogates. Hybrid rules such as SSTDP [132] merged global error signals with local timing windows, while system-level advances—single-spike hybrid input encodings [150], threshold-dependent batch normalization for very deep SNNs [151], and spiking Transformers [152,153]—pushed accuracy–latency–efficiency frontiers on larger benchmarks.

In parallel, unsupervised and Reinforcement Learning paradigms emphasize locality and efficiency: classical and adaptive STDP variants [51,122,126,127] excel at feature discovery but often benefit from auxiliary supervision to reach state-of-the-art accuracy; R-STDP and e-prop [52,131] support closed-loop learning with reduced memory demands. ANN-to-SNN conversion [31,133,134,135,136,137,138] leverages mature ANN training and calibrates rates or spike times for neuromorphic deployment, retaining strong performance on MNIST [139] and CIFAR-10 [140] with improved efficiency [18,141]. Energy-aware objectives and normalization layers (e.g., Spike-Norm, rate normalization) further stabilize training and reduce power [154,155].

Overall, supervised methods deliver the highest accuracy but at greater compute/energy cost; unsupervised and RL approaches favor locality and efficiency with possible trade-offs in scalability; and hybrid plus conversion pipelines increasingly reconcile these aims. Continued progress hinges on tighter integration of temporal coding, normalization, and hardware-aware objectives to realize energy-efficient, high-performance SNNs at scale.

The foregoing background surveyed encoding strategies, neuron models, and learning paradigms that distinguish SNNs from ANNs, highlighting their potential for event-driven efficiency alongside the practical challenges of trainability, robustness, and hardware fit. Building on these principles, we now turn to a controlled empirical study that couples matched SNN/ANN architectures with carefully selected encodings and training procedures. The goal is to quantify accuracy–energy trade-offs under standardized conditions and to extract actionable design rules. Accordingly, the next section details the datasets, model backbones, encoding/neuron selections, training setup, and evaluation metrics that ground our analysis.

3. Materials and Methods

This section details the datasets and preprocessing, model architectures and spiking configurations, training/inference settings, and evaluation metrics used in our comparative study.

3.1. Experimental Design

Objective. Evaluate predictive efficacy (accuracy) and energy efficiency (power consumption) of SNNs versus architecturally matched ANNs on image classification. To enable a fair comparison, we pair each SNN with an ANN using the same backbone and conduct experiments on two standard benchmarks: MNIST and CIFAR-10. SNN variants span diverse combinations of encoding schemes and neuron models within supervised learning, with multiple surrogate gradient functions. Energy per inference is estimated following [156] using KerasSpiking [157].

We develop and train both simple and complex network architectures tailored to the MNIST and CIFAR-10 datasets:

• Fully Connected Network (FCN): Two hidden fully connected layers , and a classifier; applied to MNIST; $\approx 118,288$ trainable parameters.
• Deep Convolutional Network (VGG7): five convolutional layers, two max-pooling layers, one hidden fully connected layer, and a classifier; applied to CIFAR-10; $\approx 548,554$ trainable parameters.

We experiment with a diverse set of neuron models and encoding schemes for each network architecture to generate spike trains from input data. The specifics of encoding schemes and neuron models are detailed in Table 1 and Table 2.

• Neuron Models: The neuron models include IF, LIF, ALIF, CUBA, $\Sigma \Delta$, RF, RF–Iz, EIF, and AdEx.
• Encoding Schemes: The encoding schemes utilized are Direct Coding, Rate Encoding, Temporal TTFS, Sigma-Delta ($\Sigma \Delta$) Encoding, Burst Coding, PoFC, and R-NoM. These schemes transform the continuous pixel values of input images into spike trains over specified time steps.

We use a limited number of time steps for encoding and inference: 4, 6, and 8 for MNIST, and fewer (2, 4, and 6) for CIFAR-10, given its higher complexity and resource demands. Each SNN model is trained and evaluated under various encoding schemes and neuron models, with performance measured by two primary metrics:

• Predictive Efficacy (Accuracy): the proportion of correctly classified instances.
• Energy Efficiency (Power Consumption): theoretical power usage during inference.

The evaluation involves:

• Training models on MNIST and CIFAR-10 with the specified time steps.
• Encoding inputs based on predefined schemes.
• Measuring predictive accuracy and estimating energy consumption.
• Comparing SNN performance against equivalent ANN baselines to assess accuracy and power efficiency trade-offs.

By examining these configurations, we aim to identify SNN setups that balance high accuracy with low energy consumption, offering insights for future research and practical applications.

3.2. Data Collection and Preprocessing

We evaluate on MNIST [139] and CIFAR-10 [140]. MNIST contains 70,000 $28\times 28$ grayscale digit images (60k train/10k test, 10 classes). Images are normalized (mean $=0.5$, std $=0.5$, range $[-1,1]$) and converted to spike trains via multiple encodings with timesteps $T\in \{4,6,8\}$. CIFAR-10 comprises 60,000 $32\times 32$ RGB images (50k train/10k test, 10 classes). Training augmentation uses random crop (padding 4) and horizontal flip; per-channel normalization is mean $[0.4914,0.4822,0.4465]$, std $[0.2023,0.1994,0.2010]$. Normalized images are encoded as spikes with $T\in \{2,4,6\}$. We consider encoding schemes as in Table 1 and neuron models—IF, LIF, ALIF, CUBA, $\Sigma \Delta$, RF, RF–Iz, EIF, AdEx—integrated as in Table 2.

3.3. Implementation Frameworks and Tools

We implemented preprocessing, encodings, and models using Python frameworks tailored to SNNs: Lava [116], SpikingJelly [158], Norse [159], all interoperating with PyTorch. These supported the MNIST FCN and CIFAR-10 VGG7 pipelines.

3.3.0.14. Lava

An Intel neuromorphic framework with modular components for neuron/synapse models, learning rules, and deployment. Lava-DL provides SLAYER 2.0 for efficient surrogate-gradient training; NetX streamlines compilation to neuromorphic targets (e.g., Loihi [42]). It supports rate/temporal coding, ANN→SNN conversion (e.g., Bootstrap), PyTorch integration, and HDF5-based, platform-independent model exchange [116].

3.3.0.15. SpikingJelly

A PyTorch-native SNN library offering IF/LIF neurons, advanced surrogate gradients (e.g., ATan), and multiple encodings (rate, temporal, phase), with CuPy-backed graphics processing unit (GPU) acceleration for scalable training [158].

3.3.0.16. Norse

A lightweight PyTorch extension emphasizing biologically plausible neurons (e.g., AdEx) and efficient simulations, with surrogate-gradient training (e.g., SuperSpike), JIT, and GPU support [159].

3.3.0.17. PyTorch

Used to construct ANN/SNN backbones and training loops (Adam optimizer), ensuring standard DL practices while leveraging the above SNN-specific features.

Together, these tools enabled efficient development, training, and comparison of ANN/SNN variants across neuron models and encoding schemes.

3.4. Neural Network Architectures

In this study, we employed both ANNs and SNNs for the MNIST and CIFAR-10 datasets to enable direct comparisons. The ANN models were developed in PyTorch, with FCN (two fully connected layers of 128 units, 5% dropout, and ReLU) for MNIST, and a VGG7-inspired network (multiple convolutional layers interspersed with batch normalization, ReLU, max-pooling, plus a 1024-unit fully connected layer with 20% dropout) for CIFAR-10. MNIST images were normalized to a mean of 0.5 and a standard deviation of 0.5, whereas CIFAR-10 images underwent data augmentation (random cropping with a 4-pixel padding and horizontal flipping) and dataset-specific normalization. SNN counterparts—implemented in PyTorch with Lava, SpikingJelly, and Norse—used a diverse set of neuron models and encoding schemes (see Section 3.1), retaining equivalent network depths and widths for fair evaluation. Detailed structures appear in Table 4, and Figure 6 and Figure 7.

FCN architecture. This shallow network has 118,288 parameters and processes spike trains from the 784 input pixels of MNIST. It includes two fully connected layers with 128 spiking neurons each (5% dropout), followed by an output layer of 10 neurons corresponding to the digit classes.

VGG7 architecture. This deeper network, totaling 548,554 parameters, is based on the VGG design and handles CIFAR-10 images of $32\times 32$ pixels in RGB. It comprises sequential convolutional layers with varying strides and 64 or 128 filters, interspersed with max-pooling; features are then flattened and passed to a 1024-neuron fully connected layer (20% dropout) before the final 10-neuron output layer.

3.5. Training Configuration and Procedures

All experiments were run on Google Colab with GPU acceleration. ANNs were implemented in PyTorch; SNNs used PyTorch in conjunction with Lava, SpikingJelly, and Norse, employing surrogate gradient BPTT. A consistent training–validation split and identical data loaders were used across all models, encoding schemes, and neuron types to ensure fair, reproducible comparisons on FCN and VGG7.

Hyperparameters—Unless noted otherwise, all models used the Adam optimizer (learning rate $0.001$; weight decay $1\times {10}^{-5}$) with CrossEntropyLoss. FCN models were trained for 100 epochs; VGG7 models for 150 epochs; batch size was 64 in all cases. Dropout was 5% (FCN) and 20% (VGG7), with batch normalization where applicable. ANNs used ReLU activations and PyTorch default weight initialization. SNNs relied on spiking activations with neuron parameters matched across datasets except for threshold: FCN used $V_{\mathrm{th}}=1.25$; VGG7 used $V_{\mathrm{th}}=0.5$. Shared SNN settings were: current decay $0.25$, voltage decay $0.03$, tau gradient $0.03$, scale gradient 3, and refractory decay 1. A consolidated summary appears in Table 5.

Preprocessing and encoding—ANN pipelines applied standard normalization (and augmentation on CIFAR-10). For SNNs, inputs were transformed to spike trains via the evaluated encoding schemes (e.g., rate/temporal/$\Sigma \Delta$) and then processed by the selected neuron models.

Training loop—Each iteration comprised a forward pass, temporal aggregation for SNN outputs (time–averaged logits/readouts), computation of cross-entropy loss, gradient backpropagation (BPTT with surrogates for SNNs; standard backprop for ANNs), and parameter updates with Adam. This unified procedure ensured consistent optimization across ANN and SNN settings.

3.6. Evaluation Metrics

We report two metrics: (i) classification accuracy and (ii) a per-inference energy estimate.

Accuracy—Fraction of correctly classified test samples (single-label, top-1), computed from logits with CrossEntropyLoss. For SNNs, outputs are temporally aggregated (e.g., time-averaged logits or spike counts across T steps) before the final argmax. Identical splits, preprocessing, batch size, and (for SNNs) timestep settings are used across FCN and VGG7 for fair comparisons.

Energy estimate—We follow the KerasSpiking methodology [156,157], which models per-inference energy as the sum of synaptic/MAC operations and neuron/state updates:

$$\begin{array}{cc}\hfill E_S& =E_{o}S,\hfill \end{array}$$

(51)

$$\begin{array}{cc}\hfill E_N& =E_{u}U,\hfill \end{array}$$

(52)

$$\begin{array}{cc}\hfill E_{\mathrm{total}}& =E_S+E_N,\hfill \end{array}$$

(53)

where $E_o$ and $E_u$ are hardware-dependent energy constants, and S and U are operation counts collected during inference. For ANNs, S is the number of MACs and U the number of activation evaluations; for SNNs, S counts synaptic events (spike transmissions) and U counts membrane/state updates across T timesteps. We instantiate $E_o$ and $E_u$ using published hardware values (e.g., GPU constants reported in [156], with typical Titan-class figures $E_o\approx E_u\approx 0.3\mathrm{nJ}$) and report $E_{\mathrm{total}}$ in nJ/inference.

Rationale and limitations of KerasSpiking—KerasSpiking integrates with TensorFlow/Keras and provides high-level abstractions for synaptic and neuronal operations; it pairs measured or literature-based device constants with counted operations to yield energy estimates [157]. Prior work has used this approach to benchmark SNNs against ANNs [156,160,161]. However, its constants reflect generalized device specifications rather than chip-specific, peer-reviewed calibrations; documentation cautions they are rough approximations sensitive to architecture, memory traffic, and data movement. We therefore use KerasSpiking as a transparent, hardware-pluggable proxy—suitable for relative comparisons and for swapping in other platforms (including neuromorphic chips such as Intel Loihi) by substituting the appropriate per-operation constants—rather than as a definitive measure of absolute energy.

3.7. Algorithms

This section enumerates the exact encodings, neuron models, and learning rules used in the experiments. Unless noted, SNNs use surrogate-gradient BPTT; timesteps are $T\in \{4,6,8\}$ for FCN and $T\in \{2,4,6\}$ for VGG7.

3.7.0.18. Encodings used

• Direct input: duplicate the image across T (no spike synthesis).
• Rate (Poisson): intensities $\in [0,1]$ mapped to rates (max 100 Hz); Bernoulli sampling per step.
• TTFS: single-spike latency monotonically mapped from intensity over T bins.
• $\Sigma \Delta$: dead-zone delta encoder with feedback; emit when $\left|\Delta x\right|>\theta$ (here $\theta =0.5$), then reconstruct by $\pm \theta$.
• R–NoM: rank-modulated top-N spiking from sorted intensities; N tuned by validation.
• PoFC: with phase derived from normalized intensity on an $T_{\mathrm{osc}}=T$ cycle.
• Burst: intensity-dependent bursts capped at $B_{max}$ (chosen by validation) within T.

3.7.0.19. Neuron models instantiated

• IF, LIF (SpikingJelly; ATan surrogate).
• ALIF (Lava; dynamic threshold/current adaptation).
• CUBA (Lava,current-based neuron).
• $\Sigma \Delta$ neuron (Lava; event-driven error-based spiking).
• RF and RF–Iz (Lava; resonance/phase sensitivity).
• EIF and AdEx (Norse; exponential onset and adaptive dynamics).

3.7.0.20. Learning rules

• SLAYER surrogate gradient (Lava/SLAYER 2.0).
• SuperSpike surrogate gradient (Norse).
• ATan surrogate function (SpikingJelly).

Algorithm 1:Training/evaluationfor VGG7 on CIFAR-10 and FCN on MNIST with operation counting for energy estimation.

Data: VGG7/CIFAR-10 with $T\in \{2,4,6\}$; FCN/MNIST with $T\in \{4,6,8\}$ Result: Trained models, accuracy/loss, per-inference energy proxy Define encodings $\mathcal{E}$ and neuron models $\mathcal{N}$; set lr, batch size, epochs foreach dataset $D\in \{\mathrm{CIFAR}-10,\mathrm{MNIST}\}$do$\phantom{(}$$\phantom{(}$ set T per D; load & preprocess Dforeach$t\in T$do$\phantom{(}$$\phantom{(}$foreach$e\in \mathcal{E}$do$\phantom{(}$$\phantom{(}$foreach$n\in \mathcal{N}$do$\phantom{(}$$\phantom{(}$ encode data with e over t steps; define architecture with neuron n initialize params; reset energy counters $S\leftarrow 0$, $U\leftarrow 0$forepoch $=1$ toepochsdo$\phantom{(}$$\phantom{(}$foreachbatch $(X,y)$do$\phantom{(}$$\phantom{(}$ forward pass (aggregate over time for SNNs); compute cross-entropy loss backprop; update (Adam) accumulate operation counts: $S+=$ synaptic/MAC ops; $U+=$ neuron/state updatesend$\phantom{(}$ evaluate accuracy/loss on validation/test setend$\phantom{(}$ save model and metrics; compute $E_{\mathrm{total}}=E_{o}S+E_{u}U$end$\phantom{(}$end$\phantom{(}$end$\phantom{(}$ end$\phantom{(}$

Notes: thresholds were dataset-specific ($V_{\mathrm{th}}=1.25$ for FCN/MNIST; $0.5$ for VGG7/CIFAR-10). Shared SNN settings: current decay $0.25$, voltage decay $0.03$, tau gradient $0.03$, scale gradient 3, refractory decay 1. Frameworks: PyTorch (ANNs); PyTorch+SpikingJelly/Lava/Norse (SNNs). Energy is reported via $E_{\mathrm{total}}=E_{o}S+E_{u}U$ using hardware constants cited in the Evaluation Metrics section.

4. Results

In this section, we present the outcomes of our experiments designed to evaluate the predictive performance and energy efficiency of all possible combinations of SNNs in our study compared with their ANN counterparts. We conducted experiments on the MNIST and CIFAR-10 datasets using various network architectures, encoding schemes, and neuron models. The metrics of interest include classification accuracy, energy consumption during inference, and computational efficiency, measured in synaptic operations (SynOps) and event sparsity.

4.1. Performance on MNIST Dataset

We utilized a shallow FCN comprising two dense layers and evaluated it on the MNIST dataset, as described in Section 3.1. Our objective was to assess the predictive performance of different SNN configurations compared with a baseline ANN model. We experimented with various encoding schemes and neuron models to understand their impact on classification accuracy. Additionally, we assessed the models at varying time steps (4, 6, and 8) to evaluate the effect of temporal dynamics.

4.1.1. Classification Accuracy Results

Table 6 summarizes the maximum classification accuracies (%) achieved by different combinations of neuron models, encoding schemes, and time steps. The ANN baseline attained an accuracy of 98.23%. The highest accuracies for each neuron type and encoding are highlighted in bold.

4.1.1.1. Observation

The results demonstrate that SNNs can achieve classification accuracies comparable to traditional ANNs on the MNIST dataset, with the choice of neuron model and encoding scheme significantly impacting performance.

• ($\Sigma \Delta$) neurons achieving highest accuracy $\Sigma \Delta$ neurons achieved the highest accuracy of 98.10% with Rate Encoding at 8 time steps. They maintained strong performance across other encoding schemes, including 98.00% with $\Sigma \Delta$ Encoding at both 8 and 6 time steps. This indicates their effectiveness in precise spike-based computation and suitability for tasks requiring precise timing and efficient encoding.
• Adaptive neuron models showing competitive performance Adaptive neuron models like ALIF and AdEx showed competitive performance, particularly with Direct Coding and Burst Coding. ALIF achieved a maximum accuracy of 97.30% with Rate Encoding at 8 time steps, while AdEx reached 97.50% with Direct Coding at 6 time steps. These models effectively incorporate adaptation mechanisms to capture temporal dynamics, providing a favorable balance between accuracy and computational efficiency.
• Solid performance of simpler neuron models Simpler neuron models like IF and LIF provided solid performance with Rate Encoding and $\Sigma \Delta$ Encoding. IF achieved a maximum accuracy of 97.70% with $\Sigma \Delta$ Encoding at 8 time steps, and LIF reached 97.50% with $\Sigma \Delta$ Encoding at 6 time steps. While their accuracies are slightly below the ANN baseline of 98.23%, these results demonstrate that simpler neuron models can still perform well with appropriate encoding schemes.
• Performance of RF neurons The standard RF neuron exhibited lower accuracies than other models, with a maximum of 97.20% achieved with Direct Coding at 8 time steps. The RF-Iz variant performed better, achieving a maximum accuracy of 97.70% with Rate Encoding and Direct Coding at 8 time steps.
• Robustness of CUBA neurons CUBA neurons demonstrated strong performance with a maximum accuracy of 97.66% using Rate Encoding at 8 time steps and maintained high accuracies across other encoding schemes, such as 97.60% with Direct Coding at 8 time steps. This consistency highlights their robustness across different encoding strategies.
• EIF neurons’ effectiveness EIF neurons showed robust performance with a maximum accuracy of 97.60% using Direct Coding at 6 time steps, indicating their effectiveness in handling direct input representations. Neuron models that perform well across multiple encoding schemes, such as CUBA and EIF, demonstrate robustness and versatility, making them suitable for diverse applications where encoding strategies may vary.
• Effectiveness of specific encoding schemes Encoding schemes like Direct Coding and $\Sigma \Delta$ Encoding emerged as the most effective across multiple neuron types, often resulting in the highest accuracies. Burst Coding also demonstrated strong performance, especially when paired with adaptive neuron models like ALIF and AdEx. Temporal encoding schemes (TTFS, PoFC) showed improvement with increased time steps but generally did not outperform Direct and Sigma-Delta Encoding.
• Effect of time steps on accuracy Increasing the number of time steps generally led to higher accuracies for most neuron models and encoding schemes, especially with configurations utilizing temporal encoding schemes like TTFS and PoFC. However, models like ALIF and $\Sigma \Delta$ neurons maintained high accuracy even with fewer time steps, demonstrating their efficiency in capturing essential temporal dynamics and making them more suitable for practical applications due to reduced computational load and energy consumption.
• Advanced neuron models outperform simpler models Advanced neuron models like $\Sigma \Delta$, ALIF, and AdEx consistently achieved higher accuracy than simpler models like IF and LIF, underscoring the importance of incorporating mechanisms like spike timing precision and adaptation to enhance performance. While some SNN configurations approached the ANN baseline accuracy, others remained slightly below but demonstrated competitive performance. This highlights the potential of SNNs to match traditional ANNs while offering additional benefits like energy efficiency and temporal processing capabilities.
• Variable performance of R-NoM encoding Although not the primary focus, R-NoM encoding showed varying performance across neuron types, with ALIF neurons achieving a maximum of 58.00% and EIF neurons reaching 88.10%. This suggests that while R-NoM can be effective, its performance highly depends on the neuron model used.

4.1.2. Energy Consumption

Table 7 presents the total energy consumption (in joules) for inferring a single sample on the MNIST dataset using various SNN configurations. The energy consumption was measured on a GPU. For comparison, the baseline ANN consumes $1.1355\times {10}^{-3}$ joules per inference. All energy values are approximate and based on GPU inference measurements for a single sample, following the methodology outlined in Section 3.6. The lower energy consumption for each neuron type and encoding are highlighted in bold.

4.1.2.1. Trade-off between accuracy and power consumption

As shown in Table 7, R-NoM consistently provides the lowest energy consumption for most neuron types; however, Table 6 reveals that its classification accuracy often remains notably below the best-performing schemes (e.g., $\Sigma \Delta$, Direct Coding). Conversely, the highest-accuracy models (e.g., $\Sigma \Delta$ neurons with Rate or Sigma-Delta encoding) still operate at energy levels below the ANN baseline ($1.1355\times {10}^{-3}$ J), underscoring SNNs’ potential to outperform traditional ANNs in power efficiency without sacrificing too much accuracy.

• R-NoM: minimal energy, lower accuracy R-NoM encoding reaches remarkably low power usage—e.g., $\mathbf{2}.\mathbf{33240}\times {\mathbf{10}}^{-\mathbf{6}}$ J for IF at 6 time steps—but these same configurations typically yield weaker accuracies (e.g., around 70–75% for IF, much lower for ALIF), indicating a clear cost/benefit trade-off.
• High-accuracy configurations are still energy-efficient Several neuron types (e.g., $\Sigma \Delta$, ALIF, CUBA) achieve accuracies near or above 97–98%, yet their energy consumption remains well under the ANN baseline. For instance, $\Sigma \Delta$ neurons with Rate encoding at 8 time steps yield 98.10% accuracy (Table 6) and consume only $\approx 9.57181\times {10}^{-5}$ J (Table 7), which is $\sim 10\times$ more efficient than the ANN baseline.
• AdEx neurons: best energy with Burst coding, good accuracy with Direct coding AdEx achieves its minimal energy consumption under Burst coding (bolded entries in Table 7) but generally attains its top accuracies (around 97.4–97.5%) via Direct coding (Table 6). This highlights another instance of how the most energy-frugal choice may not align with the highest-accuracy choice—even within the same neuron model.
• Fewer time steps often reduce energy but may lower accuracy Most neuron types consume less power at 4 or 6 time steps than at 8. Yet, especially for temporal encoding schemes (e.g., TTFS, PoFC), dropping below 8 time steps can reduce accuracy by several percentage points. The models with built-in adaptation (ALIF, AdEx) or robust dynamics $\Sigma \Delta$ preserve relatively high accuracies at lower time steps, making them attractive for energy-constrained scenarios.
• Overall SNN advantage Nearly all SNN configurations—even those approaching or exceeding 97–98% accuracy—still require less energy than the ANN baseline. This confirms the viability of SNNs for edge devices or power-sensitive deployments, where small accuracy drops might be acceptable if power savings are substantial.
• Conclusion: balancing encoding and neuron type While R-NoM leads in power savings, it lags in accuracy. Schemes like $\Sigma \Delta$ or Direct coding may offer near-ANN accuracy with only a moderate energy increase over R-NoM—still significantly lower than the ANN baseline. Ultimately, choosing a neuron model and encoding scheme requires balancing accuracy targets against power constraints, as each combination exhibits distinct performance–efficiency trade-offs.

4.2. Performance on CIFAR-10 Dataset

In this subsection, we utilized a VGG7 network architecture as described in Section 3.1 and evaluated it on the CIFAR-10 dataset using various neuron models and encoding schemes to show classification accuracies achieved. We aimed to assess the performance of different SNN configurations compared to a baseline ANN. Additionally, we evaluated the models at varying time steps (2, 4, and 6) to evaluate the effect of temporal dynamics.

4.2.1. Classification Accuracy Results

Table 8 summarizes the maximum classification accuracies (%) achieved by various neuron models, encoding schemes, and time steps on the CIFAR-10 dataset. The baseline ANN attained an accuracy of 83.6%. Note that a reported accuracy of around 10% indicates that the model did not learn effectively at those time steps (as 10% performance is equivalent to random guessing among 10 classes). The highest accuracies for each neuron type and encoding scheme are highlighted in bold for clarity.

4.2.1.1. Observation

The results in Table 8 demonstrate that SNNs can approach traditional ANNs’ classification accuracy on complex datasets like CIFAR-10. The choice of neuron model, encoding scheme, and number of time steps significantly impacts performance.

• $\Sigma \Delta$ neurons achieving highest accuracy The $\Sigma \Delta$ neurons achieved the highest SNN accuracy of 83.00% with Direct coding at 2 time steps, closely matching the ANN baseline of 83.60%. This performance at a low number of time steps indicates the effectiveness of $\Sigma \Delta$ neurons in capturing complex patterns with efficient temporal dynamics. Additionally, TTFS encoding with $\Sigma \Delta$ neurons yielded accuracies up to 72.50%, showcasing their versatility across encoding schemes.
• Solid performance of IF and LIF neurons IF and LIF neurons showed solid performance, with maximum accuracies of 74.50% for both using Direct coding at 4 time steps. These results highlight that even simpler neuron models can perform well on complex datasets when paired with effective encoding schemes. IF and LIF improved slightly with increased time steps, suggesting temporal dynamics contribute positively to their classification capabilities.
• Moderate performance of ALIF neurons The adaptive LIF (ALIF) model achieved a maximum accuracy of 51.00% with Rate encoding at 6 time steps. The lower accuracies compared to other neuron models suggest ALIF may require further tuning or more sophisticated encoding to fully leverage adaptation on CIFAR-10.
• Performance of CUBA neurons CUBA neurons reached a maximum of 50.00% with TTFS at 4 time steps. While above chance, this indicates CUBA may not capture features needed for higher accuracy on CIFAR-10 without additional optimization.
• Limited performance of RF and RF–Iz neurons RF and its Izhikevich variant (RF-Iz) were limited, peaking at 47.00% and 45.00%, respectively—suggesting resonate-and-fire dynamics are less effective for CIFAR-10 image classification.
• Consistent performance of EIF and AdEx neurons EIF reached 70.00% with Direct coding at 2 steps, and AdEx achieved 70.10% with Direct coding at 6 steps. Exponential mechanisms and adaptation appear to aid the processing of complex patterns.
• Effectiveness of Direct coding and TTFS encoding Across neuron models, Direct coding emerged as the most effective scheme, consistently yielding higher accuracies—likely due to conveying rich information without heavy reliance on temporal dynamics. TTFS also performed well, particularly with $\Sigma \Delta$ neurons, indicating precise spike timing benefits certain configurations.
• Impact of time steps Time steps influenced performance, though less than on MNIST. Some models, such as $\Sigma \Delta$ , achieved high accuracies even at low time steps, highlighting efficiency. Increasing steps generally gave modest gains, indicating a trade-off between temporal resolution and computational load.
• Comparison with ANN baseline While several SNN configurations approached the ANN baseline, many still lagged. Careful selection of neuron model and encoding is crucial for high performance on complex datasets. In particular, $\Sigma \Delta$ with Direct coding shows strong promise—high accuracy with few time steps, enabling potential energy and computational savings.

4.2.2. Energy Consumption on CIFAR-10 Dataset

This subsection reports approximate GPU-based per-sample inference energy for the CIFAR-10 experiments (Table 9). The ANN baseline consumes $1.1355\times {10}^{-3}$ J per inference and is used for reference. Entries shown as 0 J indicate configurations that were not evaluated at that time-step (e.g., due to ineffective learning), hence no measurement was taken.

4.2.2.1. Observation

• Overall Energy Trends. In general, SNNs consume significantly less energy than the baseline ANN across neuron types and encoding schemes. Models achieving higher classification accuracy—such as those using Direct Coding or certain temporal encodings—tend to consume more energy relative to simpler encodings. However, even these higher-energy SNN configurations remain below the $1.1355\times {10}^{-3}$ J reference set by the ANN. This underscores SNNs’ potential for energy savings in complex tasks such as CIFAR-10 classification.
• Influence of Time Steps. A clear pattern emerges whereby increasing the number of time steps typically elevates energy consumption. For example, IF neurons see their energy usage grow from $3.94852\times {10}^{-4}$ J at 2 time steps to $1.08961\times {10}^{-3}$ J at 6 time steps under Rate Encoding. Although more time steps can improve classification accuracy in certain cases, it raises the energy cost. Consequently, applications requiring real-time performance or low power draw may benefit from using fewer time steps, provided accuracy remains acceptable.
• Neuron Models and Encoding Schemes. While simpler neuron models (e.g., IF, LIF) generally show moderate energy consumption, their performance depends heavily on the chosen encoding. For instance, IF neurons with Rate Encoding at 2 time steps require as little as $3.94852\times {10}^{-4}$ J, whereas LIF neurons with certain temporal encodings increase overall energy usage but often achieve better accuracy. More advanced neuron models, such as ALIF or AdEx, sometimes yield improved accuracy but do not always minimize energy. Their adaptive dynamics can reduce spiking under certain conditions, yet these benefits vary with the specific encoding and time-step setting.
• Balancing Accuracy and Efficiency. Although some encoding schemes report lower energy consumption, they may simultaneously yield substantially lower accuracy. Hence, choosing an optimal combination of neuron model, encoding scheme, and time steps is essential for achieving an acceptable balance of performance and efficiency. Overall, the results confirm that SNNs maintain lower energy consumption compared to a conventional ANN, even when configured for higher accuracy. This balance between accuracy and energy use makes SNNs appealing for edge devices and other power-sensitive environments.

4.3. Effect of Thresholding and Encoding Schemes on Model Performance and Energy Consumption

In this subsection, we investigate how varying the neuronal firing threshold and different encoding schemes affect the classification accuracy and energy consumption of SNNs, with a focus on the EIF neuron model applied to the CIFAR-10 dataset. The experimental setup includes the EIF neuron model, the CIFAR-10 dataset, evaluation at time steps of 2, 4, and 6, testing of threshold values at 0.1, 0.5, and 0.75, and the application of various encoding schemes such as Rate Encoding, TTFS, $\Sigma \Delta$, Direct Coding, Burst Coding, PoFC, and R-NoM.

4.3.0.2. Impact of threshold values on classification accuracy

The results presented in Table 10 demonstrate that the neuronal firing threshold across different encoding schemes strongly influences classification accuracy. Lower thresholds, such as 0.1, tend to facilitate easier spiking and thus higher accuracy in schemes like Rate Encoding and Direct Coding, where performance noticeably declines as the threshold increases. In contrast, temporal TTFS encoding achieves optimal accuracy at an intermediate threshold of 0.5, which appears to balance the timing of the first spike effectively. $\Sigma \Delta$ encoding similarly benefits from lower thresholds, particularly at longer time steps, underscoring its sensitivity to threshold adjustments. Meanwhile, Burst Coding and PoFC exhibit variable performance across thresholds and time steps, indicating that their optimal operation requires careful tuning of threshold values. Finally, R-NoM consistently produces lower accuracy levels, with only marginal improvements at higher thresholds, suggesting that threshold variations limit its capability to capture complex patterns in the CIFAR-10 dataset.

4.3.0.3. Impact of threshold values on energy consumption

The results in Table 11 demonstrate that energy consumption generally decreases as the threshold increases from 0.1 to 0.75. This trend is observed across most encoding schemes, reflecting that higher thresholds reduce the number of spikes generated during inference and thereby lower the computational load. For instance, both Rate Encoding and TTFS encoding exhibit significant energy reductions at elevated thresholds, while Direct coding shows a dramatic drop in energy usage at a threshold of 0.75, albeit with a corresponding loss in classification accuracy. $\Sigma \Delta$ encoding also benefits from increased thresholds, though the reduction in energy consumption is less pronounced, likely due to its inherent reliance on capturing subtle differences in the input. These observations underscore the delicate balance between minimizing energy consumption and maintaining performance, as the choice of threshold directly influences the trade-off between energy efficiency and inference accuracy.

4.3.0.4. Trade-off between accuracy and energy consumption

The analysis of results in Table 10 and Table 11 reveals that threshold values play a critical role in balancing classification accuracy and energy consumption in SNNs. Lower thresholds lead to increased neural activity and higher accuracy, but they also incur greater energy consumption due to the higher spike rate. Conversely, higher thresholds reduce energy usage by decreasing the number of spikes, although this may impair the model’s ability to learn complex patterns. An intermediate threshold, such as 0.5, often strikes an effective balance between performance and efficiency, as evidenced by encoding schemes such as TTFS and Direct coding. These findings underscore the importance of optimal threshold selection, as it directly influences both the network’s energy efficiency and inference capability. Furthermore, the impact of threshold adjustments varies across different encoding schemes, highlighting the importance of careful hyperparameter tuning for maximizing the benefits of the EIF neuron model on complex datasets such as CIFAR-10, while maintaining competitive accuracy.

4.3.0.5. Comparison with related studies

Recent studies highlight complementary approaches and findings. Takaghaj and Sampson (2024) introduced Rouser, a method that adaptively learns neuronal thresholds during SNN training, effectively mitigating “dead neuron” issues and significantly enhancing accuracy and training convergence efficiency across neuromorphic datasets [162]. Their adaptive mechanism dynamically adjusts thresholds, aligning closely with our observations on the impacts of thresholds.

Similarly, Sengupta et al. [155] emphasized the critical role of threshold balancing when converting deep convolutional architectures (VGG, ResNet) into spiking formats, preserving accuracy and reducing hardware overhead due to sparse neural activity.

Additionally, Diehl et al. [37] investigated weight and threshold balancing techniques in SNNs, showing that optimal threshold tuning significantly minimizes performance loss during ANN-to-SNN conversion. This supports our findings on threshold-related trade-offs.

4.4. Comparative Analysis and Discussion

Overall trade-off. Across all settings, there is a precise accuracy–energy tension: configurations that maximize accuracy typically incur higher per-inference energy and SynOps, while the most energy-frugal encodings reduce accuracy.

FCN (MNIST). From Table 6, $\Sigma \Delta$ neurons with Rate encoding at 8 steps reached 98.10, very close to the ANN baseline (98.23). However, Table 7 shows this setup consumes more energy than simpler IF/LIF models using energy-efficient encodings (Burst or R-NoM). ALIF and AdEx also performed competitively, and Direct and $\Sigma \Delta$ encodings were consistently strong across neuron types. Increasing time steps generally improved accuracy (especially for temporal encodings such as TTFS and PoFC) but raised energy.

VGG7 (CIFAR-10 ). From Table 8, $\Sigma \Delta$ neurons with Direct coding achieved 83.00 at 2 steps, close to the ANN baseline (83.60), indicating effective temporal dynamics at low T. This configuration, however, consumed more energy than several lower-accuracy SNNs (Table 9). IF/LIF with Direct coding peaked around 74.5, while ALIF and CUBA underperformed without further tuning. Direct coding was the most effective scheme overall on CIFAR-10; TTFS paired well with $\Sigma \Delta$.

Thresholds and time steps. Lower thresholds increased spiking, often boosting accuracy but raising energy; higher thresholds reduced energy at the cost of learning complex patterns. Intermediate thresholds yielded the best trade-offs, particularly for Direct and TTFS encodings. More time steps improved accuracy for many models yet increased energy, suggesting task-dependent selection of T.

Energy. Across datasets, per-inference energy is driven mainly by encoding sparsity and the number of time steps. On MNIST, almost all SNN configurations consume less energy than the ANN baseline ($1.1355\times {10}^{-3}$ J); R-NoM yields the lowest values (e.g., IF at $T=6$: $2.33\times {10}^{-6}$ J; LIF at $T=4$: $2.44\times {10}^{-6}$ J). Higher-accuracy settings—such as $\Sigma \Delta$ neurons with Rate or $\Sigma \Delta$ encoding—cost more than R-NoM/Burst but remain well below the ANN reference on MNIST. On CIFAR-10, energy generally rises with T and denser encodings; several high-T cases exceed the ANN baseline, whereas low-T Direct or Rate configurations often stay below it. In practice, fewer time steps plus sparse encodings (R-NoM or Burst) minimize energy, while $\Sigma \Delta$/Direct improves accuracy at a moderate energy premium.

Application guidance.

• Accuracy-critical tasks: prefer $\Sigma \Delta$ neurons with Direct (CIFAR-10) or Rate/$\Sigma \Delta$ encodings (MNIST). Expect higher energy than ultra-sparse choices, but still below ANN.
• Energy-constrained/edge settings: choose IF/LIF with Burst or R-NoM and fewer time steps; tune thresholds to meet power budgets, accepting some accuracy loss.

Neuromorphic potential. Event-driven accelerators can exploit data-dependent spiking, temporal asynchrony, and local memory access to translate the observed per-inference energy reductions into larger system-level savings, reinforcing SNNs’ suitability for edge and real-time deployments.

Positioning in the literature. These findings align with prior reports on the accuracy–efficiency trade-off and conversion/training challenges on complex vision tasks [134,154,155]. Our results highlight the promise of $\Sigma \Delta$ neurons for high accuracy, while confirming the energy advantages of simpler neurons with sparse encodings.

Key takeaways. (i) $\Sigma \Delta$ with appropriate encoding approaches ANN-level accuracy on MNIST and narrows the gap on CIFAR-10; (ii) R-NoM/Burst minimize energy but reduce accuracy; (iii) thresholds and time steps are primary knobs for balancing performance and power; (iv) Direct and $\Sigma \Delta$ encodings are broadly effective, whereas temporal encodings benefit from higher T and careful tuning.

5. Conclusions and Outlook

This work paired a comprehensive review with a standardized, hands-on benchmarking of SNNs against architecturally matched ANNs on MNIST (shallow FCN) and CIFAR-10 (VGG7). We varied neuron models, input encodings, thresholds, and time steps, and we reported accuracy alongside a transparent per-inference energy proxy. Three consistent conclusions emerge.

5.0.0.6. 1) Accuracy–energy trade-off is real but tunable.

Across both datasets, higher accuracy typically coincided with higher energy, yet many SNN settings still undercut the ANN energy baseline:

• MNIST (FCN):$\Sigma \Delta$ neurons with rate/$\Sigma \Delta$ encodings reached up to 98.1% (vs. 98.23% ANN) while remaining energetically below the ANN proxy. ALIF/AdEx and even LIF/IF also performed strongly when paired with effective encodings.
• CIFAR-10 (VGG7):$\Sigma \Delta$ neurons with Direct input achieved 83.0% at 2 time steps (vs. 83.6% ANN), indicating that well-chosen neuron/encoding pairs can approach ANN performance even on a deeper, more complex task.
• Encodings that are extremely frugal (e.g., R–NoM) minimized the energy proxy but incurred the largest accuracy drops; conversely, settings that closed the accuracy gap (e.g., $\Sigma \Delta$ with Direct/Rate) used more energy—but still generally below the ANN reference on our GPU-targeted model.

5.0.0.7. 2) Practical configuration rules.

The most useful knobs in practice were the encoding, the neuron model, the threshold, and the number of time steps T:

• Accuracy-critical: Prefer $\Sigma \Delta$ neurons with Direct (CIFAR-10) or with Rate/$\Sigma \Delta$ (MNIST); AdEx/EIF are solid fallbacks. Keep T as low as possible once the accuracy target is met.
• Energy-constrained: Favor simpler neurons (IF/LIF) with Burst or R–NoM encoding and small T; expect some accuracy loss. Intermediate thresholds typically balance activity with correctness better than very low or very high ones.
• General tip: Tune thresholds jointly with the encoding; moderate T and carefully chosen thresholds often deliver the best accuracy-per-joule.

5.0.0.8. 3) Neuromorphic potential.

Event-driven accelerators can exploit data-dependent spiking, temporal asynchrony, and local memory access to translate our per-inference energy reductions into larger system-level savings, reinforcing SNNs’ suitability for edge and real-time deployments.

5.0.0.9. Limitations.

Energy was estimated via an operation-based GPU proxy (with published constants), not direct power measurements; absolute values will differ across chips and memory systems. We focused on two datasets and representative backbones; hyperparameter sweeps were bounded, and we did not deploy on neuromorphic hardware in this study.

5.0.0.10. Future work.

Promising directions include (i) hardware-in-the-loop metering on neuromorphic and embedded GPUs/NPUs; (ii) tighter algorithm–hardware co-design of thresholds, time windows, and mixed-precision synapses; (iii) dynamic T and threshold schedules during inference; (iv) architecture/encoding search and spiking-normalization layers for very deep nets; (v) broader tasks (event cameras, audio, biosignals) and on-device learning. These steps should further close the accuracy gap where it persists while improving realized energy at the system level.

5.0.0.11. Takeaway.

With careful choices of neuron model, encoding, threshold, and time steps, SNNs can consistently approach ANN accuracy on both shallow and deep settings while offering meaningful energy advantages. The recipe is straightforward: pick the encoding and neuron to match the task’s accuracy target, set T to the minimum that meets it, and calibrate thresholds for energy-aware operation—then map to event-driven hardware to compound the gains.