docs/tutorials/repeat_mode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeat Running Mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another simple but powerful function provided in ``BrainPy`` is the repeat running mode of ``brainpy.Network``. This function allows users to run a compiled network model repetitively. Specifically, each ``brainpy.Network`` is instantiated in the repeat mode by default. The parameters and the variables in the step functions can be arbitrarily changed without the need to recompile the network models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeat mode of ``brainpy.Network`` is very useful at least in the following two situations: *parameter searching* and *RAM memory saving*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameter Searching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``Parameter searching`` is one of the most common things in computational modeling. When creating a \n",
    "model, we'll be presented with many parameters to control how our defined model evolves. Often times, \n",
    "we don't immediately know what the optimal parameter set should be for a given model, and thus we'd \n",
    "like to be able to explore a range of possibilities. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately, with the ``repeat`` mode provided in ``brainpy.Network``, parameter searching is a very easy thing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we illustrate this with the example of [gamma oscillation](https://brainmodels.readthedocs.io/en/latest/from_papers/Wang_1996_gamma_oscillation.html), and to see how different value of ``g_max`` (the maximal synaptic conductance) affect the network coherence. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's import the necessary packages and define the models first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import brainpy as bp\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "bp.backend.set('numba', dt=0.04)\n",
    "bp.integrators.set_default_odeint('exponential_euler')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first define the HH neuron model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neuron Group #\n",
    "# ------------ #\n",
    "\n",
    "class HH(bp.NeuGroup):\n",
    "    target_backend = 'general'\n",
    "\n",
    "    def __init__(self, size, ENa=55., EK=-90., EL=-65,\n",
    "                 C=1.0, gNa=35., gK=9., gL=0.1, V_th=20.,\n",
    "                 phi=5.0, **kwargs):\n",
    "        super(HH, self).__init__(size=size, **kwargs)\n",
    "        \n",
    "        # parameters\n",
    "        self.ENa = ENa\n",
    "        self.EK = EK\n",
    "        self.EL = EL\n",
    "        self.C = C\n",
    "        self.gNa = gNa\n",
    "        self.gK = gK\n",
    "        self.gL = gL\n",
    "        self.V_th = V_th\n",
    "        self.phi = phi\n",
    "\n",
    "        # variables\n",
    "        self.V = bp.ops.ones(self.num) * -65.\n",
    "        self.h = bp.ops.ones(self.num) * 0.6\n",
    "        self.n = bp.ops.ones(self.num) * 0.32\n",
    "        self.spike = bp.ops.zeros(self.num, dtype=bool)\n",
    "        self.input = bp.ops.zeros(self.num)\n",
    "\n",
    "    def reset(self):\n",
    "        self.V[:] = -70. + np.random.random(self.num) * 20\n",
    "\n",
    "        h_alpha = 0.07 * np.exp(-(self.V + 58) / 20)\n",
    "        h_beta = 1 / (np.exp(-0.1 * (self.V + 28)) + 1)\n",
    "        self.h[:] = h_alpha / (h_alpha + h_beta)\n",
    "\n",
    "        n_alpha = -0.01 * (self.V + 34) / (np.exp(-0.1 * (self.V + 34)) - 1)\n",
    "        n_beta = 0.125 * np.exp(-(self.V + 44) / 80)\n",
    "        self.n[:] = n_alpha / (n_alpha + n_beta)\n",
    "\n",
    "        self.spike[:] = False\n",
    "        self.input[:] = 0.\n",
    "\n",
    "    @staticmethod\n",
    "    @bp.odeint\n",
    "    def integral(V, h, n, t, Iext, gNa, ENa, gK, EK, gL, EL, C, phi):\n",
    "        alpha = 0.07 * bp.ops.exp(-(V + 58) / 20)\n",
    "        beta = 1 / (bp.ops.exp(-0.1 * (V + 28)) + 1)\n",
    "        dhdt = phi * (alpha * (1 - h) - beta * h)\n",
    "\n",
    "        alpha = -0.01 * (V + 34) / (bp.ops.exp(-0.1 * (V + 34)) - 1)\n",
    "        beta = 0.125 * bp.ops.exp(-(V + 44) / 80)\n",
    "        dndt = phi * (alpha * (1 - n) - beta * n)\n",
    "\n",
    "        m_alpha = -0.1 * (V + 35) / (bp.ops.exp(-0.1 * (V + 35)) - 1)\n",
    "        m_beta = 4 * bp.ops.exp(-(V + 60) / 18)\n",
    "        m = m_alpha / (m_alpha + m_beta)\n",
    "        INa = gNa * m ** 3 * h * (V - ENa)\n",
    "        IK = gK * n ** 4 * (V - EK)\n",
    "        IL = gL * (V - EL)\n",
    "        dVdt = (- INa - IK - IL + Iext) / C\n",
    "\n",
    "        return dVdt, dhdt, dndt\n",
    "\n",
    "    def update(self, _t):\n",
    "        V, h, n = self.integral(self.V, self.h, self.n, _t,\n",
    "                                self.input, self.gNa, self.ENa, self.gK,\n",
    "                                self.EK, self.gL, self.EL, self.C, self.phi)\n",
    "        self.spike = np.logical_and(self.V < self.V_th, V >= self.V_th)\n",
    "        self.V = V\n",
    "        self.h = h\n",
    "        self.n = n\n",
    "        self.input[:] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, the inter-connected synapse GABAA can be defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GABAa Synapse #\n",
    "# ------------- #\n",
    "\n",
    "class GABAa(bp.TwoEndConn):\n",
    "    target_backend = ['numpy', 'numba']\n",
    "\n",
    "    def __init__(self, pre, post, conn, delay=0., E=-75., g_max=0.1,\n",
    "                 alpha=12., beta=0.1, T=1.0, T_duration=1.0, **kwargs):\n",
    "        # parameters\n",
    "        self.E = E\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.T = T\n",
    "        self.T_duration = T_duration\n",
    "        self.delay = delay\n",
    "        self.g_max = g_max\n",
    "\n",
    "        # connections\n",
    "        self.conn = conn(pre.size, post.size)\n",
    "        self.conn_mat = self.conn.requires('conn_mat')\n",
    "        self.num = bp.ops.shape(self.conn_mat)\n",
    "\n",
    "        # variables\n",
    "        self.s = bp.ops.zeros(self.num)\n",
    "        self.t_last_pre_spike = bp.ops.ones(self.num) * -1e7\n",
    "        self.g = self.register_constant_delay('g', size=self.num, delay_time=delay)\n",
    "        \n",
    "        super(GABAa, self).__init__(pre=pre, post=post, **kwargs)\n",
    "\n",
    "    def reset(self):\n",
    "        self.s[:] = 0.\n",
    "        self.t_last_pre_spike[:] = -1e7\n",
    "        self.g.reset()\n",
    "\n",
    "    @staticmethod\n",
    "    @bp.odeint\n",
    "    def int_s(s, t, TT, alpha, beta):\n",
    "        dsdt = alpha * TT * (1 - s) - beta * s\n",
    "        return dsdt\n",
    "\n",
    "    def update(self, _t):\n",
    "        for i in range(self.pre.size[0]):\n",
    "            if self.pre.spike[i] > 0:\n",
    "                self.t_last_pre_spike[i] = _t\n",
    "        TT = ((_t - self.t_last_pre_spike) < self.T_duration) * self.T\n",
    "        self.s = self.int_s(self.s, _t, TT, self.alpha, self.beta)\n",
    "        self.g.push(self.g_max * self.s)\n",
    "        g = self.g.pull()\n",
    "        self.post.input -= bp.ops.sum(g, axis=0) * (self.post.V - self.E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting the HH neuron and the GABA<sub>A</sub> syanpse together, let's define the network in which HH neurons are interconnected with the GABA<sub>A</sub> syanpses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network #\n",
    "# ------- #\n",
    "\n",
    "num = 100\n",
    "\n",
    "group = HH(num, monitors=['spike', 'V'])\n",
    "conn = GABAa(pre=group, post=group, g_max=0.1/num, \n",
    "             conn=bp.connect.All2All(include_self=False))\n",
    "net = bp.Network(group, conn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, by using the [cross correlation](https://en.wikipedia.org/wiki/Cross-correlation) measurement, we can evaluate the network coherence under the different parameter setting of ``g_max``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "lines_to_next_cell": 2,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "When g_max = 0.00050 ...\n",
      "Compilation used 5.6063 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.334 s.\n",
      "Simulation is done in 1.334 s.\n",
      "\n",
      "When g_max = 0.00060 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.332 s.\n",
      "Simulation is done in 1.332 s.\n",
      "\n",
      "When g_max = 0.00070 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.353 s.\n",
      "Simulation is done in 1.353 s.\n",
      "\n",
      "When g_max = 0.00080 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.373 s.\n",
      "Simulation is done in 1.373 s.\n",
      "\n",
      "When g_max = 0.00090 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.354 s.\n",
      "Simulation is done in 1.354 s.\n",
      "\n",
      "When g_max = 0.00100 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.358 s.\n",
      "Simulation is done in 1.358 s.\n",
      "\n",
      "When g_max = 0.00110 ...\n",
      "Compilation used 0.0010 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.364 s.\n",
      "Simulation is done in 1.364 s.\n",
      "\n",
      "When g_max = 0.00120 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.352 s.\n",
      "Simulation is done in 1.352 s.\n",
      "\n",
      "When g_max = 0.00130 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.348 s.\n",
      "Simulation is done in 1.348 s.\n",
      "\n",
      "When g_max = 0.00140 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.350 s.\n",
      "Simulation is done in 1.350 s.\n",
      "\n",
      "When g_max = 0.00150 ...\n",
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 100.0% used 1.353 s.\n",
      "Simulation is done in 1.353 s.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Parameter Searching #\n",
    "# ------------------- #\n",
    "\n",
    "all_g_max = np.arange(0.05, 0.151, 0.01) / num\n",
    "all_cc = []\n",
    "\n",
    "for i, g_max in enumerate(all_g_max):\n",
    "    print('When g_max = {:.5f} ...'.format(g_max))\n",
    "    \n",
    "    group.reset()\n",
    "    conn.reset()\n",
    "\n",
    "    net.run(duration=500., inputs=[group, 'input', 1.2], report=True, report_percent=1.)\n",
    "\n",
    "    cc = bp.measure.cross_correlation(group.mon.spike, bin=0.5)\n",
    "    all_cc.append(cc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the network was only compiled at the fist time run. And the overall speed of the later running does not change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can plot the relationship between the ``g_max`` and network coherence ``cc``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_g_max, all_cc)\n",
    "plt.xlabel('g_max')\n",
    "plt.ylabel('cc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is worthy to note that in this example, before each ``net.run()``, we reset the variable state of the neuron group and the synaptic connection. This is because each repeat run is independent with each other in the case of the parameter tuning. However, in the following example, the current ``net.run()`` relies on the previous network running, the variable state should not be reset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Memory Saving"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another annoyance often occurs is that our computers have limited RAM memory. Once the model size is big, or the running duration is long, ``MemoryError`` usually occurs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, with ``brainpy.Network`` repeat running mode, BrainPy can partially solve this problem by allowing uers to split a long duration into multiple short durations. BrainPy allows user to repeatedly call ``run()``. In this section, we illustrate this function by using the above defined gamma oscillation network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a network with the size of 200 HH neurons, and try to run this network in 2 seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "group2 = HH(200, monitors=['spike', 'V'])\n",
    "group2.reset()\n",
    "\n",
    "conn2 = GABAa(pre=group2, post=group2, g_max=0.1/200,\n",
    "              conn=bp.connect.All2All(include_self=False))\n",
    "net2 = bp.Network(group2, conn2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we do not run the total 1.5 second at one time. On the contrary, we run the model with four steps, with each step of 0.5 second running duration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 2.1291 s.\n",
      "Start running ...\n",
      "Run 50.0% used 2.095 s.\n",
      "Run 100.0% used 4.187 s.\n",
      "Simulation is done in 4.187 s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 1: 0 - 500 ms\n",
    "\n",
    "net2.run(duration=(0., 500.), inputs=[group2, 'input', 1.2], report=True, report_percent=0.5)\n",
    "bp.visualize.raster_plot(group2.mon.spike_t, group2.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 0.0000 s.\n",
      "Start running ...\n",
      "Run 50.0% used 2.128 s.\n",
      "Run 100.0% used 4.249 s.\n",
      "Simulation is done in 4.249 s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEGCAYAAACdJRn3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAX4ElEQVR4nO3df5BlZX3n8fdHUBSiEaRhESEzuKMVlHVkGlYkIhE3gNmIsv6AigazbEZ3sUqj2Q2oJSQb1ggaUxrRGoUVo4IoouwGFUJcibUq9iA/BkbCIAgjI9PgL8yw6MB3/7inw52hu+ee7r59751+v6pu3XOee57zfM9TPfc758d9nlQVkiS18bhBByBJGj0mD0lSayYPSVJrJg9JUmsmD0lSa7sOOoD52HvvvWvZsmWDDkOSRsratWvvq6qx+exjpJPHsmXLmJiYGHQYkjRSkvxgvvvwspUkqTWThySpNZOHJKk1k4ckqbW+JY8kByT5WpL1SW5O8pamfK8kVyW5rXnfs6vOGUk2JLk1ybH9ik2SND/9PPPYCry9qn4TeAFwWpKDgdOBq6tqBXB1s07z2UnAc4DjgPOS7NLH+CRJc9S35FFVm6rqumb5AWA9sD9wAnBhs9mFwCua5ROAi6vqoaq6A9gAHN6v+CRJc7co9zySLAOeD3wb2LeqNkEnwQD7NJvtD9zdVW1jU7b9vlYnmUgyMTk5OeeY7rvvPs4991zuu+8+6w5x2x7zaNQdZNujWHfQbS+IqurrC/g1YC1wYrP+0+0+/0nz/mHgdV3l5wP/YbZ9r1q1qubqzDPPLKDOPPNM6w5x2x7zaNQdZNujWHfQbQMTNc/v9r6eeSR5PHAp8Omq+kJTfG+S/ZrP9wM2N+UbgQO6qj8DuKdfsW3ZsmWbd+sOZ9se82jUHWTbo1h30G0vhH4+bRU6Zw/rq+qvuj66HDilWT4F+FJX+UlJdkuyHFgBXNuv+CRJc9fPsa2OBF4P3JTk+qbsHcBfApckORW4C3g1QFXdnOQS4BY6T2qdVlUP9zE+SdIc9S15VNU3gMzw8TEz1DkbOLtfMUmSFoa/MJcktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktdbPaWgvSLI5ybquss8mub553Tk1w2CSZUke7Prso/2KS5I0f/2chvYTwN8An5wqqKrXTi0neT/ws67tb6+qlX2MR5K0QPo5De01SZZN91mSAK8BXtKv9iVJ/TOoex4vAu6tqtu6ypYn+W6Sryd50UwVk6xOMpFkYnJysv+RSpIeY1DJ42Tgoq71TcCBVfV84G3AZ5I8ZbqKVbWmqsaranxsbGwRQpUkbW/Rk0eSXYETgc9OlVXVQ1V1f7O8FrgdeNZixyZJ6s0gzjxeCnyvqjZOFSQZS7JLs3wQsAL4/gBikyT1oJ+P6l4EfBN4dpKNSU5tPjqJbS9ZARwF3JjkBuDzwJuq6sf9ik2SND/9fNrq5BnK3zBN2aXApf2KRZK0sPyFuSSpNZOHJKk1k4ckqTWThySpNZOHJKk1k4ckqTWThySpNZOHJKk1k4ckqTWThySpNZOHJKk1k4ckqTWThySpNZOHJKk1k4ckqTWThySptX7OJHhBks1J1nWVnZXkh0mub14v6/rsjCQbktya5Nh+xSVJmr9+nnl8AjhumvIPVNXK5nUFQJKD6UxP+5ymznlTc5pLkoZP35JHVV0D9DoP+QnAxVX1UFXdAWwADu9XbJKk+RnEPY83J7mxuay1Z1O2P3B31zYbm7LHSLI6yUSSicnJyX7HKkmaxmInj48AzwRWApuA9zflmWbbmm4HVbWmqsaranxsbKwvQUqSZreoyaOq7q2qh6vqEeBjPHppaiNwQNemzwDuWczYJEm9W9TkkWS/rtVXAlNPYl0OnJRktyTLgRXAtYsZmySpd7v2a8dJLgKOBvZOshE4Ezg6yUo6l6TuBN4IUFU3J7kEuAXYCpxWVQ/3KzZJ0vz0LXlU1cnTFJ8/y/ZnA2f3Kx5J0sLxF+aSpNZMHpKk1kwekqTWTB6SpNZMHpKk1kwekqTWTB6SpNZMHpKk1kwekqTWTB6SpNZMHpKk1kwekqTWdpg8mvnFty87uh/BSJJGQy9nHpck+dN0PCnJh4D39DswSdLw6iV5/Fs6s/z9X+A7dGb4O7KfQUmShlsvyeNXwIPAk4AnAnc008hKkpaoXpLHd+gkj8OA3wJOTvL5HVVKckGSzUnWdZWdm+R7SW5MclmSpzbly5I8mOT65vXRuR2OJGkx9JI8Tq2qd1fVr6rqR1V1AvClHup9Ajhuu7KrgOdW1b8B/gk4o+uz26tqZfN6Uy/BS5IGo5fksTbJ65K8GyDJgcCtO6pUVdcAP96u7Mqq2tqsfgt4Rst4JUlDoJfkcR5wBDA1J/kDwIcXoO3/CHy5a315ku8m+XqSF81UKcnqJBNJJiYnJxcgDElSWz09bVVVpwH/D6CqfgI8YT6NJnknsBX4dFO0CTiwqp4PvA34TJKnTFe3qtZU1XhVjY+Njc0nDEnSHPX0tFWSXYACSDIGzPlpqySnAP8e+P2qKoCqeqiq7m+W1wK3A8+aaxuSpP7qJXl8ELgM2CfJ2cA3gP8xl8aSHAf8KfDyqtrSVT7WJCiSHASsAL4/lzYkSf236442qKpPJ1kLHAMEeEVVrd9RvSQXAUcDeyfZCJxJ5+mq3YCrkgB8q3my6ijgz5NsBR4G3lRVP552x5KkgZsxeSTZq2t1M3BR92c7+nKvqpOnKT5/hm0vBS6dPVRJ0rCY7cxjLZ37HAEOBH7SLD8VuAtY3u/gJEnDacZ7HlW1vKoOAr4K/F5V7V1VT6Nzs/sLixWgJGn49HLD/LCqumJqpaq+DLy4fyFJkobdDm+YA/cleRfwKTqXsV4H3N/XqCRJQ62XM4+TgTE6j+t+EdiHR39tLklagnp5VPfHwFsWIRZJ0ojYYfJI8izgT4Bl3dtX1Uv6F5YkaZj1cs/jc8BHgY/T+QGfJGmJ6yV5bK2qj/Q9EknSyOjlhvn/SvJfkuyXZK+pV98jkyQNrV7OPE5p3v9rV1kBBy18OJKkUdDL01YOQyJJ2sZsAyO+pKr+IcmJ031eVQ5RIklL1GxnHi8G/gH4vWk+KxzfSpKWrBmTR1Wd2bz/4eKFI0kaBb08bTUnSS5IsjnJuq6yvZJcleS25n3Prs/OSLIhya1Jju1XXJKk+etb8gA+ARy3XdnpwNVVtQK4ulknycHAScBzmjrnTU1LK0kaPn1LHlV1DbD9bIMnABc2yxcCr+gqv7iqHqqqO4ANwOH9ik2SND+9/M6DJC/ksWNbfXIO7e1bVZua+puS7NOU7w98q2u7jU2ZJGkI9TIw4t8CzwSu59GxrQqYS/KYsZlpymqGeFYDqwEOPPDABQxBktSrXs48xoGDq2raL/OW7k2yX3PWsR+wuSnfCBzQtd0zgHum20FVrQHWAIyPjy9ETJKklnq557EO+FcL1N7lPDrcySnAl7rKT0qyW5LlwArg2gVqU5K0wHo589gbuCXJtcBDU4VV9fLZKiW5CDga2DvJRuBM4C+BS5KcCtwFvLrZ181JLgFuAbYCp1WVw79L0pDqJXmcNZcdV9VMU9UeM8P2ZwNnz6UtSdLi6mVgxK8n2Rc4rCm6tqo2z1ZHkrRz2+E9jySvoXP/4dXAa4BvJ3lVvwOTJA2vXi5bvRM4bOpsI8kY8PfA5/sZmCRpePXytNXjtrtMdX+P9SRJO6lezjy+kuSrwEXN+muBK/oXkiRp2M2aPJIE+CCdm+W/ReeX4Guq6rJFiE2SNKRmTR5VVUm+WFWr2Mkmf9qyZcs279YdzrY95tGoO8i2R7HuoNteCL3cu/hWksN2vNlouemmm7Z5t+5wtu0xj0bdQbY9inUH3fZC6CV5/DbwzSS3J7kxyU1Jbux3YP12yCGHbPNu3eFs22MejbqDbHsU6w667YXQyw3z4/sexQDsvvvu27xbdzjb9phHo+4g2x7FuoNueyH0kjwcuVaStI1eksff0UkgAZ4ILAdupTNlrCRpCeplbKttLqolORR4Y98ikiQNvda/FK+q63h0kERJ0hLUyzS0b+tafRxwKDDZt4gkSUOvl3seT+5a3krnHsil/QlHkjQKernn8WcASfaoqn+eb4NJng18tqvoIODdwFOBP+LRs5p3VJVjaEnSEOplPo8jktwCrG/Wn5fkvLk2WFW3VtXKqloJrAK2AFNjZX1g6jMThyQNr15umP81cCydodipqhuAoxao/WOA26vqBwu0P0nSIujpaauqunu7oocXqP2TeHSod4A3N0OgXJBkz+kqJFmdZCLJxOSk9+0laRB6SR53J3khUEmekORPaC5hzUeSJwAvBz7XFH0EeCawEtgEvH+6elW1pqrGq2p8bGxsvmFIkuagl+TxJuA0YH9gI50v99MWoO3jgeuq6l6Aqrq3qh6uqkeAjwGHL0AbkqQ+6OVpq/uA3+9D2yfTdckqyX5VtalZfSWwrg9tSpIWwIzJI8m7Z6lXVfXf59pokt2Bf8e2w5yck2QlnXG07sQhUCRpaM125jHdbzr2AE4FngbMOXlU1ZZmH91lr5/r/iRJi2vG5FFV/3LDOsmTgbcAfwhczAw3syVJS8Os9zyS7AW8jc49jwuBQ6vqJ4sRmCRpeM12z+Nc4ERgDXBIVf1i0aKSJA212R7VfTvwdOBdwD1Jft68Hkjy88UJT5I0jGa759F6rg9J0tJggpAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1tsNpaPshyZ3AA8DDwNaqGm+Gf/8ssIzOTIKvcfh3SRpOgzzz+O2qWllV48366cDVVbUCuLpZlyQNoWG6bHUCnQmnaN5fMbhQJEmzGVTyKODKJGuTrG7K9q2qTQDN+z7TVUyyOslEkonJyclFCleS1G0g9zyAI6vqniT7AFcl+V6vFatqDZ3ZDRkfH69+BShJmtlAzjyq6p7mfTNwGXA4cG+S/QCa982DiE2StGOLnjyS7JHkyVPLwO8A64DLgVOazU4BvrTYsUmSejOIy1b7ApclmWr/M1X1lSTfAS5JcipwF/DqAcQmSerBoiePqvo+8Lxpyu8HjlnseCRJ7Q3To7qSpBFh8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLVm8pAktWbykCS1ZvKQJLU2iGloD0jytSTrk9yc5C1N+VlJfpjk+ub1ssWOTZLUm0FMQ7sVeHtVXdfMZb42yVXNZx+oqvcNICZJUguDmIZ2E7CpWX4gyXpg/8WOQ5I0dwO955FkGfB84NtN0ZuT3JjkgiR7zlBndZKJJBOTk5OLFaokqcvAkkeSXwMuBd5aVT8HPgI8E1hJ58zk/dPVq6o1VTVeVeNjY2OLFa4kqctAkkeSx9NJHJ+uqi8AVNW9VfVwVT0CfAw4fBCxSZJ2bBBPWwU4H1hfVX/VVb5f12avBNYtdmySpN4M4mmrI4HXAzclub4pewdwcpKVQAF3Am8cQGySpB4M4mmrbwCZ5qMrFjsWSdLc+AtzSVJrJg9JUmsmD0lSayYPSVJrJg9JUmsmD0lSayYPSVJrJg9JUmsmD0lSayYPSVJrJg9JUmsmD0lSayYPSVJrJg9JUmsmD0lSayYPSVJrQ5c8khyX5NYkG5KcPuh4JEmPNVTJI8kuwIeB44GD6UxNe/Bgo5IkbW+okgdwOLChqr5fVb8ELgZOGHBMkqTtDFvy2B+4u2t9Y1P2L5KsTjKRZGJycnLODe2+++7bvFt3ONv2mEej7iDbHsW6g257QVTV0LyAVwMf71p/PfChmbZftWpVzdXk5GSdc845NTk5ad0hbttjHo26g2x7FOsOum1goub5fZ3OfoZDkiOAs6rq2Gb9DICqes9024+Pj9fExMQiRihJoy/J2qoan88+hu2y1XeAFUmWJ3kCcBJw+YBjkiRtZ9dBB9CtqrYmeTPwVWAX4IKqunnAYUmStjNUyQOgqq4Arhh0HJKkmQ3bZStJ0ggweUiSWjN5SJJaM3lIklobqt95tJVkEvhBV9HewH0DCmeY2A/2wRT7ocN+2LYPfqOqxuazs5FOHttLMjHfH77sDOwH+2CK/dBhPyx8H3jZSpLUmslDktTazpY81gw6gCFhP9gHU+yHDvthgftgp7rnIUlaHDvbmYckaRGYPCRJrY1U8khyZ5KbklyfZKIp2yvJVUlua9737Nr+jCQbktya5NjBRb6wkjw1yeeTfC/J+iRHLLV+SPLs5u9g6vXzJG9dgv3wx0luTrIuyUVJnrjU+gAgyVuaPrg5yVubsp2+H5JckGRzknVdZa2PO8mq5rt1Q5IPJskOG5/vbFKL+QLuBPberuwc4PRm+XTgvc3ywcANwG7AcuB2YJdBH8MC9cOFwH9qlp8APHUp9kNXf+wC/Aj4jaXUD3SmaL4DeFKzfgnwhqXUB81xPRdYB+xOZ6TwvwdWLIV+AI4CDgXWdZW1Pm7gWuAIIMCXgeN31PZInXnM4AQ6X6Y076/oKr+4qh6qqjuADcDhix/ewkryFDp/MOcDVNUvq+qnLLF+2M4xwO1V9QOWXj/sCjwpya50vjzvYen1wW8C36qqLVW1Ffg68EqWQD9U1TXAj7crbnXcSfYDnlJV36xOJvlkV50ZjVryKODKJGuTrG7K9q2qTQDN+z5N+f7A3V11NzZlo+4gYBL4n0m+m+TjSfZg6fVDt5OAi5rlJdMPVfVD4H3AXcAm4GdVdSVLqA8a64Cjkjwtye7Ay4ADWHr9MKXtce/fLG9fPqtRSx5HVtWhwPHAaUmOmmXb6a7Z7QzPJe9K5zT1I1X1fOCf6ZyazmRn7QcAmumKXw58bkebTlM20v3QXMs+gc4liKcDeyR53WxVpikb6T4AqKr1wHuBq4Cv0Lk0s3WWKjtlP/RgpuOeU3+MVPKoqnua983AZXRONe9tTrto3jc3m2+k87+PKc+gc0o/6jYCG6vq28365+kkk6XWD1OOB66rqnub9aXUDy8F7qiqyar6FfAF4IUsrT4AoKrOr6pDq+ooOpdxbmMJ9kOj7XFvbJa3L5/VyCSPJHskefLUMvA7dE5XLwdOaTY7BfhSs3w5cFKS3ZIsp3MD7drFjXrhVdWPgLuTPLspOga4hSXWD11O5tFLVrC0+uEu4AVJdm+ejjkGWM/S6gMAkuzTvB8InEjnb2LJ9UOj1XE3l7YeSPKC5u/oD7rqzGzQTwu0eKrgIDqnozcANwPvbMqfBlxN538aVwN7ddV5J50nCm6lh6cHRuUFrAQmgBuBLwJ7LtF+2B24H/j1rrIl1Q/AnwHfo/Mfqb+l8yTNkuqD5rj+kc5/om4Ajlkqfwt0kuQm4Fd0ziBOnctxA+PN39DtwN/QjD4y28vhSSRJrY3MZStJ0vAweUiSWjN5SJJaM3lIklozeUiSWjN5aElqhrKYGpH3R0l+2Cz/Isl5fWrzrUn+YAH2c3GSFQsRkzRXPqqrJS/JWcAvqup9fWxjV+A64NDqDN43n329GHhdVf3RggQnzYFnHlKXJEcn+d/N8llJLkxyZTpzyZyY5Jxm3oOvJHl8s92qJF9vBuz86tTQENt5CZ1hVLY2df5Pkg8kuSadOVkOS/KFZg6Gv2i22SPJ3yW5oZmr4rXNvv4ReGmTkKSBMHlIs3sm8Lt0BiD8FPC1qjoEeBD43SaBfAh4VVWtAi4Azp5mP0cCa7cr+2V1xmL6KJ3hIE6jMzfFG5I8DTgOuKeqnldVz6Uz6B9V9Qid4bSft6BHKrVg8pBm9+XqDDp4E51Jp77SlN8ELAOeTecL/6ok1wPvYttB5qbsR2co/W6Xd+3r5qraVFUPAd+nM4DdTXTOMN6b5EVV9bOuupvpjKQrDYSnvdLsHoLO//aT/KoevUn4CJ1/P6HzxX/EDvbzIPDE6fbd7OuhrvJHgF2r6p+SrKIzP8V7klxZVX/ebPPEZp/SQHjmIc3PrcBYkiMAkjw+yXOm2W498K/b7DjJ04EtVfUpOpM+Hdr18bPoDBAqDYRnHtI8VNUvk7wK+GCSX6fzb+qveewX+5fpjHrbxiHAuUkeoTNq6n8GSLIv8GA1s8VJg+CjutIiSXIZ8N+q6rZ57uePgZ9X1fkLE5nUnpetpMVzOp0b5/P1U+DCBdiPNGeeeUiSWvPMQ5LUmslDktSayUOS1JrJQ5LUmslDktTa/wdQl4j9LGB2IAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 2: 500 - 1000 ms\n",
    "\n",
    "net2.run(duration=(500., 1000.), inputs=[group2, 'input', 1.2], report=True, report_percent=0.5)\n",
    "bp.visualize.raster_plot(group2.mon.spike_t, group2.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set a different inputs structure (the previous is a \"float\", now it's a vector), the network will rebuild the input function and run the network continuously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 0.0010 s.\n",
      "Start running ...\n",
      "Run 50.0% used 2.134 s.\n",
      "Run 100.0% used 4.284 s.\n",
      "Simulation is done in 4.284 s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 1000 - 1500 ms\n",
    "\n",
    "Iext = np.ones(group2.num) * 1.2\n",
    "net2.run(duration=(1000., 1500.), inputs=[group2, 'input', Iext],\n",
    "        report=True, report_percent=0.5)\n",
    "bp.visualize.raster_plot(group2.mon.spike_t, group2.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**NOTE**\n",
    "\n",
    "\n",
    "Another thing worthy noting is that if the model variable states rely on the time (for example, the LIF neuron model ``self.t_last_spike``). Setting the continuous time duration between each repeat run is necessary, because the model's logic is dependent on the current time ``_t``. \n",
    "\n",
    "\n",
    "**Author**:\n",
    "\n",
    "- Chaoming Wang\n",
    "- Email: adaduo@outlook.com\n",
    "- Date: 2021.05.25\n",
    "\n",
    "---\n"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "180.07px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}