diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml new file mode 100644 index 000000000..d547100d3 --- /dev/null +++ b/.github/workflows/docker.yml @@ -0,0 +1,59 @@ +name: Docker + +on: + release: + types: [published] + pull_request: + paths: + - docker/** + - .github/workflows/docker.yml + + +jobs: + docker-build-push: + if: | + github.repository_owner == 'brainpy' || + github.event_name != 'release' + runs-on: ubuntu-22.04 + strategy: + matrix: + include: + - context: "docker/" + base: "brainpy/brainpy" + env: + TARGET_PLATFORMS: linux/amd64 + REGISTRY: ghcr.io + IMAGE_NAME: ${{ github.repository }} + DOCKER_TAG_NAME: | + ${{ + (github.event_name == 'release' && github.event.release.tag_name) || + 'pull-request-test' + }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Login to DockerHub + if: github.event_name != 'pull_request' + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Docker Build & Push (version tag) + uses: docker/build-push-action@v4 + with: + context: ${{ matrix.context }} + tags: ${{ matrix.base }}:${{ env.DOCKER_TAG_NAME }} + push: ${{ github.event_name != 'pull_request' }} + platforms: ${{ env.TARGET_PLATFORMS }} + + - name: Docker Build & Push (latest tag) + if: | + (github.event_name == 'release' && ! github.event.release.prerelease) + uses: docker/build-push-action@v4 + with: + context: ${{ matrix.context }} + tags: ${{ matrix.base }}:latest + push: ${{ github.event_name != 'pull_request' }} + platforms: ${{ env.TARGET_PLATFORMS }} \ No newline at end of file diff --git a/.gitignore b/.gitignore index dec4fa91d..29424003d 100644 --- a/.gitignore +++ b/.gitignore @@ -225,3 +225,4 @@ cython_debug/ /docs/tutorial_advanced/data/ /my_tests/ /examples/dynamics_simulation/Joglekar_2018_data/ +/docs/apis/deprecated/generated/ diff --git a/ACKNOWLEDGMENTS.md b/ACKNOWLEDGMENTS.md new file mode 100644 index 000000000..caf968c4a --- /dev/null +++ b/ACKNOWLEDGMENTS.md @@ -0,0 +1,13 @@ +# Acknowledgments + +The development of BrainPy is being or has been supported by many organizations, programs, and individuals since 2020. +The following list of support received is therefore necessarily incomplete. + + +This project has received funding from Science and Technology Innovation 2030 (China Brain Project): + +- Brain Science and Brain-inspired Intelligence Project (No. 2021ZD0200204). + +Additionally, BrainPy gratefully acknowledges the support and funding received from: + +- Beijing Academy of Artificial Intelligence. diff --git a/README.md b/README.md index 8d98ceaab..263d74568 100644 --- a/README.md +++ b/README.md @@ -34,22 +34,37 @@ $ pip install brainpy brainpylib -U For detailed installation instructions, please refer to the documentation: [Quickstart/Installation](https://brainpy.readthedocs.io/en/latest/quickstart/installation.html) +### Using BrainPy with docker + +We provide a docker image for BrainPy. You can use the following command to pull the image: +```bash +$ docker pull brainpy/brainpy:latest +``` + +Then, you can run the image with the following command: +```bash +$ docker run -it --platform linux/amd64 brainpy/brainpy:latest +``` + +### Using BrainPy with Binder + +We provide a Binder environment for BrainPy. You can use the following button to launch the environment: + +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/brainpy/BrainPy-binder/main) + ## Ecosystem - **[BrainPy](https://github.com/brainpy/BrainPy)**: The solution for the general-purpose brain dynamics programming. - **[brainpy-examples](https://github.com/brainpy/examples)**: Comprehensive examples of BrainPy computation. - **[brainpy-datasets](https://github.com/brainpy/datasets)**: Neuromorphic and Cognitive Datasets for Brain Dynamics Modeling. -## Citing and Funding - -If you are using ``brainpy``, please consider citing [the corresponding papers](https://brainpy.readthedocs.io/en/latest/tutorial_FAQs/citing_and_publication.html). +## Citing BrainPy is developed by a team in Neural Information Processing Lab at Peking University, China. Our team is committed to the long-term maintenance and development of the project. -Moreover, the development of BrainPy is being or has been supported by Science and Technology -Innovation 2030 - Brain Science and Brain-inspired Intelligence Project (China Brain Project), -and Beijing Academy of Artificial Intelligence. +If you are using ``brainpy``, please consider citing [the corresponding papers](https://brainpy.readthedocs.io/en/latest/tutorial_FAQs/citing_and_publication.html). + ## Ongoing development plans diff --git a/brainpy/__init__.py b/brainpy/__init__.py index c31989a2a..97f5aa304 100644 --- a/brainpy/__init__.py +++ b/brainpy/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -__version__ = "2.4.4.post3" +__version__ = "2.4.4.post4" # fundamental supporting modules from brainpy import errors, check, tools diff --git a/brainpy/_src/delay.py b/brainpy/_src/delay.py index 9b9e7bf01..8ffdc05e6 100644 --- a/brainpy/_src/delay.py +++ b/brainpy/_src/delay.py @@ -327,7 +327,7 @@ def retrieve(self, delay_step, *indices): if self.method == ROTATE_UPDATE: i = share.load('i') - delay_idx = bm.as_jax((delay_step - i - 1) % self.max_length) + delay_idx = bm.as_jax((delay_step - i - 1) % self.max_length, dtype=jnp.int32) delay_idx = jax.lax.stop_gradient(delay_idx) elif self.method == CONCAT_UPDATE: @@ -358,7 +358,7 @@ def update( # update the delay data at the rotation index if self.method == ROTATE_UPDATE: i = share.load('i') - idx = bm.as_jax((-i - 1) % self.max_length) + idx = bm.as_jax((-i - 1) % self.max_length, dtype=jnp.int32) self.data[idx] = latest_value # update the delay data at the first position diff --git a/brainpy/_src/dnn/linear.py b/brainpy/_src/dnn/linear.py index 3bdc3a31c..5fdee8d99 100644 --- a/brainpy/_src/dnn/linear.py +++ b/brainpy/_src/dnn/linear.py @@ -10,12 +10,12 @@ from brainpy import math as bm from brainpy._src import connect, initialize as init from brainpy._src.context import share -from brainpy.algorithms import OnlineAlgorithm, OfflineAlgorithm from brainpy.check import is_initializer from brainpy.errors import MathError from brainpy.initialize import XavierNormal, ZeroInit, Initializer, parameter from brainpy.types import ArrayType, Sharding from brainpy._src.dnn.base import Layer +from brainpy._src.mixin import SupportOnline, SupportOffline, SupportSTDP __all__ = [ 'Dense', 'Linear', @@ -29,14 +29,14 @@ ] -class Dense(Layer): +class Dense(Layer, SupportOnline, SupportOffline, SupportSTDP): r"""A linear transformation applied over the last dimension of the input. Mathematically, this node can be defined as: .. math:: - y = x \cdot W + b + y = x \cdot weight + b Parameters ---------- @@ -44,7 +44,7 @@ class Dense(Layer): The number of the input feature. A positive integer. num_out: int The number of the output features. A positive integer. - W_initializer: optional, Initializer + weight_initializer: optional, Initializer The weight initialization. b_initializer: optional, Initializer The bias initialization. @@ -52,12 +52,6 @@ class Dense(Layer): Enable training this node or not. (default True) """ - online_fit_by: Optional[OnlineAlgorithm] - '''Online fitting method.''' - - offline_fit_by: Optional[OfflineAlgorithm] - '''Offline fitting method.''' - def __init__( self, num_in: int, @@ -80,13 +74,13 @@ def __init__( f'a positive integer. Received: num_out={num_out}') # weight initializer - self.weight_initializer = W_initializer + self.W_initializer = W_initializer self.bias_initializer = b_initializer is_initializer(W_initializer, 'weight_initializer') is_initializer(b_initializer, 'bias_initializer', allow_none=True) # parameter initialization - W = parameter(self.weight_initializer, (num_in, self.num_out)) + W = parameter(self.W_initializer, (num_in, self.num_out)) b = parameter(self.bias_initializer, (self.num_out,)) if isinstance(self.mode, bm.TrainingMode): W = bm.TrainVar(W) @@ -95,8 +89,8 @@ def __init__( self.b = b # fitting parameters - self.online_fit_by = None - self.offline_fit_by = None + self.online_fit_by = None # support online training + self.offline_fit_by = None # support offline training self.fit_record = dict() def __repr__(self): @@ -204,6 +198,20 @@ def offline_fit(self, self.W.value = Wff self.b.value = bias[0] + def update_STDP(self, dW, constraints=None): + if isinstance(self.W, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + if self.W.shape != dW.shape: + raise ValueError(f'The shape of delta_weight {dW.shape} ' + f'should be the same as the shape of weight {self.W.shape}.') + if not isinstance(self.W, bm.Variable): + self.tracing_variable('W', self.W, self.W.shape) + self.W += dW + if constraints is not None: + self.W.value = constraints(self.W) + Linear = Dense @@ -219,7 +227,7 @@ def update(self, x): return x -class AllToAll(Layer): +class AllToAll(Layer, SupportSTDP): """Synaptic matrix multiplication with All2All connections. Args: @@ -281,8 +289,23 @@ def update(self, pre_val): post_val = pre_val @ self.weight return post_val + def update_STDP(self, dW, constraints=None): + if isinstance(self.weight, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + if self.weight.shape != dW.shape: + raise ValueError(f'The shape of delta_weight {dW.shape} ' + f'should be the same as the shape of weight {self.weight.shape}.') + if not isinstance(self.weight, bm.Variable): + self.tracing_variable('weight', self.weight, self.weight.shape) + self.weight += dW + if constraints is not None: + self.weight.value = constraints(self.weight) + + -class OneToOne(Layer): +class OneToOne(Layer, SupportSTDP): """Synaptic matrix multiplication with One2One connection. Args: @@ -315,8 +338,23 @@ def __init__( def update(self, pre_val): return pre_val * self.weight - -class MaskedLinear(Layer): + def update_STDP(self, dW, constraints=None): + if isinstance(self.weight, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + dW = dW.sum(axis=0) + if self.weight.shape != dW.shape: + raise ValueError(f'The shape of delta_weight {dW.shape} ' + f'should be the same as the shape of weight {self.weight.shape}.') + if not isinstance(self.weight, bm.Variable): + self.tracing_variable('weight', self.weight, self.weight.shape) + self.weight += dW + if constraints is not None: + self.weight.value = constraints(self.weight) + + +class MaskedLinear(Layer, SupportSTDP): r"""Synaptic matrix multiplication with masked dense computation. It performs the computation of: @@ -369,8 +407,23 @@ def __init__( def update(self, x): return x @ self.mask_fun(self.weight * self.mask) + def update_STDP(self, dW, constraints=None): + if isinstance(self.weight, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + if self.weight.shape != dW.shape: + raise ValueError(f'The shape of delta_weight {dW.shape} ' + f'should be the same as the shape of weight {self.weight.shape}.') + if not isinstance(self.weight, bm.Variable): + self.tracing_variable('weight', self.weight, self.weight.shape) + + self.weight += dW + if constraints is not None: + self.weight.value = constraints(self.weight) + -class CSRLinear(Layer): +class CSRLinear(Layer, SupportSTDP): r"""Synaptic matrix multiplication with CSR sparse computation. It performs the computation of: @@ -438,6 +491,22 @@ def _batch_csrmv(self, x): transpose=self.transpose, method=self.method) + def update_STDP(self, dW, constraints=None): + if isinstance(self.weight, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + pre_ids, post_ids = bm.sparse.csr_to_coo(self.indices, self.indptr) + sparse_dW = dW[pre_ids, post_ids] + if self.weight.shape != sparse_dW.shape: + raise ValueError(f'The shape of sparse delta_weight {sparse_dW.shape} ' + f'should be the same as the shape of sparse weight {self.weight.shape}.') + if not isinstance(self.weight, bm.Variable): + self.tracing_variable('weight', self.weight, self.weight.shape) + self.weight += sparse_dW + if constraints is not None: + self.weight.value = constraints(self.weight) + class CSCLinear(Layer): r"""Synaptic matrix multiplication with CSC sparse computation. @@ -474,7 +543,7 @@ def __init__( self.sharding = sharding -class EventCSRLinear(Layer): +class EventCSRLinear(Layer, SupportSTDP): r"""Synaptic matrix multiplication with event CSR sparse computation. It performs the computation of: @@ -538,6 +607,22 @@ def _batch_csrmv(self, x): shape=(self.conn.pre_num, self.conn.post_num), transpose=self.transpose) + def update_STDP(self, dW, constraints=None): + if isinstance(self.weight, float): + raise ValueError(f'Cannot update the weight of a constant node.') + if not isinstance(dW, (bm.ndarray, jnp.ndarray, np.ndarray)): + raise ValueError(f'"delta_weight" must be a array, but got {type(dW)}') + pre_ids, post_ids = bm.sparse.csr_to_coo(self.indices, self.indptr) + sparse_dW = dW[pre_ids, post_ids] + if self.weight.shape != sparse_dW.shape: + raise ValueError(f'The shape of sparse delta_weight {sparse_dW.shape} ' + f'should be the same as the shape of sparse weight {self.weight.shape}.') + if not isinstance(self.weight, bm.Variable): + self.tracing_variable('weight', self.weight, self.weight.shape) + self.weight += sparse_dW + if constraints is not None: + self.weight.value = constraints(self.weight) + class BcsrMM(Layer): r"""Synaptic matrix multiplication with BCSR sparse computation. diff --git a/brainpy/_src/dyn/base.py b/brainpy/_src/dyn/base.py index e318eee4b..e18ac2a82 100644 --- a/brainpy/_src/dyn/base.py +++ b/brainpy/_src/dyn/base.py @@ -1,19 +1,19 @@ # -*- coding: utf-8 -*- from brainpy._src.dynsys import Dynamic -from brainpy._src.mixin import AutoDelaySupp, ParamDesc +from brainpy._src.mixin import SupportAutoDelay, ParamDesc __all__ = [ 'NeuDyn', 'SynDyn', 'IonChaDyn', ] -class NeuDyn(Dynamic, AutoDelaySupp): +class NeuDyn(Dynamic, SupportAutoDelay): """Neuronal Dynamics.""" pass -class SynDyn(Dynamic, AutoDelaySupp, ParamDesc): +class SynDyn(Dynamic, SupportAutoDelay, ParamDesc): """Synaptic Dynamics.""" pass diff --git a/brainpy/_src/dyn/projections/aligns.py b/brainpy/_src/dyn/projections/aligns.py index 2dfa2dd14..23b907286 100644 --- a/brainpy/_src/dyn/projections/aligns.py +++ b/brainpy/_src/dyn/projections/aligns.py @@ -4,7 +4,7 @@ from brainpy._src.delay import Delay, DelayAccess, delay_identifier, init_delay_by_return from brainpy._src.dynsys import DynamicalSystem, Projection from brainpy._src.mixin import (JointType, ParamDescInit, ReturnInfo, - AutoDelaySupp, BindCondData, AlignPost) + SupportAutoDelay, BindCondData, AlignPost) __all__ = [ 'VanillaProj', @@ -297,7 +297,7 @@ def update(self, inp): def __init__( self, - pre: JointType[DynamicalSystem, AutoDelaySupp], + pre: JointType[DynamicalSystem, SupportAutoDelay], delay: Union[None, int, float], comm: DynamicalSystem, syn: ParamDescInit[JointType[DynamicalSystem, AlignPost]], @@ -310,7 +310,7 @@ def __init__( super().__init__(name=name, mode=mode) # synaptic models - check.is_instance(pre, JointType[DynamicalSystem, AutoDelaySupp]) + check.is_instance(pre, JointType[DynamicalSystem, SupportAutoDelay]) check.is_instance(comm, DynamicalSystem) check.is_instance(syn, ParamDescInit[JointType[DynamicalSystem, AlignPost]]) check.is_instance(out, ParamDescInit[JointType[DynamicalSystem, BindCondData]]) @@ -507,7 +507,7 @@ def update(self, inp): def __init__( self, - pre: JointType[DynamicalSystem, AutoDelaySupp], + pre: JointType[DynamicalSystem, SupportAutoDelay], delay: Union[None, int, float], comm: DynamicalSystem, syn: JointType[DynamicalSystem, AlignPost], @@ -520,7 +520,7 @@ def __init__( super().__init__(name=name, mode=mode) # synaptic models - check.is_instance(pre, JointType[DynamicalSystem, AutoDelaySupp]) + check.is_instance(pre, JointType[DynamicalSystem, SupportAutoDelay]) check.is_instance(comm, DynamicalSystem) check.is_instance(syn, JointType[DynamicalSystem, AlignPost]) check.is_instance(out, JointType[DynamicalSystem, BindCondData]) @@ -631,7 +631,7 @@ def update(self, inp): def __init__( self, pre: DynamicalSystem, - syn: ParamDescInit[JointType[DynamicalSystem, AutoDelaySupp]], + syn: ParamDescInit[JointType[DynamicalSystem, SupportAutoDelay]], delay: Union[None, int, float], comm: DynamicalSystem, out: JointType[DynamicalSystem, BindCondData], @@ -644,7 +644,7 @@ def __init__( # synaptic models check.is_instance(pre, DynamicalSystem) - check.is_instance(syn, ParamDescInit[JointType[DynamicalSystem, AutoDelaySupp]]) + check.is_instance(syn, ParamDescInit[JointType[DynamicalSystem, SupportAutoDelay]]) check.is_instance(comm, DynamicalSystem) check.is_instance(out, JointType[DynamicalSystem, BindCondData]) check.is_instance(post, DynamicalSystem) @@ -654,7 +654,7 @@ def __init__( self._syn_id = f'{syn.identifier} // Delay' if not pre.has_aft_update(self._syn_id): # "syn_cls" needs an instance of "ProjAutoDelay" - syn_cls: AutoDelaySupp = syn() + syn_cls: SupportAutoDelay = syn() delay_cls = init_delay_by_return(syn_cls.return_info()) # add to "after_updates" pre.add_aft_update(self._syn_id, _AlignPre(syn_cls, delay_cls)) @@ -755,7 +755,7 @@ def update(self, inp): def __init__( self, - pre: JointType[DynamicalSystem, AutoDelaySupp], + pre: JointType[DynamicalSystem, SupportAutoDelay], delay: Union[None, int, float], syn: ParamDescInit[DynamicalSystem], comm: DynamicalSystem, @@ -768,7 +768,7 @@ def __init__( super().__init__(name=name, mode=mode) # synaptic models - check.is_instance(pre, JointType[DynamicalSystem, AutoDelaySupp]) + check.is_instance(pre, JointType[DynamicalSystem, SupportAutoDelay]) check.is_instance(syn, ParamDescInit[DynamicalSystem]) check.is_instance(comm, DynamicalSystem) check.is_instance(out, JointType[DynamicalSystem, BindCondData]) @@ -884,7 +884,7 @@ def update(self, inp): def __init__( self, pre: DynamicalSystem, - syn: JointType[DynamicalSystem, AutoDelaySupp], + syn: JointType[DynamicalSystem, SupportAutoDelay], delay: Union[None, int, float], comm: DynamicalSystem, out: JointType[DynamicalSystem, BindCondData], @@ -897,7 +897,7 @@ def __init__( # synaptic models check.is_instance(pre, DynamicalSystem) - check.is_instance(syn, JointType[DynamicalSystem, AutoDelaySupp]) + check.is_instance(syn, JointType[DynamicalSystem, SupportAutoDelay]) check.is_instance(comm, DynamicalSystem) check.is_instance(out, JointType[DynamicalSystem, BindCondData]) check.is_instance(post, DynamicalSystem) @@ -1002,7 +1002,7 @@ def update(self, inp): def __init__( self, - pre: JointType[DynamicalSystem, AutoDelaySupp], + pre: JointType[DynamicalSystem, SupportAutoDelay], delay: Union[None, int, float], syn: DynamicalSystem, comm: DynamicalSystem, @@ -1015,7 +1015,7 @@ def __init__( super().__init__(name=name, mode=mode) # synaptic models - check.is_instance(pre, JointType[DynamicalSystem, AutoDelaySupp]) + check.is_instance(pre, JointType[DynamicalSystem, SupportAutoDelay]) check.is_instance(syn, DynamicalSystem) check.is_instance(comm, DynamicalSystem) check.is_instance(out, JointType[DynamicalSystem, BindCondData]) @@ -1052,4 +1052,4 @@ def update(self): spk = self.refs['delay'].at(self.name) g = self.comm(self.syn(spk)) self.refs['out'].bind_cond(g) - return g + return g \ No newline at end of file diff --git a/brainpy/_src/dyn/projections/plasticity.py b/brainpy/_src/dyn/projections/plasticity.py new file mode 100644 index 000000000..a85f6e1fc --- /dev/null +++ b/brainpy/_src/dyn/projections/plasticity.py @@ -0,0 +1,238 @@ +from typing import Optional, Callable, Union + +from brainpy import math as bm, check +from brainpy._src.delay import DelayAccess, delay_identifier, init_delay_by_return +from brainpy._src.dyn.synapses.abstract_models import Expon +from brainpy._src.dynsys import DynamicalSystem, Projection +from brainpy._src.initialize import parameter +from brainpy._src.mixin import (JointType, ParamDescInit, SupportAutoDelay, BindCondData, AlignPost, SupportSTDP) +from brainpy.types import ArrayType +from .aligns import _AlignPost, _AlignPreMg, _get_return + +__all__ = [ + 'STDP_Song2000', +] + + +class STDP_Song2000(Projection): + r"""Synaptic output with spike-time-dependent plasticity. + + This model filters the synaptic currents according to the variables: :math:`w`. + + .. math:: + + I_{syn}^+(t) = I_{syn}^-(t) * w + + where :math:`I_{syn}^-(t)` and :math:`I_{syn}^+(t)` are the synaptic currents before + and after STDP filtering, :math:`w` measures synaptic efficacy because each time a presynaptic neuron emits a pulse, + the conductance of the synapse will increase w. + + The dynamics of :math:`w` is governed by the following equation: + + .. math:: + + \begin{aligned} + \frac{dw}{dt} & = & -A_{post}\delta(t-t_{sp}) + A_{pre}\delta(t-t_{sp}), \\ + \frac{dA_{pre}}{dt} & = & -\frac{A_{pre}}{\tau_s}+A_1\delta(t-t_{sp}), \\ + \frac{dA_{post}}{dt} & = & -\frac{A_{post}}{\tau_t}+A_2\delta(t-t_{sp}), \\ + \tag{1}\end{aligned} + + where :math:`t_{sp}` denotes the spike time and :math:`A_1` is the increment + of :math:`A_{pre}`, :math:`A_2` is the increment of :math:`A_{post}` produced by a spike. + + Example:: + import brainpy as bp + import brainpy.math as bm + + class STDPNet(bp.DynamicalSystem): + def __init__(self, num_pre, num_post): + super().__init__() + self.pre = bp.dyn.LifRef(num_pre, name='neu1') + self.post = bp.dyn.LifRef(num_post, name='neu2') + self.syn = bp.dyn.STDP_Song2000( + pre=self.pre, + delay=1., + comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(1, pre=self.pre.num, post=self.post.num), + weight=bp.init.Uniform(max_val=0.1)), + syn=bp.dyn.Expon.desc(self.post.varshape, tau=5.), + out=bp.dyn.COBA.desc(E=0.), + post=self.post, + tau_s=16.8, + tau_t=33.7, + A1=0.96, + A2=0.53, + ) + + def update(self, I_pre, I_post): + self.syn() + self.pre(I_pre) + self.post(I_post) + conductance = self.syn.refs['syn'].g + Apre = self.syn.refs['pre_trace'].g + Apost = self.syn.refs['post_trace'].g + current = self.post.sum_inputs(self.post.V) + return self.pre.spike, self.post.spike, conductance, Apre, Apost, current, self.syn.comm.weight + + duration = 300. + I_pre = bp.inputs.section_input([0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0], + [5, 15, 15, 15, 15, 15, 100, 15, 15, 15, 15, 15, duration - 255]) + I_post = bp.inputs.section_input([0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0], + [10, 15, 15, 15, 15, 15, 90, 15, 15, 15, 15, 15, duration - 250]) + + net = STDPNet(1, 1) + def run(i, I_pre, I_post): + pre_spike, post_spike, g, Apre, Apost, current, W = net.step_run(i, I_pre, I_post) + return pre_spike, post_spike, g, Apre, Apost, current, W + + indices = bm.arange(0, duration, bm.dt) + pre_spike, post_spike, g, Apre, Apost, current, W = bm.for_loop(run, [indices, I_pre, I_post], jit=True) + + Args: + tau_s: float, ArrayType, Callable. The time constant of :math:`A_{pre}`. + tau_t: float, ArrayType, Callable. The time constant of :math:`A_{post}`. + A1: float, ArrayType, Callable. The increment of :math:`A_{pre}` produced by a spike. + A2: float, ArrayType, Callable. The increment of :math:`A_{post}` produced by a spike. + """ + + def __init__( + self, + pre: JointType[DynamicalSystem, SupportAutoDelay], + delay: Union[None, int, float], + syn: ParamDescInit[DynamicalSystem], + comm: DynamicalSystem, + out: ParamDescInit[JointType[DynamicalSystem, BindCondData]], + post: DynamicalSystem, + # synapse parameters + tau_s: Union[float, ArrayType, Callable] = 16.8, + tau_t: Union[float, ArrayType, Callable] = 33.7, + A1: Union[float, ArrayType, Callable] = 0.96, + A2: Union[float, ArrayType, Callable] = 0.53, + # others + out_label: Optional[str] = None, + name: Optional[str] = None, + mode: Optional[bm.Mode] = None, + ): + super().__init__(name=name, mode=mode) + + # synaptic models + check.is_instance(pre, JointType[DynamicalSystem, SupportAutoDelay]) + check.is_instance(syn, ParamDescInit[DynamicalSystem]) + check.is_instance(comm, JointType[DynamicalSystem, SupportSTDP]) + check.is_instance(out, ParamDescInit[JointType[DynamicalSystem, BindCondData]]) + check.is_instance(post, DynamicalSystem) + self.pre_num = pre.num + self.post_num = post.num + self.comm = comm + self.syn = syn + + # delay initialization + if not pre.has_aft_update(delay_identifier): + delay_ins = init_delay_by_return(pre.return_info()) + pre.add_aft_update(delay_identifier, delay_ins) + delay_cls = pre.get_aft_update(delay_identifier) + delay_cls.register_entry(self.name, delay) + + if issubclass(syn.cls, AlignPost): + # synapse and output initialization + self._post_repr = f'{out_label} // {syn.identifier} // {out.identifier}' + if not post.has_bef_update(self._post_repr): + syn_cls = syn() + out_cls = out() + if out_label is None: + out_name = self.name + else: + out_name = f'{out_label} // {self.name}' + post.add_inp_fun(out_name, out_cls) + post.add_bef_update(self._post_repr, _AlignPost(syn_cls, out_cls)) + # references + self.refs = dict(pre=pre, post=post, out=out) # invisible to ``self.nodes()`` + self.refs['delay'] = pre.get_aft_update(delay_identifier) + self.refs['syn'] = post.get_bef_update(self._post_repr).syn # invisible to ``self.node()`` + self.refs['out'] = post.get_bef_update(self._post_repr).out # invisible to ``self.node()`` + + else: + # synapse initialization + self._syn_id = f'Delay({str(delay)}) // {syn.identifier}' + if not delay_cls.has_bef_update(self._syn_id): + # delay + delay_access = DelayAccess(delay_cls, delay) + # synapse + syn_cls = syn() + # add to "after_updates" + delay_cls.add_bef_update(self._syn_id, _AlignPreMg(delay_access, syn_cls)) + + # output initialization + if out_label is None: + out_name = self.name + else: + out_name = f'{out_label} // {self.name}' + post.add_inp_fun(out_name, out) + + # references + self.refs = dict(pre=pre, post=post) # invisible to `self.nodes()` + self.refs['delay'] = delay_cls.get_bef_update(self._syn_id) + self.refs['syn'] = delay_cls.get_bef_update(self._syn_id).syn + self.refs['out'] = out + + self.refs['pre_trace'] = self.calculate_trace(pre, delay, Expon.desc(pre.num, tau=tau_s)) + self.refs['post_trace'] = self.calculate_trace(post, None, Expon.desc(post.num, tau=tau_t)) + # parameters + self.tau_s = parameter(tau_s, sizes=self.pre_num) + self.tau_t = parameter(tau_t, sizes=self.post_num) + self.A1 = parameter(A1, sizes=self.pre_num) + self.A2 = parameter(A2, sizes=self.post_num) + + def calculate_trace( + self, + target: DynamicalSystem, + delay: Union[None, int, float], + syn: ParamDescInit[DynamicalSystem], + ): + """Calculate the trace of the target.""" + check.is_instance(target, DynamicalSystem) + check.is_instance(syn, ParamDescInit[DynamicalSystem]) + + # delay initialization + if not target.has_aft_update(delay_identifier): + delay_ins = init_delay_by_return(target.return_info()) + target.add_aft_update(delay_identifier, delay_ins) + delay_cls = target.get_aft_update(delay_identifier) + delay_cls.register_entry(target.name, delay) + + # synapse initialization + _syn_id = f'Delay({str(delay)}) // {syn.identifier}' + if not delay_cls.has_bef_update(_syn_id): + # delay + delay_access = DelayAccess(delay_cls, delay) + # synapse + syn_cls = syn() + # add to "after_updates" + delay_cls.add_bef_update(_syn_id, _AlignPreMg(delay_access, syn_cls)) + + return delay_cls.get_bef_update(_syn_id).syn + + def update(self): + # pre spikes, and pre-synaptic variables + if issubclass(self.syn.cls, AlignPost): + pre_spike = self.refs['delay'].at(self.name) + x = pre_spike + else: + pre_spike = self.refs['delay'].access() + x = _get_return(self.refs['syn'].return_info()) + + # post spikes + post_spike = self.refs['post'].spike + + # weight updates + Apre = self.refs['pre_trace'].g + Apost = self.refs['post_trace'].g + delta_w = - bm.outer(pre_spike, Apost * self.A2) + bm.outer(Apre * self.A1, post_spike) + self.comm.update_STDP(delta_w) + + # currents + current = self.comm(x) + if issubclass(self.syn.cls, AlignPost): + self.refs['syn'].add_current(current) # synapse post current + else: + self.refs['out'].bind_cond(current) + return current diff --git a/brainpy/_src/dyn/projections/tests/test_STDP.py b/brainpy/_src/dyn/projections/tests/test_STDP.py new file mode 100644 index 000000000..b74aec5f9 --- /dev/null +++ b/brainpy/_src/dyn/projections/tests/test_STDP.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- + + +from absl.testing import parameterized + +import brainpy as bp +import brainpy.math as bm + +class Test_STDP(parameterized.TestCase): + def test_STDP(self): + bm.random.seed() + class STDPNet(bp.DynamicalSystem): + def __init__(self, num_pre, num_post): + super().__init__() + self.pre = bp.dyn.LifRef(num_pre, name='neu1') + self.post = bp.dyn.LifRef(num_post, name='neu2') + self.syn = bp.dyn.STDP_Song2000( + pre=self.pre, + delay=1., + comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(1, pre=self.pre.num, post=self.post.num), + weight=lambda s: bm.Variable(bm.random.rand(*s) * 0.1)), + syn=bp.dyn.Expon.desc(self.post.varshape, tau=5.), + out=bp.dyn.COBA.desc(E=0.), + post=self.post, + tau_s=16.8, + tau_t=33.7, + A1=0.96, + A2=0.53, + ) + + def update(self, I_pre, I_post): + self.syn() + self.pre(I_pre) + self.post(I_post) + conductance = self.syn.refs['syn'].g + Apre = self.syn.refs['pre_trace'].g + Apost = self.syn.refs['post_trace'].g + current = self.post.sum_inputs(self.post.V) + return self.pre.spike, self.post.spike, conductance, Apre, Apost, current, self.syn.comm.weight + + duration = 300. + I_pre = bp.inputs.section_input([0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0], + [5, 15, 15, 15, 15, 15, 100, 15, 15, 15, 15, 15, duration - 255]) + I_post = bp.inputs.section_input([0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0, 30, 0], + [10, 15, 15, 15, 15, 15, 90, 15, 15, 15, 15, 15, duration - 250]) + + net = STDPNet(1, 1) + def run(i, I_pre, I_post): + pre_spike, post_spike, g, Apre, Apost, current, W = net.step_run(i, I_pre, I_post) + return pre_spike, post_spike, g, Apre, Apost, current, W + + indices = bm.arange(0, duration, bm.dt) + bm.for_loop(run, [indices, I_pre, I_post], jit=True) diff --git a/brainpy/_src/dyn/synapses/abstract_models.py b/brainpy/_src/dyn/synapses/abstract_models.py index f6efd89fe..3cbfac08e 100644 --- a/brainpy/_src/dyn/synapses/abstract_models.py +++ b/brainpy/_src/dyn/synapses/abstract_models.py @@ -1030,4 +1030,4 @@ def return_info(self): lambda shape: self.u * self.x) -STP.__doc__ = STP.__doc__ % (pneu_doc,) +STP.__doc__ = STP.__doc__ % (pneu_doc,) \ No newline at end of file diff --git a/brainpy/_src/dynold/synapses/base.py b/brainpy/_src/dynold/synapses/base.py index 145eec585..c212884b7 100644 --- a/brainpy/_src/dynold/synapses/base.py +++ b/brainpy/_src/dynold/synapses/base.py @@ -11,7 +11,7 @@ from brainpy._src.dynsys import DynamicalSystem from brainpy._src.initialize import parameter from brainpy._src.mixin import (ParamDesc, JointType, - AutoDelaySupp, BindCondData, ReturnInfo) + SupportAutoDelay, BindCondData, ReturnInfo) from brainpy.errors import UnsupportedError from brainpy.types import ArrayType @@ -109,7 +109,7 @@ def update(self): pass -class _SynSTP(_SynapseComponent, ParamDesc, AutoDelaySupp): +class _SynSTP(_SynapseComponent, ParamDesc, SupportAutoDelay): """Base class for synaptic short-term plasticity.""" def update(self, pre_spike): diff --git a/brainpy/_src/dynsys.py b/brainpy/_src/dynsys.py index 78ea721c7..770d4bf30 100644 --- a/brainpy/_src/dynsys.py +++ b/brainpy/_src/dynsys.py @@ -10,7 +10,7 @@ from brainpy import tools, math as bm from brainpy._src.initialize import parameter, variable_ -from brainpy._src.mixin import AutoDelaySupp, Container, ReceiveInputProj, DelayRegister, global_delay_data +from brainpy._src.mixin import SupportAutoDelay, Container, SupportInputProj, DelayRegister, global_delay_data from brainpy.errors import NoImplementationError, UnsupportedError from brainpy.types import ArrayType, Shape from brainpy._src.deprecations import _update_deprecate_msg @@ -70,7 +70,7 @@ def update(self, x): return func -class DynamicalSystem(bm.BrainPyObject, DelayRegister, ReceiveInputProj): +class DynamicalSystem(bm.BrainPyObject, DelayRegister, SupportInputProj): """Base Dynamical System class. .. note:: @@ -487,7 +487,7 @@ class Network(DynSysGroup): pass -class Sequential(DynamicalSystem, AutoDelaySupp, Container): +class Sequential(DynamicalSystem, SupportAutoDelay, Container): """A sequential `input-output` module. Modules will be added to it in the order they are passed in the @@ -557,9 +557,9 @@ def update(self, x): def return_info(self): last = self[-1] - if not isinstance(last, AutoDelaySupp): + if not isinstance(last, SupportAutoDelay): raise UnsupportedError(f'Does not support "return_info()" because the last node is ' - f'not instance of {AutoDelaySupp.__name__}') + f'not instance of {SupportAutoDelay.__name__}') return last.return_info() def __getitem__(self, key: Union[int, slice, str]): diff --git a/brainpy/_src/math/object_transform/base.py b/brainpy/_src/math/object_transform/base.py index daa8a55bb..061bfe472 100644 --- a/brainpy/_src/math/object_transform/base.py +++ b/brainpy/_src/math/object_transform/base.py @@ -141,6 +141,8 @@ def fun(self): # that has been created. a = self.tracing_variable('a', bm.zeros, (10,)) + .. versionadded:: 2.4.5 + Args: name: str. The variable name. init: callable, Array. The data to be initialized as a ``Variable``. diff --git a/brainpy/_src/math/object_transform/controls.py b/brainpy/_src/math/object_transform/controls.py index 4a9165420..61c7b7f0d 100644 --- a/brainpy/_src/math/object_transform/controls.py +++ b/brainpy/_src/math/object_transform/controls.py @@ -526,25 +526,17 @@ def cond( node_deprecation(child_objs) dyn_vars = get_stack_cache((true_fun, false_fun)) - _transform = _get_cond_transform(VariableStack() if dyn_vars is None else dyn_vars, - pred, - true_fun, - false_fun) - if jax.config.jax_disable_jit: - dyn_values, res = _transform(operands) - - else: + if not jax.config.jax_disable_jit: if dyn_vars is None: with new_transform('cond'): - dyn_vars, rets = evaluate_dyn_vars( - _transform, - operands, - use_eval_shape=current_transform_number() <= 1 - ) + dyn_vars1, rets = evaluate_dyn_vars(true_fun, *operands, use_eval_shape=current_transform_number() <= 1) + dyn_vars2, rets = evaluate_dyn_vars(false_fun, *operands, use_eval_shape=current_transform_number() <= 1) + dyn_vars = dyn_vars1 + dyn_vars2 cache_stack((true_fun, false_fun), dyn_vars) if current_transform_number() > 0: - return rets[1] - dyn_values, res = _get_cond_transform(dyn_vars, pred, true_fun, false_fun)(operands) + return rets + dyn_vars = VariableStack() if dyn_vars is None else dyn_vars + dyn_values, res = _get_cond_transform(dyn_vars, pred, true_fun, false_fun)(operands) for k in dyn_values.keys(): dyn_vars[k]._value = dyn_values[k] return res @@ -1009,22 +1001,17 @@ def while_loop( if not isinstance(operands, (list, tuple)): operands = (operands,) - if jax.config.jax_disable_jit: - dyn_vars = VariableStack() - - else: - dyn_vars = get_stack_cache(body_fun) - + dyn_vars = get_stack_cache((body_fun, cond_fun)) + if not jax.config.jax_disable_jit: if dyn_vars is None: with new_transform('while_loop'): - dyn_vars, rets = evaluate_dyn_vars( - _get_while_transform(cond_fun, body_fun, VariableStack()), - operands - ) - cache_stack(body_fun, dyn_vars) + dyn_vars1, _ = evaluate_dyn_vars(cond_fun, *operands, use_eval_shape=current_transform_number() <= 1) + dyn_vars2, rets = evaluate_dyn_vars(body_fun, *operands, use_eval_shape=current_transform_number() <= 1) + dyn_vars = dyn_vars1 + dyn_vars2 + cache_stack((body_fun, cond_fun), dyn_vars) if current_transform_number(): - return rets[1] - + return rets + dyn_vars = VariableStack() if dyn_vars is None else dyn_vars dyn_values, out = _get_while_transform(cond_fun, body_fun, dyn_vars)(operands) for k, v in dyn_vars.items(): v._value = dyn_values[k] diff --git a/brainpy/_src/math/object_transform/tests/test_controls.py b/brainpy/_src/math/object_transform/tests/test_controls.py index 7203adb6f..5295d80db 100644 --- a/brainpy/_src/math/object_transform/tests/test_controls.py +++ b/brainpy/_src/math/object_transform/tests/test_controls.py @@ -132,6 +132,13 @@ def update(self): self.assertTrue(bm.allclose(cls.a, 10.)) +class TestCond(unittest.TestCase): + def test1(self): + bm.random.seed(1) + bm.cond(True, lambda: bm.random.random(10), lambda: bm.random.random(10), ()) + bm.cond(False, lambda: bm.random.random(10), lambda: bm.random.random(10), ()) + + class TestIfElse(unittest.TestCase): def test1(self): def f(a): @@ -221,6 +228,33 @@ def body(x, y): print() print(res) + def test2(self): + bm.random.seed() + + a = bm.Variable(bm.zeros(1)) + b = bm.Variable(bm.ones(1)) + + def cond(x, y): + return x < 6. + + def body(x, y): + a.value += x + b.value *= y + return x + b[0], y + 1. + + res = bm.while_loop(body, cond, operands=(1., 1.)) + print() + print(res) + + with jax.disable_jit(): + a = bm.Variable(bm.zeros(1)) + b = bm.Variable(bm.ones(1)) + + res2 = bm.while_loop(body, cond, operands=(1., 1.)) + print(res2) + self.assertTrue(bm.array_equal(res2[0], res[0])) + self.assertTrue(bm.array_equal(res2[1], res[1])) + def test3(self): bm.random.seed() @@ -242,32 +276,27 @@ def body(x, y): print(a) print(b) - def test2(self): + def test4(self): bm.random.seed() a = bm.Variable(bm.zeros(1)) b = bm.Variable(bm.ones(1)) def cond(x, y): - return x < 6. + a.value += 1 + return bm.all(a.value < 6.) def body(x, y): a.value += x b.value *= y - return x + b[0], y + 1. res = bm.while_loop(body, cond, operands=(1., 1.)) - print() + self.assertTrue(bm.allclose(a, 5.)) + self.assertTrue(bm.allclose(b, 1.)) print(res) - - with jax.disable_jit(): - a = bm.Variable(bm.zeros(1)) - b = bm.Variable(bm.ones(1)) - - res2 = bm.while_loop(body, cond, operands=(1., 1.)) - print(res2) - self.assertTrue(bm.array_equal(res2[0], res[0])) - self.assertTrue(bm.array_equal(res2[1], res[1])) + print(a) + print(b) + print() class TestDebugAndCompile(parameterized.TestCase): diff --git a/brainpy/_src/math/random.py b/brainpy/_src/math/random.py index eb04c5d2e..e989908a0 100644 --- a/brainpy/_src/math/random.py +++ b/brainpy/_src/math/random.py @@ -22,7 +22,7 @@ __all__ = [ 'RandomState', 'Generator', 'DEFAULT', - 'seed', 'default_rng', 'split_key', + 'seed', 'default_rng', 'split_key', 'split_keys', # numpy compatibility 'rand', 'randint', 'random_integers', 'randn', 'random', @@ -1258,6 +1258,8 @@ def split_keys(n): internally by `pmap` and `vmap` to ensure that random numbers are different in parallel threads. + .. versionadded:: 2.4.5 + Parameters ---------- n : int @@ -1267,6 +1269,15 @@ def split_keys(n): def clone_rng(seed_or_key=None, clone: bool = True) -> RandomState: + """Clone the random state according to the given setting. + + Args: + seed_or_key: The seed (an integer) or the random key. + clone: Bool. Whether clone the default random state. + + Returns: + The random state. + """ if seed_or_key is None: return DEFAULT.clone() if clone else DEFAULT else: diff --git a/brainpy/_src/math/surrogate/_one_input.py b/brainpy/_src/math/surrogate/_one_input.py index 5ddb94254..23f151ee0 100644 --- a/brainpy/_src/math/surrogate/_one_input.py +++ b/brainpy/_src/math/surrogate/_one_input.py @@ -36,6 +36,13 @@ class Sigmoid(Surrogate): + """Spike function with the sigmoid-shaped surrogate gradient. + + See Also + -------- + sigmoid + + """ def __init__(self, alpha=4., origin=False): self.alpha = alpha self.origin = origin @@ -118,6 +125,13 @@ def grad(dz): class PiecewiseQuadratic(Surrogate): + """Judge spiking state with a piecewise quadratic function. + + See Also + -------- + piecewise_quadratic + + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -220,6 +234,12 @@ def grad(dz): class PiecewiseExp(Surrogate): + """Judge spiking state with a piecewise exponential function. + + See Also + -------- + piecewise_exp + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -308,6 +328,12 @@ def grad(dz): class SoftSign(Surrogate): + """Judge spiking state with a soft sign function. + + See Also + -------- + soft_sign + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -391,6 +417,12 @@ def grad(dz): class Arctan(Surrogate): + """Judge spiking state with an arctan function. + + See Also + -------- + arctan + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -473,6 +505,12 @@ def grad(dz): class NonzeroSignLog(Surrogate): + """Judge spiking state with a nonzero sign log function. + + See Also + -------- + nonzero_sign_log + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -568,6 +606,12 @@ def grad(dz): class ERF(Surrogate): + """Judge spiking state with an erf function. + + See Also + -------- + erf + """ def __init__(self, alpha=1., origin=False): self.alpha = alpha self.origin = origin @@ -660,6 +704,12 @@ def grad(dz): class PiecewiseLeakyRelu(Surrogate): + """Judge spiking state with a piecewise leaky relu function. + + See Also + -------- + piecewise_leaky_relu + """ def __init__(self, c=0.01, w=1., origin=False): self.c = c self.w = w @@ -771,6 +821,12 @@ def grad(dz): class SquarewaveFourierSeries(Surrogate): + """Judge spiking state with a squarewave fourier series. + + See Also + -------- + squarewave_fourier_series + """ def __init__(self, n=2, t_period=8., origin=False): self.n = n self.t_period = t_period @@ -863,6 +919,12 @@ def grad(dz): class S2NN(Surrogate): + """Judge spiking state with the S2NN surrogate spiking function. + + See Also + -------- + s2nn + """ def __init__(self, alpha=4., beta=1., epsilon=1e-8, origin=False): self.alpha = alpha self.beta = beta @@ -969,6 +1031,12 @@ def grad(dz): class QPseudoSpike(Surrogate): + """Judge spiking state with the q-PseudoSpike surrogate function. + + See Also + -------- + q_pseudo_spike + """ def __init__(self, alpha=2., origin=False): self.alpha = alpha self.origin = origin @@ -1062,6 +1130,12 @@ def grad(dz): class LeakyRelu(Surrogate): + """Judge spiking state with the Leaky ReLU function. + + See Also + -------- + leaky_relu + """ def __init__(self, alpha=0.1, beta=1., origin=False): self.alpha = alpha self.beta = beta @@ -1156,6 +1230,12 @@ def grad(dz): class LogTailedRelu(Surrogate): + """Judge spiking state with the Log-tailed ReLU function. + + See Also + -------- + log_tailed_relu + """ def __init__(self, alpha=0., origin=False): self.alpha = alpha self.origin = origin @@ -1260,6 +1340,12 @@ def grad(dz): class ReluGrad(Surrogate): + """Judge spiking state with the ReLU gradient function. + + See Also + -------- + relu_grad + """ def __init__(self, alpha=0.3, width=1.): self.alpha = alpha self.width = width @@ -1337,6 +1423,12 @@ def grad(dz): class GaussianGrad(Surrogate): + """Judge spiking state with the Gaussian gradient function. + + See Also + -------- + gaussian_grad + """ def __init__(self, sigma=0.5, alpha=0.5): self.sigma = sigma self.alpha = alpha @@ -1413,6 +1505,12 @@ def grad(dz): class MultiGaussianGrad(Surrogate): + """Judge spiking state with the multi-Gaussian gradient function. + + See Also + -------- + multi_gaussian_grad + """ def __init__(self, h=0.15, s=6.0, sigma=0.5, scale=0.5): self.h = h self.s = s @@ -1503,6 +1601,12 @@ def grad(dz): class InvSquareGrad(Surrogate): + """Judge spiking state with the inverse-square surrogate gradient function. + + See Also + -------- + inv_square_grad + """ def __init__(self, alpha=100.): self.alpha = alpha @@ -1571,6 +1675,12 @@ def grad(dz): class SlayerGrad(Surrogate): + """Judge spiking state with the slayer surrogate gradient function. + + See Also + -------- + slayer_grad + """ def __init__(self, alpha=1.): self.alpha = alpha diff --git a/brainpy/_src/mixin.py b/brainpy/_src/mixin.py index fce2aca18..23cd703bf 100644 --- a/brainpy/_src/mixin.py +++ b/brainpy/_src/mixin.py @@ -1,6 +1,5 @@ import numbers import sys -import warnings from dataclasses import dataclass from typing import Union, Dict, Callable, Sequence, Optional, TypeVar, Any from typing import (_SpecialForm, _type_check, _remove_dups_flatten) @@ -28,11 +27,15 @@ 'ParamDesc', 'ParamDescInit', 'AlignPost', - 'AutoDelaySupp', 'Container', 'TreeNode', 'BindCondData', 'JointType', + 'SupportSTDP', + 'SupportAutoDelay', + 'SupportInputProj', + 'SupportOnline', + 'SupportOffline', ] global_delay_data = dict() @@ -46,59 +49,6 @@ class MixIn(object): pass -class ReceiveInputProj(MixIn): - """The :py:class:`~.MixIn` that receives the input projections. - - Note that the subclass should define a ``cur_inputs`` attribute. - - """ - cur_inputs: bm.node_dict - - def add_inp_fun(self, key: Any, fun: Callable): - """Add an input function. - - Args: - key: The dict key. - fun: The function to generate inputs. - """ - if not callable(fun): - raise TypeError('Must be a function.') - if key in self.cur_inputs: - raise ValueError(f'Key "{key}" has been defined and used.') - self.cur_inputs[key] = fun - - def get_inp_fun(self, key): - """Get the input function. - - Args: - key: The key. - - Returns: - The input function which generates currents. - """ - return self.cur_inputs.get(key) - - def sum_inputs(self, *args, init=0., label=None, **kwargs): - """Summarize all inputs by the defined input functions ``.cur_inputs``. - - Args: - *args: The arguments for input functions. - init: The initial input data. - **kwargs: The arguments for input functions. - - Returns: - The total currents. - """ - if label is None: - for key, out in self.cur_inputs.items(): - init = init + out(*args, **kwargs) - else: - for key, out in self.cur_inputs.items(): - if key.startswith(label + ' // '): - init = init + out(*args, **kwargs) - return init - - class ParamDesc(MixIn): """:py:class:`~.MixIn` indicates the function for describing initialization parameters. @@ -207,13 +157,6 @@ def get_data(self): return init -class AutoDelaySupp(MixIn): - """``MixIn`` to support the automatic delay in synaptic projection :py:class:`~.SynProj`.""" - - def return_info(self) -> Union[bm.Variable, ReturnInfo]: - raise NotImplementedError('Must implement the "return_info()" function.') - - class Container(MixIn): """Container :py:class:`~.MixIn` which wrap a group of objects. """ @@ -347,7 +290,7 @@ def register_delay_at( if delay_identifier is None: from brainpy._src.delay import delay_identifier if DynamicalSystem is None: from brainpy._src.dynsys import DynamicalSystem - assert isinstance(self, AutoDelaySupp), f'self must be an instance of {AutoDelaySupp.__name__}' + assert isinstance(self, SupportAutoDelay), f'self must be an instance of {SupportAutoDelay.__name__}' assert isinstance(self, DynamicalSystem), f'self must be an instance of {DynamicalSystem.__name__}' if not self.has_aft_update(delay_identifier): self.add_aft_update(delay_identifier, init_delay_by_return(self.return_info())) @@ -549,8 +492,97 @@ def get_delay_var(self, name): return global_delay_data[name] +class SupportInputProj(MixIn): + """The :py:class:`~.MixIn` that receives the input projections. + + Note that the subclass should define a ``cur_inputs`` attribute. + + """ + cur_inputs: bm.node_dict + + def add_inp_fun(self, key: Any, fun: Callable): + """Add an input function. + + Args: + key: The dict key. + fun: The function to generate inputs. + """ + if not callable(fun): + raise TypeError('Must be a function.') + if key in self.cur_inputs: + raise ValueError(f'Key "{key}" has been defined and used.') + self.cur_inputs[key] = fun + + def get_inp_fun(self, key): + """Get the input function. + + Args: + key: The key. + + Returns: + The input function which generates currents. + """ + return self.cur_inputs.get(key) + + def sum_inputs(self, *args, init=0., label=None, **kwargs): + """Summarize all inputs by the defined input functions ``.cur_inputs``. + + Args: + *args: The arguments for input functions. + init: The initial input data. + **kwargs: The arguments for input functions. + + Returns: + The total currents. + """ + if label is None: + for key, out in self.cur_inputs.items(): + init = init + out(*args, **kwargs) + else: + for key, out in self.cur_inputs.items(): + if key.startswith(label + ' // '): + init = init + out(*args, **kwargs) + return init + + +class SupportAutoDelay(MixIn): + """``MixIn`` to support the automatic delay in synaptic projection :py:class:`~.SynProj`.""" + + def return_info(self) -> Union[bm.Variable, ReturnInfo]: + raise NotImplementedError('Must implement the "return_info()" function.') + + +class SupportOnline(MixIn): + """:py:class:`~.MixIn` to support the online training methods. + + .. versionadded:: 2.4.5 + """ + + online_fit_by: Optional # methods for online fitting + + def online_init(self): + raise NotImplementedError + + def online_fit(self, target: ArrayType, fit_record: Dict[str, ArrayType]): + raise NotImplementedError + + +class SupportOffline(MixIn): + """:py:class:`~.MixIn` to support the offline training methods. + + .. versionadded:: 2.4.5 + """ + + offline_fit_by: Optional # methods for offline fitting + + def offline_fit(self, target: ArrayType, fit_record: Dict[str, ArrayType]): + raise NotImplementedError + + class BindCondData(MixIn): """Bind temporary conductance data. + + """ _conductance: Optional @@ -561,6 +593,16 @@ def unbind_cond(self): self._conductance = None +class SupportSTDP(MixIn): + """Support synaptic plasticity by modifying the weights. + """ + def update_STDP(self, + dW: Union[bm.Array, jax.Array], + constraints: Optional[Callable] = None, + ): + raise NotImplementedError + + T = TypeVar('T') @@ -598,7 +640,7 @@ class UnionType2(MixIn): >>> import brainpy as bp >>> - >>> isinstance(bp.dyn.Expon(1), JointType[bp.DynamicalSystem, bp.mixin.ParamDesc, bp.mixin.AutoDelaySupp]) + >>> isinstance(bp.dyn.Expon(1), JointType[bp.DynamicalSystem, bp.mixin.ParamDesc, bp.mixin.SupportAutoDelay]) """ @classmethod diff --git a/brainpy/dyn/__init__.py b/brainpy/dyn/__init__.py index 297c0c50b..00587fb06 100644 --- a/brainpy/dyn/__init__.py +++ b/brainpy/dyn/__init__.py @@ -5,6 +5,7 @@ from .neurons import * from .synapses import * from .projections import * +from .plasticity import * from .others import * from .outs import * from .rates import * diff --git a/brainpy/dyn/plasticity.py b/brainpy/dyn/plasticity.py new file mode 100644 index 000000000..db978b390 --- /dev/null +++ b/brainpy/dyn/plasticity.py @@ -0,0 +1,3 @@ +from brainpy._src.dyn.projections.plasticity import ( + STDP_Song2000 as STDP_Song2000, +) diff --git a/brainpy/dyn/projections.py b/brainpy/dyn/projections.py index 6ee6f300a..2954b7871 100644 --- a/brainpy/dyn/projections.py +++ b/brainpy/dyn/projections.py @@ -1,5 +1,4 @@ - from brainpy._src.dyn.projections.aligns import ( VanillaProj, ProjAlignPostMg1, @@ -20,3 +19,4 @@ PoissonInput as PoissonInput, ) + diff --git a/brainpy/mixin.py b/brainpy/mixin.py index a3f17c7aa..ab3c3cd37 100644 --- a/brainpy/mixin.py +++ b/brainpy/mixin.py @@ -1,13 +1,14 @@ from brainpy._src.mixin import ( MixIn as MixIn, - ReceiveInputProj as ReceiveInputProj, + SupportInputProj as SupportInputProj, AlignPost as AlignPost, - AutoDelaySupp as AutoDelaySupp, + SupportAutoDelay as SupportAutoDelay, ParamDesc as ParamDesc, ParamDescInit as ParamDescInit, BindCondData as BindCondData, Container as Container, TreeNode as TreeNode, JointType as JointType, + SupportSTDP as SupportPlasticity, ) diff --git a/docker/Dockerfile b/docker/Dockerfile new file mode 100644 index 000000000..aa728cada --- /dev/null +++ b/docker/Dockerfile @@ -0,0 +1,23 @@ +FROM ubuntu:22.04 + +ENV TZ=Asia/Dubai +RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone + +RUN apt update +RUN apt install -y --no-install-recommends software-properties-common + +RUN apt update && apt install -y python3-pip + +RUN ln -sf /usr/bin/python3.10 /usr/bin/python && \ + ln -sf /usr/bin/pip3 /usr/bin/pip + + +RUN pip --no-cache-dir install --upgrade pip && \ + pip --no-cache-dir install --upgrade setuptools && \ + pip --no-cache-dir install --upgrade wheel + +ADD . /usr/src/app +WORKDIR /usr/src/app + +RUN pip --no-cache-dir install --upgrade "jax[cpu]" +RUN pip --no-cache-dir install --upgrade -r requirements.txt diff --git a/docker/requirements.txt b/docker/requirements.txt new file mode 100644 index 000000000..460371906 --- /dev/null +++ b/docker/requirements.txt @@ -0,0 +1,16 @@ +numpy +tqdm +msgpack +matplotlib>=3.4 +jax +jaxlib +scipy>=1.1.0 +brainpy +brainpylib +brainpy_datasets +h5py +pathos + +# test requirements +pytest +absl-py diff --git a/docs/_templates/class_template.rst b/docs/_templates/class_template.rst index d9135b2c1..a902dc6d9 100644 --- a/docs/_templates/class_template.rst +++ b/docs/_templates/class_template.rst @@ -5,7 +5,9 @@ .. autoclass:: {{ objname }} - .. automethod:: __init__ + {% for item in methods %} + .. automethod:: {{ item }} + {%- endfor %} {% block methods %} diff --git a/docs/_templates/classtemplate.rst b/docs/_templates/classtemplate.rst new file mode 100644 index 000000000..57b89b777 --- /dev/null +++ b/docs/_templates/classtemplate.rst @@ -0,0 +1,10 @@ +.. role:: hidden + :class: hidden-section +.. currentmodule:: {{ module }} + + +{{ name | underline}} + +.. autoclass:: {{ name }} + :members: + diff --git a/docs/advanced_tutorials.rst b/docs/advanced_tutorials.rst index 1cb343846..5c8cba0fd 100644 --- a/docs/advanced_tutorials.rst +++ b/docs/advanced_tutorials.rst @@ -4,44 +4,12 @@ Advanced Tutorials This section contains tutorials that illustrate more advanced features of BrainPy. - -Advanced math -------------- - - -.. toctree:: - :maxdepth: 1 - - tutorial_advanced/differentiation.ipynb - - - -Interoperation --------------- - - -.. toctree:: - :maxdepth: 1 - - tutorial_advanced/integrate_flax_into_brainpy.ipynb - tutorial_advanced/integrate_bp_lif_into_flax.ipynb - tutorial_advanced/integrate_bp_convlstm_into_flax.ipynb - - -Advanced dynamics analysis --------------------------- - -.. toctree:: - :maxdepth: 1 - - tutorial_advanced/advanced_lowdim_analysis.ipynb - - -Developer guides ---------------- - .. toctree:: - :maxdepth: 1 + :maxdepth: 2 - tutorial_advanced/contributing.md + tutorial_advanced/1_advanced_math.rst + tutorial_advanced/2_interoperation.rst + tutorial_advanced/3_dedicated_operators.rst + tutorial_advanced/4_developer_guides.rst + tutorial_advanced/5_others.rst diff --git a/docs/api.rst b/docs/api.rst index 65bc5b088..076ce48c9 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -5,31 +5,31 @@ API Documentation :maxdepth: 1 apis/auto/changelog.rst - apis/auto/brainpy.rst - apis/auto/math.rst - apis/auto/dnn.rst - apis/auto/dyn.rst - apis/auto/integrators.rst - apis/auto/analysis.rst - apis/auto/connect.rst - apis/auto/encoding.rst - apis/auto/initialize.rst - apis/auto/inputs.rst - apis/auto/losses.rst - apis/auto/measure.rst - apis/auto/optim.rst - apis/auto/running.rst - apis/auto/mixin.rst + apis/brainpy.rst + apis/math.rst + apis/dnn.rst + apis/dyn.rst + apis/integrators.rst + apis/analysis.rst + apis/connect.rst + apis/encoding.rst + apis/initialize.rst + apis/inputs.rst + apis/losses.rst + apis/measure.rst + apis/optim.rst + apis/running.rst + apis/mixin.rst The following APIs will no longer be maintained in the future, but you can still use them normally. .. toctree:: :maxdepth: 1 - apis/channels.rst - apis/neurons.rst - apis/rates.rst - apis/synapses.rst - apis/synouts.rst - apis/synplast.rst - apis/layers.rst + apis/deprecated/channels.rst + apis/deprecated/neurons.rst + apis/deprecated/rates.rst + apis/deprecated/synapses.rst + apis/deprecated/synouts.rst + apis/deprecated/synplast.rst + apis/deprecated/layers.rst diff --git a/docs/apis/analysis.rst b/docs/apis/analysis.rst new file mode 100644 index 000000000..897fa46c1 --- /dev/null +++ b/docs/apis/analysis.rst @@ -0,0 +1,37 @@ +``brainpy.analysis`` module +=========================== + +.. currentmodule:: brainpy.analysis +.. automodule:: brainpy.analysis + +.. contents:: + :local: + :depth: 1 + +Low-dimensional Analyzers +------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + PhasePlane1D + PhasePlane2D + Bifurcation1D + Bifurcation2D + FastSlow1D + FastSlow2D + + +High-dimensional Analyzers +-------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + SlowPointFinder + + diff --git a/docs/apis/brainpy.dyn.base.rst b/docs/apis/brainpy.dyn.base.rst new file mode 100644 index 000000000..25d794f7e --- /dev/null +++ b/docs/apis/brainpy.dyn.base.rst @@ -0,0 +1,14 @@ +Base Classes +============ + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + NeuDyn + SynDyn + IonChaDyn diff --git a/docs/apis/brainpy.dyn.channels.rst b/docs/apis/brainpy.dyn.channels.rst new file mode 100644 index 000000000..80a1af30d --- /dev/null +++ b/docs/apis/brainpy.dyn.channels.rst @@ -0,0 +1,101 @@ +Ion Channel Dynamics +==================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + +.. contents:: + :local: + :depth: 1 + + +Base Classes +------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + IonChannel + + + +Calcium Channels +----------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + CalciumChannel + ICaN_IS2008 + ICaT_HM1992 + ICaT_HP1992 + ICaHT_HM1992 + ICaHT_Re1993 + ICaL_IS2008 + + +Potassium Channels +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + PotassiumChannel + IKDR_Ba2002v2 + IK_TM1991v2 + IK_HH1952v2 + IKA1_HM1992v2 + IKA2_HM1992v2 + IKK2A_HM1992v2 + IKK2B_HM1992v2 + IKNI_Ya1989v2 + IK_Leak + IKDR_Ba2002 + IK_TM1991 + IK_HH1952 + IKA1_HM1992 + IKA2_HM1992 + IKK2A_HM1992 + IKK2B_HM1992 + IKNI_Ya1989 + IKL + + + +Sodium Channels +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + SodiumChannel + INa_Ba2002 + INa_TM1991 + INa_HH1952 + INa_Ba2002v2 + INa_TM1991v2 + INa_HH1952v2 + + +Other Channels +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Ih_HM1992 + Ih_De1996 + IAHP_De1994v2 + IAHP_De1994 + LeakyChannel + IL diff --git a/docs/apis/brainpy.dyn.ions.rst b/docs/apis/brainpy.dyn.ions.rst new file mode 100644 index 000000000..5d18643b2 --- /dev/null +++ b/docs/apis/brainpy.dyn.ions.rst @@ -0,0 +1,23 @@ +Ion Dynamics +====================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + mix_ions + Ion + MixIons + Calcium + CalciumFixed + CalciumDetailed + CalciumFirstOrder + Sodium + SodiumFixed + Potassium + PotassiumFixed diff --git a/docs/apis/brainpy.dyn.neurons.rst b/docs/apis/brainpy.dyn.neurons.rst new file mode 100644 index 000000000..980d18516 --- /dev/null +++ b/docs/apis/brainpy.dyn.neurons.rst @@ -0,0 +1,72 @@ +Neuron Dynamics +=============== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + +Reduced Neuron Models +--------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Lif + LifLTC + LifRefLTC + LifRef + ExpIF + ExpIFLTC + ExpIFRefLTC + ExpIFRef + AdExIF + AdExIFLTC + AdExIFRefLTC + AdExIFRef + QuaIF + QuaIFLTC + QuaIFRefLTC + QuaIFRef + AdQuaIF + AdQuaIFLTC + AdQuaIFRefLTC + AdQuaIFRef + Gif + GifLTC + GifRefLTC + GifRef + Izhikevich + IzhikevichLTC + IzhikevichRefLTC + IzhikevichRef + HHTypedNeuron + CondNeuGroupLTC + CondNeuGroup + HH + HHLTC + MorrisLecar + MorrisLecarLTC + WangBuzsakiHH + WangBuzsakiHHLTC + + +Hodgkin–Huxley Neuron Models +---------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + HHTypedNeuron + CondNeuGroupLTC + CondNeuGroup + HH + HHLTC + MorrisLecar + MorrisLecarLTC + WangBuzsakiHH + WangBuzsakiHHLTC + diff --git a/docs/apis/brainpy.dyn.others.rst b/docs/apis/brainpy.dyn.others.rst new file mode 100644 index 000000000..aae94ff63 --- /dev/null +++ b/docs/apis/brainpy.dyn.others.rst @@ -0,0 +1,21 @@ +Common Dynamical Models +====================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Leaky + Integrator + InputGroup + OutputGroup + SpikeTimeGroup + PoissonGroup + OUProcess + + + diff --git a/docs/apis/brainpy.dyn.outs.rst b/docs/apis/brainpy.dyn.outs.rst new file mode 100644 index 000000000..892f700e2 --- /dev/null +++ b/docs/apis/brainpy.dyn.outs.rst @@ -0,0 +1,16 @@ +Synaptic Outputs +================ + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + SynOut + COBA + CUBA + MgBlock \ No newline at end of file diff --git a/docs/apis/brainpy.dyn.plasticity.rst b/docs/apis/brainpy.dyn.plasticity.rst new file mode 100644 index 000000000..597c71aa5 --- /dev/null +++ b/docs/apis/brainpy.dyn.plasticity.rst @@ -0,0 +1,12 @@ +Synaptic Plasticity +=================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + STDP_Song2000 diff --git a/docs/apis/brainpy.dyn.projections.rst b/docs/apis/brainpy.dyn.projections.rst new file mode 100644 index 000000000..b1dcb1219 --- /dev/null +++ b/docs/apis/brainpy.dyn.projections.rst @@ -0,0 +1,24 @@ +Synaptic Projections +====================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + VanillaProj + ProjAlignPostMg1 + ProjAlignPostMg2 + ProjAlignPost1 + ProjAlignPost2 + ProjAlignPreMg1 + ProjAlignPreMg2 + ProjAlignPre1 + ProjAlignPre2 + SynConn + PoissonInput diff --git a/docs/apis/brainpy.dyn.rates.rst b/docs/apis/brainpy.dyn.rates.rst new file mode 100644 index 000000000..8aa9af007 --- /dev/null +++ b/docs/apis/brainpy.dyn.rates.rst @@ -0,0 +1,20 @@ +Population Rate Models +====================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + FHN + FeedbackFHN + QIF + StuartLandauOscillator + WilsonCowanModel + ThresholdLinearModel + + diff --git a/docs/apis/brainpy.dyn.synapses.rst b/docs/apis/brainpy.dyn.synapses.rst new file mode 100644 index 000000000..59062d180 --- /dev/null +++ b/docs/apis/brainpy.dyn.synapses.rst @@ -0,0 +1,25 @@ +Synaptic Dynamics +====================== + +.. currentmodule:: brainpy.dyn +.. automodule:: brainpy.dyn + + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Delta + Expon + Alpha + DualExpon + DualExponV2 + NMDA + STD + STP + AMPA + GABAa + BioNMDA + DiffusiveCoupling + AdditiveCoupling \ No newline at end of file diff --git a/docs/apis/brainpy.rst b/docs/apis/brainpy.rst new file mode 100644 index 000000000..bff268a11 --- /dev/null +++ b/docs/apis/brainpy.rst @@ -0,0 +1,81 @@ +``brainpy`` module +================== + +.. currentmodule:: brainpy +.. automodule:: brainpy + +.. contents:: + :local: + :depth: 1 + +Numerical Differential Integration +---------------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Integrator + JointEq + IntegratorRunner + odeint + sdeint + fdeint + + +Building Dynamical System +------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + DynamicalSystem + DynSysGroup + Sequential + Network + Dynamic + Projection + + +Simulating Dynamical System +--------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + DSRunner + + +Training Dynamical System +------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + DSTrainer + BPTT + BPFF + OnlineTrainer + ForceTrainer + OfflineTrainer + RidgeTrainer + + +Dynamical System Helpers +------------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + LoopOverTime + + diff --git a/docs/apis/connect.rst b/docs/apis/connect.rst new file mode 100644 index 000000000..9c42fbabb --- /dev/null +++ b/docs/apis/connect.rst @@ -0,0 +1,100 @@ +``brainpy.connect`` module +========================== + +.. currentmodule:: brainpy.connect +.. automodule:: brainpy.connect + +.. contents:: + :local: + :depth: 1 + +Base Connection Classes and Tools +--------------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + set_default_dtype + get_idx_type + mat2coo + mat2csc + mat2csr + csr2csc + csr2mat + csr2coo + coo2csr + coo2csc + coo2mat + coo2mat_num + mat2mat_num + visualizeMat + MAT_DTYPE + IDX_DTYPE + Connector + TwoEndConnector + OneEndConnector + CONN_MAT + PRE_IDS + POST_IDS + PRE2POST + POST2PRE + PRE2SYN + POST2SYN + SUPPORTED_SYN_STRUCTURE + + +Custom Connections +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + MatConn + IJConn + CSRConn + SparseMatConn + + +Random Connections +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + FixedProb + FixedPreNum + FixedPostNum + FixedTotalNum + GaussianProb + ProbDist + SmallWorld + ScaleFreeBA + ScaleFreeBADual + PowerLaw + + +Regular Connections +------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + One2One + All2All + GridFour + GridEight + GridN + one2one + all2all + grid_four + grid_eight + + diff --git a/docs/apis/channels.rst b/docs/apis/deprecated/channels.rst similarity index 100% rename from docs/apis/channels.rst rename to docs/apis/deprecated/channels.rst diff --git a/docs/apis/layers.rst b/docs/apis/deprecated/layers.rst similarity index 100% rename from docs/apis/layers.rst rename to docs/apis/deprecated/layers.rst diff --git a/docs/apis/neurons.rst b/docs/apis/deprecated/neurons.rst similarity index 100% rename from docs/apis/neurons.rst rename to docs/apis/deprecated/neurons.rst diff --git a/docs/apis/rates.rst b/docs/apis/deprecated/rates.rst similarity index 100% rename from docs/apis/rates.rst rename to docs/apis/deprecated/rates.rst diff --git a/docs/apis/synapses.rst b/docs/apis/deprecated/synapses.rst similarity index 100% rename from docs/apis/synapses.rst rename to docs/apis/deprecated/synapses.rst diff --git a/docs/apis/synouts.rst b/docs/apis/deprecated/synouts.rst similarity index 100% rename from docs/apis/synouts.rst rename to docs/apis/deprecated/synouts.rst diff --git a/docs/apis/synplast.rst b/docs/apis/deprecated/synplast.rst similarity index 100% rename from docs/apis/synplast.rst rename to docs/apis/deprecated/synplast.rst diff --git a/docs/apis/dnn.rst b/docs/apis/dnn.rst new file mode 100644 index 000000000..736066ce4 --- /dev/null +++ b/docs/apis/dnn.rst @@ -0,0 +1,184 @@ +``brainpy.dnn`` module +====================== + +.. currentmodule:: brainpy.dnn +.. automodule:: brainpy.dnn + +.. contents:: + :local: + :depth: 1 + +Non-linear Activations +---------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Activation + Flatten + FunAsLayer + Threshold + ReLU + RReLU + Hardtanh + ReLU6 + Sigmoid + Hardsigmoid + Tanh + SiLU + Mish + Hardswish + ELU + CELU + SELU + GLU + GELU + Hardshrink + LeakyReLU + LogSigmoid + Softplus + Softshrink + PReLU + Softsign + Tanhshrink + Softmin + Softmax + Softmax2d + LogSoftmax + + +Convolutional Layers +-------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Conv1d + Conv2d + Conv3d + Conv1D + Conv2D + Conv3D + ConvTranspose1d + ConvTranspose2d + ConvTranspose3d + + +Dense Connection Layers +----------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Dense + Linear + Identity + AllToAll + OneToOne + MaskedLinear + CSRLinear + EventCSRLinear + JitFPHomoLinear + JitFPUniformLinear + JitFPNormalLinear + EventJitFPHomoLinear + EventJitFPNormalLinear + EventJitFPUniformLinear + + +Normalization Layers +-------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + BatchNorm1d + BatchNorm2d + BatchNorm3d + BatchNorm1D + BatchNorm2D + BatchNorm3D + LayerNorm + GroupNorm + InstanceNorm + + +Pooling Layers +-------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + MaxPool + MaxPool1d + MaxPool2d + MaxPool3d + MinPool + AvgPool + AvgPool1d + AvgPool2d + AvgPool3d + AdaptiveAvgPool1d + AdaptiveAvgPool2d + AdaptiveAvgPool3d + AdaptiveMaxPool1d + AdaptiveMaxPool2d + AdaptiveMaxPool3d + + +Artificial Recurrent Layers +--------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + NVAR + Reservoir + RNNCell + GRUCell + LSTMCell + Conv1dLSTMCell + Conv2dLSTMCell + Conv3dLSTMCell + + +Interoperation with Flax +------------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + FromFlax + ToFlaxRNNCell + ToFlax + + +Other Layers +------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Layer + Dropout + Activation + Flatten + FunAsLayer + + diff --git a/docs/apis/dyn.rst b/docs/apis/dyn.rst new file mode 100644 index 000000000..0b8a3431e --- /dev/null +++ b/docs/apis/dyn.rst @@ -0,0 +1,18 @@ +``brainpy.dyn`` module +====================== + + +.. toctree:: + :maxdepth: 1 + + brainpy.dyn.base.rst + brainpy.dyn.ions.rst + brainpy.dyn.channels.rst + brainpy.dyn.neurons.rst + brainpy.dyn.synapses.rst + brainpy.dyn.outs.rst + brainpy.dyn.rates.rst + brainpy.dyn.projections.rst + brainpy.dyn.plasticity.rst + brainpy.dyn.others.rst + diff --git a/docs/apis/encoding.rst b/docs/apis/encoding.rst new file mode 100644 index 000000000..23736b1af --- /dev/null +++ b/docs/apis/encoding.rst @@ -0,0 +1,16 @@ +``brainpy.encoding`` module +=========================== + +.. currentmodule:: brainpy.encoding +.. automodule:: brainpy.encoding + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Encoder + LatencyEncoder + WeightedPhaseEncoder + PoissonEncoder + DiffEncoder diff --git a/docs/apis/initialize.rst b/docs/apis/initialize.rst new file mode 100644 index 000000000..fcce922c8 --- /dev/null +++ b/docs/apis/initialize.rst @@ -0,0 +1,68 @@ +``brainpy.initialize`` module +============================= + +.. currentmodule:: brainpy.initialize +.. automodule:: brainpy.initialize + +.. contents:: + :local: + :depth: 1 + +Basic Initialization Classes +---------------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Initializer + + +Regular Initializers +-------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + ZeroInit + Constant + OneInit + Identity + + +Random Initializers +------------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Normal + Uniform + VarianceScaling + KaimingUniform + KaimingNormal + XavierUniform + XavierNormal + LecunUniform + LecunNormal + Orthogonal + DeltaOrthogonal + + +Decay Initializers +------------------ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + GaussianDecay + DOGDecay + + diff --git a/docs/apis/inputs.rst b/docs/apis/inputs.rst new file mode 100644 index 000000000..e05372e8c --- /dev/null +++ b/docs/apis/inputs.rst @@ -0,0 +1,17 @@ +``brainpy.inputs`` module +========================= + +.. currentmodule:: brainpy.inputs +.. automodule:: brainpy.inputs + +.. autosummary:: + :toctree: generated/ + + section_input + constant_input + spike_input + ramp_input + wiener_process + ou_process + sinusoidal_input + square_input diff --git a/docs/apis/integrators.rst b/docs/apis/integrators.rst new file mode 100644 index 000000000..187b4e9a4 --- /dev/null +++ b/docs/apis/integrators.rst @@ -0,0 +1,205 @@ +``brainpy.integrators`` module +============================== + +.. currentmodule:: brainpy.integrators +.. automodule:: brainpy.integrators + +.. contents:: + :local: + :depth: 2 + +ODE integrators +--------------- + +.. currentmodule:: brainpy.integrators.ode +.. automodule:: brainpy.integrators.ode + +Base ODE Integrator +~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + ODEIntegrator + + +Generic ODE Functions +~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + set_default_odeint + get_default_odeint + register_ode_integrator + get_supported_methods + + +Explicit Runge-Kutta ODE Integrators +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + ExplicitRKIntegrator + Euler + MidPoint + Heun2 + Ralston2 + RK2 + RK3 + Heun3 + Ralston3 + SSPRK3 + RK4 + Ralston4 + RK4Rule38 + + +Adaptive Runge-Kutta ODE Integrators +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + AdaptiveRKIntegrator + RKF12 + RKF45 + DormandPrince + CashKarp + BogackiShampine + HeunEuler + + +Exponential ODE Integrators +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + ExponentialEuler + + +SDE integrators +--------------- + +.. currentmodule:: brainpy.integrators.sde +.. automodule:: brainpy.integrators.sde + +Base SDE Integrator +~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + SDEIntegrator + + +Generic SDE Functions +~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + set_default_sdeint + get_default_sdeint + register_sde_integrator + get_supported_methods + + +Normal SDE Integrators +~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Euler + Heun + Milstein + MilsteinGradFree + ExponentialEuler + + +SRK methods for scalar Wiener process +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + SRK1W1 + SRK2W1 + KlPl + + +FDE integrators +--------------- + +.. currentmodule:: brainpy.integrators.fde +.. automodule:: brainpy.integrators.fde + +Base FDE Integrator +~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + FDEIntegrator + + +Generic FDE Functions +~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + set_default_fdeint + get_default_fdeint + register_fde_integrator + get_supported_methods + + +Methods for Caputo Fractional Derivative +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + CaputoEuler + CaputoL1Schema + + +Methods for Riemann-Liouville Fractional Derivative +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + GLShortMemory + + diff --git a/docs/apis/losses.rst b/docs/apis/losses.rst new file mode 100644 index 000000000..8f50c487f --- /dev/null +++ b/docs/apis/losses.rst @@ -0,0 +1,57 @@ +``brainpy.losses`` module +========================= + +.. currentmodule:: brainpy.losses +.. automodule:: brainpy.losses + +.. contents:: + :local: + :depth: 1 + +Comparison +---------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + cross_entropy_loss + cross_entropy_sparse + cross_entropy_sigmoid + nll_loss + l1_loss + l2_loss + huber_loss + mean_absolute_error + mean_squared_error + mean_squared_log_error + binary_logistic_loss + multiclass_logistic_loss + sigmoid_binary_cross_entropy + softmax_cross_entropy + log_cosh_loss + ctc_loss_with_forward_probs + ctc_loss + CrossEntropyLoss + NLLLoss + L1Loss + MAELoss + MSELoss + + +Regularization +-------------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + l2_norm + mean_absolute + mean_square + log_cosh + smooth_labels + + diff --git a/docs/apis/math.rst b/docs/apis/math.rst new file mode 100644 index 000000000..92e4f56fc --- /dev/null +++ b/docs/apis/math.rst @@ -0,0 +1,480 @@ +``brainpy.math`` module +======================= + +.. contents:: + :local: + :depth: 1 + +Objects and Variables +--------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + BrainPyObject + FunAsObject + Partial + NodeList + NodeDict + node_dict + node_list + Variable + Parameter + TrainVar + VariableView + VarList + VarDict + var_list + var_dict + + +Object-oriented Transformations +------------------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + grad + vector_grad + jacobian + jacrev + jacfwd + hessian + make_loop + make_while + make_cond + cond + ifelse + for_loop + while_loop + jit + cls_jit + to_object + function + + +Environment Settings +-------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + set + set_environment + set_float + get_float + set_int + get_int + set_bool + get_bool + set_complex + get_complex + set_dt + get_dt + set_mode + get_mode + enable_x64 + disable_x64 + set_platform + get_platform + set_host_device_count + clear_buffer_memory + enable_gpu_memory_preallocation + disable_gpu_memory_preallocation + ditype + dftype + environment + batching_environment + training_environment + + +Array Interoperability +---------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + as_device_array + as_jax + as_ndarray + as_numpy + as_variable + + +Operators for Pre-Syn-Post Conversion +------------------------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + pre2post_sum + pre2post_prod + pre2post_max + pre2post_min + pre2post_mean + pre2post_event_sum + pre2post_csr_event_sum + pre2post_coo_event_sum + pre2syn + syn2post_sum + syn2post + syn2post_prod + syn2post_max + syn2post_min + syn2post_mean + syn2post_softmax + + +Activation Functions +-------------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + celu + elu + gelu + glu + prelu + silu + selu + relu + relu6 + rrelu + hard_silu + leaky_relu + hard_tanh + hard_sigmoid + tanh_shrink + hard_swish + hard_shrink + soft_sign + soft_shrink + softmax + softmin + softplus + swish + mish + log_sigmoid + log_softmax + one_hot + normalize + sigmoid + identity + tanh + + +Delay Variables +--------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + TimeDelay + LengthDelay + NeuTimeDelay + NeuLenDelay + ROTATE_UPDATE + CONCAT_UPDATE + + +Computing Modes +--------------- + +.. currentmodule:: brainpy.math +.. automodule:: brainpy.math + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Mode + NonBatchingMode + BatchingMode + TrainingMode + nonbatching_mode + batching_mode + training_mode + + +``brainpy.math.sparse`` module: Sparse Operators +------------------------------------------------ + +.. currentmodule:: brainpy.math.sparse +.. automodule:: brainpy.math.sparse + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + csrmv + coomv + seg_matmul + csr_to_dense + csr_to_coo + coo_to_csr + + +``brainpy.math.event`` module: Event-driven Operators +----------------------------------------------------- + +.. currentmodule:: brainpy.math.event +.. automodule:: brainpy.math.event + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + csrmv + info + + +``brainpy.math.jitconn`` module: Just-In-Time Connectivity Operators +-------------------------------------------------------------------- + +.. currentmodule:: brainpy.math.jitconn +.. automodule:: brainpy.math.jitconn + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + event_mv_prob_homo + event_mv_prob_uniform + event_mv_prob_normal + mv_prob_homo + mv_prob_uniform + mv_prob_normal + + +``brainpy.math.surrogate`` module: Surrogate Gradient Functions +--------------------------------------------------------------- + +.. currentmodule:: brainpy.math.surrogate +.. automodule:: brainpy.math.surrogate + +.. autosummary:: + :toctree: generated/ + + Surrogate + Sigmoid + sigmoid + PiecewiseQuadratic + piecewise_quadratic + PiecewiseExp + piecewise_exp + SoftSign + soft_sign + Arctan + arctan + NonzeroSignLog + nonzero_sign_log + ERF + erf + PiecewiseLeakyRelu + piecewise_leaky_relu + SquarewaveFourierSeries + squarewave_fourier_series + S2NN + s2nn + QPseudoSpike + q_pseudo_spike + LeakyRelu + leaky_relu + LogTailedRelu + log_tailed_relu + ReluGrad + relu_grad + GaussianGrad + gaussian_grad + InvSquareGrad + inv_square_grad + MultiGaussianGrad + multi_gaussian_grad + SlayerGrad + slayer_grad + inv_square_grad2 + relu_grad2 + + + +``brainpy.math.random`` module: Random Number Generations +--------------------------------------------------------- + +.. currentmodule:: brainpy.math.random +.. automodule:: brainpy.math.random + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + seed + split_key + split_keys + default_rng + rand + randint + random_integers + randn + random + random_sample + ranf + sample + choice + permutation + shuffle + beta + exponential + gamma + gumbel + laplace + logistic + normal + pareto + poisson + standard_cauchy + standard_exponential + standard_gamma + standard_normal + standard_t + uniform + truncated_normal + bernoulli + lognormal + binomial + chisquare + dirichlet + geometric + f + hypergeometric + logseries + multinomial + multivariate_normal + negative_binomial + noncentral_chisquare + noncentral_f + power + rayleigh + triangular + vonmises + wald + weibull + weibull_min + zipf + maxwell + t + orthogonal + loggamma + categorical + rand_like + randint_like + randn_like + RandomState + Generator + DEFAULT + + +``brainpy.math.linalg`` module: Linear algebra +---------------------------------------------- + +.. currentmodule:: brainpy.math.linalg +.. automodule:: brainpy.math.linalg + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + cholesky + cond + det + eig + eigh + eigvals + eigvalsh + inv + svd + lstsq + matrix_power + matrix_rank + norm + pinv + qr + solve + slogdet + tensorinv + tensorsolve + multi_dot + + +``brainpy.math.fft`` module: Discrete Fourier Transform +------------------------------------------------------- + +.. currentmodule:: brainpy.math.fft +.. automodule:: brainpy.math.fft + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + fft + fft2 + fftfreq + fftn + fftshift + hfft + ifft + ifft2 + ifftn + ifftshift + ihfft + irfft + irfft2 + irfftn + rfft + rfft2 + rfftfreq + rfftn + + diff --git a/docs/apis/measure.rst b/docs/apis/measure.rst new file mode 100644 index 000000000..931e53947 --- /dev/null +++ b/docs/apis/measure.rst @@ -0,0 +1,19 @@ +``brainpy.measure`` module +========================== + +.. currentmodule:: brainpy.measure +.. automodule:: brainpy.measure + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + cross_correlation + voltage_fluctuation + matrix_correlation + weighted_correlation + functional_connectivity + raster_plot + firing_rate + unitary_LFP diff --git a/docs/apis/mixin.rst b/docs/apis/mixin.rst new file mode 100644 index 000000000..d797bb37a --- /dev/null +++ b/docs/apis/mixin.rst @@ -0,0 +1,22 @@ +``brainpy.mixin`` module +======================== + +.. currentmodule:: brainpy.mixin +.. automodule:: brainpy.mixin + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + + MixIn + ReceiveInputProj + AlignPost + AutoDelaySupp + ParamDesc + ParamDescInit + BindCondData + Container + TreeNode + JointType diff --git a/docs/apis/optim.rst b/docs/apis/optim.rst new file mode 100644 index 000000000..49b09e594 --- /dev/null +++ b/docs/apis/optim.rst @@ -0,0 +1,63 @@ +``brainpy.optim`` module +======================== + +.. currentmodule:: brainpy.optim +.. automodule:: brainpy.optim + +.. contents:: + :local: + :depth: 1 + +Optimizers +---------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + Optimizer + SGD + Momentum + MomentumNesterov + Adagrad + Adadelta + RMSProp + Adam + LARS + Adan + AdamW + + +Schedulers +---------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + make_schedule + partial + BrainPyObject + MathError + Scheduler + Constant + CallBasedScheduler + StepLR + MultiStepLR + CosineAnnealingLR + CosineAnnealingWarmRestarts + ExponentialLR + ExponentialDecayLR + ExponentialDecay + InverseTimeDecayLR + InverseTimeDecay + PolynomialDecayLR + PolynomialDecay + PiecewiseConstantLR + PiecewiseConstant + Sequence + Union + + diff --git a/docs/apis/running.rst b/docs/apis/running.rst new file mode 100644 index 000000000..aa46ca6d7 --- /dev/null +++ b/docs/apis/running.rst @@ -0,0 +1,17 @@ +``brainpy.running`` module +========================== + +.. currentmodule:: brainpy.running +.. automodule:: brainpy.running + +.. autosummary:: + :toctree: generated/ + :nosignatures: + :template: classtemplate.rst + + jax_vectorize_map + jax_parallelize_map + process_pool + process_pool_lock + cpu_ordered_parallel + cpu_unordered_parallel diff --git a/docs/auto_generater.py b/docs/auto_generater.py index 3cccc347f..cbbb06df1 100644 --- a/docs/auto_generater.py +++ b/docs/auto_generater.py @@ -43,7 +43,7 @@ def _write_module(module_name, filename, header=None, template=False): # write autosummary fout.write('.. autosummary::\n') if template: - fout.write(' :template: class_template.rst\n') + fout.write(' :template: classtemplate.rst\n') fout.write(' :toctree: generated/\n\n') for m in functions: fout.write(f' {m}\n') @@ -77,7 +77,9 @@ def _write_submodules(module_name, filename, header=None, submodule_names=(), se # write autosummary fout.write('.. autosummary::\n') - fout.write(' :toctree: generated/\n\n') + fout.write(' :toctree: generated/\n') + fout.write(' :nosignatures:\n') + fout.write(' :template: classtemplate.rst\n\n') for m in functions: fout.write(f' {m}\n') for m in classes: @@ -109,7 +111,9 @@ def _write_subsections(module_name, fout.write(name + '\n') fout.write('-' * len(name) + '\n\n') fout.write('.. autosummary::\n') - fout.write(' :toctree: generated/\n\n') + fout.write(' :toctree: generated/\n') + fout.write(' :nosignatures:\n') + fout.write(' :template: classtemplate.rst\n\n') for m in values: fout.write(f' {m}\n') fout.write(f'\n\n') @@ -140,7 +144,9 @@ def _write_subsections_v2(module_path, fout.write(subheader + '\n') fout.write('-' * len(subheader) + '\n\n') fout.write('.. autosummary::\n') - fout.write(' :toctree: generated/\n\n') + fout.write(' :toctree: generated/\n') + fout.write(' :nosignatures:\n') + fout.write(' :template: classtemplate.rst\n\n') for m in functions: fout.write(f' {m}\n') for m in classes: @@ -182,7 +188,9 @@ def _write_subsections_v3(module_path, fout.write(subheader + '\n') fout.write('~' * len(subheader) + '\n\n') fout.write('.. autosummary::\n') - fout.write(' :toctree: generated/\n\n') + fout.write(' :toctree: generated/\n') + fout.write(' :nosignatures:\n') + fout.write(' :template: classtemplate.rst\n\n') for m in functions: fout.write(f' {m}\n') for m in classes: @@ -220,7 +228,9 @@ def _write_subsections_v4(module_path, fout.write('.. autosummary::\n') - fout.write(' :toctree: generated/\n\n') + fout.write(' :toctree: generated/\n') + fout.write(' :nosignatures:\n') + fout.write(' :template: classtemplate.rst\n\n') for m in functions: fout.write(f' {m}\n') for m in classes: diff --git a/docs/conf.py b/docs/conf.py index 8853c8b1f..19b1ab5bc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -18,25 +18,26 @@ sys.path.insert(0, os.path.abspath('../')) import brainpy -from docs import auto_generater os.makedirs('apis/auto/', exist_ok=True) -auto_generater.generate_analysis_docs() -auto_generater.generate_connect_docs() -auto_generater.generate_encoding_docs() -auto_generater.generate_initialize_docs() -auto_generater.generate_inputs_docs() -auto_generater.generate_dnn_docs() -auto_generater.generate_dyn_docs() -auto_generater.generate_losses_docs() -auto_generater.generate_measure_docs() -auto_generater.generate_optim_docs() -auto_generater.generate_running_docs() -auto_generater.generate_brainpy_docs() -auto_generater.generate_integrators_doc() -auto_generater.generate_math_docs() -auto_generater.generate_mixin_docs() +# from docs import auto_generater +# auto_generater.generate_analysis_docs() +# auto_generater.generate_connect_docs() +# auto_generater.generate_encoding_docs() +# auto_generater.generate_initialize_docs() +# auto_generater.generate_inputs_docs() +# auto_generater.generate_dnn_docs() +# auto_generater.generate_dyn_docs() +# auto_generater.generate_losses_docs() +# auto_generater.generate_measure_docs() +# auto_generater.generate_optim_docs() +# auto_generater.generate_running_docs() +# auto_generater.generate_brainpy_docs() +# auto_generater.generate_integrators_doc() +# auto_generater.generate_math_docs() +# auto_generater.generate_mixin_docs() +# sys.exit() changelogs = [ ('../changelog.rst', 'apis/auto/changelog.rst'), diff --git a/docs/core_concept/brainpy_transform_concept-old.ipynb b/docs/core_concept/brainpy_transform_concept-old.ipynb deleted file mode 100644 index c8b3a771b..000000000 --- a/docs/core_concept/brainpy_transform_concept-old.ipynb +++ /dev/null @@ -1,654 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "source": [ - "# Concept 1: Object-oriented Transformation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "@[Chaoming Wang](https://github.com/chaoming0625)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Most computation in BrainPy relies on [JAX](https://jax.readthedocs.io/en/latest/).\n", - "JAX has provided wonderful transformations, including differentiation, vecterization, parallelization and just-in-time compilation, for Python programs. If you are not familiar with it, please see its [documentation](https://jax.readthedocs.io/en/latest/).\n", - "\n", - "However, JAX only supports functional programming, i.e., transformations for Python functions. This is not what we want. Brain Dynamics Modeling need object-oriented programming.\n", - "\n", - "To meet this requirement, BrainPy defines the interface for object-oriented (OO) transformations. These OO transformations can be easily performed for BrainPy objects.\n", - "\n", - "In this section, let's talk about the BrainPy concept of object-oriented transformations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import brainpy as bp\n", - "import brainpy.math as bm\n", - "\n", - "# bm.set_platform('cpu')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "'2.3.0'" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bp.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Illustrating example: Training a network" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To illustrate this concept, we need a demonstration example. Here, we choose the popular neural network training as the illustrating case.\n", - "\n", - "In this training case, we want to teach the neural network to correctly classify a random array as two labels (`True` or `False`). That is, we have the training data:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "num_in = 100\n", - "num_sample = 256\n", - "X = bm.random.rand(num_sample, num_in)\n", - "Y = (bm.random.rand(num_sample) < 0.5).astype(float)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We use a two-layer feedforward network:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sequential(\n", - " [0] Linear0\n", - " [1] relu\n", - " [2] Linear1\n", - ")\n" - ] - } - ], - "source": [ - "class Linear(bp.BrainPyObject):\n", - " def __init__(self, n_in, n_out):\n", - " super().__init__()\n", - " self.num_in = n_in\n", - " self.num_out = n_out\n", - " init = bp.init.XavierNormal()\n", - " self.W = bm.Variable(init((n_in, n_out)))\n", - " self.b = bm.Variable(bm.zeros((1, n_out)))\n", - "\n", - " def __call__(self, x):\n", - " return x @ self.W + self.b\n", - "\n", - "\n", - "net = bp.Sequential(Linear(num_in, 20),\n", - " bm.relu,\n", - " Linear(20, 2))\n", - "print(net)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here, we use a supervised learning training paradigm. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train 400 epoch, loss = 0.6710\n", - "Train 800 epoch, loss = 0.5992\n", - "Train 1200 epoch, loss = 0.5332\n", - "Train 1600 epoch, loss = 0.4720\n", - "Train 2000 epoch, loss = 0.4189\n", - "Train 2400 epoch, loss = 0.3736\n", - "Train 2800 epoch, loss = 0.3335\n", - "Train 3200 epoch, loss = 0.2972\n", - "Train 3600 epoch, loss = 0.2644\n", - "Train 4000 epoch, loss = 0.2346\n" - ] - } - ], - "source": [ - "rng = bm.random.RandomState(123)\n", - "\n", - "\n", - "# Loss function\n", - "@bm.to_object(child_objs=net, dyn_vars=rng)\n", - "def loss():\n", - " # shuffle the data\n", - " key = rng.split_key()\n", - " x_data = rng.permutation(X, key=key)\n", - " y_data = rng.permutation(Y, key=key)\n", - " # prediction\n", - " predictions = net(dict(), x_data)\n", - " # loss\n", - " l = bp.losses.cross_entropy_loss(predictions, y_data)\n", - " return l\n", - "\n", - "\n", - "# Gradient function\n", - "grad = bm.grad(loss, grad_vars=net.vars(), return_value=True)\n", - "\n", - "# Optimizer\n", - "optimizer = bp.optim.SGD(lr=1e-2, train_vars=net.vars())\n", - "\n", - "\n", - "# Training step\n", - "@bm.to_object(child_objs=(grad, optimizer))\n", - "def train(i):\n", - " grads, l = grad()\n", - " optimizer.update(grads)\n", - " return l\n", - "\n", - "\n", - "num_step = 400\n", - "for i in range(0, 4000, num_step):\n", - " # train 400 steps once\n", - " ls = bm.for_loop(train, operands=bm.arange(i, i + num_step))\n", - " print(f'Train {i + num_step} epoch, loss = {bm.mean(ls):.4f}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the above example, we have seen classical elements in a neural network training, such as \n", - "\n", - "- `net`: neural network\n", - "- `loss`: loss function\n", - "- `grad`: gradient function\n", - "- `optimizer`: parameter optimizer\n", - "- `train`: training step" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In BrainPy, all these elements can be defined as class objects and can be used for performing OO transformations. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In essence, the concept of BrainPy object-oriented transformation has three components:\n", - "\n", - "- `BrainPyObject`: the base class for object-oriented programming\n", - "- `Variable`: the varibles in the class object, whose values are ready to be changed/updated during transformation\n", - "- `ObjectTransform`: the transformations for computation involving `BrainPyObject` and `Variable`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ``BrainPyObject`` and its ``Variable``" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "``BrainPyObject`` is the base class for object-oriented programming in BrainPy. \n", - "It can be viewed as a container which contains all needed [Variable](../tutorial_math/arrays_and_variables.ipynb) for our computation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](./imgs/net_with_two_linear.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the above example, ``Linear`` object has two ``Variable``: *W* and *b*. The ``net`` we defined is further composed of two ``Linear`` objects. We can expect that four variables can be retrieved from it." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "net.vars().keys()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "An important question is, **how to define `Variable` in a `BrainPyObject` so that we can retrieve all of them?**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Actually, all Variable instance which can be accessed by `self.` attribue can be retrived from a `BrainPyObject` recursively. \n", - "No matter how deep the composition of ``BrainPyObject``, once `BrainPyObject` instance and their `Variable` instances can be accessed by `self.` operation, all of them will be retrieved. " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "class SuperLinear(bp.BrainPyObject):\n", - " def __init__(self, ):\n", - " super().__init__()\n", - " self.l1 = Linear(10, 20)\n", - " self.v1 = bm.Variable(3)\n", - " \n", - "sl = SuperLinear()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['SuperLinear0.v1', 'Linear2.W', 'Linear2.b'])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# retrieve Variable\n", - "sl.vars().keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['SuperLinear0', 'Linear2'])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# retrieve BrainPyObject\n", - "sl.nodes().keys()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "However, we cannot access the ``BrainPyObject`` or ``Variable`` which is in a Python container (like tuple, list, or dict). For this case, we can register our objects and variables through ``.register_implicit_vars()`` and ``.register_implicit_nodes()``:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "class SuperSuperLinear(bp.BrainPyObject):\n", - " def __init__(self, register=False):\n", - " super().__init__()\n", - " self.ss = [SuperLinear(), SuperLinear()]\n", - " self.vv = {'v_a': bm.Variable(3)}\n", - " if register:\n", - " self.register_implicit_nodes(self.ss)\n", - " self.register_implicit_vars(self.vv)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys([])\n", - "dict_keys(['SuperSuperLinear0'])\n" - ] - } - ], - "source": [ - "# without register\n", - "ssl = SuperSuperLinear(register=False)\n", - "print(ssl.vars().keys())\n", - "print(ssl.nodes().keys())" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['SuperSuperLinear1.v_a', 'SuperLinear3.v1', 'SuperLinear4.v1', 'Linear5.W', 'Linear5.b', 'Linear6.W', 'Linear6.b'])\n", - "dict_keys(['SuperSuperLinear1', 'SuperLinear3', 'SuperLinear4', 'Linear5', 'Linear6'])\n" - ] - } - ], - "source": [ - "# with register\n", - "ssl = SuperSuperLinear(register=True)\n", - "print(ssl.vars().keys())\n", - "print(ssl.nodes().keys())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Transform a function to `BrainPyObject`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](./imgs/loss_with_net_and_rng.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's go back to our network training.\n", - "After the definition of `net`, we further define a ``loss`` function whose computation involves the ``net`` object for neural network prediction and a ``rng`` Variable for data shuffling. \n", - "\n", - "This Python function is then transformed into a ``BrainPyObject`` instance by ``brainpy.math.to_object`` interface. " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "FunAsObject(nodes=[Sequential0],\n", - " num_of_vars=1)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "loss" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "All `Variable` used in this instance can also be retrieved through:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['loss0._var0', 'Linear0.W', 'Linear0.b', 'Linear1.W', 'Linear1.b'])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "loss.vars().keys()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that, when using `to_object()`, we need to explicitly declare all `BrainPyObject` and `Variable` used in this Python function. \n", - "Due to the recursive retrieval property of `BrainPyObject`, we only need to specify the latest composition object.\n", - "\n", - "In the above `loss` object, we do not need to specify two ``Linear`` object. Instead, we only need to give the top level object ``net`` into ``to_object()`` transform. \n", - "\n", - "Similarly, when we transform ``train`` function into a ``BrainPyObject``, we just need to point out the ``grad`` and ``opt`` we have used, rather than the previous *loss*, *net* or *rng*. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](./imgs/train_with_grad_and_opt.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## BrainPy object-oriented transformations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "BrainPy object-oriented transformations are designed to work on ``BrainPyObject``. \n", - "These transformations include autograd ``brainpy.math.grad()`` and JIT ``brainpy.math.jit()``." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In our case, we used two OO transformations provided in BrainPy. \n", - "\n", - "First, ``grad`` object is defined with the ``loss`` function. Within it, we need to specify what variables we need to compute their gradients through `grad_vars`. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that, the OO transformation of any ``BrainPyObject`` results in another ``BrainPyObject`` object. Therefore, it can be recersively used as a component to form the larger scope of object-oriented programming and object-oriented transformation. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "GradientTransform(target=loss0, \n", - " num_of_grad_vars=4, \n", - " num_of_dyn_vars=1)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "grad" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](./imgs/grad_with_loss.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we train 400 steps once by using a ``for_loop`` transformation. Different from ``grad`` which return a `BrainPyObject` instance, `for_loop` direactly returns the loop results. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![](./imgs/for-loop-train.png)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "BrainPy", - "language": "python", - "name": "brainpy" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.6" - }, - "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": 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": "245.75px" - }, - "toc_section_display": true, - "toc_window_display": true - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/core_concept/imgs/for-loop-train.png b/docs/core_concept/imgs/for-loop-train.png deleted file mode 100644 index 5c380e5a7..000000000 Binary files a/docs/core_concept/imgs/for-loop-train.png and /dev/null differ diff --git a/docs/core_concept/imgs/grad_with_loss.png b/docs/core_concept/imgs/grad_with_loss.png deleted file mode 100644 index 64e7d6ab9..000000000 Binary files a/docs/core_concept/imgs/grad_with_loss.png and /dev/null differ diff --git a/docs/core_concept/imgs/loss_with_net_and_rng.png b/docs/core_concept/imgs/loss_with_net_and_rng.png deleted file mode 100644 index 94e4b2af5..000000000 Binary files a/docs/core_concept/imgs/loss_with_net_and_rng.png and /dev/null differ diff --git a/docs/core_concept/imgs/train_with_grad_and_opt.png b/docs/core_concept/imgs/train_with_grad_and_opt.png deleted file mode 100644 index e5ff0ca30..000000000 Binary files a/docs/core_concept/imgs/train_with_grad_and_opt.png and /dev/null differ diff --git a/docs/index.rst b/docs/index.rst index 1cf3db2f3..583a30e08 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -195,8 +195,8 @@ Learn more core_concepts.rst tutorials.rst - advanced_tutorials.rst toolboxes.rst + advanced_tutorials.rst FAQ.rst api.rst diff --git a/docs/quickstart/installation.rst b/docs/quickstart/installation.rst index 346acfaca..68baef1ad 100644 --- a/docs/quickstart/installation.rst +++ b/docs/quickstart/installation.rst @@ -78,8 +78,8 @@ BrainPy relies on `JAX`_. JAX is a high-performance JIT compiler which enables users to run Python code on CPU, GPU, and TPU devices. Core functionalities of BrainPy (>=2.0.0) have been migrated to the JAX backend. -Linux & MacOS -^^^^^^^^^^^^^ +Linux +^^^^^ Currently, JAX supports **Linux** (Ubuntu 16.04 or later) and **macOS** (10.12 or later) platforms. The provided binary releases of `jax` and `jaxlib` for Linux and macOS @@ -93,14 +93,20 @@ If you want to install a CPU-only version of `jax` and `jaxlib`, you can run .. code-block:: bash - pip install --upgrade "jax[cpu]" -f https://storage.googleapis.com/jax-releases/jax_releases.html + pip install --upgrade "jax[cpu]" If you want to install JAX with both CPU and NVidia GPU support, you must first install `CUDA`_ and `CuDNN`_, if they have not already been installed. Next, run .. code-block:: bash - pip install --upgrade "jax[cuda]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html + # CUDA 12 installation + # Note: wheels only available on linux. + pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html + + # CUDA 11 installation + # Note: wheels only available on linux. + pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html Alternatively, you can download the preferred release ".whl" file for jaxlib @@ -108,23 +114,54 @@ from the above release links, and install it via ``pip``: .. code-block:: bash - pip install xxx-0.3.14-xxx.whl + pip install xxx-0.4.15-xxx.whl - pip install jax==0.3.14 + pip install jax==0.4.15 .. note:: - Note that the versions of `jaxlib` and `jax` should be consistent. + Note that the versions of jaxlib and jax should be consistent. + + For example, if you are using jax==0.4.15, you would better install jax==0.4.15. + + +MacOS +^^^^^ + +If you are using macOS Intel, we recommend you first to install the Miniconda Intel installer: + +1. Download the package in the link https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.pkg +2. Then click the downloaded package and install it. - For example, if you are using `jax==0.3.14`, you would better install `jax==0.3.14`. + +If you are using the latest M1 macOS version, you'd better to install the Miniconda M1 installer: + + +1. Download the package in the link https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.pkg +2. Then click the downloaded package and install it. + + +Finally, you can install `jax` and `jaxlib` as the same as the Linux platform. + +.. code-block:: bash + + pip install --upgrade "jax[cpu]" Windows ^^^^^^^ -For **Windows** users, `jax` and `jaxlib` can be installed from the community supports. -Specifically, you can install `jax` and `jaxlib` through: +For **Windows** users with Python >= 3.9, `jax` and `jaxlib` can be installed +directly from the PyPi channel. + +.. code-block:: bash + + pip install jax jaxlib + + +For **Windows** users with Python <= 3.8, `jax` and `jaxlib` can be installed +from the community supports. Specifically, you can install `jax` and `jaxlib` through: .. code-block:: bash @@ -137,14 +174,15 @@ If you are using GPU, you can install GPU-versioned wheels through: pip install "jax[cuda111]" -f https://whls.blob.core.windows.net/unstable/index.html Alternatively, you can manually install you favourite version of `jax` and `jaxlib` by -downloading binary releases of JAX for Windows from https://whls.blob.core.windows.net/unstable/index.html . +downloading binary releases of JAX for Windows from +https://whls.blob.core.windows.net/unstable/index.html . Then install it via ``pip``: .. code-block:: bash - pip install xxx-0.3.14-xxx.whl + pip install xxx-0.4.15-xxx.whl - pip install jax==0.3.14 + pip install jax==0.4.15 WSL ^^^ @@ -159,17 +197,60 @@ Dependency 3: brainpylib ------------------------ Many customized operators in BrainPy are implemented in ``brainpylib``. -``brainpylib`` can also be installed through `pypi `_. +``brainpylib`` can also be installed from pypi according to your devices. +For windows, Linux and MacOS users, ``brainpylib`` supports CPU operators. +You can install CPU-version `brainpylib` by: .. code-block:: bash - pip install brainpylib + # CPU installation + pip install --upgrade brainpylib -For windows, Linux and MacOS users, ``brainpylib`` supports CPU operators. +For Nvidia GPU users, ``brainpylib`` only support Linux system and WSL2 subsystem. You can install the CUDA-version by using: + +.. code-block:: bash + + # CUDA 12 installation + pip install --upgrade brainpylib-cu12x + +.. code-block:: bash + + # CUDA 11 installation + pip install --upgrade brainpylib-cu11x + +Running BrainPy with docker +------------------------ + +If you want to use BrainPy in docker, you can use the following command to pull the docker image: + +.. code:: bash + + docker pull brainpy/brainpy:latest + +You can then run the docker image by: + +.. code:: bash + + docker run -it --platform linux/amd64 brainpy/brainpy:latest + +Please notice that BrainPy docker image is based on the `ubuntu22.04` image, so it only support CPU version of BrainPy. + + +Running BrainPy online with binder +---------------------------------- + +Click on the following link to launch the Binder environment with the +BrainPy repository: + +|image1| + +Wait for the Binder environment to build. This might take a few moments. -For CUDA users, ``brainpylib`` only support GPU on Linux platform. You can install GPU version ``brainpylib`` -on Linux through ``pip install brainpylib`` too. +Once the environment is ready, you'll be redirected to a Jupyter +notebook interface within your web browser. +.. |image1| image:: https://camo.githubusercontent.com/581c077bdbc6ca6899c86d0acc6145ae85e9d80e6f805a1071793dbe48917982/68747470733a2f2f6d7962696e6465722e6f72672f62616467655f6c6f676f2e737667 + :target: https://mybinder.org/v2/gh/brainpy/BrainPy-binder/main .. _NumPy: https://numpy.org/ diff --git a/docs/quickstart/simulation.ipynb b/docs/quickstart/simulation.ipynb index b83f47dc7..32aa7dca3 100644 --- a/docs/quickstart/simulation.ipynb +++ b/docs/quickstart/simulation.ipynb @@ -28,16 +28,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "c4fbe84d", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:21.299843Z", - "end_time": "2023-04-15T13:35:23.181553Z" + "end_time": "2023-09-10T08:44:44.998356100Z", + "start_time": "2023-09-10T08:44:43.279558300Z" } }, "outputs": [], "source": [ + "import numpy as np\n", + "\n", "import brainpy as bp\n", "import brainpy.math as bm\n", "\n", @@ -46,20 +48,20 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "d0b5bce6", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:23.181553Z", - "end_time": "2023-04-15T13:35:23.197148Z" + "end_time": "2023-09-10T08:44:45.015026300Z", + "start_time": "2023-09-10T08:44:44.998356100Z" } }, "outputs": [ { "data": { - "text/plain": "'2.4.0'" + "text/plain": "'2.4.4.post3'" }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -117,23 +119,23 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "69556409", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:23.197148Z", - "end_time": "2023-04-15T13:35:23.612974Z" + "end_time": "2023-09-10T08:44:45.746060600Z", + "start_time": "2023-09-10T08:44:45.017640300Z" } }, "outputs": [], "source": [ - "E = bp.neurons.LIF(3200, V_rest=-60., V_th=-50., V_reset=-60.,\n", - " tau=20., tau_ref=5., method='exp_auto',\n", - " V_initializer=bp.init.Normal(-60., 2.))\n", + "E = bp.dyn.LifRef(3200, V_rest=-60., V_th=-50., V_reset=-60.,\n", + " tau=20., tau_ref=5., method='exp_auto',\n", + " V_initializer=bp.init.Normal(-60., 2.))\n", "\n", - "I = bp.neurons.LIF(800, V_rest=-60., V_th=-50., V_reset=-60.,\n", - " tau=20., tau_ref=5., method='exp_auto',\n", - " V_initializer=bp.init.Normal(-60., 2.))" + "I = bp.dyn.LifRef(800, V_rest=-60., V_th=-50., V_reset=-60.,\n", + " tau=20., tau_ref=5., method='exp_auto',\n", + " V_initializer=bp.init.Normal(-60., 2.))" ] }, { @@ -146,70 +148,126 @@ }, { "cell_type": "markdown", - "id": "abe09b1b", - "metadata": {}, "source": [ - "Then the synaptic connections between these two groups can be defined as follows:" - ] + "Before we define the synaptic projections between different populations, let's create a synapse model with the Exponential dynamics and conductance-based synaptic currents. " + ], + "metadata": { + "collapsed": false + }, + "id": "24b642e81690f06a" }, { "cell_type": "code", - "execution_count": 4, - "id": "8be1733f", + "execution_count": 5, + "outputs": [], + "source": [ + "class Exponential(bp.Projection): \n", + " def __init__(self, pre, post, delay, prob, g_max, tau, E):\n", + " super().__init__()\n", + " self.pron = bp.dyn.ProjAlignPost2(\n", + " pre=pre,\n", + " delay=delay,\n", + " # Event-driven computation\n", + " comm=bp.dnn.EventCSRLinear(bp.conn.FixedProb(prob, pre=pre.num, post=post.num), g_max), \n", + " syn=bp.dyn.Expon(size=post.num, tau=tau),# Exponential synapse\n", + " out=bp.dyn.COBA(E=E), # COBA network\n", + " post=post\n", + " )" + ], "metadata": { + "collapsed": false, "ExecuteTime": { - "start_time": "2023-04-15T13:35:23.612974Z", - "end_time": "2023-04-15T13:35:25.688031Z" + "end_time": "2023-09-10T08:44:45.761555100Z", + "start_time": "2023-09-10T08:44:45.746060600Z" } }, - "outputs": [], - "source": [ - "E2E = bp.synapses.Exponential(E, E, bp.conn.FixedProb(prob=0.02), g_max=0.6,\n", - " tau=5., output=bp.synouts.COBA(E=0.),\n", - " method='exp_auto')\n", - "\n", - "E2I = bp.synapses.Exponential(E, I, bp.conn.FixedProb(prob=0.02), g_max=0.6,\n", - " tau=5., output=bp.synouts.COBA(E=0.),\n", - " method='exp_auto')\n", - "\n", - "I2E = bp.synapses.Exponential(I, E, bp.conn.FixedProb(prob=0.02), g_max=6.7,\n", - " tau=10., output=bp.synouts.COBA(E=-80.),\n", - " method='exp_auto')\n", - "\n", - "I2I = bp.synapses.Exponential(I, I, bp.conn.FixedProb(prob=0.02), g_max=6.7,\n", - " tau=10., output=bp.synouts.COBA(E=-80.),\n", - " method='exp_auto')" - ] + "id": "45b6804ed82895a" }, { "cell_type": "markdown", "id": "13b3c3a9", "metadata": {}, "source": [ - "Here we use the Exponential synapse model (``bp.synapses.Exponential``) to simulate synaptic connections. Among the parameters of the model, the first two denotes the pre- and post-synaptic neuron groups, respectively. The third one refers to the connection types. In this example, we use ``bp.conn.FixedProb``, which connects the presynaptic neurons to postsynaptic neurons with a given probability (detailed information is available in [Synaptic Connection](../tutorial_toolbox/synaptic_connections.ipynb)). The following three parameters describes the dynamic properties of the synapse, and the last one is the numerical integration method as that in the LIF model." + "Here we use the Align post projection method (``bp.dyn.ProjAlignPost2``) to simulate synaptic connections. Among the parameters of the model, the first two denotes the pre- and post-synaptic neuron groups, respectively. The third one refers to the connection types. In this example, we use ``bp.conn.FixedProb``, which connects the pre-synaptic neurons to postsynaptic neurons with a given probability (detailed information is available in [Synaptic Connection](../tutorial_toolbox/synaptic_connections.ipynb)). The following three parameters describes the dynamic properties of the synapse, and the last one is the numerical integration method as that in the LIF model." ] }, + { + "cell_type": "markdown", + "source": [ + "Then the synaptic connections between these two groups can be defined as follows:" + ], + "metadata": { + "collapsed": false + }, + "id": "abe09b1b" + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "# projection from E to E\n", + "E2E = Exponential(E, E, 0., 0.02, 0.6, 5., 0.)\n", + "\n", + "# projection from E to I\n", + "E2I = Exponential(E, I, 0., 0.02, 0.6, 5., 0.)\n", + "\n", + "# projection from I to E\n", + "I2E = Exponential(I, E, 0., 0.02, 6.7, 10., -80.)\n", + "\n", + "# projection from I to I\n", + "I2I = Exponential(I, I, 0., 0.02, 6.7, 10., -80.)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-09-10T08:44:48.194090100Z", + "start_time": "2023-09-10T08:44:45.761555100Z" + } + }, + "id": "8be1733f" + }, { "cell_type": "markdown", "id": "572fa775", "metadata": {}, "source": [ - "After defining all the components, they can be combined to form a network:" + "Putting these together, we can get an E/I balanced network." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "f8a6c731", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:25.678171Z", - "end_time": "2023-04-15T13:35:25.694111Z" + "end_time": "2023-09-10T08:44:48.203744400Z", + "start_time": "2023-09-10T08:44:48.192540100Z" } }, "outputs": [], "source": [ - "net = bp.Network(E2E, E2I, I2E, I2I, E=E, I=I)" + "class EINet(bp.DynamicalSystem):\n", + " def __init__(self, ne=3200, ni=800):\n", + " super().__init__()\n", + " self.E = bp.dyn.LifRef(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,\n", + " V_initializer=bp.init.Normal(-55., 2.))\n", + " self.I = bp.dyn.LifRef(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,\n", + " V_initializer=bp.init.Normal(-55., 2.))\n", + " self.E2E = Exponential(self.E, self.E, 0., 0.02, 0.6, 5., 0.)\n", + " self.E2I = Exponential(self.E, self.I, 0., 0.02, 0.6, 5., 0.)\n", + " self.I2E = Exponential(self.I, self.E, 0., 0.02, 6.7, 10., -80.)\n", + " self.I2I = Exponential(self.I, self.I, 0., 0.02, 6.7, 10., -80.)\n", + "\n", + " def update(self, inp=0.):\n", + " self.E2E()\n", + " self.E2I()\n", + " self.I2E()\n", + " self.I2I()\n", + " self.E(inp)\n", + " self.I(inp)\n", + " # monitor\n", + " return self.E.spike, self.I.spike" ] }, { @@ -217,9 +275,7 @@ "id": "0412deb5", "metadata": {}, "source": [ - "In the definition, neurons and synapses are given to the network. The excitatory and inhibitory neuron groups (`E` and `I`) are passed with a name, for they will be specifically operated in the simulation (here they will be given with input currents).\n", - "\n", - "We have successfully constructed an E-I balanced network by using BrainPy's biult-in models. On the other hand, BrianPy also enables users to customize their own dynamic models such as neuron groups, synapses, and networks flexibly. In fact, ``brainpy.dyn.Network()`` is a simple example of customizing a network model. Please refer to [Dynamic Simulation](../tutorial_simulation/index.rst) for more information." + "We have successfully constructed an E-I balanced network by using BrainPy's biult-in models. On the other hand, BrianPy also enables users to customize their own dynamic models such as neuron groups, synapses, and networks flexibly. In fact, ``brainpy.DynSysGroup()`` is a simple example of customizing a network model. Please refer to [Dynamic Simulation](../tutorial_simulation/index.rst) for more information." ] }, { @@ -227,7 +283,9 @@ "id": "e3bcad34", "metadata": {}, "source": [ - "### Running a simulation" + "### Running a simulation\n", + "\n", + "After building a SNN, we can use it for dynamic simulation. BrainPy provides multiple ways to simulate brain dynamics models. " ] }, { @@ -235,25 +293,24 @@ "id": "43ec39f4", "metadata": {}, "source": [ - "After building a SNN, we can use it for dynamic simulation. To run a simulation, we need to wrap the network model into a **runner** first. BrainPy provides ``DSRunner`` in ``brainpy.dyn``, which will be expanded in the [Runners](../tutorial_simulation/index.rst) tutorial. Users can initialize ``DSRunner`` as followed:" + "First, BrainPy provides ``DSRunner`` in ``brainpy``, which will be expanded in the [Runners](../tutorial_simulation/index.rst) tutorial. Users can initialize ``DSRunner`` as followed:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "8e16cd97", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:25.694111Z", - "end_time": "2023-04-15T13:35:25.709754Z" + "end_time": "2023-09-10T08:44:48.983996200Z", + "start_time": "2023-09-10T08:44:48.203744400Z" } }, "outputs": [], "source": [ - "runner = bp.DSRunner(net,\n", - " monitors=['E.spike', 'I.spike'],\n", - " inputs=[('E.input', 20.), ('I.input', 20.)],\n", - " dt=0.1)" + "net = EINet()\n", + "\n", + "runner = bp.DSRunner(net, monitors=['E.spike', 'I.spike'])" ] }, { @@ -261,21 +318,19 @@ "id": "11473917", "metadata": {}, "source": [ - "To make dynamic simulation more applicable and powerful, users can monitor variable trajectories and give inputs 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", - "More details of how to give inputs and monitors please refer to [Dynamic Simulation](../tutorial_simulation/index.rst).\n", + "To make dynamic simulation more applicable and powerful, users can monitor variable trajectories and give inputs 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. More details of how to give inputs and monitors please refer to [Dynamic Simulation](../tutorial_simulation/index.rst).\n", "\n", - "After creating the runner, we can run a simulation by calling the runner:" + "After creating the runner, we can run a simulation by calling the runner, where the calling function receives the simulation time (usually in milliseconds) as the input. BrainPy achieves an extraordinary simulation speed with the assistance of just-in-time (JIT) compilation. Please refer to [Just-In-Time Compilation](../tutorial_math/brainpy_transform_concept.ipynb) for more details." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "a2a602d2", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:25.709754Z", - "end_time": "2023-04-15T13:35:26.742003Z" + "end_time": "2023-09-10T08:44:50.192018700Z", + "start_time": "2023-09-10T08:44:48.983996200Z" } }, "outputs": [ @@ -285,7 +340,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "33ac887e0d7347a8aa9078635f0687a4" + "model_id": "cb881757388046c7876601f41a5e6afb" } }, "metadata": {}, @@ -293,34 +348,95 @@ } ], "source": [ - "runner.run(100)" + "Is = bm.ones(1000) * 20. # 100 ms\n", + "_ = runner.run(inputs=Is)" ] }, + { + "cell_type": "markdown", + "source": [ + "The monitored spikes are stored in the ``runner.mon``. " + ], + "metadata": { + "collapsed": false + }, + "id": "acff9360881308ef" + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "E_sps = runner.mon['E.spike']\n", + "I_sps = runner.mon['I.spike']" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-09-10T08:44:50.207020900Z", + "start_time": "2023-09-10T08:44:50.192018700Z" + } + }, + "id": "3cf93c4cf74a2205" + }, + { + "cell_type": "markdown", + "source": [ + "Second, users can also use ``brainpy.math.for_loop`` for the efficient simulation of any BrainPy models. To do that, we need to define a running function which defines the one-step updating function of the model. " + ], + "metadata": { + "collapsed": false + }, + "id": "19ec58dbf4c20634" + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [], + "source": [ + "net = EINet()\n", + "\n", + "def run_fun(i):\n", + " # i: the running index\n", + " # 20.: the input\n", + " return net.step_run(i, 20.)\n", + "\n", + "indices = np.arange(int(100. / bm.get_dt())) # 100. ms\n", + "E_sps, I_sps = bm.for_loop(run_fun, indices)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-09-10T08:44:51.621343100Z", + "start_time": "2023-09-10T08:44:50.209021100Z" + } + }, + "id": "85c630f3902ce1b7" + }, { "cell_type": "markdown", "id": "8452dec3", "metadata": {}, "source": [ - "where the calling function receives the simulation time (usually in milliseconds) as the input. BrainPy achieves an extraordinary simulation speed with the assistance of just-in-time (JIT) compilation. Please refer to [Just-In-Time Compilation](../tutorial_math/brainpy_transform_concept.ipynb) for more details.\n", "\n", "The simulation results are stored as NumPy arrays in the monitors, and can be visualized easily:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "id": "f3aab08c", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:26.725106Z", - "end_time": "2023-04-15T13:35:27.147108Z" + "end_time": "2023-09-10T08:44:52.164740Z", + "start_time": "2023-09-10T08:44:51.605619800Z" } }, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -331,10 +447,11 @@ "\n", "plt.figure(figsize=(12, 4.5))\n", "\n", + "ts = indices * bm.get_dt()\n", "plt.subplot(121)\n", - "bp.visualize.raster_plot(runner.mon.ts, runner.mon['E.spike'], show=False)\n", + "bp.visualize.raster_plot(ts, E_sps, show=False)\n", "plt.subplot(122)\n", - "bp.visualize.raster_plot(runner.mon.ts, runner.mon['I.spike'], show=True)" + "bp.visualize.raster_plot(ts, I_sps, show=True)" ] }, { @@ -406,12 +523,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "id": "217204d5", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:27.147108Z", - "end_time": "2023-04-15T13:35:27.212303Z" + "end_time": "2023-09-10T08:44:52.180403100Z", + "start_time": "2023-09-10T08:44:52.164740Z" } }, "outputs": [], @@ -427,78 +544,177 @@ "id": "e559ece9", "metadata": {}, "source": [ - "To build $\\mathrm{I_A}$ and $\\mathrm{I_B}$, we shall define a class of neuron groups that can generate stochastic Possion stimulu. To define neuron groups, they should inherit from `brainpy.dyn.NeuGroup`." + "We first define tools we used for simulation, including the visualization toolkit and Poisson noise generations." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "id": "b76c3965", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:27.162856Z", - "end_time": "2023-04-15T13:35:27.212303Z" + "end_time": "2023-09-10T08:44:52.258583900Z", + "start_time": "2023-09-10T08:44:52.180403100Z" } }, "outputs": [], "source": [ - "class PoissonStim(bp.NeuGroup):\n", - " def __init__(self, size, freq_mean, freq_var, t_interval, **kwargs):\n", - " super(PoissonStim, self).__init__(size=size, **kwargs)\n", - "\n", - " # initialize parameters\n", - " self.freq_mean = freq_mean\n", - " self.freq_var = freq_var\n", - " self.t_interval = t_interval\n", + "class Tool:\n", + " def __init__(self, pre_stimulus_period=100., stimulus_period=1000., delay_period=500.):\n", + " self.pre_stimulus_period = pre_stimulus_period\n", + " self.stimulus_period = stimulus_period\n", + " self.delay_period = delay_period\n", + " self.freq_variance = 10.\n", + " self.freq_interval = 50.\n", + " self.total_period = pre_stimulus_period + stimulus_period + delay_period\n", + "\n", + " def generate_freqs(self, mean):\n", + " # stimulus period\n", + " n_stim = int(self.stimulus_period / self.freq_interval)\n", + " n_interval = int(self.freq_interval / bm.get_dt())\n", + " freqs_stim = np.random.normal(mean, self.freq_variance, (n_stim, 1))\n", + " freqs_stim = np.tile(freqs_stim, (1, n_interval)).flatten()\n", + " # pre stimulus period\n", + " freqs_pre = np.zeros(int(self.pre_stimulus_period / bm.get_dt()))\n", + " # post stimulus period\n", + " freqs_delay = np.zeros(int(self.delay_period / bm.get_dt()))\n", + " all_freqs = np.concatenate([freqs_pre, freqs_stim, freqs_delay], axis=0)\n", + " return bm.asarray(all_freqs)\n", + "\n", + " def visualize_results(self, mon, IA_freqs, IB_freqs, t_start=0., title=None):\n", + " fig, gs = bp.visualize.get_figure(4, 1, 3, 10)\n", + " axes = [fig.add_subplot(gs[i, 0]) for i in range(4)]\n", + "\n", + " ax = axes[0]\n", + " bp.visualize.raster_plot(mon['ts'], mon['A.spike'], markersize=1, ax=ax)\n", + " if title: ax.set_title(title)\n", + " ax.set_ylabel(\"Group A\")\n", + " ax.set_xlim(t_start, self.total_period + 1)\n", + " ax.axvline(self.pre_stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period + self.delay_period, linestyle='dashed')\n", + "\n", + " ax = axes[1]\n", + " bp.visualize.raster_plot(mon['ts'], mon['B.spike'], markersize=1, ax=ax)\n", + " ax.set_ylabel(\"Group B\")\n", + " ax.set_xlim(t_start, self.total_period + 1)\n", + " ax.axvline(self.pre_stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period + self.delay_period, linestyle='dashed')\n", + "\n", + " ax = axes[2]\n", + " rateA = bp.measure.firing_rate(mon['A.spike'], width=10.)\n", + " rateB = bp.measure.firing_rate(mon['B.spike'], width=10.)\n", + " ax.plot(mon['ts'], rateA, label=\"Group A\")\n", + " ax.plot(mon['ts'], rateB, label=\"Group B\")\n", + " ax.set_ylabel('Population activity [Hz]')\n", + " ax.set_xlim(t_start, self.total_period + 1)\n", + " ax.axvline(self.pre_stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period + self.delay_period, linestyle='dashed')\n", + " ax.legend()\n", + "\n", + " ax = axes[3]\n", + " ax.plot(mon['ts'], IA_freqs, label=\"group A\")\n", + " ax.plot(mon['ts'], IB_freqs, label=\"group B\")\n", + " ax.set_ylabel(\"Input activity [Hz]\")\n", + " ax.set_xlim(t_start, self.total_period + 1)\n", + " ax.axvline(self.pre_stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period, linestyle='dashed')\n", + " ax.axvline(self.pre_stimulus_period + self.stimulus_period + self.delay_period, linestyle='dashed')\n", + " ax.legend()\n", + " ax.set_xlabel(\"Time [ms]\")\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "source": [ + "The main synaptic projections used in the model are AMPA, GABAA and NMDA. Therefore, we define the synaptic projections we need. " + ], + "metadata": { + "collapsed": false + }, + "id": "f4f48aca4996b3e9" + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [], + "source": [ + "class ExpSyn(bp.Projection):\n", + " def __init__(self, pre, post, conn, delay, g_max, tau, E):\n", + " super().__init__()\n", + " if conn == 'all2all':\n", + " comm = bp.dnn.AllToAll(pre.num, post.num, g_max)\n", + " elif conn == 'one2one':\n", + " comm = bp.dnn.OneToOne(pre.num, g_max)\n", + " else:\n", + " raise ValueError\n", + " syn = bp.dyn.Expon.desc(post.num, tau=tau)\n", + " out = bp.dyn.COBA.desc(E=E)\n", + " self.proj = bp.dyn.ProjAlignPostMg2(\n", + " pre=pre, delay=delay, comm=comm,\n", + " syn=syn, out=out, post=post\n", + " )\n", "\n", - " # initialize variables\n", - " self.freq = bm.Variable(bm.zeros(1))\n", - " self.freq_t_last_change = bm.Variable(bm.ones(1) * -1e7)\n", - " self.spike = bm.Variable(bm.zeros(self.num, dtype=bool))\n", - " self.rng = bm.random.RandomState()\n", "\n", - " def update(self, tdi):\n", - " in_interval = bm.logical_and(pre_stimulus_period < tdi.t, tdi.t < pre_stimulus_period + stimulus_period)\n", - " freq = bm.where(in_interval, self.freq[0], 0.)\n", - " change = bm.logical_and(in_interval, (tdi.t - self.freq_t_last_change[0]) >= self.t_interval)\n", - " self.freq[:] = bm.where(change, self.rng.normal(self.freq_mean, self.freq_var), freq)\n", - " self.freq_t_last_change[:] = bm.where(change, tdi.t, self.freq_t_last_change[0])\n", - " self.spike.value = self.rng.random(self.num) < self.freq[0] * tdi.dt / 1000." - ] + "class NMDA(bp.Projection):\n", + " def __init__(self, pre, post, conn, delay, g_max):\n", + " super().__init__()\n", + " if conn == 'all2all':\n", + " comm = bp.dnn.AllToAll(pre.num, post.num, g_max)\n", + " elif conn == 'one2one':\n", + " comm = bp.dnn.OneToOne(pre.num, g_max)\n", + " else:\n", + " raise ValueError\n", + " syn = bp.dyn.NMDA.desc(pre.num, a=0.5, tau_decay=100., tau_rise=2.)\n", + " out = bp.dyn.MgBlock(E=0., cc_Mg=1.0)\n", + " self.proj = bp.dyn.ProjAlignPreMg2(\n", + " pre=pre, delay=delay, syn=syn,\n", + " comm=comm, out=out, post=post\n", + " )" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-09-10T08:44:52.258583900Z", + "start_time": "2023-09-10T08:44:52.195990900Z" + } + }, + "id": "f9352b672e39d80d" }, { "cell_type": "markdown", "id": "0dbe7213", "metadata": {}, "source": [ - "Because there are too many neuron groups and connections, it will be much clearer if we define a new network class inheriting `brainpy.dyn.Network` to accommodate all these neurons and synapses:" + "Because there are too many neuron groups and connections, it will be much clearer if we define a new network class inheriting `brainpy.DynSysGroup` to accommodate all these neurons and synapses:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "ca22fe03", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:27.180923Z", - "end_time": "2023-04-15T13:35:27.212303Z" + "end_time": "2023-09-10T08:44:52.321088Z", + "start_time": "2023-09-10T08:44:52.211612Z" } }, "outputs": [], "source": [ - "class DecisionMaking(bp.Network):\n", - " def __init__(self, scale=1., mu0=40., coherence=25.6, f=0.15, dt=bm.get_dt()):\n", - " super(DecisionMaking, self).__init__()\n", - "\n", - " # initialize neuron-group parameters\n", + "class DecisionMakingNet(bp.DynSysGroup):\n", + " def __init__(self, scale=1., f=0.15):\n", + " super().__init__()\n", + " # 网络中各组神经元的数目\n", " num_exc = int(1600 * scale)\n", - " num_inh = int(400 * scale)\n", - " num_A = int(f * num_exc)\n", - " num_B = int(f * num_exc)\n", + " num_I, num_A, num_B = int(400 * scale), int(f * num_exc), int(f * num_exc)\n", " num_N = num_exc - num_A - num_B\n", - " poisson_freq = 2400. # Hz\n", + " self.num_A, self.num_B, self.num_N, self.num_I = num_A, num_B, num_N, num_I\n", "\n", - " # initialize synapse parameters\n", + " poisson_freq = 2400. # Hz\n", " w_pos = 1.7\n", " w_neg = 1. - f * (w_pos - 1.) / (1. - f)\n", " g_ext2E_AMPA = 2.1 # nS\n", @@ -510,87 +726,77 @@ " g_I2E_GABAa = 1.3 / scale # nS\n", " g_I2I_GABAa = 1.0 / scale # nS\n", "\n", - " # parameters of the AMPA synapse\n", - " ampa_par = dict(delay_step=int(0.5 / dt), tau=2.0, output=bp.synouts.COBA(E=0.))\n", - "\n", - " # parameters of the GABA synapse\n", - " gaba_par = dict(delay_step=int(0.5 / dt), tau=5.0, output=bp.synouts.COBA(E=-70.))\n", + " neu_par = dict(V_rest=-70., V_reset=-55., V_th=-50., V_initializer=bp.init.OneInit(-70.))\n", "\n", - " # parameters of the NMDA synapse\n", - " nmda_par = dict(delay_step=int(0.5 / dt), tau_decay=100, tau_rise=2.,\n", - " a=0.5, output=bp.synouts.MgBlock(E=0., cc_Mg=1.))\n", + " # E neurons/pyramid neurons\n", + " self.A = bp.dyn.LifRef(num_A, tau=20., R=0.04, tau_ref=2., **neu_par)\n", + " self.B = bp.dyn.LifRef(num_B, tau=20., R=0.04, tau_ref=2., **neu_par)\n", + " self.N = bp.dyn.LifRef(num_N, tau=20., R=0.04, tau_ref=2., **neu_par)\n", "\n", - " # excitatory and inhibitory neuron groups, A, B, N, and I\n", - " A = bp.neurons.LIF(num_A, V_rest=-70., V_reset=-55., V_th=-50., tau=20., R=0.04,\n", - " tau_ref=2., V_initializer=bp.init.OneInit(-70.))\n", - " B = bp.neurons.LIF(num_B, V_rest=-70., V_reset=-55., V_th=-50., tau=20., R=0.04,\n", - " tau_ref=2., V_initializer=bp.init.OneInit(-70.))\n", - " N = bp.neurons.LIF(num_N, V_rest=-70., V_reset=-55., V_th=-50., tau=20., R=0.04,\n", - " tau_ref=2., V_initializer=bp.init.OneInit(-70.))\n", - " I = bp.neurons.LIF(num_inh, V_rest=-70., V_reset=-55., V_th=-50., tau=10., R=0.05,\n", - " tau_ref=1., V_initializer=bp.init.OneInit(-70.))\n", + " # I neurons/interneurons\n", + " self.I = bp.dyn.LifRef(num_I, tau=10., R=0.05, tau_ref=1., **neu_par)\n", "\n", - " # neurons generating external inputs, I_A and I_B\n", - " IA = PoissonStim(num_A, freq_var=10., t_interval=50., freq_mean=mu0 + mu0 / 100. * coherence)\n", - " IB = PoissonStim(num_B, freq_var=10., t_interval=50., freq_mean=mu0 - mu0 / 100. * coherence)\n", + " # poisson stimulus # 'freqs' as bm.Variable\n", + " self.IA = bp.dyn.PoissonGroup(num_A, freqs=bm.Variable(bm.zeros(1)))\n", + " self.IB = bp.dyn.PoissonGroup(num_B, freqs=bm.Variable(bm.zeros(1)))\n", "\n", " # noise neurons\n", - " self.noise_A = bp.neurons.PoissonGroup(num_A, freqs=poisson_freq)\n", - " self.noise_B = bp.neurons.PoissonGroup(num_B, freqs=poisson_freq)\n", - " self.noise_N = bp.neurons.PoissonGroup(num_N, freqs=poisson_freq)\n", - " self.noise_I = bp.neurons.PoissonGroup(num_inh, freqs=poisson_freq)\n", - "\n", - " # connection from excitatory neurons to others\n", - " self.N2B_AMPA = bp.synapses.Exponential(N, B, bp.conn.All2All(), g_max=g_E2E_AMPA * w_neg, **ampa_par)\n", - " self.N2A_AMPA = bp.synapses.Exponential(N, A, bp.conn.All2All(), g_max=g_E2E_AMPA * w_neg, **ampa_par)\n", - " self.N2N_AMPA = bp.synapses.Exponential(N, N, bp.conn.All2All(), g_max=g_E2E_AMPA, **ampa_par)\n", - " self.N2I_AMPA = bp.synapses.Exponential(N, I, bp.conn.All2All(), g_max=g_E2I_AMPA, **ampa_par)\n", - " self.N2B_NMDA = bp.synapses.NMDA(N, B, bp.conn.All2All(), g_max=g_E2E_NMDA * w_neg, **nmda_par)\n", - " self.N2A_NMDA = bp.synapses.NMDA(N, A, bp.conn.All2All(), g_max=g_E2E_NMDA * w_neg, **nmda_par)\n", - " self.N2N_NMDA = bp.synapses.NMDA(N, N, bp.conn.All2All(), g_max=g_E2E_NMDA, **nmda_par)\n", - " self.N2I_NMDA = bp.synapses.NMDA(N, I, bp.conn.All2All(), g_max=g_E2I_NMDA, **nmda_par)\n", - "\n", - " self.B2B_AMPA = bp.synapses.Exponential(B, B, bp.conn.All2All(), g_max=g_E2E_AMPA * w_pos, **ampa_par)\n", - " self.B2A_AMPA = bp.synapses.Exponential(B, A, bp.conn.All2All(), g_max=g_E2E_AMPA * w_neg, **ampa_par)\n", - " self.B2N_AMPA = bp.synapses.Exponential(B, N, bp.conn.All2All(), g_max=g_E2E_AMPA, **ampa_par)\n", - " self.B2I_AMPA = bp.synapses.Exponential(B, I, bp.conn.All2All(), g_max=g_E2I_AMPA, **ampa_par)\n", - " self.B2B_NMDA = bp.synapses.NMDA(B, B, bp.conn.All2All(), g_max=g_E2E_NMDA * w_pos, **nmda_par)\n", - " self.B2A_NMDA = bp.synapses.NMDA(B, A, bp.conn.All2All(), g_max=g_E2E_NMDA * w_neg, **nmda_par)\n", - " self.B2N_NMDA = bp.synapses.NMDA(B, N, bp.conn.All2All(), g_max=g_E2E_NMDA, **nmda_par)\n", - " self.B2I_NMDA = bp.synapses.NMDA(B, I, bp.conn.All2All(), g_max=g_E2I_NMDA, **nmda_par)\n", - "\n", - " self.A2B_AMPA = bp.synapses.Exponential(A, B, bp.conn.All2All(), g_max=g_E2E_AMPA * w_neg, **ampa_par)\n", - " self.A2A_AMPA = bp.synapses.Exponential(A, A, bp.conn.All2All(), g_max=g_E2E_AMPA * w_pos, **ampa_par)\n", - " self.A2N_AMPA = bp.synapses.Exponential(A, N, bp.conn.All2All(), g_max=g_E2E_AMPA, **ampa_par)\n", - " self.A2I_AMPA = bp.synapses.Exponential(A, I, bp.conn.All2All(), g_max=g_E2I_AMPA, **ampa_par)\n", - " self.A2B_NMDA = bp.synapses.NMDA(A, B, bp.conn.All2All(), g_max=g_E2E_NMDA * w_neg, **nmda_par)\n", - " self.A2A_NMDA = bp.synapses.NMDA(A, A, bp.conn.All2All(), g_max=g_E2E_NMDA * w_pos, **nmda_par)\n", - " self.A2N_NMDA = bp.synapses.NMDA(A, N, bp.conn.All2All(), g_max=g_E2E_NMDA, **nmda_par)\n", - " self.A2I_NMDA = bp.synapses.NMDA(A, I, bp.conn.All2All(), g_max=g_E2I_NMDA, **nmda_par)\n", - "\n", - " # connection from inhibitory neurons to others\n", - " self.I2B = bp.synapses.Exponential(I, B, bp.conn.All2All(), g_max=g_I2E_GABAa, **gaba_par)\n", - " self.I2A = bp.synapses.Exponential(I, A, bp.conn.All2All(), g_max=g_I2E_GABAa, **gaba_par)\n", - " self.I2N = bp.synapses.Exponential(I, N, bp.conn.All2All(), g_max=g_I2E_GABAa, **gaba_par)\n", - " self.I2I = bp.synapses.Exponential(I, I, bp.conn.All2All(), g_max=g_I2I_GABAa, **gaba_par)\n", - "\n", - " # connection from external inputs to selective neuron groups\n", - " self.IA2A = bp.synapses.Exponential(IA, A, bp.conn.One2One(), g_max=g_ext2E_AMPA, **ampa_par)\n", - " self.IB2B = bp.synapses.Exponential(IB, B, bp.conn.One2One(), g_max=g_ext2E_AMPA, **ampa_par)\n", - "\n", - " # connectioni from noise neurons to excitatory and inhibitory neurons\n", - " self.noise2B = bp.synapses.Exponential(self.noise_B, B, bp.conn.One2One(), g_max=g_ext2E_AMPA, **ampa_par)\n", - " self.noise2A = bp.synapses.Exponential(self.noise_A, A, bp.conn.One2One(), g_max=g_ext2E_AMPA, **ampa_par)\n", - " self.noise2N = bp.synapses.Exponential(self.noise_N, N, bp.conn.One2One(), g_max=g_ext2E_AMPA, **ampa_par)\n", - " self.noise2I = bp.synapses.Exponential(self.noise_I, I, bp.conn.One2One(), g_max=g_ext2I_AMPA, **ampa_par)\n", - "\n", - " # add A, B, I, N to the class\n", - " self.A = A\n", - " self.B = B\n", - " self.N = N\n", - " self.I = I\n", - " self.IA = IA\n", - " self.IB = IB" + " self.noise_B = bp.dyn.PoissonGroup(num_B, freqs=poisson_freq)\n", + " self.noise_A = bp.dyn.PoissonGroup(num_A, freqs=poisson_freq)\n", + " self.noise_N = bp.dyn.PoissonGroup(num_N, freqs=poisson_freq)\n", + " self.noise_I = bp.dyn.PoissonGroup(num_I, freqs=poisson_freq)\n", + "\n", + " # define external inputs\n", + " self.IA2A = ExpSyn(self.IA, self.A, 'one2one', None, g_ext2E_AMPA, tau=2., E=0.)\n", + " self.IB2B = ExpSyn(self.IB, self.B, 'one2one', None, g_ext2E_AMPA, tau=2., E=0.)\n", + "\n", + " # define AMPA projections from N\n", + " self.N2B_AMPA = ExpSyn(self.N, self.B, 'all2all', 0.5, g_E2E_AMPA * w_neg, tau=2., E=0.)\n", + " self.N2A_AMPA = ExpSyn(self.N, self.A, 'all2all', 0.5, g_E2E_AMPA * w_neg, tau=2., E=0.)\n", + " self.N2N_AMPA = ExpSyn(self.N, self.N, 'all2all', 0.5, g_E2E_AMPA, tau=2., E=0.)\n", + " self.N2I_AMPA = ExpSyn(self.N, self.I, 'all2all', 0.5, g_E2I_AMPA, tau=2., E=0.)\n", + "\n", + " # define NMDA projections from N\n", + " self.N2B_NMDA = NMDA(self.N, self.B, 'all2all', 0.5, g_E2E_NMDA * w_neg)\n", + " self.N2A_NMDA = NMDA(self.N, self.A, 'all2all', 0.5, g_E2E_NMDA * w_neg)\n", + " self.N2N_NMDA = NMDA(self.N, self.N, 'all2all', 0.5, g_E2E_NMDA)\n", + " self.N2I_NMDA = NMDA(self.N, self.I, 'all2all', 0.5, g_E2I_NMDA)\n", + "\n", + " # define AMPA projections from B\n", + " self.B2B_AMPA = ExpSyn(self.B, self.B, 'all2all', 0.5, g_E2E_AMPA * w_pos, tau=2., E=0.)\n", + " self.B2A_AMPA = ExpSyn(self.B, self.A, 'all2all', 0.5, g_E2E_AMPA * w_neg, tau=2., E=0.)\n", + " self.B2N_AMPA = ExpSyn(self.B, self.N, 'all2all', 0.5, g_E2E_AMPA, tau=2., E=0.)\n", + " self.B2I_AMPA = ExpSyn(self.B, self.I, 'all2all', 0.5, g_E2I_AMPA, tau=2., E=0.)\n", + "\n", + " # define NMDA projections from B\n", + " self.B2B_NMDA = NMDA(self.B, self.B, 'all2all', 0.5, g_E2E_NMDA * w_pos)\n", + " self.B2A_NMDA = NMDA(self.B, self.A, 'all2all', 0.5, g_E2E_NMDA * w_neg)\n", + " self.B2N_NMDA = NMDA(self.B, self.N, 'all2all', 0.5, g_E2E_NMDA)\n", + " self.B2I_NMDA = NMDA(self.B, self.I, 'all2all', 0.5, g_E2I_NMDA)\n", + "\n", + " # define AMPA projections from A\n", + " self.A2B_AMPA = ExpSyn(self.A, self.B, 'all2all', 0.5, g_E2E_AMPA * w_neg, tau=2., E=0.)\n", + " self.A2A_AMPA = ExpSyn(self.A, self.A, 'all2all', 0.5, g_E2E_AMPA * w_pos, tau=2., E=0.)\n", + " self.A2N_AMPA = ExpSyn(self.A, self.N, 'all2all', 0.5, g_E2E_AMPA, tau=2., E=0.)\n", + " self.A2I_AMPA = ExpSyn(self.A, self.I, 'all2all', 0.5, g_E2I_AMPA, tau=2., E=0.)\n", + "\n", + " # define NMDA projections from A\n", + " self.A2B_NMDA = NMDA(self.A, self.B, 'all2all', 0.5, g_E2E_NMDA * w_neg)\n", + " self.A2A_NMDA = NMDA(self.A, self.A, 'all2all', 0.5, g_E2E_NMDA * w_pos)\n", + " self.A2N_NMDA = NMDA(self.A, self.N, 'all2all', 0.5, g_E2E_NMDA)\n", + " self.A2I_NMDA = NMDA(self.A, self.I, 'all2all', 0.5, g_E2I_NMDA)\n", + "\n", + " # define I->E/I conn\n", + " self.I2B = ExpSyn(self.I, self.B, 'all2all', 0.5, g_I2E_GABAa, tau=5., E=-70.)\n", + " self.I2A = ExpSyn(self.I, self.A, 'all2all', 0.5, g_I2E_GABAa, tau=5., E=-70.)\n", + " self.I2N = ExpSyn(self.I, self.N, 'all2all', 0.5, g_I2E_GABAa, tau=5., E=-70.)\n", + " self.I2I = ExpSyn(self.I, self.I, 'all2all', 0.5, g_I2I_GABAa, tau=5., E=-70.)\n", + "\n", + " # define external projections\n", + " self.noise2B = ExpSyn(self.noise_B, self.B, 'one2one', None, g_ext2E_AMPA, tau=2., E=0.)\n", + " self.noise2A = ExpSyn(self.noise_A, self.A, 'one2one', None, g_ext2E_AMPA, tau=2., E=0.)\n", + " self.noise2N = ExpSyn(self.noise_N, self.N, 'one2one', None, g_ext2E_AMPA, tau=2., E=0.)\n", + " self.noise2I = ExpSyn(self.noise_I, self.I, 'one2one', None, g_ext2I_AMPA, tau=2., E=0.)" ] }, { @@ -619,18 +825,42 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, + "outputs": [], + "source": [ + "tool = Tool()\n", + "net = DecisionMakingNet()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-09-10T08:44:53.421244Z", + "start_time": "2023-09-10T08:44:52.305456900Z" + } + }, + "id": "d942345aa2d6efe1" + }, + { + "cell_type": "code", + "execution_count": 18, "id": "47ebe27c", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:27.196569Z", - "end_time": "2023-04-15T13:35:27.437201Z" + "end_time": "2023-09-10T08:44:53.432297500Z", + "start_time": "2023-09-10T08:44:53.420182900Z" } }, "outputs": [], "source": [ - "net = DecisionMaking(scale=1., coherence=25.6, mu0=40.)\n", - "runner = bp.DSRunner(net, monitors=['A.spike', 'B.spike', 'IA.freq', 'IB.freq'])" + "mu0 = 40.\n", + "coherence = 25.6\n", + "IA_freqs = tool.generate_freqs(mu0 + mu0 / 100. * coherence)\n", + "IB_freqs = tool.generate_freqs(mu0 - mu0 / 100. * coherence)\n", + "\n", + "def give_input():\n", + " i = bp.share['i']\n", + " net.IA.freqs[0] = IA_freqs[i]\n", + " net.IB.freqs[0] = IB_freqs[i]" ] }, { @@ -643,12 +873,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "id": "96e97756", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:27.437201Z", - "end_time": "2023-04-15T13:35:33.737713Z" + "end_time": "2023-09-10T08:44:55.965045500Z", + "start_time": "2023-09-10T08:44:53.432297500Z" } }, "outputs": [ @@ -658,7 +888,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "76497ed456fc4694af96dca12be81c51" + "model_id": "245bb4bf2bd74515aa8adb212532a887" } }, "metadata": {}, @@ -666,7 +896,8 @@ } ], "source": [ - "runner.run(total_period)" + "runner = bp.DSRunner(net, inputs=give_input, monitors=['A.spike', 'B.spike'])\n", + "runner.run(tool.total_period)" ] }, { @@ -679,67 +910,27 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "id": "0d57a44d", "metadata": { "scrolled": false, "ExecuteTime": { - "start_time": "2023-04-15T13:35:33.737713Z", - "end_time": "2023-04-15T13:35:34.134822Z" + "end_time": "2023-09-10T08:44:56.518576300Z", + "start_time": "2023-09-10T08:44:55.966045300Z" } }, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "fig, gs = plt.subplots(4, 1, figsize=(10, 12), sharex='all')\n", - "t_start = 0.\n", - "\n", - "# the raster plot of A\n", - "fig.add_subplot(gs[0])\n", - "bp.visualize.raster_plot(runner.mon.ts, runner.mon['A.spike'], markersize=1)\n", - "plt.title(\"Spiking activity of group A\")\n", - "plt.ylabel(\"Neuron Index\")\n", - "\n", - "# the raster plot of A\n", - "fig.add_subplot(gs[1])\n", - "bp.visualize.raster_plot(runner.mon.ts, runner.mon['B.spike'], markersize=1)\n", - "plt.title(\"Spiking activity of group B\")\n", - "plt.ylabel(\"Neuron Index\")\n", - "\n", - "# the firing rate of A and B\n", - "fig.add_subplot(gs[2])\n", - "rateA = bp.measure.firing_rate(runner.mon['A.spike'], width=10.)\n", - "rateB = bp.measure.firing_rate(runner.mon['B.spike'], width=10.)\n", - "plt.plot(runner.mon.ts, rateA, label=\"Group A\")\n", - "plt.plot(runner.mon.ts, rateB, label=\"Group B\")\n", - "plt.ylabel('Firing rate [Hz]')\n", - "plt.title(\"Population activity\")\n", - "plt.legend()\n", - "\n", - "# the external stimuli\n", - "fig.add_subplot(gs[3])\n", - "plt.plot(runner.mon.ts, runner.mon['IA.freq'], label=\"group A\")\n", - "plt.plot(runner.mon.ts, runner.mon['IB.freq'], label=\"group B\")\n", - "plt.title(\"Input activity\")\n", - "plt.ylabel(\"Firing rate [Hz]\")\n", - "plt.legend()\n", - "\n", - "for i in range(4):\n", - " gs[i].axvline(pre_stimulus_period, linestyle='dashed', color=u'#444444')\n", - " gs[i].axvline(pre_stimulus_period + stimulus_period, linestyle='dashed', color=u'#444444')\n", - "\n", - "plt.xlim(t_start, total_period + 1)\n", - "plt.xlabel(\"Time [ms]\")\n", - "plt.tight_layout()\n", - "plt.show()" + "tool.visualize_results(runner.mon, IA_freqs, IB_freqs)" ] }, { @@ -784,12 +975,12 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 21, "id": "e141c3a4", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:34.134822Z", - "end_time": "2023-04-15T13:35:34.901202Z" + "end_time": "2023-09-10T08:44:56.843470200Z", + "start_time": "2023-09-10T08:44:56.502834100Z" } }, "outputs": [ @@ -799,7 +990,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "09d66952ca0d4dada42a9dfd80ce688f" + "model_id": "ccf6dc60ead1448baccda739beb34933" } }, "metadata": {}, @@ -808,19 +999,19 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "wc = bp.rates.WilsonCowanModel(2,\n", - " wEE=16., wIE=15., wEI=12., wII=3.,\n", - " E_a=1.5, I_a=1.5, E_theta=3., I_theta=3.,\n", - " method='exp_euler_auto',\n", - " x_initializer=bm.asarray([-0.2, 1.]),\n", - " y_initializer=bm.asarray([0.0, 1.]))\n", + "wc = bp.dyn.WilsonCowanModel(2,\n", + " wEE=16., wIE=15., wEI=12., wII=3.,\n", + " E_a=1.5, I_a=1.5, E_theta=3., I_theta=3.,\n", + " method='exp_euler_auto',\n", + " x_initializer=bm.asarray([-0.2, 1.]),\n", + " y_initializer=bm.asarray([0.0, 1.]))\n", "\n", "runner = bp.DSRunner(wc, monitors=['x', 'y'], inputs=['input', -0.5])\n", "runner.run(10.)\n", @@ -858,12 +1049,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "id": "ad292779", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:35:34.476580Z", - "end_time": "2023-04-15T13:36:04.420909Z" + "end_time": "2023-09-10T08:45:49.867445200Z", + "start_time": "2023-09-10T08:44:56.843470200Z" } }, "outputs": [ @@ -876,14 +1067,14 @@ "I am trying to find fixed points by optimization ...\n", "\tThere are 40000 candidates\n", "I am trying to filter out duplicate fixed points ...\n", - "\tFound 579 fixed points.\n", + "\tFound 400 fixed points.\n", "I am plotting the limit cycle ...\n" ] }, { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAGwCAYAAACq12GxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZd0lEQVR4nO3deVxUVeMG8OeyDSAyKDuKoIFKbqCUorkn7qmVS5pLpmVq/szMpTIxe1/b89VyK5cstzI1K1uowA0sF3ADlxRFBCQUBmKHOb8/aEYGZmBYhmGY5/v5zGeYe8+999y5vs3znnPuuZIQQoCIiIjITFkYuwJERERExsQwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKxZGbsCDZ1SqURycjKaNm0KSZKMXR0iIiLSgxAC2dnZ8PLygoVF5W0/DENVSE5Ohre3t7GrQURERDVw69YttGzZstIyDENVaNq0KYDSL9PR0dHItSEiIiJ9ZGVlwdvbW/07XhmGoSqousYcHR0ZhoiIiEyMPkNcOICaiIiIzBrDEBEREZk1kwpDR44cwciRI+Hl5QVJknDgwIEqtzl8+DC6desGW1tbtGnTBhs2bDB8RYmIiMhkmNSYoZycHHTp0gXPPPMMnnjiiSrLJyQkYNiwYZg5cya+/PJLHD9+HLNnz4arq6te2xMRkSalUonCwkJjV4MI1tbWsLS0rJN9mVQYGjp0KIYOHap3+Q0bNqBVq1ZYvXo1ACAgIACnTp3C+++/zzBERFRNhYWFSEhIgFKpNHZViAAATk5O8PDwqPU8gCYVhqorOjoaoaGhGssGDx6MzZs3o6ioCNbW1hW2KSgoQEFBgfpzVlaWwetJRNTQCSGQkpICS0tLeHt7VzmJHZEhCSGQm5uLtLQ0AICnp2et9teow1Bqairc3d01lrm7u6O4uBjp6elav7xVq1ZhxYoV9VVFIiKTUFxcjNzcXHh5ecHe3t7Y1SGCnZ0dACAtLQ1ubm616jJr9NG+fNOZEELrcpWlS5dCoVCoX7du3TJ4HYmIGrqSkhIAgI2NjZFrQnSfKpgXFRXVaj+NumXIw8MDqampGsvS0tJgZWUFZ2dnrdvIZDLIZLL6qB4RkcnhMxqpIamrf4+NumUoJCQE4eHhGst++eUXBAcHax0vRERERObHpMLQP//8g9jYWMTGxgIovXU+NjYWiYmJAEq7uKZMmaIuP2vWLNy8eRMLFixAfHw8tmzZgs2bN2PhwoXGqD4RERE1QCYVhk6dOoWgoCAEBQUBABYsWICgoCC88cYbAICUlBR1MAKA1q1b49ChQ4iMjERgYCBWrlyJNWvW8LZ6IiKqsbCwMAQGBlZaZtq0aRg9enStjpObm4snnngCjo6OkCQJmZmZtdof6WZSY4b69eunHgCtzbZt2yos69u3L86cOWPAWhERkb4y7+QiPioF2Xfz0NTZDgE9PeHkbpy706ZNm4bMzEy9nmZgDJ9//jmOHj2KqKgouLi4QC6XG7tKjZZJhSEiIjJd8VHJiPjiEiABEAAkIOaXm+g/OQABPWs3T0xjdO3aNQQEBKBjx47GrkqjZ1LdZEREZJoy7+Qi4otLEAIQSmi8R3wRj8y0XIMcd+/evejUqRPs7Ozg7OyMRx99FDk5OQgLC8Pnn3+Ob7/9FpIkQZIkREZGAgAWL16Mtm3bwt7eHm3atMGyZcu03rq9ceNGeHt7w97eHmPHjq20G0sIgXfffRdt2rSBnZ0dunTpgr179+os369fP3zwwQc4cuQIJElCv379AAAZGRmYMmUKmjVrBnt7ewwdOhRXr17V2Pb48ePo27cv7O3t0axZMwwePBgZGRkAAF9fX/VTGVQCAwMRFham/hwWFoZWrVpBJpPBy8sL8+bN0/0FNxJsGSIiIoOLj0q53yJUngTEH09ByJgH6vSYKSkpeOqpp/Duu+9izJgxyM7OxtGjRyGEwMKFCxEfH4+srCxs3boVANC8eXMAQNOmTbFt2zZ4eXnh/PnzmDlzJpo2bYpFixap9/3XX3/hq6++wnfffYesrCw8++yzmDNnDnbs2KG1Lq+//jr27duH9evXw9/fH0eOHMHTTz8NV1dX9O3bt0L5ffv2YcmSJbhw4QL27dunnt9p2rRpuHr1Kg4ePAhHR0csXrwYw4YNQ1xcHKytrREbG4uBAwdi+vTpWLNmDaysrBAREaGeJ6oqe/fuxUcffYTdu3ejQ4cOSE1NxdmzZ6v1vZsihiEiIjK47Lt52oMQAIh/19exlJQUFBcX4/HHH4ePjw8AoFOnTur1dnZ2KCgogIeHh8Z2r7/+uvpvX19fvPzyy9izZ49GGMrPz8fnn3+Oli1bAgDWrl2L4cOH44MPPqiwv5ycHHz44Yf4/fffERISAgBo06YNjh07ho0bN2oNQ82bN4e9vT1sbGzU+1OFoOPHj6Nnz54AgB07dsDb2xsHDhzA2LFj8e677yI4OBjr1q1T76tDhw56f2eJiYnw8PDAo48+Cmtra7Rq1QoPP/yw3tubKnaTERGRwTV1tittGdJG+nd9HevSpQsGDhyITp06YezYsfj000/V3UWV2bt3Lx555BF4eHjAwcEBy5Yt07hTGQBatWqlDkJA6bx2SqUSly9frrC/uLg45OfnY9CgQXBwcFC/tm/fjmvXrul9PvHx8bCyskL37t3Vy5ydndGuXTvEx8cDgLplqKbGjh2LvLw8tGnTBjNnzsT+/ftRXFxc4/2ZCoYhIiIyuICenpW2DAX0qvsB1JaWlggPD8ePP/6IBx98EGvXrkW7du2QkJCgc5sTJ05gwoQJGDp0KL7//nvExMTgtddeQ2FhYaXHUs2ErG1GZKVSCQD44Ycf1HPlxcbGIi4urtJxQ+XpuptaCKE+rup5XbpYWFhU2E/Z8VDe3t64fPkyPvnkE9jZ2WH27Nno06dPrR930dAxDBERkcE5uduj/+QASBIgWUj/vgOSBPSfHAAnN8PcXi9JEnr16oUVK1YgJiYGNjY22L9/P4DS56yVH0tz/Phx+Pj44LXXXkNwcDD8/f1x8+bNCvtNTExEcnKy+nN0dDQsLCzQtm3bCmUffPBByGQyJCYmws/PT+Pl7e2t97k8+OCDKC4uxh9//KFedvfuXVy5cgUBAQEAgM6dO+O3337TuQ9XV1ekpKSoP2dlZVUIh3Z2dnjsscewZs0aREZGIjo6GufPn9e7nqaIY4aIiKheBPT0hKefHPHHy8wz1MvTYEHojz/+wG+//YbQ0FC4ubnhjz/+wN9//60ODr6+vvj5559x+fJlODs7Qy6Xw8/PD4mJidi9ezceeugh/PDDD+rwVJatrS2mTp2K999/H1lZWZg3bx7GjRtXYbwQUDoge+HChXjppZegVCrxyCOPICsrC1FRUXBwcMDUqVP1Oh9/f3+MGjUKM2fOxMaNG9G0aVMsWbIELVq0wKhRowCUPomhU6dOmD17NmbNmgUbGxtERERg7NixcHFxwYABA7Bt2zaMHDkSzZo1w7JlyzSe9r5t2zaUlJSge/fusLe3xxdffAE7Ozv1mKtGS1ClFAqFACAUCoWxq0JEZDR5eXkiLi5O5OXlGbsqeouLixODBw8Wrq6uQiaTibZt24q1a9eq16elpYlBgwYJBwcHAUBEREQIIYR45ZVXhLOzs3BwcBDjx48XH330kZDL5ertli9fLrp06SLWrVsnvLy8hK2trXj88cfFvXv31GWmTp0qRo0apf6sVCrF//73P9GuXTthbW0tXF1dxeDBg8Xhw4d11v///u//RN++fTWW3bt3T0yePFnI5XJhZ2cnBg8eLK5cuaJRJjIyUvTs2VPIZDLh5OQkBg8eLDIyMoQQpb9p48aNE46OjsLb21ts27ZNdOnSRSxfvlwIIcT+/ftF9+7dhaOjo2jSpIno0aOH+PXXX/X/0utZZf8uq/P7LQlRyZTOhKysLMjlcigUCjg6Ohq7OkRERpGfn4+EhAS0bt0atra2xq4OEYDK/11W5/ebY4aIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIiMQJIkHDhwQOf6GzduQJIkxMbG1uo4Bw4cgJ+fHywtLTF//vxa7auxYhgiIiKqoboKLIb0/PPP48knn8StW7ewcuVKY1enQeKDWomIqN4Upech91QqijMKYNVMBvtgD1i72Bm7Wo3WP//8g7S0NAwePBheXl7Grk6DxZYhIiKqFzmnUnHng1PIPpKEvHN/I/tIEu58cAo5p+4Y7Ji+vr5YvXq1xrLAwECEhYWpP0uShM8++wxjxoyBvb09/P39cfDgQfX6jIwMTJo0Ca6urrCzs4O/vz+2bt0KAGjdujUAICgoCJIkoV+/fgCAkydPYtCgQXBxcYFcLkffvn1x5syZCvVLSUnB0KFDYWdnh9atW+Prr7+u9Hzi4uIwbNgwODg4wN3dHZMnT0Z6errWspGRkWjatCkAYMCAAZAkCZGRkQCAb775Bh06dIBMJoOvry8++OADjW0LCgqwaNEieHt7QyaTwd/fH5s3bwZQ+mR7JycnjfIHDhyAJEnqz2fPnkX//v3RtGlTODo6olu3bjh16lSl52ZMDENERGRwRel5yPjmKiAAKKHxnvHNFRSn5xm1fitWrMC4ceNw7tw5DBs2DJMmTcK9e/cAAMuWLUNcXBx+/PFHxMfHY/369XBxcQEA/PnnnwCAX3/9FSkpKdi3bx8AIDs7G1OnTsXRo0dx4sQJ+Pv7Y9iwYcjOztY47rJly/DEE0/g7NmzePrpp/HUU08hPj5eax1TUlLQt29fBAYG4tSpU/jpp59w584djBs3Tmv5nj174vLlywBKw09KSgp69uyJ06dPY9y4cZgwYQLOnz+PsLAwLFu2DNu2bVNvO2XKFOzevRtr1qxBfHw8NmzYAAcHB72/z0mTJqFly5Y4efIkTp8+jSVLlsDa2lrv7esbu8mIiMjgck+lAhJKQ1B5UmmrkXxI6/qultq0adPw1FNPAQD++9//Yu3atfjzzz8xZMgQJCYmIigoCMHBwQBKW5tUXF1dAQDOzs7w8PBQLx8wYIDG/jdu3IhmzZrh8OHDGDFihHr52LFjMWPGDADAypUrER4ejrVr12LdunUV6rh+/Xp07doV//3vf9XLtmzZAm9vb1y5cgVt27bVKG9jYwM3NzcAQPPmzdX1+/DDDzFw4EAsW7YMANC2bVvExcXhvffew7Rp03DlyhV89dVXCA8Px6OPPgoAaNOmjb5fJQAgMTERr7zyCtq3bw8A8Pf3r9b29Y0tQ0REZHDFGQXagxAAiH/XG1Hnzp3Vfzdp0gRNmzZFWloaAOCFF17A7t27ERgYiEWLFiEqKqrK/aWlpWHWrFlo27Yt5HI55HI5/vnnHyQmJmqUCwkJqfBZV8vQ6dOnERERAQcHB/VLFTauXbum97nGx8ejV69eGst69eqFq1evoqSkBLGxsbC0tETfvn313md5CxYswIwZM/Doo4/i7bffrlb9jIFhiIiIDM6qmay0ZUgb6d/1BmBhYQEhNFNYUVFRhXLlu3AkSYJSqQQADB06FDdv3sT8+fORnJyMgQMHYuHChZUed9q0aTh9+jRWr16NqKgoxMbGwtnZGYWFhVXWuezYm7KUSiVGjhyJ2NhYjdfVq1fRp0+fKverIoSocIyy35GdXeUD2vX5TsPCwnDx4kUMHz4cv//+Ox588EHs379f7zrWN4YhIiIyOPtgj0pbhpoEe+hYWTuurq5ISUlRf87KykJCQkKN9jNt2jR8+eWXWL16NTZt2gSgtCsKAEpKSjTKHz16FPPmzcOwYcPUA5W1DXQ+ceJEhc+q1p7yunbtiosXL8LX1xd+fn4aryZNmuh9Lg8++CCOHTumsSwqKgpt27aFpaUlOnXqBKVSicOHD2vd3tXVFdnZ2cjJyVEv0za1QNu2bfHSSy/hl19+weOPP64edN4QMQwREZHBWbvYodkTbUtbhyyg8d7sibawMtDt9QMGDMAXX3yBo0eP4sKFC5g6dSosLS2rtY833ngD3377Lf766y9cvHgR33//PQICAgAAbm5usLOzUw9mVigUAAA/Pz988cUXiI+Pxx9//IFJkyZpbXH5+uuvsWXLFly5cgXLly/Hn3/+iblz52qtx5w5c3Dv3j089dRT+PPPP3H9+nX88ssvmD59eoUwVpmXX34Zv/32G1auXIkrV67g888/x8cff6xu7fL19cXUqVMxffp0HDhwAAkJCYiMjMRXX30FAOjevTvs7e3x6quv4q+//sLOnTs1Bl/n5eVh7ty5iIyMxM2bN3H8+HGcPHlS/Z01SIIqpVAoBAChUCiMXRUiIqPJy8sTcXFxIi8vr1b7Kfo7V2T+eF2k74wXmT9eF0V/59ZRDbVTKBRi3LhxwtHRUXh7e4tt27aJLl26iOXLl6vLABD79+/X2E4ul4utW7cKIYRYuXKlCAgIEHZ2dqJ58+Zi1KhR4vr16+qyn376qfD29hYWFhaib9++Qgghzpw5I4KDg4VMJhP+/v7i66+/Fj4+PuKjjz7SOO4nn3wiBg0aJGQymfDx8RG7du1Sr09ISBAARExMjHrZlStXxJgxY4STk5Ows7MT7du3F/PnzxdKpVLr+WdkZAgAIiIiQmP53r17xYMPPiisra1Fq1atxHvvvaexPi8vT7z00kvC09NT2NjYCD8/P7Flyxb1+v379ws/Pz9ha2srRowYITZt2iRUkaKgoEBMmDBBeHt7CxsbG+Hl5SXmzp1b63872lT277I6v9+SEEJXwyWhtElVLpdDoVDA0dHR2NUhIjKK/Px8JCQkoHXr1rC1tTV2dYgAVP7vsjq/3+wmIyIiIrPGMERERERmjWGIiIiIzBrDEBEREZk1hiEiIiIyawxDREREZNYYhoiIiMisMQwRERGRWWMYIiIiIrPGMERERI1Wv379MH/+fPVnX19frF69ulb7DAsLQ2BgYK32UdciIyMhSRIyMzNrva8+ffpg586dta9ULS1cuBDz5s2rl2MxDBERkdk4efIknnvuuVrtY+HChfjtt9/Un6dNm4bRo0fXsmYNw/fff4/U1FRMmDDB2FXBokWLsHXrViQkJBj8WAxDRERUr84lZeKpTSdwLimz3o/t6uoKe3v7Wu3DwcEBzs7OdVSjhmXNmjV45plnYGFh/Hjg5uaG0NBQbNiwweDHMv7ZEhGRWdl35jair9/FvjO36/3Y5bvJJEnCxo0bMWLECNjb2yMgIADR0dH466+/0K9fPzRp0gQhISG4du2aepuy3WRhYWH4/PPP8e2330KSJEiShMjISK3HViqVeOedd+Dn5weZTIZWrVrhP//5DwBgwIABmDt3rkb5u3fvQiaT4ffffwcAFBQUYNGiRfD29oZMJoO/vz82b96s81yjoqLQp08f2NnZwdvbG/PmzUNOTo7O8unp6fj111/x2GOPaSyvyXd07do1jBo1Cu7u7nBwcMBDDz2EX3/9Vb3+0qVLsLe31+iO27dvH2xtbXH+/Hn1ssceewy7du3SWee6wjBEREQGl5SRi/NJCly4rcB3Z5MBAN+dTcaF2wqcT1IgKSPXaHVbuXIlpkyZgtjYWLRv3x4TJ07E888/j6VLl+LUqVMAUCGoqCxcuBDjxo3DkCFDkJKSgpSUFPTs2VNr2aVLl+Kdd97BsmXLEBcXh507d8Ld3R0AMGPGDOzcuRMFBQXq8jt27ICXlxf69+8PAJgyZQp2796NNWvWID4+Hhs2bICDg4PWY50/fx6DBw/G448/jnPnzmHPnj04duyYzvMAgGPHjqnDTm2/o3/++QfDhg3Dr7/+ipiYGAwePBgjR45EYmIiAKB9+/Z4//33MXv2bNy8eRPJycmYOXMm3n77bXTq1Em9n4cffhi3bt3CzZs3dda7TgiqlEKhEACEQqEwdlWIiIwmLy9PxMXFiby8vBpt77P4e/XLt9y76mUIffv2Ff/3f/93vx4+PuKjjz5SfwYgXn/9dfXn6OhoAUBs3rxZvWzXrl3C1tZW/Xn58uWiS5cu6s9Tp04Vo0aNqrQeWVlZQiaTiU8//VTr+vz8fNG8eXOxZ88e9bLAwEARFhYmhBDi8uXLAoAIDw/Xun1ERIQAIDIyMoQQQkyePFk899xzGmWOHj0qLCwsdF7Djz76SLRp06bC8pp8R9o8+OCDYu3atRrLhg8fLnr37i0GDhwoBg0aJJRKpcZ61W9wZGSk1n1W9u+yOr/fbBkiIiKDWz0+EFYWEgBA/LtM9W5lIWH1+EBjVAsA0LlzZ/Xfqpaasq0T7u7uyM/PR1ZWVo2PER8fj4KCAgwcOFDreplMhqeffhpbtmwBAMTGxuLs2bOYNm2a+rOlpSX69u2r1/FOnz6Nbdu2wcHBQf0aPHgwlEqlzgHJeXl5sLW11bquut9RTk4OFi1ahAcffBBOTk5wcHDApUuX1C1DKlu2bMG5c+dw5swZbNu2DZIkaay3s7MDAOTmGrbl0MqgeyciIgIwOqgF/NwcMGLtsQrrDszphY4t5EaoVSlra2v136ofY23LlEpljY+h+lGvzIwZMxAYGIikpCRs2bIFAwcOhI+Pj97bl6VUKvH8889rvTW9VatWWrdxcXFBRkaG1nXV/Y5eeeUV/Pzzz3j//ffh5+cHOzs7PPnkkygsLNTY79mzZ5GTkwMLCwukpqbCy8tLY/29e/cAlA58NySGISIiqleSBAhx/93U2djYoKSkpNIy/v7+sLOzw2+//YYZM2ZoLdOpUycEBwfj008/xc6dO7F27VqNdUqlEocPH8ajjz5aZZ26du2Kixcvws/PT+/zCAoKQmpqKjIyMtCsWTO9t9Pm6NGjmDZtGsaMGQOgdAzRjRs3NMrcu3cP06ZNw2uvvYbU1FRMmjQJZ86c0Qh+Fy5cgLW1NTp06FCr+lTF5LrJ1q1bh9atW8PW1hbdunXD0aNHKy2/Y8cOdOnSBfb29vD09MQzzzyDu3fv1lNtiYhIxdnBBq4OMnRqIcd/xnREpxZyuDrI4OxgY+yq1Yqvry/OnTuHy5cvIz09HUVFRRXK2NraYvHixVi0aBG2b9+Oa9eu4cSJExXuBpsxYwbefvttlJSUqIOE6hhTp07F9OnTceDAASQkJCAyMhJfffWV1jotXrwY0dHRmDNnDmJjY3H16lUcPHgQL774os7zCAoKgqurK44fP17Db+I+Pz8/7Nu3T93dN3HixAota7NmzYK3tzdef/11fPjhhxBCYOHChRpljh49it69e1e7Zay6TCoM7dmzB/Pnz8drr72GmJgY9O7dG0OHDq3QB6ly7NgxTJkyBc8++ywuXryIr7/+GidPntSZyomIyHA85XY4tqQ/vp3TC5O6++DbOb1wbEl/eMoN+0NnaDNnzkS7du0QHBxcaZhYtmwZXn75ZbzxxhsICAjA+PHjkZaWplHmqaeegpWVFSZOnFhh/M769evx5JNPYvbs2Wjfvj1mzpyp81b5zp074/Dhw7h69Sp69+6NoKAgLFu2DJ6enjrPw9LSEtOnT8eOHTuq+Q1U9NFHH6FZs2bo2bMnRo4cicGDB6Nr167q9du3b8ehQ4fwxRdfwMrKCvb29tixYwc+++wzHDp0SF1u165dmDlzZq3rUxVJCNNppOzevTu6du2K9evXq5cFBARg9OjRWLVqVYXy77//PtavX68x98HatWvx7rvv4tatW3odMysrC3K5HAqFAo6OjrU/CSIiE5Sfn4+EhAR1yzwZxq1bt+Dr64uTJ09qhIf6cufOHXTo0AGnT59Wj1cylh9++AGvvPIKzp07Bysr7aN6Kvt3WZ3fb5NpGSosLMTp06cRGhqqsTw0NBRRUVFat+nZsyeSkpJw6NAhCCFw584d7N27F8OHD9d5nIKCAmRlZWm8iIiIDKmoqAiJiYlYvHgxevToYZQgBJTeFbZ582adPS71KScnB1u3btUZhOqSyQygTk9PR0lJifqWPhV3d3ekpqZq3aZnz57YsWMHxo8fj/z8fBQXF+Oxxx7TGJRW3qpVq7BixYo6rTsREVFljh8/jv79+6Nt27bYu3evUesyatQoox5fZdy4cfV2LJNpGVIpPweBEKLCMpW4uDjMmzcPb7zxBk6fPo2ffvoJCQkJmDVrls79L126FAqFQv3StzuNiIiopvr16wchBC5fvqwxfw/VD5NpGXJxcYGlpWWFVqC0tLQKrUUqq1atQq9evfDKK68AKB1Q1qRJE/Tu3RtvvfWW1oFkMpkMMpms7k+AiIiIGiSTaRmysbFBt27dEB4errE8PDxc53NgcnNzKzx519LSEkBpixIRERGRyYQhAFiwYAE+++wzbNmyBfHx8XjppZeQmJio7vZaunQppkyZoi4/cuRI7Nu3D+vXr8f169dx/PhxzJs3Dw8//HCFWS6JiIjIPJlMNxkAjB8/Hnfv3sWbb76JlJQUdOzYEYcOHVLf/peSkqIxAn7atGnIzs7Gxx9/jJdffhlOTk4YMGAA3nnnHWOdAhERETUwJjXPkDFwniEiIs4zRA2T2c0zRERERGQIDENERNRo9evXD/Pnz1d/9vX1xerVq2u1z7CwMAQGBtZqH3UtMjISkiQhMzOz1vvq06cPdu7cWat91OQ7euihh7Bv375aHbemGIaIiMhsnDx5Es8991yt9rFw4UL89ttv6s/Tpk3D6NGja1mzhuH7779HamoqJkyYUKv9lP+O9LFs2TIsWbKkwgNd6wPDEBER1a/bZ4BtI0rf65mrqyvs7e1rtQ8HBwc4OzvXUY0aljVr1uCZZ56pMC1NddXkOxo+fDgUCgV+/vnnWh27JhiGiIiofp3dDdw4CpzbU++HLt9NJkkSNm7ciBEjRsDe3h4BAQGIjo7GX3/9hX79+qFJkyYICQnReOB32S6gsLAwfP755/j2228hSRIkSUJkZKTWYyuVSrzzzjvw8/ODTCZDq1at8J///AcAMGDAAMydO1ej/N27dyGTyfD7778DKH125qJFi+Dt7Q2ZTAZ/f39s3rxZ57lGRUWhT58+sLOzg7e3N+bNm6fzKfdA6WOvfv31Vzz22GMay2v7HQH3W8/ef/99eHp6wtnZGXPmzEFRUZG6jKWlJYYNG4Zdu3bprKOhMAwREZHhZSYCyTFAcixw8d9xIRe+Kf2cHFO63khWrlyJKVOmIDY2Fu3bt8fEiRPx/PPPY+nSpTh16hQAVAgqKgsXLsS4ceMwZMgQpKSkICUlRedEwEuXLsU777yDZcuWIS4uDjt37lQ/QWHGjBnYuXMnCgoK1OV37NgBLy8v9O/fHwAwZcoU7N69G2vWrEF8fDw2bNgABwcHrcc6f/48Bg8ejMcffxznzp3Dnj17cOzYMZ3nAQDHjh1Th526/I5UIiIicO3aNURERODzzz/Htm3bsG3bNo0yDz/8MI4ePVrpfgzBpOYZIiIiE7W67PO2/n2eZE46sKnv/cVhinqtksozzzyjfijo4sWLERISgmXLlmHw4MEAgP/7v//DM888o3VbBwcH2NnZoaCgAB4eHjqPkZ2djf/973/4+OOPMXXqVADAAw88gEceeQQA8MQTT+DFF1/Et99+q67L1q1bMW3aNEiShCtXruCrr75CeHg4Hn30UQBAmzZtdB7vvffew8SJE9WDx/39/bFmzRr07dsX69ev1zo9wo0bN+Du7q61i6w235FKs2bN8PHHH8PS0hLt27fH8OHD8dtvv2HmzJnqMi1atEBiYiKUSmWtu+qqgy1DRERkeI9/Clio/v+30Hy3sCpdbySdO3dW/61qqSn7sFR3d3fk5+cjKyurxseIj49HQUEBBg4cqHW9TCbD008/jS1btgAAYmNjcfbsWUybNk392dLSEn379tW6fXmnT5/Gtm3b4ODgoH4NHjwYSqUSCQkJWrfJy8vTOYdUXXxHHTp0UD8SCwA8PT2RlpamUcbOzg5KpVKjhaw+sGWIiIgMr/M4wKWtZkuQyozfAK/Aeq+SirW1tfpvSZJ0LqvNXU52dnZVlpkxYwYCAwORlJSELVu2YODAgeonLOizfVlKpRLPP/885s2bV2Fdq1attG7j4uKCjIwMrevq4jsqW161Tfny9+7dg729fbXPt7bYMkRERPXMoty7abOxsUFJSUmlZfz9/WFnZ1fp7eadOnVCcHAwPv30U+zcuRPTp0/XWKdUKnH48GG96tS1a1dcvHgRfn5+FV42NjZatwkKCkJqaqrOQFQfLly4gK5du9b7cRvHv0QiImr4mrgCDm6AVxdgxEel7w5upctNmK+vL86dO4fLly8jPT1d4w4pFVtbWyxevBiLFi3C9u3bce3aNZw4caLC3WAzZszA22+/jZKSEowZM0bjGFOnTsX06dNx4MABJCQkIDIyEl999ZXWOi1evBjR0dGYM2cOYmNjcfXqVRw8eBAvvviizvMICgqCq6srjh8/XsNvovaOHj2K0NDQej8uwxAREdUPeQtg/gVgZgQQPL30ff6F0uUmbObMmWjXrh2Cg4MrDRPLli3Dyy+/jDfeeAMBAQEYP358hTEzTz31FKysrDBx4sQK43fWr1+PJ598ErNnz0b79u0xc+ZMnbfKd+7cGYcPH8bVq1fRu3dvBAUFYdmyZfD09NR5HpaWlpg+fTp27NhRzW+gbty+fRtRUVFVDsQ2BD6otQp8UCsRER/UWl9u3boFX19fnDx50ijdRXfu3EGHDh1w+vRp9Xil+vLKK69AoVBg06ZNem/DB7USERE1EkVFRUhMTMTixYvRo0cPowQhoPSusM2bNyMxsf7nfXJzc8PKlSvr/bgA7yYjIiIyuuPHj6N///5o27Yt9u7da9S6jBo1yijHfeWVV4xyXIBhiIiIyOj69esHjloxHnaTERERkVljGCIiIr2x9YIakrr698gwREREVVI9RqGwsNDINSG6Lzc3F0DF2a2ri2OGiIioSlZWVrC3t8fff/8Na2vren2IJlF5Qgjk5uYiLS0NTk5OGs88qwmGISIiqpIkSfD09ERCQgJu3rxp7OoQAQCcnJzg4eFR6/0wDBERkV5sbGzg7+/PrjJqEKytrWvdIqTCMERERHqzsLDgDNTU6LDTl4iIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMyayYWhdevWoXXr1rC1tUW3bt1w9OjRSssXFBTgtddeg4+PD2QyGR544AFs2bKlnmpLREREDZ2VsStQHXv27MH8+fOxbt069OrVCxs3bsTQoUMRFxeHVq1aad1m3LhxuHPnDjZv3gw/Pz+kpaWhuLi4nmtOREREDZUkhBDGroS+unfvjq5du2L9+vXqZQEBARg9ejRWrVpVofxPP/2ECRMm4Pr162jevLlexygoKEBBQYH6c1ZWFry9vaFQKODo6Fj7kyAiIiKDy8rKglwu1+v322S6yQoLC3H69GmEhoZqLA8NDUVUVJTWbQ4ePIjg4GC8++67aNGiBdq2bYuFCxciLy9P53FWrVoFuVyufnl7e9fpeRAREVHDYjLdZOnp6SgpKYG7u7vGcnd3d6Smpmrd5vr16zh27BhsbW2xf/9+pKenY/bs2bh3757OcUNLly7FggUL1J9VLUNERETUOJlMGFKRJEnjsxCiwjIVpVIJSZKwY8cOyOVyAMCHH36IJ598Ep988gns7OwqbCOTySCTyeq+4kRERNQgmUw3mYuLCywtLSu0AqWlpVVoLVLx9PREixYt1EEIKB1jJIRAUlKSQetLREREpsFkwpCNjQ26deuG8PBwjeXh4eHo2bOn1m169eqF5ORk/PPPP+plV65cgYWFBVq2bGnQ+hIREZFpMJkwBAALFizAZ599hi1btiA+Ph4vvfQSEhMTMWvWLACl432mTJmiLj9x4kQ4OzvjmWeeQVxcHI4cOYJXXnkF06dP19pFRkRERObHpMYMjR8/Hnfv3sWbb76JlJQUdOzYEYcOHYKPjw8AICUlBYmJieryDg4OCA8Px4svvojg4GA4Oztj3LhxeOutt4x1CkRERNTAmNQ8Q8ZQnXkKiIiIqGFolPMMERERERkCwxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzZnJhaN26dWjdujVsbW3RrVs3HD16VK/tjh8/DisrKwQGBhq2gkRERGRSTCoM7dmzB/Pnz8drr72GmJgY9O7dG0OHDkViYmKl2ykUCkyZMgUDBw6sp5oSERGRqah2GPr11191rtu4cWOtKlOVDz/8EM8++yxmzJiBgIAArF69Gt7e3li/fn2l2z3//POYOHEiQkJCDFo/IiIiMj3VDkPDhw/Hyy+/jMLCQvWyv//+GyNHjsTSpUvrtHJlFRYW4vTp0wgNDdVYHhoaiqioKJ3bbd26FdeuXcPy5cv1Ok5BQQGysrI0XkRERNR4VTsMHTlyBN999x0eeughXLx4ET/88AM6duyIf/75B2fPnjVEHQEA6enpKCkpgbu7u8Zyd3d3pKamat3m6tWrWLJkCXbs2AErKyu9jrNq1SrI5XL1y9vbu9Z1JyIiooar2mGoe/fuiImJQefOndGtWzeMGTMGL7/8Mn7//fd6CQ6SJGl8FkJUWAYAJSUlmDhxIlasWIG2bdvqvf+lS5dCoVCoX7du3ap1nYmIiEi7c0mZGLn2GAZ+EImRa4/hXFJmvddBv+aSci5fvoyTJ0+iZcuWSE5OxqVLl5Cbm4smTZrUdf3UXFxcYGlpWaEVKC0trUJrEQBkZ2fj1KlTiImJwdy5cwEASqUSQghYWVnhl19+wYABAypsJ5PJIJPJDHMSREREjdy5pEy8tv8CAGBaTx/sPX0bS4e1R+eWTlrL7ztzG+dvKzQ+6yprKNVuGXr77bcREhKCQYMG4cKFCzh58qS6pSg6OtoQdQQA2NjYoFu3bggPD9dYHh4ejp49e1Yo7+joiPPnzyM2Nlb9mjVrFtq1a4fY2Fh0797dYHUlIiJqrM4lZeKpTSd0tuCows352wp8djQB0dfvYt+Z2xplkjJy8VvcHWw5loC9pzR7YPaeTsLmY9fxa/wdJGXkGuo0NFS7Zeh///sfDhw4gKFDhwIAOnTogD///BOvvvoq+vXrh4KCgjqvpMqCBQswefJkBAcHIyQkBJs2bUJiYiJmzZoFoLSL6/bt29i+fTssLCzQsWNHje3d3Nxga2tbYTkRERHpZ9+Z2+qAo2rBScrIxeWUbGQXFOOb0/fDzaXUbADAN2eS0NvfBW5NbdGsiTUeeSdC5/7/KSjGyu/j1Z9vvD3cMCdSRrXD0Pnz5+Hi4qKxzNraGu+99x5GjBhRZxXTZvz48bh79y7efPNNpKSkoGPHjjh06BB8fHwAACkpKVXOOUREREQVnUvKxKpDl7R2aSVl5CIjpwiSBHx3NhlA6fuT3VpCCGDkx8e07lP8+56dX4xnPz+lXr56fCAWfBULpdC6GQDAQgI+HBdYizPSnySEqKQqlJWVBblcDoVCAUdHR2NXh4iIqFK6Qk3ZsTz/GdOxQuAJO3gR26JuYFpPX4Q91kFjne+SH9R/SygNOap3FQsJlYYbALCykPD+2C4YHdQCF24rMGKt9hAFAN+/+Ag6tpBXvsNKVOf326RmoCYiIqLKle3GKr9cNZZHtS4pIxfnkxS4cFuh0eJz4bYC55MU6jE7q8cHwsqi9M5tVd5RvVtZSFg9PhAH5z5SZd0OzOmF0UEtan+SdaxGd5MRERFR/dDW0lN+ma5urD7+LkhIzwUkgf1nktT73B9zG11aOuGlr2LVy1ST1NzLKdRosbnx9nCMDmoBPzcHrS05B+b0QscWclwoc0dYeeVbkQDA2cEGze1toMgrhABgaSGhRFk6XY7czhrODjbV+JZqh2GIiIioAdAVep7bfhqpWfkaA5bLD2IuOyC5bKiZXmacTlmKvCKNIARob/F5f2yXCttKEiDE/XcVVbjJyi+Ci4MMadn5UArA3sYSPs72SM8u1Ag4nnI7RL86AKrROjaWFigsUf57DAkyK8sqv7O6wjBERETUAJQNOM2b2CAjpwifHrmO1Kx8AMCBmNsI9HaCEMC3saXdXKpBzC8PaovVv11FiVJUCDWVsZCAlx5tiw/Cr1RYp2rxUXF2sIGrgwyeTrYY/5A39py8hZTMfHXAKRtuZFaWKCgugRACFhYW6qBTPuCU/2xrYZzROxxAXQUOoCYiotrQ9y6tqVv+xN2cQjjZWSMzr0ivfWvrfipv9fhAzN8Tq3Xd9y+WjvMZsfZYhRYfbQOYC4pLYGNpAUmSIITQGnAaiur8frNliIiIyIC0zcujoq17S98gBGh2af3fQH98EH5FZzeWLlW1+JRVNvjUd1eWITEMERER1bGq5uVp1sQaLZvZY/X4QCz8+iyKy3Rv1cSBOb3g7GCD7dE3K4Sa1i726rE87o62AATuZBXA8d9Byp5yOxxb0l/d4jPx4VYNusXHENhNVgV2kxERUXXpMy+Pamblqubb0UZXl5aubizV+B1VwCkoLmlULTvacJ4hIiKiOlLVs7i00WdenvIkSfNdG7mtFZo3sUGnFnL8Z0xHdGohh6uDTN2lJbOyhPTvDsqGHZmVJWytrSBJEiRJgq21VaMOQtXFbjIiIqJKVDbmRxd95uVR0TZmJ+leHiABXk62mPCQN746lYTkjDx8M7snPOS2Zt2lZQgMQ0REROXoO+ZHH1UNaNY1ZgeAetmk7j5aQ09j7+qqLwxDRERk1rTd+q5rEsPyMzNXpi7v0mLoMSyGISIiMmvausG03eVV1czM5fEuLdPBAdRERGR2qnpAabBvMxyY00vrttV52KiuAc3UsLBliIiIzI4+3WCq2ZmrO4khmR62DBERkdnR59Z31ZgfXbexU+PBSRerwEkXiYhMS2XPAitL12SHZZ/JZUrP4iJNnHSRiIjMStmJEcsOiNZHZZMdcsyPeeCYISIiMnnbo24i+vpdfHrkOqKu3QVQ9bxA1bn1nRo3dpNVgd1kREQN069xqfjfb39hei9fvPTV2SrLa5sXiN1gjVd1fr/ZMkRERCZpxvbTAFBlEKpsXqCqJjsk88AwREREJqPsYzIcZJb4p6Ckym3KPwuMqDyGISIiMhna5gfShfMCkb54NxkREZkMbfMDaTOn/wOcF4j0xjBEREQNVtlb5gFgdFALnY/JmNP/AXRs4QiXJjZ4uocPvp3TC8eW9Ien3K4ea0ymiN1kRETUYGl7iKpK+W6woR09sTC0ncYdYRwQTfpgGCIiogal7CDpsg9RVc0ZVFRSonN+IN4R1vgUpech91QqijMKYNVMBvtgD1i71G1rH+cZqgLnGSIiql++S35Q/y2hdGyQ6l3l8ltDOD9QI1SUnod/jtxCwY0siGIllEVKiOyi+wX+HTXf7Im2aBLsXum+OM8QERGZrNXjA7Hw67MoVgqtD1F9f2wXzg/USKjCT/5fmSjJKgSKq2if+Xd1xjdXIPN1hFUdtRAxDBERUYMyOqgF/NwctD5ElXMGmS6N4JNbDBQrqw4/lcg5lQr5kNZ1UjeGISIiarBUg6Q5Z5BpqbK7q7YEUJxRUGe7YxgiIqIGhw9RNT2qAJR78S5ETrHBj2fVTFZ3+6qzPREREdURT7kdji3prx4kPfHhVhwk3YDUdZdXTTQJ9qizfTEMERGR0ZxLysSqQ5ewdFj7CvMIcZB0w2DwLq8acBziW2eDpwGGISIiMqLKJlUk46nvLq/qcBziC8d+3nW6T4YhIiKqV1VNqtisiTVaNrM3ci3NR0Po8tJFcrCBhY0FJCsJMl85mvZpWactQioMQ0REVK/KPnle5V5Oocat9DfeHl6fVTIbDbHLS81agmRpAQt7a9j6ORks+GjDMERERPVq9fhAvPRVrMat8uUnVaS602C7vKwtYNnUpt6DjzYMQ0REVC9U3WN+bg5wlFlBkV/xh5mTKtZOQ+3yqq/urppiGCIionqhrXuMakf1ENPC1BwUp+SgRFFo7CqVsrGApUPDaPXRB8MQERHVi7LPHNOmqa0VJ1WsQrWf5VVfGlCXV00wDBERUb2o7Jlj383thbYeTTmXUDka4eefIqBQaewqNfgur5pgGCIionpX/pljnFRRs8tLqShEcWY+RF6Jsatlcl1eNcEwRERE9YbPHNPUIO/0MvEur5qQhOBzgCuTlZUFuVwOhUIBR0dHY1eHiMjkFRSXqJ85JoQwq2eOlZ3npySnyOgBqDF2ealU5/ebLUNERFSvzO2ZYw2q9ccMurxqgmGIiIioDjWo1h8z7PKqCYYhIiKiWmoorT9SE2tYNrFqdF1ehmZyYWjdunV47733kJKSgg4dOmD16tXo3bu31rL79u3D+vXrERsbi4KCAnTo0AFhYWEYPHhwPdeaiIgakwZxy7sRn+XV2JhUGNqzZw/mz5+PdevWoVevXti4cSOGDh2KuLg4tGrVqkL5I0eOYNCgQfjvf/8LJycnbN26FSNHjsQff/yBoKAgI5wBERGZqobQ+mPRxBp2HZwZfOqYSd1N1r17d3Tt2hXr169XLwsICMDo0aOxatUqvfbRoUMHjB8/Hm+88YZe5Xk3GRGReTJ664+dFSQJsLC1YstPDTTKu8kKCwtx+vRpLFmyRGN5aGgooqKi9NqHUqlEdnY2mjdvrrNMQUEBCgoK1J+zsrJqVmEiIjN2LikTqw5dwtJh7dG5pZOxq6OXhvCcL7b8GIfJhKH09HSUlJTA3d1dY7m7uztSU1P12scHH3yAnJwcjBs3TmeZVatWYcWKFbWqKxGRudt35jair9/FvjO3G3QYMnbXl4VcBhvPJrD2sEeTYA8GICMxmTCkIkmSxmchRIVl2uzatQthYWH49ttv4ebmprPc0qVLsWDBAvXnrKwseHt717zCRERmIikjFxk5RZAk4LuzyQBK35/s1hJCAM2aWKNlM3sj17JUUXoeMr65gsKE+m/9Z+tPw2MyYcjFxQWWlpYVWoHS0tIqtBaVt2fPHjz77LP4+uuv8eijj1ZaViaTQSaT1bq+RETm5pF3ItR/q/4v6r2cQo0Hs954e3g916qUMcf/sPWn4TOZMGRjY4Nu3bohPDwcY8aMUS8PDw/HqFGjdG63a9cuTJ8+Hbt27cLw4cb5HyERkTlYPT4QC78+i2KlgOrOHNW7lYWE98d2qbe6GHX8D2d5NjkmE4YAYMGCBZg8eTKCg4MREhKCTZs2ITExEbNmzQJQ2sV1+/ZtbN++HUBpEJoyZQr+97//oUePHupWJTs7O8jlcqOdBxFRYzQ6qAX83Bw0WoJUDszphY4tDP/fXWN1f7Hry7SZVBgaP3487t69izfffBMpKSno2LEjDh06BB8fHwBASkoKEhMT1eU3btyI4uJizJkzB3PmzFEvnzp1KrZt21bf1SciMhuSBAhx/93Q6j0EsfWnUTGpeYaMgfMMERHpL0WRh8fWHoenky3GP+SNPSdvISUzHwdf7AVPed0FBmM8/4utP6alOr/fDENVYBgiIqqeguIS2FhaQJIkCCFQWKKssyfT12cLEJ/zZdoa5aSLRERkGsoGH0mSah2EVIOh8y7dQ3Fqbm2rVym2/pgnhiEiImqQ6qsVyKKpNewCGIDMGcMQERE1KPURgtgCRGUxDBERUYORFXELWT/fqPP9cvwPVYZhiIiI6kRNH85qyOeD2bSWo/kT/gw/Dd3tM8D3LwGQgBEfAi261uvhGYaIiKhOVPfhrIbsDmMIMiG3zwC7JwHZpc+zw7k9DENERGQ6avpw1rruDuPzv0xQZiJw5yLwx8b7QQgAzu4uDUMyR8C9A+DUyuBV4TxDVeA8Q0REuvku+UH9t4TSZ5Gp3lVUD2dV3SKfeyEdJen5dXJ8tgA1cLfPAOFvAIPe1GztyUwEVnfSbx9hihodmvMMERFRvdD34ax12RJk5dEEdu2bsQWooSo7/qe5L3DjaMWuL32CkGQBjNloqFpqYBgiIqIa0+fhrBnfX0fOsdu1PhZbgUzEn58CKbGlf/99qfT9wjdAl6cACMDeGXj8U+DAC4CykgHzMyMAr0ADV7YUwxAREdWJ8g9nLc4swJ39Z1CUlFOr/TIEmQDV+J/8LODszvvLi/NK33P+Bjb1vb88TAG4tNVcZkQMQ0REVCvODjZwdZCpH866O+omktNzoPwiHkWwqPF+bds1g9PIBxiCGhpt44D0Hf9jYQWMXl95GckSsGsGNHGtXT2rgWGIiIhqxVNuh2NL+sPG0gLZkUnocwcoQhPYQKrR/tgS1MCd3V1xHNDjnwL7nweEsvJtZ/x2v+uriSvg4AY09QS6TCptUcq6DTzzC+DUArCSGfQ0ymIYIiKiWpNZWarHBkmQYFODfVi3dIDzhPYMQcai684voLQbLPcuAAm4uK90WdlxQK16lI7x0dntVf4eQwDyFsD8C4ClTWnfavfngJLCeg1BKgxDRERUa7UdJO04xBeO/bzrsEZUbdpafFQ0usH+bfHLSdcMP88d1r1v17ZAXkbFrq+ywUeSjBKEAIYhIiKqpayIxBoFIStXO9h1cOYt8vVF2yMvqmrxsXcunfRQ4+6vcpMoqMYBNXEtLZ+vKO36EgLITikd/zNpH+DgarSwUxWGISIiqrGi9Dxk/Xyz2ts59G4Bp+FtDFAj0uns7vu3vKtaf/Rp8QlTAJ3H6b77q+w4oAXxpSFIFXqKC4za4qOvmg/zJyIis5f+zZXyI0Gq5DjEl0HIkG6fAbaNKH3PTAQu/wic3VMagFTO7i79HDIXsLD8d6GWFp/HP9VyAIty72VYyQBr29IAJEmlfzfwIASwZYiIiGro0i830OS6ApJU9V1jFk2sYdfBGU37tGSXWF2obLBz2bE/f2zQvn1+JrDvucqPUbbFB7h/95djC6DrFODM9tK7v+rxFnhDYRgiIqJqS4y7i+RDN+Avq7qDgV1iBlB+sLOusT/9Xwci/oMKd3KpSBZAv1eBiLdQ2tKjLPNeTvm7v7o9Y7S7v+oawxAREVXL6Z9u4MSB6+hmb6l+MGt5quUMQrVUdtBz30WAoye0DnbWGMtTZuxPxFuV739mRGnLzslN+rX4NJC7v+oawxAREelNFYQAIFepKwqVsmntyCBUHdq6vsoOet79VJnCOgY7A6gw9keyBESJ7uM24hYffXEANRER6SXzTq46CAFAYqGydCo9odkFo/rc/Im29Vk906fq+jr5mfZBz9b2pd1aALQOdu7/uvb9PrW79JZ3CytA7l36srAC7F3ut/5YyUqDENCoWnz0xZYhIiLSy7Gvr2h8zlECMXklCLKzhLJMIJIA2A724UBplerO7By7o/RVXlGu7mPM+K30XdvYHwc3k73lvb4wDBERUZUy7+Ti5oV7FZbfKhS4V1yMVjYWcLX6Cy1k25DV7VW49m9lhFo2UNWd2VkvqsdblBnsXNndXuVDj7VttU+jMWMYIiKiKsVHpehcl6ME4vOVcGn6O5pbn0dzu8MAhtVf5RqiWs3sXAW75kAzn4qBh2N/aoxhiIiIqpR0uWKrEAA0tUiDrUU2BIAAeTRQDO0/+qassm4uXepiZmddJu4BWj6kPfA00ru9DI1hiIiIKpV5JxdpN7K1rpvi9vz9D8WV/Oibssq6uXTR51leFZQb62PrBBT+U/qcL6D0OV+2TqXdYGY82NkQGIaIiKhS5QdOlxWeOR8D5WthIZVA/x/9BkZby4++3Vy66PssL0D3WJ9nfimdV4iDng2OYYiIiHRKjLurdeC0ypX8vpDc2uHRwhcqrvToBDj7GbB2dURby4++3Vx6qaOZnTno2WA4zxAREWkVH5WM79acrbKcm4/jv3+Ve4BncozmPDmGVPbhpGX/1iUzsbR+ybGaLT/JsaXLh6wqbdkCoP8DTMtRtfh4dQFGfFT67uCme2Zndn0ZDVuGiIiogsw7ufj9i0t6lfUJaQ+kuAH2rkDbwcClH4D0KwCEYQdTl+3eKtu6I0TVY3z0afl57rB+3Vy68O4uk8GWISIiqiDiy0t63ent09EZ8jZ+pT/6aReBYx8C6ZfvF1AFjE39NAOIqvUmdlflrTiVtfL8+Wlp6In+GDj/demys7vvt0ad++p+S09moua2j39ajZafci1e1cEWH5PAliEiItJwbO9VJF/N1KvsI+P8S/+wklXvDipVS05eBnDngu5WnMqezn52Z2mZC9/cL59fpt5593SP8dFngLPitu5JDKlRYRgiIiK1Y3uv4uyvt/QqO2BKAJzc7O8vqCpg2DcvbaXJvnO/9ebOxdL3s7uBB/oDDu6ld01ZyVD109n1VOVdbToGOLOby2wwDBEREYDqBaHH/i8Q3gHNKymhJWBojNNR+bflKD8T2Dley/rKns6uJ11jfCp7fIUKJzE0CwxDRERmLPNOLmLCE3E95m/k5xTptY1PR2fdQaiygKHRjaaDhRXQdSpw5nPd3W19l/z7QNKq6LiVXYUtP/QvhiEiIjOUeScXEV9e0ntsUFnqcULaVBYw9Hn0hKoVp+sU3d1tQLmns//roeeA01tK/+7/GhB/sOoxPmz5ITAMERGZjcw7uYiPSsHNC+m4ezunRvvoMaaN5jghbfQKGKqnruv6rKKlu61869PpbUBWMvDIfCB0ZWkZa1vgkZfY0kN6YRgiImrE1N1gsWnI/6eS7ik9BA7yRrfBvrWrkCrINHEtvTNMWVza9eXkA+Sk3W/Fqay7Td/uLbb0kJ4kIYQeM0mYr6ysLMjlcigUCjg6Ola9ARGREalaf+7ezkb67X+Qk1FYJ/sNHOSNXk9U0j1WHcUFpUGmpBCwsAaURfc/lw0vqnKSVDqRIlt5qBqq8/vNliEiIhOmavlJunQPOYoClBTV/f+/rdMgBNwPNKp3i3Kfy5cD2MpDBsUwRERkAsqGnvycIggloFQKlBRVcrdUHegx+gF0G+Jj0GMQGRvDEBGRkZXt2vonswD5OUUoyi+BUAKShQRIQGFu7cb7VJdPR2c8Ms6/6sHSRI0AwxARkQGVbdEpzCuGpY0lrG0sUVRYjKL8EpQUKVFS3HCGbnr5O6H/5PYMQWRWGIaIiPRUVbAR//ZYSRYSrG0toSwRyMsqN4A5p35bePTFEETmjGGIiBo9VYhJ+SsTJcVKWFhaaAQYVXipy2BTmNcwQ09Zzi0c4NPRGQG9PBmCyKyZXBhat24d3nvvPaSkpKBDhw5YvXo1evfurbP84cOHsWDBAly8eBFeXl5YtGgRZs2aVY81JiJdKhsrA+gXUsqvK788/58ive6wqiy8mEKw0ZedgzVaB7kiaFArBiCif5lUGNqzZw/mz5+PdevWoVevXti4cSOGDh2KuLg4tGrVqkL5hIQEDBs2DDNnzsSXX36J48ePY/bs2XB1dcUTTzxhhDMgqjva7i7SNyDUJFTU9TaGDCmNKbzUlq2DNewcrOHp78QARKSDSU262L17d3Tt2hXr169XLwsICMDo0aOxatWqCuUXL16MgwcPIj4+Xr1s1qxZOHv2LKKjo7Ueo6CgAAUFBerPWVlZ8Pb21mvSpvI/TkDD+wFqrNs0hDrU5zbGuLuIGj5LGwmWlpawdbBGy/bNGH7IrDXKSRcLCwtx+vRpLFmyRGN5aGgooqKitG4THR2N0NBQjWWDBw/G5s2bUVRUBGtr6wrbrFq1CitWrKh2/eKjkvH79ksV613H/6+W2zTsOtTnuZJ5s7SSYGnN4ENUF0wmDKWnp6OkpATu7u4ay93d3ZGamqp1m9TUVK3li4uLkZ6eDk9PzwrbLF26FAsWLFB/VrUMVSbzTq7WIEREVBM29laAEOqWQBs7S8jsreHQTAZnLwcOeCaqYyYThlQkSdL4LISosKyq8tqWq8hkMshk1ZvyPT4qpVrlich8yeytYOdog+LCYhTm3e/6ZAsPkfGYTBhycXGBpaVlhVagtLS0Cq0/Kh4eHlrLW1lZwdnZuc7qln03r872RUSmQ1uwAe635ljZWEJZooSlpQUHMBM1YCYThmxsbNCtWzeEh4djzJgx6uXh4eEYNWqU1m1CQkLw3XffaSz75ZdfEBwcrHW8UE01dbars30RkeHZO9rAwgoaLTOq8MJgQ2R+TCYMAcCCBQswefJkBAcHIyQkBJs2bUJiYqJ63qClS5fi9u3b2L59O4DSO8c+/vhjLFiwADNnzkR0dDQ2b96MXbt21Wm9Anp64szPN+t0n0TmqOxYGUD/kFK+y6n8coDdUESkm0mFofHjx+Pu3bt48803kZKSgo4dO+LQoUPw8Sl9onJKSgoSExPV5Vu3bo1Dhw7hpZdewieffAIvLy+sWbOmzucYcnK3x4ApAfh9e3zVhYkMRHV3kb4BoSahoq63YUghoobApOYZMobqzFOQmZaLmF805xlqiD9AjXGbhlCH+t6GdxcREenWKOcZMgVObvbo/3R7Y1eDiIiIqsHC2BUgIiIiMiaGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis8YwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis8YwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis8YwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis8YwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis8YwRERERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZYxgiIiIis2YyYSgjIwOTJ0+GXC6HXC7H5MmTkZmZqbN8UVERFi9ejE6dOqFJkybw8vLClClTkJycXH+VJiIiogbPZMLQxIkTERsbi59++gk//fQTYmNjMXnyZJ3lc3NzcebMGSxbtgxnzpzBvn37cOXKFTz22GP1WGsiIiJq6CQhhDB2JaoSHx+PBx98ECdOnED37t0BACdOnEBISAguXbqEdu3a6bWfkydP4uGHH8bNmzfRqlUrvbbJysqCXC6HQqGAo6Njjc+BiIiI6k91fr9NomUoOjoacrlcHYQAoEePHpDL5YiKitJ7PwqFApIkwcnJSWeZgoICZGVlabyIiIio8TKJMJSamgo3N7cKy93c3JCamqrXPvLz87FkyRJMnDix0oS4atUq9bgkuVwOb2/vGtebiIiIGj6jhqGwsDBIklTp69SpUwAASZIqbC+E0Lq8vKKiIkyYMAFKpRLr1q2rtOzSpUuhUCjUr1u3btXs5IiIiMgkWBnz4HPnzsWECRMqLePr64tz587hzp07Fdb9/fffcHd3r3T7oqIijBs3DgkJCfj999+r7DeUyWSQyWRVV56IiIgaBaOGIRcXF7i4uFRZLiQkBAqFAn/++ScefvhhAMAff/wBhUKBnj176txOFYSuXr2KiIgIODs711ndiYiIqHEwiTFDAQEBGDJkCGbOnIkTJ07gxIkTmDlzJkaMGKFxJ1n79u2xf/9+AEBxcTGefPJJnDp1Cjt27EBJSQlSU1ORmpqKwsJCY50KERERNTAmEYYAYMeOHejUqRNCQ0MRGhqKzp0744svvtAoc/nyZSgUCgBAUlISDh48iKSkJAQGBsLT01P9qs4daERERNS4mcQ8Q8bEeYaIiIhMT6ObZ4iIiIjIUIw6gNoUqBrOOPkiERGR6VD9buvTAcYwVIXs7GwA4OSLREREJig7OxtyubzSMhwzVAWlUonk5GQ0bdpUrwkes7Ky4O3tjVu3bjX6MUY818aJ59o48VwbJ56rbkIIZGdnw8vLCxYWlY8KYstQFSwsLNCyZctqb+fo6Njo/2Gq8FwbJ55r48RzbZx4rtpV1SKkwgHUREREZNYYhoiIiMisMQzVMZlMhuXLl5vF8814ro0Tz7Vx4rk2TjzXusEB1ERERGTW2DJEREREZo1hiIiIiMwawxARERGZNYYhIiIiMmsMQ7Vw48YNPPvss2jdujXs7OzwwAMPYPny5SgsLKx0OyEEwsLC4OXlBTs7O/Tr1w8XL16sp1rXzn/+8x/07NkT9vb2cHJy0mubadOmQZIkjVePHj0MW9E6UJNzNdVrm5GRgcmTJ0Mul0Mul2Py5MnIzMysdBtTua7r1q1D69atYWtri27duuHo0aOVlj98+DC6desGW1tbtGnTBhs2bKinmtZedc41MjKywvWTJAmXLl2qxxrXzJEjRzBy5Eh4eXlBkiQcOHCgym1M9bpW91xN9bquWrUKDz30EJo2bQo3NzeMHj0aly9frnK7urquDEO1cOnSJSiVSmzcuBEXL17ERx99hA0bNuDVV1+tdLt3330XH374IT7++GOcPHkSHh4eGDRokPo5aA1ZYWEhxo4dixdeeKFa2w0ZMgQpKSnq16FDhwxUw7pTk3M11Ws7ceJExMbG4qeffsJPP/2E2NhYTJ48ucrtGvp13bNnD+bPn4/XXnsNMTEx6N27N4YOHYrExESt5RMSEjBs2DD07t0bMTExePXVVzFv3jx888039Vzz6qvuuapcvnxZ4xr6+/vXU41rLicnB126dMHHH3+sV3lTvq7VPVcVU7uuhw8fxpw5c3DixAmEh4ejuLgYoaGhyMnJ0blNnV5XQXXq3XffFa1bt9a5XqlUCg8PD/H222+rl+Xn5wu5XC42bNhQH1WsE1u3bhVyuVyvslOnThWjRo0yaH0MSd9zNdVrGxcXJwCIEydOqJdFR0cLAOLSpUs6tzOF6/rwww+LWbNmaSxr3769WLJkidbyixYtEu3bt9dY9vzzz4sePXoYrI51pbrnGhERIQCIjIyMeqid4QAQ+/fvr7SMKV/XsvQ518ZyXdPS0gQAcfjwYZ1l6vK6smWojikUCjRv3lzn+oSEBKSmpiI0NFS9TCaToW/fvoiKiqqPKhpFZGQk3Nzc0LZtW8ycORNpaWnGrlKdM9VrGx0dDblcju7du6uX9ejRA3K5vMp6N+TrWlhYiNOnT2tcDwAIDQ3VeV7R0dEVyg8ePBinTp1CUVGRwepaWzU5V5WgoCB4enpi4MCBiIiIMGQ1jcZUr2ttmPp1VSgUAFDp72ldXleGoTp07do1rF27FrNmzdJZJjU1FQDg7u6usdzd3V29rrEZOnQoduzYgd9//x0ffPABTp48iQEDBqCgoMDYVatTpnptU1NT4ebmVmG5m5tbpfVu6Nc1PT0dJSUl1boeqampWssXFxcjPT3dYHWtrZqcq6enJzZt2oRvvvkG+/btQ7t27TBw4EAcOXKkPqpcr0z1utZEY7iuQggsWLAAjzzyCDp27KizXF1eV4YhLcLCwrQOQCv7OnXqlMY2ycnJGDJkCMaOHYsZM2ZUeQxJkjQ+CyEqLKsvNTnf6hg/fjyGDx+Ojh07YuTIkfjxxx9x5coV/PDDD3V4Fvox9LkCDefaVudctdWvqno3pOtamepeD23ltS1viKpzru3atcPMmTPRtWtXhISEYN26dRg+fDjef//9+qhqvTPl61odjeG6zp07F+fOncOuXbuqLFtX19WqWqXNxNy5czFhwoRKy/j6+qr/Tk5ORv/+/RESEoJNmzZVup2HhweA0kTr6empXp6WllYh4daX6p5vbXl6esLHxwdXr16ts33qy5Dn2tCurb7neu7cOdy5c6fCur///rta9TbmddXGxcUFlpaWFVpGKrseHh4eWstbWVnB2dnZYHWtrZqcqzY9evTAl19+WdfVMzpTva51xZSu64svvoiDBw/iyJEjaNmyZaVl6/K6Mgxp4eLiAhcXF73K3r59G/3790e3bt2wdetWWFhU3tjWunVreHh4IDw8HEFBQQBK+/sPHz6Md955p9Z1r4nqnG9duHv3Lm7duqURGOqLIc+1oV1bfc81JCQECoUCf/75Jx5++GEAwB9//AGFQoGePXvqfTxjXldtbGxs0K1bN4SHh2PMmDHq5eHh4Rg1apTWbUJCQvDdd99pLPvll18QHBwMa2trg9a3NmpyrtrExMQ0mOtXl0z1utYVU7iuQgi8+OKL2L9/PyIjI9G6desqt6nT61rtIdekdvv2beHn5ycGDBggkpKSREpKivpVVrt27cS+ffvUn99++20hl8vFvn37xPnz58VTTz0lPD09RVZWVn2fQrXdvHlTxMTEiBUrVggHBwcRExMjYmJiRHZ2trpM2fPNzs4WL7/8soiKihIJCQkiIiJChISEiBYtWjT4863uuQphutd2yJAhonPnziI6OlpER0eLTp06iREjRmiUMcXrunv3bmFtbS02b94s4uLixPz580WTJk3EjRs3hBBCLFmyREyePFld/vr168Le3l689NJLIi4uTmzevFlYW1uLvXv3GusU9Fbdc/3oo4/E/v37xZUrV8SFCxfEkiVLBADxzTffGOsU9Jadna3+3yMA8eGHH4qYmBhx8+ZNIUTjuq7VPVdTva4vvPCCkMvlIjIyUuO3NDc3V13GkNeVYagWtm7dKgBofZUFQGzdulX9WalUiuXLlwsPDw8hk8lEnz59xPnz5+u59jUzdepUrecbERGhLlP2fHNzc0VoaKhwdXUV1tbWolWrVmLq1KkiMTHROCdQDdU9VyFM99revXtXTJo0STRt2lQ0bdpUTJo0qcKtuaZ6XT/55BPh4+MjbGxsRNeuXTVu1Z06daro27evRvnIyEgRFBQkbGxshK+vr1i/fn0917jmqnOu77zzjnjggQeEra2taNasmXjkkUfEDz/8YIRaV5/q9vHyr6lTpwohGtd1re65mup11fVbWva/r4a8rtK/lSAiIiIyS7ybjIiIiMwawxARERGZNYYhIiIiMmsMQ0RERGTWGIaIiIjIrDEMERERkVljGCIiIiKzxjBEREREZo1hiIiIiMwawxARUQ1IkoQDBw4YuxpEVAcYhoiIiMisMQwRkUn6+++/4eHhgf/+97/qZX/88QdsbGzwyy+/VLn9d999h27dusHW1hZt2rTBihUrUFxcDAB488034eXlhbt376rLP/bYY+jTpw+USiV8fX0BAGPGjIEkSerPRGSa+KBWIjJZhw4dwujRoxEVFYX27dsjKCgIw4cPx+rVqyvd7ueff8a4ceOwZs0a9O7dG9euXcNzzz2HadOmYfny5SgpKUHv3r3h7u6O/fv3Y8OGDViyZAnOnj0LHx8f/P3333Bzc8PWrVsxZMgQWFpawtXVtX5OmojqHMMQEZm0OXPm4Ndff8VDDz2Es2fP4uTJk7C1ta10mz59+mDo0KFYunSpetmXX36JRYsWITk5GQBw/fp1BAYGYvbs2Vi7di02bdqESZMmqctLkoT9+/dj9OjRBjkvIqo/DENEZNLy8vLQsWNH3Lp1C6dOnULnzp2r3KZJkyZQKpWwtLRULyspKUF+fj5ycnJgb28PANi0aROef/55jB8/Hrt379bYB8MQUeNhZewKEBHVxvXr15GcnAylUombN2/qFYaUSiVWrFiBxx9/vMK6sq1KR44cgaWlJW7cuIHi4mJYWfE/mUSNEQdQE5HJKiwsxKRJkzB+/Hi89dZbePbZZ3Hnzp0qt+vatSsuX74MPz+/Ci8Li9L/LO7Zswf79u1DZGQkbt26hZUrV2rsw9raGiUlJQY5LyKqX+wmIyKT9corr2Dv3r04e/YsHBwc0L9/fzRt2hTff/99pdv9/PPPGDFiBF577TWMHTsWFhYWOHfuHM6fP4+33noLSUlJ6Ny5M1asWIEXX3wR4eHhGD58OI4cOYIePXoAANq2bYtHH30Ub7zxBmQyGZo1a1Yfp0xEBsAwREQmKTIyEoMGDUJERAQeeeQRAEBiYiI6d+6MVatW4YUXXqh0+59//hlvvvkmYmJiYG1tjfbt22PGjBmYMWMGBg0aBCsrK/z444+QJAkAsGDBAhw8eBCxsbFwcHDAd999hwULFuDGjRto0aIFbty4YehTJiIDYRgiIiIis8YxQ0RERGTWGIaIqNHp0KEDHBwctL527Nhh7OoRUQPDbjIianRu3ryJoqIirevc3d3RtGnTeq4RETVkDENERERk1thNRkRERGaNYYiIiIjMGsMQERERmTWGISIiIjJrDENERERk1hiGiIiIyKwxDBEREZFZ+38dSc8pXtmA0QAAAABJRU5ErkJggg==\n" }, "metadata": {}, "output_type": "display_data" @@ -891,7 +1082,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -920,12 +1111,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 23, "id": "cfc406d6", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:04.420909Z", - "end_time": "2023-04-15T13:36:30.537951Z" + "end_time": "2023-09-10T08:46:20.482199900Z", + "start_time": "2023-09-10T08:45:49.867445200Z" } }, "outputs": [ @@ -945,7 +1136,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -953,7 +1144,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -984,12 +1175,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "id": "d9e6e771", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.537951Z", - "end_time": "2023-04-15T13:36:30.845691Z" + "end_time": "2023-09-10T08:46:20.693485700Z", + "start_time": "2023-09-10T08:46:20.482199900Z" } }, "outputs": [ @@ -999,7 +1190,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "7bec60ddad4d426c8e3e879d7276dda9" + "model_id": "869f49c0fec04d2f9a0e4e5d7f198625" } }, "metadata": {}, @@ -1008,7 +1199,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -1050,12 +1241,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "id": "9bfddfb6", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.845691Z", - "end_time": "2023-04-15T13:36:30.892557Z" + "end_time": "2023-09-10T08:46:20.742976Z", + "start_time": "2023-09-10T08:46:20.693485700Z" } }, "outputs": [], @@ -1087,12 +1278,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 26, "id": "dc569420", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.861307Z", - "end_time": "2023-04-15T13:36:30.892557Z" + "end_time": "2023-09-10T08:46:20.742976Z", + "start_time": "2023-09-10T08:46:20.709964500Z" } }, "outputs": [], @@ -1102,12 +1293,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 27, "id": "05e72272", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.876931Z", - "end_time": "2023-04-15T13:36:30.892557Z" + "end_time": "2023-09-10T08:46:20.743976800Z", + "start_time": "2023-09-10T08:46:20.728288100Z" } }, "outputs": [ @@ -1115,7 +1306,7 @@ "data": { "text/plain": "(80, 80)" }, - "execution_count": 21, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1128,12 +1319,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 28, "id": "bcdff2d9", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.892557Z", - "end_time": "2023-04-15T13:36:30.908185Z" + "end_time": "2023-09-10T08:46:20.760804800Z", + "start_time": "2023-09-10T08:46:20.742976Z" } }, "outputs": [ @@ -1141,7 +1332,7 @@ "data": { "text/plain": "(80, 80)" }, - "execution_count": 22, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1154,12 +1345,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 29, "id": "6f0a53fe", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.908185Z", - "end_time": "2023-04-15T13:36:30.939433Z" + "end_time": "2023-09-10T08:46:20.823627600Z", + "start_time": "2023-09-10T08:46:20.760804800Z" } }, "outputs": [ @@ -1167,7 +1358,7 @@ "data": { "text/plain": "(7, 80, 80)" }, - "execution_count": 23, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1188,12 +1379,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 30, "id": "60c8b649", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:30.923807Z", - "end_time": "2023-04-15T13:36:31.517478Z" + "end_time": "2023-09-10T08:46:21.087118100Z", + "start_time": "2023-09-10T08:46:20.776306Z" } }, "outputs": [ @@ -1236,12 +1427,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 31, "id": "d051ba87", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:31.508711Z", - "end_time": "2023-04-15T13:36:31.571460Z" + "end_time": "2023-09-10T08:46:21.102743100Z", + "start_time": "2023-09-10T08:46:21.087118100Z" } }, "outputs": [], @@ -1263,12 +1454,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 32, "id": "d08ab2d6", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:31.524578Z", - "end_time": "2023-04-15T13:36:31.720896Z" + "end_time": "2023-09-10T08:46:21.213479300Z", + "start_time": "2023-09-10T08:46:21.102743100Z" } }, "outputs": [], @@ -1291,12 +1482,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 33, "id": "62b80f65", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:31.720896Z", - "end_time": "2023-04-15T13:36:31.736552Z" + "end_time": "2023-09-10T08:46:21.228594400Z", + "start_time": "2023-09-10T08:46:21.213479300Z" } }, "outputs": [], @@ -1305,13 +1496,13 @@ " def __init__(self, Cmat, Dmat):\n", " super(WholeBrainNet, self).__init__()\n", "\n", - " self.fhn = bp.rates.FHN(\n", + " self.fhn = bp.dyn.FHN(\n", " 80,\n", " x_ou_sigma=0.01,\n", " y_ou_sigma=0.01,\n", " method='exp_auto'\n", " )\n", - " self.syn = bp.synapses.DiffusiveCoupling(\n", + " self.syn = bp.dyn.DiffusiveCoupling(\n", " self.fhn.x,\n", " self.fhn.x,\n", " var_to_output=self.fhn.input,\n", @@ -1323,12 +1514,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 34, "id": "3a9c8008", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:31.736552Z", - "end_time": "2023-04-15T13:36:35.551732Z" + "end_time": "2023-09-10T08:46:23.160880500Z", + "start_time": "2023-09-10T08:46:21.228594400Z" } }, "outputs": [ @@ -1338,7 +1529,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "18fcc8251ae0405c9523d3814087d908" + "model_id": "215d8dc9ad3c460d9e83cdb7a0300c77" } }, "metadata": {}, @@ -1362,19 +1553,19 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 35, "id": "03e47705", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:35.555731Z", - "end_time": "2023-04-15T13:36:36.078535Z" + "end_time": "2023-09-10T08:46:23.644212100Z", + "start_time": "2023-09-10T08:46:23.161879500Z" } }, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -1400,12 +1591,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 36, "id": "cd516013", "metadata": { "ExecuteTime": { - "start_time": "2023-04-15T13:36:36.078535Z", - "end_time": "2023-04-15T13:36:36.157109Z" + "end_time": "2023-09-10T08:46:23.730206100Z", + "start_time": "2023-09-10T08:46:23.644212100Z" } }, "outputs": [ @@ -1413,8 +1604,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Correlation per subject: ['0.56', '0.44', '0.55', '0.48', '0.53', '0.47', '0.39']\n", - "Mean FC/FC correlation: 0.49\n" + "Correlation per subject: ['0.63', '0.5', '0.58', '0.51', '0.56', '0.49', '0.47']\n", + "Mean FC/FC correlation: 0.53\n" ] } ], diff --git a/docs/tutorial_FAQs/how_to_debug.ipynb b/docs/tutorial_FAQs/how_to_debug.ipynb index 8b51d0bc4..a6f124288 100644 --- a/docs/tutorial_FAQs/how_to_debug.ipynb +++ b/docs/tutorial_FAQs/how_to_debug.ipynb @@ -154,12 +154,11 @@ { "cell_type": "markdown", "source": [ - "``jax.disable_jit()`` works for all brainpy transformations, for example:\n", + "``jax.disable_jit()`` works for most brainpy transformations, including:\n", "\n", "- ``brainpy.math.jit()``\n", "- ``brainpy.math.grad()``\n", "- ``brainpy.math.vector_grad()``\n", - "- ``brainpy.math.for_loop()``\n", "- ``brainpy.math.while_loop()``\n", "- ``brainpy.math.cond()``\n", "- ``brainpy.math.ifelse()``" @@ -167,6 +166,28 @@ "metadata": { "collapsed": false } + }, + { + "cell_type": "markdown", + "source": [ + "## ``brainpy.DSRunner(..., jit=False)``\n", + "\n", + "If users are using ``brainpy.DSRunner``, you can initialize ``brainpy.DSRunner(..., jit=False)`` to disable JIT compilation when simulating a brain dynamics model.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## ``brainpy.for_loop(..., jit=False)``\n", + "\n", + "Similarly, if users are using ``brainpy.for_loop``, you can put a ``jit=False`` argument into the ``for_loop`` transformation, then the JIT compilation will be removed." + ], + "metadata": { + "collapsed": false + } } ], "metadata": { diff --git a/docs/tutorial_advanced/1_advanced_math.rst b/docs/tutorial_advanced/1_advanced_math.rst new file mode 100644 index 000000000..174770d61 --- /dev/null +++ b/docs/tutorial_advanced/1_advanced_math.rst @@ -0,0 +1,8 @@ +Advanced Math +================= + +.. toctree:: + :maxdepth: 1 + + compilation.ipynb + differentiation.ipynb diff --git a/docs/tutorial_advanced/2_interoperation.rst b/docs/tutorial_advanced/2_interoperation.rst new file mode 100644 index 000000000..9fac2edf4 --- /dev/null +++ b/docs/tutorial_advanced/2_interoperation.rst @@ -0,0 +1,9 @@ +Interoperation +================= + +.. toctree:: + :maxdepth: 1 + + integrate_flax_into_brainpy.ipynb + integrate_bp_lif_into_flax.ipynb + integrate_bp_convlstm_into_flax.ipynb diff --git a/docs/tutorial_advanced/3_dedicated_operators.rst b/docs/tutorial_advanced/3_dedicated_operators.rst new file mode 100644 index 000000000..746891cfa --- /dev/null +++ b/docs/tutorial_advanced/3_dedicated_operators.rst @@ -0,0 +1,5 @@ +Brain Dynamics Dedicated Operators +================================== + +.. toctree:: + :maxdepth: 1 diff --git a/docs/tutorial_advanced/4_developer_guides.rst b/docs/tutorial_advanced/4_developer_guides.rst new file mode 100644 index 000000000..f486de066 --- /dev/null +++ b/docs/tutorial_advanced/4_developer_guides.rst @@ -0,0 +1,7 @@ +Developer Guides +================ + +.. toctree:: + :maxdepth: 1 + + contributing.md diff --git a/docs/tutorial_advanced/5_others.rst b/docs/tutorial_advanced/5_others.rst new file mode 100644 index 000000000..93a0c368a --- /dev/null +++ b/docs/tutorial_advanced/5_others.rst @@ -0,0 +1,7 @@ +Others +================ + +.. toctree:: + :maxdepth: 1 + + advanced_lowdim_analysis.ipynb diff --git a/examples/dynamics_simulation/ei_nets.py b/examples/dynamics_simulation/ei_nets.py new file mode 100644 index 000000000..2243a9ca1 --- /dev/null +++ b/examples/dynamics_simulation/ei_nets.py @@ -0,0 +1,249 @@ +import brainpy as bp +import brainpy.math as bm + + +def model1(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + self.N = bp.dyn.LifRefLTC(4000, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.delay = bp.VarDelay(self.N.spike, entries={'I': None}) + self.E = bp.dyn.ProjAlignPost1(comm=bp.dnn.EventJitFPHomoLinear(3200, 4000, prob=0.02, weight=0.6), + syn=bp.dyn.Expon(size=4000, tau=5.), + out=bp.dyn.COBA(E=0.), + post=self.N) + self.I = bp.dyn.ProjAlignPost1(comm=bp.dnn.EventJitFPHomoLinear(800, 4000, prob=0.02, weight=6.7), + syn=bp.dyn.Expon(size=4000, tau=10.), + out=bp.dyn.COBA(E=-80.), + post=self.N) + + def update(self, input): + spk = self.delay.at('I') + self.E(spk[:3200]) + self.I(spk[3200:]) + self.delay(self.N(input)) + return self.N.spike.value + + model = EINet() + indices = bm.arange(1000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices) + bp.visualize.raster_plot(indices, spks, show=True) + + +def model2(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + ne, ni = 3200, 800 + self.E = bp.dyn.LifRefLTC(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.I = bp.dyn.LifRefLTC(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.E2E = bp.dyn.ProjAlignPost2(pre=self.E, + delay=0.1, + comm=bp.dnn.EventJitFPHomoLinear(ne, ne, prob=0.02, weight=0.6), + syn=bp.dyn.Expon(size=ne, tau=5.), + out=bp.dyn.COBA(E=0.), + post=self.E) + self.E2I = bp.dyn.ProjAlignPost2(pre=self.E, + delay=0.1, + comm=bp.dnn.EventJitFPHomoLinear(ne, ni, prob=0.02, weight=0.6), + syn=bp.dyn.Expon(size=ni, tau=5.), + out=bp.dyn.COBA(E=0.), + post=self.I) + self.I2E = bp.dyn.ProjAlignPost2(pre=self.I, + delay=0.1, + comm=bp.dnn.EventJitFPHomoLinear(ni, ne, prob=0.02, weight=6.7), + syn=bp.dyn.Expon(size=ne, tau=10.), + out=bp.dyn.COBA(E=-80.), + post=self.E) + self.I2I = bp.dyn.ProjAlignPost2(pre=self.I, + delay=0.1, + comm=bp.dnn.EventJitFPHomoLinear(ni, ni, prob=0.02, weight=6.7), + syn=bp.dyn.Expon(size=ni, tau=10.), + out=bp.dyn.COBA(E=-80.), + post=self.I) + + def update(self, inp): + self.E2E() + self.E2I() + self.I2E() + self.I2I() + self.E(inp) + self.I(inp) + return self.E.spike + + model = EINet() + indices = bm.arange(1000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices) + bp.visualize.raster_plot(indices, spks, show=True) + + +def model3(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + self.N = bp.dyn.LifRefLTC(4000, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.delay = bp.VarDelay(self.N.spike, entries={'I': None}) + self.syn1 = bp.dyn.Expon(size=3200, tau=5.) + self.syn2 = bp.dyn.Expon(size=800, tau=10.) + self.E = bp.dyn.VanillaProj(comm=bp.dnn.JitFPHomoLinear(3200, 4000, prob=0.02, weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.N) + self.I = bp.dyn.VanillaProj(comm=bp.dnn.JitFPHomoLinear(800, 4000, prob=0.02, weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.N) + + def update(self, input): + spk = self.delay.at('I') + self.E(self.syn1(spk[:3200])) + self.I(self.syn2(spk[3200:])) + self.delay(self.N(input)) + return self.N.spike.value + + model = EINet() + indices = bm.arange(1000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices) + bp.visualize.raster_plot(indices, spks, show=True) + + +def model4(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + ne, ni = 3200, 800 + self.E = bp.dyn.LifRefLTC(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.I = bp.dyn.LifRefLTC(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.E2E = bp.dyn.ProjAlignPreMg1(pre=self.E, + syn=bp.dyn.Expon.desc(size=ne, tau=5.), + delay=0.1, + comm=bp.dnn.JitFPHomoLinear(ne, ne, prob=0.02, weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.E) + self.E2I = bp.dyn.ProjAlignPreMg1(pre=self.E, + syn=bp.dyn.Expon.desc(size=ne, tau=5.), + delay=0.1, + comm=bp.dnn.JitFPHomoLinear(ne, ni, prob=0.02, weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.I) + self.I2E = bp.dyn.ProjAlignPreMg1(pre=self.I, + syn=bp.dyn.Expon.desc(size=ni, tau=10.), + delay=0.1, + comm=bp.dnn.JitFPHomoLinear(ni, ne, prob=0.02, weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.E) + self.I2I = bp.dyn.ProjAlignPreMg1(pre=self.I, + syn=bp.dyn.Expon.desc(size=ni, tau=10.), + delay=0.1, + comm=bp.dnn.JitFPHomoLinear(ni, ni, prob=0.02, weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.I) + + def update(self, inp): + self.E2E() + self.E2I() + self.I2E() + self.I2I() + self.E(inp) + self.I(inp) + return self.E.spike + + model = EINet() + indices = bm.arange(1000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices) + bp.visualize.raster_plot(indices, spks, show=True) + + +def model5(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + ne, ni = 3200, 800 + self.E = bp.dyn.LifRefLTC(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.I = bp.dyn.LifRefLTC(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 2.)) + self.E2E = bp.dyn.ProjAlignPreMg2(pre=self.E, + delay=0.1, + syn=bp.dyn.Expon.desc(size=ne, tau=5.), + comm=bp.dnn.JitFPHomoLinear(ne, ne, prob=0.02, weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.E) + self.E2I = bp.dyn.ProjAlignPreMg2(pre=self.E, + delay=0.1, + syn=bp.dyn.Expon.desc(size=ne, tau=5.), + comm=bp.dnn.JitFPHomoLinear(ne, ni, prob=0.02, weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.I) + self.I2E = bp.dyn.ProjAlignPreMg2(pre=self.I, + delay=0.1, + syn=bp.dyn.Expon.desc(size=ni, tau=10.), + comm=bp.dnn.JitFPHomoLinear(ni, ne, prob=0.02, weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.E) + self.I2I = bp.dyn.ProjAlignPreMg2(pre=self.I, + delay=0.1, + syn=bp.dyn.Expon.desc(size=ni, tau=10.), + comm=bp.dnn.JitFPHomoLinear(ni, ni, prob=0.02, weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.I) + + def update(self, inp): + self.E2E() + self.E2I() + self.I2E() + self.I2I() + self.E(inp) + self.I(inp) + return self.E.spike + + model = EINet() + indices = bm.arange(1000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices) + bp.visualize.raster_plot(indices, spks, show=True) + + +def vanalla_proj(): + class EINet(bp.DynSysGroup): + def __init__(self): + super().__init__() + self.N = bp.dyn.LifRefLTC(4000, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5., + V_initializer=bp.init.Normal(-55., 1.)) + self.delay = bp.VarDelay(self.N.spike, entries={'delay': 2}) + self.syn1 = bp.dyn.Expon(size=3200, tau=5.) + self.syn2 = bp.dyn.Expon(size=800, tau=10.) + self.E = bp.dyn.VanillaProj( + comm=bp.dnn.CSRLinear(bp.conn.FixedProb(0.02, pre=3200, post=4000), weight=0.6), + out=bp.dyn.COBA(E=0.), + post=self.N + ) + self.I = bp.dyn.VanillaProj( + comm=bp.dnn.CSRLinear(bp.conn.FixedProb(0.02, pre=800, post=4000), weight=6.7), + out=bp.dyn.COBA(E=-80.), + post=self.N + ) + + def update(self, input): + spk = self.delay.at('I') + self.E(self.syn1(spk[:3200])) + self.I(self.syn2(spk[3200:])) + self.delay(self.N(input)) + return self.N.spike.value + + model = EINet() + indices = bm.arange(10000) + spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices, progress_bar=True) + bp.visualize.raster_plot(indices, spks, show=True) + + +if __name__ == '__main__': + # model1() + # model2() + # model3() + # model4() + # model5() + vanalla_proj() diff --git a/requirements-dev.txt b/requirements-dev.txt index 126f0bd27..01184540a 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,12 +1,11 @@ numpy -tqdm -msgpack -matplotlib>=3.4 +numba +brainpylib jax>=0.4.1 jaxlib>=0.4.1 -scipy>=1.1.0 -brainpylib -numba +matplotlib>=3.4 +msgpack +tqdm # test requirements pytest diff --git a/requirements-doc.txt b/requirements-doc.txt index d41a8cf41..d88a0c02a 100644 --- a/requirements-doc.txt +++ b/requirements-doc.txt @@ -3,8 +3,8 @@ tqdm msgpack numba jax>=0.4.1 -matplotlib>=3.4 jaxlib>=0.4.1 +matplotlib>=3.4 scipy>=1.1.0 numba