diff --git a/brainpy/dyn/base.py b/brainpy/dyn/base.py index d48c773fb..ff94899c8 100644 --- a/brainpy/dyn/base.py +++ b/brainpy/dyn/base.py @@ -54,13 +54,13 @@ class DynamicalSystem(Base): """Global delay variables. Useful when the same target variable is used in multiple mappings.""" - global_delay_vars: Dict[str, bm.LengthDelay] = dict() + global_delay_vars: Dict[str, bm.LengthDelay] = Collector() def __init__(self, name=None): super(DynamicalSystem, self).__init__(name=name) # local delay variables - self.local_delay_vars: Dict[str, bm.LengthDelay] = dict() + self.local_delay_vars: Dict[str, bm.LengthDelay] = Collector() def __repr__(self): return f'{self.__class__.__name__}(name={self.name})' @@ -334,15 +334,17 @@ def reset(self): @classmethod def has(cls, **children_cls): - """ + """The aggressive operation to gather master and children classes. Parameters ---------- children_cls + The children classes. Returns ------- - + wrapper: ContainerWrapper + A wrapper which has master and its children classes. """ return ContainerWrapper(master=cls, **children_cls) diff --git a/brainpy/math/controls.py b/brainpy/math/controls.py index 5f86b0d04..6046878c1 100644 --- a/brainpy/math/controls.py +++ b/brainpy/math/controls.py @@ -169,9 +169,9 @@ def call(xs=None, length=None): turn_off_global_jit() except UnexpectedTracerError as e: turn_off_global_jit() - for v, d in zip(dyn_vars, init_values): v.value = d + for v, d in zip(dyn_vars, init_values): v._value = d raise errors.JaxTracerError(variables=dyn_vars) from e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d return tree_unflatten(tree, out_values), results else: @@ -189,7 +189,7 @@ def call(xs): turn_off_global_jit() for v, d in zip(dyn_vars, init_values): v._value = d raise e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d return tree_unflatten(tree, out_values) return call @@ -271,7 +271,7 @@ def call(x=None): turn_off_global_jit() for v, d in zip(dyn_vars, dyn_init): v._value = d raise e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d return call @@ -359,7 +359,7 @@ def call(pred, x=None): turn_off_global_jit() for v, d in zip(dyn_vars, old_values): v._value = d raise e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d return res else: @@ -477,7 +477,7 @@ def _false_fun(op): turn_off_global_jit() for v, d in zip(dyn_vars, old_values): v._value = d raise e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d else: turn_on_global_jit() res = lax.cond(pred, true_fun, false_fun, operands) @@ -663,7 +663,7 @@ def fun2scan(dyn_vals, x): turn_off_global_jit() for v, d in zip(dyn_vars, init_vals): v._value = d raise e - for v, d in zip(dyn_vars, dyn_vals): v.value = d + for v, d in zip(dyn_vars, dyn_vals): v._value = d return out_vals @@ -729,4 +729,4 @@ def _cond_fun(op): turn_off_global_jit() for v, d in zip(dyn_vars, dyn_init): v._value = d raise e - for v, d in zip(dyn_vars, dyn_values): v.value = d + for v, d in zip(dyn_vars, dyn_values): v._value = d diff --git a/brainpy/math/jit.py b/brainpy/math/jit.py index 5bde413e6..3242fda07 100644 --- a/brainpy/math/jit.py +++ b/brainpy/math/jit.py @@ -56,7 +56,7 @@ def call(*args, **kwargs): turn_off_global_jit() for key, v in vars.items(): v._value = variable_data[key] raise e - vars.assign(changes) + for key, v in vars.items(): v._value = changes[key] return out return change_func_name(name=f_name, f=call) if f_name else call diff --git a/docs/apis/dyn.rst b/docs/apis/dyn.rst index 2d3447c6e..922cfdcbe 100644 --- a/docs/apis/dyn.rst +++ b/docs/apis/dyn.rst @@ -13,4 +13,5 @@ auto/dyn/neurons auto/dyn/synapses auto/dyn/rates + auto/dyn/others auto/dyn/runners \ No newline at end of file diff --git a/docs/auto_generater.py b/docs/auto_generater.py index 4e7d2337f..c1d6090e1 100644 --- a/docs/auto_generater.py +++ b/docs/auto_generater.py @@ -255,7 +255,6 @@ def generate_dyn_docs(path='apis/auto/dyn/'): module_and_name = [ ('biological_models', 'Biological Models'), ('fractional_models', 'Fractional-order Models'), - ('input_models', 'Input Models'), ('reduced_models', 'Reduced Models'), ] write_submodules(module_name='brainpy.dyn.neurons', @@ -278,7 +277,6 @@ def generate_dyn_docs(path='apis/auto/dyn/'): module_and_name = [ ('populations', 'Population Models'), ('couplings', 'Coupling Models'), - ('noises', 'Noise Models'), ] write_submodules(module_name='brainpy.dyn.rates', filename=os.path.join(path, 'rates.rst'), @@ -286,6 +284,16 @@ def generate_dyn_docs(path='apis/auto/dyn/'): submodule_names=[a[0] for a in module_and_name], section_names=[a[1] for a in module_and_name]) + module_and_name = [ + ('noises', 'Noise Models'), + ('inputs', 'Input Models'), + ] + write_submodules(module_name='brainpy.dyn.others', + filename=os.path.join(path, 'others.rst'), + header='Helper Models', + submodule_names=[a[0] for a in module_and_name], + section_names=[a[1] for a in module_and_name]) + write_module(module_name='brainpy.dyn.runners', filename=os.path.join(path, 'runners.rst'), header='Runners') diff --git a/docs/index.rst b/docs/index.rst index b3f3f19fd..0973c3f8e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -59,8 +59,8 @@ The code of BrainPy is open-sourced at GitHub: tutorial_toolbox/ode_numerical_solvers tutorial_toolbox/sde_numerical_solvers - tutorial_toolbox/dde_numerical_solvers tutorial_toolbox/fde_numerical_solvers + tutorial_toolbox/dde_numerical_solvers tutorial_toolbox/joint_equations tutorial_toolbox/synaptic_connections tutorial_toolbox/synaptic_weights diff --git a/docs/tutorial_toolbox/fde_numerical_solvers.ipynb b/docs/tutorial_toolbox/fde_numerical_solvers.ipynb index dc2492958..1f6bdcf09 100644 --- a/docs/tutorial_toolbox/fde_numerical_solvers.ipynb +++ b/docs/tutorial_toolbox/fde_numerical_solvers.ipynb @@ -46,7 +46,7 @@ "source": [ "Factional differential equations have several definitions. It can be defined in a variety of different ways that do often do not all lead to the same result even for smooth functions. In neuroscience, we usually use the following two definitions:\n", "\n", - "- Riemann–Liouville fractional derivative\n", + "- Grünwald-Letnikov derivative\n", "- Caputo fractional derivative\n", "\n", "See [Fractional calculus - Wikipedia](https://en.wikipedia.org/wiki/Fractional_calculus) for more details." @@ -421,7 +421,7 @@ { "cell_type": "markdown", "source": [ - "## Methods for Riemann–Liouville FDEs" + "## Methods for Grünwald-Letnikov FDEs" ], "metadata": { "collapsed": false, diff --git a/docs/tutorial_toolbox/initializing_connection_weights.ipynb b/docs/tutorial_toolbox/initializing_connection_weights.ipynb deleted file mode 100644 index 9152fb35e..000000000 --- a/docs/tutorial_toolbox/initializing_connection_weights.ipynb +++ /dev/null @@ -1,554 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "d67d4fa4", - "metadata": {}, - "source": [ - "# Connection Weight Initialization" - ] - }, - { - "cell_type": "markdown", - "id": "c69f432f", - "metadata": {}, - "source": [ - "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" - ] - }, - { - "cell_type": "markdown", - "id": "d579e1e5", - "metadata": {}, - "source": [ - "After a neural network is constructed, the connection weights of different layers should be initialized. The ``brainpy.training.initialize`` module provides some built-in initializers. Besides, users can customize the initializers of their own. Here we will briefly talk about how to use these built-in initializers and how to create customized initializers." - ] - }, - { - "cell_type": "markdown", - "id": "2f48218a", - "metadata": {}, - "source": [ - "## General Structure of Initializers" - ] - }, - { - "cell_type": "markdown", - "id": "804f757f", - "metadata": {}, - "source": [ - "### Base Class: bp.init.Initializer" - ] - }, - { - "cell_type": "markdown", - "id": "456657ed", - "metadata": {}, - "source": [ - "Initializers initialize the coonection weights between two groups of neurons (though they can refer to the same group). The base class of initializers are [`brainpy.training.initialize.Initializer`](../apis/auto/training/initialize.rst), which can be accessed by the shortcut `bp.init`. All initializers, built-in or costumized, should inherit the `Initializer` class. \n", - "\n", - "Weight initialization is implemented in the `__call__` function, so that it can be realized automatically when the initializer is called. The `__call__` function has a `shape` parameter that has different meanings in the following two superclasses and returns a matrix containing initialized weights." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "bde31457", - "metadata": {}, - "outputs": [], - "source": [ - "import brainpy as bp\n", - "# bp.training.initialize can be accessed by bp.init\n", - "\n", - "bp.math.set_platform('cpu')" - ] - }, - { - "cell_type": "markdown", - "id": "2edfba91", - "metadata": {}, - "source": [ - "### Superclass 1: bp.init.InterLayerInitializer" - ] - }, - { - "cell_type": "markdown", - "id": "00908305", - "metadata": {}, - "source": [ - "The [`InterLayerInitializer`](../apis/auto/training/initialize.rst) is an abstract subclass of `Initializer`. Subclasses of `InterLayerInitializer` initialize the weights between two fully connected layers. The `shape` parameter of the `__call__` function should be a 2-element tuple $(m, n)$, which refers to the number of presynaptic neurons $m$ and of postsynaptic neurons $n$. The output of the `__call__` function is a `bp.math.ndarray` with the shape of $(m, n)$, where the value at $(i, j)$ is the initialized weight of the presynaptic neuron $i$ to postsynpatic neuron $j$." - ] - }, - { - "cell_type": "markdown", - "id": "bd8fb450", - "metadata": {}, - "source": [ - "### Superclass 2: bp.init.IntraLayerInitializer" - ] - }, - { - "cell_type": "markdown", - "id": "08c79681", - "metadata": {}, - "source": [ - "The [`IntraLayerInitializer`](../apis/auto/training/initialize.rst) is also an abstract subclass of `Initializer`. Subclasses of `InterLayerInitializer` initialize the weights within a layer. The `shape` parameter of the `__call__` function refers to the the structure of the neural population $(n_1, n_2, ..., n_d)$. The `__call__` function returns a 2-D `bp.math.ndarray` with the shape of $(\\prod_{k=1}^d n_k, \\prod_{k=1}^d n_k)$. In the 2-D array, the value at $(i, j)$ is the initialized weight of neuron $i$ to neuron $j$ of the flattened neural sequence." - ] - }, - { - "cell_type": "markdown", - "id": "be9a3ca9", - "metadata": {}, - "source": [ - "## Built-In Regular Initializers" - ] - }, - { - "cell_type": "markdown", - "id": "8d0f9f82", - "metadata": {}, - "source": [ - "Regular initializers all belong to `InterLayerInitializer` and initialize the connection weights between two layers with a regular pattern. There are `ZeroInit`, `OneInit`, and `Identity` initializers in built-in regular initializers. Here we show how to use the `OneInit` initializer. The remaining two classes are used in a similar way. See [Weight Initialization](../apis/auto/training/initialize.rst) for more details." - ] - }, - { - "cell_type": "markdown", - "id": "6e528f29", - "metadata": {}, - "source": [ - "### bp.init.OneInit" - ] - }, - { - "cell_type": "markdown", - "id": "c7419de2", - "metadata": {}, - "source": [ - "This initializer initializes all the weights with the same given value. In the following example, 5 presynaptic neurons are fully connected to 6 postsynaptic neurons with the same weight value:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "62387bba", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# visualization\n", - "def mat_visualize(matrix, cmap=plt.cm.get_cmap('coolwarm')):\n", - " im = plt.matshow(matrix, cmap=cmap)\n", - " plt.colorbar(mappable=im, shrink=0.8, aspect=15)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a815be5f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "JaxArray(DeviceArray([[2.5, 2.5, 2.5, 2.5, 2.5, 2.5],\n", - " [2.5, 2.5, 2.5, 2.5, 2.5, 2.5],\n", - " [2.5, 2.5, 2.5, 2.5, 2.5, 2.5],\n", - " [2.5, 2.5, 2.5, 2.5, 2.5, 2.5],\n", - " [2.5, 2.5, 2.5, 2.5, 2.5, 2.5]], dtype=float32))\n" - ] - } - ], - "source": [ - "shape = (5, 6)\n", - "one_init = bp.init.OneInit(value=2.5)\n", - "weights = one_init(shape)\n", - "print(weights)" - ] - }, - { - "cell_type": "markdown", - "id": "824db6d9", - "metadata": {}, - "source": [ - "## Built-In Random Initializers" - ] - }, - { - "cell_type": "markdown", - "id": "c57a12b1", - "metadata": {}, - "source": [ - "Random initializers all belong to `InterLayerInitializer` and initialize the connection weights between two layers with a random distribution. There are `Normal`, `Uniform`, `Orthogonal` and other initializers in built-in regular initializers. Here we show how to use the `Normal` and `Uniform` initializer. See [Weight Initialization](../apis/auto/training/initialize.rst) for more details." - ] - }, - { - "cell_type": "markdown", - "id": "ba256cfa", - "metadata": {}, - "source": [ - "### bp.init.Normal" - ] - }, - { - "cell_type": "markdown", - "id": "518cede6", - "metadata": {}, - "source": [ - "This initializer initializes the weights with a normal distribution. The variance of the distribution changes according to the `scale` parameter. In the following example, 10 presynaptic neurons are fully connected to 20 postsynaptic neurons with the same weight value:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "99f74e71", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "shape = (10, 20)\n", - "normal_init = bp.init.Normal(scale=1.0)\n", - "weights = normal_init(shape)\n", - "mat_visualize(weights)" - ] - }, - { - "cell_type": "markdown", - "id": "7ce49cea", - "metadata": {}, - "source": [ - "### bp.init.Uniform" - ] - }, - { - "cell_type": "markdown", - "id": "36003d3b", - "metadata": {}, - "source": [ - "This initializer initializes the weights with a uniform distribution. The variance of the distribution changes according to the `scale` parameter. In the following example, 10 presynaptic neurons are fully connected to 20 postsynaptic neurons with the same weight value:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "694f6017", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "shape = (10, 20)\n", - "uniform_init = bp.init.Uniform(min_val=0., max_val=1.)\n", - "weights = uniform_init(shape)\n", - "mat_visualize(weights)" - ] - }, - { - "cell_type": "markdown", - "id": "8d63ac24", - "metadata": {}, - "source": [ - "## Built-In Decay Initializers" - ] - }, - { - "cell_type": "markdown", - "id": "aae2fd22", - "metadata": {}, - "source": [ - "Decay initializers all belong to `IntraLayerInitializer` and initialize the connection weights within a layer with a decay function according to the neural distance. There are `GaussianDecay` and `DOGDecay` initializers in built-in decay initializers. Below are examples of how to use them." - ] - }, - { - "cell_type": "markdown", - "id": "b26c0a47", - "metadata": {}, - "source": [ - "### brainpy.training.initialize.GaussianDecay" - ] - }, - { - "cell_type": "markdown", - "id": "17488f64", - "metadata": {}, - "source": [ - "This initializer creates a Gaussian connectivity pattern within a population of neurons, where the weights decay with a gaussian function.\n", - "Specifically, for any pair of neurons $ (i, j) $, the weight is computed as\n", - "\n", - "$$\n", - "w(i, j) = w_{max} \\cdot \\exp(-\\frac{\\sum_{k=1}^n |v_k^i - v_k^j|^2 }{2\\sigma^2})\n", - "$$\n", - "\n", - "where $ v_k^i $ is the $ i $-th neuron's encoded value (position) at dimension $ k $.\n", - "\n", - "The example below is a neural population with the size of $ 5 \\times 5 $. Note that this shape is the structure of the target neural population, not the size of presynaptic and postsynaptic neurons." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "50c68a98", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "shape of weights: (25, 25)\n" - ] - } - ], - "source": [ - "size = (5, 5)\n", - "gaussian_init = bp.init.GaussianDecay(sigma=2., max_w=10., include_self=True)\n", - "weights = gaussian_init(size)\n", - "print('shape of weights: {}'.format(weights.shape))" - ] - }, - { - "cell_type": "markdown", - "id": "6e23ccde", - "metadata": {}, - "source": [ - "Self-connections are created if `include_self=True`. The connection weights of each neuron with others are stored in each row of `weights`. For instance, the connection weights of neuron(0, 0) to other neurons are stored in `weights[0]`. After reshaping, the weights are:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5ead905c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mat_visualize(weights[0].reshape(size), cmap=plt.cm.get_cmap('Reds'))" - ] - }, - { - "cell_type": "markdown", - "id": "f7a25e57", - "metadata": {}, - "source": [ - "### brainpy.training.initialize.DOGDecay" - ] - }, - { - "cell_type": "markdown", - "id": "7b56e0dd", - "metadata": {}, - "source": [ - "This initializer creates a Difference-Of-Gaussian (DOG) connectivity pattern within a population of neurons. Specifically, for the given pair of neurons $ (i, j) $, the weight between them is computed as\n", - "\n", - "$$\n", - "w(i, j) = w_{max}^+ \\cdot \\exp(-\\frac{\\sum_{k=1}^n |v_k^i - v_k^j|^2}{2\\sigma_+^2}) - w_{max}^- \\cdot \\exp(-\\frac{\\sum_{k=1}^n |v_k^i - v_k^j|^2}{2\\sigma_-^2})\n", - "$$\n", - "\n", - "where $ v_k^i $ is the $ i $-th neuron's encoded value (position) at dimension $ k $.\n", - "\n", - "\n", - "\n", - "The example below is a neural population with the size of $ 10 \\times 10 $:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "9a4701d5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "shape of weights: (100, 100)\n" - ] - } - ], - "source": [ - "size = (10, 10)\n", - "gaussian_init = bp.init.DOGDecay(sigmas=(1., 3.), max_ws=(10., 5.), min_w=0.1, include_self=True)\n", - "weights = gaussian_init(size)\n", - "print('shape of weights: {}'.format(weights.shape))" - ] - }, - { - "cell_type": "markdown", - "id": "18203c26", - "metadata": {}, - "source": [ - "Weights smaller than `min_w` will not be created. `min_w` $ = 0.005 \\times min( $ `max_ws` $ ) $ if it is not assigned with a value.\n", - "The organization of `weights` is similar to that in the `GaussianDecay` initializer. For instance, the connection weights of neuron (3, 4) to other neurons after reshaping are shown as below:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e29818d4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mat_visualize(weights[34].reshape(size), cmap=plt.cm.get_cmap('Reds'))" - ] - }, - { - "cell_type": "markdown", - "id": "77c73b63", - "metadata": {}, - "source": [ - "## Customize your initializers" - ] - }, - { - "cell_type": "markdown", - "id": "0a8852bf", - "metadata": {}, - "source": [ - "BrainPy also allows users to customize the weight initializers of their own. When customizing a initializer, users should follow the instructions below:\n", - "- Your initializer should inherit `brainpy.training.initialize.Initializer`.\n", - "- Override the `__call__` funtion, to which the `shape` parameter should be given.\n", - "\n", - "Here is an example of creating an inter-layer initializer that initialize the weights as follows:\n", - "\n", - "$$\n", - "w(i, j) = max(w_{max} - \\sigma |v_i - v_j|, 0)\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c0d03e7f", - "metadata": {}, - "outputs": [], - "source": [ - "class LinearDecay(bp.init.InterLayerInitializer):\n", - " def __init__(self, max_w, sigma=1.):\n", - " self.max_w = max_w\n", - " self.sigma = sigma\n", - " \n", - " def __call__(self, shape, dtype=None):\n", - " mat = bp.math.zeros(shape, dtype=dtype)\n", - " n_pre, n_post = shape\n", - " seq = np.arange(n_pre)\n", - " current_w = self.max_w\n", - " \n", - " for i in range(max(n_pre, n_post)):\n", - " if current_w <= 0:\n", - " break\n", - " seq_plus = ((seq + i) >= 0) & ((seq + i) < n_post)\n", - " seq_minus = ((seq - i) >= 0) & ((seq - i) < n_post)\n", - " mat[seq[seq_plus], (seq + i)[seq_plus]] = current_w\n", - " mat[seq[seq_minus], (seq - i)[seq_minus]] = current_w\n", - " current_w -= self.sigma\n", - " \n", - " return mat" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0c327190", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "shape = (10, 15)\n", - "lin_init = LinearDecay(max_w=5, sigma=1.)\n", - "weights = lin_init(shape)\n", - "mat_visualize(weights, cmap=plt.cm.get_cmap('Reds'))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cd5d5480", - "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" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/examples/simulation/Wang_2002_decision_making_spiking.py b/examples/simulation/Wang_2002_decision_making_spiking.py index 1d2e60f68..ecc0cde81 100644 --- a/examples/simulation/Wang_2002_decision_making_spiking.py +++ b/examples/simulation/Wang_2002_decision_making_spiking.py @@ -3,6 +3,7 @@ import brainpy as bp import brainpy.math as bm +bp.check.turn_off() bm.set_platform('cpu') import matplotlib.pyplot as plt