diff --git a/brainpy/dyn/neurons/reduced_models.py b/brainpy/dyn/neurons/reduced_models.py index 8beda8155..c8dff8f01 100644 --- a/brainpy/dyn/neurons/reduced_models.py +++ b/brainpy/dyn/neurons/reduced_models.py @@ -714,7 +714,7 @@ def __init__(self, size, V_rest=-70., V_reset=-70., V_th_inf=-50., V_th_reset=-6 self.I1 = bm.Variable(bm.zeros(self.num)) self.I2 = bm.Variable(bm.zeros(self.num)) self.V_th = bm.Variable(bm.ones(self.num) * -50.) - self.V = bm.Variable(bm.zeros(self.num)) + self.V = bm.Variable(bm.zeros(self.num) - 70.) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) diff --git a/docs/index.rst b/docs/index.rst index 2aacd9392..f338bbf16 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -64,6 +64,7 @@ The code of BrainPy is open-sourced at GitHub: tutorial_toolbox/synaptic_weights tutorial_toolbox/optimizers tutorial_toolbox/runners + tutorial_toolbox/inputs tutorial_toolbox/monitors tutorial_toolbox/saving_and_loading diff --git a/docs/quickstart/simulation.ipynb b/docs/quickstart/simulation.ipynb index e0ea9c060..b1e840810 100644 --- a/docs/quickstart/simulation.ipynb +++ b/docs/quickstart/simulation.ipynb @@ -170,7 +170,7 @@ "id": "43ec39f4", "metadata": {}, "source": [ - "After build a SNN, we can use it for dynamic simulation. To run a simulation, we need first wrap the network model into a runner. Currently BrainPy provides ``DSRunner``, ``StructRunner``, ``ReportRunner`` in ``brainpy.dyn``. They receive inputs with the same structure, and will be expanded in [Running a Simulation](../tutorial_simulation/runner.ipynb). Here we use ``DSRunner`` as an example:" + "After build a SNN, we can use it for dynamic simulation. To run a simulation, we need first wrap the network model into a **runner**. Currently BrainPy provides ``DSRunner`` and ``ReportRunner`` in ``brainpy.dyn``, which will be expanded in the [Runners](../tutorial_simulation/runner.ipynb) tutorial. Here we use ``DSRunner`` as an example:" ] }, { @@ -191,7 +191,7 @@ "id": "11473917", "metadata": {}, "source": [ - "To make dynamic simulation more applicable and powerful, users can [**monitor**](../tutorial_simulation/monitors_and_inputs.ipynb) variable trajectories and give [**inputs**](../tutorial_simulation/monitors_and_inputs.ipynb) to target neuron groups. Here we monitor the ``spike`` variable in the ``E`` and ``I`` LIF model, which refers to the spking status of the neuron group, and give a constant input to both neuron groups. The time interval of numerical integration ``dt`` (with the default value of 0.1) can also be specified.\n", + "To make dynamic simulation more applicable and powerful, users can [**monitor**](../tutorial_toolbox/monitors.ipynb) variable trajectories and give [**inputs**](../tutorial_toolbox/inputs.ipynb) to target neuron groups. Here we monitor the ``spike`` variable in the ``E`` and ``I`` LIF model, which refers to the spking status of the neuron group, and give a constant input to both neuron groups. The time interval of numerical integration ``dt`` (with the default value of 0.1) can also be specified.\n", "\n", "After creating the runner, we can run a simulation by calling the runner:" ] @@ -290,9 +290,9 @@ ], "metadata": { "kernelspec": { - "display_name": "brainpy", + "display_name": "Python [conda env:root] *", "language": "python", - "name": "brainpy" + "name": "conda-root-py" }, "language_info": { "codemirror_mode": { @@ -304,7 +304,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.11" + "version": "3.8.8" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/docs/tutorial_simulation/network_models.ipynb b/docs/tutorial_simulation/network_models.ipynb index 470bfe05b..d830cd5c4 100644 --- a/docs/tutorial_simulation/network_models.ipynb +++ b/docs/tutorial_simulation/network_models.ipynb @@ -342,7 +342,7 @@ "id": "84449872", "metadata": {}, "source": [ - " All elements are passed as ``**kwargs`` argument can be accessed by the provided keys. This will affect the following dynamics simualtion and will be discussed in greater detail in [tutorial of Monitors and Inputs](../tutorial_simulation/monitors_and_inputs.ipynb)." + "All elements are passed as ``**kwargs`` argument can be accessed by the provided keys. This will affect the following dynamics simualtion and will be discussed in greater detail in tutorial of [Runners](../tutorial_toolbox/runners.ipynb)." ] }, { @@ -466,13 +466,21 @@ "id": "ee0ef0f9", "metadata": {}, "source": [ - "Above are some simulation examples showing the possible application of network models. The detailed description of dynamics simulation is covered in [Dynamics Simulation](../tutorial_simulation/index.rst), where the use of monitors and inputs will be expatiated." + "Above are some simulation examples showing the possible application of network models. The detailed description of dynamics simulation is covered in the toolboxes, where the use of [runners](../tutorial_toolbox/runners.ipynb), [monitors](../tutorial_toolbox/monitors.ipynb), and [inputs](../tutorial_toolbox/inputs.ipynb) will be expatiated." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d31c4afc", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -486,7 +494,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.8" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/docs/tutorial_simulation/neuron_models.ipynb b/docs/tutorial_simulation/neuron_models.ipynb index 70c1c851a..9f82aba1f 100644 --- a/docs/tutorial_simulation/neuron_models.ipynb +++ b/docs/tutorial_simulation/neuron_models.ipynb @@ -395,7 +395,7 @@ "id": "f9d2604b", "metadata": {}, "source": [ - "The details of the model simulation will be expanded in the [Dynamics Simulation](../tutorial_simulation/index.rst) section. In brief, running any dynamical system instance should be accomplished with a runner, such like `brianpy.StructRunner` and `brainpy.ReportRunner`. In the runner, the variables want to monitor and the input crrents try to specify can be provided when initializing the runner. The details please see the tutorial of [Monitors and Inputs](../tutorial_simulation/monitors_and_inputs.ipynb). " + "The details of the model simulation will be expanded in the [Runners](../tutorial_toolbox/runners.ipynb) section. In brief, running any dynamical system instance should be accomplished with a runner, such like `brianpy.DSRunner` and `brainpy.ReportRunner`. The variables to be monitored and the input crrents to be applied in the simulation can be provided when initializing the runner. The details are accessible in [Monitors](../tutorial_toolbox/monitors.ipynb) and [Inputs](../tutorial_toolbox/inputs.ipynb). " ] }, { @@ -512,7 +512,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -526,7 +526,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.8" }, "latex_envs": { "LaTeX_envs_menu_present": true, @@ -562,4 +562,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/docs/tutorial_simulation/synapse_models.ipynb b/docs/tutorial_simulation/synapse_models.ipynb index 7e081b03c..8ae2b03cd 100644 --- a/docs/tutorial_simulation/synapse_models.ipynb +++ b/docs/tutorial_simulation/synapse_models.ipynb @@ -169,7 +169,7 @@ "1. Constructor function ``__init__()``, in which three key arguments are needed. \n", " - `pre`: the pre-synaptic neural group. It should be an instance of `brainpy.dyn.NeuGroup`.\n", " - `post`: the post-synaptic neural group. It should be an instance of `brainpy.dyn.NeuGroup`.\n", - " - `conn` (optional): the connection type between these two groups. BrainPy has provided abundant connection types that are described in details in the [Synaptic Connections](./synaptic_connections.ipynb).\n", + " - `conn` (optional): the connection type between these two groups. BrainPy has provided abundant connection types that are described in details in the [Synaptic Connections](../tutorial_toolbox/synaptic_connections.ipynb).\n", "2. Update function ``update(_t, _dt)`` describes the updating rule from the current time $\\mathrm{\\_t}$ to the next time $\\mathrm{\\_t + \\_dt}$. " ] }, @@ -385,7 +385,7 @@ "id": "44fa4941", "metadata": {}, "source": [ - "More details of the connection structures please see the tutorial of [Synaptic Connections](./synaptic_connections.ipynb)." + "More details of the connection structures please see the tutorial of [Synaptic Connections](../tutorial_toolbox/synaptic_connections.ipynb)." ] }, { @@ -953,7 +953,7 @@ "\n", "Imaging you want to connect 10,000 pre-synaptic neurons to 10,000 post-synaptic neurons with a 10% random connection probability. Using matrix, you need $10^8$ floats to save the synaptic state, and at each update step, you need do computation on $10^8$ floats. Actually, the number of synapses you really connect is only $10^7$. See, there is a huge memory waste and computing resource inefficiency. Moreover, at the given time $\\mathrm{\\_t}$, the number of pre-synaptic neurons in the spiking state is small on average. This means we have made many useless computations when defining synaptic computations with matrix-based connections (zeros dot connection matrix results in zeros).\n", "\n", - "Therefore, we need new ways to define synapse models. Specifically, we use vectors to store the connected neuron indices, like the ``pre_ids`` and ``post_ids`` (see [Synaptic Connections](./synaptic_connections.ipynb)). " + "Therefore, we need new ways to define synapse models. Specifically, we use vectors to store the connected neuron indices, like the ``pre_ids`` and ``post_ids`` (see [Synaptic Connections](../tutorial_toolbox/synaptic_connections.ipynb)). " ] }, { @@ -961,7 +961,7 @@ "id": "b67256b8", "metadata": {}, "source": [ - "In the below, we assume you have learned the synaptic connection types detailed in the tutorial of [Synaptic Connections](./synaptic_connections.ipynb)." + "In the below, we assume you have learned the synaptic connection types detailed in the tutorial of [Synaptic Connections](../tutorial_toolbox/synaptic_connections.ipynb)." ] }, { @@ -1233,7 +1233,7 @@ "encoding": "# -*- coding: utf-8 -*-" }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1247,7 +1247,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.8" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/docs/tutorial_toolbox/inputs.ipynb b/docs/tutorial_toolbox/inputs.ipynb new file mode 100644 index 000000000..25f7db839 --- /dev/null +++ b/docs/tutorial_toolbox/inputs.ipynb @@ -0,0 +1,527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9f5ef59c", + "metadata": {}, + "source": [ + "# Inputs" + ] + }, + { + "cell_type": "markdown", + "id": "95e252ca", + "metadata": {}, + "source": [ + "@[Chaoming Wang](https://github.com/chaoming0625)\n", + "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" + ] + }, + { + "cell_type": "markdown", + "id": "f9c7d3ca", + "metadata": {}, + "source": [ + "In brain dynamics simulation, various inpus are usually given to different units of the dynamical system. In BrainPy, `inputs` can be specified to [runners for dynamical systems](runners.ipynb). The aim of ``inputs`` is to mimic the input operations in experiments like Transcranial Magnetic Stimulation (TMS) and patch clamp recording.\n", + "\n", + "``inputs`` should have the format like ``(target, value, [type, operation])``, where \n", + "- ``target`` is the target variable to inject the input.\n", + "- ``value`` is the input value. It can be a scalar, a tensor, or a iterable object/function.\n", + "- ``type`` is the type of the input value. It support two types of input: ``fix`` and ``iter``. The first one means that the data is static; the second one denotes the data can be iterable, no matter whether the input value is a tensor or a function. The `iter` type must be explicitly stated. \n", + "- ``operation`` is the input operation on the target variable. It should be set as one of `{ + , - , * , / , = }`, and if users do not provide this item explicitly, it will be set to '+' by default, which means that the target variable will be updated as ``val = val + input``. " + ] + }, + { + "cell_type": "markdown", + "id": "3451b77b", + "metadata": {}, + "source": [ + "Users can also give multiple inputs for different target variables, like:\n", + "\n", + "```python\n", + "\n", + "inputs=[(target1, value1, [type1, op1]), \n", + " (target2, value2, [type2, op2]),\n", + " ... ]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e377d41a", + "metadata": {}, + "source": [ + "The mechanism of ``inputs`` is the same as [``monitors``](monitors.ipynb). BrainPy finds the target variables for input operations through [the absolute or relative path](../tutorial_math/base.ipynb). " + ] + }, + { + "cell_type": "markdown", + "id": "844fcb78", + "metadata": {}, + "source": [ + "## Input construction functions " + ] + }, + { + "cell_type": "markdown", + "id": "a4ff6914", + "metadata": {}, + "source": [ + "Like electrophysiological experiments, model simulation also needs various kind of inputs. BrainPy provide several convenient input functions to help users construct input currents. " + ] + }, + { + "cell_type": "markdown", + "id": "64f9a99c", + "metadata": {}, + "source": [ + "### 1\\. ``brainpy.inputs.section_input()``\n", + "\n", + "[brainpy.inputs.section_input()](../apis/simulation/generated/brainpy.simulation.inputs.section_input.rst) is an updated function of previous `brainpy.inputs.constant_input()` (see below). \n", + "\n", + "Sometimes, we need input currents with different values in different periods. For example, if you want to get an input that is 0 in the first 100 ms, 1 in the next 300 ms, and 0 again from the last 100 ms, you can define:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "078fbd0d", + "metadata": {}, + "outputs": [], + "source": [ + "current1, duration = bp.inputs.section_input(values=[0, 1., 0.],\n", + " durations=[100, 300, 100],\n", + " return_length=True,\n", + " dt=0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "579e8b2d", + "metadata": {}, + "source": [ + "Where `values` receive a list/arrray of the current values in each section and `durations` receives a list/array of the duration of each section. The function returns a tensor as the current, the length of which is `duration`$/\\mathrm{d}t$ (if not specified, $\\mathrm{d}t=0.1 \\mathrm{ms}$). We can visualize the current input by:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "54aec8c9", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def show(current, duration, title):\n", + " ts = np.arange(0, duration, 0.1)\n", + " plt.plot(ts, current)\n", + " plt.title(title)\n", + " plt.xlabel('Time [ms]')\n", + " plt.ylabel('Current Value')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1a18a549", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(current1, duration, 'values=[0, 1, 0], durations=[100, 300, 100]')" + ] + }, + { + "cell_type": "markdown", + "id": "6b1eee02", + "metadata": {}, + "source": [ + "### 2\\. ``brainpy.inputs.constant_input()``" + ] + }, + { + "cell_type": "markdown", + "id": "26708359", + "metadata": {}, + "source": [ + "[brainpy.inputs.constant_input()](../apis/simulation/generated/brainpy.simulation.inputs.constant_input.rst) function helps users to format constant currents in several periods.\n", + "\n", + "We can generate the above input current with `constant_input()` by:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "8ea6dea6", + "metadata": {}, + "outputs": [], + "source": [ + "current2, duration = bp.inputs.constant_input([(0, 100), (1, 300), (0, 100)])" + ] + }, + { + "cell_type": "markdown", + "id": "6cc74d90", + "metadata": {}, + "source": [ + "Where each tuple in the list contains the value and duration of the input in this section." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e862ebad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(current2, duration, '[(0, 100), (1, 300), (0, 100)]')" + ] + }, + { + "cell_type": "markdown", + "id": "067aae19", + "metadata": {}, + "source": [ + "### 3\\. ``brainpy.inputs.spike_input()``" + ] + }, + { + "cell_type": "markdown", + "id": "e6ea2868", + "metadata": {}, + "source": [ + "[brainpy.inputs.spike_input()](../apis/simulation/generated/brainpy.simulation.inputs.spike_input.rst) constructs an input containing a series of short-time spikes. It receives the following settings:\n", + "\n", + "- `sp_times` : The spike time-points. Must be an iterable object. For example, list, tuple, or arrays.\n", + "- `sp_lens` : The length of each point-current, mimicking the spike durations. It can be a scalar float to specify the unified duration. Or, it can be list/tuple/array of time lengths with the length same with `sp_times`. \n", + "- `sp_sizes` : The current sizes. It can be a scalar value. Or, it can be a list/tuple/array of spike current sizes with the length same with `sp_times`.\n", + "- `duration` : The total current duration.\n", + "- `dt` : The time step precision. The default is None (will be initialized as the default `dt` step). " + ] + }, + { + "cell_type": "markdown", + "id": "146ebc19", + "metadata": {}, + "source": [ + "For example, if you want to generate a spike train at 10 ms, 20 ms, 30 ms, 200 ms, 300 ms, where each spike lasts 1 ms and the average value for each spike is 0.5, then you can define the current by:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1eb035a2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "current3 = bp.inputs.spike_input(\n", + " sp_times=[10, 20, 30, 200, 300],\n", + " sp_lens=1., # can be a list to specify the spike length at each point\n", + " sp_sizes=0.5, # can be a list to specify the spike current size at each point\n", + " duration=400.)\n", + "\n", + "show(current3, 400, 'Spike Input Example')" + ] + }, + { + "cell_type": "markdown", + "id": "68262531", + "metadata": {}, + "source": [ + "### 4\\. ``brainpy.inputs.ramp_input()``" + ] + }, + { + "cell_type": "markdown", + "id": "ce29ec3c", + "metadata": {}, + "source": [ + "[brainpy.inputs.ramp_input()](../apis/simulation/generated/brainpy.simulation.inputs.ramp_input.rst) mimics a ramp or a step current to the input of the circuit. It receives the following settings:\n", + "\n", + "- `c_start` : The minimum (or maximum) current size.\n", + "- `c_end` : The maximum (or minimum) current size.\n", + "- `duration` : The total duration.\n", + "- `t_start` : The ramped current start time-point.\n", + "- `t_end` : The ramped current end time-point. Default is the None.\n", + "- `dt` : The current precision.\n", + "\n", + "We illustrate the usage of `brainpy.inputs.ramp_input()` by two examples." + ] + }, + { + "cell_type": "markdown", + "id": "7435a038", + "metadata": {}, + "source": [ + "In the first example, we increase the current size from 0. to 1. between the start time (0 ms) and the end time (500 ms). " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "a667a133", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "duration = 500\n", + "current4 = bp.inputs.ramp_input(0, 1, duration)\n", + "\n", + "show(current4, duration, r'$c_{start}$=0, $c_{end}$=%d, duration, '\n", + " r'$t_{start}$=0, $t_{end}$=None' % (duration))" + ] + }, + { + "cell_type": "markdown", + "id": "7f765623", + "metadata": {}, + "source": [ + "In the second example, we increase the current size from 0. to 1. from the 100 ms to 400 ms." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d0caf6ea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "duration, t_start, t_end = 500, 100, 400\n", + "current5 = bp.inputs.ramp_input(0, 1, duration, t_start, t_end)\n", + "\n", + "show(current5, duration, r'$c_{start}$=0, $c_{end}$=1, duration=%d, '\n", + " r'$t_{start}$=%d, $t_{end}$=%d' % (duration, t_start, t_end))" + ] + }, + { + "cell_type": "markdown", + "id": "5ec7e24c", + "metadata": {}, + "source": [ + "Because the current input is stored as a tensor, a complex input can be realized by the combination of several simple currents." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "64ac8ffa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(current1 + current5, 500, 'A Complex Current Input')" + ] + }, + { + "cell_type": "markdown", + "id": "307b4eb1", + "metadata": {}, + "source": [ + "## General properties of input functions" + ] + }, + { + "cell_type": "markdown", + "id": "4601f294", + "metadata": {}, + "source": [ + "**1\\. Every input function receives a ``dt`` specification.**\n", + "\n", + "If ``dt`` is not provided, input functions will use the default ``dt`` in the whole BrainPy system. " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "bf9084a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I1.shape: (600,)\n", + "I2.shape: (6000,)\n" + ] + } + ], + "source": [ + "I1 = bp.inputs.section_input(values=[0, 1, 2], durations=[10, 20, 30], dt=0.1)\n", + "I2 = bp.inputs.section_input(values=[0, 1, 2], durations=[10, 20, 30], dt=0.01)\n", + "print('I1.shape: {}'.format(I1.shape))\n", + "print('I2.shape: {}'.format(I2.shape))" + ] + }, + { + "cell_type": "markdown", + "id": "3b0ac63a", + "metadata": {}, + "source": [ + "**2\\. All input functions can automatically broadcast the current shapes if they are heterogenous among different periods.**\n", + "\n", + "For example, during period 1 we give an input with a scalar value, during period 2 we give an input with a vector shape, and during period 3 we give a matrix input value. Input functions will broadcast them to the maximum shape. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "fa0679d0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5000, 3, 10)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "current = bp.inputs.section_input(values=[0, bm.ones(10), bm.random.random((3, 10))],\n", + " durations=[100, 300, 100])\n", + "\n", + "current.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26d3e6e1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.8" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorial_toolbox/runners.ipynb b/docs/tutorial_toolbox/runners.ipynb index 4b8a222e2..bb83397c6 100644 --- a/docs/tutorial_toolbox/runners.ipynb +++ b/docs/tutorial_toolbox/runners.ipynb @@ -78,7 +78,7 @@ "In which\n", "- ``target`` specifies the model to be simulated. It must an instance of [brainpy.DynamicalSystem](../apis/auto/simulation/generated/brainpy.simulation.brainobjects.DynamicalSystem.rst). \n", "- ``monitors`` is used to define target variables in the model. During the simulation, the history values of the monitored variables will be recorded. More information can be found in the [Monitors](monitors.ipynb) tutorial.\n", - "- ``inputs`` is used to define the input operations for specific variables. It will be expanded later in this tutorial.\n", + "- ``inputs`` is used to define the input operations for specific variables. It will be expanded in the [Inputs](inputs.ipynb) tutorial.\n", "- ``dyn_vars`` is used to specify all the dynamically changed [variables](../tutorial_math/variables.ipynb) used in the ``target`` model.\n", "- ``jit`` determines whether to use [JIT compilation](../tutorial_math/compilation.ipynb) during the simulation." ] @@ -316,456 +316,6 @@ "bp.visualize.raster_plot(runner.mon.ts, runner.mon['E.spike'], show=True)" ] }, - { - "cell_type": "markdown", - "id": "50aa356e", - "metadata": {}, - "source": [ - "### Inputs for runners" - ] - }, - { - "cell_type": "markdown", - "id": "f9c7d3ca", - "metadata": {}, - "source": [ - "BrainPy provides `inputs` operations for each instance of ``brainpy.Runner``. The aim of ``inputs`` is to mimic the input operations in experiments like Transcranial Magnetic Stimulation (TMS) and patch clamp recording.\n", - "\n", - "``inputs`` should have the format like ``(target, value, [type, operation])``, where \n", - "- ``target`` is the target variable to inject the input.\n", - "- ``value`` is the input value. It can be a scalar, a tensor, or a iterable object/function.\n", - "- ``type`` is the type of the input value. It support two types of input: ``fix`` and ``iter``. The first one means that the data is static; the second one denotes the data can be iterable, no matter whether the input value is a tensor or a function. The `iter` type must be explicitly stated. \n", - "- ``operation`` is the input operation on the target variable. It should be set as one of `{ + , - , * , / , = }`, and if users do not provide this item explicitly, it will be set to '+' by default, which means that the target variable will be updated as ``val = val + input``. " - ] - }, - { - "cell_type": "markdown", - "id": "3451b77b", - "metadata": {}, - "source": [ - "Users can also give multiple inputs for different target variables, like:\n", - "\n", - "```python\n", - "\n", - "inputs=[(target1, value1, [type1, op1]), \n", - " (target2, value2, [type2, op2]),\n", - " ... ]\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "e377d41a", - "metadata": {}, - "source": [ - "The mechanism of ``inputs`` is the same as [``monitors``](monitors.ipynb). BrainPy finds the target variables for input operations through [the absolute or relative path](../tutorial_math/base.ipynb). " - ] - }, - { - "cell_type": "markdown", - "id": "844fcb78", - "metadata": {}, - "source": [ - "### Input construction functions " - ] - }, - { - "cell_type": "markdown", - "id": "a4ff6914", - "metadata": {}, - "source": [ - "Like electrophysiological experiments, model simulation also needs various kind of inputs. BrainPy provide several convenient input functions to help users construct input currents. " - ] - }, - { - "cell_type": "markdown", - "id": "64f9a99c", - "metadata": {}, - "source": [ - "**1\\. ``brainpy.inputs.section_input()``**\n", - "\n", - "[brainpy.inputs.section_input()](../apis/simulation/generated/brainpy.simulation.inputs.section_input.rst) is an updated function of previous `brainpy.inputs.constant_input()` (see below). \n", - "\n", - "Sometimes, we need input currents with different values in different periods. For example, if you want to get an input that is 0 in the first 100 ms, 1 in the next 300 ms, and 0 again from the last 100 ms, you can define:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "078fbd0d", - "metadata": {}, - "outputs": [], - "source": [ - "current1, duration = bp.inputs.section_input(values=[0, 1., 0.],\n", - " durations=[100, 300, 100],\n", - " return_length=True,\n", - " dt=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "579e8b2d", - "metadata": {}, - "source": [ - "Where `values` receive a list/arrray of the current values in each section and `durations` receives a list/array of the duration of each section. The function returns a tensor as the current, the length of which is `duration`$/\\mathrm{d}t$ (if not specified, $\\mathrm{d}t=0.1 \\mathrm{ms}$). We can visualize the current input by:" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "54aec8c9", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def show(current, duration, title):\n", - " ts = np.arange(0, duration, 0.1)\n", - " plt.plot(ts, current)\n", - " plt.title(title)\n", - " plt.xlabel('Time [ms]')\n", - " plt.ylabel('Current Value')\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "1a18a549", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "show(current1, duration, 'values=[0, 1, 0], durations=[100, 300, 100]')" - ] - }, - { - "cell_type": "markdown", - "id": "6b1eee02", - "metadata": {}, - "source": [ - "**2\\. ``brainpy.inputs.constant_input()``**" - ] - }, - { - "cell_type": "markdown", - "id": "26708359", - "metadata": {}, - "source": [ - "[brainpy.inputs.constant_input()](../apis/simulation/generated/brainpy.simulation.inputs.constant_input.rst) function helps users to format constant currents in several periods.\n", - "\n", - "We can generate the above input current with `constant_input()` by:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8ea6dea6", - "metadata": {}, - "outputs": [], - "source": [ - "current2, duration = bp.inputs.constant_input([(0, 100), (1, 300), (0, 100)])" - ] - }, - { - "cell_type": "markdown", - "id": "6cc74d90", - "metadata": {}, - "source": [ - "Where each tuple in the list contains the value and duration of the input in this section." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "e862ebad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "show(current2, duration, '[(0, 100), (1, 300), (0, 100)]')" - ] - }, - { - "cell_type": "markdown", - "id": "067aae19", - "metadata": {}, - "source": [ - "**3\\. ``brainpy.inputs.spike_input()``**" - ] - }, - { - "cell_type": "markdown", - "id": "e6ea2868", - "metadata": {}, - "source": [ - "[brainpy.inputs.spike_input()](../apis/simulation/generated/brainpy.simulation.inputs.spike_input.rst) constructs an input containing a series of short-time spikes. It receives the following settings:\n", - "\n", - "- `sp_times` : The spike time-points. Must be an iterable object. For example, list, tuple, or arrays.\n", - "- `sp_lens` : The length of each point-current, mimicking the spike durations. It can be a scalar float to specify the unified duration. Or, it can be list/tuple/array of time lengths with the length same with `sp_times`. \n", - "- `sp_sizes` : The current sizes. It can be a scalar value. Or, it can be a list/tuple/array of spike current sizes with the length same with `sp_times`.\n", - "- `duration` : The total current duration.\n", - "- `dt` : The time step precision. The default is None (will be initialized as the default `dt` step). " - ] - }, - { - "cell_type": "markdown", - "id": "146ebc19", - "metadata": {}, - "source": [ - "For example, if you want to generate a spike train at 10 ms, 20 ms, 30 ms, 200 ms, 300 ms, where each spike lasts 1 ms and the average value for each spike is 0.5, then you can define the current by:" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "1eb035a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "current3 = bp.inputs.spike_input(\n", - " sp_times=[10, 20, 30, 200, 300],\n", - " sp_lens=1., # can be a list to specify the spike length at each point\n", - " sp_sizes=0.5, # can be a list to specify the spike current size at each point\n", - " duration=400.)\n", - "\n", - "show(current3, 400, 'Spike Input Example')" - ] - }, - { - "cell_type": "markdown", - "id": "68262531", - "metadata": {}, - "source": [ - "**4\\. ``brainpy.inputs.ramp_input()``**" - ] - }, - { - "cell_type": "markdown", - "id": "ce29ec3c", - "metadata": {}, - "source": [ - "[brainpy.inputs.ramp_input()](../apis/simulation/generated/brainpy.simulation.inputs.ramp_input.rst) mimics a ramp or a step current to the input of the circuit. It receives the following settings:\n", - "\n", - "- `c_start` : The minimum (or maximum) current size.\n", - "- `c_end` : The maximum (or minimum) current size.\n", - "- `duration` : The total duration.\n", - "- `t_start` : The ramped current start time-point.\n", - "- `t_end` : The ramped current end time-point. Default is the None.\n", - "- `dt` : The current precision.\n", - "\n", - "We illustrate the usage of `brainpy.inputs.ramp_input()` by two examples." - ] - }, - { - "cell_type": "markdown", - "id": "7435a038", - "metadata": {}, - "source": [ - "In the first example, we increase the current size from 0. to 1. between the start time (0 ms) and the end time (500 ms). " - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "a667a133", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "duration = 500\n", - "current4 = bp.inputs.ramp_input(0, 1, duration)\n", - "\n", - "show(current4, duration, r'$c_{start}$=0, $c_{end}$=%d, duration, '\n", - " r'$t_{start}$=0, $t_{end}$=None' % (duration))" - ] - }, - { - "cell_type": "markdown", - "id": "7f765623", - "metadata": {}, - "source": [ - "In the second example, we increase the current size from 0. to 1. from the 100 ms to 400 ms." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "d0caf6ea", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "duration, t_start, t_end = 500, 100, 400\n", - "current5 = bp.inputs.ramp_input(0, 1, duration, t_start, t_end)\n", - "\n", - "show(current5, duration, r'$c_{start}$=0, $c_{end}$=1, duration=%d, '\n", - " r'$t_{start}$=%d, $t_{end}$=%d' % (duration, t_start, t_end))" - ] - }, - { - "cell_type": "markdown", - "id": "5ec7e24c", - "metadata": {}, - "source": [ - "Because the current input is stored as a tensor, a complex input can be realized by adding several small currents together." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "64ac8ffa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "show(current1 + current5, 500, 'A Complex Current Input')" - ] - }, - { - "cell_type": "markdown", - "id": "307b4eb1", - "metadata": {}, - "source": [ - "### General property of input functions" - ] - }, - { - "cell_type": "markdown", - "id": "4601f294", - "metadata": {}, - "source": [ - "1\\. Every input function receives a ``dt`` specification. If ``dt`` is not provided, input functions will use the default ``dt`` in the whole BrainPy system. " - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "bf9084a9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I1.shape: (600,)\n", - "I2.shape: (6000,)\n" - ] - } - ], - "source": [ - "I1 = bp.inputs.section_input(values=[0, 1, 2], durations=[10, 20, 30], dt=0.1)\n", - "I2 = bp.inputs.section_input(values=[0, 1, 2], durations=[10, 20, 30], dt=0.01)\n", - "print('I1.shape: {}'.format(I1.shape))\n", - "print('I2.shape: {}'.format(I2.shape))" - ] - }, - { - "cell_type": "markdown", - "id": "3b0ac63a", - "metadata": {}, - "source": [ - "2\\. All input functions can automatically broadcast the current shapes, if they are heterogenous among different periods. For example, during period 1 we give an input with a scalar value, during period 2 we give an input with a vector shape, and during period 3 we give a matrix input value. Input functions will broadcast them to the maximum shape. For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "fa0679d0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5000, 3, 10)" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "current = bp.inputs.section_input(values=[0, bm.ones(10), bm.random.random((3, 10))],\n", - " durations=[100, 300, 100])\n", - "\n", - "current.shape" - ] - }, { "cell_type": "markdown", "id": "3551f214", @@ -785,7 +335,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -799,7 +349,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.8" }, "latex_envs": { "LaTeX_envs_menu_present": true,