{ "cells": [ { "cell_type": "markdown", "id": "b78f6e1b6cb0dada", "metadata": { "collapsed": false }, "source": [ "# Simulating Spiking Neural Networks\n", "\n", "Building and simulating brain dynamics models is one of the important methods for studying brain dynamics. In spiking neural network simulations, we specify the model and input parameters, and conduct simulation experiments. During this process, parameter learning and updates (such as synaptic weights) are not involved. The main purpose is to simulate and analyze the designed network.\n", "\n", "The spiking neural network models of brain dynamics can be divided into **single neuron models** and **neural network models**. We will demonstrate an example for each of these." ] }, { "cell_type": "markdown", "id": "c5622779", "metadata": {}, "source": [ "## Simulation of a Single Neuron Model\n", "\n", "The **Hodgkin-Huxley (HH) model** is a mathematical model proposed in 1952 by neurophysiologists Allen Hodgkin (1914-1998) and Andrew Huxley (1917-2012) to describe the generation and propagation of action potentials in neurons. The HH model is based on the classical electrical circuit model and links the dynamic changes of the neuron membrane potential with the biophysical properties of the membrane ion channels. It is one of the most important theoretical models in neuroscience and earned the two researchers the Nobel Prize in Physiology or Medicine in 1963. The mathematical definition of the HH model is:\n", "\n", "$$\n", "\\begin{aligned}C \\frac {dV} {dt} = -(\\bar{g}_{Na} m^3 h (V &-E_{Na}) + \\bar{g}_K n^4 (V-E_K) + g_{leak} (V - E_{leak})) + I(t)\\\\\n", "\\frac {dx} {dt} &= \\alpha_x (1-x) - \\beta_x, \\quad x\\in {\\rm{\\{m, h, n\\}}}\\\\\n", "&\\alpha_m(V) = \\frac {0.1(V+40)}{1-\\exp(\\frac{-(V + 40)} {10})}\\\\\n", "&\\beta_m(V) = 4.0 \\exp(\\frac{-(V + 65)} {18})\\\\\n", "&\\alpha_h(V) = 0.07 \\exp(\\frac{-(V+65)}{20})\\\\\n", "&\\beta_h(V) = \\frac 1 {1 + \\exp(\\frac{-(V + 35)} {10})}\\\\\n", "&\\alpha_n(V) = \\frac {0.01(V+55)}{1-\\exp(-(V+55)/10)}\\\\\n", "&\\beta_n(V) = 0.125 \\exp(\\frac{-(V + 65)} {80})\\end{aligned}\n", "$$\n", "\n", "In this tutorial, we simulate the HH model as an example of a single neuron model.``brainstate`` can run multiple neuron models in parallel, which saves time. We will simulate a group of HH neurons." ] }, { "cell_type": "code", "execution_count": 1, "id": "9dd07dd9", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.202997Z", "start_time": "2025-10-11T10:18:47.556209Z" } }, "outputs": [], "source": [ "import brainunit as u\n", "import jax.numpy as jnp\n", "import matplotlib.pyplot as plt\n", "\n", "import brainpy\n", "import brainstate" ] }, { "cell_type": "code", "execution_count": 2, "id": "051f8f24", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.210583Z", "start_time": "2025-10-11T10:18:51.207154Z" } }, "outputs": [], "source": [ "# brainstate.environ.set(platform='gpu')" ] }, { "cell_type": "code", "execution_count": 3, "id": "60058528", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.246433Z", "start_time": "2025-10-11T10:18:51.213359Z" } }, "outputs": [], "source": [ "brainstate.random.seed(100)" ] }, { "cell_type": "markdown", "id": "a6ba5685", "metadata": {}, "source": [ "## Defining the Single Neuron Model\n", "\n", "We can use ``brainstate`` to define custom neuron models. To define a custom neuron model, we need to inherit the base class ``brainpy.state.Dynamics``.\n", "\n", "1. First, define the initialization method ``__init__()``. This method receives the number of neurons running in parallel, ``in_size``, and other model parameters. The base class is initialized with ``in_size``, and the model parameters are set as class attributes for easy access.\n", "\n", "2. Then, we can define some common calculations as class methods for later use. Here, we implement functions related to the calculations of m, h, and n. Note that for the drift term function of an ordinary differential equation, the order of the incoming parameters should be, the dynamic variable, the current moment t and the other parameters.\n", "\n", "3. Next, define the state initialization method ``init_state()``. Unlike ``__init__()``, this method initializes the model's state, not the model parameters. The state refers to variables that change during the model's operation. In ``brainstate``, all variables that need to change must be encapsulated in a ``State`` object. The hidden state variables, which change during the model's operation, must be encapsulated in a ``HiddenState`` object (a subclass of ``State``).\n", "\n", "4. Then, define the method to calculate dV. Similar to the functions for m, h, and n, this method defines some commonly used computations as class methods for easy access. However, in this case, the calculation of dV involves the current I. In this example, the neurons are not connected, but the same process can be used for defining neurons in a network. Therefore, ``I = self.sum_current_inputs(I, V)`` includes both external input currents and currents from other neurons.\n", "\n", "5. Finally, define the ``update()`` method, which receives the input for each time step and updates the model variables. ``bst.environ.get('t')`` is used to get the current time t. The ordinary differential equations are solved, and the current values of each variable are obtained using the exponential Euler method ``brainstate.nn.exp_euler_step()`` (where the first argument is the drift term of the ordinary differential equation, and the other arguments are the parameters the equation requires). For neurons in the network, ``V = self.sum_delta_inputs(init=V)`` allows the model to receive inputs from other neurons through delta synaptic transmission. Then, the updated spike information is computed, and the model variables are updated. The output indicates whether the neurons fired an action potential (1 if fired, 0 if not). When using the model, the ``update()`` method is automatically called when the model instance is invoked with input." ] }, { "cell_type": "code", "execution_count": 4, "id": "f08c361a", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.259482Z", "start_time": "2025-10-11T10:18:51.250256Z" } }, "outputs": [], "source": [ "class HH(brainpy.state.Dynamics):\n", " def __init__(\n", " self,\n", " in_size,\n", " ENa=50. * u.mV, gNa=120. * u.mS / u.cm ** 2,\n", " EK=-77. * u.mV, gK=36. * u.mS / u.cm ** 2,\n", " EL=-54.387 * u.mV, gL=0.03 * u.mS / u.cm ** 2,\n", " V_th=20. * u.mV,\n", " C=1.0 * u.uF / u.cm ** 2\n", " ):\n", " # Initialization of the neuron model parameters\n", " super().__init__(in_size)\n", "\n", " # Set model parameters based on provided values or defaults\n", " self.ENa = ENa # Sodium reversal potential (mV)\n", " self.EK = EK # Potassium reversal potential (mV)\n", " self.EL = EL # Leak reversal potential (mV)\n", " self.gNa = gNa # Sodium conductance (mS/cm^2)\n", " self.gK = gK # Potassium conductance (mS/cm^2)\n", " self.gL = gL # Leak conductance (mS/cm^2)\n", " self.C = C # Membrane capacitance (uF/cm^2)\n", " self.V_th = V_th # Threshold for spike (mV)\n", "\n", " # m (sodium activation) channel kinetics\n", " m_alpha = lambda self, V: 1. / u.math.exprel(-(V / u.mV + 40) / 10) # Alpha function for m\n", " m_beta = lambda self, V: 4.0 * jnp.exp(-(V / u.mV + 65) / 18) # Beta function for m\n", " m_inf = lambda self, V: self.m_alpha(V) / (self.m_alpha(V) + self.m_beta(V)) # Steady-state value for m\n", " dm = lambda self, m, t, V: (self.m_alpha(V) * (1 - m) - self.m_beta(V) * m) / u.ms # Rate of change of m\n", "\n", " # h (sodium inactivation) channel kinetics\n", " h_alpha = lambda self, V: 0.07 * jnp.exp(-(V / u.mV + 65) / 20.) # Alpha function for h\n", " h_beta = lambda self, V: 1 / (1 + jnp.exp(-(V / u.mV + 35) / 10)) # Beta function for h\n", " h_inf = lambda self, V: self.h_alpha(V) / (self.h_alpha(V) + self.h_beta(V)) # Steady-state value for h\n", " dh = lambda self, h, t, V: (self.h_alpha(V) * (1 - h) - self.h_beta(V) * h) / u.ms # Rate of change of h\n", "\n", " # n (potassium activation) channel kinetics\n", " n_alpha = lambda self, V: 0.1 / u.math.exprel(-(V / u.mV + 55) / 10) # Alpha function for n\n", " n_beta = lambda self, V: 0.125 * jnp.exp(-(V / u.mV + 65) / 80) # Beta function for n\n", " n_inf = lambda self, V: self.n_alpha(V) / (self.n_alpha(V) + self.n_beta(V)) # Steady-state value for n\n", " dn = lambda self, n, t, V: (self.n_alpha(V) * (1 - n) - self.n_beta(V) * n) / u.ms # Rate of change of n\n", "\n", " def init_state(self, batch_size=None):\n", " # Initialize the state variables for membrane potential (V) and gating variables (m, h, n)\n", " self.V = brainstate.HiddenState(\n", " jnp.ones(self.varshape, brainstate.environ.dftype()) * -65. * u.mV) # Resting potential (mV)\n", " self.m = brainstate.HiddenState(self.m_inf(self.V.value)) # Sodium activation variable\n", " self.h = brainstate.HiddenState(self.h_inf(self.V.value)) # Sodium inactivation variable\n", " self.n = brainstate.HiddenState(self.n_inf(self.V.value)) # Potassium activation variable\n", "\n", " def dV(self, V, t, m, h, n, I):\n", " # Compute the derivative of membrane potential (V) based on the currents and model parameters\n", " I = self.sum_current_inputs(I, V) # Sum of all incoming currents\n", " I_Na = (self.gNa * m * m * m * h) * (V - self.ENa) # Sodium current (I_Na)\n", " n2 = n * n # Squared potassium activation variable\n", " I_K = (self.gK * n2 * n2) * (V - self.EK) # Potassium current (I_K)\n", " I_leak = self.gL * (V - self.EL) # Leak current (I_leak)\n", " dVdt = (- I_Na - I_K - I_leak + I) / self.C # Membrane potential change rate (dV/dt)\n", " return dVdt\n", "\n", " def update(self, x=0. * u.mA / u.cm ** 2):\n", " # Update the state of the neuron based on current inputs and time\n", " t = brainstate.environ.get('t') # Retrieve the current time\n", " V = brainstate.nn.exp_euler_step(\n", " self.dV, self.V.value, t, self.m.value, self.h.value, self.n.value, x\n", " ) # Update membrane potential\n", " m = brainstate.nn.exp_euler_step(self.dm, self.m.value, t, self.V.value) # Update m variable (activation)\n", " h = brainstate.nn.exp_euler_step(self.dh, self.h.value, t, self.V.value) # Update h variable (inactivation)\n", " n = brainstate.nn.exp_euler_step(self.dn, self.n.value, t, self.V.value) # Update n variable (activation)\n", " V = self.sum_delta_inputs(init=V) # Sum the inputs for membrane potential\n", " spike = jnp.logical_and(self.V.value < self.V_th, V >= self.V_th) # Check if a spike occurs\n", " self.V.value = V # Update membrane potential\n", " self.m.value = m # Update m variable\n", " self.h.value = h # Update h variable\n", " self.n.value = n # Update n variable\n", " return spike # Return the spike event (True/False)" ] }, { "cell_type": "markdown", "id": "4bd51608", "metadata": {}, "source": [ "## Running the Model Simulation\n", "\n", "After instantiating the defined model, we need to initialize the instance with ``bst.nn.init_all_states()``.\n", "\n", "Define the model’s time step ``dt``." ] }, { "cell_type": "code", "execution_count": 5, "id": "85dca7b9", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.629871Z", "start_time": "2025-10-11T10:18:51.259482Z" } }, "outputs": [], "source": [ "hh = HH(10)\n", "brainstate.nn.init_all_states(hh)\n", "dt = 0.01 * u.ms" ] }, { "cell_type": "markdown", "id": "aab91f0f", "metadata": {}, "source": [ "Define the function ``run()`` for running the model one step at a time.\n", "\n", "``with bst.environ.context(t=t, dt=dt):``is used to define environment variables within a code block, and variables can be accessed using ``bst.environ.get()`` (e.g., ``bst.environ.get('t')``). This is necessary because we use ``t = bst.environ.get('t')`` inside the ``update()`` method." ] }, { "cell_type": "code", "execution_count": 6, "id": "ef0d23e0", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:51.639659Z", "start_time": "2025-10-11T10:18:51.636718Z" } }, "outputs": [], "source": [ "def run(t, inp):\n", " # Run the simulation for a given time 't' and input current 'inp'\n", " # `brainstate.environ.context` sets the environment context for this simulation step\n", " with brainstate.environ.context(t=t, dt=dt):\n", " hh(inp) # Update the Hodgkin-Huxley model using the input current at time 't'\n", "\n", " # Return the membrane potential at the current time step\n", " return hh.V.value" ] }, { "cell_type": "markdown", "id": "3602f2a4", "metadata": {}, "source": [ "Use ``bst.compile.for_loop()`` to iterate the function and run the simulation for a period of time. The first argument is the function to iterate, followed by the parameters the function needs. You can also display a progress bar during the iteration.\n", "\n", "This completes the simulation of the single neuron model." ] }, { "cell_type": "code", "execution_count": 7, "id": "da2ea460", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:52.223392Z", "start_time": "2025-10-11T10:18:51.644666Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "40dc50bbaa5345598eea2732231fecb5", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/10000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Define the simulation times, from 0 to 100 ms with a time step of 'dt'\n", "times = u.math.arange(0. * u.ms, 100. * u.ms, dt)\n", "\n", "# Run the simulation using `brainstate.transform.for_loop`:\n", "# - `run` function is called iteratively with each time step and random input current\n", "# - Random input current between 1 and 10 uA/cm² is generated at each time step\n", "# - `pbar` is used to show a progress bar during the simulation\n", "vs = brainstate.transform.for_loop(\n", " run,\n", " times, # Time steps as input\n", " brainstate.random.uniform(1., 10., times.shape) * u.uA / u.cm ** 2, # Random input current (1 to 10 uA/cm²)\n", " pbar=brainstate.transform.ProgressBar(count=10)\n", ") # Show progress bar with 10 steps\n", "\n", "# Plot the membrane potential over time\n", "plt.plot(times, vs)\n", "plt.show() # Display the plot" ] }, { "cell_type": "markdown", "id": "c3f5e7c3", "metadata": {}, "source": [ "# Simulation of Spiking Neural Network Models\n", "\n", "One of the goals of neuroscience research is to uncover the possible principles by which the brain encodes information. As a potential encoding rule, we naturally expect neurons to produce the same response to the same stimulus. However, in the 1980s and 1990s, numerous experiments found that when the same external stimulus is presented repeatedly, the spike sequences produced by neurons in the cerebral cortex are different each time, and the spike sequences exhibit highly irregular statistical behaviors. Van Vreeswijk and Haim Sompolinsky proposed the **Excitatory-Inhibitory Balanced Network (E-I balanced network)**. They suggested that there should be both excitatory and inhibitory neurons in the network, and the inputs to both types of neurons must be balanced and counteracting. In this case, the mean input received by the neurons remains very small, and the variance (fluctuation) is large enough to induce irregular firing of neurons. Furthermore, the following conditions must also hold for the network:\n", "+ Neuron connections are random and sparse, which reduces the statistical correlation between the internal inputs received by different neurons, leading to stronger macroscopic irregularity.\n", "+ Statistically, the excitatory inputs and inhibitory inputs received by a neuron should approximately cancel each other out, meaning that the excitation and inhibition transmitted within the network are balanced.\n", "+ The connection strength between neurons within the network is relatively strong, so the activity of the entire network is dominated not by external inputs but by synaptic currents generated by the internal network connections. The random fluctuations in synaptic currents determine the irregular firing of neurons.\n", "\n", "
\n", " \"EI-balance\"\n", "
\n", "\n", "Here, we simulate the Excitatory-Inhibitory Balanced Network model as an example of simulating a spiking neural network model.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "60bc3e45", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:52.230575Z", "start_time": "2025-10-11T10:18:52.227314Z" } }, "outputs": [], "source": [ "import braintools\n", "import brainstate\n", "import brainunit as u\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "2b06bb4b", "metadata": {}, "source": [ "## Defining Spiking Neural Network Model\n", "\n", "We can use ``brainstate`` to define custom neuron models. To define a custom neuron model, we need to inherit the base class ``brainpy.state.DynamicsGroup``.\n", "\n", "1. First, define the initialization method ``__init__()``, which receives model parameters and initializes the model. Note that we need to first call ``super().__init__()`` to initialize the base class. The model initialization mainly includes initializing neurons and synapses:\n", " - **Initializing Neurons**: Neurons in the network can either use the pre-defined neuron models in ``brainpy.state`` or use the custom neurons defined in the **Single Neuron Model Definition** section.\n", " - **Initializing Synapses**: Here, we use ``brainpy.state.AlignPostProj``, which is suitable for the align-post projection model. In the align-post projection, the dimensions of the synaptic variables and the postsynaptic neuron group are the same. The update order of align-post projection models is: action potential → synaptic communication → synaptic dynamics → output. The update order of align-pre projection models is: action potential → synaptic dynamics → synaptic communication → output. Several parameters need to be set:\n", " - ``comm``: Describes the connections between the neuron groups.\n", " - ``syn``: Specifies which synapse model is used.\n", " - ``out``: Indicates whether the output is based on conductance or current.\n", " - ``post``: Specifies the postsynaptic neuron group.\n", "\n", "2. Next, define the ``update()`` method, which receives the input for each time step and updates the model's current state. As a neuron network, neurons need to receive inputs not only from external sources but also from other neurons. Therefore, in this model, we first compute the inputs received from other neurons, then calculate the external inputs. Finally, we output the firing state of each neuron in the entire network." ] }, { "cell_type": "code", "execution_count": 9, "id": "61efc944", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:52.248792Z", "start_time": "2025-10-11T10:18:52.243501Z" } }, "outputs": [], "source": [ "class EINet(brainstate.nn.Module):\n", " def __init__(self, n_exc, n_inh, prob, JE, JI):\n", " # Initialize the network with the following parameters:\n", " # - n_exc: number of excitatory neurons\n", " # - n_inh: number of inhibitory neurons\n", " # - prob: connection probability between neurons\n", " # - JE: synaptic weight for excitatory connections\n", " # - JI: synaptic weight for inhibitory connections\n", " super().__init__()\n", "\n", " self.n_exc = n_exc # Number of excitatory neurons\n", " self.n_inh = n_inh # Number of inhibitory neurons\n", " self.num = n_exc + n_inh # Total number of neurons (excitatory + inhibitory)\n", "\n", " # Initialize the neurons as LIF (Leaky Integrate-and-Fire) neurons\n", " self.N = brainpy.state.LIF(\n", " n_exc + n_inh, # Total number of neurons\n", " V_rest=-52. * u.mV, # Resting potential (mV)\n", " V_th=-50. * u.mV, # Threshold potential for firing (mV)\n", " V_reset=-60. * u.mV, # Reset potential after spike (mV)\n", " tau=10. * u.ms, # Membrane time constant (ms)\n", " V_initializer=braintools.init.Normal(-60., 10., unit=u.mV),\n", " # Initialize membrane potential with a normal distribution\n", " spk_reset='soft' # Soft reset for spiking (reset without forcing a specific value)\n", " )\n", "\n", " # Synapse connections from excitatory neurons to all neurons\n", " self.E = brainpy.state.AlignPostProj(\n", " comm=brainstate.nn.EventFixedProb(n_exc, self.num, prob, JE),\n", " # Fixed probability of synaptic connection with strength JE\n", " syn=brainpy.state.Expon.desc(self.num, tau=2. * u.ms), # Exponential decay of synaptic weight\n", " out=brainpy.state.CUBA.desc(), # CUBA (Conductance-based) synaptic model\n", " post=self.N, # Target neurons for these excitatory synapses\n", " )\n", "\n", " # Synapse connections from inhibitory neurons to all neurons\n", " self.I = brainpy.state.AlignPostProj(\n", " comm=brainstate.nn.EventFixedProb(n_inh, self.num, prob, JI),\n", " # Fixed probability of synaptic connection with strength JI\n", " syn=brainpy.state.Expon.desc(self.num, tau=2. * u.ms), # Exponential decay of synaptic weight\n", " out=brainpy.state.CUBA.desc(), # CUBA (Conductance-based) synaptic model\n", " post=self.N, # Target neurons for these inhibitory synapses\n", " )\n", "\n", " def update(self, inp):\n", " # Get the spike states of the neurons\n", " spks = self.N.get_spike() != 0. # Non-zero spikes (spike detection)\n", "\n", " # Update the synaptic currents for excitatory and inhibitory neurons\n", " self.E(spks[:self.n_exc]) # Apply excitatory synaptic input based on the excitatory neuron spikes\n", " self.I(spks[self.n_exc:]) # Apply inhibitory synaptic input based on the inhibitory neuron spikes\n", "\n", " # Update the neurons with the provided input current (inp)\n", " self.N(inp)\n", "\n", " # Return the spike states of the neurons (whether each neuron spiked)\n", " return self.N.get_spike()" ] }, { "cell_type": "markdown", "id": "3320eacc", "metadata": {}, "source": [ "## Running the Simulation Experiment\n", "\n", "Set some model parameters. In this example, we use the sign (positive or negative) of the connection strength to set the excitatory or inhibitory nature of the neurons." ] }, { "cell_type": "code", "execution_count": 10, "id": "3e1569f5", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:52.278002Z", "start_time": "2025-10-11T10:18:52.253733Z" } }, "outputs": [], "source": [ "# connectivity\n", "num_exc = 500\n", "num_inh = 500\n", "prob = 0.1\n", "# external current\n", "Ib = 3. * u.mA\n", "# excitatory and inhibitory synaptic weights\n", "JE = 1 / u.math.sqrt(prob * num_exc) * u.mS\n", "JI = -1 / u.math.sqrt(prob * num_inh) * u.mS" ] }, { "cell_type": "markdown", "id": "f2c2db9e", "metadata": {}, "source": [ "Define the time step ``dt`` for the simulation.\n", "\n", "After instantiating the defined model, initialize the instance with ``bst.nn.init_all_states()``." ] }, { "cell_type": "code", "execution_count": 11, "id": "3aed3747", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:18:53.355359Z", "start_time": "2025-10-11T10:18:52.284008Z" } }, "outputs": [], "source": [ "# network\n", "brainstate.environ.set(dt=0.1 * u.ms)\n", "net = EINet(num_exc, num_inh, prob=prob, JE=JE, JI=JI)\n", "_ = brainstate.nn.init_all_states(net)" ] }, { "cell_type": "markdown", "id": "0a52aac5", "metadata": {}, "source": [ "The instantiated network model uses the ``update()`` method to input the current for each time step.\n", "\n", "Use ``bst.compile.for_loop()`` to iterate the function and run the simulation for a certain period of time. The first argument is the function to iterate, followed by the parameters that the function requires. You can also display a progress bar during the iteration.\n", "\n", "This completes the simulation of the spiking neural network model." ] }, { "cell_type": "code", "execution_count": 12, "id": "32e8e8ee", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f3137469a0b44410b0e70f4b8c9e657e", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/10000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# visualization\n", "times = times.to_decimal(u.ms)\n", "t_indices, n_indices = u.math.where(spikes)\n", "plt.plot(times[t_indices], n_indices, 'k.', markersize=1)\n", "plt.xlabel('Time (ms)')\n", "plt.ylabel('Neuron index')\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Ecosystem-py", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 5 }