betaFeedback

WorksComputer Science

SuperNeuroMAT: An Efficient Matrix-based Simulator for Spiking Neural Networks

Abstract

Spiking neural networks (SNNs) offer a promising pathway to energy-efficient AI and brain-inspired computing. However, their widespread adoption is hindered by a lack of fast, accessible, and versatile simulation frameworks. In this paper, we introduce SuperNeuroMAT, an open-source, scalable, and highly efficient Python-based SNN simulator. We devise a novel matrix-based approach to model the leaky integrate-and-fire (LIF) neuron dynamics and natively support dense and sparse execution modes. This enables fast simulation of approximately 10,000 neurons in dense mode and 100,000 neurons in sparse mode on standard laptops and desktops without requiring specialized hardware. We demonstrate that SuperNeuroMAT consistently outperforms four established SNN simulators—NEST, Brian2, BindsNET, and snnTorch—on two performance metrics (execution speed and peak resident memory) and across various network sizes and connection probabilities. Furthermore, we demonstrate SuperNeuroMAT's applicability across a diverse set of problems. SuperNeuroMAT can efficiently handle conventional machine learning benchmarks such as the Digits and citation network datasets as well as neuromorphic event-based vision tasks such as N-CARS and ASL-DVS. Moreover, it can be extended beyond machine learning workloads and facilitate general-purpose workloads. We validated this by implementing the neuromorphic shortest path algorithm and two arithmetic primitives (addition and multiplication). SuperNeuroMAT can be installed via the Python Package Index (PyPI), thereby lowering the barrier to entry into the field of neuromorphic computing and accelerating the broader development of neuromorphic algorithms.

Introduction

Neuromorphic computing is a brain-inspired computing paradigm [1]. It performs computations by emulating mechanisms of the human brain [2]. Just like the human brain, which is known to consume as little as 20 W of power, neuromorphic computers are known to be extremely energy efficient. Some neuromorphic platforms, such as Intel Loihi 2, IBM North Pole, and NeuroCoreX, are known to consume thousands of times less energy than conventional hardware such as CPUs or GPUs [3, 4, 6, 7] [5]. The energy efficiency of neuromorphic computing stems from its event-driven operation, collocated processing and memory, and intrinsic parallelism [1]. Although neuromorphic computing is primarily explored on machine learning (ML) tasks, it is Turing-complete: that is, it is capable of executing all general-purpose computations that a CPU or a GPU can execute [8, 9]. Some examples of ML applications of neuromorphic computing are graph learning [10, 11], autonomous racing [12], data filtering in high-energy physics [13], and classifying node failures on supercomputers [14]. Some examples of the non-ML applications of neuromorphic computing are graph algorithms [15, 16, 17], general-purpose computing [18, 19, 20, 21], epidemiological simulations [22], and other scientific applications [23]. The primary ML model that runs on neuromorphic computers is called the spiking neural network (SNN) [24, 25]. An SNN is a type of neural network that more closely mimics the behavior and communication of the biological brain as compared to conventional artificial neural networks (ANNs). SNNs are considered the third generation of neural networks and are the architectural foundation for neuromorphic computing.

SNN simulators play a vital role in designing state-of-the-art SNN models. They are used to simulate computational neuroscience workloads, train SNNs off of the neuromorphic chip, co-design neuromorphic hardware through their integration with hardware simulators, and interface with domain-specific simulators (e.g., for self-driving car simulators). In the SNN literature, we observe two types of SNN simulators. On the one hand are simulators catered to neuroscience workloads such as Brian2, NEST (Neural Simulation Tool), FUGU, and STACS (Simulation Tool for Asynchronous Cortical Streams) [26, 27, 28, 29, 30]. These simulators try to solve systems of ordinary differential equations (ODEs) that govern the dynamics of biological neuron models such as the leaky integrate-and-fire (LIF) neuron model, the Izhikevich neuron model, and the Hodgkin–Huxley neuron model. Some, such as NEST, leverage discrete event simulation techniques to simulate SNNs. In practice, these simulators take a long time to simulate the SNN operations. Although they work well on small problems, they soon become intractable as the number of neurons or synapses in the simulation increases.

The other category of SNN simulators is those catered to ML workloads such as BindsNET, snnTorch, and spikingjelly [31, 32, 33]. These simulators are designed for speed, but they lack certain neuron or synapse parameters—for instance, synaptic delay. Moreover, neither the neuroscience-based nor the ML-based simulators are well suited for general-purpose computing tasks such as running graph algorithms, performing arithmetic operations for processing data, etc. Therefore, there is a need for a simulator that supports the desired functionality for neuroscience workloads and the speed required for ML workloads. Furthermore, such a simulator would have to be user-friendly, Python-based, scalable, open-source, and support a wide range of workloads, from neuroscience to ML [34].

In the work presented in this paper, we developed a fast and scalable SNN simulator called SuperNeuroMAT by leveraging a novel matrix-based approach to model the SNN computations. SuperNeuroMAT is designed for and meant to be used on personal computers such as laptops, desktops, and small-scale CPU clusters. SuperNeuroMAT can accelerate the off-chip training of SNNs on compute clusters with CPUs. It is lightweight, user friendly, Python-based, and open-source, and it can be installed using the pip command as it is available on the Python Package Installer (PyPI). The GitHub repository for SuperNeuroMAT is at the following link: https://github.com/ORNL/superneuromat.

SuperNeuroMAT currently supports LIF neurons with four parameters: threshold, leak, reset state, and refractory period. Synapses in SuperNeuroMAT have weights, delays, and built-in learning based on the spike-timing-dependent plasticity (STDP) mechanism. SuperNeuroMAT supports both dense and sparse execution modes, and these modes can be selected automatically. SuperNeuroMAT further supports single precision (32-bit) and double precision (64-bit) floating-point operations on CPUs. The remainder of this paper presents the related work (§ 2), the notation (§ 3), the matrix-based approach used in SuperNeuroMAT (§ 5), scalability and benchmarking results (§ 6), and finally, the conclusion and future work (§ 7).

Related Work

Simulators for SNNs or neuromorphic computing can largely be divided into two categories. The first category is those that are catered to neuroscience workloads, and the second is those catered towards deep learning workloads. Simulators such as NEST and Brian2 have defined the state-of-the-art in computational neuroscience [26, 27]. NEST has a Python frontend and a C++ backend, and it uses the Message Passing Interface (MPI) and is engineered for high-performance scalability. It aims to facilitate the simulation of large-scale cortical structures on distributed high-performance computing (HPC) platforms. Brian2 provides users modeling flexibility through an equation-based domain-specific language. It employs runtime code generation to translate mathematical differential equations into optimized C++ or Cython; thus, it enables the rapid prototyping of non-standard neural dynamics, though execution is limited to a single node.

FrameworkComputational ParadigmLearning Mechanism SupportedParallelization Approach
Brian2 [26]Equation-based, domain-specific languageUser-defined differential equationsSingle-Node Execution
NEST [27]Discrete event simulationHebbian, plasticity rulesDistributed MPI
STACS [30]Discrete event simulationSynaptic scalingCharm++ Parallel Programming Framework
Fugu [28]Computation graphsLogic compositionSingle-Node Execution
snnTorch [32]Frame-based, tensor-basedSurrogate gradient, back-propagation through timeGPU Acceleration
SpikingJelly [33]Frame-based, tensor-basedANN-to-SNN, backpropagation through timeCUDA/Triton Kernels
BindsNET [31]Bio-inspired machine learningSTDP, reinforcement learningPyTorch Autograd

Table 1. Summary of simulators for SNN and neuromorphic computing

Fugu introduces a high-level algorithmic framework that represents SNNs as computational graphs [28]. This lets researchers compose complex spiking architectures without low-level manual tuning of synapse or neuron parameters. This abstraction layer is paired with scalable backends like STACS, which employs an asynchronous, event-driven execution model to manage high-dimensional neural communication [29]. Because these tools decouple the algorithmic specification from the execution engine, they provide a structured pathway for deploying robust spiking computations across heterogeneous computing resources, ranging from conventional CPU clusters to emerging neuromorphic hardware.

The recent convergence of SNNs and deep learning has necessitated the development of frameworks that interface with automatic differentiation engines and leverage variants of the backpropagation algorithm for training SNNs. snnTorch and SpikingJelly are prominent PyTorch-based libraries that treat spiking neurons as recurrent primitives [32, 33]. These frameworks facilitate the training of deep SNNs via backpropagation through time (BPTT) using surrogate gradient descent to overcome the non-differentiability of the Heaviside step function (i.e., the spike function). Whereas snnTorch focuses on ease of integration with standard deep learning workflows, SpikingJelly provides a high-performance suite that features specialized CUDA kernels to minimize the overhead of temporal state updates. Complementing these is BindsNET, which is specifically built for biologically inspired learning paradigms, such as STDP and reinforcement learning, and provides a modular environment for unsupervised feature extraction [31].

Notation

We use B\mathbb{B}, N\mathbb{N}, W\mathbb{W}, and R\mathbb{R} to denote the sets of binary numbers ({0,1}\{0,1\}), natural numbers, whole numbers, and real numbers, respectively. In neuroscience, the LIF neuron is described using the notation presented in Table 2. In describing the mathematical and computational approaches pertaining to the neurons, synapses, and STDP parameters, we use the notation described in Table 3, Table 4, and Table 5 respectively. Throughout this paper, we use parentheses to denote functions of continuous variables (e.g., I(t)I(t) in Table 2) and rectangular braces to denote functions of discrete variables (e.g., vi[t]v_i[t] in Table 3 and Table 4). Note that we use tt to denote time in both continuous and discrete domains. Whether tt is continuous time or a discrete time step should be evident from the context of the equation; for instance, if an equation uses parentheses, then tt in that equation is continuous time.

SymbolDescription
ttTime; continuous functions of time are denoted using parentheses, (…)(\ldots)
V(t)V(t)Membrane potential of the LIF neuron at time tt
VtV_tNeuron threshold of the LIF neuron
V0V_0Reset membrane potential of the LIF neuron, typically around −70-70 mV
τm\tau_mTime constant of the LIF neuron, dictates how fast the membrane potential decays back to the reset state; larger means a slower leak
RRMembrane resistance of the LIF neuron
I(t)I(t)Input current to the LIF neuron at time tt
treft_{\mathrm{ref}}Refractory period of the LIF neuron

Table 2. Standard notation used to describe the LIF neuron model in the literature.

SymbolDescription
ttDiscretized time or time step; discrete functions of time are denoted using square brackets […][\ldots]
NNNumber of LIF neurons in the simulation
1,2,…,N1, 2, \ldots, NNeuron indices of all the neurons in the simulation
vi[t]v_i[t]Membrane potential of LIF neuron ii at time step tt; vi[t]∈Rv_i[t] \in\mathbb{R}
v[t]\mathbf{v}[t]Vector of membrane potentials of all the neurons in the simulation at time step tt; v∈RN\mathbf{v} \in\mathbb{R}^{N}
νi[t]\nu_i[t]Threshold of neuron ii at time step tt; νi[t]∈R\nu_i[t] \in\mathbb{R}
ν[t]\boldsymbol{\nu}[t]Vector of thresholds of all neurons at time step tt; ν∈RN\boldsymbol{\nu} \in\mathbb{R}^{N}
λi\lambda_iLeak of neuron ii; SuperNeuroMAT supports a constant leak at each time step; λi∈R\lambda_i \in\mathbb{R}, λi≥0\lambda_i \ge0
λ\boldsymbol{\lambda}Vector of leaks of all the neurons; λ∈RN\boldsymbol{\lambda} \in\mathbb{R}^{N}
ρi\rho_iReset state of neuron ii; ρi∈R\rho_i \in\mathbb{R}
ρ\boldsymbol{\rho}Vector of reset states of all neurons; ρ∈RN\boldsymbol{\rho} \in\mathbb{R}^{N}
τi\tau_iRefractory period of neuron ii; τi∈W\tau_i \in\mathbb{W}
τ\boldsymbol{\tau}Vector of refractory periods of all neurons; τ∈WN\boldsymbol{\tau} \in\mathbb{W}^{N}
τi′[t]\tau_i^{\prime}[t]Refractory period of neuron ii remaining at time step tt; τi′∈W\tau_i^{\prime} \in\mathbb{W}
τ′[t]\boldsymbol{\tau}^{\prime}[t]Vector of refractory periods of all neurons remaining at time step tt; τ′[t]∈WN\boldsymbol{\tau}^{\prime}[t] \in\mathbb{W}^{N}
xi[t]x_i[t]Input spike of neuron ii at time step tt; xi[t]∈Rx_i[t] \in\mathbb{R}; input spikes are given by the user and can have value
x[t]\mathbf{x}[t]Vector of input spikes of all neurons at time step tt; x[t]∈RN\mathbf{x}[t] \in\mathbb{R}^{N}
si[t]s_i[t]Spike of neuron ii at time step tt; si[t]∈Bs_i[t] \in\mathbb{B}
s[t]\mathbf{s}[t]Vector of spikes of all neurons in the simulation at time step tt; s∈BN\mathbf{s} \in\mathbb{B}^{N}

Table 3. Notation used to describe the mathematical and computational approaches for neurons in SuperNeuroMAT.

SymbolDescription
SSNumber of synapses in the SNN
(i,j)(i,j)Index of synapse going from neuron ii to neuron jj; i,j∈{1,2,…,N}i,j \in\{1,2,\ldots,N\}
ωi,j[t]\omega_{i,j}[t]Synaptic weight of the synapse (i,j)(i,j) at time tt; ωi,j[t]∈R\omega_{i,j}[t] \in\mathbb{R}
W[t]W[t]Synaptic weight matrix at time step tt, where the value at ithi^{\mathrm{th}} row and jthj^{\mathrm{th}} column represents ωij[t]\omega_{ij}[t]; W∈RN×NW \in\mathbb{R}^{N \times N}
δi,j\delta_{i,j}Synaptic delay of synapse (i,j)(i,j); δi,j∈N\delta_{i,j} \in\mathbb{N}
DDMatrix of synaptic delays, where the value at ithi^{\mathrm{th}} row and jthj^{\mathrm{th}} column represents δij[t]\delta_{ij}[t]; W∈NN×NW \in\mathbb{N}^{N \times N}
ϵi,j\epsilon_{i,j}A binary flag denoting whether STDP is enabled (1) or not enabled (0) for synapse (i,j)(i,j); ϵ∈B\epsilon\in\mathbb{B}
EEMatrix of binary flags denoting whether STDP is enabled for all synapses; E∈BN×NE \in\mathbb{B}^{N \times N}

Table 4. Notation used to describe the mathematical and computational approaches for synapses in SuperNeuroMAT.

SymbolDescription
TST_SNumber of time steps over which STDP operations occur in the SNN; TS∈NT_S \in\mathbb{N}
α+\alpha^{+}A vector of coefficients for positive weight updates; the length of α+\alpha^{+} is TST_S; αi+∈R ∀i∈{1,2,…,TS}\alpha_i^{+} \in\mathbb{R}\ \forall i \in\{1,2,\ldots,T_S\}; α1+≥α2+≥…≥αTS+≥0\alpha_1^{+} \ge\alpha_2^{+} \ge\ldots\ge\alpha_{T_S}^{+} \ge0
α−\alpha^{-}A vector of coefficients for negative weight updates; the length of α−\alpha^{-} is TST_S; αi−∈R ∀i∈{1,2,…,TS}\alpha_i^{-} \in\mathbb{R}\ \forall i \in\{1,2,\ldots,T_S\}; α1−≤α2−≤…≤αTS−≤0\alpha_1^{-} \le\alpha_2^{-} \le\ldots\le\alpha_{T_S}^{-} \le0

Table 5. Notation used to describe the mathematical and computational approaches for STDP operations in SuperNeuroMAT.

The Leaky Integrate-and-Fire Neuron Model

The LIF model is one of the most widely used theoretical models to model biological neurons in computational neuroscience [35, 36]. It represents an abstraction of a biological neuron and focuses on the timing of action potentials (spikes) rather than the complex biophysics of the neuron’s ion channels. The dynamics of the LIF neuron can be modeled using a simple resistor–capacitor (RC) electrical circuit. The LIF dynamics can be broken down into three stages as follows:

  1. Leak: The accumulated charge in the membrane potential of the neuron gradually leaks away and returns to its baseline resting state. This happens because the cell membrane of the neuron is not perfectly sealed; it has ion channels that allow charge to slowly leak over time.

  1. Integrate: As synaptic inputs arrive from other neurons into the neuron under consideration, they deposit a charge into the neuron. This charge accumulates and increases the neuron’s membrane potential.

  1. Fire: If the membrane potential continues to rise and crosses a specific threshold, then the neuron ‘fires,’ sending a spike along all of its outgoing synapses.

The words ‘fire’ and ‘spike’ are used interchangeably in the literature. In this paper, ‘firing’ refers to the event that occurs when a neuron’s membrane potential reaches the threshold, whereas ‘spike’ refers to the resulting output signal. The dynamics of the LIF neuron before it fires are governed by the following linear differential equation:

τmdV(t)dt=−(V(t)−V0)+RI(t)(1)\tau_m \frac{\mathrm{d}V(t)}{\mathrm{d}t} = -(V(t)-V_0) + RI(t) \tag*{(1)}

The neuron spikes if the membrane potential V(t)V(t) is greater than the neuron threshold VtV_t. In this case, the membrane potential is instantly reset to the reset state of the neuron V0V_0.

Although the basic LIF model is powerful, it is often modified to capture a bit more biological realism. For instance, some LIF variants introduce the notion of a refractory period such that after spiking, a neuron undergoes a brief period during which it cannot spike again. This is modeled by holding V(t)V(t) at V0V_0 for a fixed time interval treft_{\mathrm{ref}} immediately after a spike. Some other variants of the LIF model use a constant leak for computational efficiency. The LIF neuron model is popular because it is computationally efficient. Other neuron models, such as Izhikevich and Hodgkin–Huxley, are more complex. Although small-scale simulations of these neuron models are possible on laptops and desktops, large-scale simulations are intractable. On the other hand, because the LIF model abstracts away ion channel dynamics, it cannot replicate complex single-neuron behaviors such as bursting and resonance or the detailed shape of an action potential, as the Izhikevich or Hodgkin–Huxley models can.

SuperNeuroMAT

Our rationale behind designing the SuperNeuroMAT simulator was threefold: (1) Ease of use; (2) computational efficiency; and (3) open-source development. To ensure ease of use for the end user, we developed SuperNeuroMAT in Python, which is the most popular programming language in the neuromorphic community and has a vast ecosystem of libraries. Moreover, we wanted to lower the barrier to entry for new users. Therefore, we provide a very simple application programming interface (API) and a well-documented user guide. Users can install SuperNeuroMAT by running pip install superneuromat, assuming they have Python and pip installed already.

We designed and engineered SuperNeuroMAT for laptops and desktops. To ensure high performance on these systems, we leveraged the numpy and scipy libraries in Python [37, 38]. As a result, SuperNeuroMAT is fast and scalable on personal computers and supports a variety of workloads. It does not constrain the connectivity of neurons (fan-in/fan-out); the user can simulate a sparsely connected SNN with the same computational efficiency and speed as they can a densely connected SNN because SuperNeuroMAT supports both sparse and dense computations. Lastly, SuperNeuroMAT offers support for both single (32-bit) and double (64-bit) precision computations. This gives users the flexibility to achieve higher precision in their computation using double precision or to have more memory at their disposal and thus simulate larger SNNs using single precision.

Lastly, we provide SuperNeuroMAT as a free, open-source library on GitHub to foster a collaborative research environment and software development. We envision SuperNeuroMAT being used by professors, scientists, postdocs, graduate students, undergraduate students, high school students, and SNN enthusiasts all over the world. We actively encourage contributions from the global SNN and neuromorphic computing community in further developing SuperNeuroMAT.

Neuron Parameters

SuperNeuroMAT simulates LIF neurons. Each neuron has an associated index i∈Ni \in\mathbb{N}, and the total number of neurons in the SNN is N∈NN \in\mathbb{N}. On desktop and laptop computers, SuperNeuroMAT can support up to N=10,000N = 10{,}000 neurons with a dense implementation and around N=100,000N = 100{,}000 neurons with a sparse implementation. We denote the scalar versions of the neuron parameters for neuron ii using Greek letters with a subscript ii and the vector versions using bold Greek letters. We denote the time step in square brackets. For example, the membrane potential of neuron ii at time tt is denoted as vi[t]v_i[t]. The membrane potential of all NN neurons at time tt is denoted as v[t]\mathbf{v}[t]. The membrane potential of a LIF neuron is the charge across the membrane of the neuron. In SuperNeuroMAT, the membrane potential represents the internal state of the neuron, and new charges are deposited at every time step. LIF neurons in SuperNeuroMAT have four parameters, as follows:

  1. Threshold (ν\nu): The threshold is a critical value associated with a neuron: if the membrane potential of the neuron becomes greater than the threshold, then the neuron can spike. The threshold of neuron ii is denoted by νi\nu_i (νi∈R ∀i\nu_i \in\mathbb{R}\ \forall i), and the threshold of all neurons is denoted by the vector ν=[ν1 ν2 … νN]T\boldsymbol{\nu} = [\nu_1\ \nu_2\ \ldots\ \nu_N]^\mathsf{T}. The threshold is set when a neuron is created in SuperNeuroMAT and does not change during the course of the simulation.

  1. Leak (λ\lambda): The leak is the constant amount by which the membrane potential of a neuron is either increased or decreased in order to bring it closer to the reset state of the neuron. If the membrane potential of neuron ii is greater than its reset state, then the leak, denoted by λi\lambda_i (λi∈R ∀i\lambda_i \in\mathbb{R}\ \forall i), will be subtracted from its membrane potential. On the other hand, if the membrane potential of the neuron is less than its reset state, then the leak will be added to its membrane potential. The leak is added to or subtracted from the membrane potential until the membrane potential equals the reset state and no further. The leak of all NN neurons in SuperNeuroMAT

is denoted by the vector λ=[λ1 λ2 … λN]T\boldsymbol{\lambda} = [\lambda_1\ \lambda_2\ \ldots\ \lambda_N]^{T} (λ∈RN\boldsymbol{\lambda} \in\mathbb{R}^{N}). The leak is set when a neuron is created and does not change during the course of a simulation.

  1. Reset State (ρ\boldsymbol{\rho}): The reset state of a neuron is the value that its membrane potential attains after the neuron spikes. It is also the value toward which the membrane potential of the neuron is brought by adding or subtracting leak in case the neuron does not spike. The reset state of neuron ii is denoted by ρi\rho_i (ρi∈R ∀i\rho_i \in\mathbb{R}\ \forall i), and the reset state of all NN neurons is denoted by the vector ρ=[ρ1 ρ2 … ρN]T\boldsymbol{\rho} = [\rho_1\ \rho_2\ \ldots\ \rho_N]^{T} (ρ∈RN\boldsymbol{\rho} \in\mathbb{R}^{N}).

  1. Refractory Period (τ\boldsymbol{\tau}): The refractory period of a neuron is the number of time steps during which the neuron cannot spike after it spikes at a certain time step. For instance, if a neuron ii spikes at time step tt and its refractory period is τi\tau_i (τi∈W ∀i\tau_i \in\mathbb{W}\ \forall i), then the neuron cannot spike for the next τi\tau_i time steps. The vector of all refractory periods is denoted by τ=[τ1 τ2 … τN]T\boldsymbol{\tau} = [\tau_1\ \tau_2\ \ldots\ \tau_N]^{T} (τ∈WN\boldsymbol{\tau} \in\mathbb{W}^{N}). To track the refractory period remaining during the course of the simulation, we define a sister variable τ′=[τ1′ τ2′ … τN′]\boldsymbol{\tau}^{\prime} = [\tau^{\prime}_1\ \tau^{\prime}_2\ \ldots\ \tau^{\prime}_N] such that τi′∈W ∀i\tau^{\prime}_i \in\mathbb{W}\ \forall i and τ′∈WN\boldsymbol{\tau}^{\prime} \in\mathbb{W}^{N}. Whereas τ\boldsymbol{\tau} does not change during the course of the simulation, τ′\boldsymbol{\tau}^{\prime} can change. In fact, τ′\boldsymbol{\tau}^{\prime} is checked and updated at every time step. A neuron ii can spike at time step tt only if its refractory period remaining equals 0 (i.e., τi′[t]=0\tau^{\prime}_i[t] = 0).

In SuperNeuroMAT, we store each neuron parameter as a Python list. When a neuron is created, we append all the neuron parameters to their corresponding lists. For instance, if a new neuron is created with threshold ν\nu, leak λ\lambda, reset state ρ\rho, and refractory period τ\tau, then the lists of thresholds (ν\nu), leaks (λ\lambda), reset states (ρ\rho), and refractory periods (τ\tau) would be appended with ν\nu, λ\lambda, ρ\rho, and τ\tau, respectively.

Synapse Parameters

SuperNeuroMAT does not impose any restrictions on the connectivity or the fan-in/fan-out of the neurons. It can simulate all-to-all connectivity in an SNN. For an SNN with NN neurons, the maximum number of synapses is N2N^2, and SuperNeuroMAT indeed supports this. For computational efficiency, we provide two ways of representing the synapses in memory: dense and sparse representations. The user can select the representation that is the most apt for their application. SuperNeuroMAT also has the capability of automatically selecting dense or sparse representation based on the connectivity of the SNN. Each synapse has a unique index (i,j)(i,j), where ii and jj are the neuron indices of the pre-synaptic and post-synaptic neurons, respectively. We support three synapse parameters as follows:

  1. Weight (W): The synaptic weight represents the strength of the connection between two neurons. Each synapse multiplies the incoming spike by its weight. The weight of synapse (i,j)(i,j) is denoted by ωi,j\omega_{i,j} (ωi,j∈R\omega_{i,j} \in\mathbb{R}). The matrix of all synaptic weights is denoted by WW (W∈RN×NW \in\mathbb{R}^{N \times N}).

  1. Delay (D): The synaptic delay represents the number of time steps it takes for a spike to travel from a pre-synaptic neuron to a post-synaptic neuron. Each synapse has a default delay of 1, as we assume that it takes at least one unit of time for a synapse to propagate the spike. This assumption is fundamental to determine the computational complexity of neuromorphic algorithms [9]. The delay of synapse

(i,j)(i,j) is denoted by δi,j\delta_{i,j} (δi,j∈N\delta_{i,j} \in\mathbb{N}). The matrix containing all synaptic delays is denoted by DD (D∈NN×ND \in\mathbb{N}^{N \times N}).

  1. STDP Enabled Flag (E): We allow the option of enabling or disabling STDP learning on each synapse in SuperNeuroMAT. This is captured by the STDP enabled flag, which for synapse (i,j)(i,j) is denoted by ϵi,j\epsilon_{i,j} (ϵi,j∈B\epsilon_{i,j} \in\mathbb{B}). STDP is enabled if the flag is set to 1; otherwise, it is disabled. The matrix of STDP enabled flags for all synapses is denoted by EE (E∈BN×NE \in\mathbb{B}^{N \times N}).

While creating synapses, we store the synapse parameters in Python lists. When a synapse is created, we append the synapse parameters of the newly created synapse to their corresponding lists. Let us say a new synapse is to be created with weight ω\omega, delay δ\delta, and STDP enabled flag ϵ\epsilon. If the delay is 1, then all synapse parameters (ω\omega, δ\delta, and ϵ\epsilon) get appended to their respective lists: that is, weights list (ω\omega), delays list (δ\delta), and STDP enabled flags list (ϵ\epsilon). If the delay δ\delta is greater than 1, then SuperNeuroMAT creates a chain of additional δ−1\delta- 1 neurons such that all synapses along this chain have a delay of 1. The last synapse in this chain is assigned the weight ω\omega and STDP enabled flag ϵ\epsilon. All synapse parameters are updated in their corresponding lists during the creation of these chained synapses. We also store the pre-synaptic and post-synaptic neuron indices for all synapses while creating them. While running the simulation, synapses are represented using dense or sparse arrays. In the dense representation, the synapse parameters are stored as O(N2)O(N^2) numpy arrays. In the sparse representation, the synapse parameters are stored as O(S)O(S) sparse scipy arrays.

Input Spikes

In SuperNeuroMAT, we enable the user to provide external input spikes to neurons at any time step. Unlike the ‘internal’ binary spikes propagated by the neurons in the SNN, the ‘external’ spikes are provided by the user and can be real valued. We denote the external spike given to neuron ii at time step tt by xi[t]x_i[t]. A vector of all input spikes at time step tt is denoted by x[t]\mathbf{x}[t]. These input spikes are ordered by the time step. For the most efficient simulation, it is better to provide details about input spikes before the simulate function is called.

Learning Parameters

SuperNeuroMAT supports STDP learning with the following three parameters.

  1. STDP Time Steps (TST_S): This is the number of time steps over which STDP operations occur. Typically, TS∈WT_S \in\mathbb{W}. If TST_S equals 0, then no STDP operations occur.

  1. Coefficients for Positive Updates (α+\alpha^{+}): This is a TST_S dimensional vector containing coefficients for positive weight updates. Typically, αi+∈R ∀i∈{1,2,…,TS}\alpha_i^{+} \in\mathbb{R}\ \forall i \in\{1,2,\ldots,T_S\}, α+∈RTS\alpha^{+} \in\mathbb{R}^{T_S}, and α1+≥α2+≥…≥αTS+≥0\alpha_1^{+} \ge\alpha_2^{+} \ge\ldots\ge\alpha_{T_S}^{+} \ge0.

  1. Coefficients for Negative Updates (α−\alpha^{-}): This is a TST_S dimensional vector of coefficients for negative weight updates in the STDP operation. Typically, αi−∈R ∀i∈{1,2,…,TS}\alpha_i^{-} \in\mathbb{R}\ \forall i \in\{1,2,\ldots,T_S\}, α−∈RTS\alpha^{-} \in\mathbb{R}^{T_S}, and α1−≤α2−≤…≤αTS−≤0\alpha_1^{-} \le\alpha_2^{-} \le\ldots\le\alpha_{T_S}^{-} \le0.

If the user only requires positive weight updates during STDP, then αi−\alpha_i^{-} can be set to 0 for all ii. Similarly, αi+\alpha_i^{+} can be set to 0 for all ii if only negative weight updates are required during STDP.

Modeling the LIF Operations

We model the LIF operations using a matrix-based approach. To the best of our knowledge, this approach is unprecedented in the literature. We use a matrix-based approach in order cater to the processors available on today’s laptops and desktops. The CPUs available on these machines are highly optimized to run matrix or vector operations using single instruction, multiple data (SIMD) computations. By modeling the LIF operations using matrices and vectors, and by leveraging the numpy and scipy libraries, which are based on the BLAS library in C [39], we were able to perform the LIF operations in a highly optimized and computationally efficient manner.

In this section, we derive the discretized version of Equation (1) to make it amenable to computation on CPUs. Firstly, we start by multiplying Equation (1) by dtτm\frac{dt}{\tau_m} on both sides.

dV(t)=[−(V(t)−V0)+RI(t)τm]dt(2)dV(t) = \left[\frac{-(V(t)-V_0)+RI(t)}{\tau_m}\right]dt \tag*{(2)}

Next, we discretize the equation in time and use square brackets to make this evident. Note that we switch to using square brackets for discrete time tt according to our notation described in § 3.

ΔV[t]=[−(V[t−Δt]−V0)+RI[t−Δt]τm]Δt(3)\Delta V[t] = \left[\frac{-(V[t-\Delta t]-V_0)+RI[t-\Delta t]}{\tau_m}\right]\Delta t \tag*{(3)}

Next, we choose a small enough time step such that Δt\Delta t equals 1. In real physical units, this time difference can vary from application to application. Some applications may have a time step of 1 ms whereas others might have a time step of 1 ns or 1 ps.

ΔV[t]=−(V[t−1]−V0)+RI[t−1]τm(4)\Delta V[t] = \frac{-(V[t-1]-V_0)+RI[t-1]}{\tau_m} \tag*{(4)}

Now, we move the τm\tau_m into the two terms on the right-hand side.

ΔV[t]=−(V[t−1]−V0)τm⏟leak+Rτm⏟weightsI[t−1]⏟spikes(5)\Delta V[t] = \underbrace{\frac{-(V[t-1]-V_0)}{\tau_m}}_{\text{leak}} + \underbrace{\frac{R}{\tau_m}}_{\text{weights}}\underbrace{I[t-1]}_{\text{spikes}} \tag*{(5)}

This separates the leak term from the weights and spikes term. We further split the second term on the right-hand side into two terms, one for the input spikes sent by the user and the other for the spikes propagated within the network.

ΔV[t]=−(V[t−1]−V0)τm+RIin[t−1]τm+RInet[t−1]τm(6)\Delta V[t] = \frac{-(V[t-1]-V_0)}{\tau_m} + \frac{R I_{\mathrm{in}}[t-1]}{\tau_m} + \frac{R I_{\mathrm{net}}[t-1]}{\tau_m} \tag*{(6)}

Now, let us rewrite the above equation using the SuperNeuroMAT notation from Table 3 and Table 4. The membrane potential of neuron ii at time step tt in SuperNeuroMAT is denoted using vi[t]v_i[t]. Therefore, the ΔV[t]\Delta V[t] term becomes vi[t]−vi[t−1]v_i[t] - v_i[t-1]. SuperNeuroMAT supports a constant leak at each time step. Therefore, the leak term for neuron ii simply reduces to −λi-\lambda_i. The input spikes in SuperNeuroMAT are denoted by xi[t]x_i[t], which are not binary spikes but, rather, can have a real number value. Therefore, the input spikes term becomes xi[t]x_i[t]. Lastly, the network spikes term can be split into Rτm\frac{R}{\tau_m}, which denotes the synaptic weights of all the incoming synapses and Inet[t]I_{\mathrm{net}}[t], which denotes the binary spikes along all incoming synapses. Therefore, the above equation can be rewritten using the SuperNeuroMAT notation as follows:

vi[t]−vi[t−1]=−λi+xi[t]+∑j=1Nωi,j[t−1]sj[t−1](7)v_i[t] - v_i[t-1] = -\lambda_i + x_i[t] + \sum_{j=1}^{N} \omega_{i,j}[t-1]s_j[t-1] \tag*{(7)}

Note that the summation of jj is taken over all the neurons in the SNN. If a synapse from neuron jj to neuron ii does not exist in the SNN, then we set its weight to 0. From a computational efficiency point of view, it is more efficient to perform this operation over weights that are initialized to 0 rather than searching for only those synapses that exist in the SNN. We now move the vi[t−1]v_i[t-1] term to the right-hand side to yield the equation to update the membrane potential of neuron ii at time step tt:

vi[t]=vi[t−1]−λi+xi[t]+∑j=1Nωi,j[t−1]sj[t−1](8)v_i[t] = v_i[t-1] - \lambda_i + x_i[t] + \sum_{j=1}^{N} \omega_{i,j}[t-1]s_j[t-1] \tag*{(8)}

We now vectorize this equation to compute the membrane potential of all NN neurons in one shot:

v[t]=v[t−1]−λ+x[t]+WT[t−1]s[t−1](9)v[t] = v[t-1] - \lambda+ x[t] + W^{T}[t-1]s[t-1] \tag*{(9)}

Note that in the matrix WW, each element wi,jw_{i,j} denotes the synaptic weight of the synapse going from neuron ii to neuron jj. In order to match the weights to the incoming spike vector ss, we must take the transpose of WW. Equation (9) gives us a vectorized equation to update the membrane potential of all neurons at time step tt.

We would like to point out a few considerations about computing the leak in Equation (9). The leak tries to bring the membrane potential of the neuron back to the rest state. If the membrane potential vi[t−1]v_i[t-1] is greater than the reset states ρi\rho_i for neuron ii, then the leak is subtracted as shown in Equation (1). However, if vi[t−1]<ρiv_i[t-1] < \rho_i for some neuron ii, then the constant leak λi\lambda_i will be added to the membrane potential instead of being subtracted in order to bring the membrane potential closer to the reset state. Another point to keep in mind about the leak is that after subtracting/adding leak to the membrane potential, if the membrane potential becomes lower/higher than the reset state, then we set the membrane potential to the reset state.

The neuron spikes if its membrane potential is greater than its threshold and its refractory period remaining at the current time step is 0. If the neuron spikes, then it enters its refractory period. We do this by setting its refractory period remaining τi′\tau'_i to its refractory period τi\tau_i. If the neuron does not spike, we decrement its refractory period by 1 until it reaches 0. Accordingly, we have the two following equations to compute the spikes and the refractory periods.

si[t]={1if vi[t]>νi and τi′[t]=00otherwise(10)s_i[t] = \begin{cases} 1 & \text{if } v_i[t] > \nu_i \text{ and } \tau'_i[t] = 0 \\ 0 & \text{otherwise} \end{cases} \tag*{(10)}
τi′[t]={τiif si[t]=1max⁡{0,τi′[t−1]−1}otherwise(11)\tau'_i[t] = \begin{cases} \tau_i & \text{if } s_i[t] = 1 \\ \max\{0,\tau'_i[t-1]-1\} & \text{otherwise} \end{cases} \tag*{(11)}

where the max⁡{…}\max\{\ldots\} function selects the maximum element out of all the elements in a given set.

Modeling the STDP Operations

The STDP algorithm is often colloquially summarized as follows: neurons that fire together, wire together. More formally, the STDP algorithm can be described as follows. Let us say that a neuron ii spiked at time step t−1t-1 and another neuron jj spiked at time step tt (i.e., neuron jj spiked immediately after neuron ii). In this case, the weight of synapse (i,j)(i,j) should be increased. The rationale behind this is that the spiking behavior of neuron ii is positively correlated with that of neuron jj. In some cases, neuron ii could even be thought of as causing neuron jj to spike, although causality is not always guaranteed. Conversely, if neuron jj spiked at time step t−1t-1 and neuron ii spiked at time step tt—that is, if neuron jj spiked before neuron ii—then the weight of synapse (i,j)(i,j) will be decreased. This is because neuron jj spiked before neuron ii, meaning their spiking behavior is negatively correlated.

Now, in a series of steps, we will formulate the STDP weight update as matrix–vector operations. This is how we implement STDP operations in SuperNeuroMAT. First, we want to find the indices of the weights that need to be updated. To do so, we need to look at the spike vectors at times t−1t-1 and tt. Since the spike vectors are binary (s[t−1],s[t]∈BNs[t-1], s[t] \in\mathbb{B}^{N}), their outer product gives us an N×NN \times N binary matrix. The non-zero entries of this matrix represent the weights for which the pre-synaptic neuron spiked at time step t−1t-1 and the post-synaptic neuron spiked at time step tt. This is a positive correlation, as described above, and these weights must be increased. Thus, the positive weight update matrix at time step tt, ΔW+[t]\Delta W^{+}[t] can be written as follows.

ΔW+[t]=s[t−1]sT[t](12)\Delta W^{+}[t] = s[t-1]s^{T}[t] \tag*{(12)}

Note that if we subtract ΔW+[t]\Delta W^{+}[t] from an N×NN \times N matrix of ones, we will get the indices of the weights that should be decreased. Thus, the negative weight update matrix at time step tt, ΔW−[t]\Delta W^{-}[t] can be written as follows.

ΔW−[t]=1N×N−s[t−1]sT[t](13)\Delta W^{-}[t] = \mathbf{1}_{N \times N} - s[t-1]s^{T}[t] \tag*{(13)}

Typically, ΔW+\Delta W^{+} and ΔW−\Delta W^{-} are multiplied by coefficients α1+\alpha^{+}_{1} and α1−\alpha^{-}_{1}, respectively. These coefficients are called potentiation amplitude and depression amplitude, respectively, in neuroscience. They are described in Table 5. This is akin to the learning rate used in the backpropagation algorithm for training ANNs. Accounting for these coefficients, we can rewrite ΔW+[t]\Delta W^{+}[t] and ΔW−[t]\Delta W^{-}[t] as follows.

ΔW+[t]=α1+s[t−1]sT[t](14)\Delta W^{+}[t] = \alpha^{+}_{1}s[t-1]s^{T}[t] \tag*{(14)}
ΔW−[t]=α1−(1N×N−s[t−1]sT[t])(15)\Delta W^{-}[t] = \alpha^{-}_{1}\left(\mathbf{1}_{N \times N} - s[t-1]s^{T}[t]\right) \tag*{(15)}

Furthermore, STDP operations occur over TST_{S} time steps. Accordingly, we have TST_{S} amplitudes of potentiation and depression, α1+,α2+,…,αTS+\alpha^{+}_{1}, \alpha^{+}_{2}, \ldots, \alpha^{+}_{T_{S}} and α1−,α2−,…,αTS−\alpha^{-}_{1}, \alpha^{-}_{2}, \ldots, \alpha^{-}_{T_{S}}. These are applied to the outer products of the spike vectors over previous TST_{S} time steps. The resulting matrices are summed together to yield an updated expression for the positive and negative weight updates as follows.

ΔW+[t]=∑ts=1TSαts+s[t−ts]sT[t](16)\Delta W^{+}[t] = \sum_{t_{s}=1}^{T_{S}} \alpha^{+}_{t_{s}}s[t-t_{s}]s^{T}[t] \tag*{(16)}
ΔW−[t]=∑ts=1TSαts−(1N×N−s[t−ts]sT[t])(17)\Delta W^{-}[t] = \sum_{t_{s}=1}^{T_{S}} \alpha^{-}_{t_{s}}\left(\mathbf{1}_{N \times N} - s[t-t_{s}]s^{T}[t]\right) \tag*{(17)}

Essentially, for positive weight updates, we apply the first potentiation amplitude α1+\alpha^{+}_{1} to the most recent spike vector, s[t−1]s[t-1], the second potentiation amplitude α2+\alpha^{+}_{2} to the second most recent spike vector, s[t−2]s[t-2], and so on. Typically, we have α1+≥α2+≥…≥αTS+≥0\alpha^{+}_{1} \ge\alpha^{+}_{2} \ge\ldots\ge\alpha^{+}_{T_{S}} \ge0, giving more importance to the recent spike vectors and less importance to older spike vectors. We eventually add all these matrices, and that becomes our positive weight update matrix at time step tt. The same can be said for the negative weight updates, where we have α1−≤α2−≤…≤αTS−≤0\alpha^{-}_{1} \le\alpha^{-}_{2} \le\ldots\le\alpha^{-}_{T_{S}} \le0.

Given W+[t]W^{+}[t] and W−[t]W^{-}[t], we can write the overall weight update ΔW\Delta W as follows. Note that we do not need to subtract ΔW−\Delta W^{-} because the depression coefficients are already assumed to be negative.

ΔW[t]=ΔW+[t]+ΔW−[t](18)\Delta W[t] = \Delta W^{+}[t] + \Delta W^{-}[t] \tag*{(18)}

Next, SuperNeuroMAT allows users to enable STDP on certain synapses and disable it on others. We have a variable ϵi,j\epsilon_{i,j} associated with synapse (i,j)(i,j) to capture this information. If STDP is enabled on synapse (i,j)(i,j), then ϵi,j\epsilon_{i,j} is set to 1, else 0. This information is also represented in the matrix EE, where the element in the ithi^{\mathrm{th}} row and jthj^{\mathrm{th}} column is ϵi,j\epsilon_{i,j}. EE is called the STDP enabled matrix, and E∈BN×NE \in\mathbb{B}^{N \times N}. To allow STDP operations on only those synapses for which STDP is enabled, we need to multiply the weight updates by EE element-wise. We denote the element-wise multiplication operator for two matrices using the ⊙\odot symbol. The resulting matrix is added to the weight matrix WW to update the weights at time step tt. Therefore, the overall weight update can be written as follows.

W[t]=W[t−1]+E⊙ΔW[t](19)W[t] = W[t-1] + E \odot\Delta W[t] \tag*{(19)}

Setting Up the Simulation Environment

All the neuron parameters, synapse parameters, and learning parameters are stored in memory as Python lists when the SNN is being created. The input spikes are stored as a Python dictionary, keyed on the time steps for efficient retrieval during simulation. When the simulation environment is being initialized, numpy arrays are created for all neuron and learning parameters. If the representation of matrices pertaining to the synaptic parameters is dense, then the synaptic weights and STDP enabled flags are stored as numpy arrays. If the representation is sparse, then they are stored as scipy sparse arrays. We also initialize variables to store the spikes and the spike trains.

Simulation Algorithm

The simulation algorithm implements Equation (9), Equation (10), Equation (11), and Equation (19) at each time step. We leverage numpy and scipy arrays to store the vectors and matrices in memory. We also implement the computations in a manner that is amenable for SIMD computations on hardware. We assume here that the simulation is run for TT time steps and determine the computational complexity of updating the membrane potential of the neurons (Equation (9)) and updating the synaptic weights using STDP (Equation (19)). These two equations are the dominant computations that must be performed at each simulation time step.

For storing the vectors in Equation (9)—vv, λ\lambda, xx, ss etc.—we need O(N)O(N) space. For storing the matrix WW under a dense implementation, we need O(N2)O(N^2) space because with NN neurons, the maximum number of synapses possible is N2N^2. Under a sparse implementation, storing WW would require O(S)O(S) space. Therefore, the space complexity in a dense implementation is O(N2)O(N^2), and that in a sparse implementation is O(N+S)O(N+S). To compute the vector operations, we would need O(N)O(N) time. To compute the matrix operations under a dense implementation, we would need O(N2)O(N^2) time, and under a sparse implementation, we would need O(S)O(S) time. Therefore, the overall time complexity under a dense implementation is O(N2)O(N^2), and that in a sparse implementation is O(N+S)O(N+S).

The space complexity for computing Equation (19) is O(N2)O(N^2) for a dense implementation and O(S)O(S) for a sparse implementation. Since all the vectors are stored as dense vectors in SuperNeuroMAT, the time complexity of computing the outer products in Equation (16) and Equation (17) is O(N2)O(N^2). We compute TST_S such outer products at each time step. Therefore, the overall time complexity of computing Equation (16) and Equation (17) is O(N2⋅TS)O(N^2 \cdot T_S). The time complexity of computing Equation (19) is O(N2)O(N^2) for a dense implementation and O(S)O(S) for a sparse implementation. However, the overall time complexity of STDP computations is dominated by Equation (16) and Equation (17). Therefore, the overall time complexity of STDP computations is O(N2⋅TS)O(N^{2} \cdot T_{S}), and the overall space complexity of STDP computations is O(N2)O(N^{2}) for dense and O(S)O(S) for sparse implementations.

We will also need O(N⋅T)O(N \cdot T) space to store the spike train. Therefore, the overall space complexity for dense computations is O(N2)+O(N2⋅TS)+O(N⋅T)O(N^{2}) + O(N^{2} \cdot T_{S}) + O(N \cdot T). The overall space complexity for sparse computations is O(S)+O(N2⋅TS)+O(N⋅T)O(S) + O(N^{2} \cdot T_{S}) + O(N \cdot T). Taking the highest-order terms, we get overall space complexity as O(N2⋅TS+N⋅T)O(N^{2} \cdot T_{S} + N \cdot T). Similarly, the overall time complexity for each time step is O(N2⋅TS)O(N^{2} \cdot T_{S}) for both sparse and dense computations. This is dominated by the STDP operations. The overall time complexity across TT simulation time steps is O(N2⋅TS⋅T)O(N^{2} \cdot T_{S} \cdot T). Note that since all operations are modeled using matrices and vectors, they can be parallelized to take advantage of multiple CPUs on a compute platform. Numpy and scipy inherently support this parallel execution because they are based on the BLAS library in C. Although the time complexity is a polynomial expression in the number of inputs and is thus considered efficient, we see even better performance in practice because of the parallel execution.

Results

SuperNeuroMAT supports both sparse and dense representations of the SNN. We conducted a detailed study comparing the total run time and memory consumption for both sparse and dense representations of various SNNs generated uniformly at random, as detailed in in § 6.1. We also compared the performance of SuperNeuroMAT with four SNN simulators: NEST, Brian2, BindsNET, and snnTorch. As shown in § 6.2, we used SuperNeuroMAT in two conventional benchmark ML examples (Digits and Citation Networks), two neuromorphic ML examples (N-CARS and ASL-DVS), and two non-ML examples (shortest path and arithmetic primitives). These problems are crucial for general-purpose computing applications of neuromorphic computing.

Computational Efficiency

All experiments in this section were conducted on a KVM virtual machine running Rocky Linux 9.8 with 32 vCPUs and 128 GiB of RAM, hosted on an AMD EPYC 7702 64-core (Zen 2) processor. Simultaneous multithreading was disabled and a single NUMA node was used. Storage consisted of a 60 GiB virtio block device holding the root file system as well as a 1.2 TiB shared NFS v4.2 volume mounted for user data. Transparent huge pages were enabled in always mode, and no swap was configured, so no measurement was affected by paging.

Performance of Sparse and Dense Simulation Modes

We first compare the performance of the sparse and dense execution modes in SuperNeuroMAT. In this section, the connection probability is defined as S/N2S/N^{2}, where

SS is the number of synapses, and NN is the number of neurons in the SNN. Since N2N^2 is the maximum possible number of synapses in an SNN of NN neurons, this quantity expresses the fraction of connections that are actually present. We evaluated a structured grid of four network sizes (N=10N = 10, 100, 1,000, and 10,000) and five connection probabilities (SN2=10−4\frac{S}{N^2} = 10^{-4}, 10−310^{-3}, 10−210^{-2}, 10−110^{-1}, and 1.0). Each of these twenty combinations was simulated in both modes, yielding forty distinct simulation configurations, each of which was executed ten times for a total of four hundred runs. The values shown in Figure 1 and Figure 2 are averaged over the ten runs of each configuration.

Comparison of run times of sparse and dense modes in SuperNeuroMAT for four network sizes

Figure 1. Comparison of run times of sparse and dense modes in SuperNeuroMAT for (a) 10 neurons; (b) 100 neurons; (c) 1,000 neurons; and (d) 10,000 neurons. The connection probability is shown on the X-axis, and the total run time in seconds is shown on the Y-axis.

Comparison of memory consumed by the sparse and dense modes in SuperNeuroMAT

Figure 2. Comparison of memory consumed by the sparse and dense modes in SuperNeuroMAT for (a) 10 neurons; (b) 100 neurons; (c) 1,000 neurons; and (d) 10,000 neurons. The connection probability is shown on the X-axis, and the total memory consumed in megabytes (MB) is shown on the Y-axis.

Each SNN was constructed by first creating NN neurons and then creating synapses uniformly at random according to the connection probability of the configuration. STDP was enabled on all synapses, and input spikes were assigned uniformly at random. Every network was simulated for 100 time steps. For each run, we recorded the network setup time, the simulation time, the total run time, and the peak resident memory so that computational and memory costs could be compared directly across the two modes.

Figure 1 presents the total run time (Y-axis) for both sparse and dense modes as a function of connection probability (X-axis) for each network size; because the Y-axis denotes run time, lower values are better. Figure 2 presents the peak memory consumption (Y-axis) for both modes as a function of connection probability (X-axis) for each of the four network sizes; once again, lower values are better. The results reveal a clear crossover the location of which depends jointly on network size and connectivity. For the smallest networks (10–100 neurons), dense mode was consistently faster at every connection probability, with simulation times of roughly 0.004–0.011 s compared with 0.07–0.11 s in sparse mode. Peak memory in this regime was essentially identical between the two modes (approximately 80 MB) and was dominated by run time overhead rather than by the network itself. At 1,000 neurons the ordering reversed at low and moderate connectivity: mean total run time in sparse mode was 5.1×5.1 \times faster at 10−410^{-4} (0.166 s vs. 0.851 s), 3.6×\times faster at 10−310^{-3} (0.226 s vs. 0.821 s), and 2.4×\times faster at 10−210^{-2} (0.400 s vs. 0.949 s), with correspondingly lower peak memory (84–88 MB vs. 119–122 MB). At a connection probability of 10−110^{-1}, the two modes were effectively tied in terms of run time (1.72 s vs. 1.75 s), although the sparse mode retained a memory advantage (about 124 MB vs 155 MB), and at full connectivity the dense mode was again faster (3.23 s vs 9.82 s).

The sparse mode performance was the most prominent at the largest scale. For 10,000 neurons, sparse mode reduced total run time by approximately 45×\times at a connection probability of 10−410^{-4} (3.93 s vs. 179 s), 26×\times at 10−310^{-3} (6.67 s vs. 176 s), and 8×\times at 10−210^{-2} (23.0 s vs. 184 s), and it remained faster at 10−110^{-1} (200 s vs. 273 s). Peak memory usage in these regimes was between 1.3×\times and 14×\times lower than in dense mode, with the largest reductions at the sparsest connectivities. At full connectivity, however, sparse mode required substantially more time (2,140 s vs. 508 s) and slightly more memory (27.2 GB vs. 25.6 GB) than the dense mode.

The results above indicate that neither representation dominates across the parameter space. Dense execution is preferable when the problem is small because its lower per-operation overhead outweighs any redundant computation, as well as when the network is close to fully connected because the sparse representation traverses almost as many elements as the dense one while paying additional indexing costs. Sparse execution is preferable for large, genuinely sparse networks, which is the regime most representative of application-scale SNNs; it yielded speedups of up to 45×\times and memory reductions of up to 14×\times in our experiments. Because users can present SuperNeuroMAT with any of these configurations, it supports both execution modes. When the user does not explicitly select a mode, SuperNeuroMAT chooses one automatically from the number of neurons and the number of synapses in the SNN. Dense mode is selected for small problems and for large, densely connected problems. Sparse mode is selected for large, sparse problems.

Comparison with Other Simulators

We now evaluate the computational efficiency of both sparse and dense modes of SuperNeuroMAT against four widely used SNN simulation frameworks: NEST, Brian2, BindsNET, and snnTorch. Rather than relying on a specific application-derived network, the comparison uses synthetic Erdős–Rényi random graphs spanning four network sizes (10, 100, 1,000, and 10,000 neurons) and six connection probabilities (0.01, 0.1, 0.25, 0.5, 0.75, and 1.0), with 10 independently generated graphs for each combination of network size and connection probability. Each graph is converted into an equivalent SNN in every framework, and all neurons receive external spikes at every fifth time step.

While each simulator operates differently, we ensured that the neuron and synapse models are matched as closely as possible within what is allowed under each framework’s API. In each simulator, we ensured that the neuron model being simulated matches the default configuration of SuperNeuroMAT’s neuron and synapse: zero threshold, memoryless (infinite-leak) LIF neurons with instantaneous (“delta”) synapses carrying a unit delay. This was implemented via NEST’s iaf_psc_delta, a custom-scheduled Brian2 equation set, BindsNET’s LIFNodes with near-zero decay, and snnTorch’s Leaky neuron with zero decay. By equalizing simulation semantics across frameworks, differences in measured runtime and memory can be attributed to implementation efficiency rather than to differences in model complexity. For each run, setup time (data-structure preparation) and simulation time (100 time steps of execution) were recorded separately, along with peak resident memory usage, and

SuperNeuroMAT was evaluated in both its dense (NumPy) and sparse (SciPy sparse matrix) modes.

Figure 3 shows the comparison of run times in seconds along the Y-axis as a function of increasing connection probability along the X-axis for four network sizes. Across the tested range, SuperNeuroMAT outperforms all four simulators, and its performance in relation to other simulators improves significantly as the network size increases. At 1,000 neurons (averaged across all connection probabilities), SuperNeuroMAT’s dense mode completes in 0.052 s, versus 0.56 s for Brian2, 2.52 s for snnTorch, 2.81 s for BindsNET, and 7.05 s for NEST—a 1010–135×135 \times speedup. At 10,000 neurons under full connectivity (the most computationally demanding configuration tested), SuperNeuroMAT dense mode requires 7.18 s, compared with 70.0 s for Brian2 (9.8×9.8 \times), 578.7 s for snnTorch (81×), 613.3 s for BindsNET (85×), and 1,545.6 s for NEST (215×). Notably, at the smallest network size (10 neurons) NEST is marginally faster than SuperNeuroMAT, reflecting its low fixed per-run overhead. However, this crossover disappears by 100 neurons, since NEST’s per-neuron and per-edge object-creation calls scale poorly with network size, and SuperNeuroMAT’s advantage grows monotonically thereafter.

Run time comparison for SuperNeuroMAT sparse and dense, NEST, Brian2, BindsNet, and snnTorch for different neuron counts

Figure 3. Run time comparison for SuperNeuroMAT sparse (green), SuperNeuroMAT dense (blue), NEST (orange), Brian2 (yellow), BindsNet (red), and snnTorch (purple) for (a) 10 neurons; (b) 100 neurons; (c) 1,000 neurons; and (d) 10,000 neurons. The connection probability is shown on the X-axis, and the time in seconds is shown on the Y-axis.

Figure 4 shows the comparison of peak resident memory in MB along the Y-axis as a function of increasing connection probability along the X-axis for four network sizes. SuperNeuroMAT maintains a consistently smaller memory footprint. At small scale (10–100 neurons), its peak memory usage is negligible (well under 1 MB), whereas the other frameworks carry substantial fixed overhead—largely from their underlying runtime systems (PyTorch for BindsNET and snnTorch, the NEST kernel, and Brian2’s code-generation backend)—ranging from roughly 130 MB (NEST) to over 800 MB (BindsNET). At the largest scale tested (10,000 neurons, full connectivity), SuperNeuroMAT consumes approximately the same peak memory as Brian2 and is slightly higher than the remaining three simulators. However, the 2–3 orders of magnitude speedup obtained in the run times shown in Figure 3 by SuperNeuroMAT as compared to NEST, BindsNET, and snnTorch, more than compensates for the slightly higher peak memory consumption. Note that the memory values presented in Figure 4 include the memory consumed by the Erdős–Rényi graphs, which were created using the networkx library in Python.

Peak memory comparison for SuperNeuroMAT sparse, SuperNeuroMAT dense, NEST, Brian2, BindsNet, and snnTorch across four network sizes

Figure 4. Peak memory comparison for SuperNeuroMAT sparse (green), SuperNeuroMAT dense (blue), NEST (orange), Brian2 (yellow), BindsNet (red), and snnTorch (purple) for (a) 10 neurons; (b) 100 neurons; (c) 1,000 neurons; and (d) 10,000 neurons. The connection probability is shown on the X-axis, and the time in seconds is shown on the Y-axis.

Benchmark Examples

We provide six examples of how SuperNeuroMAT can be used in a variety of different settings. We focus on two conventional machine learning examples: the Digits dataset and citation networks datasets (Cora, Citeseer, and Pubmed). Next, we delve into two neuromorphic ML datasets: the N-CARS dataset and the ASL-DVS dataset. Finally, we look into two non-ML examples: the shortest path algorithm and the arithmetic primitives.

Digits

We use SuperNeuroMAT to implement a two-layer SNN for the Digits dataset, which is available in the Scikit-learn library in Python. The Digits dataset is a benchmark handwritten digit classification dataset containing 1,797 grayscale images of decimal digits (0–9), with one class label per image. Each image has a spatial size 8×88 \times8, so every sample is represented by 64 pixel features after flattening. Pixel intensities are quantized integer values in the range [0,15][0,15], corresponding to 4-bit grayscale levels. We split the data into train and test subsets using a 80/20 partition without shuffling, yielding approximately 1,438 training samples and 359 test samples.

Our SNN contained 64 input neurons for the 8×88 \times8 pixels and 10 output neurons for the ten digit classes. We encoded the pixel intensities as spike amplitudes and added input spikes to the correct output neuron during training to facilitate STDP-based synaptic updates. Figure 5 shows the learned synaptic weights after the STDP operations. After training, the learned weight matrix was used for inference with STDP disabled. Predictions were decoded by selecting outputs with the highest spike counts and then resolving ties using earliest spike times. We obtained 93% one-versus-all accuracy, which is at par with the state-of-the-art for such a two-layer SNN. Figure 6 shows the confusion matrix for this dataset. The Digits example demonstrates that a

Learned weights for the Digits dataset using a two-layer SNN in SuperNeuroMAT

Figure 5. Learned weights for the Digits dataset using a two-layer SNN in SuperNeuroMAT.

Confusion matrix for the Digits dataset using a two-layer SNN in SuperNeuroMAT

Figure 6. Confusion matrix for the Digits dataset using a two-layer SNN in SuperNeuroMAT.

compact two-layer SNN can be successfully trained in SuperNeuroMAT using built-in STDP.

Citation Networks

We used SuperNeuroMAT for node classification on three citation network datasets (Cora, Citeseer, and Pubmed). These are well-established benchmarks for evaluating graph learning algorithms. In these datasets, each node corresponds to a scientific publication, directed edges denote citation relationships, and every publication belongs to one of several research topics [40, 41]. Conventional approaches formulate this problem using graph neural networks (GNNs), where node attributes are iteratively aggregated through neighborhood message passing and optimized using backpropagation [42]. In contrast, we develop a neuromorphic formulation in SuperNeuroMAT such that publications are represented as neurons and citation relationships as synapses. This approach enables classification to emerge from event-driven spike propagation and local synaptic plasticity. This approach relies exclusively on graph topology and does not utilize node features, demonstrating that meaningful classification can be achieved through biologically plausible local learning operating directly on the graph structure.

Cora consists of 2,708 publications connected by 5,429 citation links and categorized into seven research topics. CiteSeer contains 3,327 publications, 4,732 citation links, and six topic classes, while PubMed comprises 19,717 publications connected by 44,338 citation links across three research areas. Standard Planetoid train/validation/test splits were adopted for all experiments [43]. Each citation graph was mapped directly onto an SNN, with every publication represented by a neuron and every citation represented by a synapse. To suppress multiple spikes at a given neuron arising from cycles within the citation graph, neurons were assigned a sufficiently long refractory period such that each neuron emitted at most one spike during a simulation. A dedicated output neuron was allocated to each topic class, and every publication neuron in the test set was connected to all topic neurons through trainable synapses initialized with small random weights. During classification, a spike injected into a test publication neuron propagated through the citation graph according to its connectivity. Synaptic weights between publication neurons and topic neurons were updated online using STDP learning. At the end of the simulation, the predicted class was assigned to the topic neuron whose incoming synapse from the test publication neuron attained the largest weight.

Table 6 summarizes the classification performance—these are state-of-the-art results for spiking graph neural network models that do not incorporate features. Although the proposed method does not employ node features, global message passing, or gradient-based optimization, it successfully extracts discriminative information directly from graph topology through local spike-based computation. Our results demonstrate that structurally meaningful representations can emerge from purely local synaptic adaptation. This highlights the flexibility of SuperNeuroMAT for graph-structured learning tasks beyond conventional neuromorphic sensory benchmarks.

DatasetNodesCitation LinksClassesAccuracy (%)
Cora2,7085,429762.7
CiteSeer3,3274,732642.4
PubMed19,71744,338354.7

Table 6. Node classification performance on citation network benchmarks using graph topology alone. No node features were used during learning or classification.

N-CARS

Approach 1: Diehl–Cook-Inspired STDP with Neuron-Level Fine-Tuning

We used SuperNeuroMAT to evaluate unsupervised SNN approaches for car-versus-background classification on the event-based N-CARS dataset [44]. The first approach employed a Diehl–Cook-inspired architecture comprising an input layer with 1,080 input neurons to encode the event camera voxel grid, a 64-neuron excitatory population, and a 64-neuron inhibitory population implementing winner-take-all competition [45]. Input-to-excitatory synapses were trained without class labels using STDP, after which each excitatory neuron was assigned to the class that produced its highest average training set spike response.

SuperNeuroMAT’s spike train was then used to compare activity associated with true positive, true negative, false positive, and false negative predictions. As shown in Figure 7, two neurons exhibited firing rates at least 30% higher during misclassifications, whereas six additional neurons displayed slowly decaying error-associated activity. The two neurons were therefore deactivated, and the leak values of the six remaining neurons were increased from 0.05 to 0.15. These targeted interventions improved the excitatory neuron accuracy by 4.3 percentage points, from 60.7% to 65.0%. This example demonstrates how SuperNeuroMAT can be used to interpret and enhance SNNs in an unsupervised learning setting.

Firing traces of the neurons driving each error type

Figure 7. Mean spike activity of the excitatory neurons associated with false positive and false negative classifications across simulation time steps.

Approach 2: Biologically Inspired Neuromorphic Feature Extraction

We used SuperNeuroMAT in a custom biologically inspired feature extraction pipeline to perform car-versus-background classification on the event-based N-CARS dataset [44]. Unlike conventional approaches that rely on established event representations, such as Histograms of Averaged Time Surfaces (HATS) [44], Hierarchies of Time Surfaces (HOTS) [46], or related time-surface methods, the proposed approach learned a neuromorphic representation directly from the asynchronous event stream.

Events from the 100×120100 \times120 pixel sensor were spatially mapped to a 10×1210 \times12 lattice of ON- and OFF-polarity relay neurons and processed by a sparse 960-neuron SNN. The network incorporated center–surround filtering, fast and slow LIF traces, lateral inhibition, cross-polarity inhibition, and STDP at the excitatory trace-to-output synapses. The use of competitive lateral inhibition and unsupervised STDP builds on established SNN feature learning principles, including the competitive learning architecture introduced by Diehl and Cook [45].

STDP training was performed in an unsupervised learning setting using the 80% training dataset. After training, the SNN was frozen, and features derived from output spike counts, first-spike latencies, and population-level activity (Figure 8a) were combined into a 2,880-dimensional representation. This representation was then evaluated using both a regularized logistic regression classifier and a nonlinear multilayer perceptron with a 2,880→128→64→22{,}880 \to128 \to64 \to2 architecture. On the untouched 20% test partition, comprising 4,806 recordings, the regularized logistic regression achieved 87.7% accuracy, an F1 score of 88.0%, and a receiver operating characteristic area under the curve (ROC-AUC) of 0.938 (Figure 8b). When the same SuperNeuroMAT representation was paired with the nonlinear MLP, performance improved to 92.4% accuracy, an F1 score of 92.7%, and a ROC-AUC of 0.975, demonstrating that the learned neuromorphic features were particularly effective when combined with a nonlinear classifier.

Analysis of the biologically inspired SuperNeuroMAT representation on the N-CARS dataset

Figure 8. (a) Population-level neural activity. (b) Logistic regression classification results. Analysis of the biologically inspired SuperNeuroMAT representation on the N-CARS dataset.

ASL-DVS

We further evaluated the proposed SuperNeuroMAT feature-extraction approach on the ASL-DVS dataset [47]. ASL-DVS contains 100,800 event camera recordings representing 24 American Sign Language letters from A–Y, excluding J and Z. Each class contains 4,200 recordings captured at a spatial resolution of 240×180240 \times180 pixels. An illustrative image is shown in Figure 9. A stratified 80/20 partition was used in the present study, producing 80,640 training recordings and 20,160 held-out test recordings, with 840 test samples per class.

ASL-DVS letter classification results

Figure 9. ASL-DVS letter classification results.

SuperNeuroMAT was used to construct and simulate the SNN and perform STDP learning. Events were mapped to separate ON- and OFF-polarity pathways within a 10×1210 \times12 receptive field lattice and processed using a 2 ms simulation time step. The resulting 960-neuron network incorporated center–surround filtering, fast- and slow-memory LIF neurons, lateral inhibition, and cross-polarity competition. STDP was restricted to the 480 excitatory trace-to-output synapses, which were trained without class labels using only the training partition.

Following unsupervised STDP training, the network parameters were frozen, and each recording was transformed into a 1,548-dimensional feature representation composed of output spike counts, first-spike latencies, and population-level activity measurements. The resulting features were standardized and supplied to a regularized logistic regression classifier. On the test set, the SNN–STDP pipeline achieved 85.3% accuracy, with a 95% confidence interval of 84.8%–85.7%. Macro-averaged precision, recall, and F1 score were 85.3%, 85.3%, and 85.2%, respectively, while the multiclass receiver operating characteristic area under the curve (ROC-AUC) reached 0.992. Classification performance was strongest for the G, P, Q, and H signs, whereas M, S, and T were among the most difficult classes to distinguish.

Shortest Path Algorithm

To evaluate SuperNeuroMAT’s ability to solve graph problems natively through spike timing, we implemented the neuromorphic shortest path algorithm [15] for a directed, weighted graph of 8 nodes and 15 edges as shown in Figure 10 [48]. Each node in the graph is represented by a neuron with a threshold of zero and a large refractory period such that it spikes exactly once during the course of the simulation. Each directed edge is represented by a synapse whose delay is proportional to the corresponding edge weight scaled by a factor of 100 to preserve two decimal digits of precision. Under this encoding, the arrival time of a spike at a given neuron corresponds to the cumulative weight of the path it traveled. A single input spike was injected into a given source node at time zero, and the network was simulated for 300 time steps. This was repeated for all eight source nodes.

Image not extracted

Figure 10. The graph containing eight nodes and fifteen edges used for comparing the neuromorphic shortest path algorithm implemented in SuperNeuroMAT with Dijkstra’s algorithm.

The spike times recorded for each neuron were decoded back into path distances by dividing by 100. The resulting values were compared against shortest distances computed using Dijkstra’s algorithm. For all pairs of source and destination nodes, the neuromorphic shortest distances matched those from Dijkstra’s algorithm. These are shown in Table 7. For instance, for the source neuron 0, neuron 2 spiked at time step 26, corresponding to a distance of 0.26, and neuron 6 spiked at time step 151, corresponding to a distance of 1.51. These results demonstrate the usability of SuperNeuroMAT in solving the shortest path problem without requiring explicit priority queues or relaxation steps as required in Dijkstra’s algorithm.

SourceDestination
01234567
001052699387315160
113701202817318280154
218294073976212534
310918692014515452126
4185671687603512837
5169321526035011228
6571344011393102074
714860131396328910

Table 7. Shortest paths obtained from each source node to each destination node. These were obtained by implementing the neuromorphic shortest path algorithm in SuperNeuroMAT. When scaled down by 100, these shortest paths match the shortest paths obtained using the Dijkstra’s shortest path algorithm.

Arithmetic Primitives

To perform arithmetic operations using SNNs in SuperNeuroMAT, we first encode each operand as a fixed-width binary integer, an nn-bit integer across nn input neurons: neuron ii emits a spike if bit ii is 1. For addition, bit ii of each operand feeds a triad of neurons with thresholds 0, 1, and 2 that reproduce the sum and carry logic of a full adder; the carry neuron at position ii is connected to the triad at position

i+1i + 1 with a one time step delay, so that as the input spike wavefront propagates through the network, the carry ripples forward automatically. This results in a static, feed-forward ripple-carry adder whose control logic is the pattern of synaptic delays. Figure 11 shows a 4-bit adder as an illustration of this approach. Because the SNN is purely feed-forward, its single instantiation can be pipelined such that successive operand pairs are injected one time step apart and are processed concurrently as they move through the network. We validated our approach by building an 8-bit ripple-carry adder. Including the delay neurons, this adder SNN contained 293 neurons and 336 synapses. We streamed 100 randomly generated pairs of 8-bit unsigned integers through it and decoded the resulting spike trains back into decimal values. Comparing against conventional integer addition showed exact match for all 100 input pairs.

Image not extracted

Figure 11. 4-bit spiking adder. Takes two 4-bit operands (AA and BB) encoded using binary encoding as inputs, performs the addition operation through the hidden neurons (HH) and computes a 5-bit output (CC).

We also implemented an 8-bit multiplication SNN. Each partial product Ai∧BjA_i \wedge B_j was computed with a dedicated spiking neuron. The resulting eight shifted partial product rows were summed using a binary merge tree of delay-based ripple-carry adders rather than a single sequential accumulation: at each step, the two partial sums that are ready earliest are combined first, so most merges require no additional resynchronization delay and the SNN depth scales with log⁡2(N)\log_{2}(N), where NN is the number of bits. Testing this SNN on 20 randomly generated pairs of 8-bit unsigned integers, the correct 16-bit product was recovered from the output spike times in all 20 cases, using 2,238 neurons and 2,802 synapses.

Conclusion

This paper introduced SuperNeuroMAT, a fast, scalable, and open-source SNN simulator that leverages a novel matrix-based approach to model the LIF operations, our simulator achieves exceptional computational efficiency on standard CPUs. Both dense and sparse execution modes efficiently simulate up to 10,000 neurons under a dense implementation and approximately 100,000 neurons under a sparse implementation directly on personal computers.

Our results indicate that SuperNeuroMAT consistently outperforms four established SNN frameworks—NEST, Brian2, BindsNET, and snnTorch—in both total run time and peak resident memory across a wide range of connection probabilities and network sizes. Furthermore, we showcased the versatility of SuperNeuroMAT across six diverse examples. We applied SuperNeuroMAT to conventional ML benchmarks (Digits and citation network datasets) as well as to neuromorphic event-based vision datasets (N-CARS and ASL-DVS). Finally, we validated its capability for non-ML, general-purpose computing by accurately implementing a neuromorphic shortest path algorithm and pipelined arithmetic primitives.

Our guiding rationale was to create a framework that is both highly performant and widely accessible; therefore, we developed it to be Python-based, user-friendly, and easily installable via PyPI. By lowering the barrier to entry and providing a powerful tool for SNN simulation and off-chip training, we intend for SuperNeuroMAT to foster a collaborative global research environment and accelerate the broader development of SNNs and neuromorphic computing.

In the future, we would like to implement SuperNeuroMAT in a distributed fashion to simulate billions of neurons and trillions of synapses. Such an implementation will have to leverage both CPUs and GPUs. Unlike desktops or laptops, this implementation would cater to exascale HPC systems such as Frontier, Lux, and Discovery.

Acknowledgements

This material is based upon work supported by the U.S. Department of Energy, Office of Science, Office of Advanced Scientific Computing Research, under contract number DE-AC05-00OR22725. This manuscript has been co-authored by UT-Battelle, LLC under Contract No. DE-AC05-00OR22725 with the US Department of Energy. The United States Government retains and the publisher, by accepting the article for publication, acknowledges that the United States Government retains a non-exclusive, paid-up, irrevocable, world- wide license to publish or reproduce the published form of this manuscript or allow others to do so, for United States Government purposes. The Department of Energy will provide public access to these results of federally sponsored research in accordance with the DOE Public Access Plan (http://energy.gov/downloads/doe-public-access-plan). The authors would like to thank John Baston III, Technical Editor at the Oak Ridge National Laboratory (ORNL), for reviewing and editing this manuscript. The authors would like to thank Nicholas Quentin Haas, Software Developer at ORNL, for providing access to the virtual machine on which the computational efficiency results were obtained in this manuscript.

References

  1. [1]Schuman, C.D., Kulkarni, S.R., Parsa, M., Mitchell, J.P., Date, P., Kay, B.: Opportunities for neuromorphic computing algorithms and applications. Nature Computational Science 2(1), 10–19 (2022)DOI
  2. [2]Aimone, J.B., Date, P., Fonseca-Guerra, G.A., Hamilton, K.E., Henke, K., Kay, B., Kenyon, G.T., Kulkarni, S.R., Mniszewski, S.M., Parsa, M., et al.: A review of non-cognitive applications for neuromorphic computing. Neuromorphic Computing and Engineering 2(3), 032003 (2022)DOI
  3. [3]Orchard, G., Frady, E.P., Rubin, D.B.D., Sanborn, S., Shrestha, S.B., Sommer, F.T., Davies, M.: Efficient neuromorphic signal processing with loihi 2. In: 2021 IEEE Workshop on Signal Processing Systems (SiPS), pp. 254–259 (2021). IEEEarxiv.org/abs/2111.03746
  4. [4]Cassidy, A.S., Arthur, J.V., Akopyan, F., Andreopoulos, A., Appuswamy, R., Datta, P., Debole, M.V., Esser, S.K., Otero, C.O., Sawada, J., et al.: 11.4 ibm northpole: An architecture for neural network inference with a 12nm chip. In: 2024 IEEE International Solid-State Circuits Conference (ISSCC), vol. 67, pp. 214–215 (2024). IEEE Gautam, A., Date, P., Kulkarni, S., Patton, R., Potok, T.: NeuroCoreX: An open-source fpga-based spiking neural network emulator with on-chip learning. arXiv preprint arXiv:2506.14138 (2025)
  5. [6]Maheshwari, D., Young, A., Date, P., Kulkarni, S., Witherspoon, B., Miniskar, N.R.: An fpga-based neuromorphic processor with all-to-all connectivity. In: 2023 IEEE International Conference on Rebooting Computing (ICRC), pp. 1–5 (2023). IEEEDOI
  6. [7]Miniskar, N.R., Young, A.R., Asifuzzaman, K., Kulkarni, S., Date, P., Bean, A., Vetter, J.S.: Neuro-spark: A submicroscond spiking neural networks architecture for in-sensor filtering. In: 2024 International Conference on Neuromorphic Systems (ICONS), pp. 63–70 (2024). IEEEDOI
  7. [8]Date, P., Potok, T., Schuman, C., Kay, B.: Neuromorphic computing is Turing-complete. In: Proceedings of the International Conference on Neuromorphic Systems 2022, pp. 1–10 (2022)arxiv.org/abs/2104.13983
  8. [9]Date, P., Kay, B., Schuman, C., Patton, R., Potok, T.: Computational complexity of neuromorphic algorithms. In: International Conference on Neuromorphic Systems 2021, pp. 1–7 (2021)DOI
  9. [10]Cong, G., Lim, S.-H., Kulkarni, S., Date, P., Potok, T., Snyder, S., Parsa, M., Schuman, C.: Semi-supervised graph structure learning on neuromorphic computers. In: Proceedings of the International Conference on Neuromorphic Systems 2022, pp. 1–4 (2022)DOI
  10. [11]Cong, G., Kulkarni, S., Lim, S.-H., Date, P., Snyder, S., Parsa, M., Kennedy, D., Schuman, C.: Hyperparameter optimization and feature inclusion in graph neural networks for spiking implementation. In: 2023 International Conference on Machine Learning and Applications (ICMLA), pp. 1541–1546 (2023). IEEEDOI
  11. [12]Patton, R., Schuman, C., Kulkarni, S., Parsa, M., Mitchell, J.P., Haas, N.Q., Stahl, C., Paulissen, S., Date, P., Potok, T., et al.: Neuromorphic computing for autonomous racing. In: International Conference on Neuromorphic Systems 2021, pp. 1–5 (2021)DOI
  12. [13]R. Kulkarni, S., Young, A., Date, P., Rao Miniskar, N., Vetter, J., Fahim, F., Parpillon, B., Dickinson, J., Tran, N., Yoo, J., et al.: On-sensor data filtering using neuromorphic computing for high energy physics experiments. In: Proceedings of the 2023 International Conference on Neuromorphic Systems, pp. 1–8 (2023)arxiv.org/abs/2307.11242
  13. [14]Date, P., Carothers, C.D., Hendler, J.A., Magdon-Ismail, M.: Efficient classification of supercomputer failures using neuromorphic computing. In: 2018 IEEE Symposium Series on Computational Intelligence (SSCI), pp. 242–249 (2018). IEEEDOI
  14. [15]Kay, B., Date, P., Schuman, C.: Neuromorphic graph algorithms: Extracting longest shortest paths and minimum spanning trees. In: Proceedings of the 2020 Annual Neuro-inspired Computational Elements Workshop, pp. 1–6 (2020)DOI
  15. [16]Kay, B., Schuman, C., O’connor, J., Date, P., Potok, T.: Neuromorphic graph algorithms: Cycle detection, odd cycle detection, and max flow. In: International Conference on Neuromorphic Systems 2021, pp. 1–7 (2021)DOI
  16. [17]Hamilton, K., Mintz, T., Date, P., Schuman, C.D.: Spike-based graph centrality measures. In: International Conference on Neuromorphic Systems 2020, pp. 1–8 (2020)DOI
  17. [18]Date, P., Kulkarni, S., Young, A., Schuman, C., Potok, T., Vetter, J.: Encoding integers and rationals on neuromorphic computers using virtual neuron. Scientific Reports 13(1), 10975 (2023)DOI
  18. [19]Date, P., Kulkarni, S., Young, A., Schuman, C., Potok, T., Vetter, J.S.: Virtual neuron: A neuromorphic approach for encoding numbers. In: 2022 IEEE International Conference on Rebooting Computing (ICRC), pp. 100–105 (2022). IEEEDOI
  19. [20]Wurm, A., Seay, R., Date, P., Kulkarni, S., Young, A., Vetter, J.: Arithmetic primitives for efficient neuromorphic computing. In: 2023 IEEE International Conference on Rebooting Computing (ICRC), pp. 1–5 (2023). IEEEDOI
  20. [21]Schuman, C.D., Kay, B., Date, P., Kannan, R., Sao, P., Potok, T.E.: Sparse binary matrix-vector multiplication on neuromorphic computers. In: 2021 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), pp. 308–311 (2021). IEEEDOI
  21. [22]Hamilton, K., Date, P., Kay, B., Schuman D, C.: Modeling epidemic spread with spike-based models. In: International Conference on Neuromorphic Systems 2020, pp. 1–5 (2020)DOI
  22. [23]Patton, R., Date, P., Kulkarni, S., Gunaratne, C., Lim, S.-H., Cong, G., Young, S.R., Coletti, M., Potok, T.E., Schuman, C.D.: Neuromorphic computing for scientific applications. In: 2022 IEEE/ACM Redefining Scalability for Diversely Heterogeneous Architectures Workshop (RSDHA), pp. 22–28 (2022). IEEEDOI
  23. [24]Date, P.: Combinatorial Neural Network Training Algorithm for Neuromorphic Computing. Rensselaer Polytechnic Institute, ??? (2019)DOI
  24. [25]Date, P., Carothers, C.D., Mitchell, J.E., Hendler, J.A., Magdon-Ismail, M.: Training deep neural networks with constrained learning parameters. In: 2020 International Conference on Rebooting Computing (ICRC), pp. 107–115 (2020). IEEEDOI
  25. [26]Stimberg, M., Brette, R., Goodman, D.F.: Brian 2, an intuitive and efficient neural simulator. elife 8, 47314 (2019)DOI
  26. [27]Gewaltig, M.-O., Diesmann, M.: Nest (neural simulation tool). Scholarpedia 2(4), 1430 (2007)DOI
  27. [28]Aimone, J.B., Severa, W., Vineyard, C.M.: Composing neural algorithms with fugu. In: Proceedings of the International Conference on Neuromorphic Systems, pp. 1–8 (2019)arxiv.org/abs/1905.12130
  28. [29]Wang, F., Kulkarni, S., Theilman, B., Rothganger, F., Schuman, C., Lim, S.-H., Aimone, J.B.: Scaling neural simulations in stacs. Neuromorphic Computing and Engineering 4(2), 024002 (2024)DOI
  29. [30]Wang, F.: Simulation tool for asynchronous cortical streams (stacs): interfacing with spiking neural networks. Procedia Computer Science 61, 322–327 (2015)DOI
  30. [31]Hazan, H., Saunders, D.J., Khan, H., Patel, D., Sanghavi, D.T., Siegelmann, H.T., Kozma, R.: Bindsnet: A machine learning-oriented spiking neural networks library in python. Frontiers in neuroinformatics 12, 89 (2018)DOI
  31. [32]Eshraghian, J.K., Ward, M., Neftci, E., Wang, X., Lenz, G., Dwivedi, G., Ben-namoun, M., Jeong, D.S., Lu, W.D.: Training spiking neural networks using lessons from deep learning. Proceedings of the IEEE 111(9), 1016–1054 (2023)
  32. [33]Fang, W., Chen, Y., Ding, J., Yu, Z., Masquelier, T., Chen, D., Huang, L., Zhou, H., Li, G., Tian, Y.: SpikingJelly: An open-source machine learning infrastructure platform for spike-based intelligence. Science Advances 9(40), 1480 (2023)arxiv.org/abs/2310.16620
  33. [34]Date, P., Gunaratne, C., R. Kulkarni, S., Patton, R., Coletti, M., Potok, T.: SuperNeuro: A fast and scalable simulator for neuromorphic computing. In: Proceedings of the 2023 International Conference on Neuromorphic Systems, pp. 1–4 (2023)arxiv.org/abs/2305.02510
  34. [35]Lapicque, L.: Recherches quantitatives sur l’excitationélectrique des nerfs traitée comme une polarisation. Journal de Physiologie et de Pathologie Générale 9, 620–635 (1907)
  35. [36]Gerstner, W., Kistler, W.M.: Spiking Neuron Models: Single Neurons, Populations, Plasticity. Cambridge University Press, Cambridge, UK (2002)
  36. [37]Harris, C.R., Millman, K.J., Walt, S.J., Gommers, R., Virtanen, P., Cournapeau, D., Wieser, E., Taylor, J., Berg, S., Smith, N.J., Kern, R., Picus, M., Hoyer, S., Kerkwijk, M.H., Brett, M., Haldane, A., Río, J.F., Wiebe, M., Peterson, P., Gérard-Marchant, P., Sheppard, K., Reddy, T., Weckesser, W., Abbasi, H., Gohlke, C., Oliphant, T.E.: Array programming with NumPy. Nature 585(7825), 357–362 (2020) https://doi.org/10.1038/s41586-020-2649-2
  37. [38]Virtanen, P., Gommers, R., Oliphant, T.E., Haberland, M., Reddy, T., Cournapeau, D., Burovski, E., Peterson, P., Weckesser, W., Bright, J., van der Walt, S.J., Brett, M., Wilson, J., Millman, K.J., Mayorov, N., Nelson, A.R.J., Jones, E., Kern, R., Larson, E., Carey, C.J., Polat, İ., Feng, Y., Moore, E.W., VanderPlas, J., Laxalde, D., Perktold, J., Cimrman, R., Henriksen, I., Quintero, E.A., Harris, C.R., Archibald, A.M., Ribeiro, A.H., Pedregosa, F., van Mulbregt, P., SciPy 1.0 Contributors: SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python. Nature Methods 17, 261–272 (2020) https://doi.org/10.1038/s41592-019-0686-2
  38. [39]Lawson, C.L., Hanson, R.J., Kincaid, D.R., Krogh, F.T.: Basic linear algebra subprograms for routine usage. ACM Transactions on Mathematical Software (TOMS) 5(3), 308–323 (1979)DOI
  39. [40]Sen, P., Namata, G., Bilgic, M., Getoor, L., Gallagher, B., Eliassi-Rad, T.: Collective classification in network data. In: AI Magazine, vol. 29, pp. 93–106 (2008)DOI
  40. [41]Namata, G., London, B., Getoor, L., Huang, B., EDU, U.: Query-driven active surveying for collective classification. In: 10th International Workshop on Mining and Learning with Graphs (MLG) (2012)
  41. [42]Kipf, T.N., Welling, M.: Semi-supervised classification with graph convolutional networks. In: International Conference on Learning Representations (ICLR) (2017)arxiv.org/abs/1609.02907
  42. [43]Yang, Z., Cohen, W.W., Salakhutdinov, R.: Revisiting semi-supervised learning with graph embeddings. In: Proceedings of the 33rd International Conference on Machine Learning (ICML), pp. 40–48 (2016)arxiv.org/abs/1603.08861
  43. [44]Sironi, A., Brambilla, M., Bourdis, N., Lagorce, X., Benosman, R.: Hats: Histograms of averaged time surfaces for robust event-based object classification. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1731–1740. IEEE, ??? (2018). https://doi.org/10.1109/CVPR.2018.00186
  44. [45]Diehl, P.U., Cook, M.: Unsupervised learning of digit recognition using spike-timing-dependent plasticity. Frontiers in Computational Neuroscience 9, 99 (2015) https://doi.org/10.3389/fncom.2015.00099
  45. [46]Lagorce, X., Orchard, G., Galluppi, F., Shi, B.E., Benosman, R.B.: Hots: A hierarchy of event-based time-surfaces for pattern recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence 39(7), 1346–1359 (2017) https://doi.org/10.1109/TPAMI.2016.2574707
  46. [47]Bi, Y., Chadha, A., Abbas, A., Bourtsoulatze, E., Andreopoulos, Y.: Graph-based object classification for neuromorphic vision sensing. In: Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 491–501 (2019). https://doi.org/10.1109/ICCV.2019.00058
  47. [48]Sedgewick, R., Wayne, K.: DijkstraSP.java: Dijkstra’s Shortest Path Algorithm. https://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/DijkstraSP.java.html. Part of the Algorithms, 4th Edition codebase. Accessed: 2026-08-02

Paper details

vlnc:W_w9wq2d6h
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 10

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents