{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# *(Li, et. al, 2017)*: Unified Thalamus Oscillation Model\n", "\n", "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/brainpy/examples/blob/main/oscillation_synchronization/Li_2017_unified_thalamus_oscillation_model.ipynb)\n", "[![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/brainpy/examples/blob/main/oscillation_synchronization/Li_2017_unified_thalamus_oscillation_model.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Implementation of the model:\n", "\n", "- Li, Guoshi, Craig S. Henriquez, and Flavio Fröhlich. \"Unified\n", " thalamic model generates multiple distinct oscillations with\n", " state-dependent entrainment by stimulation.\" PLoS computational\n", " biology 13.10 (2017): e1005797." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.734035Z", "start_time": "2023-07-22T03:35:34.890900200Z" } }, "outputs": [], "source": [ "from typing import Dict\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "import brainpy as bp\n", "import brainpy.math as bm\n", "from brainpy import channels, synapses, synouts, synplast\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.751816600Z", "start_time": "2023-07-22T03:35:35.734035Z" }, "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "'2.4.3'" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bp.__version__" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## HTC neuron" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.801156100Z", "start_time": "2023-07-22T03:35:35.751816600Z" } }, "outputs": [], "source": [ "class HTC(bp.CondNeuGroup):\n", " def __init__(self, size, gKL=0.01, V_initializer=bp.init.OneInit(-65.), ):\n", " gL = 0.01 if size == 1 else bp.init.Uniform(0.0075, 0.0125)\n", " IL = channels.IL(size, g_max=gL, E=-70)\n", " IKL = channels.IKL(size, g_max=gKL)\n", " INa = channels.INa_Ba2002(size, V_sh=-30)\n", " IDR = channels.IKDR_Ba2002(size, V_sh=-30., phi=0.25)\n", " Ih = channels.Ih_HM1992(size, g_max=0.01, E=-43)\n", "\n", " ICaL = channels.ICaL_IS2008(size, g_max=0.5)\n", " IAHP = channels.IAHP_De1994(size, g_max=0.3, E=-90.)\n", " ICaN = channels.ICaN_IS2008(size, g_max=0.5)\n", " ICaT = channels.ICaT_HM1992(size, g_max=2.1)\n", " ICaHT = channels.ICaHT_HM1992(size, g_max=3.0)\n", " Ca = channels.CalciumDetailed(size, C_rest=5e-5, tau=10., d=0.5, ICaL=ICaL,\n", " IAHP=IAHP, ICaN=ICaN, ICaT=ICaT, ICaHT=ICaHT)\n", "\n", " super(HTC, self).__init__(size, A=2.9e-4, V_initializer=V_initializer, V_th=20.,\n", " IL=IL, IKL=IKL, INa=INa, IDR=IDR, Ih=Ih, Ca=Ca)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## RTC neuron" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.805057400Z", "start_time": "2023-07-22T03:35:35.772768300Z" } }, "outputs": [], "source": [ "class RTC(bp.CondNeuGroup):\n", " def __init__(self, size, gKL=0.01, V_initializer=bp.init.OneInit(-65.), ):\n", " gL = 0.01 if size == 1 else bp.init.Uniform(0.0075, 0.0125)\n", " IL = channels.IL(size, g_max=gL, E=-70)\n", " IKL = channels.IKL(size, g_max=gKL)\n", " INa = channels.INa_Ba2002(size, V_sh=-40)\n", " IDR = channels.IKDR_Ba2002(size, V_sh=-40, phi=0.25)\n", " Ih = channels.Ih_HM1992(size, g_max=0.01, E=-43)\n", "\n", " ICaL = channels.ICaL_IS2008(size, g_max=0.3)\n", " IAHP = channels.IAHP_De1994(size, g_max=0.1, E=-90.)\n", " ICaN = channels.ICaN_IS2008(size, g_max=0.6)\n", " ICaT = channels.ICaT_HM1992(size, g_max=2.1)\n", " ICaHT = channels.ICaHT_HM1992(size, g_max=0.6)\n", " Ca = channels.CalciumDetailed(size, C_rest=5e-5, tau=10., d=0.5, ICaL=ICaL,\n", " IAHP=IAHP, ICaN=ICaN, ICaT=ICaT, ICaHT=ICaHT)\n", "\n", " super(RTC, self).__init__(size, A=2.9e-4, V_initializer=V_initializer, V_th=20.,\n", " IL=IL, IKL=IKL, INa=INa, IDR=IDR, Ih=Ih, Ca=Ca)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## IN neuron" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.805057400Z", "start_time": "2023-07-22T03:35:35.801898300Z" } }, "outputs": [], "source": [ "class IN(bp.CondNeuGroup):\n", " def __init__(self, size, gKL=0.01, V_initializer=bp.init.OneInit(-70.), ):\n", " gL = 0.01 if size == 1 else bp.init.Uniform(0.0075, 0.0125)\n", " IL = channels.IL(size, g_max=gL, E=-60)\n", " IKL = channels.IKL(size, g_max=gKL)\n", " INa = channels.INa_Ba2002(size, V_sh=-30)\n", " IDR = channels.IKDR_Ba2002(size, V_sh=-30, phi=0.25)\n", " Ih = channels.Ih_HM1992(size, g_max=0.05, E=-43)\n", "\n", " IAHP = channels.IAHP_De1994(size, g_max=0.2, E=-90.)\n", " ICaN = channels.ICaN_IS2008(size, g_max=0.1)\n", " ICaHT = channels.ICaHT_HM1992(size, g_max=2.5)\n", " Ca = channels.CalciumDetailed(size, C_rest=5e-5, tau=10., d=0.5,\n", " IAHP=IAHP, ICaN=ICaN, ICaHT=ICaHT)\n", "\n", " super(IN, self).__init__(size, A=1.7e-4, V_initializer=V_initializer, V_th=20.,\n", " IL=IL, IKL=IKL, INa=INa, IDR=IDR, Ih=Ih, Ca=Ca)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## TRN neuron" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.817068Z", "start_time": "2023-07-22T03:35:35.803913Z" } }, "outputs": [], "source": [ "class TRN(bp.CondNeuGroup):\n", " def __init__(self, size, gKL=0.01, V_initializer=bp.init.OneInit(-70.), ):\n", " gL = 0.01 if size == 1 else bp.init.Uniform(0.0075, 0.0125)\n", " IL = channels.IL(size, g_max=gL, E=-60)\n", " IKL = channels.IKL(size, g_max=gKL)\n", " INa = channels.INa_Ba2002(size, V_sh=-40)\n", " IDR = channels.IKDR_Ba2002(size, V_sh=-40)\n", "\n", " IAHP = channels.IAHP_De1994(size, g_max=0.2, E=-90.)\n", " ICaN = channels.ICaN_IS2008(size, g_max=0.2)\n", " ICaT = channels.ICaT_HP1992(size, g_max=1.3)\n", " Ca = channels.CalciumDetailed(size, C_rest=5e-5, tau=100., d=0.5,\n", " IAHP=IAHP, ICaN=ICaN, ICaT=ICaT)\n", "\n", " super(TRN, self).__init__(size, A=1.43e-4,\n", " V_initializer=V_initializer, V_th=20.,\n", " IL=IL, IKL=IKL, INa=INa, IDR=IDR, Ca=Ca)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Thalamus network" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.836870200Z", "start_time": "2023-07-22T03:35:35.817068Z" } }, "outputs": [], "source": [ "class MgBlock(bp.SynOut):\n", " def __init__(self, E=0.):\n", " super(MgBlock, self).__init__()\n", " self.E = E\n", "\n", " def filter(self, g):\n", " V = self.master.post.V.value\n", " return g * (self.E - V) / (1 + bm.exp(-(V + 25) / 12.5))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.852402300Z", "start_time": "2023-07-22T03:35:35.852402300Z" } }, "outputs": [], "source": [ "class Thalamus(bp.Network):\n", " def __init__(\n", " self,\n", " g_input: Dict[str, float],\n", " g_KL: Dict[str, float],\n", " HTC_V_init=bp.init.OneInit(-65.),\n", " RTC_V_init=bp.init.OneInit(-65.),\n", " IN_V_init=bp.init.OneInit(-70.),\n", " RE_V_init=bp.init.OneInit(-70.),\n", " ):\n", " super(Thalamus, self).__init__()\n", "\n", " # populations\n", " self.HTC = HTC(size=(7, 7), gKL=g_KL['TC'], V_initializer=HTC_V_init)\n", " self.RTC = RTC(size=(12, 12), gKL=g_KL['TC'], V_initializer=RTC_V_init)\n", " self.RE = TRN(size=(10, 10), gKL=g_KL['RE'], V_initializer=IN_V_init)\n", " self.IN = IN(size=(8, 8), gKL=g_KL['IN'], V_initializer=RE_V_init)\n", "\n", " # noises\n", " self.poisson_HTC = bp.neurons.PoissonGroup(self.HTC.size, freqs=100)\n", " self.poisson_RTC = bp.neurons.PoissonGroup(self.RTC.size, freqs=100)\n", " self.poisson_IN = bp.neurons.PoissonGroup(self.IN.size, freqs=100)\n", " self.poisson_RE = bp.neurons.PoissonGroup(self.RE.size, freqs=100)\n", " self.noise2HTC = synapses.Exponential(self.poisson_HTC, self.HTC, bp.conn.One2One(),\n", " output=synouts.COBA(E=0.), tau=5.,\n", " g_max=g_input['TC'])\n", " self.noise2RTC = synapses.Exponential(self.poisson_RTC, self.RTC, bp.conn.One2One(),\n", " output=synouts.COBA(E=0.), tau=5.,\n", " g_max=g_input['TC'])\n", " self.noise2IN = synapses.Exponential(self.poisson_IN, self.IN, bp.conn.One2One(),\n", " output=synouts.COBA(E=0.), tau=5.,\n", " g_max=g_input['IN'])\n", " self.noise2RE = synapses.Exponential(self.poisson_RE, self.RE, bp.conn.One2One(),\n", " output=synouts.COBA(E=0.), tau=5.,\n", " g_max=g_input['RE'])\n", "\n", " # HTC cells were connected with gap junctions\n", " self.gj_HTC = synapses.GapJunction(self.HTC, self.HTC,\n", " bp.conn.ProbDist(dist=2., prob=0.3, ),\n", " comp_method='sparse',\n", " g_max=1e-2)\n", "\n", " # HTC provides feedforward excitation to INs\n", " self.HTC2IN_ampa = synapses.AMPA(self.HTC, self.IN, bp.conn.FixedProb(0.3),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " alpha=0.94,\n", " beta=0.18,\n", " g_max=6e-3)\n", " self.HTC2IN_nmda = synapses.AMPA(self.HTC, self.IN, bp.conn.FixedProb(0.3),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=MgBlock(),\n", " alpha=1.,\n", " beta=0.0067,\n", " g_max=3e-3)\n", "\n", " # INs delivered feedforward inhibition to RTC cells\n", " self.IN2RTC = synapses.GABAa(self.IN, self.RTC, bp.conn.FixedProb(0.3),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=synouts.COBA(E=-80),\n", " alpha=10.5,\n", " beta=0.166,\n", " g_max=3e-3)\n", "\n", " # 20% RTC cells electrically connected with HTC cells\n", " self.gj_RTC2HTC = synapses.GapJunction(self.RTC, self.HTC,\n", " bp.conn.ProbDist(dist=2., prob=0.3, pre_ratio=0.2),\n", " comp_method='sparse',\n", " g_max=1 / 300)\n", "\n", " # Both HTC and RTC cells sent glutamatergic synapses to RE neurons, while\n", " # receiving GABAergic feedback inhibition from the RE population\n", " self.HTC2RE_ampa = synapses.AMPA(self.HTC, self.RE, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " alpha=0.94,\n", " beta=0.18,\n", " g_max=4e-3)\n", " self.RTC2RE_ampa = synapses.AMPA(self.RTC, self.RE, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " alpha=0.94,\n", " beta=0.18,\n", " g_max=4e-3)\n", " self.HTC2RE_nmda = synapses.AMPA(self.HTC, self.RE, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=MgBlock(),\n", " alpha=1.,\n", " beta=0.0067,\n", " g_max=2e-3)\n", " self.RTC2RE_nmda = synapses.AMPA(self.RTC, self.RE, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=MgBlock(),\n", " alpha=1.,\n", " beta=0.0067,\n", " g_max=2e-3)\n", " self.RE2HTC = synapses.GABAa(self.RE, self.HTC, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=synouts.COBA(E=-80),\n", " alpha=10.5,\n", " beta=0.166,\n", " g_max=3e-3)\n", " self.RE2RTC = synapses.GABAa(self.RE, self.RTC, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=synouts.COBA(E=-80),\n", " alpha=10.5,\n", " beta=0.166,\n", " g_max=3e-3)\n", "\n", " # RE neurons were connected with both gap junctions and GABAergic synapses\n", " self.gj_RE = synapses.GapJunction(self.RE, self.RE,\n", " bp.conn.ProbDist(dist=2., prob=0.3, pre_ratio=0.2),\n", " comp_method='sparse',\n", " g_max=1 / 300)\n", " self.RE2RE = synapses.GABAa(self.RE, self.RE, bp.conn.FixedProb(0.2),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=synouts.COBA(E=-70),\n", " alpha=10.5, beta=0.166,\n", " g_max=1e-3)\n", "\n", " # 10% RE neurons project GABAergic synapses to local interneurons\n", " # probability (0.05) was used for the RE->IN synapses according to experimental data\n", " self.RE2IN = synapses.GABAa(self.RE, self.IN, bp.conn.FixedProb(0.05, pre_ratio=0.1),\n", " delay_step=int(2 / bm.get_dt()),\n", " stp=synplast.STD(tau=700, U=0.07),\n", " output=synouts.COBA(E=-80),\n", " alpha=10.5, beta=0.166,\n", " g_max=1e-3, )\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulation" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.868054100Z", "start_time": "2023-07-22T03:35:35.852402300Z" } }, "outputs": [], "source": [ "\n", "states = {\n", " 'delta': dict(g_input={'IN': 1e-4, 'RE': 1e-4, 'TC': 1e-4},\n", " g_KL={'TC': 0.035, 'RE': 0.03, 'IN': 0.01}),\n", " 'spindle': dict(g_input={'IN': 3e-4, 'RE': 3e-4, 'TC': 3e-4},\n", " g_KL={'TC': 0.01, 'RE': 0.02, 'IN': 0.015}),\n", " 'alpha': dict(g_input={'IN': 1.5e-3, 'RE': 1.5e-3, 'TC': 1.5e-3},\n", " g_KL={'TC': 0., 'RE': 0.01, 'IN': 0.02}),\n", " 'gamma': dict(g_input={'IN': 1.5e-3, 'RE': 1.5e-3, 'TC': 1.7e-2},\n", " g_KL={'TC': 0., 'RE': 0.01, 'IN': 0.02}),\n", "}\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.883652800Z", "start_time": "2023-07-22T03:35:35.868054100Z" } }, "outputs": [], "source": [ "\n", "def rhythm_const_input(amp, freq, length, duration, t_start=0., t_end=None, dt=None):\n", " if t_end is None: t_end = duration\n", " if length > duration:\n", " raise ValueError(f'Expected length <= duration, while we got {length} > {duration}')\n", " sec_length = 1e3 / freq\n", " values, durations = [0.], [t_start]\n", " for t in np.arange(t_start, t_end, sec_length):\n", " values.append(amp)\n", " if t + length <= t_end:\n", " durations.append(length)\n", " values.append(0.)\n", " if t + sec_length <= t_end:\n", " durations.append(sec_length - length)\n", " else:\n", " durations.append(t_end - t - length)\n", " else:\n", " durations.append(t_end - t)\n", " values.append(0.)\n", " durations.append(duration - t_end)\n", " return bp.inputs.section_input(values=values, durations=durations, dt=dt, )\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:35.899301500Z", "start_time": "2023-07-22T03:35:35.883652800Z" } }, "outputs": [], "source": [ "\n", "def try_trn_neuron():\n", " trn = TRN(1)\n", " I, length = bp.inputs.section_input(values=[0, -0.05, 0],\n", " durations=[100, 100, 500],\n", " return_length=True,\n", " dt=0.01)\n", " runner = bp.DSRunner(trn,\n", " monitors=['V'],\n", " inputs=['input', I, 'iter'],\n", " dt=0.01)\n", " runner.run(length)\n", "\n", " bp.visualize.line_plot(runner.mon.ts, runner.mon.V, show=True)\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:36.980821500Z", "start_time": "2023-07-22T03:35:35.899301500Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1c4a647ccda44773bbd6c006c62ce2b8", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/70000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "try_trn_neuron()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:36.996009600Z", "start_time": "2023-07-22T03:35:36.984823200Z" } }, "outputs": [], "source": [ "\n", "def try_network(state='delta'):\n", " duration = 3e3\n", " net = Thalamus(\n", " IN_V_init=bp.init.OneInit(-70.),\n", " RE_V_init=bp.init.OneInit(-70.),\n", " HTC_V_init=bp.init.OneInit(-80.),\n", " RTC_V_init=bp.init.OneInit(-80.),\n", " **states[state],\n", " )\n", " net.reset()\n", "\n", " currents = rhythm_const_input(2e-4, freq=4., length=10.,\n", " duration=duration,\n", " t_end=2e3, t_start=1e3)\n", " plt.plot(currents)\n", " plt.title('Current')\n", " plt.show()\n", "\n", " runner = bp.DSRunner(\n", " net,\n", " monitors=['HTC.spike', 'RTC.spike', 'RE.spike', 'IN.spike',\n", " 'HTC.V', 'RTC.V', 'RE.V', 'IN.V', ],\n", " inputs=[('HTC.input', currents, 'iter'),\n", " ('RTC.input', currents, 'iter'),\n", " ('IN.input', currents, 'iter')],\n", " )\n", " runner.run(duration)\n", "\n", " fig, gs = bp.visualize.get_figure(4, 2, 2, 5)\n", " fig.add_subplot(gs[0, 0])\n", " bp.visualize.line_plot(runner.mon.ts, runner.mon.get('HTC.V'), ylabel='HTC', xlim=(0, duration))\n", " fig.add_subplot(gs[1, 0])\n", " bp.visualize.line_plot(runner.mon.ts, runner.mon.get('RTC.V'), ylabel='RTC', xlim=(0, duration))\n", " fig.add_subplot(gs[2, 0])\n", " bp.visualize.line_plot(runner.mon.ts, runner.mon.get('IN.V'), ylabel='IN', xlim=(0, duration))\n", " fig.add_subplot(gs[3, 0])\n", " bp.visualize.line_plot(runner.mon.ts, runner.mon.get('RE.V'), ylabel='RE', xlim=(0, duration))\n", "\n", " fig.add_subplot(gs[0, 1])\n", " bp.visualize.raster_plot(runner.mon.ts, runner.mon.get('HTC.spike'), xlim=(0, duration))\n", " fig.add_subplot(gs[1, 1])\n", " bp.visualize.raster_plot(runner.mon.ts, runner.mon.get('RTC.spike'), xlim=(0, duration))\n", " fig.add_subplot(gs[2, 1])\n", " bp.visualize.raster_plot(runner.mon.ts, runner.mon.get('IN.spike'), xlim=(0, duration))\n", " fig.add_subplot(gs[3, 1])\n", " bp.visualize.raster_plot(runner.mon.ts, runner.mon.get('RE.spike'), xlim=(0, duration))\n", "\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2023-07-22T03:35:45.864470900Z", "start_time": "2023-07-22T03:35:36.997417900Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e4c8590ce3af4c4ab341e23310984126", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/30000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "try_network()" ] } ], "metadata": { "kernelspec": { "display_name": "brainpy", "language": "python", "name": "brainpy" }, "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.9.12" } }, "nbformat": 4, "nbformat_minor": 1 }