{ "cells": [ { "cell_type": "markdown", "id": "7990444df7514d07", "metadata": {}, "source": [ "# Simulating asynchronous or Gamma oscillations using AdEx neurons in ``brainpy.state``\n", "\n", "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/chaobrain/brain-modeling-ecosystem/blob/main/docs/brainpy_spiking_gamma_oscillations.ipynb)\n", "[![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/chaobrain/brain-modeling-ecosystem/blob/main/docs/brainpy_spiking_gamma_oscillations.ipynb)" ] }, { "cell_type": "markdown", "id": "ec60919cbef225dc", "metadata": {}, "source": [ "Implementation of the paper:\n", "\n", "- Susin, Eduarda, and Alain Destexhe. “Integration, coincidence detection and resonance in networks of spiking neurons expressing gamma oscillations and asynchronous states.” PLoS computational biology 17.9 (2021): e1009416. [https://pmc.ncbi.nlm.nih.gov/articles/PMC8478196/](https://pmc.ncbi.nlm.nih.gov/articles/PMC8478196/)" ] }, { "cell_type": "code", "execution_count": 19, "id": "5f51dbe53760f90a", "metadata": {}, "outputs": [], "source": [ "import braintools\n", "import brainstate\n", "import brainpy.state\n", "import brainunit as u\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from scipy.signal import kaiserord, lfilter, firwin, hilbert" ] }, { "cell_type": "markdown", "id": "8e9c180b917e6c59", "metadata": {}, "source": [ "## Parameters" ] }, { "cell_type": "code", "execution_count": 20, "id": "260c41400daa5498", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:02.115383Z", "start_time": "2025-09-16T13:08:02.108620Z" } }, "outputs": [], "source": [ "# Table 1: specific neuron model parameters\n", "RS_par = dict(\n", " Vth=-40 * u.mV, delta=2. * u.mV, tau_ref=5. * u.ms, tau_w=500 * u.ms,\n", " a=4 * u.nS, b=20 * u.pA, C=150 * u.pF, gL=10 * u.nS, EL=-65 * u.mV, V_reset=-65 * u.mV,\n", " E_e=0. * u.mV, E_i=-80. * u.mV\n", ")\n", "FS_par = dict(\n", " Vth=-47.5 * u.mV, delta=0.5 * u.mV, tau_ref=5. * u.ms, tau_w=500 * u.ms,\n", " a=0 * u.nS, b=0 * u.pA, C=150 * u.pF, gL=10 * u.nS, EL=-65 * u.mV, V_reset=-65 * u.mV,\n", " E_e=0. * u.mV, E_i=-80. * u.mV\n", ")\n", "Ch_par = dict(\n", " Vth=-47.5 * u.mV, delta=0.5 * u.mV, tau_ref=1. * u.ms, tau_w=50 * u.ms,\n", " a=80 * u.nS, b=150 * u.pA, C=150 * u.pF, gL=10 * u.nS, EL=-58 * u.mV, V_reset=-65 * u.mV,\n", " E_e=0. * u.mV, E_i=-80. * u.mV,\n", ")" ] }, { "cell_type": "markdown", "id": "5871ee35fcf5fd6", "metadata": {}, "source": [ "## Neuron model" ] }, { "cell_type": "code", "execution_count": 21, "id": "26247f936435827e", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:02.150205Z", "start_time": "2025-09-16T13:08:02.137036Z" } }, "outputs": [], "source": [ "class AdEx(brainpy.state.Neuron):\n", " def __init__(\n", " self,\n", " in_size,\n", " # neuronal parameters\n", " Vth=-40 * u.mV, delta=2. * u.mV, tau_ref=5. * u.ms, tau_w=500 * u.ms,\n", " a=4 * u.nS, b=20 * u.pA, C=150 * u.pF,\n", " gL=10 * u.nS, EL=-65 * u.mV, V_reset=-65 * u.mV, V_sp_th=-40. * u.mV,\n", " # synaptic parameters\n", " tau_e=1.5 * u.ms, tau_i=7.5 * u.ms, E_e=0. * u.mV, E_i=-80. * u.mV,\n", " # other parameters\n", " V_initializer=braintools.init.Uniform(-65., -50., unit=u.mV),\n", " w_initializer=braintools.init.Constant(0. * u.pA),\n", " ge_initializer=braintools.init.Constant(0. * u.nS),\n", " gi_initializer=braintools.init.Constant(0. * u.nS),\n", " ):\n", " super().__init__(in_size=in_size)\n", "\n", " # neuronal parameters\n", " self.Vth = Vth\n", " self.delta = delta\n", " self.tau_ref = tau_ref\n", " self.tau_w = tau_w\n", " self.a = a\n", " self.b = b\n", " self.C = C\n", " self.gL = gL\n", " self.EL = EL\n", " self.V_reset = V_reset\n", " self.V_sp_th = V_sp_th\n", "\n", " # synaptic parameters\n", " self.tau_e = tau_e\n", " self.tau_i = tau_i\n", " self.E_e = E_e\n", " self.E_i = E_i\n", "\n", " # other parameters\n", " self.V_initializer = V_initializer\n", " self.w_initializer = w_initializer\n", " self.ge_initializer = ge_initializer\n", " self.gi_initializer = gi_initializer\n", "\n", " def init_state(self):\n", " # neuronal variables\n", " self.V = brainstate.HiddenState(braintools.init.param(self.V_initializer, self.varshape))\n", " self.w = brainstate.HiddenState(braintools.init.param(self.w_initializer, self.varshape))\n", " self.t_last_spike = brainstate.HiddenState(braintools.init.param(braintools.init.Constant(-1e7 * u.ms), self.varshape))\n", " self.spike = brainstate.HiddenState(braintools.init.param(lambda s: u.math.zeros(s, bool), self.varshape))\n", "\n", " # synaptic parameters\n", " self.ge = brainstate.HiddenState(braintools.init.param(self.ge_initializer, self.varshape))\n", " self.gi = brainstate.HiddenState(braintools.init.param(self.gi_initializer, self.varshape))\n", "\n", " def dV(self, V, w, ge, gi, Iext):\n", " I = ge * (self.E_e - V) + gi * (self.E_i - V)\n", " Iext = self.sum_current_inputs(Iext)\n", " dVdt = (self.gL * self.delta * u.math.exp((V - self.Vth) / self.delta)\n", " - w + self.gL * (self.EL - V) + I + Iext) / self.C\n", " return dVdt\n", "\n", " def dw(self, w, V):\n", " dwdt = (self.a * (V - self.EL) - w) / self.tau_w\n", " return dwdt\n", "\n", " def update(self, x=0. * u.pA):\n", " # numerical integration\n", " ge = brainstate.nn.exp_euler_step(lambda g: -g / self.tau_e, self.ge.value)\n", " ge = self.sum_delta_inputs(ge, label='ge')\n", " gi = brainstate.nn.exp_euler_step(lambda g: -g / self.tau_i, self.gi.value)\n", " gi = self.sum_delta_inputs(gi, label='gi')\n", " V = brainstate.nn.exp_euler_step(self.dV, self.V.value, self.w.value, self.ge.value, self.gi.value, x)\n", " V = self.sum_delta_inputs(V, label='V')\n", " w = brainstate.nn.exp_euler_step(self.dw, self.w.value, self.V.value)\n", " # spike detection\n", " t = brainstate.environ.get('t')\n", " refractory = (t - self.t_last_spike.value) <= self.tau_ref\n", " V = u.math.where(refractory, self.V.value, V)\n", " spike = V >= self.V_sp_th\n", " self.V.value = u.math.where(spike, self.V_reset, V)\n", " self.w.value = u.math.where(spike, w + self.b, w)\n", " self.ge.value = ge\n", " self.gi.value = gi\n", " self.spike.value = spike\n", " self.t_last_spike.value = u.math.where(spike, t, self.t_last_spike.value)\n", " return spike\n" ] }, { "cell_type": "markdown", "id": "e9b74d45c10ea321", "metadata": {}, "source": [ "## Utility functions" ] }, { "cell_type": "code", "execution_count": 22, "id": "c510957bcb627132", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:02.200739Z", "start_time": "2025-09-16T13:08:02.186292Z" } }, "outputs": [], "source": [ "def get_inputs(c_low, c_high, t_transition, t_min_plato, t_max_plato, t_gap, t_total):\n", " t = 0\n", " dt = brainstate.environ.get_dt()\n", " num_gap = int(t_gap / dt)\n", " num_total = int(t_total / dt)\n", " num_transition = int(t_transition / dt)\n", "\n", " inputs = []\n", " ramp_up = u.math.linspace(c_low, c_high, num_transition)\n", " ramp_down = u.math.linspace(c_high, c_low, num_transition)\n", " plato_base = u.math.ones(num_gap) * c_low\n", " while t < num_total:\n", " num_plato = int(brainstate.random.uniform(low=t_min_plato, high=t_max_plato) / dt)\n", " inputs.extend([plato_base, ramp_up, np.ones(num_plato) * c_high, ramp_down])\n", " t += (num_gap + num_transition + num_plato + num_transition)\n", " return u.math.concatenate(inputs)[:num_total]\n", "\n", "\n", "def signal_phase_by_Hilbert(signal, signal_time, low_cut, high_cut, sampling_space):\n", " # sampling_space: in seconds (no units)\n", " # signal_time: in seconds (no units)\n", " # low_cut: in Hz (no units)(band to filter)\n", " # high_cut: in Hz (no units)(band to filter)\n", "\n", " signal = signal - np.mean(signal)\n", " width = 5.0 # The desired width in Hz of the transition from pass to stop\n", " ripple_db = 60.0 # The desired attenuation in the stop band, in dB.\n", " sampling_rate = 1. / sampling_space\n", " Nyquist = sampling_rate / 2.\n", "\n", " num_taps, beta = kaiserord(ripple_db, width / Nyquist)\n", " if num_taps % 2 == 0:\n", " num_taps = num_taps + 1 # Numtaps must be odd\n", " taps = firwin(num_taps, [low_cut / Nyquist, high_cut / Nyquist], window=('kaiser', beta),\n", " pass_zero=False, scale=True)\n", " filtered_signal = lfilter(taps, 1.0, signal)\n", " delay = 0.5 * (num_taps - 1) / sampling_rate # To corrected to zero-phase\n", " delay_index = int(np.floor(delay * sampling_rate))\n", " filtered_signal = filtered_signal[num_taps - 1:] # taking out the \"corrupted\" signal\n", " # correcting the delay and taking out the \"corrupted\" signal part\n", " filtered_time = signal_time[num_taps - 1:] - delay\n", " cutted_signal = signal[(num_taps - 1 - delay_index): (len(signal) - (num_taps - 1 - delay_index))]\n", "\n", " # --------------------------------------------------------------------------\n", " # The hilbert transform are very slow when the signal has odd lenght,\n", " # This part check if the length is odd, and if this is the case it adds a zero in the end\n", " # of all the vectors related to the filtered Signal:\n", " if len(filtered_signal) % 2 != 0: # If the lengh is odd\n", " tmp1 = filtered_signal.tolist()\n", " tmp1.append(0)\n", " tmp2 = filtered_time.tolist()\n", " tmp2.append((len(filtered_time) + 1) * sampling_space + filtered_time[0])\n", " tmp3 = cutted_signal.tolist()\n", " tmp3.append(0)\n", " filtered_signal = np.asarray(tmp1)\n", " filtered_time = np.asarray(tmp2)\n", " cutted_signal = np.asarray(tmp3)\n", " # --------------------------------------------------------------------------\n", "\n", " ht_filtered_signal = hilbert(filtered_signal)\n", " envelope = np.abs(ht_filtered_signal)\n", " phase = np.angle(ht_filtered_signal) # The phase is between -pi and pi in radians\n", "\n", " return filtered_time, filtered_signal, cutted_signal, envelope, phase\n", "\n", "\n", "def visualize_simulation_results(\n", " times, spikes, example_potentials, varied_rates,\n", " xlim=None, t_lfp_start=None, t_lfp_end=None, filename=None\n", "):\n", " times = times.to_decimal(u.ms)\n", " varied_rates = varied_rates.to_decimal(u.Hz)\n", " example_potentials = {k: v.to_decimal(u.mV) for k, v in example_potentials.items()}\n", "\n", " fig, gs = braintools.visualize.get_figure(7, 1, 1, 12)\n", " # 1. input firing rate\n", " ax = fig.add_subplot(gs[0])\n", " plt.plot(times, varied_rates)\n", " if xlim is None:\n", " xlim = (0, times[-1])\n", " else:\n", " xlim = (xlim[0].to_decimal(u.ms), xlim[1].to_decimal(u.ms))\n", " ax.set_xlim(*xlim)\n", " ax.set_xticks([])\n", " ax.set_ylabel('External\\nRate (Hz)')\n", "\n", " # 2. inhibitory cell rater plot\n", " ax = fig.add_subplot(gs[1: 3])\n", " i = 0\n", " y_ticks = ([], [])\n", " for key, (sp_matrix, sp_type) in spikes.items():\n", " iis, sps = np.where(sp_matrix)\n", " tts = times[iis]\n", " plt.scatter(tts, sps + i, s=1, label=key)\n", " y_ticks[0].append(i + sp_matrix.shape[1] / 2)\n", " y_ticks[1].append(key)\n", " i += sp_matrix.shape[1]\n", " ax.set_xlim(*xlim)\n", " ax.set_xlabel('')\n", " ax.set_ylabel('Neuron Index')\n", " ax.set_xticks([])\n", " ax.set_yticks(*y_ticks)\n", "\n", " # 3. example membrane potential\n", " ax = fig.add_subplot(gs[3: 5])\n", " for key, potential in example_potentials.items():\n", " vs = np.where(spikes[key][0][:, 0], 0, potential)\n", " plt.plot(times, vs, label=key)\n", " ax.set_xlim(*xlim)\n", " ax.set_xticks([])\n", " ax.set_ylabel('V (mV)')\n", " ax.legend()\n", "\n", " # 4. LFP\n", " ax = fig.add_subplot(gs[5:7])\n", " ax.set_xlim(*xlim)\n", " t1 = int(t_lfp_start / brainstate.environ.get_dt()) if t_lfp_start is not None else 0\n", " t2 = int(t_lfp_end / brainstate.environ.get_dt()) if t_lfp_end is not None else len(times)\n", " times = times[t1: t2]\n", " lfp = 0\n", " for sp_matrix, sp_type in spikes.values():\n", " lfp += braintools.metric.unitary_LFP(times, sp_matrix[t1: t2], sp_type)\n", " phase_ts, filtered, cutted, envelope, _ = signal_phase_by_Hilbert(\n", " lfp, times * 1e-3, 30, 50, brainstate.environ.get_dt() / u.second\n", " )\n", " plt.plot(phase_ts * 1e3, cutted, color='k', label='Raw LFP')\n", " plt.plot(phase_ts * 1e3, filtered, color='orange', label=\"Filtered LFP (30-50 Hz)\")\n", " plt.plot(phase_ts * 1e3, envelope, color='purple', label=\"Hilbert Envelope\")\n", " plt.legend(loc='best')\n", " plt.xlabel('Time (ms)')\n", "\n", " # save or show\n", " if filename:\n", " plt.savefig(filename, dpi=500)\n", " plt.show()" ] }, { "cell_type": "markdown", "id": "534325aac042b043", "metadata": {}, "source": [ "## Neuron dynamics simulation" ] }, { "cell_type": "code", "execution_count": 23, "id": "1b6cb9cfc0a69309", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:02.249100Z", "start_time": "2025-09-16T13:08:02.242242Z" } }, "outputs": [], "source": [ "def simulate_adex_neuron(ax_v, ax_I, pars, title):\n", " with brainstate.environ.context(dt=0.1 * u.ms):\n", " # neuron\n", " adex = brainstate.nn.init_all_states(AdEx(1, **pars))\n", "\n", " def run_step(t, x):\n", " with brainstate.environ.context(t=t):\n", " adex.update(x)\n", " return adex.V.value\n", "\n", " # simulation\n", " duration = 1.5e3 * u.ms\n", " times = u.math.arange(0. * u.ms, duration, brainstate.environ.get_dt())\n", " inputs = get_inputs(0. * u.nA, 0.5 * u.nA, t_transition=50. * u.ms,\n", " t_min_plato=500 * u.ms, t_max_plato=500 * u.ms,\n", " t_gap=500 * u.ms, t_total=duration)\n", " vs = brainstate.transform.for_loop(run_step, times, inputs, pbar=brainstate.transform.ProgressBar(10))\n", "\n", " # visualization\n", " ax_v.plot(times.to_decimal(u.ms), vs.to_decimal(u.mV))\n", " ax_v.set_title(title)\n", " ax_v.set_ylabel('V (mV)')\n", " ax_v.set_xlim(0.4 * u.second / u.ms, 1.2 * u.second / u.ms)\n", "\n", " ax_I.plot(times.to_decimal(u.ms), inputs.to_decimal(u.nA))\n", " ax_I.set_ylabel('I (nA)')\n", " ax_I.set_xlabel('Time (ms)')\n", " ax_I.set_xlim(0.4 * u.second / u.ms, 1.2 * u.second / u.ms)\n", "\n", "\n", "def simulate_adex_neurons():\n", " fig, gs = braintools.visualize.get_figure(2, 3, 4, 6)\n", " simulate_adex_neuron(fig.add_subplot(gs[0, 0]), fig.add_subplot(gs[1, 0]), RS_par, 'Regular Spiking')\n", " simulate_adex_neuron(fig.add_subplot(gs[0, 1]), fig.add_subplot(gs[1, 1]), FS_par, 'Fast Spiking')\n", " simulate_adex_neuron(fig.add_subplot(gs[0, 2]), fig.add_subplot(gs[1, 2]), Ch_par, 'Chattering')\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 24, "id": "4165b0187918af52", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:04.555721Z", "start_time": "2025-09-16T13:08:02.293560Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9120c1bb6ff445798f43c320e371dfe5", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/15000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simulate_adex_neurons()" ] }, { "cell_type": "markdown", "id": "9c8289ee6cbfa319", "metadata": {}, "source": [ "## PING Network for Generating Gamma Oscillation" ] }, { "cell_type": "code", "execution_count": 25, "id": "f75291d03bd6492a", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:07.171700Z", "start_time": "2025-09-16T13:08:07.162519Z" } }, "outputs": [], "source": [ "class PINGNet(brainstate.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " self.num_exc = 20000\n", " self.num_inh = 5000\n", " self.exc_syn_tau = 1. * u.ms\n", " self.inh_syn_tau = 7.5 * u.ms\n", " self.exc_syn_weight = 5. * u.nS\n", " self.inh_syn_weight = 3.34 * u.nS\n", " self.ext_weight = 4. * u.nS\n", " self.delay = 1.5 * u.ms\n", "\n", " # neuronal populations\n", " RS_par_ = RS_par.copy()\n", " FS_par_ = FS_par.copy()\n", " RS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " FS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " self.rs_pop = AdEx(self.num_exc, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **RS_par_)\n", " self.fs_pop = AdEx(self.num_inh, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **FS_par_)\n", " self.ext_pop = brainpy.state.PoissonEncoder(self.num_exc)\n", "\n", " # Poisson inputs\n", " self.ext_to_FS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_inh, 0.02, self.ext_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.ext_to_RS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_exc, 0.02, self.ext_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", "\n", " # synaptic projections\n", " self.RS_to_FS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_inh, 0.02, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.RS_to_RS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_exc, 0.02, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", " self.FS_to_RS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_inh, self.num_exc, 0.02, self.inh_syn_weight),\n", " post=self.rs_pop,\n", " label='gi'\n", " )\n", " self.FS_to_FS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_inh, self.num_inh, 0.02, self.inh_syn_weight),\n", " post=self.fs_pop,\n", " label='gi'\n", " )\n", "\n", " def update(self, i, t, freq):\n", " with brainstate.environ.context(t=t, i=i):\n", " ext_spikes = self.ext_pop(freq)\n", " self.ext_to_FS(ext_spikes)\n", " self.ext_to_RS(ext_spikes)\n", "\n", " self.RS_to_RS()\n", " self.RS_to_FS()\n", "\n", " self.FS_to_RS()\n", " self.FS_to_FS()\n", "\n", " self.rs_pop()\n", " self.fs_pop()\n", "\n", " return {\n", " 'FS.V0': self.fs_pop.V.value[0],\n", " 'RS.V0': self.rs_pop.V.value[0],\n", " 'FS.spike': self.fs_pop.spike.value,\n", " 'RS.spike': self.rs_pop.spike.value\n", " }" ] }, { "cell_type": "code", "execution_count": 26, "id": "2c5893a684e206b8", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:08:07.289100Z", "start_time": "2025-09-16T13:08:07.283400Z" } }, "outputs": [], "source": [ "def simulate_ping_net():\n", " with brainstate.environ.context(dt=0.1 * u.ms):\n", " # inputs\n", " duration = 6e3 * u.ms\n", " varied_rates = get_inputs(2. * u.Hz, 3. * u.Hz, 50. * u.ms, 3150 * u.ms, 600 * u.ms, 1e3 * u.ms, duration)\n", "\n", " # network\n", " net = brainstate.nn.init_all_states(PINGNet())\n", "\n", " # simulation\n", " times = u.math.arange(0. * u.ms, duration, brainstate.environ.get_dt())\n", " indices = u.math.arange(0, len(times))\n", " returns = brainstate.transform.for_loop(net.update, indices, times, varied_rates,\n", " pbar=brainstate.transform.ProgressBar(100))\n", "\n", " # visualization\n", " visualize_simulation_results(\n", " times=times,\n", " spikes={'FS': (returns['FS.spike'], 'inh'),\n", " 'RS': (returns['RS.spike'], 'exc')},\n", " example_potentials={'FS': returns['FS.V0'],\n", " 'RS': returns['RS.V0']},\n", " varied_rates=varied_rates,\n", " xlim=(2e3 * u.ms, 3.4e3 * u.ms),\n", " t_lfp_start=1e3 * u.ms,\n", " t_lfp_end=5e3 * u.ms\n", " )" ] }, { "cell_type": "code", "execution_count": 27, "id": "6a838e74781bb", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:09:08.926220Z", "start_time": "2025-09-16T13:08:07.454591Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a397d2bbf9954211853254ea9d0c9297", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/60000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simulate_ping_net()" ] }, { "cell_type": "markdown", "id": "48b1be8554203784", "metadata": {}, "source": [ "## ING Network for Generating Gamma Oscillation" ] }, { "cell_type": "code", "execution_count": 28, "id": "430c28e4919d54ac", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:09:09.065379Z", "start_time": "2025-09-16T13:09:09.043229Z" } }, "outputs": [], "source": [ "class INGNet(brainstate.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " self.num_rs = 20000\n", " self.num_fs = 4000\n", " self.num_fs2 = 1000\n", " self.exc_syn_tau = 5. * u.ms\n", " self.inh_syn_tau = 5. * u.ms\n", " self.ext_weight = 0.9 * u.nS\n", " self.exc_syn_weight = 1. * u.nS\n", " self.inh_syn_weight = 5. * u.nS\n", " self.delay = 1.5 * u.ms\n", "\n", " # neuronal populations\n", " RS_par_ = RS_par.copy()\n", " FS_par_ = FS_par.copy()\n", " FS2_par_ = FS_par.copy()\n", " RS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " FS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " FS2_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " self.rs_pop = AdEx(self.num_rs, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **RS_par_)\n", " self.fs_pop = AdEx(self.num_fs, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **FS_par_)\n", " self.fs2_pop = AdEx(self.num_fs2, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **FS2_par_)\n", " self.ext_pop = brainpy.state.PoissonEncoder(self.num_rs)\n", "\n", " # Poisson inputs\n", " self.ext_to_FS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs, 0.02, self.ext_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.ext_to_RS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_rs, 0.02, self.ext_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", " self.ext_to_RS2 = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs2, 0.02, self.ext_weight),\n", " post=self.fs2_pop,\n", " label='ge'\n", " )\n", "\n", " # synaptic projections\n", " self.RS_to_FS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs, 0.02, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.RS_to_RS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_rs, 0.02, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", " self.RS_to_FS2 = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs2, 0.15, self.exc_syn_weight),\n", " post=self.fs2_pop,\n", " label='ge'\n", " )\n", "\n", " self.FS_to_RS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_rs, 0.02, self.inh_syn_weight),\n", " post=self.rs_pop,\n", " label='gi'\n", " )\n", " self.FS_to_FS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_fs, 0.02, self.inh_syn_weight),\n", " post=self.fs_pop,\n", " label='gi'\n", " )\n", " self.FS_to_FS2 = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_fs2, 0.03, self.inh_syn_weight),\n", " post=self.fs2_pop,\n", " label='gi'\n", " )\n", "\n", " self.FS2_to_RS = brainpy.state.DeltaProj(\n", " self.fs2_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs2, self.num_rs, 0.15, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='gi'\n", " )\n", " self.FS2_to_FS = brainpy.state.DeltaProj(\n", " self.fs2_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs2, self.num_fs, 0.15, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='gi'\n", " )\n", " self.FS2_to_FS2 = brainpy.state.DeltaProj(\n", " self.fs2_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs2, self.num_fs2, 0.6, self.exc_syn_weight),\n", " post=self.fs2_pop,\n", " label='gi'\n", " )\n", "\n", " def update(self, i, t, freq):\n", " with brainstate.environ.context(t=t, i=i):\n", " ext_spikes = self.ext_pop(freq)\n", " self.ext_to_FS(ext_spikes)\n", " self.ext_to_RS(ext_spikes)\n", " self.ext_to_RS2(ext_spikes)\n", "\n", " self.RS_to_RS()\n", " self.RS_to_FS()\n", " self.RS_to_FS2()\n", "\n", " self.FS_to_RS()\n", " self.FS_to_FS()\n", " self.FS_to_FS2()\n", "\n", " self.FS2_to_RS()\n", " self.FS2_to_FS()\n", " self.FS2_to_FS2()\n", "\n", " self.rs_pop()\n", " self.fs_pop()\n", " self.fs2_pop()\n", "\n", " return {\n", " 'FS.V0': self.fs_pop.V.value[0],\n", " 'FS2.V0': self.fs2_pop.V.value[0],\n", " 'RS.V0': self.rs_pop.V.value[0],\n", " 'FS.spike': self.fs_pop.spike.value,\n", " 'FS2.spike': self.fs2_pop.spike.value,\n", " 'RS.spike': self.rs_pop.spike.value\n", " }" ] }, { "cell_type": "code", "execution_count": 29, "id": "845aff04ab929f03", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:09:09.098845Z", "start_time": "2025-09-16T13:09:09.088522Z" } }, "outputs": [], "source": [ "def simulate_ing_net():\n", " with brainstate.environ.context(dt=0.1 * u.ms):\n", " # inputs\n", " duration = 6e3 * u.ms\n", " varied_rates = get_inputs(2. * u.Hz, 3. * u.Hz, 50. * u.ms, 350 * u.ms, 600 * u.ms, 1e3 * u.ms, duration)\n", "\n", " # network\n", " net = brainstate.nn.init_all_states(INGNet())\n", "\n", " # simulation\n", " times = u.math.arange(0. * u.ms, duration, brainstate.environ.get_dt())\n", " indices = u.math.arange(0, len(times))\n", " returns = brainstate.transform.for_loop(net.update, indices, times, varied_rates,\n", " pbar=brainstate.transform.ProgressBar(100))\n", "\n", " # visualization\n", " visualize_simulation_results(\n", " times=times,\n", " spikes={'FS': (returns['FS.spike'], 'inh'),\n", " 'FS2': (returns['FS2.spike'], 'inh'),\n", " 'RS': (returns['RS.spike'], 'exc')},\n", " example_potentials={'FS': returns['FS.V0'],\n", " 'FS2': returns['FS2.V0'],\n", " 'RS': returns['RS.V0']},\n", " varied_rates=varied_rates,\n", " xlim=(2e3 * u.ms, 3.4e3 * u.ms),\n", " t_lfp_start=1e3 * u.ms,\n", " t_lfp_end=5e3 * u.ms\n", " )" ] }, { "cell_type": "code", "execution_count": 30, "id": "874f20718be90133", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:06.662307Z", "start_time": "2025-09-16T13:09:09.103854Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "806d8b41fcd24ce3a534191e7c6eebc8", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/60000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simulate_ing_net()" ] }, { "cell_type": "markdown", "id": "c9f57b3b09323ce1", "metadata": {}, "source": [ "## CHING Network for Generating Gamma Oscillation" ] }, { "cell_type": "code", "execution_count": 31, "id": "b6d0242ed300b60d", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:06.741740Z", "start_time": "2025-09-16T13:10:06.713803Z" } }, "outputs": [], "source": [ "class CHINGNet(brainstate.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " self.num_rs = 19000\n", " self.num_fs = 5000\n", " self.num_ch = 1000\n", " self.exc_syn_tau = 5. * u.ms\n", " self.inh_syn_tau = 5. * u.ms\n", " self.exc_syn_weight = 1. * u.nS\n", " self.inh_syn_weight1 = 7. * u.nS\n", " self.inh_syn_weight2 = 5. * u.nS\n", " self.ext_weight1 = 1. * u.nS\n", " self.ext_weight2 = 0.75 * u.nS\n", " self.delay = 1.5 * u.ms\n", "\n", " # neuronal populations\n", " RS_par_ = RS_par.copy()\n", " FS_par_ = FS_par.copy()\n", " Ch_par_ = Ch_par.copy()\n", " RS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " FS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " Ch_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " self.rs_pop = AdEx(self.num_rs, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **RS_par_)\n", " self.fs_pop = AdEx(self.num_fs, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **FS_par_)\n", " self.ch_pop = AdEx(self.num_ch, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **Ch_par_)\n", " self.ext_pop = brainpy.state.PoissonEncoder(self.num_rs)\n", "\n", " # Poisson inputs\n", " self.ext_to_FS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs, 0.02, self.ext_weight2),\n", " post=self.fs_pop,\n", " label='ge',\n", " )\n", " self.ext_to_RS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_rs, 0.02, self.ext_weight1),\n", " post=self.rs_pop,\n", " label='ge',\n", " )\n", " self.ext_to_CH = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_ch, 0.02, self.ext_weight1),\n", " post=self.ch_pop,\n", " label='ge',\n", " )\n", "\n", " # synaptic projections\n", " self.RS_to_FS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_fs, 0.02, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='ge',\n", " )\n", " self.RS_to_RS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_rs, 0.02, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='ge',\n", " )\n", " self.RS_to_Ch = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_rs, self.num_ch, 0.02, self.exc_syn_weight),\n", " post=self.ch_pop,\n", " label='ge',\n", " )\n", "\n", " # inhibitory projections\n", " self.FS_to_RS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_rs, 0.02, self.inh_syn_weight1),\n", " post=self.rs_pop,\n", " label='gi',\n", " )\n", " self.FS_to_FS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_fs, 0.02, self.inh_syn_weight2),\n", " post=self.fs_pop,\n", " label='gi',\n", " )\n", " self.FS_to_Ch = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_fs, self.num_ch, 0.02, self.inh_syn_weight1),\n", " post=self.ch_pop,\n", " label='gi',\n", " )\n", "\n", " # chatter cell projections\n", " self.Ch_to_RS = brainpy.state.DeltaProj(\n", " self.ch_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_ch, self.num_rs, 0.02, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='ge',\n", " )\n", " self.Ch_to_FS = brainpy.state.DeltaProj(\n", " self.ch_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_ch, self.num_fs, 0.02, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='ge',\n", " )\n", " self.Ch_to_Ch = brainpy.state.DeltaProj(\n", " self.ch_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_ch, self.num_ch, 0.02, self.exc_syn_weight),\n", " post=self.ch_pop,\n", " label='ge',\n", " )\n", "\n", " def update(self, i, t, freq):\n", " with brainstate.environ.context(i=i, t=t):\n", " ext_spikes = self.ext_pop(freq)\n", " self.ext_to_FS(ext_spikes)\n", " self.ext_to_RS(ext_spikes)\n", " self.ext_to_CH(ext_spikes)\n", "\n", " self.RS_to_FS()\n", " self.RS_to_RS()\n", " self.RS_to_Ch()\n", "\n", " self.FS_to_RS()\n", " self.FS_to_FS()\n", " self.FS_to_Ch()\n", "\n", " self.Ch_to_RS()\n", " self.Ch_to_FS()\n", " self.Ch_to_Ch()\n", "\n", " self.rs_pop()\n", " self.fs_pop()\n", " self.ch_pop()\n", "\n", " return {\n", " 'FS.V0': self.fs_pop.V.value[0],\n", " 'CH.V0': self.ch_pop.V.value[0],\n", " 'RS.V0': self.rs_pop.V.value[0],\n", " 'FS.spike': self.fs_pop.spike.value,\n", " 'CH.spike': self.ch_pop.spike.value,\n", " 'RS.spike': self.rs_pop.spike.value\n", " }" ] }, { "cell_type": "code", "execution_count": 32, "id": "282b0b61345f8ea0", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:06.863642Z", "start_time": "2025-09-16T13:10:06.856208Z" } }, "outputs": [], "source": [ "def simulate_ching_net():\n", " with brainstate.environ.context(dt=0.1 * u.ms):\n", " # inputs\n", " duration = 6e3 * u.ms\n", " varied_rates = get_inputs(1. * u.Hz, 2. * u.Hz, 50. * u.ms, 150 * u.ms, 600 * u.ms, 1e3 * u.ms, duration)\n", "\n", " # network\n", " net = brainstate.nn.init_all_states(CHINGNet())\n", "\n", " # simulation\n", " times = u.math.arange(0. * u.ms, duration, brainstate.environ.get_dt())\n", " indices = u.math.arange(0, len(times))\n", " returns = brainstate.transform.for_loop(net.update, indices, times, varied_rates,\n", " pbar=brainstate.transform.ProgressBar(100))\n", "\n", " # visualization\n", " visualize_simulation_results(\n", " times=times,\n", " spikes={'FS': (returns['FS.spike'], 'inh'),\n", " 'CH': (returns['CH.spike'], 'exc'),\n", " 'RS': (returns['RS.spike'], 'exc')},\n", " example_potentials={'FS': returns['FS.V0'],\n", " 'CH': returns['CH.V0'],\n", " 'RS': returns['RS.V0']},\n", " varied_rates=varied_rates,\n", " xlim=(2e3 * u.ms, 3.4e3 * u.ms),\n", " t_lfp_start=1e3 * u.ms,\n", " t_lfp_end=5e3 * u.ms\n", " )" ] }, { "cell_type": "code", "execution_count": 33, "id": "9dee53ac11069c40", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:57.993481Z", "start_time": "2025-09-16T13:10:06.870304Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7111d62ab1f84d5db823f62593a7c4a7", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/60000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simulate_ching_net()" ] }, { "cell_type": "markdown", "id": "fea0301280359931", "metadata": {}, "source": [ "## Asynchronous Network State" ] }, { "cell_type": "code", "execution_count": 34, "id": "3b5724da30143044", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:58.076410Z", "start_time": "2025-09-16T13:10:58.065441Z" } }, "outputs": [], "source": [ "class AINet(brainstate.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " self.num_exc = 20000\n", " self.num_inh = 5000\n", " self.exc_syn_tau = 5. * u.ms\n", " self.inh_syn_tau = 5. * u.ms\n", " self.exc_syn_weight = 1. * u.nS\n", " self.inh_syn_weight = 5. * u.nS\n", " self.delay = 1.5 * u.ms\n", " self.ext_weight = 1.0 * u.nS\n", "\n", " # neuronal populations\n", " RS_par_ = RS_par.copy()\n", " FS_par_ = FS_par.copy()\n", " RS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " FS_par_.update(Vth=-50 * u.mV, V_sp_th=-40 * u.mV)\n", " self.fs_pop = AdEx(self.num_inh, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **FS_par_)\n", " self.rs_pop = AdEx(self.num_exc, tau_e=self.exc_syn_tau, tau_i=self.inh_syn_tau, **RS_par_)\n", " self.ext_pop = brainpy.state.PoissonEncoder(self.num_exc)\n", "\n", " # Poisson inputs\n", " self.ext_to_FS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_inh, 0.02, self.ext_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.ext_to_RS = brainpy.state.DeltaProj(\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_exc, 0.02, self.ext_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", "\n", " # synaptic projections\n", " self.RS_to_FS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_inh, 0.02, self.exc_syn_weight),\n", " post=self.fs_pop,\n", " label='ge'\n", " )\n", " self.RS_to_RS = brainpy.state.DeltaProj(\n", " self.rs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_exc, self.num_exc, 0.02, self.exc_syn_weight),\n", " post=self.rs_pop,\n", " label='ge'\n", " )\n", " self.FS_to_FS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_inh, self.num_inh, 0.02, self.inh_syn_weight),\n", " post=self.fs_pop,\n", " label='gi'\n", " )\n", " self.FS_to_RS = brainpy.state.DeltaProj(\n", " self.fs_pop.prefetch('spike').delay.at(self.delay),\n", " comm=brainstate.nn.EventFixedProb(self.num_inh, self.num_exc, 0.02, self.inh_syn_weight),\n", " post=self.rs_pop,\n", " label='gi'\n", " )\n", "\n", " def update(self, i, t, freq):\n", " with brainstate.environ.context(t=t, i=i):\n", " ext_spikes = self.ext_pop(freq)\n", " self.ext_to_FS(ext_spikes)\n", " self.ext_to_RS(ext_spikes)\n", " self.RS_to_RS()\n", " self.RS_to_FS()\n", " self.FS_to_FS()\n", " self.FS_to_RS()\n", " self.rs_pop()\n", " self.fs_pop()\n", " return {\n", " 'FS.V0': self.fs_pop.V.value[0],\n", " 'RS.V0': self.rs_pop.V.value[0],\n", " 'FS.spike': self.fs_pop.spike.value,\n", " 'RS.spike': self.rs_pop.spike.value\n", " }" ] }, { "cell_type": "code", "execution_count": 35, "id": "95a9f45bf54c84b9", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:10:58.169554Z", "start_time": "2025-09-16T13:10:58.163279Z" } }, "outputs": [], "source": [ "def simulate_ai_net():\n", " with brainstate.environ.context(dt=0.1 * u.ms):\n", " # inputs\n", " duration = 2e3 * u.ms\n", " varied_rates = get_inputs(2. * u.Hz, 2. * u.Hz, 50. * u.ms, 150 * u.ms, 600 * u.ms, 1e3 * u.ms, duration)\n", "\n", " # network\n", " net = brainstate.nn.init_all_states(AINet())\n", "\n", " # simulation\n", " times = u.math.arange(0. * u.ms, duration, brainstate.environ.get_dt())\n", " indices = u.math.arange(0, len(times))\n", " returns = brainstate.transform.for_loop(net.update, indices, times, varied_rates, pbar=brainstate.transform.ProgressBar(100))\n", "\n", " # # spike raster plot\n", " # spikes = returns['FS.spike']\n", " # fig, gs = braintools.visualize.get_figure(1, 1, 4., 5.)\n", " # fig.add_subplot(gs[0, 0])\n", " # times2 = times.to_decimal(u.ms)\n", " # t_indices, n_indices = u.math.where(spikes)\n", " # plt.scatter(times2[t_indices], n_indices, s=1, c='k')\n", " # plt.xlabel('Time (ms)')\n", " # plt.ylabel('Neuron index')\n", " # plt.title('Spike raster plot')\n", " # plt.show()\n", "\n", " # visualization\n", " visualize_simulation_results(\n", " times=times,\n", " spikes={'FS': (returns['FS.spike'], 'inh'),\n", " 'RS': (returns['RS.spike'], 'exc')},\n", " example_potentials={'FS': returns['FS.V0'],\n", " 'RS': returns['RS.V0']},\n", " varied_rates=varied_rates\n", " )" ] }, { "cell_type": "code", "execution_count": 36, "id": "12483b78350f572", "metadata": { "ExecuteTime": { "end_time": "2025-09-16T13:11:15.544725Z", "start_time": "2025-09-16T13:10:58.177255Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b63a1f511a72484e95a915454e059ff9", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/20000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "simulate_ai_net()" ] } ], "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 }