diff --git a/brainpy/__init__.py b/brainpy/__init__.py index 272a7a0a7..c52358720 100644 --- a/brainpy/__init__.py +++ b/brainpy/__init__.py @@ -77,7 +77,8 @@ # common tools from brainpy._src.context import (share as share) -from brainpy._src.helpers import (reset_state as reset_state, +from brainpy._src.helpers import (reset_level as reset_level, + reset_state as reset_state, save_state as save_state, load_state as load_state, clear_input as clear_input) diff --git a/brainpy/_src/helpers.py b/brainpy/_src/helpers.py index 9352ff850..ab0a306e9 100644 --- a/brainpy/_src/helpers.py +++ b/brainpy/_src/helpers.py @@ -1,11 +1,12 @@ -from typing import Dict +from typing import Dict, Callable +from brainpy._src import dynsys from brainpy._src.dyn.base import IonChaDyn from brainpy._src.dynsys import DynamicalSystem, DynView from brainpy._src.math.object_transform.base import StateLoadResult - __all__ = [ + 'reset_level', 'reset_state', 'load_state', 'save_state', @@ -13,6 +14,34 @@ ] +_max_level = 10 + + +def reset_level(level: int = 0): + """The decorator for indicating the resetting level. + + The function takes an optional integer argument level with a default value of 0. + + The lower the level, the earlier the function is called. + + >>> import brainpy as bp + >>> bp.reset_level(0) + >>> bp.reset_level(-1) + >>> bp.reset_level(-2) + + """ + if level < 0: + level = _max_level + level + if level < 0 or level >= _max_level: + raise ValueError(f'"reset_level" must be an integer in [0, 10). but we got {level}') + + def wrap(fun: Callable): + fun.reset_level = level + return fun + + return wrap + + def reset_state(target: DynamicalSystem, *args, **kwargs): """Reset states of all children nodes in the given target. @@ -20,11 +49,28 @@ def reset_state(target: DynamicalSystem, *args, **kwargs): Args: target: The target DynamicalSystem. - *args: - **kwargs: """ - for node in target.nodes().subset(DynamicalSystem).not_subset(DynView).not_subset(IonChaDyn).unique().values(): - node.reset_state(*args, **kwargs) + dynsys.the_top_layer_reset_state = False + + try: + nodes = list(target.nodes().subset(DynamicalSystem).not_subset(DynView).not_subset(IonChaDyn).unique().values()) + nodes_with_level = [] + + # reset node whose `reset_state` has no `reset_level` + for node in nodes: + if not hasattr(node.reset_state, 'reset_level'): + node.reset_state(*args, **kwargs) + else: + nodes_with_level.append(node) + + # reset the node's states + for l in range(_max_level): + for node in nodes_with_level: + if node.reset_state.reset_level == l: + node.reset_state(*args, **kwargs) + + finally: + dynsys.the_top_layer_reset_state = True def clear_input(target: DynamicalSystem, *args, **kwargs): diff --git a/brainpy/_src/math/environment.py b/brainpy/_src/math/environment.py index b7a17bb9e..c81cd77de 100644 --- a/brainpy/_src/math/environment.py +++ b/brainpy/_src/math/environment.py @@ -709,7 +709,7 @@ def clear_buffer_memory( """ if array: - for buf in xla_bridge.get_backend(platform=platform).live_buffers(): + for buf in xla_bridge.get_backend(platform).live_buffers(): buf.delete() if compilation: jax.clear_caches() diff --git a/brainpy/_src/math/object_transform/autograd.py b/brainpy/_src/math/object_transform/autograd.py index 6122f6cd8..f5e091675 100644 --- a/brainpy/_src/math/object_transform/autograd.py +++ b/brainpy/_src/math/object_transform/autograd.py @@ -6,6 +6,7 @@ import jax import numpy as np + if jax.__version__ >= '0.4.16': from jax.extend import linear_util else: @@ -15,35 +16,27 @@ from jax._src.api import (_vjp, _jvp) from jax.api_util import argnums_partial from jax.interpreters import xla -from jax.tree_util import ( - tree_flatten, tree_unflatten, - tree_map, tree_transpose, - tree_structure -) +from jax.tree_util import (tree_flatten, tree_unflatten, + tree_map, tree_transpose, + tree_structure) from jax.util import safe_map from brainpy import tools, check from brainpy._src.math.ndarray import Array, _as_jax_array_ -from .tools import ( - dynvar_deprecation, - node_deprecation, - get_stack_cache, - cache_stack, -) -from .base import ( - BrainPyObject, - ObjectTransform -) -from .variables import ( - Variable, - VariableStack, - current_transform_number, - new_transform, -) +from .tools import (dynvar_deprecation, + node_deprecation, + get_stack_cache, + cache_stack) +from .base import (BrainPyObject, ObjectTransform) +from .variables import (Variable, + VariableStack, + current_transform_number, + new_transform) __all__ = [ 'grad', # gradient of scalar function 'vector_grad', # gradient of vector/matrix/... + 'functional_vector_grad', 'jacobian', 'jacrev', 'jacfwd', # gradient of jacobian 'hessian', # gradient of hessian ] @@ -466,7 +459,8 @@ def _std_basis(pytree): return _unravel_array_into_pytree(pytree, 1, flat_basis) -_isleaf = lambda x: isinstance(x, Array) +def _isleaf(x): + return isinstance(x, Array) def _jacrev(fun, argnums=0, holomorphic=False, allow_int=False, has_aux=False, return_value=False): @@ -594,9 +588,6 @@ def jacrev( def _jacfwd(fun, argnums=0, holomorphic=False, has_aux=False, return_value=False): _check_callable(fun) - if has_aux and jax.__version__ < '0.2.28': - raise NotImplementedError(f'"has_aux" only supported in jax>=0.2.28, but we detect ' - f'the current jax version is {jax.__version__}') @wraps(fun) def jacfun(*args, **kwargs): @@ -769,7 +760,7 @@ def hessian( return_value=return_value) -def _vector_grad(func, argnums=0, return_value=False, has_aux=False): +def functional_vector_grad(func, argnums=0, return_value=False, has_aux=False): _check_callable(func) @wraps(func) @@ -866,7 +857,7 @@ def vector_grad( if func is None: return lambda f: GradientTransform(target=f, - transform=_vector_grad, + transform=functional_vector_grad, grad_vars=grad_vars, dyn_vars=dyn_vars, child_objs=child_objs, @@ -875,7 +866,7 @@ def vector_grad( has_aux=False if has_aux is None else has_aux) else: return GradientTransform(target=func, - transform=_vector_grad, + transform=functional_vector_grad, grad_vars=grad_vars, dyn_vars=dyn_vars, child_objs=child_objs, diff --git a/brainpy/_src/tests/test_dynsys.py b/brainpy/_src/tests/test_dynsys.py index b7a2ebdab..f8605380e 100644 --- a/brainpy/_src/tests/test_dynsys.py +++ b/brainpy/_src/tests/test_dynsys.py @@ -1,3 +1,4 @@ +import unittest import brainpy as bp @@ -36,5 +37,19 @@ def update(self, tdi, x=None): B()(1.) +class TestResetLevelDecorator(unittest.TestCase): + _max_level = 10 # Define the maximum level for testing purposes + @bp.reset_level(5) + def test_function_with_reset_level_5(self): + self.assertEqual(self.test_function_with_reset_level_5.reset_level, 5) + def test1(self): + with self.assertRaises(ValueError): + @bp.reset_level(12) # This should raise a ValueError + def test_function_with_invalid_reset_level(self): + pass # Call the function here to trigger the ValueError + + @bp.reset_level(-3) + def test_function_with_negative_reset_level(self): + self.assertEqual(self.test_function_with_negative_reset_level.reset_level, self._max_level - 3) diff --git a/brainpy/_src/tests/test_helper.py b/brainpy/_src/tests/test_helper.py new file mode 100644 index 000000000..d8c85010b --- /dev/null +++ b/brainpy/_src/tests/test_helper.py @@ -0,0 +1,30 @@ +import brainpy as bp + +import unittest + + +class TestResetLevel(unittest.TestCase): + + def test1(self): + class Level0(bp.DynamicalSystem): + @bp.reset_level(0) + def reset_state(self, *args, **kwargs): + print('Level 0') + + class Level1(bp.DynamicalSystem): + @bp.reset_level(1) + def reset_state(self, *args, **kwargs): + print('Level 1') + + class Net(bp.DynamicalSystem): + def __init__(self): + super().__init__() + self.l0 = Level0() + self.l1 = Level1() + self.l0_2 = Level0() + self.l1_2 = Level1() + + net = Net() + net.reset() + + diff --git a/brainpy/math/oo_transform.py b/brainpy/math/oo_transform.py index 0b012f869..f3de18297 100644 --- a/brainpy/math/oo_transform.py +++ b/brainpy/math/oo_transform.py @@ -25,6 +25,7 @@ from brainpy._src.math.object_transform.autograd import ( grad as grad, vector_grad as vector_grad, + functional_vector_grad as functional_vector_grad, jacobian as jacobian, jacrev as jacrev, jacfwd as jacfwd, diff --git a/docs/tutorial_building/build_conductance_neurons.ipynb b/docs/tutorial_building/build_conductance_neurons.ipynb deleted file mode 100644 index 3656cd245..000000000 --- a/docs/tutorial_building/build_conductance_neurons.ipynb +++ /dev/null @@ -1,404 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Building Conductance-based Neuron Models" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "outputs": [], - "source": [ - "import brainpy as bp\n", - "import brainpy.math as bm\n", - "\n", - "bm.set_platform('cpu')" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.528689700Z", - "start_time": "2023-09-16T14:59:18.546835700Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [ - { - "data": { - "text/plain": "'2.4.4.post4'" - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bp.__version__" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.536485600Z", - "start_time": "2023-09-16T14:59:19.528689700Z" - } - } - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There are basically two types of neuron models: **conductance-based models** and **simplified models**. In conductance-based models, a single neuron can be regarded as a electric circuit, where the membrane is a capacitor, ion channels are conductors, and ion gradients are batteries. The neuronal activity is captured by the current flows through those ion channels. Sometimes there is an external input to this neuron, which can also be included in the equivalent circuit (see the figure below which shows potassium channels, sodium channels and leaky channels).\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "source": [ - "On the other hand, simplified models do not care about the physiological features of neurons but mainly focus on how to reproduce the exact spike timing. Therefore, they are more simplified and maybe not biologically explicable.\n", - "\n", - "BrainPy provides a large volume of predefined neuron models including conductance-based and simplified models for ease of use. In this section, we will only talk about how to build conductance-based models by ion channels. Users please refer to [Customizing Your Neuron Models](customize_neuron_models.ipynb) for more information." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Building an ion channel" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we have known, ion channels are crucial for conductance-based neuron models. So how do we model an ion channel? Let's take a look at the potassium channel for instance.\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The diagram above shows how a potassium channel is changed to an electric circuit. By this, we have the differential equation:\n", - "\n", - "$$\n", - "\\begin{align}\n", - "c_\\mathrm{M} \\frac{\\mathrm{d}V_\\mathrm{M}}{\\mathrm{d}t} &= \\frac{E_\\mathrm{K} - V_\\mathrm{M}}{R_\\mathrm{K}} \\\\\n", - "&= g_\\mathrm{K}(E_\\mathrm{K} - V_\\mathrm{M}),\n", - "\\end{align}\n", - "$$\n", - "\n", - "in which $c_\\mathrm{M}$ is the membrane capacitance, $\\mathrm{d}V_\\mathrm{M}$ is the membrane potential, $E_\\mathrm{K}$ is the equilibrium potential of potassium ions, and $R_\\mathrm{K}$ ($g_\\mathrm{K}$) refers to the resistance (conductance) of the potassium channel. We define currents from inside to outside as the positive direction.\n", - "\n", - "In the equation above, the conductance of potassium channels $g_\\mathrm{K}$ does not remain a constant, but changes according to the membrane potential, by which the channel is categorized as **voltage-gated ion channels**. If we want to build an ion channel model, we should figure out how the conductance of the ion channel changes with membrane potential.\n", - "\n", - "Fortunately, there has been a lot of work addressing this issue to formulate analytical expressions. For example, the conductance of one typical potassium channel can be written as:\n", - "\n", - "$$\n", - "\\begin{align}\n", - "g_\\mathrm{K} &= \\bar{g}_\\mathrm{K} n^4, \\\\\n", - "\\frac{\\mathrm{d}n}{\\mathrm{d}t} &= \\phi [\\alpha_n(V)(1-n) - \\beta_n(V)n],\n", - "\\end{align}\n", - "$$\n", - "\n", - "in which $\\bar{g}_\\mathrm{K}$ refers to the maximal conductance and $n$, also named the gating variable, refers to the probability (proportion) of potassium channels to open. $\\phi$ is a parameter showing the effects of temperature. In the differential equation of $n$, there are two parameters, $\\alpha_n(V)$ and $\\beta_n(V)$, that change with membrane potential:\n", - "\n", - "$$\n", - "\\begin{align}\n", - "\\alpha_n(V) &= \\frac{0.01(V+55)}{1 - \\exp(-\\frac{V+55}{10})}, \\\\\n", - "\\beta_n(V) &= 0.125 \\exp\\left(-\\frac{V+65}{80}\\right).\n", - "\\end{align}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we have learned the mathematical expression of the potassium channel. Next, we try to build this channel in BrainPy." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.541280600Z", - "start_time": "2023-09-16T14:59:19.536485600Z" - } - }, - "outputs": [], - "source": [ - "class IK(bp.dyn.IonChannel):\n", - " def __init__(self, size, E=-77., g_max=36., phi=1., method='exp_auto'):\n", - " super(IK, self).__init__(size)\n", - " self.g_max = g_max\n", - " self.E = E\n", - " self.phi = phi\n", - "\n", - " self.n = bm.Variable(bm.zeros(size)) # variables should be packed with bm.Variable\n", - " \n", - " self.integral = bp.odeint(self.dn, method=method)\n", - "\n", - " def dn(self, n, t, V):\n", - " alpha_n = 0.01 * (V + 55) / (1 - bm.exp(-(V + 55) / 10))\n", - " beta_n = 0.125 * bm.exp(-(V + 65) / 80)\n", - " return self.phi * (alpha_n * (1. - n) - beta_n * n)\n", - "\n", - " def update(self, V):\n", - " t = bp.share['t']\n", - " dt = bp.share['dt']\n", - " self.n.value = self.integral(self.n, t, V, dt=dt)\n", - "\n", - " def current(self, V):\n", - " return self.g_max * self.n ** 4 * (self.E - V)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that besides the initialzation and update function, **another function named ``current()`` that computes the current flow through this channel must be implemented**. Then this potassium channel model can be used as a building block for assembling a conductance-based neuron model." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Building a conductance-based neuron model with ion channels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Instead of building a conductance-based model from scratch, we can utilize ion channel models as building blocks to assemble a neuron model in a modular and convenient way. Now let's try to construct a **Hodgkin-Huxley (HH) model** (jump to [here](customize_neuron_models.ipynb) for the complete mathematical expression of the HH model).\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The HH neuron models the current flows of potassium, sodium, and leaky channels. Besides the potassium channel that we implemented, we can import the other channel models from ``brainpy.channels``:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then we wrap these three channels into a single neuron model:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.548873600Z", - "start_time": "2023-09-16T14:59:19.544788500Z" - } - }, - "outputs": [], - "source": [ - "class HH(bp.dyn.CondNeuGroup):\n", - " def __init__(self, size):\n", - " super(HH, self).__init__(size, V_initializer=bp.init.Uniform(-70, -50.))\n", - " self.IK = IK(size, E=-77., g_max=36.)\n", - " self.INa = bp.dyn.INa_HH1952(size, E=50., g_max=120.)\n", - " self.IL = bp.dyn.IL(size, E=-54.39, g_max=0.03)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here the `HH` class should inherit the superclass **`brainpy.dyn.CondNeuGroup`**, which will automatically integrate the current flows by calling the `current()` function of each channel model to compute the neuronal activity when running a simulation.\n", - "\n", - "Surprisingly, the model construction is finished! Users do not need to implement the update function of the neuron model as `brainpy.dyn.CondNeuGroup` has its own way to update variables (like the membrane potential `V` and spiking sequence `spike`) implicitly." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's run a simulation of this HH model to examine the changes of the inner variables.\n", - "\n", - "First of all, we instantiate a neuron group with 1 HH neuron:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.761147Z", - "start_time": "2023-09-16T14:59:19.548873600Z" - } - }, - "outputs": [], - "source": [ - "neu = HH(1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then we wrap the neuron group into a dynamical-system runner `DSRunner` for running a simulation:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:19.768678900Z", - "start_time": "2023-09-16T14:59:19.763422Z" - } - }, - "outputs": [], - "source": [ - "runner = bp.DSRunner(\n", - " neu, \n", - " monitors=['V', 'IK.n', 'INa.p', 'INa.q'], \n", - " inputs=('input', 6.) # constant external inputs of 6 mA to all neurons\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then we run the simulation and visualize the result:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:20.416477600Z", - "start_time": "2023-09-16T14:59:19.768678900Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": " 0%| | 0/2000 [00:00", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "runner.run(200) # the running time is 200 ms\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(runner.mon['ts'], runner.mon['V'])\n", - "plt.xlabel('t (ms)')\n", - "plt.ylabel('V (mV)')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also visualize the changes of the gating variables of sodium and potassium channels:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2023-09-16T14:59:20.523732100Z", - "start_time": "2023-09-16T14:59:20.418863800Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6, 2))\n", - "plt.plot(runner.mon['ts'], runner.mon['IK.n'], label='n')\n", - "plt.plot(runner.mon['ts'], runner.mon['INa.p'], label='m')\n", - "plt.plot(runner.mon['ts'], runner.mon['INa.q'], label='h')\n", - "plt.xlabel('t (ms)')\n", - "plt.legend()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By combining different ion channels, we can get different types of conductance-based neuron models easily and straightforwardly. To see all predefined channel models in BrainPy, please click [here](../apis/brainpy.dyn.neurons.rst)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/docs/tutorial_building/build_conductance_neurons_v2.ipynb b/docs/tutorial_building/build_conductance_neurons_v2.ipynb index 6ba02c79a..29549dd80 100644 --- a/docs/tutorial_building/build_conductance_neurons_v2.ipynb +++ b/docs/tutorial_building/build_conductance_neurons_v2.ipynb @@ -924,7 +924,6 @@ "plt.plot(runner.mon['ts'], runner.mon['V'])\n", "plt.xlabel('t (ms)')\n", "plt.ylabel('V (mV)')\n", - "plt.savefig(\"HH.jpg\")\n", "plt.show()\n", "\n", "plt.figure(figsize=(6, 2))\n",