From 7c6cacb4c68443ab16f30a3fdc434e75b1f773e1 Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 21 Mar 2022 16:01:30 +0800 Subject: [PATCH 01/22] fix #79 --- brainpy/dyn/runners/ds_runner.py | 50 +++++++++++++++++--------------- 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/brainpy/dyn/runners/ds_runner.py b/brainpy/dyn/runners/ds_runner.py index 64eea723f..941c1495f 100644 --- a/brainpy/dyn/runners/ds_runner.py +++ b/brainpy/dyn/runners/ds_runner.py @@ -7,6 +7,7 @@ import tqdm.auto from jax.experimental.host_callback import id_tap +from brainpy.base.base import TensorCollector from brainpy import math as bm from brainpy.dyn import utils from brainpy.dyn.base import DynamicalSystem @@ -74,7 +75,6 @@ def __init__(self, target: DynamicalSystem, inputs=(), dt=None, **kwargs): self.dyn_vars.update({'_i': self._i}) else: self._i = None - self.dyn_vars.update(self.target.vars().unique()) # run function self._run_func = self.build_run_function() @@ -159,29 +159,33 @@ def build_monitors(self): return_with_idx[key] = (data, bm.asarray(idx)) def func(_t, _dt): - res = {k: (v.flatten() if bm.ndim(v) > 1 else v) for k, v in return_without_idx.items()} + res = {k: (v.flatten() if bm.ndim(v) > 1 else v.value) + for k, v in return_without_idx.items()} res.update({k: (v.flatten()[idx] if bm.ndim(v) > 1 else v[idx]) for k, (v, idx) in return_with_idx.items()}) return res return func - def _run_one_step(self, t_and_dt): - _t, _dt = t_and_dt[0], t_and_dt[1] - self._input_step(_t=_t, _dt=_dt) - self.target.update(_t=_t, _dt=_dt) + def _run_one_step(self, _t): + self._input_step(_t=_t, _dt=self.dt) + self.target.update(_t=_t, _dt=self.dt) if self.progress_bar: id_tap(lambda *args: self._pbar.update(), ()) - return self._monitor_step(_t=_t, _dt=_dt) + return self._monitor_step(_t=_t, _dt=self.dt) def build_run_function(self): if self.jit: - f_run = bm.make_loop(self._run_one_step, dyn_vars=self.dyn_vars, has_return=True) + dyn_vars = TensorCollector() + dyn_vars.update(self.dyn_vars) + dyn_vars.update(self.target.vars().unique()) + f_run = bm.make_loop(self._run_one_step, + dyn_vars=dyn_vars, + has_return=True) else: - def f_run(t_and_dt): - all_t, all_dt = t_and_dt + def f_run(all_t): for i in range(all_t.shape[0]): - mon = self._run_one_step((all_t[i], all_dt[i])) + mon = self._run_one_step(all_t[i]) for k, v in mon.items(): self.mon.item_contents[k].append(v) return None, {} @@ -212,8 +216,7 @@ def __call__(self, duration, start_t=None): start_t = float(self._start_t) end_t = float(start_t + duration) # times - times = bm.arange(start_t, end_t, self.dt) - time_steps = bm.ones_like(times) * self.dt + times = np.arange(start_t, end_t, self.dt) # build monitor for key in self.mon.item_contents.keys(): self.mon.item_contents[key] = [] # reshape the monitor items @@ -223,7 +226,7 @@ def __call__(self, duration, start_t=None): self._pbar.set_description(f"Running a duration of {round(float(duration), 3)} ({times.size} steps)", refresh=True) t0 = time.time() - _, hists = self._run_func([times.value, time_steps.value]) + _, hists = self._run_func(times) running_time = time.time() - t0 if self.progress_bar: self._pbar.close() @@ -277,23 +280,24 @@ def __init__(self, target, inputs=(), jit=False, dt=None, **kwargs): # Build the update function if jit: - self._update_step = bm.jit(self.target.update, dyn_vars=self.dyn_vars) + dyn_vars = TensorCollector() + dyn_vars.update(self.dyn_vars) + dyn_vars.update(self.target.vars().unique()) + self._update_step = bm.jit(self.target.update, dyn_vars=dyn_vars) else: self._update_step = self.target.update - def _run_one_step(self, t_and_dt): - _t, _dt = t_and_dt[0], t_and_dt[1] - self._input_step(_t=_t, _dt=_dt) - self._update_step(_t=_t, _dt=_dt) + def _run_one_step(self, _t): + self._input_step(_t, self.dt) + self._update_step(_t, self.dt) if self.progress_bar: self._pbar.update() - return self._monitor_step(_t=_t, _dt=_dt) + return self._monitor_step(_t, self.dt) def build_run_function(self): - def f_run(t_and_dt): - all_t, all_dt = t_and_dt + def f_run(all_t): for i in range(all_t.shape[0]): - mon = self._run_one_step((all_t[i], all_dt[i])) + mon = self._run_one_step(all_t[i]) for k, v in mon.items(): self.mon.item_contents[k].append(v) return None, {} From bf40f75bb2ca03d894161aec6d6b63dea9cf739a Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 21 Mar 2022 16:02:05 +0800 Subject: [PATCH 02/22] brainpy.math.fill_diagonal is the same as numpy.fill_diagonal --- brainpy/math/numpy_ops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/brainpy/math/numpy_ops.py b/brainpy/math/numpy_ops.py index f041297fe..d0322dbcf 100644 --- a/brainpy/math/numpy_ops.py +++ b/brainpy/math/numpy_ops.py @@ -1507,10 +1507,10 @@ def vander(x, N=None, increasing=False): def fill_diagonal(a, val): - a = _remove_jaxarray(a) - assert a.ndim >= 2 + assert isinstance(a, JaxArray), f'Must be a JaxArray, but got {type(a)}' + assert a.ndim >= 2, f'Only support tensor has dimension >= 2, but got {a.shape}' i, j = jnp.diag_indices(_min(a.shape[-2:])) - return JaxArray(a.at[..., i, j].set(val)) + a.value = a.value.at[..., i, j].set(val) # indexing funcs From c707dd56b3943eec0f62f8ddd3cebbc5821867b2 Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 21 Mar 2022 23:20:53 +0800 Subject: [PATCH 03/22] feat: add LengthDelay --- brainpy/math/delay_vars.py | 140 +++++++++++++++++++++----- brainpy/math/numpy_ops.py | 12 +-- brainpy/math/tests/test_delay_vars.py | 96 +++++++++++++----- 3 files changed, 188 insertions(+), 60 deletions(-) diff --git a/brainpy/math/delay_vars.py b/brainpy/math/delay_vars.py index 4c1079b9b..f9be0bf23 100644 --- a/brainpy/math/delay_vars.py +++ b/brainpy/math/delay_vars.py @@ -13,7 +13,7 @@ from brainpy import math as bm from brainpy.base.base import Base from brainpy.errors import UnsupportedError -from brainpy.tools.checking import check_float +from brainpy.tools.checking import check_float, check_integer from brainpy.tools.others import to_size __all__ = [ @@ -21,11 +21,12 @@ 'TimeDelay', 'FixedLenDelay', 'NeutralDelay', + 'LengthDelay', ] class AbstractDelay(Base): - def update(self, time, value): + def update(self, *args, **kwargs): raise NotImplementedError @@ -49,13 +50,13 @@ class TimeDelay(AbstractDelay): 1. the one-dimensional delay data - >>> delay = bm.TimeDelay(3, delay_len=1., dt=0.1, before_t0=lambda t: t) + >>> delay = bm.TimeDelay(bm.zeros(3), delay_len=1., dt=0.1, before_t0=lambda t: t) >>> delay(-0.2) [-0.2 -0.2 -0.2] 2. the two-dimensional delay data - >>> delay = bm.TimeDelay((3, 2), delay_len=1., dt=0.1, before_t0=lambda t: t) + >>> delay = bm.TimeDelay(bm.zeros((3, 2)), delay_len=1., dt=0.1, before_t0=lambda t: t) >>> delay(-0.6) [[-0.6 -0.6] [-0.6 -0.6] @@ -63,8 +64,8 @@ class TimeDelay(AbstractDelay): 3. the three-dimensional delay data - >>> delay = bm.TimeDelay((3, 2, 1), delay_len=1., dt=0.1, before_t0=lambda t: t) - >>> delay(-0.6) + >>> delay = bm.TimeDelay(bm.zeros((3, 2, 1)), delay_len=1., dt=0.1, before_t0=lambda t: t) + >>> delay(-0.8) [[[-0.8] [-0.8]] [[-0.8] @@ -74,7 +75,7 @@ class TimeDelay(AbstractDelay): Parameters ---------- - shape: int, sequence of int + inits: int, sequence of int The delay data shape. t0: float, int The zero time. @@ -107,7 +108,7 @@ class TimeDelay(AbstractDelay): def __init__( self, - shape: Union[int, Tuple[int, ...]], + inits: Union[bm.ndarray, jnp.ndarray], delay_len: Union[float, int], before_t0: Union[Callable, bm.ndarray, jnp.ndarray, float, int] = None, t0: Union[float, int] = 0., @@ -118,17 +119,20 @@ def __init__( ): super(TimeDelay, self).__init__(name=name) - # shape - self.shape = to_size(shape) + # dtype self.dtype = dtype + # shape + assert isinstance(inits, (bm.ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' + f'or jax.numpy.ndarray. But we got {type(inits)}') + self.shape = bm.asarray(inits).shape + # delay_len self.t0 = t0 self._dt = bm.get_dt() if dt is None else dt check_float(delay_len, 'delay_len', allow_none=False, allow_int=True, min_bound=0.) - self._delay_len = delay_len - self.delay_len = delay_len + self._dt - self.num_delay_step = int(bm.ceil(self.delay_len / self._dt).value) + self.delay_len = delay_len + self.num_delay_step = int(bm.ceil(self.delay_len / self._dt).value) + 1 # interp method if interp_method not in [_INTERP_LINEAR, _INTERP_ROUND]: @@ -151,19 +155,23 @@ def __init__( self._before_type = _FUNC_BEFORE elif isinstance(before_t0, (bm.ndarray, jnp.ndarray, float, int)): self._before_type = _DATA_BEFORE - try: - self._data[:] = before_t0 - except: - raise ValueError(f'Cannot set delay data by using "before_t0". ' - f'The delay data has the shape of ' - f'{((self.num_delay_step,) + self.shape)}, while ' - f'we got "before_t0" of {bm.asarray(before_t0).shape}. ' - f'They are not compatible. Note that the delay length ' - f'{self._delay_len} will automatically add a dt {self.dt} ' - f'to {self.delay_len}.') + self._data[:-1] = before_t0 + # try: + # pass + # except: + # raise ValueError(f'Cannot set delay data by using "before_t0". ' + # f'The delay data has the shape of ' + # f'{((self.num_delay_step,) + self.shape)}, while ' + # f'we got "before_t0" of {bm.asarray(before_t0).shape}. ' + # f'They are not compatible. Note that the delay length ' + # f'{self._delay_len} will automatically add a dt {self.dt} ' + # f'to {self.delay_len}.') else: - raise ValueError(f'"before_t0" does not support {type(before_t0)}: before_t0') + raise ValueError(f'"before_t0" does not support {type(before_t0)}') + # set initial data + self._data[-1] = inits + # interpolation function self.f = jnp.interp for dim in range(1, len(self.shape) + 1, 1): self.f = vmap(self.f, in_axes=(None, None, dim), out_axes=dim - 1) @@ -257,7 +265,7 @@ def update(self, time, value): self._idx.value = (self._idx + 1) % self.num_delay_step -def FixedLenDelay(shape: Union[int, Tuple[int, ...]], +def FixedLenDelay(inits: Union[bm.ndarray, jnp.ndarray], delay_len: Union[float, int], before_t0: Union[Callable, bm.ndarray, jnp.ndarray, float, int] = None, t0: Union[float, int] = 0., @@ -268,7 +276,7 @@ def FixedLenDelay(shape: Union[int, Tuple[int, ...]], warnings.warn('Please use "brainpy.math.TimeDelay" instead. ' '"brainpy.math.FixedLenDelay" is deprecated since version 2.1.2. ', DeprecationWarning) - return TimeDelay(shape=shape, + return TimeDelay(inits=inits, delay_len=delay_len, before_t0=before_t0, t0=t0, @@ -283,6 +291,84 @@ class NeutralDelay(TimeDelay): class LengthDelay(AbstractDelay): - pass + """Delay variable which has a fixed delay length. + """ + def __init__( + self, + inits: Union[bm.ndarray, jnp.ndarray], + delay_len: int, + delay_data: Union[bm.ndarray, jnp.ndarray, float, int] = None, + name: str = None, + dtype=None, + ): + super(LengthDelay, self).__init__(name=name) + # shape and dtype + assert isinstance(inits, (bm.ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' + f'or jax.numpy.ndarray. But we got {type(inits)}') + self.shape = inits.shape + self.dtype = dtype + + # delay_len + check_integer(delay_len, 'delay_len', allow_none=False, min_bound=0) + self.delay_len = delay_len + self.num_delay_step = delay_len + 1 + + # time variables + self._idx = bm.Variable(bm.asarray([0], dtype=bm.int_)) + + # delay data + self._data = bm.Variable(bm.zeros((self.num_delay_step,) + self.shape, dtype=dtype)) + if delay_data is None: + pass + elif isinstance(delay_data, (bm.ndarray, jnp.ndarray, float, int)): + self._data[:-1] = delay_data + else: + raise ValueError(f'"delay_data" does not support {type(delay_data)}') + + @property + def idx(self): + return self._idx + + @idx.setter + def idx(self, value): + raise ValueError('Cannot set "idx" by users.') + + @property + def data(self): + return self._data + + @data.setter + def data(self, value): + self._data[:-1] = value + + def _check_delay(self, delay_len, transforms): + if isinstance(delay_len, bm.ndarray): + delay_len = delay_len.value + if np.any(delay_len >= self.num_delay_step): + raise ValueError(f'\n' + f'!!! Error in {self.__class__.__name__}: \n' + f'The request delay length should be less than the ' + f'maximum delay {self.delay_len}. But we ' + f'got {delay_len}') + + def __call__(self, delay_len, indices=None): + # check + if check.is_checking(): + id_tap(self._check_delay, delay_len) + # the delay length + delay_idx = (self.idx[0] - delay_len - 1) % self.num_delay_step + if delay_idx.dtype not in [bm.int32, bm.int64]: + raise ValueError(f'"delay_len" must be integer, but we got {delay_len}') + # the delay data + if indices is None: + return self.data[delay_idx] + else: + return self.data[delay_idx, indices] + + def update(self, value): + if bm.shape(value) != self.shape: + raise ValueError(f'value shape should be {self.shape}, but we got {bm.shape(value)}') + self._data[self.idx[0]] = value + self._idx.value = (self._idx + 1) % self.num_delay_step diff --git a/brainpy/math/numpy_ops.py b/brainpy/math/numpy_ops.py index d0322dbcf..a7d1baa3b 100644 --- a/brainpy/math/numpy_ops.py +++ b/brainpy/math/numpy_ops.py @@ -79,7 +79,7 @@ 'setxor1d', 'tensordot', 'trim_zeros', 'union1d', 'unravel_index', 'unwrap', 'take_along_axis', # others - 'clip_by_norm', 'as_device_array', 'as_variable', 'as_jaxarray', 'as_numpy', + 'clip_by_norm', 'as_device_array', 'as_variable', 'as_numpy', ] _min = min @@ -89,6 +89,10 @@ # others # ------ +# def as_jax_array(tensor): +# return asarray(tensor) + + def as_device_array(tensor): if isinstance(tensor, JaxArray): return tensor.value @@ -111,10 +115,6 @@ def as_variable(tensor): return Variable(asarray(tensor)) -def as_jaxarray(tensor): - return asarray(tensor) - - def _remove_jaxarray(obj): if isinstance(obj, JaxArray): return obj.value @@ -1510,7 +1510,7 @@ def fill_diagonal(a, val): assert isinstance(a, JaxArray), f'Must be a JaxArray, but got {type(a)}' assert a.ndim >= 2, f'Only support tensor has dimension >= 2, but got {a.shape}' i, j = jnp.diag_indices(_min(a.shape[-2:])) - a.value = a.value.at[..., i, j].set(val) + a._value = a.value.at[..., i, j].set(val) # indexing funcs diff --git a/brainpy/math/tests/test_delay_vars.py b/brainpy/math/tests/test_delay_vars.py index 475651fc4..93eb58f64 100644 --- a/brainpy/math/tests/test_delay_vars.py +++ b/brainpy/math/tests/test_delay_vars.py @@ -5,63 +5,66 @@ import brainpy.math as bm -class TestFixedLenDelay(unittest.TestCase): +class TestTimeDelay(unittest.TestCase): def test_dim1(self): bm.enable_x64() # linear interp t0 = 0. - before_t0 = bm.repeat(bm.arange(11).reshape((-1, 1)), 10, axis=1) - delay = bm.TimeDelay(10, delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) - self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones(10) * 10)) - self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones(10) * 9.5)) + before_t0 = bm.repeat(bm.arange(10).reshape((-1, 1)), 10, axis=1) + delay = bm.TimeDelay(bm.zeros(10), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) + print(delay(t0 - 0.1)) + print(delay(t0 - 0.15)) + self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones(10) * 9.)) + self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones(10) * 8.5)) print() print(delay(t0 - 0.23)) print(delay(t0 - 0.23) - bm.ones(10) * 8.7) # self.assertTrue(bm.array_equal(delay(t0 - 0.23), bm.ones(10) * 8.7)) # round interp - delay = bm.TimeDelay(10, delay_len=1., t0=t0, dt=0.1, before_t0=before_t0, + delay = bm.TimeDelay(bm.zeros(10), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0, interp_method='round') - self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones(10) * 10)) - self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones(10) * 10)) - self.assertTrue(bm.array_equal(delay(t0 - 0.2), bm.ones(10) * 9)) + self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones(10) * 9)) + print(delay(t0 - 0.15)) + self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones(10) * 8)) + self.assertTrue(bm.array_equal(delay(t0 - 0.2), bm.ones(10) * 8)) def test_dim2(self): t0 = 0. - before_t0 = bm.repeat(bm.arange(11).reshape((-1, 1)), 10, axis=1) - before_t0 = bm.repeat(before_t0.reshape((11, 10, 1)), 5, axis=2) - delay = bm.TimeDelay((10, 5), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) - self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones((10, 5)) * 10)) - self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones((10, 5)) * 9.5)) + before_t0 = bm.repeat(bm.arange(10).reshape((-1, 1)), 10, axis=1) + before_t0 = bm.repeat(before_t0.reshape((10, 10, 1)), 5, axis=2) + delay = bm.TimeDelay(bm.zeros((10, 5)), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) + self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones((10, 5)) * 9)) + self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones((10, 5)) * 8.5)) # self.assertTrue(bm.array_equal(delay(t0 - 0.23), bm.ones((10, 5)) * 8.7)) def test_dim3(self): t0 = 0. - before_t0 = bm.repeat(bm.arange(11).reshape((-1, 1)), 10, axis=1) - before_t0 = bm.repeat(before_t0.reshape((11, 10, 1)), 5, axis=2) - before_t0 = bm.repeat(before_t0.reshape((11, 10, 5, 1)), 3, axis=3) - delay = bm.TimeDelay((10, 5, 3), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) - self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones((10, 5, 3)) * 10)) - self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones((10, 5, 3)) * 9.5)) + before_t0 = bm.repeat(bm.arange(10).reshape((-1, 1)), 10, axis=1) + before_t0 = bm.repeat(before_t0.reshape((10, 10, 1)), 5, axis=2) + before_t0 = bm.repeat(before_t0.reshape((10, 10, 5, 1)), 3, axis=3) + delay = bm.TimeDelay(bm.zeros((10, 5, 3)), delay_len=1., t0=t0, dt=0.1, before_t0=before_t0) + self.assertTrue(bm.array_equal(delay(t0 - 0.1), bm.ones((10, 5, 3)) * 9)) + self.assertTrue(bm.array_equal(delay(t0 - 0.15), bm.ones((10, 5, 3)) * 8.5)) # self.assertTrue(bm.array_equal(delay(t0 - 0.23), bm.ones((10, 5, 3)) * 8.7)) def test1(self): print() - delay = bm.TimeDelay(3, delay_len=1., dt=0.1, before_t0=lambda t: t) + delay = bm.TimeDelay(bm.zeros(3), delay_len=1., dt=0.1, before_t0=lambda t: t) print(delay(-0.2)) - delay = bm.TimeDelay((3, 2), delay_len=1., dt=0.1, before_t0=lambda t: t) + delay = bm.TimeDelay(bm.zeros((3, 2)), delay_len=1., dt=0.1, before_t0=lambda t: t) print(delay(-0.6)) - delay = bm.TimeDelay((3, 2, 1), delay_len=1., dt=0.1, before_t0=lambda t: t) + delay = bm.TimeDelay(bm.zeros((3, 2, 1)), delay_len=1., dt=0.1, before_t0=lambda t: t) print(delay(-0.8)) def test_current_time2(self): print() - delay = bm.TimeDelay(3, delay_len=1., dt=0.1, before_t0=lambda t: t) + delay = bm.TimeDelay(bm.zeros(3), delay_len=1., dt=0.1, before_t0=lambda t: t) print(delay(0.)) - before_t0 = bm.repeat(bm.arange(11).reshape((-1, 1)), 10, axis=1) - before_t0 = bm.repeat(before_t0.reshape((11, 10, 1)), 5, axis=2) - delay = bm.TimeDelay((10, 5), delay_len=1., dt=0.1, before_t0=before_t0) + before_t0 = bm.repeat(bm.arange(10).reshape((-1, 1)), 10, axis=1) + before_t0 = bm.repeat(before_t0.reshape((10, 10, 1)), 5, axis=2) + delay = bm.TimeDelay(bm.zeros((10, 5)), delay_len=1., dt=0.1, before_t0=before_t0) print(delay(0.)) # def test_prev_time_beyond_boundary(self): @@ -69,3 +72,42 @@ def test_current_time2(self): # delay = bm.FixedLenDelay(3, delay_len=1., dt=0.1, before_t0=lambda t: t) # delay(-1.2) + +class TestLengthDelay(unittest.TestCase): + def test1(self): + dim = 3 + delay = bm.LengthDelay(bm.zeros(dim), 10) + print(delay(1)) + self.assertTrue(bm.array_equal(delay(1), bm.zeros(dim))) + + delay = bm.jit(delay) + print(delay(1)) + self.assertTrue(bm.array_equal(delay(1), bm.zeros(dim))) + + def test2(self): + dim = 3 + delay = bm.LengthDelay(bm.zeros(dim), 10, delay_data=bm.arange(1, 11).reshape((10, 1))) + print(delay(0)) + self.assertTrue(bm.array_equal(delay(0), bm.zeros(dim))) + print(delay(1)) + self.assertTrue(bm.array_equal(delay(1), bm.ones(dim) * 10)) + + delay = bm.jit(delay) + print(delay(0)) + self.assertTrue(bm.array_equal(delay(0), bm.zeros(dim))) + print(delay(1)) + self.assertTrue(bm.array_equal(delay(1), bm.ones(dim) * 10)) + + def test3(self): + dim = 3 + delay = bm.LengthDelay(bm.zeros(dim), 10, delay_data=bm.arange(1, 11).reshape((10, 1))) + print(delay(bm.asarray([1, 2, 3]), + bm.arange(3))) + # self.assertTrue(bm.array_equal(delay(0), bm.zeros(dim))) + + delay = bm.jit(delay) + print(delay(bm.asarray([1, 2, 3]), + bm.arange(3))) + # self.assertTrue(bm.array_equal(delay(1), bm.ones(dim) * 10)) + + From 509243a9e7259e45e222fdaa04e337d2bd417ff0 Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 21 Mar 2022 23:21:47 +0800 Subject: [PATCH 04/22] fix bug --- brainpy/dyn/neurons/rate_models.py | 2 +- brainpy/nn/base.py | 2 +- examples/simulation/COBA_for_benchmark.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/brainpy/dyn/neurons/rate_models.py b/brainpy/dyn/neurons/rate_models.py index 8a11af87c..39b283f1b 100644 --- a/brainpy/dyn/neurons/rate_models.py +++ b/brainpy/dyn/neurons/rate_models.py @@ -211,7 +211,7 @@ def __init__(self, # variables self.w = bm.Variable(bm.zeros(self.num)) self.V = bm.Variable(bm.zeros(self.num)) - self.Vdelay = bm.TimeDelay(self.num, self.delay, interp_method='round') + self.Vdelay = bm.TimeDelay(self.V, self.delay, interp_method='round') self.input = bm.Variable(bm.zeros(self.num)) # integral diff --git a/brainpy/nn/base.py b/brainpy/nn/base.py index 4bf5d5ddc..adf4b781d 100644 --- a/brainpy/nn/base.py +++ b/brainpy/nn/base.py @@ -1012,7 +1012,7 @@ def initialize(self, num_batch: int): if not self._is_fb_initialized: if len(self.fb_senders) > 0: fb_sizes = dict() - for sender, _ in self.fb_senders: + for sender in self.fb_senders.keys(): fb_sizes[sender] = sender.output_shape self.set_feedforward_shapes(fb_sizes) diff --git a/examples/simulation/COBA_for_benchmark.py b/examples/simulation/COBA_for_benchmark.py index bde2c29ed..c1b9c50d3 100644 --- a/examples/simulation/COBA_for_benchmark.py +++ b/examples/simulation/COBA_for_benchmark.py @@ -3,7 +3,7 @@ import brainpy as bp import brainpy.math as bm -bp.math.set_platform('gpu') +bp.math.set_platform('cpu') class ExpCOBA(bp.dyn.TwoEndConn): From 4bf8ac219e66cca81d542c711f2cf21871cdcbfc Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 10:37:46 +0800 Subject: [PATCH 05/22] feat: improve analysis output --- brainpy/analysis/lowdim/lowdim_bifurcation.py | 32 ++++++++++--------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/brainpy/analysis/lowdim/lowdim_bifurcation.py b/brainpy/analysis/lowdim/lowdim_bifurcation.py index 347e2878e..43bb886fc 100644 --- a/brainpy/analysis/lowdim/lowdim_bifurcation.py +++ b/brainpy/analysis/lowdim/lowdim_bifurcation.py @@ -393,25 +393,27 @@ def plot_limit_cycle_by_sim(self, duration=100, with_plot=True, with_return=Fals # visualization if with_plot: if plot_style is None: plot_style = dict() - fmt = plot_style.pop('fmt', '.') + fmt = plot_style.pop('fmt', '*') if len(self.target_par_names) == 2: - for i, var in enumerate(self.target_var_names): - pyplot.figure(var) - pyplot.plot(ps_limit_cycle[0], ps_limit_cycle[1], vs_limit_cycle[i]['max'], - **plot_style, label='limit cycle (max)') - pyplot.plot(ps_limit_cycle[0], ps_limit_cycle[1], vs_limit_cycle[i]['min'], - **plot_style, label='limit cycle (min)') - pyplot.legend() + if len(ps_limit_cycle[0]): + for i, var in enumerate(self.target_var_names): + pyplot.figure(var) + pyplot.plot(ps_limit_cycle[0], ps_limit_cycle[1], vs_limit_cycle[i]['max'], + **plot_style, label='limit cycle (max)') + pyplot.plot(ps_limit_cycle[0], ps_limit_cycle[1], vs_limit_cycle[i]['min'], + **plot_style, label='limit cycle (min)') + pyplot.legend() elif len(self.target_par_names) == 1: - for i, var in enumerate(self.target_var_names): - pyplot.figure(var) - pyplot.plot(ps_limit_cycle[0], vs_limit_cycle[i]['max'], fmt, - **plot_style, label='limit cycle (max)') - pyplot.plot(ps_limit_cycle[0], vs_limit_cycle[i]['min'], fmt, - **plot_style, label='limit cycle (min)') - pyplot.legend() + if len(ps_limit_cycle[0]): + for i, var in enumerate(self.target_var_names): + pyplot.figure(var) + pyplot.plot(ps_limit_cycle[0], vs_limit_cycle[i]['max'], fmt, + **plot_style, label='limit cycle (max)') + pyplot.plot(ps_limit_cycle[0], vs_limit_cycle[i]['min'], fmt, + **plot_style, label='limit cycle (min)') + pyplot.legend() else: raise errors.AnalyzerError From af25d58077a5ac46c90a8df5e7993645746224c7 Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 14:27:16 +0800 Subject: [PATCH 06/22] feat: add more input functions --- brainpy/inputs/currents.py | 184 +++++++++++ docs/tutorial_toolbox/inputs.ipynb | 507 +++++++++++++++++++++-------- 2 files changed, 559 insertions(+), 132 deletions(-) diff --git a/brainpy/inputs/currents.py b/brainpy/inputs/currents.py index a5de05025..094b6f91d 100644 --- a/brainpy/inputs/currents.py +++ b/brainpy/inputs/currents.py @@ -3,12 +3,17 @@ import numpy as np from brainpy import math as bm +from brainpy.tools.checking import check_float, check_integer __all__ = [ 'section_input', 'constant_input', 'constant_current', 'spike_input', 'spike_current', 'ramp_input', 'ramp_current', + 'wiener_process', + 'ou_process', + 'sinusoidal_input', + 'square_input', ] @@ -200,3 +205,182 @@ def ramp_input(c_start, c_end, duration, t_start=0, t_end=None, dt=None): ramp_current = ramp_input + +def wiener_process(duration, dt=None, n=1, t_start=0., t_end=None, seed=None): + """Stimulus sampled from a Wiener process, i.e. + drawn from standard normal distribution N(0, sqrt(dt)). + + Parameters + ---------- + duration: float + The input duration. + dt: float + The numerical precision. + n: int + The variable number. + t_start: float + The start time. + t_end: float + The end time. + seed: int + The noise seed. + """ + dt = bm.get_dt() if dt is None else dt + check_float(dt, 'dt', allow_none=False, min_bound=0.) + check_integer(n, 'n', allow_none=False, min_bound=0) + rng = bm.random.RandomState(seed) + t_end = duration if t_end is None else t_end + i_start = int(t_start / dt) + i_end = int(t_end / dt) + noises = rng.standard_normal((i_end - i_start, n)) * bm.sqrt(dt) + currents = bm.zeros((int(duration / dt), n)) + currents[i_start: i_end] = noises + return currents + + +def ou_process(mean, sigma, tau, duration, dt=None, n=1, t_start=0., t_end=None, seed=None): + r"""Ornstein–Uhlenbeck input. + + .. math:: + + dX = (mu - X)/\tau * dt + \sigma*dW + + Parameters + ---------- + mean: float + Drift of the OU process. + sigma: float + Standard deviation of the Wiener process, i.e. strength of the noise. + tau: float + Timescale of the OU process, in ms. + duration: float + The input duration. + dt: float + The numerical precision. + n: int + The variable number. + t_start: float + The start time. + t_end: float + The end time. + + """ + dt = bm.get_dt() if dt is None else dt + dt_sqrt = bm.sqrt(dt) + check_float(dt, 'dt', allow_none=False, min_bound=0.) + check_integer(n, 'n', allow_none=False, min_bound=0) + rng = bm.random.RandomState(seed) + x = bm.Variable(bm.ones(n) * mean) + + def _f(t): + x.value = x + dt * ((mean - x) / tau) + sigma * dt_sqrt * rng.standard_normal(n) + + f = bm.make_loop(_f, dyn_vars=[x, rng], out_vars=x) + noises = f(bm.arange(t_start, t_end, dt)) + + t_end = duration if t_end is None else t_end + i_start = int(t_start / dt) + i_end = int(t_end / dt) + currents = bm.zeros((int(duration / dt), n)) + currents[i_start: i_end] = noises + return currents + + +def sinusoidal_input(amplitude, frequency, duration, dt=None, t_start=0., t_end=None, dc_bias=False): + """Sinusoidal input. + + Parameters + ---------- + amplitude: float + Amplitude of the sinusoid. + frequency: float + Frequency of the sinus oscillation, in Hz + duration: float + The input duration. + t_start: float + The start time. + t_end: float + The end time. + dt: float + The numerical precision. + dc_bias: bool + Whether the sinusoid oscillates around 0 (False), or + has a positive DC bias, thus non-negative (True). + """ + dt = bm.get_dt() if dt is None else dt + check_float(dt, 'dt', allow_none=False, min_bound=0.) + if t_end is None: + t_end = duration + times = bm.arange(0, t_end-t_start, dt) + start_i = int(t_start/dt) + end_i = int(t_end/dt) + sin_inputs = amplitude * bm.sin(2 * bm.pi * times * (frequency / 1000.0)) + if dc_bias: + sin_inputs += amplitude + currents = bm.zeros(int(duration / dt)) + currents[start_i:end_i] = sin_inputs + return currents + + +def _square(t, duty=0.5): + t, w = np.asarray(t), np.asarray(duty) + w = np.asarray(w + (t - t)) + t = np.asarray(t + (w - w)) + if t.dtype.char in ['fFdD']: + ytype = t.dtype.char + else: + ytype = 'd' + + y = np.zeros(t.shape, ytype) + + # width must be between 0 and 1 inclusive + mask1 = (w > 1) | (w < 0) + np.place(y, mask1, np.nan) + + # on the interval 0 to duty*2*pi function is 1 + tmod = np.mod(t, 2 * np.pi) + mask2 = (1 - mask1) & (tmod < w * 2 * np.pi) + np.place(y, mask2, 1) + + # on the interval duty*2*pi to 2*pi function is + # (pi*(w+1)-tmod) / (pi*(1-w)) + mask3 = (1 - mask1) & (1 - mask2) + np.place(y, mask3, -1) + return y + + +def square_input(amplitude, frequency, duration, dt=None, dc_bias=False, t_start=None, t_end=None): + """Oscillatory square input. + + Parameters + ---------- + amplitude: float + Amplitude of the square oscillation. + frequency: float + Frequency of the square oscillation, in Hz. + duration: float + The input duration. + t_start: float + The start time. + t_end: float + The end time. + dt: float + The numerical precision. + dc_bias: bool + Whether the sinusoid oscillates around 0 (False), or + has a positive DC bias, thus non-negative (True). + """ + dt = bm.get_dt() if dt is None else dt + check_float(dt, 'dt', allow_none=False, min_bound=0.) + if t_end is None: + t_end = duration + times = bm.arange(0, t_end - t_start, dt) + currents = bm.zeros(int(duration / dt)) + start_i = int(t_start/dt) + end_i = int(t_end/dt) + sin_inputs = amplitude * _square(2 * bm.pi * times * (frequency / 1000.0)) + if dc_bias: + sin_inputs += amplitude + currents[start_i:end_i] = sin_inputs + return currents + diff --git a/docs/tutorial_toolbox/inputs.ipynb b/docs/tutorial_toolbox/inputs.ipynb index 25f7db839..a201c8f03 100644 --- a/docs/tutorial_toolbox/inputs.ipynb +++ b/docs/tutorial_toolbox/inputs.ipynb @@ -19,8 +19,42 @@ }, { "cell_type": "markdown", - "id": "f9c7d3ca", - "metadata": {}, + "source": [ + "In this section, we are going to talk about stimulus inputs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "source": [ + "import brainpy as bp\n", + "import brainpy.math as bm" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Inputs in ``brainpy.dyn.DSRunner``" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", "source": [ "In brain dynamics simulation, various inpus are usually given to different units of the dynamical system. In BrainPy, `inputs` can be specified to [runners for dynamical systems](runners.ipynb). The aim of ``inputs`` is to mimic the input operations in experiments like Transcranial Magnetic Stimulation (TMS) and patch clamp recording.\n", "\n", @@ -29,12 +63,16 @@ "- ``value`` is the input value. It can be a scalar, a tensor, or a iterable object/function.\n", "- ``type`` is the type of the input value. It support two types of input: ``fix`` and ``iter``. The first one means that the data is static; the second one denotes the data can be iterable, no matter whether the input value is a tensor or a function. The `iter` type must be explicitly stated. \n", "- ``operation`` is the input operation on the target variable. It should be set as one of `{ + , - , * , / , = }`, and if users do not provide this item explicitly, it will be set to '+' by default, which means that the target variable will be updated as ``val = val + input``. " - ] + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } }, { "cell_type": "markdown", - "id": "3451b77b", - "metadata": {}, "source": [ "Users can also give multiple inputs for different target variables, like:\n", "\n", @@ -44,11 +82,17 @@ " (target2, value2, [type2, op2]),\n", " ... ]\n", "```" - ] + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } }, { "cell_type": "markdown", - "id": "e377d41a", + "id": "f9c7d3ca", "metadata": {}, "source": [ "The mechanism of ``inputs`` is the same as [``monitors``](monitors.ipynb). BrainPy finds the target variables for input operations through [the absolute or relative path](../tutorial_math/base.ipynb). " @@ -56,7 +100,7 @@ }, { "cell_type": "markdown", - "id": "844fcb78", + "id": "3451b77b", "metadata": {}, "source": [ "## Input construction functions " @@ -64,7 +108,7 @@ }, { "cell_type": "markdown", - "id": "a4ff6914", + "id": "e377d41a", "metadata": {}, "source": [ "Like electrophysiological experiments, model simulation also needs various kind of inputs. BrainPy provide several convenient input functions to help users construct input currents. " @@ -72,32 +116,44 @@ }, { "cell_type": "markdown", - "id": "64f9a99c", + "id": "844fcb78", "metadata": {}, "source": [ "### 1\\. ``brainpy.inputs.section_input()``\n", "\n", - "[brainpy.inputs.section_input()](../apis/simulation/generated/brainpy.simulation.inputs.section_input.rst) is an updated function of previous `brainpy.inputs.constant_input()` (see below). \n", + "[brainpy.inputs.section_input()](../apis/inputs/generated/brainpy.inputs.section_input.rst) is an updated function of previous `brainpy.inputs.constant_input()` (see below).\n", "\n", "Sometimes, we need input currents with different values in different periods. For example, if you want to get an input that is 0 in the first 100 ms, 1 in the next 300 ms, and 0 again from the last 100 ms, you can define:" ] }, { "cell_type": "code", - "execution_count": 29, - "id": "078fbd0d", - "metadata": {}, - "outputs": [], + "id": "a4ff6914", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "source": [ "current1, duration = bp.inputs.section_input(values=[0, 1., 0.],\n", " durations=[100, 300, 100],\n", " return_length=True,\n", " dt=0.1)" + ], + "execution_count": 2, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + } ] }, { "cell_type": "markdown", - "id": "579e8b2d", + "id": "64f9a99c", "metadata": {}, "source": [ "Where `values` receive a list/arrray of the current values in each section and `durations` receives a list/array of the duration of each section. The function returns a tensor as the current, the length of which is `duration`$/\\mathrm{d}t$ (if not specified, $\\mathrm{d}t=0.1 \\mathrm{ms}$). We can visualize the current input by:" @@ -105,8 +161,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "54aec8c9", + "execution_count": 3, + "id": "078fbd0d", "metadata": {}, "outputs": [], "source": [ @@ -114,7 +170,7 @@ "import matplotlib.pyplot as plt\n", "\n", "def show(current, duration, title):\n", - " ts = np.arange(0, duration, 0.1)\n", + " ts = np.arange(0, duration, bm.get_dt())\n", " plt.plot(ts, current)\n", " plt.title(title)\n", " plt.xlabel('Time [ms]')\n", @@ -123,59 +179,56 @@ ] }, { - "cell_type": "code", - "execution_count": 31, - "id": "1a18a549", + "cell_type": "markdown", + "id": "579e8b2d", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "show(current1, duration, 'values=[0, 1, 0], durations=[100, 300, 100]')" ] }, { "cell_type": "markdown", - "id": "6b1eee02", - "metadata": {}, + "id": "54aec8c9", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 2\\. ``brainpy.inputs.constant_input()``" ] }, { "cell_type": "markdown", - "id": "26708359", - "metadata": {}, + "id": "1a18a549", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "[brainpy.inputs.constant_input()](../apis/simulation/generated/brainpy.simulation.inputs.constant_input.rst) function helps users to format constant currents in several periods.\n", + "[brainpy.inputs.constant_input()](../apis/inputs/generated/brainpy.inputs.constant_input.rst) function helps users to format constant currents in several periods.\n", "\n", "We can generate the above input current with `constant_input()` by:" ] }, { "cell_type": "code", - "execution_count": 32, - "id": "8ea6dea6", - "metadata": {}, - "outputs": [], + "id": "6b1eee02", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "source": [ "current2, duration = bp.inputs.constant_input([(0, 100), (1, 300), (0, 100)])" - ] + ], + "execution_count": 4, + "outputs": [] }, { "cell_type": "markdown", - "id": "6cc74d90", + "id": "26708359", "metadata": {}, "source": [ "Where each tuple in the list contains the value and duration of the input in this section." @@ -183,20 +236,16 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "e862ebad", + "execution_count": 5, + "id": "8ea6dea6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "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\n" }, + "metadata": {}, "output_type": "display_data" } ], @@ -206,7 +255,7 @@ }, { "cell_type": "markdown", - "id": "067aae19", + "id": "6cc74d90", "metadata": {}, "source": [ "### 3\\. ``brainpy.inputs.spike_input()``" @@ -214,10 +263,14 @@ }, { "cell_type": "markdown", - "id": "e6ea2868", - "metadata": {}, + "id": "e862ebad", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "[brainpy.inputs.spike_input()](../apis/simulation/generated/brainpy.simulation.inputs.spike_input.rst) constructs an input containing a series of short-time spikes. It receives the following settings:\n", + "[brainpy.inputs.spike_input()](../apis/inputs/generated/brainpy.inputs.spike_input.rst) constructs an input containing a series of short-time spikes. It receives the following settings:\n", "\n", "- `sp_times` : The spike time-points. Must be an iterable object. For example, list, tuple, or arrays.\n", "- `sp_lens` : The length of each point-current, mimicking the spike durations. It can be a scalar float to specify the unified duration. Or, it can be list/tuple/array of time lengths with the length same with `sp_times`. \n", @@ -228,7 +281,7 @@ }, { "cell_type": "markdown", - "id": "146ebc19", + "id": "067aae19", "metadata": {}, "source": [ "For example, if you want to generate a spike train at 10 ms, 20 ms, 30 ms, 200 ms, 300 ms, where each spike lasts 1 ms and the average value for each spike is 0.5, then you can define the current by:" @@ -236,23 +289,12 @@ }, { "cell_type": "code", - "execution_count": 34, - "id": "1eb035a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "id": "e6ea2868", + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, "source": [ "current3 = bp.inputs.spike_input(\n", " sp_times=[10, 20, 30, 200, 300],\n", @@ -261,11 +303,22 @@ " duration=400.)\n", "\n", "show(current3, 400, 'Spike Input Example')" + ], + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } ] }, { "cell_type": "markdown", - "id": "68262531", + "id": "146ebc19", "metadata": {}, "source": [ "### 4\\. ``brainpy.inputs.ramp_input()``" @@ -273,10 +326,14 @@ }, { "cell_type": "markdown", - "id": "ce29ec3c", - "metadata": {}, + "id": "1eb035a2", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "[brainpy.inputs.ramp_input()](../apis/simulation/generated/brainpy.simulation.inputs.ramp_input.rst) mimics a ramp or a step current to the input of the circuit. It receives the following settings:\n", + "[brainpy.inputs.ramp_input()](../apis/inputs/generated/brainpy.inputs.ramp_input.rst) mimics a ramp or a step current to the input of the circuit. It receives the following settings:\n", "\n", "- `c_start` : The minimum (or maximum) current size.\n", "- `c_end` : The maximum (or minimum) current size.\n", @@ -290,7 +347,7 @@ }, { "cell_type": "markdown", - "id": "7435a038", + "id": "68262531", "metadata": {}, "source": [ "In the first example, we increase the current size from 0. to 1. between the start time (0 ms) and the end time (500 ms). " @@ -298,29 +355,29 @@ }, { "cell_type": "code", - "execution_count": 35, - "id": "a667a133", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "id": "ce29ec3c", + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, "source": [ "duration = 500\n", "current4 = bp.inputs.ramp_input(0, 1, duration)\n", "\n", "show(current4, duration, r'$c_{start}$=0, $c_{end}$=%d, duration, '\n", " r'$t_{start}$=0, $t_{end}$=None' % (duration))" + ], + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } ] }, { @@ -333,20 +390,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "id": "d0caf6ea", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEYCAYAAABRB/GsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAArt0lEQVR4nO3dd5wV9fX/8dehioIUKSJdRRSRzmKJCZbEXhJN1EgHS6LGxBhDojGamF++lhgTo2KhE0GssZfEllhYFukguKDAAlIE6S7s7vn9MYNelmX37u6dnd1738/H4z723pm5M+czO/eeKZ97xtwdERHJXLXiDkBEROKlRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRFI7MxsvJndUcXLXGBmA6pymSLVlRJBTMysmZk9a2bbzWy5mf047pjKw8yuNbMcM8s3s/Fxx1MaM/vMzE5PHObux7r721UYw9tm9pWZbQsfi4uN3+/2kIptxcxWmVnPFDSlwsraZtJ9HZhZ53AbmJwwrNR2VdX3RJ0oZipJeQDYBbQCegIvmdkcd18Qa1TJWw3cAZwBNIgrCDOr4+4FcS2/nK5198f2M6607aFS24qZNQdaAosqF36llbXNpPs6eACYUcKw0tpVNd8T7p4xD+AyYCawGVgKDIgpjoPCf+5RCcMmAf9XA9tyBzC+nO/pBXwEbAWeAKYCdySMd+DIhNfji43/DPg1MBfIJ9ihGRWuh63AQuD7Ceu1CNgJbANuSpjH6eHzY4C3gS+BBcD5xZZ1Y7iszWG8B1RgPb0NjCzv9lDZbQU4Mmx7Ydj+L4A6cWwrpW0z6b4OgEuBacBtwOSy2pzM+FQ+MubUkJn9ErgFuAJoClxI8CFP9XJeNLMv9/N4MZzsKKDQ3ZckvHUOcGySy4isLUnGX5n51wOeI9igmwFPAhdVYFaXAecATTw4IlgKnAw0Bm4HJptZa3cfBKwAznP3hu5+V7F46gIvAK8T7DFeB/zTzLokTPYj4EygE9AdGJrw/vKsrz+b2QYze6/Y9YnStodKbSvunkuQyJ4K23+Ip/gIKkXbTI1bB8m228wOBv4A/LLYLMpqV6XaXR4ZcWrIzFoAvwdOdvc54eB5+5n2FOBTd/8syXnvNb27n5vE2xoS7F0m2gw0SmJ5SbclWWb2WyDb3f+dZPyVcTxQF7jPg12cp8zshgrM5+/uvnLPC3d/MmHcE2b2GyAL+FcS8TQk2MsqAt4MP8SXEey97VnWagAze4HgEH3PcpNdX78mOFLZRbB3+IKZ9XT3pZS+PVR4W0nQA5hd2gTl2e4ruM2XJfZ1kIwKflb+CIxx95Vmlji8rHalot1JyZQjgtOBeQlfnKUZDliZUwFmVqs80yfYBhxcbNjBBKc1ylKetiTrWCqZTMrhMGBVmAT2WF6B+axMfGFmg81s9p49MqAb0DzJeFaGSSAxnjYJrz9PeL6D4ANaLu4+3d23unu+u08A3gPODkeXtj1UZlvZoyfBnmRpktqOK7HNl6U6rINklOuzEl6cPh34awmjy2pXKtqdlExJBM0Izv/uxczqmtkkM3vfzKab2RDgPGCcmQ0Op/mjBT0+Pjazb4XDPjKzh4DcEqZ/xb7pGVL88Uq46CVAHTPrnBBOD4Lz0xVqS0KbBpnZmxb0zjglHJZtZveGX5Q/C4f9JGz3GKC1u68tR/yVsQZoY3vvGrUvNs0O4MCE14eWMJ+vE4mZdQAeBa4FDnH3JsB8vvmyKq3W+mqgXfgFlxjPqlLe87VKrC9PiK+07aEy28qeL+5uhHvDJWzzrc3sfBK244i2+bJU2ToIh+3zOQmHp/qzMgDoCKwws88JTlFdZGYfJdGuSrW7XKrygklcD+BEgkOqHgQfvs4EFwhPBB4IpzGCxPhWsfceFP7tR5DVmxPsjTYrafpyxDQVmEJwQeikML5jE8aPp4SLsPtrSziuG/B4OPxg4KUw3qUEh5NNgdfC6aaG02UB/6lA/HWAA4A/E5zvP4CEC3ClxF+P4Jz99eE8fgDsZu+Lwe8RXCSsTXBufif7Xiw+PeF1V+AroEv4nmFAAeHFWeBD4MpicXxGsKdWL1w/owhOWQ0g2OM6ej/Luo3wYl851lUTgp4yB4RtvhzYDnRJZnuo6LayZ/slSDptE7afr7f58O9e2zHRbfNlbTNVtQ72+ZyEw1P+WSHYoTk04XEP8BTQIsl2lTo+VY+MOCJw9/cJeiq8SPAhf5ag+9pMYKuZTSU4TD8S+Lp/t5m1BEab2VsEe5wrCS4WPu7uG4tPX04/DWNYR/CP/onv3SWsHcEXYrJtAfg+wZfiW8DzBBtNd2Cqu28FWgDLwuke8WBLK6Jip4VuIfiCHgUMDJ/fkkT8uwi+/IcCm4BLgGeKTXY9wV7nlwRfms+VFoi7LwT+AnwArAWOK7bsPwO3hKeNbiwhnvOBs4ANwIPAYHf/uLRlllNdgv/Z+nAZ1wEXunvitlPa9lChbQXA3bcDo4GFZpbHvts8JGzHEW/zZW0zVbUOSvqcQASfFXff4e6f73kQnO75yt3XJ9mussanxJ49goxkZge6+w4za0JwUfGvQEd3vy8cfz/B3sKrZjaW4B9xLJDn7k+Z2YWJ06cwrnoE5zO7u/vucrzvL8Cz7v6/8HUdgtMlK939aTO7hGCvrgvwiru/ZsGPW95y9zFxxy/lV951XXybd/fvJG7HcW3zlVGBdbDP58TdC8zs51TxZ6W6yIheQ6UYa2btCPbYbiU4ZXGHmXV0958T7GHcE24UxxL0Jb+UYG8cgnN4idOnRLiXekwF3vowQZt2E5xuGUywd/xCOL5X+DyboHvlCoIuk3+vdNAJKhG/lFMF1nXxbR4StmNi2uYrowLroKTPyefE8FmpLjL6iEBERDKn15CIiOyHEoGISIZTIhARyXA17mJx8+bNvWPHjnGHISJSo8ycOXODu7coaVyNSwQdO3YkJycn7jBERGoUM9tvKRedGhIRyXBKBCIiGU6JQEQkwykRiIhkOCUCEZEMF1kiMLOxZrbOzObvZ7yZ2d/NLNfM5ppZ76hiERGR/YvyiGA8QS35/TmLoJZ+Z+BK4KEIYxERkf2ILBG4+7vAxlImuQCY6IEPgSZm1jqqeEQkffx74VoWrdkSdxhpI85rBG3Y+76zeex9n9ivmdmV4S3lctavX1/SJCKSIZ6emcfIiTk88u6yuENJG3EmgpJufl1iTWx3f8Td+7p73xYtSvyFtIhkgDcWruWmp+cCUFikEvqpEmeJiTyC28vt0ZbgRuIiIvv4cNkXXPP4R3Q77GDWbsmPO5y0EucRwfPA4LD30PHAZndfE2M8IlJNzV+1mZETcmjf7EDGD8uiQb3acYeUViI7IjCzKcAAoHl4w+jfE9weD3cfDbxMcPPsXGAHMCyqWESk5lq2fhtDxmbTuEFdJo3IoulB9eIOKe1Elgjc/bIyxjtwTVTLF5Gab83mnQwakw3ApBFZtG7cIOaI0lONK0MtIplh0/ZdDB6Tzeadu5l65fEc3qLhXuN1qTh1lAhEpNrZnl/A0PEzWL5xBxOGZdGtTeO4Q0prqjUkItVKfkEhV02ayfxVm/nHZb044YhD4g4p7SkRiEi1UVjk/OKJ2fwvdwN3XtSd7x17aInTlfQjJKk4JQIRqRbcnVuem8fL8z7nlnOO4eI+beMOKWMoEYhItXD3a4uZkr2Sa045gpEnHx53OBlFiUBEYvfou8t48O2l/Lh/e278Xpek3hP0QJdUUCIQkVhNy1nJn15exDnHteaPF3TDTFcAqpoSgYjE5rUFnzPq6bmc3Lk5917Sg9q1lATioEQgIrH4YOkXXDdlFt3bNmH0wD7Ur1OO+kHKFymlRCAiVW5e3maumJhDh2YHMm5oPw6qr9+2xkmJQESq1NL12xgybk8Ruf4qIlcNKBGISJVZ/eVOBj02nVoGk0f259DGB8QdkqBEICJVZOP2XQwaM52tXxUwflgWnZofVKn5qfNo6ujEnIhEblt+AcPGZZO3aScTh6uIXHWjRCAikQqKyOUwf/UWHh7Yh/6Hq4hcdaNTQyISmcIi5/ops3kv9wvuvrg7p3dtlZL5qvdoaikRiEgk3J3fPjOPVxd8zq3nduUHvVVErrpSIhCRSNz56mKeyFnJdaceyfBvdYo7HCmFEoGIpNzD7yxl9DtLGXh8e2747lHRLETdhlJGiUBEUuqJGSv48ysfc2731tx+vorI1QRKBCKSMq/OX8NvnpnHt49qwb0/6qkicjWEEoGIpMT7uRv42ZTZ9GjXhNEDe1OvTnRfLzrKSC0lAhGptDkrv+SKiTl0an4Q44b248B6+olSTaJEICKVkrtuG0PHZdP0oHpMHJFFkwNVRK6mUSIQkQpb9eVOBo2ZTu1atZg8oj+tDlYRuZpIiUBEKuSLbfkMGjOdbfkFTByeRcdKFpErL1f/0ZRRIhCRctuWX8DQcTNYtWknY4b0o+thB8cdklSCruiISLl8tbuQKybksHDNFh4d3IesTs2qPAb1GUotHRGISNIKCov42ZRZfLDsC/7ywx6cenRqishJvJQIRCQp7s5vn53H6wvX8vvzunJhrzZxhyQpEmkiMLMzzWyxmeWa2agSxjc2sxfMbI6ZLTCzYVHGIyIV93+vfMy0nDx+dlpnhp2kInLpJLJEYGa1gQeAs4CuwGVm1rXYZNcAC929BzAA+IuZqROySDXz0NtLefjdZQw+oQO/OL1z3OEA4Oo0lDJRHhFkAbnuvszddwFTgQuKTeNAIwt+L94Q2AgURBiTiJTTlOwV3Pnqx5zf4zBuO+9YlXdIQ1EmgjbAyoTXeeGwRP8AjgFWA/OA6929qPiMzOxKM8sxs5z169dHFa+IFPPKvDXc/Ow8BnRpwT0/7EEtFZFLS1EmgpK2mOIHc2cAs4HDgJ7AP8xsnw7J7v6Iu/d1974tWrRIdZwiUoL/fbKB66fOplf7pjx0eZ9Ii8iVlw5KUivK/2we0C7hdVuCPf9Ew4BnPJALfAocHWFMIpKE2Su/5MpJORze4iDGDulHg3q14w5JIhRlIpgBdDazTuEF4EuB54tNswI4DcDMWgFdgGURxiQiZchdt5Wh47Jp3rA+E4dn0fjAunGHJBGL7JfF7l5gZtcCrwG1gbHuvsDMrg7Hjwb+CIw3s3kEp5J+7e4boopJREqXt2kHAx/Lpm7toIhcy2pcRE69hlIn0hIT7v4y8HKxYaMTnq8GvhdlDCKSnA3b8hk8JpvtuwqYdtUJtD/kwLhDkipSfa7+iEhstn61m6Hjslm9eSfjhvbjmNYqIpdJlAhEMtxXuwsZOSGHj9ds5aHL+9C3Y9UXkSsvU9m5lFL1UZEMVlBYxHVTZpH92Ubuu6QnpxzdMu6QJAY6IhDJUEVFzqhn5vHGwrXcdt6xXNBTReQylRKBSAZyd/7fy4t4amYePz+9M0NO7Bh3SBIjJQKRDPTg20t57H+fMvTEjlx/WvUoIldeulVl6igRiGSYx6ev4O7XFnNhz8O49dyuKiInSgQimeSluWu4+bl5nHp0S+6uwUXklLtSS4lAJEP895P1/PyJWfTt0JQHftyburX18ZeAtgSRDDBrxSaumjSTI1o05DEVkZNilAhE0tyStVsZNn4GLRrVZ+KILBo3UBE52ZsSgUgaW7lxB4PGTKfeniJyjapvEbnyUtG51FEiEElT67fmM2jMdHbuKmTiiCzaNVMROSmZSkyIpKEtX+1myNhs1m7JZ/LI/hx9qIrIyf7piEAkzewpIvfJuq08NLA3fTo0jTskqeZ0RCCSRnYXFnHt4x8x47ON/O3SXgzooiJyUjYdEYikiaIi59dPzeXfi9bxhwu6cX6Pw+IOSWoIJQKRNODu3PHSIp6ZtYpffvcoBh3fIe6QIqdOQ6mjRCCSBh54K5ex733KsJM6cu2pR8YdjtQwSgQiNdykD5dzz+tL+H6vNvzuHBWRk/JTIhCpwV6Ys5pb/zWf045uyV0Xd6+xReTKS8kutcpMBGZ2oJn9zsweDV93NrNzow9NRErzzpL13DBtNv06NOOBy1VETioumS1nHJAPnBC+zgPuiCwiESnTzOWbuHrSTI5s2YjHhvblgLoqIicVl0wiOMLd7wJ2A7j7TkDHZSIxWfz5VoaPn0Grg+szcXgWBx+gInJSOckkgl1m1oCwt5aZHUFwhCAiVWxPEbkD6tZi0oj+tGhUP+6QYqOic6mTzC+Lfw+8CrQzs38CJwFDowxKRPa1fms+A8dMJ7+giGlXnaAicpIyZSYCd3/DzD4Cjic4JXS9u2+IPDIR+drmnbsZPDabdVvy+ecV/elyaKO4Q4qVzk2nVpmJwMy+HT7dGv7tama4+7vRhSUie+zcVcjICTPIXbeVMUP60bu9ishJaiVzauhXCc8PALKAmcCpkUQkIl/bXVjENY9/RM7yTdx/WS++fVSLuEOSNJTMqaHzEl+bWTvgrsgiEhEgKCJ301NzefPjdfzp+904t7uKyEk0KvILlDygWzITmtmZZrbYzHLNbNR+phlgZrPNbIGZvVOBeETSjrvzhxcX8uysVfzqjC5c3j/9i8iVn7oNpUoy1wju55s1XgvoCcxJ4n21gQeA7xIkjxlm9ry7L0yYpgnwIHCmu68wMxVPFwHufzOX8e9/xohvdeKnA46IOxxJc8lcI8hJeF4ATHH395J4XxaQ6+7LAMxsKnABsDBhmh8Dz7j7CgB3X5dU1CJpbNIHn3HvG0u4qHdbbj77GNXVKYFWSWolc41gQgXn3QZYmfA6D+hfbJqjgLpm9jbQCPibu08sPiMzuxK4EqB9+/YVDEek+vvX7FXc+vwCTj+mFXdedFzGFJGTeO03EZjZPEo+CWeAu3v3MuZd0hZcfH51gD7AaUAD4AMz+9Ddl+z1JvdHgEcA+vbtqxODkpbeWryOX06bQ1bHZvzjx72ooyJyUkVKOyKobIXRPKBdwuu2wOoSptng7tuB7Wb2LtADWIJIBpm5fCM/mTyTLoc24tEhKiInVWu/icDdl1dy3jOAzmbWCVgFXEpwTSDRv4B/mFkdoB7BqaO/VnK5IjXKojVbGDZuBq0bN2CCisglTbWGUieZ+xEcb2YzzGybme0ys0Iz21LW+9y9ALgWeA1YBExz9wVmdrWZXR1Os4igjtFcIBt4zN3nV6ZBIjXJii92MHhsNgfWq8OkEVk0b5i5ReQkPsn0GvoHwd78k0BfYDCQ1E1R3f1l4OViw0YXe303cHcy8xNJJ+u2fMXAMdPZXVjE41edQNumKiIn8UgmEeDuuWZW290LgXFm9n7EcYmktc07giJyG7bl88+R/encKrOLyJWXuo+mVjKJYIeZ1QNmm9ldwBrgoGjDEklfO3cVMmLCDJau38bYof3opSJyErP9XiMws77h00HhdNcC2wl6Al0UfWgi6Wd3YRE//edMZq7YxN8u7cXJnVVETuJX2hHBo2bWEJgCTA1LQ9xeNWGJpJ+iIufGJ+fw1uL1/PkHx3H2ca3jDkkEKOWIwN17EfyWoBB4KiwM92szU/UrkXJyd25/YQH/mr2am87swmVZ+oV8Zan3aOqU2n3U3Re7++3u3hUYAjQB3jSzZGoNiUjob//5hAkfLOeKkzvxk++oiJxUL0n9ht3MagEtgVYEF4rXRxmUSDoZ/96n3PfvT/hhn7b8VkXkUsJ0s8qUKrXXkJmdDFwGXAjMB6YCv3D3zdGHJlLzPTdrFbe9sJDvdW3Fn39wnJKAVEulFZ1bCawg+PK/3d3XVllUImngrY/XceOTczj+8Gb8/TIVkZPqq7Qjgm+loN6QSEaa8dlGrp48k2NaH8yjg1VETqq30noNKQmIVMDC1VsYPn4GbZo0YPywfjRSEblIuKrOpYyOVUVSaPkX2xk8NpuG9eswaWR/DlEROakBkqk+elIyw0Qy3dqwiFxhURGTRmTRpkmDuENKW7rmnlrJHBHcn+QwkYy1ecduBo/JZuO2XYwflsWRLVVETmqO0noNnQCcCLQwsxsSRh0M6MqXSGjHrgKGjc/m0w3bGTesHz3aNYk7JJFyKa3XUD2gYThN4u7NFuDiKIMSqSl2FRTxk8kfMXvllzx4eW9OOrJ53CGJlFtpt6p8B3jHzMarB5HIvgqLnF8+OYd3lqznzouO48xuKiJXldRnKHWSuR9BfTN7BOiYOL27nxpVUCLVnbtz2/MLeGHOakaddTSX9FMROam5kkkETwKjgccIKpGKZLy//vsTJn24nKu+fThXq4ic1HDJJIICd38o8khEaohx733K3//zCZf0bceos46OO5yMpN6jqZVM99EXzOynZtbazJrteUQemUg19OysPG5/YSFnHNuKP32/m4rISVpI5ohgSPj3VwnDHDg89eGIVF//WbSWG5+cy4lHHMLfLlUROUkfZSYCd+9UFYGIVGfZn27kp//8iGMPO5hHVERO0kwyJSYONLNbwp5DmFlnMzs3+tBEqocFqzczYvwM2jRtwPhhWTSsn8yBtERNNedSJ5lj23HALoJfGQPkAXdEFpFINfLphu0MGZtNowPqMHlEf5odVC/ukERSLplEcIS73wXsBnD3neiivWSAzzd/xaAx0ylymDiiP4epiFz1oYv0KZVMIthlZg0If8hnZkcA+ZFGJRKzL3fsYvDY6Wzavovxw/pxZMuGcYckEplkTnb+HngVaGdm/wROAoZGGZRInIIicjP4bMMOxg/vR/e2TeIOSSRSZd28vhbQFPgBcDzBKaHr3X1DFcQmUuV2FRRx1aSZzFn5JQ8N7MOJR6iInKS/UhOBuxeZ2bXuPg14qYpiEolFYZHzi2mz+e8nG7jr4u6cceyhcYckpVCnodRJ5hrBG2Z2o5m10y+LJV25O7/713xemruG3559ND/q2y7ukESqTDKJYDhwDfAuMDN85CQzczM708wWm1mumY0qZbp+ZlZoZrrPgcTiL68v4fHpK/jJgCO48tsqIlfdqc9QaiVzjWCUuz9R3hmbWW3gAeC7BL89mGFmz7v7whKmuxN4rbzLEEmFx/67jH+8lctlWe246YwucYcjUuVKPSJw9yKCo4GKyAJy3X2Zu+8CpgIXlDDddcDTwLoKLkekwp6emccdLy3irG6HcseFx6mInGSkKK8RtAFWJrzOC4d9zczaAN8nuN/BfpnZlWaWY2Y569evT2LRImV7Y+Fabnp6Lt86sjn3XdqT2rWUBCQzJfM7guHh38Qjg2Sqj5b0qSp+of8+4NfuXljanpi7PwI8AtC3b191FpBK+3DZF1zz+Ed0a9OYhwf1oX4dFZGraVzFhlImyuqjeUBi14u2wOpi0/QFpoZJoDlwtpkVuPtzFVymSJnmr9rMyAk5tG92IOOG9uMgFZGTDFfmJ8DMBpc03N0nlvHWGUBnM+sErAIuBX5cbB5fJxkzGw+8qCQgUVq2fhtDxmbTuEFdJo3IUhE5EZI7NdQv4fkBwGnAR0CpicDdC8zsWoLeQLWBse6+wMyuDseXel1AJNXWbN7JoDHZAEwakUXrxioiV1Ppmn5qJXNq6LrE12bWGJiUzMzd/WXg5WLDSkwA7j40mXmKVMSm7bsYPCabzTt3M/XK4zm8hYrIiexRkZOjO4DOqQ5EJCrb84Micss37mDCsCy6tWkcd0gi1Uoy1whe4JvePrWArsC0KIMSSZX8gkKunjyTeas289DlvTnhiEPiDkmk2knmiOCehOcFwHJ3z4soHpGUKSxybnhiDv/9ZAP3/LAH31MROZES7TcRmNmRQCt3f6fY8JPNrL67L408OpEKcndueW4+L81bwy3nHMPFfdrGHZJItVXaL4vvA7aWMHxnOE6k2rr7tcVMyV7BNaccwciTy/rto9Q06jSUWqUlgo7uPrf4QHfPATpGFpFIJT367jIefHspP+7fnhu/pyJyImUpLREcUMo4dcCWamlazkr+9PIizjmuNX+8oJuKyIkkobREMMPMrig+0MxGENyTQKRaeW3B54x6ei4nd27OvZf0UBE5kSSV1mvo58CzZnY533zx9wXqEVQMFak2Plj6BddNmUX3tk0YPVBF5DKBas6lzn4TgbuvBU40s1OAbuHgl9z9zSqJTCRJ8/I2c8XEHDqoiJxIhSRTYuIt4K0qiEWk3Jau38aQcXuKyPWnqYrIZQRd+0mtZG5MI1Itrf5yJ4Mem04tg8kj+3No49L6N4jI/igRSI20cfsuBo2ZztavChg/LItOzQ+KOySRGksnU6XG2ZZfwLBx2eRt2snE4SoiJ1JZSgRSo+QXFHLVpBzmr97CwwP70P9wFZHLVL7PnW+lonRqSGqMwiLn+imzeS/3C+6+uDund20Vd0giaUGJQGoEd+fmZ+fx6oLPufXcrvygt4rIiaSKEoHUCHe+upipM1Zy3alHMvxbncp+g6Q1dR5NLSUCqfYefmcpo99ZyuX923PDd4+KOxyRtKNEINXatBkr+fMrH3Nu99b8QUXkRCKhRCDV1qvzP2fUM3P59lEtuPdHPVVETiQiSgRSLb2fu4GfTZlFj3ZNGD2wN/XqaFOVvanoXOro0yXVzty8L7liYg6dmh/EuKH9OLCefu4iEiUlAqlWctdtY+i4GTQ9qB4TR2TR5EAVkZN96VJRaikRSLWx6sudDBoznVpmTB7Rn1YHq4icSFVQIpBq4Ytt+QwaM51t+QVMHJ5FRxWRE6kySgQSu235BQwdN4NVm3YyZkg/uh52cNwhiWQUXYWTWH21u5ArJuSwcM0WHh3ch6xOzeIOSWoI9RpKHR0RSGwKCov42ZRZfLDsC/7ywx6cerSKyInEQYlAYuHu/PbZeby+cC2/P68rF/ZqE3dIUoOYqg2lVKSJwMzONLPFZpZrZqNKGH+5mc0NH++bWY8o45Hq4/9e+ZhpOXn87LTODDtJReRE4hRZIjCz2sADwFlAV+AyM+tabLJPge+4e3fgj8AjUcUj1cdDby/l4XeXMfiEDvzi9M5xhyOS8aI8IsgCct19mbvvAqYCFyRO4O7vu/um8OWHgIrMp7kp2Su489WPOb/HYdx23rEqIidSDUSZCNoAKxNe54XD9mcE8EpJI8zsSjPLMbOc9evXpzBEqUqvzFvDzc/OY0CXFtzzwx7UUhE5kWohykRQ0qe8xA5fZnYKQSL4dUnj3f0Rd+/r7n1btGiRwhClqvzvkw1cP3U2vdo35aHL+6iInFSa7lmcOlH+jiAPaJfwui2wuvhEZtYdeAw4y92/iDAeicnslV9y5aQcDm9xEGOH9KNBvdpxhyQiCaLcLZsBdDazTmZWD7gUeD5xAjNrDzwDDHL3JRHGIjHJXbeVYeOyOaRhPSYOz6LxgXXjDknSgc4qplRkRwTuXmBm1wKvAbWBse6+wMyuDsePBm4FDgEeDC8aFrh736hikqqVt2kHAx/Lpk7tWkwe0Z+WKiInUi1FWmLC3V8GXi42bHTC85HAyChjkHhs2JbP4DHZbN9VwLSrTqDDISoiJ1Jd6YqdpNzWr3YzdFw2qzfvZNzQfhzTWkXkRKozJQJJqa92F3LFxBw+XrOVhy7vQ9+OKiIn0VDRudRR9VFJmYLCIq6bMovpn27kvkt6csrRLeMOSUSSoCMCSYmiImfUM/N4Y+FabjvvWC7oqSJyEh11GkotJQKpNHfn/728iKdm5vHz0zsz5MSOcYckIuWgRCCV9uDbS3nsf58y9MSOXH+aisiJ1DRKBFIpj09fwd2vLebCnodx67ldVUROpAZSIpAKe2nuGm5+bh6nHt2Su1VETqqYOg2ljhKBVMh/P1nPz5+YRd8OTXngx72pW1ubkkhNpU+vlNusFZu4atJMjmjRkMdURE5ioDOQqaVEIOWyZO1Who2fQYtG9Zk4IovGDVRETqSmUyKQpK3cuINBY6ZTb08RuUYqIieSDpQIJCnrt+YzaMx0du4qZOKILNo1OzDukEQkRVRiQsq0JSwit3ZLPpNH9ufoQ1VETiSd6IhASvXV7kJGTshhydqtPDSwN306NI07JJGA+o+mjBKB7FdBYRHXPv4RMz7byF9+1JMBXVRETqoHU7WhlFIikBIVFTk3PT2Xfy9axx8u6Mb5PQ6LOyQRiYgSgezD3bnjpUU889EqbvjuUQw6vkPcIYlIhJQIZB8PvJXL2Pc+ZdhJHbnu1CPjDkdEIqZEIHuZ/OFy7nl9Cd/v1YbfnaMiciKZQIlAvvbCnNX87l/zOe3oltx1cXcVkZNqzdVtKGWUCASAd5as54Zps+nXoRkPXK4iciKZRJ92YebyTVw9aSZHtmzEY0P7ckBdFZGT6k1nLFNLiSDDLf58K8PHz6DVwfWZODyLgw9QETmRTKNEkMH2FJE7oG4tJo3oT4tG9eMOSURioFpDGWr91nwGjplOfkER0646QUXkRDKYjggy0Oaduxk8Npt1W/IZN6wfXQ5tFHdIIuXm6jSUMkoEGWbnrkJGTphB7rqtPDyoD73bq4icSKbTqaEMsruwiGse/4ic5Zu4/7JefPuoFnGHJFIh6jWUWjoiyBBFRc5NT83lzY/XcceF3Ti3u4rIiUhAiSADuDt/eHEhz85axa/O6MLl/VVETkS+EWkiMLMzzWyxmeWa2agSxpuZ/T0cP9fMekcZT6a6/81cxr//GSO+1YmfDjgi7nBEpJqJLBGYWW3gAeAsoCtwmZl1LTbZWUDn8HEl8FBU8WSqSR98xr1vLOGi3m25+exjVERORPYR5cXiLCDX3ZcBmNlU4AJgYcI0FwAT3d2BD82siZm1dvc1qQ7mnSXr+eOL3yzaE/qe7dMLzff/0ov1Wdt7XPH3FZvW9z/t3tPtfxn7zKeUZQCs35bP6ce04s6LjlMROUkr81Zt5rv3vhN3GFXqkn7tGHny4Smfb5SJoA2wMuF1HtA/iWnaAHslAjO7kuCIgfbt21comIb169ClVbH+8lbi0z3L3N+k+/RYKO29+3z17rXMYssoZb77jtv/exOfN29Yn2tOOZI6KiInaWRg/w40bpB55VCaN4zm1/9RJoKSdj+L79wmMw3u/gjwCEDfvn0r9DOSPh2a6sbrImnirONac9ZxreMOI21EuZuYB7RLeN0WWF2BaUREJEJRJoIZQGcz62Rm9YBLgeeLTfM8MDjsPXQ8sDmK6wMiIrJ/kZ0acvcCM7sWeA2oDYx19wVmdnU4fjTwMnA2kAvsAIZFFY+IiJQs0hIT7v4ywZd94rDRCc8duCbKGEREpHTqSiIikuGUCEREMpwSgYhIhlMiEBHJcFa8nEF1Z2brgeUVfHtzYEMKw6kJ1ObMoDZnhsq0uYO7l3gTkhqXCCrDzHLcvW/ccVQltTkzqM2ZIao269SQiEiGUyIQEclwmZYIHok7gBiozZlBbc4MkbQ5o64RiIjIvjLtiEBERIpRIhARyXAZkwjM7EwzW2xmuWY2Ku54UsXMxprZOjObnzCsmZm9YWafhH+bJoz7TbgOFpvZGfFEXXFm1s7M3jKzRWa2wMyuD4enc5sPMLNsM5sTtvn2cHjatnkPM6ttZrPM7MXwdVq32cw+M7N5ZjbbzHLCYdG32d3T/kFQBnspcDhQD5gDdI07rhS17dtAb2B+wrC7gFHh81HAneHzrmHb6wOdwnVSO+42lLO9rYHe4fNGwJKwXencZgMahs/rAtOB49O5zQltvwF4HHgxfJ3WbQY+A5oXGxZ5mzPliCALyHX3Ze6+C5gKXBBzTCnh7u8CG4sNvgCYED6fAFyYMHyqu+e7+6cE94HIqoo4U8Xd17j7R+HzrcAigvtcp3Ob3d23hS/rhg8njdsMYGZtgXOAxxIGp3Wb9yPyNmdKImgDrEx4nRcOS1etPLzTW/i3ZTg8rdaDmXUEehHsIad1m8NTJLOBdcAb7p72bQbuA24CihKGpXubHXjdzGaa2ZXhsMjbHOmNaaoRK2FYJvabTZv1YGYNgaeBn7v7FrOSmhZMWsKwGtdmdy8EeppZE+BZM+tWyuQ1vs1mdi6wzt1nmtmAZN5SwrAa1ebQSe6+2sxaAm+Y2celTJuyNmfKEUEe0C7hdVtgdUyxVIW1ZtYaIPy7LhyeFuvBzOoSJIF/uvsz4eC0bvMe7v4l8DZwJund5pOA883sM4JTuaea2WTSu824++rw7zrgWYJTPZG3OVMSwQygs5l1MrN6wKXA8zHHFKXngSHh8yHAvxKGX2pm9c2sE9AZyI4hvgqzYNd/DLDI3e9NGJXObW4RHglgZg2A04GPSeM2u/tv3L2tu3ck+Ly+6e4DSeM2m9lBZtZoz3Pge8B8qqLNcV8lr8Kr8WcT9DBZCtwcdzwpbNcUYA2wm2APYQRwCPAf4JPwb7OE6W8O18Fi4Ky4469Ae79FcPg7F5gdPs5O8zZ3B2aFbZ4P3BoOT9s2F2v/AL7pNZS2bSbo1TgnfCzY8z1VFW1WiQkRkQyXKaeGRERkP5QIREQynBKBiEiGUyIQEclwSgQiIhlOiUBEJMMpEUhGMLNDwtK+s83sczNbFT7fZmYPRrC88Wb2qZldnYJ53R3GfGMqYhMpLlNqDUmGc/cvgJ4AZnYbsM3d74l4sb9y96cqOxN3/5WZbU9FQCIl0RGBZDQzG5Bw05PbzGyCmb0e3iDkB2Z2V3ijkFfDGkeYWR8zeyesEPnanjowZSxnvJk9ZMFNdZaZ2XcsuKnQIjMbH05TO5xufrjMX0TaeJGQEoHI3o4gqIF/ATAZeMvdjwN2AueEyeB+4GJ37wOMBf6U5LybAqcCvwBeAP4KHAscZ2Y9CY5Y2rh7t3CZ41LVKJHS6NSQyN5ecffdZjaP4M52r4bD5wEdgS5AN4ISwYTTrEly3i+4u4fzXuvu8wDMbEE473eAw83sfuAl4PWUtEikDEoEInvLB3D3IjPb7d8U4yoi+LwYsMDdT6jovMN55ScMLwLquPsmM+sBnAFcA/wIGF6B5YiUi04NiZTPYqCFmZ0Awb0RzOzYVMzYzJoDtdz9aeB3BPeiFomcjghEysHdd5nZxcDfzawxwWfoPoKywZXVBhhnZnt20H6TgnmKlEllqEUiEPYEejEV3UfD+d1G1XR5lQykU0Mi0dgM/DFVPygDBgL6LYFEQkcEIiIZTkcEIiIZTolARCTDKRGIiGQ4JQIRkQz3/wGn7Yp2anXPgAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "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\n" }, + "metadata": {}, "output_type": "display_data" } ], @@ -358,6 +411,206 @@ " r'$t_{start}$=%d, $t_{end}$=%d' % (duration, t_start, t_end))" ] }, + { + "cell_type": "markdown", + "source": [ + "### 5\\. ``brainpy.inputs.wiener_process``" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "[brainpy.inputs.wiener_process()](../apis/inputs/generated/brainpy.inputs.wiener_process.rst) is used to generate the basic Wiener process $dW$, i.e. random numbers drawn from $N(0, \\sqrt{dt})$." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "duration = 200\n", + "current6 = bp.inputs.wiener_process(duration, n=2, t_start=10., t_end=180.)\n", + "show(current6, duration, 'Wiener Process')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### ``brainpy.inputs.ou_process``" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "[brainpy.inputs.ou_process()](../apis/inputs/generated/brainpy.inputs.ou_process.rst) is used to generate the noise time series from Ornstein-Uhlenback process $\\dot{x} = (\\mu - x)/\\tau \\cdot dt + \\sigma\\cdot dW$." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "duration = 200\n", + "current7 = bp.inputs.ou_process(mean=1., sigma=0.1, tau=10., duration=duration, n=2, t_start=10., t_end=180.)\n", + "show(current7, duration, 'Ornstein-Uhlenbeck Process')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### ``brainpy.inputs.sinusoidal_input``" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "[brainpy.inputs.sinusoidal_input()](../apis/inputs/generated/brainpy.inputs.sinusoidal_input.rst) can help to generate sinusoidal inputs." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "duration = 2000\n", + "current8 = bp.inputs.sinusoidal_input(amplitude=1., frequency=2.0, duration=duration, t_start=100., )\n", + "show(current8, duration, 'Sinusoidal Input')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### ``brainpy.inputs.square_input``" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "[brainpy.inputs.square_input()](../apis/inputs/generated/brainpy.inputs.square_input.rst) can help to generate oscillatory square inputs." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "duration = 2000\n", + "current9 = bp.inputs.square_input(amplitude=1., frequency=2.0,\n", + " duration=duration, t_start=100)\n", + "show(current9, duration, 'Square Input')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### More complex inputs" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "markdown", "id": "5ec7e24c", @@ -368,20 +621,16 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 13, "id": "64ac8ffa", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABX3UlEQVR4nO3deVxU9f4/8NewzaDAKIIssqogsrjhAphbKipKLmV2K9Kyuna1VKrvDXfKXFpMzS1vKnK7qXVxzw030CvZVcEFFSVRFEFcGUTZhs/vD3/OdQSRUYYDnNfz8ZjHo/OZz5zzPgcbXpzz+ZyjEEIIEBEREcmIidQFEBEREdU0BiAiIiKSHQYgIiIikh0GICIiIpIdBiAiIiKSHQYgIiIikh0GICIiIpIdBiAiIiKSHQYgIiIikh0GIKIasnDhQigUCvj7+xv82bKyMvzzn/9Enz59YGdnB3NzczRt2hSDBg3Cli1bUFZWZoSKq8fFixehUCgQExMjyfYvXLiAcePGwdvbG5aWlmjQoAH8/PwwZcoUZGVlSVJTdTh9+jRmzJiBixcvVql/TEwMFAoFjhw5YtzCDDBr1ixs3LhR6jJIphiAiGrIypUrAQCpqak4fPhwlT9XWFiIsLAwjBw5Ek2bNsXSpUuxd+9eLFu2DM7Ozhg+fDi2bNlirLLrtK1bt6JNmzbYunUr3n//fWzdulX331u2bMGgQYOkLvGZnT59GtHR0VUOQLURAxBJyUzqAojk4MiRIzh+/DgGDhyI3377DStWrECXLl2q9NnIyEjs3LkTq1evxltvvaX33rBhw/Dpp5/i/v37xii7TsvIyMBrr70Gb29v7Nu3D2q1Wvfeiy++iI8++ggbNmyolm2VlJRAoVDAzKz8V+q9e/fQoEGDatkOEVUfngEiqgErVqwAAMyZMwchISFYu3Yt7t2799TP5eTk4Mcff0S/fv3KhZ+HvLy80KZNG91yZmYm3nzzTTRt2hRKpRKtW7fGt99+q3eZ7OFlqa+//hpz586Fh4cHLC0t0bNnT5w7dw4lJSX47LPP4OzsDLVajaFDhyI3N1dvux4eHhg0aBA2bNiANm3aQKVSoXnz5li4cGGVjsn58+fx+uuv69W5ePFi3fuFhYVo3749WrZsiby8PL1j4ujoiJ49e0Kr1T5x/fPmzUNBQQGWLFmiF34eUigUGDZsmN7+jBo1qly/nj17omfPnrrl/fv3Q6FQ4J///Cc+/vhjNGvWDEqlEunp6Rg1ahSsrKxw8uRJhIaGwtraGr179wYAFBcXY+bMmfDx8YFSqYS9vT3efvttXL9+XW97D4/rjh070KFDB1haWsLHx0d3BhF4cDlr+PDhAIBevXpBoVA802XGh/Wmp6cjLCwMVlZWcHV1xccff4yioiJdv4f/Xr766it8+eWXcHNzg0qlQseOHbFnz55y6/Tw8Ci3rRkzZkChUOiWFQoFCgoKsHr1al39jx5nIqMTRGRU9+7dE2q1WnTq1EkIIcSPP/4oAIiYmJinfvbnn38WAMTSpUurtK3c3FzRrFkzYW9vL5YtWyZ27Nghxo0bJwCIDz74QNcvIyNDABDu7u4iPDxcbN26Vfz000/CwcFBeHt7i4iICPHOO++I7du3i2XLlgkrKysRHh6uty13d3fRrFkz4ebmJlauXCm2bdsm3njjDQFAfP311+W2tWrVKl1bamqqUKvVIiAgQMTGxopdu3aJjz/+WJiYmIgZM2bo+p07d05YW1uLYcOGCSGE0Gq14sUXXxRNmzYVV69erfRYeHt7CwcHhyodt4f7M3LkyHLtPXr0ED169NAt79u3TwAQzZo1E6+88orYvHmz2Lp1q7h586YYOXKkMDc3Fx4eHmL27Nliz549YufOnUKr1Yr+/fuLhg0biujoaBEfHy9+/PFH0axZM+Hr6yvu3bunV4eLi4vw9fUVsbGxYufOnWL48OECgEhISBBCPPg5z5o1SwAQixcvFklJSSIpKUnk5uY+cf9WrVolAIj//ve/uraRI0cKCwsL0bp1a/HNN9+I3bt3i2nTpgmFQiGio6N1/R7+DF1dXcULL7wg4uLixK+//io6deokzM3NxaFDh/TW6e7uXm7706dPF4/+yklKShKWlpYiLCxMV39qamqlPyOi6sQARGRksbGxAoBYtmyZEEKI/Px8YWVlJbp16/bUz86ZM0cAEDt27KjStj777DMBQBw+fFiv/YMPPhAKhUKkpaUJIf73C61t27ZCq9Xq+s2fP18AEC+99JLe5ydMmCAAiLy8PF2bu7u7UCgUIiUlRa9v3759hY2NjSgoKNDb1qMBqF+/fsLFxUVvfUIIMW7cOKFSqcStW7d0bevWrRMAxPz588W0adOEiYmJ2LVr11OPhUqlEkFBQU/t9+j+GBKAunfvXq7vyJEjBQCxcuVKvfY1a9YIACIuLk6v/b///a8AIJYsWaJXh0qlEpcuXdK13b9/X9ja2oq//vWvurZff/1VABD79u2r0v49KQABEL/88ote37CwMNGqVSvd8sOfobOzs7h//76uXaPRCFtbW9GnTx+9dVYlAAkhRMOGDSs85kQ1gZfAiIxsxYoVsLS0xGuvvQYAsLKywvDhw3HgwAGcP3++Wre1d+9e+Pr6onPnznrto0aNghACe/fu1WsPCwuDicn/vgZat24NABg4cKBev4ftmZmZeu1+fn5o27atXtvrr78OjUaDY8eOVVhjYWEh9uzZg6FDh6JBgwYoLS3VvcLCwlBYWIjff/9d1//VV1/FBx98gE8//RQzZ87EpEmT0Ldv36ocDqN6+eWXq/ze1q1b0ahRI4SHh+vtb7t27eDo6Ij9+/fr9W/Xrh3c3Nx0yyqVCt7e3rh06VK17gPw4FJUeHi4XlubNm0q3NawYcOgUql0y9bW1ggPD0diYmKllyOJaiMGICIjSk9PR2JiIgYOHAghBO7cuYM7d+7glVdeAQC9cR0VefhLMCMjo0rbu3nzJpycnMq1Ozs7695/lK2trd6yhYVFpe2FhYV67Y6OjuW29bDt8W09WmNpaSm+//57mJub673CwsIAADdu3ND7zDvvvIOSkhKYmZnho48+qnC9j3Nzc6vycXsWFR1nAGjQoAFsbGz02q5du4Y7d+7AwsKi3D7n5OSU298mTZqUW69SqTTKYPcGDRrohZqH23r8Zw08+eddXFyMu3fvVnttRMbEWWBERrRy5UoIIfDvf/8b//73v8u9v3r1asycOROmpqYVfr5Xr14wNzfHxo0bMWbMmKdur0mTJsjOzi7XfvXqVQCAnZ2dgXtQuZycnCe2VfRLHAAaN24MU1NTREREYOzYsRX28fT01P13QUEBIiIi4O3tjWvXruHdd9/Fpk2bnlpbv3798P333+P3339HUFDQU/urVCq9gb8P3bhxo8Lj9uiA3qe129nZoUmTJtixY0eFn7G2tn5qfbXBk37eFhYWsLKyAlD5cSSqTXgGiMhItFotVq9ejRYtWmDfvn3lXh9//DGys7Oxffv2J67D0dER7777Lnbu3InY2NgK+/z55584ceIEAKB37944ffp0uctPsbGxUCgU6NWrV/XtIB7c0+j48eN6bT///DOsra3RoUOHCj/ToEED9OrVC8nJyWjTpg06duxY7vVoeBozZgwyMzOxfv16rFixAps3b8Z333331NomTpyIhg0b4m9/+5veLLKHhBB60+A9PDx0x/Ghc+fOIS0t7anbeppBgwbh5s2b0Gq1Fe5vq1atDF6nUqkEgBq9BcL69ev1zgzl5+djy5Yt6Natmy7Ee3h4IDc3F9euXdP1Ky4uxs6dO8utz1hntYiqgmeAiIxk+/btuHr1KubOnVvh9F5/f38sWrQIK1asqPSGfPPmzcOFCxcwatQo7Ny5E0OHDoWDgwNu3LiB+Ph4rFq1CmvXrkWbNm0wceJExMbGYuDAgfj888/h7u6O3377DUuWLMEHH3wAb2/vat1HZ2dnvPTSS5gxYwacnJzw008/IT4+HnPnzq303jcLFizACy+8gG7duuGDDz6Ah4cH8vPzkZ6eji1btujGKv3444/46aefsGrVKvj5+cHPzw/jxo3D3//+d3Tt2rXcWKdHeXp6Yu3atRgxYgTatWuHcePGoX379gAe3ETw4dm5oUOHAgAiIiLw5ptv4m9/+xtefvllXLp0CV999RXs7e2f+zi99tpr+Ne//oWwsDCMHz8enTt3hrm5Oa5cuYJ9+/Zh8ODBujqq6uEdxZcvXw5ra2uoVCp4eno+8cxbdTA1NUXfvn0RGRmJsrIyzJ07FxqNBtHR0bo+I0aMwLRp0/Daa6/h008/RWFhIRYuXFjhGKGAgADs378fW7ZsgZOTE6ytrZ8pDBI9E0mHYBPVY0OGDBEWFhaVTk1+7bXXhJmZmcjJyal0XaWlpWL16tXixRdfFLa2tsLMzEzY29uLAQMGiJ9//llvJtelS5fE66+/Lpo0aSLMzc1Fq1atxNdff63X5+GsnkenqwvxvxlOv/76q157RTOI3N3dxcCBA8W///1v4efnJywsLISHh4eYN2+e3mcrmgX2sP2dd94RzZo1E+bm5sLe3l6EhISImTNnCiGEOHHihLC0tCw3S6iwsFAEBgYKDw8Pcfv27UqPmxBC/Pnnn+Jvf/ubaNmypVAqlcLS0lL4+vqKyMhIkZGRoetXVlYmvvrqK9G8eXOhUqlEx44dxd69e584C+zxYyTEgxlQDRs2rLCOkpIS8c0334i2bdsKlUolrKyshI+Pj/jrX/8qzp8/X+64Pu7xOoR4MGvP09NTmJqaVniMH/WkWWAV1fv4jK2HP8O5c+eK6Oho4eLiIiwsLET79u3Fzp07y31+27Ztol27dsLS0lI0b95cLFq0qMJZYCkpKaJr166iQYMGAkC5/SMyJoUQQkiUvYioDvPw8IC/vz+2bt0qdSlkZBcvXoSnpye+/vprfPLJJ1KXQ1QtOAaIiIiIZIcBiIiIiGSHl8CIiIhIdngGiIiIiGSHAYiIiIhkhwGIiIiIZIc3QqxAWVkZrl69Cmtr6yfe7p6IiIhqFyEE8vPz4ezsrPeg54owAFXg6tWrcHV1lboMIiIiegaXL1+Gi4tLpX0YgCrw8MGEly9fLvdUZyIiIqqdNBoNXF1dq/SAYQagCjy87GVjY8MAREREVMdUZfgKB0ETERGR7DAAERERkewwABEREZHsMAARERGR7DAAERERkewwABEREZHsMAARERGR7DAAERERkewwABEREZHsMAARERGR7EgagGbPno1OnTrB2toaTZs2xZAhQ5CWlvbUzyUkJCAwMBAqlQrNmzfHsmXLyvWJi4uDr68vlEolfH19sWHDBmPsAhEREdVBkgaghIQEjB07Fr///jvi4+NRWlqK0NBQFBQUPPEzGRkZCAsLQ7du3ZCcnIxJkybho48+QlxcnK5PUlISRowYgYiICBw/fhwRERF49dVXcfjw4ZrYLSIiIqrlFEIIIXURD12/fh1NmzZFQkICunfvXmGfv//979i8eTPOnDmjaxszZgyOHz+OpKQkAMCIESOg0Wiwfft2XZ/+/fujcePGWLNmzVPr0Gg0UKvVyMvL48NQiYhk5H6xFpYWplKXQc/IkN/ftWoMUF5eHgDA1tb2iX2SkpIQGhqq19avXz8cOXIEJSUllfY5dOhQhessKiqCRqPRexERkXxc0xRi7L+OofW0Hfjlv5elLodqQK0JQEIIREZG4oUXXoC/v/8T++Xk5MDBwUGvzcHBAaWlpbhx40alfXJycipc5+zZs6FWq3UvV1fX59wbIiKqC7RlAqsPXUTvbxPw28lsAEDq1TyJq6KaYCZ1AQ+NGzcOJ06cwMGDB5/aV6FQ6C0/vIr3aHtFfR5veygqKgqRkZG6ZY1GwxBERFTPncrKw6QNJ3HiyoPAY2FmguLSMomroppSKwLQhx9+iM2bNyMxMREuLi6V9nV0dCx3Jic3NxdmZmZo0qRJpX0ePyv0kFKphFKpfI49ICKiuuJuUSnm7TqHmEMZKBOAtcoMf+/vg5y8Qizaly51eVRDJL0EJoTAuHHjsH79euzduxeenp5P/UxwcDDi4+P12nbt2oWOHTvC3Ny80j4hISHVVzwREdUpQgjsOJWDvvMSsPI/D8LPS22dsefjHngzyB0mFV8koHpK0jNAY8eOxc8//4xNmzbB2tpad9ZGrVbD0tISwIPLU1lZWYiNjQXwYMbXokWLEBkZiffeew9JSUlYsWKF3uyu8ePHo3v37pg7dy4GDx6MTZs2Yffu3VW6vEZERPXPldv3MGNzKnafyQUAuNk2wMwh/ujubS9xZSQVSQPQ0qVLAQA9e/bUa1+1ahVGjRoFAMjOzkZmZqbuPU9PT2zbtg0TJ07E4sWL4ezsjIULF+Lll1/W9QkJCcHatWsxZcoUTJ06FS1atMC6devQpUsXo+8TERHVHiXaMqw8mIH5u8/jfokW5qYKjOnRAmN7tYTKnNPd5UzSAFSVWxDFxMSUa+vRoweOHTtW6edeeeUVvPLKK89aGhER1XHHMm9j0vqTOJuTDwDo7GmLWUP90bKptcSVUW1QKwZBExERVZe8+yX4asdZ/PxHJoQAGjcwx6Sw1ngl0OWJs4EfVWvuDkxGxQBERET1ghACm49fxRdbz+DG3SIAwPBAF0SFtYZtQwuJq6PahgGIiIjqvIs3CjB10ykcOP/ghrgt7Bviy6EBCGreROLKqLZiACIiojqrqFSLHxIuYNG+dBSXlkFpZoIPX2yJ97o3h9LMwEHOVbg8RvUHAxAREdVJv1+4ickbTuLP6wUAgG5edpg5xB/uTRpKXBnVBQxARERUp9wqKMasbWfw76NXAAB2VkpMC/dFeBunKg1yJgIYgIiIqI4QQuDXI1cwa/sZ3LlXAoUCeKOLGz7t5wO1pbnU5VEdwwBERES13vlr+Zi84RT+uHgLAODjaI1ZwwLQwa1xtW+rCreoo3qAAYiIiGqtwhItvt97HssTL6BEK2BpborIvt54u6sHzEwlfZwl1XEMQEREVCslnLuOqRtPIfPWPQBAn9YOiB7sh2aNLCWujOoDBiAiIqpVcvML8cXWM9hy/CoAwEmtwoyX/NDPz9Go2+XwaXlhACIiolpBWybw8+FL+GpnGvILS2GiAN7u6omJfb1hpeSvK6pe/BdFRESSS72ah0kbTuH45TsAgLYuanw5NAD+zdTSFkb1FgMQERFJpqCoFN/Fn8OqQxehLROwVprh0/6t8EYXd5ia8KIUGQ8DEBERSWJXag5mbE7F1bxCAMDANk6YNsgXDjYqSesSfB68LDAAERFRjbp65z6mb05F/OlrAABXW0t8MdgfPVs1lbgykhMGICIiqhGl2jLEHLqIefHncK9YCzMTBd7v3hwfvugFSwsDH1xK9JwYgIiIyOhSLt/BpPUncTpbAwDo5NEYXw4NgLeDtcSV/Q8fIyYvDEBERGQ0msISfL0jDT8dvgQhgEYNzBE1wAfDA11hwkHOJCEGICIiqnZCCGw9kY3Pt57G9fwiAMCwDs0wOaw1mlgpJa6OiAGIiIiqWebNe5i66RQSzl0HADS3a4iZQ/0R0sJO4sqI/ocBiIiIqkVxaRn+ceACFu45j6LSMliYmWBsz5YY07M5lGYc5Ey1CwMQERE9tz8ybmHyhpM4n3sXANC1ZRPMHBIAT7uGEldmOMHbAMkCAxARET2z2wXFmL39DH45cgUAYGdlgSkDfTG4nTMUnFZFtRgDEBERGUwIgbhjWZi17QxuFRQDAP7S2Q2f9feBuoG5xNU9GwWfBy8rDEBERGSQ9Ny7mLLxJH6/cAsA0MrBGrOG+SPQ3VbiyoiqjgGIiIiqpLBEiyX70rE04U+UaAVU5iaY0Mcbo1/whLmpidTlERmEAYiIiJ7q4PkbmLLxJC7evAcAeNGnKaJf8oOrbQOJKyN6NgxARET0RNfzizDzt9PYlHIVAOBgo8SMcD/093fkIGeq0xiAiIionLIygTX/zcTc7WehKSyFiQJ4K9gDH4d6w1pVNwc5VxVnwcsDAxAREek5k63B5A0ncSzzDgAgoJkas4YGIMBFLW1hRNVI0lFriYmJCA8Ph7Pzg/tFbNy4sdL+o0aNgkKhKPfy8/PT9YmJiamwT2FhoZH3hoiobrtXXIrZ285g0PcHcSzzDqyUZpge7ouNY7sy/FC9I+kZoIKCArRt2xZvv/02Xn755af2X7BgAebMmaNbLi0tRdu2bTF8+HC9fjY2NkhLS9NrU6lU1VM0EVE9tOfMNUzblIqsO/cBAAP8HTE93A+Oavl8d3JIk7xIGoAGDBiAAQMGVLm/Wq2GWv2/v0I2btyI27dv4+2339brp1Ao4OjoWG11EhHVV9l59xG9+TR2pOYAAJo1ssQXQ/zwoo+DxJURGVedHgO0YsUK9OnTB+7u7nrtd+/ehbu7O7RaLdq1a4cvvvgC7du3f+J6ioqKUFRUpFvWaDRGq5mIqDYo1ZYhNukSvt2VhoJiLcxMFBjdzRPje3uhgUWd/tVAVCV19l95dnY2tm/fjp9//lmv3cfHBzExMQgICIBGo8GCBQvQtWtXHD9+HF5eXhWua/bs2YiOjq6JsomIJHfiyh1M2nASp7Ie/LHXwa0RZg0LgI+jjcSVEdWcOhuAYmJi0KhRIwwZMkSvPSgoCEFBQbrlrl27okOHDvj++++xcOHCCtcVFRWFyMhI3bJGo4Grq6tR6iYikkp+YQm+3XUOsUkXUSYAG5UZPhvQGq91coWJCQfAPMSnwctDnQxAQgisXLkSERERsLCwqLSviYkJOnXqhPPnzz+xj1KphFKprO4yiYhqBSEEtp/KQfSWVFzTPLjcP6SdMyYP9IW9Nb/7SJ7qZABKSEhAeno6Ro8e/dS+QgikpKQgICCgBiojIqpdLt+6h2mbTmFf2nUAgKddQ3wx2B8veNlJXBmRtCQNQHfv3kV6erpuOSMjAykpKbC1tYWbmxuioqKQlZWF2NhYvc+tWLECXbp0gb+/f7l1RkdHIygoCF5eXtBoNFi4cCFSUlKwePFio+8PEVFtUaItwz8OXMDCPedRWFIGC1MTjOnZAn/r2QIqc1Opy6uVeBFQXiQNQEeOHEGvXr10yw/H4YwcORIxMTHIzs5GZmam3mfy8vIQFxeHBQsWVLjOO3fu4P3330dOTg7UajXat2+PxMREdO7c2Xg7QkRUixy5eAuTNpzEuWt3AQBBzW3x5dAAtLC3krgyotpDIQSHez1Oo9FArVYjLy8PNjacFUFEdcOde8WYu+Ms1vxxGQBg29ACk8NaY1iHZnxwaRV8v+c8vo0/h790dsPsYRw2URcZ8vu7To4BIiKi/xFCYGNKFmZuPYObBcUAgBEdXfHZAB80blj5RBEiuWIAIiKqwy5cv4spG0/h0J83AQBeTa3w5dAAdPa0lbiyuowXRuSAAYiIqA4qLNFi6f4/sXT/nyjWlkFpZoKPenvhvW7NYWEm6XOuieoEBiAiojrmUPoNTNl4ChduFAAAenjb44vB/nBr0kDiyojqDgYgIqI64sbdInz52xlsSM4CANhbKzE93BcDA5w4yLka8BDKCwMQEVEtV1Ym8MuRy5i9/Szy7pdAoQAigtzxSb9WsFGZS10eUZ3EAEREVIul5eRj8oaTOHLpNgDA18kGs4YFoJ1rI2kLI6rjGICIiGqh+8VaLNhzHj8euIDSMoEGFqb4OLQVRga7w8yUg5yJnhcDEBFRLbPvbC6mbjqFK7fvAwBCfR0w4yU/ODeylLgyovqDAYiIqJa4pilE9JZUbDuZAwBwVqsQPdgffX0dJK5MXvh8BHlgACIikpi2TOCfSRfxza5zuFtUClMTBd7p6oEJfbzRUMmvaSJj4P9ZREQSOpWVh0kbTuLElTwAQDvXRpg1NAC+znwOYU3jrQTkhQGIiEgCd4tK8e2uNKw+dBFlArBWmeHv/X3wemc3mJjwFzGRsTEAERHVICEEdqbmYMbm08jRFAIAXmrrjCmDWqOptUri6ojkgwGIiKiGXLl9D9M3pWLP2VwAgJttA8wc4o/u3vYSV0YkPwxARERGVqItw8qDGZi/+zzul2hhbqrAX7u3wLgXW0Jlbip1eUSyxABERGRERy/dxuQNJ3E2Jx8A0NnTFrOG+qNlU2uJK6Mn4TR4eWAAIiIygrx7JZi78yzW/JEJIYDGDcwxKaw1Xgl04WwjolqAAYiIqBoJIbD5+FV8sfU0btwtBgAMD3RBVFhr2Da0kLg6InqIAYiIqJpcvFGAqZtO4cD5GwCAFvYN8eXQAAQ1byJxZUT0OAYgIqLnVFSqxQ8JF7BoXzqKS8tgYWaCD3u1xPs9mkNpxkHORLURAxAR0XNI+vMmJm88iQvXCwAA3bzs8MVgf3jYNZS4MiKqDAMQEdEzuFVQjC9/O4O4Y1cAAHZWSkwL90V4GycOciaqAxiAiIgMIITAr0euYNb2M7hzrwQKBfBGFzd82s8HaktzqcujaiDAefBywABERFRF56/lY/KGU/jj4i0AgI+jNWYNC0AHt8YSV0ZEhmIAIiJ6isISLb7fex7LEy+gRCtgaW6KiX298HZXT5ibmkhdHhE9AwYgIqJKJJy7jqkbTyHz1j0AQJ/WDoge7IdmjSwlroyqG4duyQsDEBFRBXI1hfh862lsPZENAHBSqzDjJT/083OUuDIiqg4MQEREj9CWCfx8+BK+2pGG/KJSmCiAt7t6YmJfb1gp+ZVJVF/w/2Yiov8v9WoeJm04heOX7wAA2rqo8eXQAPg3U0tbGBFVOwYgIpK9gqJSfBd/DqsOXYS2TMBKaYb/698Kb3Rxh6kJB4YQ1UeSTl9ITExEeHg4nJ2doVAosHHjxkr779+/HwqFotzr7Nmzev3i4uLg6+sLpVIJX19fbNiwwYh7QUR12a7UHPSdl4AfD2ZAWyYwsI0T9nzcA28FezD8yJTgbYBkQdIAVFBQgLZt22LRokUGfS4tLQ3Z2dm6l5eXl+69pKQkjBgxAhERETh+/DgiIiLw6quv4vDhw9VdPhHVYVfv3Md7sUfw/j+P4mpeIVxtLRHzdicsfr0DHGxUUpdHREYm6SWwAQMGYMCAAQZ/rmnTpmjUqFGF782fPx99+/ZFVFQUACAqKgoJCQmYP38+1qxZ8zzlElE9UKotQ8yhi5gXfw73irUwM1Hg/e7N8eGLXrC04INL5UwBnvGTkzp5B6/27dvDyckJvXv3xr59+/TeS0pKQmhoqF5bv379cOjQoSeur6ioCBqNRu9FRPVPyuU7eGnRfzDztzO4V6xFJ4/G2Da+G/6vvw/DD5HM1KlB0E5OTli+fDkCAwNRVFSEf/7zn+jduzf279+P7t27AwBycnLg4OCg9zkHBwfk5OQ8cb2zZ89GdHS0UWsnIuloCkvw9Y40/HT4EoQA1JbmmBTmg+GBrjDhOB8iWapTAahVq1Zo1aqVbjk4OBiXL1/GN998owtAAMo9iVkIUenTmaOiohAZGalb1mg0cHV1rcbKiUgKQghsPZGNz7eexvX8IgDAsA7NMDmsNZpYKSWujoikVKcCUEWCgoLw008/6ZYdHR3Lne3Jzc0td1boUUqlEkolvwyJ6pPMm/cwZdMpJJ67DgBobtcQM4f6I6SFncSVEVFtUCfHAD0qOTkZTk5OuuXg4GDEx8fr9dm1axdCQkJqujQikkBxaRkW70tH3+8SkHjuOizMTDCxjze2T+jG8ENVwlnw8iDpGaC7d+8iPT1dt5yRkYGUlBTY2trCzc0NUVFRyMrKQmxsLIAHM7w8PDzg5+eH4uJi/PTTT4iLi0NcXJxuHePHj0f37t0xd+5cDB48GJs2bcLu3btx8ODBGt8/IqpZhy/cxOSNp5CeexcA0LVlE8wcEgBPu4YSV0ZEtY2kAejIkSPo1auXbvnhOJyRI0ciJiYG2dnZyMzM1L1fXFyMTz75BFlZWbC0tISfnx9+++03hIWF6fqEhIRg7dq1mDJlCqZOnYoWLVpg3bp16NKlS83tGBHVqNsFxZi17Qx+PXoFAGBnZYEpA30xuJ1zpeP/iB7FfyryohCC97x8nEajgVqtRl5eHmxsbKQuh4ieQAiBuGNZmLXtDG4VFAMA/tLZDZ/194G6gbnE1VFdsyzhT8zZfhavBLrgm+FtpS6HnoEhv7/r/CBoIpKn9Ny7mLLxJH6/cAsA0MrBGrOG+SPQ3VbiyoioLmAAIqI6pbBEiyX70rE04U+UaAVU5iaY0Mcbo1/whLlpnZ/XQUQ1hAGIiOqMA+evY8rGU7h08x4A4EWfpoh+yQ+utg0kroyI6hoGICKq9XLzCzFz6xlsPn4VAOBgo8SMcD/093fkIGeqdhwZKw8MQERUa5WVCaz5bybmbD+L/MJSmCiAt4I98HGoN6xVHORMRM+OAYiIaqUz2RpM3nASxzLvAAACmqkxa2gAAlzU0hZGRPUCAxAR1Sr3ikuxYPd5/HgwA9oyASulGT4O9cZbwR4w5YNLyYj4r0teGICIqNbYffoapm9ORdad+wCAAf6OmB7uB0e1SuLKiKi+YQAiIsll593HjM2p2Jl6DQDQrJElvhjihxd9nvwQYyKi58EARESSKdWWYXXSJczblYaCYi3MTBQY3c0T43t7oYEFv56IyHj4DUNEkjh++Q4mbzyJU1kaAEAHt0aYNSwAPo58/AxJS/B58LLAAERENUpTWIJvd6Yh9vdLEAKwUZnhswGt8VonV5hwkDMR1RAGICKqEUIIbDuZg+gtqcjNLwIADGnnjMkDfWFvrZS4OiKSGwYgIjK6y7fuYeqmU9ifdh0A4NGkAWYOCcALXnYSV0b0P7ypuLwwABGR0ZRoy/CPAxewcM95FJaUwcLUBGN6tsDferaAytxU6vKISMYYgIjIKI5cvIVJG07i3LW7AICg5rb4cmgAWthbSVwZEREDEBFVszv3ijFn+1ms/e9lAIBtQwtMDmuNYR2a8cGlRFRrMAARUbUQQmBDcha+/O0MbhYUAwBGdHTFZwN80LihhcTVERHpYwAioud24fpdTNl4Cof+vAkA8GpqhS+HBqCzp63ElRE9A94GSBYYgIjomRWWaLF0/59Yuv9PFGvLoDQzwUe9vfBet+awMDORujwioidiACKiZ3Io/QambDyFCzcKAAA9vO3xxWB/uDVpIHFlRM9GwefBywoDEBEZ5MbdInz52xlsSM4CANhbKzE93BcDA5w4yJmI6gwGICKqkrIygXVHLmPO9rPIu18ChQKICHLHJ/1awUZlLnV5REQGYQAioqdKy8nH5A0nceTSbQCAr5MNZg0LQDvXRtIWRkT0jBiAiOiJ7hdrsWDPefx44AJKywQaWJgisq83RoV4wMyUg5yJqO5iACKiCu07m4upm07hyu37AIBQXwfMeMkPzo0sJa6MyLg4C14eGICISM81TSGit6Ri28kcAICzWoXowf7o6+sgcWVERNWHAYiIAADaMoF/Jl3EN7vO4W5RKUxNFHinqwcm9PFGQyW/KoiofuG3GhHhVFYeJm04iRNX8gAA7VwbYdbQAPg620hcGVHN4V0c5IUBiEjG7haV4ttdaVh96CLKBGCtMsP/9ffB653dYGrC3wZEVH8xABHJkBACO1NzMGPzaeRoCgEAL7V1xpRBrdHUWiVxdURExvdc81gLCwufa+OJiYkIDw+Hs7MzFAoFNm7cWGn/9evXo2/fvrC3t4eNjQ2Cg4Oxc+dOvT4xMTFQKBTlXs9bK1F9ceX2Pby7+gjG/HQMOZpCuNk2QOw7nbHwL+0ZfohINgwOQGVlZfjiiy/QrFkzWFlZ4cKFCwCAqVOnYsWKFQatq6CgAG3btsWiRYuq1D8xMRF9+/bFtm3bcPToUfTq1Qvh4eFITk7W62djY4Ps7Gy9l0rFL3aStxJtGX5I+BN95yViz9lcmJsqMK5XS+ya2B3dve2lLo+o1hCCE+HlwOBLYDNnzsTq1avx1Vdf4b333tO1BwQE4LvvvsPo0aOrvK4BAwZgwIABVe4/f/58veVZs2Zh06ZN2LJlC9q3b69rVygUcHR0rPJ6ieq7o5duY/KGkzibkw8A6Oxpi1lD/dGyqbXElRERScPgM0CxsbFYvnw53njjDZiamura27Rpg7Nnz1ZrcU9TVlaG/Px82Nra6rXfvXsX7u7ucHFxwaBBg8qdIXpcUVERNBqN3ouoPsi7V4Ko9Sfx8tJDOJuTj8YNzPHVK22w7v0ghh8ikjWDA1BWVhZatmxZrr2srAwlJSXVUlRVffvttygoKMCrr76qa/Px8UFMTAw2b96MNWvWQKVSoWvXrjh//vwT1zN79myo1Wrdy9XVtSbKJzIaIQQ2pWSh97z9WPNHJgBgeKAL9nzcE692dOVT24lI9gy+BObn54cDBw7A3d1dr/3XX3/VuwxlbGvWrMGMGTOwadMmNG3aVNceFBSEoKAg3XLXrl3RoUMHfP/991i4cGGF64qKikJkZKRuWaPRMARRnXXxRgGmbDyFg+k3AAAt7Bviy6EBCGreROLKiIhqD4MD0PTp0xEREYGsrCyUlZVh/fr1SEtLQ2xsLLZu3WqMGstZt24dRo8ejV9//RV9+vSptK+JiQk6depU6RkgpVIJpVJZ3WUS1aiiUi1+SLiARfvSUVxaBgszE3zYqyXe79EcSjPTp6+AiEhGDA5A4eHhWLduHWbNmgWFQoFp06ahQ4cO2LJlC/r27WuMGvWsWbMG77zzDtasWYOBAwc+tb8QAikpKQgICDB6bURSSfrzJiZvPIkL1wsAAN287PDFYH942DWUuDIiotrpmW6E2K9fP/Tr1++5N3737l2kp6frljMyMpCSkgJbW1u4ubkhKioKWVlZiI2NBfAg/Lz11ltYsGABgoKCkJPz4GGNlpaWUKvVAIDo6GgEBQXBy8sLGo0GCxcuREpKChYvXvzc9RLVNjfvFuHLbWew/lgWAMDOSolp4b4Ib+PEcT5Ez4iT4OVB0jtBHzlyBL169dItPxyHM3LkSMTExCA7OxuZmZm693/44QeUlpZi7NixGDt2rK79YX8AuHPnDt5//33k5ORArVajffv2SExMROfOnWtmp4hqQFmZwK9HL2P29rO4c68ECgXwRhc3fNrPB2pLc6nLIyKq9RTCwDs+mZiYVPqXpVarfe6ipKbRaKBWq5GXlwcbGz4MkmqX89fyMXnDKfxx8RYAwMfRGrOGBaCDW2OJKyOq2348cAEzfzuDwe2cseC1mpvUQ9XHkN/fBp8B2rBhg95ySUkJkpOTsXr1akRHRxu6OiKqosISLb7fex7LEy+gRCtgaW6KiX298HZXT5ibPtdTbYgI4GVjmTE4AA0ePLhc2yuvvAI/Pz/d7Cwiql7703IxbVMqMm/dAwD0ad0UM17yg0vjBhJXRkRUN1XbGKAuXbroPRqDiJ5frqYQ0VtP47cT2QAAJ7UKM17yQ6ivA/9aJSJ6DtUSgO7fv4/vv/8eLi4u1bE6ItnTlgn86/AlfL0jDflFpTBRAG939cTEvt6wUko6d4GIqF4w+Ju0cePGen95CiGQn5+PBg0a4KeffqrW4ojkKPVqHiZtOIXjl+8AANq6qPHl0AD4N1NLWxgRUT1icAD67rvv9AKQiYkJ7O3t0aVLFzRuzFkoRM+qoKgU8+LPYdV/MlAmACulGf6vfyu80cUdpia83EVUUwybG011lcEBaNSoUUYog0jedqbmYMbmVGTnFQIABgY4YVq4LxxsVBJXRkRUP1UpAJ04caLKK2zTps0zF0MkN1l37mP6plTsPnMNAOBqa4nPB/ujV6umT/kkEVU3nmeVlyoFoHbt2kGhUOBp90xUKBT14kaIRMZWqi3Dqv9cxHe7z+FesRZmJgq83705PnzRC5YWfHApEZGxVSkAZWRkGLsOItlIzryNSRtO4Uy2BgDQyaMxvhwaAG8Ha4krIyKSjyoFIHd3d2PXQVTv5d0vwdc7z+JfhzMhBKC2NMekMB8MD3SFCQc5ExHVqGe+ocjp06eRmZmJ4uJivfaXXnrpuYsiqk+EENhyIhtfbD2N6/lFAIBh7Zth0sDWsLNSSlwdEZE8GRyALly4gKFDh+LkyZN644IeTo3nGCCi/7l0swBTNp7CgfM3AADN7Rpi5lB/hLSwk7gyInoSzoKXB4OfoDh+/Hh4enri2rVraNCgAVJTU5GYmIiOHTti//79RiiRqO4pLi3Dor3nEfpdIg6cvwELMxNM7OON7RO6MfwQEdUCBp8BSkpKwt69e2Fvbw8TExOYmJjghRdewOzZs/HRRx8hOTnZGHUS1RmHL9zE5I2nkJ57FwDQtWUTzBwSAE+7hhJXRkREDxkcgLRaLaysrAAAdnZ2uHr1Klq1agV3d3ekpaVVe4FEdcWtgmLM3nYGvx69AgCws7LAlIG+GNzOmQ8uJaoD+L+pvBgcgPz9/XHixAk0b94cXbp0wVdffQULCwssX74czZs3N0aNRLWaEAL/PnoFs7adwe17JQCAv3R2w2f9faBuYC5xdUREVBGDA9CUKVNQUFAAAJg5cyYGDRqEbt26oUmTJli3bl21F0hUm6Xn3sXkDSdxOOMWAKCVgzVmDfNHoLutxJUREVFlqhyA2rVrh3fffRdvvPGG7qGnzZs3x+nTp3Hr1q1yT4knqs8KS7RYvC8dyxL+RIlWQGVuggl9vDH6BU+Ymxo8t4CIiGpYlb+pu3TpgilTpsDZ2Rmvv/469uzZo3vP1taW4Ydk48D56+g3PxHf701HiVbgRZ+miJ/YA2N6tGD4IaoHnvbYJ6ofqvxt/cMPPyAnJwfLly9HTk4OQkND4eHhgc8//xyZmZnGrJGoVsjNL8RHa5IRseIPXLp5Dw42Six9owNWjOwIV9sGUpdHREQGMOjPVZVKhYiICOzduxfp6emIiIjAihUr0Lx5c/Tr1w+//PKLseokkkxZmcBPv19C728TsPn4VZgogFEhHtgd2QMDApx49pOIqA565vP1np6e+OKLL3Dx4kWsXbsWR44cwV/+8pfqrI1IcmeyNXh52SFM2XgK+YWlCGimxsaxXTHjJT9YqzjDi6g+4Z8y8vLMzwIDgH379mHVqlVYv349zMzM8N5771VXXUSSuldcivm7z2PFwQxoywSslGb4ONQbbwV7wJQPLiUiqvMMDkCZmZmIiYlBTEwMLl68iG7dumHJkiUYPnw4LC0tjVEjUY3affoapm9ORdad+wCAAf6OmB7uB0e1SuLKiIioulQ5AP38889YtWoV9u3bBwcHB7z11lsYPXo0WrZsacz6iGpMdt59zNicip2p1wAAzRpZ4oshfnjRx0HiyoiIqLpVOQCNGjUKAwcOxMaNGxEWFgYTE073pfqhVFuG1UmXMG9XGgqKtTA1UeDdbp4Y39sLDSye6yoxERHVUlX+dr9y5QqaNm1qzFqIatzxy3cwacNJpF7VAAA6uDXCrGEB8HG0kbgyIpIK7wIkD1UOQAw/VJ9oCkvw7c40xP5+CUIANiozfDagNV7r5AoTDnImIqr3eH6fZEUIgW0ncxC9JRW5+UUAgCHtnDF5oC/srZUSV0dEUuI9veSFAYhk4/Kte5i66RT2p10HAHg0aYCZQwLwgpedxJUREVFNk3Qkc2JiIsLDw+Hs7AyFQoGNGzc+9TMJCQkIDAyESqVC8+bNsWzZsnJ94uLi4OvrC6VSCV9fX2zYsMEI1VNdUaItw5L96ej7XQL2p12HhakJPurthR0TujP8EBHJlMEBqHnz5rh582a59jt37qB58+YGraugoABt27bFokWLqtQ/IyMDYWFh6NatG5KTkzFp0iR89NFHiIuL0/VJSkrCiBEjEBERgePHjyMiIgKvvvoqDh8+bFBtVD8cuXgLAxcewFc70lBYUoag5rbYNr4bIvt6Q2VuKnV5REQkEYMvgV28eBFarbZce1FREbKysgxa14ABAzBgwIAq91+2bBnc3Nwwf/58AEDr1q1x5MgRfPPNN3j55ZcBAPPnz0ffvn0RFRUFAIiKikJCQgLmz5+PNWvWGFQf1V137hVjzvazWPvfywAA24YWmBzWGsM6NON1fiIiqnoA2rx5s+6/d+7cCbVarVvWarXYs2cPPDw8qrW4xyUlJSE0NFSvrV+/flixYgVKSkpgbm6OpKQkTJw4sVyfh6GpIkVFRSgqKtItazSaaq2bat7IlX/g+JU8AMCIjq74bIAPGje0kLgqIqoTOA9eFqocgIYMGQLgwSj5kSNH6r1nbm4ODw8PfPvtt9Va3ONycnLg4KB/V14HBweUlpbixo0bcHJyemKfnJycJ6539uzZiI6ONkrNJI2MGwUAgGVvBqK/v6PE1RARUW1T5TFAZWVlKCsrg5ubG3Jzc3XLZWVlKCoqQlpaGgYNGmTMWgGUn6YohCjXXlGfyi57REVFIS8vT/e6fPlyNVZMUvJysJK6BCKqI3h1XF4MHgOUkZFhjDqqxNHRsdyZnNzcXJiZmaFJkyaV9nn8rNCjlEollEreA4aIiEgunuk+QHv27MGePXt0Z4IetXLlymoprCLBwcHYsmWLXtuuXbvQsWNHmJub6/rEx8frjQPatWsXQkJCjFYX1T68hE9ERJUxOABFR0fj888/R8eOHeHk5PRcM2ru3r2L9PR03XJGRgZSUlJga2sLNzc3REVFISsrC7GxsQCAMWPGYNGiRYiMjMR7772HpKQkrFixQm921/jx49G9e3fMnTsXgwcPxqZNm7B7924cPHjwmeskIiKi+sXgALRs2TLExMQgIiLiuTd+5MgR9OrVS7ccGRkJABg5ciRiYmKQnZ2NzMxM3fuenp7Ytm0bJk6ciMWLF8PZ2RkLFy7UTYEHgJCQEKxduxZTpkzB1KlT0aJFC6xbtw5dunR57nqp7uElfSIiqojBAai4uLjaLif17NlTN4i5IjExMeXaevTogWPHjlW63ldeeQWvvPLK85ZHREQyJHgRXRYMvhP0u+++i59//tkYtRBVH35/ERFRJQw+A1RYWIjly5dj9+7daNOmjW7w8UPz5s2rtuKInhfv+kxERBUxOACdOHEC7dq1AwCcOnVK7z3+siEiorqKv8HkxeAAtG/fPmPUQVSteAWMiIgqY/AYoIfS09Oxc+dO3L9/HwAqHcxMREREVJsYHIBu3ryJ3r17w9vbG2FhYcjOzgbwYHD0xx9/XO0FEj0PntImIqKKGByAJk6cCHNzc2RmZqJBgwa69hEjRmDHjh3VWhwREVFN4wUNeTB4DNCuXbuwc+dOuLi46LV7eXnh0qVL1VYY0fPgJVkiIqqMwWeACgoK9M78PHTjxg0+UJRqHU5MJCKiihgcgLp37657NhfwYOp7WVkZvv76a73HWhAREdUp/ItJVgy+BPb111+jZ8+eOHLkCIqLi/F///d/SE1Nxa1bt/Cf//zHGDUSERERVSuDzwD5+vrixIkT6Ny5M/r27YuCggIMGzYMycnJaNGihTFqJDIYRwAREVFlDDoDVFJSgtDQUPzwww+Ijo42Vk1E1UbBifBERFQBg84AmZub49SpU3zkBREREdVpBl8Ce+utt7BixQpj1EJUbTgLnoieFb8/5MHgQdDFxcX48ccfER8fj44dO6Jhw4Z67/Np8FSb8GQlERFVxOAAdOrUKXTo0AEAcO7cOb33eGmMiIjqKv4GkxeDApBWq8WMGTMQEBAAW1tbY9VEREREZFQGjQEyNTVFv379kJeXZ6x6iKqF4ER4IiKqhMGDoAMCAnDhwgVj1EJERERUIwwOQF9++SU++eQTbN26FdnZ2dBoNHovIiIiotrO4EHQ/fv3BwC89NJLeoOehRBQKBTQarXVVx3RM+I0ViJ6VryELg8GB6B9+/YZow4io+DERCIiqojBAahHjx7GqIOIiEhS/INJXgwOQImJiZW+371792cuhoiIiKgmGByAevbsWa7t0bFAHANEtQGv4BMRUWUMngV2+/ZtvVdubi527NiBTp06YdeuXcaokeiZ8e7kRERUEYPPAKnV6nJtffv2hVKpxMSJE3H06NFqKYyIiIjIWAw+A/Qk9vb2SEtLq67VERERSYK30ZAHg88AnThxQm9ZCIHs7GzMmTMHbdu2rbbCiJ4Lv8CIiKgSBgegdu3aQaFQQDwWkYOCgrBy5cpqK4yoOnAEEBERVcTgS2AZGRm4cOECMjIykJGRgUuXLuHevXs4dOgQfHx8DC5gyZIl8PT0hEqlQmBgIA4cOPDEvqNGjYJCoSj38vPz0/WJiYmpsE9hYaHBtRERkXwo+CeTrBh8Bsjd3b3aNr5u3TpMmDABS5YsQdeuXfHDDz9gwIABOH36NNzc3Mr1X7BgAebMmaNbLi0tRdu2bTF8+HC9fjY2NuXGI6lUqmqrm2o/3sqeiIgqU+UzQHv37oWvr2+FDzzNy8uDn59fpWdvKjJv3jyMHj0a7777Llq3bo358+fD1dUVS5curbC/Wq2Go6Oj7nXkyBHcvn0bb7/9tl4/hUKh18/R0dGguqj+4Cx4IiKqSJUD0Pz58/Hee+/Bxsam3HtqtRp//etfMW/evCpvuLi4GEePHkVoaKhee2hoKA4dOlSldaxYsQJ9+vQpd1bq7t27cHd3h4uLCwYNGoTk5ORK11NUVMSn2hMREclIlQPQ8ePHdU+Cr0hoaKhB9wC6ceMGtFotHBwc9NodHByQk5Pz1M9nZ2dj+/btePfdd/XafXx8EBMTg82bN2PNmjVQqVTo2rUrzp8//8R1zZ49G2q1WvdydXWt8n4QERFR3VPlAHTt2jWYm5s/8X0zMzNcv37d4AIev1OvEKJKd++NiYlBo0aNMGTIEL32oKAgvPnmm2jbti26deuGX375Bd7e3vj++++fuK6oqCjk5eXpXpcvXzZ4P6h24X08iOhZ8etDHqo8CLpZs2Y4efIkWrZsWeH7J06cgJOTU5U3bGdnB1NT03Jne3Jzc8udFXqcEAIrV65EREQELCwsKu1rYmKCTp06VXoGSKlUQqlUVrl2qjs4q4OIiCpS5TNAYWFhmDZtWoXTye/fv4/p06dj0KBBVd6whYUFAgMDER8fr9ceHx+PkJCQSj+bkJCA9PR0jB49+qnbEUIgJSXFoHBGRETyw0kT8lLlM0BTpkzB+vXr4e3tjXHjxqFVq1ZQKBQ4c+YMFi9eDK1Wi8mTJxu08cjISERERKBjx44IDg7G8uXLkZmZiTFjxgB4cGkqKysLsbGxep9bsWIFunTpAn9//3LrjI6ORlBQELy8vKDRaLBw4UKkpKRg8eLFBtVGRERE9VeVA5CDgwMOHTqEDz74AFFRUbo7QSsUCvTr1w9Llix56qWrx40YMQI3b97E559/juzsbPj7+2Pbtm26WV3Z2dnIzMzU+0xeXh7i4uKwYMGCCtd5584dvP/++8jJyYFarUb79u2RmJiIzp07G1Qb1W0Pr+HzLzoiIqqIQjz+TIsquH37NtLT0yGEgJeXFxo3bmyM2iSj0WigVquRl5dX4bR/qv1aTNoGbZnA4Um94WDDm2AS0dOt+SMTUetPoq+vA/7xVkepy6FnYMjvb4PvBA0AjRs3RqdOnZ6pOCIiIiKpGfwsMKK64BlObBIRAeBtNOSCAYjqNQ4BIiKiijAAERERgX8wyQ0DEBEREckOAxDVS7pL+PyTjoiIKsAARERERLLDAERERESywwBE9RKnsRLRs+MXiBwwAFG9xqfBExFRRRiAiIiIwGcHyg0DEBEREckOAxARERHJDgMQ1Ws8pU1ERBVhACIiIiLZYQAiIiJ6BG+jIQ8MQFTviEe+vXgFjIiIKsIARERERLLDAERERATeOFVuGICo3uH1eyIiehoGIKrXFJwHT0REFWAAIiIiItlhACIiIiLZYQCieufRIUC8AEZEhuIwQnlgACIiIiLZYQAiIiICeMpYZhiAiIiISHYYgKje0XsUBv+iIyKiCjAAERERkewwABEREZHsMABRvaM/DZ7XwIjIMILP05EFyQPQkiVL4OnpCZVKhcDAQBw4cOCJfffv3w+FQlHudfbsWb1+cXFx8PX1hVKphK+vLzZs2GDs3SAiIqI6RNIAtG7dOkyYMAGTJ09GcnIyunXrhgEDBiAzM7PSz6WlpSE7O1v38vLy0r2XlJSEESNGICIiAsePH0dERAReffVVHD582Ni7Q0REdRjPF8uLpAFo3rx5GD16NN599120bt0a8+fPh6urK5YuXVrp55o2bQpHR0fdy9TUVPfe/Pnz0bdvX0RFRcHHxwdRUVHo3bs35s+fb+S9ISIiorpCsgBUXFyMo0ePIjQ0VK89NDQUhw4dqvSz7du3h5OTE3r37o19+/bpvZeUlFRunf369at0nUVFRdBoNHovqrsEn4VBRERPIVkAunHjBrRaLRwcHPTaHRwckJOTU+FnnJycsHz5csTFxWH9+vVo1aoVevfujcTERF2fnJwcg9YJALNnz4Zarda9XF1dn2PPiIiIqLYzk7oAxWN3qhNClGt7qFWrVmjVqpVuOTg4GJcvX8Y333yD7t27P9M6ASAqKgqRkZG6ZY1GwxBERERUj0l2BsjOzg6mpqblzszk5uaWO4NTmaCgIJw/f1637OjoaPA6lUolbGxs9F5UP/BO0ERkKE6ClwfJApCFhQUCAwMRHx+v1x4fH4+QkJAqryc5ORlOTk665eDg4HLr3LVrl0HrpLpN8OuLiIieQtJLYJGRkYiIiEDHjh0RHByM5cuXIzMzE2PGjAHw4NJUVlYWYmNjATyY4eXh4QE/Pz8UFxfjp59+QlxcHOLi4nTrHD9+PLp37465c+di8ODB2LRpE3bv3o2DBw9Kso9ERERU+0gagEaMGIGbN2/i888/R3Z2Nvz9/bFt2za4u7sDALKzs/XuCVRcXIxPPvkEWVlZsLS0hJ+fH3777TeEhYXp+oSEhGDt2rWYMmUKpk6dihYtWmDdunXo0qVLje8fERHVHZWNFaX6RyF4z+9yNBoN1Go18vLyOB6oDios0cJn6g4AwMkZobBWmUtcERHVBf8+egWf/HocPVvZI+btzlKXQ8/AkN/fkj8Kg4iIiKimMQARERGR7DAAERERkewwAFG9xkGNRGQojoyVBwYgIiIikh0GICIiIvDZyXLDAET1zqOnr/mFRkREFWEAIiIiItlhACIiIiLZYQAiIiIi2WEAonrn0afBcxY8ERmKs+DlgQGIiIiIZIcBiIiICDxjLDcMQFSvKTgRnoiIKsAARPUOb2NPRERPwwBEREREssMARERERLLDAET1zqNXwDiokYgMJXgdXRYYgIiIiEh2GICIiIjAM8ZywwBEREREssMARPUOr98TEdHTMAARERGR7DAAERERkewwAFG9xkGNRERUEQYgqnc4AoiIiJ6GAYiIiIhkhwGIiIgIgAK8Zi4nDEBU7zw6C55faEREVBEGICIiIpIdBiAiIiKSHckD0JIlS+Dp6QmVSoXAwEAcOHDgiX3Xr1+Pvn37wt7eHjY2NggODsbOnTv1+sTExEChUJR7FRYWGntXqBbiNHgiIqqIpAFo3bp1mDBhAiZPnozk5GR069YNAwYMQGZmZoX9ExMT0bdvX2zbtg1Hjx5Fr169EB4ejuTkZL1+NjY2yM7O1nupVKqa2CWqDTgPnoieA5+mIw9mUm583rx5GD16NN59910AwPz587Fz504sXboUs2fPLtd//vz5esuzZs3Cpk2bsGXLFrRv317XrlAo4OjoaNTaiYiIqO6S7AxQcXExjh49itDQUL320NBQHDp0qErrKCsrQ35+PmxtbfXa7969C3d3d7i4uGDQoEHlzhA9rqioCBqNRu9FRETywkvm8iJZALpx4wa0Wi0cHBz02h0cHJCTk1OldXz77bcoKCjAq6++qmvz8fFBTEwMNm/ejDVr1kClUqFr1644f/78E9cze/ZsqNVq3cvV1fXZdopqBfHINTB+nxERUUUkHwSteCxyCyHKtVVkzZo1mDFjBtatW4emTZvq2oOCgvDmm2+ibdu26NatG3755Rd4e3vj+++/f+K6oqKikJeXp3tdvnz52XeIiIiIaj3JxgDZ2dnB1NS03Nme3NzccmeFHrdu3TqMHj0av/76K/r06VNpXxMTE3Tq1KnSM0BKpRJKpbLqxRMREVGdJtkZIAsLCwQGBiI+Pl6vPT4+HiEhIU/83Jo1azBq1Cj8/PPPGDhw4FO3I4RASkoKnJycnrtmqnuqcjaRiIjkR9JZYJGRkYiIiEDHjh0RHByM5cuXIzMzE2PGjAHw4NJUVlYWYmNjATwIP2+99RYWLFiAoKAg3dkjS0tLqNVqAEB0dDSCgoLg5eUFjUaDhQsXIiUlBYsXL5ZmJ6nGcQorET0PwXtpyIKkAWjEiBG4efMmPv/8c2RnZ8Pf3x/btm2Du7s7ACA7O1vvnkA//PADSktLMXbsWIwdO1bXPnLkSMTExAAA7ty5g/fffx85OTlQq9Vo3749EhMT0blz5xrdNyIiIqq9FELw7+XHaTQaqNVq5OXlwcbGRupyyEC3C4rR/osHl1b/nBUGUxNeBiOip9uUkoXxa1PQtWUT/OvdIKnLoWdgyO9vyWeBERkTow8REVWEAYjqHZ7SJCKip2EAIiIiItlhAKJ6jbPgiYioIgxAVO9wXD8RPQ9+hcgDAxARERHJDgMQEREReOd4uWEAonqNX2hERFQRBiCqd3j5noiInoYBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiOod3sODiJ4Hv0PkgQGIiIiIZIcBiOotzoAnIkPwK0NeGICo3hGcCE9ERE/BAERERESywwBEREREssMARPUWr+cTEdGTMABR/cMhQET0HDiOUB4YgIiIiEh2GICo3uKT4InIEPzKkBcGIKp3ePKaiIiehgGIiIiIZIcBiIiIiGSHAYjqLV7OJyKiJ2EAonqHT3ImoufB7xB5YAAiIiIi2WEAonqLU1qJyBAKXjiXFQYgIiIikh0GIKp3eBt7IiJ6GskD0JIlS+Dp6QmVSoXAwEAcOHCg0v4JCQkIDAyESqVC8+bNsWzZsnJ94uLi4OvrC6VSCV9fX2zYsMFY5RMREVEdJGkAWrduHSZMmIDJkycjOTkZ3bp1w4ABA5CZmVlh/4yMDISFhaFbt25ITk7GpEmT8NFHHyEuLk7XJykpCSNGjEBERASOHz+OiIgIvPrqqzh8+HBN7RbVEryeT0RET6IQQroJf126dEGHDh2wdOlSXVvr1q0xZMgQzJ49u1z/v//979i8eTPOnDmjaxszZgyOHz+OpKQkAMCIESOg0Wiwfft2XZ/+/fujcePGWLNmTZXq0mg0UKvVyMvLg42NzbPuXjlFpVpczy+qtvVRxXLzizBsySFYmJrg3JcDpC6HiOqI305kY+zPx9DWtREWv95e6nLqPQszEzS1VlXrOg35/W1WrVs2QHFxMY4ePYrPPvtMrz00NBSHDh2q8DNJSUkIDQ3Va+vXrx9WrFiBkpISmJubIykpCRMnTizXZ/78+U+spaioCEVF/wsmGo3GwL2pmtSrGgxbUvG+ERFR7XD88h28MHef1GXUex3cGmH937pKtn3JAtCNGzeg1Wrh4OCg1+7g4ICcnJwKP5OTk1Nh/9LSUty4cQNOTk5P7POkdQLA7NmzER0d/Yx7UnUKAEozyYddycagNs5Sl0BEdUgH90Zwb9IAOXmFUpciC+am0v4+lCwAPaR47GYtQohybU/r/3i7oeuMiopCZGSkblmj0cDV1fXpxRuovVtjpM3kJRkiotrISW2JhE97SV0G1RDJApCdnR1MTU3LnZnJzc0tdwbnIUdHxwr7m5mZoUmTJpX2edI6AUCpVEKpVD7LbhAREVEdJNn5JwsLCwQGBiI+Pl6vPT4+HiEhIRV+Jjg4uFz/Xbt2oWPHjjA3N6+0z5PWSURERPIj6SWwyMhIREREoGPHjggODsby5cuRmZmJMWPGAHhwaSorKwuxsbEAHsz4WrRoESIjI/Hee+8hKSkJK1as0JvdNX78eHTv3h1z587F4MGDsWnTJuzevRsHDx6UZB+JiIio9pE0AI0YMQI3b97E559/juzsbPj7+2Pbtm1wd3cHAGRnZ+vdE8jT0xPbtm3DxIkTsXjxYjg7O2PhwoV4+eWXdX1CQkKwdu1aTJkyBVOnTkWLFi2wbt06dOnSpcb3j4iIiGonSe8DVFsZ6z5AREREZDyG/P7mnGwiIiKSHQYgIiIikh0GICIiIpIdBiAiIiKSHQYgIiIikh0GICIiIpIdBiAiIiKSHQYgIiIikh0GICIiIpIdSR+FUVs9vDm2RqORuBIiIiKqqoe/t6vykAsGoArk5+cDAFxdXSWuhIiIiAyVn58PtVpdaR8+C6wCZWVluHr1KqytraFQKKp13RqNBq6urrh8+TKfM2ZEPM41g8e5ZvA41xwe65phrOMshEB+fj6cnZ1hYlL5KB+eAaqAiYkJXFxcjLoNGxsb/s9VA3icawaPc83gca45PNY1wxjH+Wlnfh7iIGgiIiKSHQYgIiIikh0GoBqmVCoxffp0KJVKqUup13icawaPc83gca45PNY1ozYcZw6CJiIiItnhGSAiIiKSHQYgIiIikh0GICIiIpIdBiAiIiKSHQagGrRkyRJ4enpCpVIhMDAQBw4ckLqkOiUxMRHh4eFwdnaGQqHAxo0b9d4XQmDGjBlwdnaGpaUlevbsidTUVL0+RUVF+PDDD2FnZ4eGDRvipZdewpUrV2pwL2q/2bNno1OnTrC2tkbTpk0xZMgQpKWl6fXhsX5+S5cuRZs2bXQ3ggsODsb27dt17/MYG8fs2bOhUCgwYcIEXRuPdfWYMWMGFAqF3svR0VH3fq07zoJqxNq1a4W5ubn4xz/+IU6fPi3Gjx8vGjZsKC5duiR1aXXGtm3bxOTJk0VcXJwAIDZs2KD3/pw5c4S1tbWIi4sTJ0+eFCNGjBBOTk5Co9Ho+owZM0Y0a9ZMxMfHi2PHjolevXqJtm3bitLS0hrem9qrX79+YtWqVeLUqVMiJSVFDBw4ULi5uYm7d+/q+vBYP7/NmzeL3377TaSlpYm0tDQxadIkYW5uLk6dOiWE4DE2hj/++EN4eHiINm3aiPHjx+vaeayrx/Tp04Wfn5/Izs7WvXJzc3Xv17bjzABUQzp37izGjBmj1+bj4yM+++wziSqq2x4PQGVlZcLR0VHMmTNH11ZYWCjUarVYtmyZEEKIO3fuCHNzc7F27Vpdn6ysLGFiYiJ27NhRY7XXNbm5uQKASEhIEELwWBtT48aNxY8//shjbAT5+fnCy8tLxMfHix49eugCEI919Zk+fbpo27Zthe/VxuPMS2A1oLi4GEePHkVoaKhee2hoKA4dOiRRVfVLRkYGcnJy9I6xUqlEjx49dMf46NGjKCkp0evj7OwMf39//hwqkZeXBwCwtbUFwGNtDFqtFmvXrkVBQQGCg4N5jI1g7NixGDhwIPr06aPXzmNdvc6fPw9nZ2d4enritddew4ULFwDUzuPMh6HWgBs3bkCr1cLBwUGv3cHBATk5ORJVVb88PI4VHeNLly7p+lhYWKBx48bl+vDnUDEhBCIjI/HCCy/A398fAI91dTp58iSCg4NRWFgIKysrbNiwAb6+vrovex7j6rF27VocPXoUR44cKfce/z1Xny5duiA2Nhbe3t64du0aZs6ciZCQEKSmptbK48wAVIMUCoXeshCiXBs9n2c5xvw5PNm4ceNw4sQJHDx4sNx7PNbPr1WrVkhJScGdO3cQFxeHkSNHIiEhQfc+j/Hzu3z5MsaPH49du3ZBpVI9sR+P9fMbMGCA7r8DAgIQHByMFi1aYPXq1QgKCgJQu44zL4HVADs7O5iampZLsLm5ueXSMD2bhzMNKjvGjo6OKC4uxu3bt5/Yh/7nww8/xObNm7Fv3z64uLjo2nmsq4+FhQVatmyJjh07Yvbs2Wjbti0WLFjAY1yNjh49itzcXAQGBsLMzAxmZmZISEjAwoULYWZmpjtWPNbVr2HDhggICMD58+dr5b9pBqAaYGFhgcDAQMTHx+u1x8fHIyQkRKKq6hdPT084OjrqHePi4mIkJCTojnFgYCDMzc31+mRnZ+PUqVP8OTxCCIFx48Zh/fr12Lt3Lzw9PfXe57E2HiEEioqKeIyrUe/evXHy5EmkpKToXh07dsQbb7yBlJQUNG/enMfaSIqKinDmzBk4OTnVzn/T1T6smir0cBr8ihUrxOnTp8WECRNEw4YNxcWLF6Uurc7Iz88XycnJIjk5WQAQ8+bNE8nJybpbCcyZM0eo1Wqxfv16cfLkSfGXv/ylwimWLi4uYvfu3eLYsWPixRdf5FTWx3zwwQdCrVaL/fv3601nvXfvnq4Pj/Xzi4qKEomJiSIjI0OcOHFCTJo0SZiYmIhdu3YJIXiMjenRWWBC8FhXl48//ljs379fXLhwQfz+++9i0KBBwtraWvd7rrYdZwagGrR48WLh7u4uLCwsRIcOHXTTiqlq9u3bJwCUe40cOVII8WCa5fTp04Wjo6NQKpWie/fu4uTJk3rruH//vhg3bpywtbUVlpaWYtCgQSIzM1OCvam9KjrGAMSqVat0fXisn98777yj+z6wt7cXvXv31oUfIXiMjenxAMRjXT0e3tfH3NxcODs7i2HDhonU1FTd+7XtOCuEEKL6zysRERER1V4cA0RERESywwBEREREssMARERERLLDAERERESywwBEREREssMARERERLLDAERERESywwBERLXGjBkz0K5duxrf7v79+6FQKKBQKDBkyBCjbuvhdho1amTU7RBR5RiAiKhGPPzF/6TXqFGj8Mknn2DPnj2S1ZiWloaYmBijbiM7Oxvz58836jaI6OnMpC6AiOQhOztb99/r1q3DtGnTkJaWpmuztLSElZUVrKyspCgPANC0aVOjn5lxdHSEWq026jaI6Ol4BoiIaoSjo6PupVaroVAoyrU9fgls1KhRGDJkCGbNmgUHBwc0atQI0dHRKC0txaeffgpbW1u4uLhg5cqVetvKysrCiBEj0LhxYzRp0gSDBw/GxYsXDa65Z8+e+PDDDzFhwgQ0btwYDg4OWL58OQoKCvD222/D2toaLVq0wPbt23WfuX37Nt544w3Y29vD0tISXl5eWLVq1bMeNiIyEgYgIqrV9u7di6tXryIxMRHz5s3DjBkzMGjQIDRu3BiHDx/GmDFjMGbMGFy+fBkAcO/ePfTq1QtWVlZITEzEwYMHYWVlhf79+6O4uNjg7a9evRp2dnb4448/8OGHH+KDDz7A8OHDERISgmPHjqFfv36IiIjAvXv3AABTp07F6dOnsX37dpw5cwZLly6FnZ1dtR4TInp+DEBEVKvZ2tpi4cKFaNWqFd555x20atUK9+7dw6RJk+Dl5YWoqChYWFjgP//5DwBg7dq1MDExwY8//oiAgAC0bt0aq1atQmZmJvbv32/w9tu2bYspU6botmVpaQk7Ozu899578PLywrRp03Dz5k2cOHECAJCZmYn27dujY8eO8PDwQJ8+fRAeHl6dh4SIqgHHABFRrebn5wcTk//9rebg4AB/f3/dsqmpKZo0aYLc3FwAwNGjR5Geng5ra2u99RQWFuLPP/80ePtt2rQpt62AgAC9egDotv/BBx/g5ZdfxrFjxxAaGoohQ4YgJCTE4O0SkXExABFRrWZubq63rFAoKmwrKysDAJSVlSEwMBD/+te/yq3L3t6+2revUCh02wWAAQMG4NKlS/jtt9+we/du9O7dG2PHjsU333xj8LaJyHgYgIioXunQoQPWrVuHpk2bwsbGRpIa7O3tMWrUKIwaNQrdunXDp59+ygBEVMtwDBAR1StvvPEG7OzsMHjwYBw4cAAZGRlISEjA+PHjceXKFaNvf9q0adi0aRPS09ORmpqKrVu3onXr1kbfLhEZhgGIiOqVBg0aIDExEW5ubhg2bBhat26Nd955B/fv36+RM0IWFhaIiopCmzZt0L17d5iammLt2rVG3y4RGUYhhBBSF0FEJKX9+/ejV69euH37do08oiImJgYTJkzAnTt3jL4tIqoYxwAREf1/Li4uCA8Px5o1a4y2DSsrK5SWlkKlUhltG0T0dDwDRESyd//+fWRlZQF4EFAcHR2Ntq309HQAD6bUe3p6Gm07RFQ5BiAiIiKSHQ6CJiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2fl/5SWRuCveYYcAAAAASUVORK5CYII=\n" }, + "metadata": {}, "output_type": "display_data" } ], @@ -409,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 14, "id": "bf9084a9", "metadata": {}, "outputs": [ @@ -441,17 +690,19 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 15, "id": "fa0679d0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(5000, 3, 10)" - ] + "text/plain": "(5000, 3, 10)" }, - "execution_count": 43, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -462,21 +713,13 @@ "\n", "current.shape" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "26d3e6e1", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "name": "brainpy", "language": "python", - "name": "python3" + "display_name": "brainpy" }, "language_info": { "codemirror_mode": { @@ -524,4 +767,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 52db9167550b83baa2f675ba184f0216ceaacb4b Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 14:27:41 +0800 Subject: [PATCH 07/22] doc: update dde documentation --- .../dde_numerical_solvers.ipynb | 289 +++++++----------- 1 file changed, 103 insertions(+), 186 deletions(-) diff --git a/docs/tutorial_toolbox/dde_numerical_solvers.ipynb b/docs/tutorial_toolbox/dde_numerical_solvers.ipynb index 84b72c543..202b1098d 100644 --- a/docs/tutorial_toolbox/dde_numerical_solvers.ipynb +++ b/docs/tutorial_toolbox/dde_numerical_solvers.ipynb @@ -84,7 +84,7 @@ "BrainPy provides several kinds of delay variables: \n", "\n", "\n", - "- [brainpy.math.FixedLenDelay](../apis/auto/math/generated/brainpy.math.delay_vars.FixedLenDelay.rst)\n", + "- [brainpy.math.TimeDelay](../apis/auto/math/generated/brainpy.math.delay_vars.TimeDelay.rst)\n", "- [brainpy.math.NeutralDelay](../apis/auto/math/generated/brainpy.math.delay_vars.NeutralDelay.rst)" ] }, @@ -92,7 +92,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "All of these can be used for defining delay differential equations. ``brainpy.math.FixedLenDelay`` can be used to define delay variables which depend on states, and ``brainpy.math.NeutralDelay`` is used to define delay variables which depend on the derivative. " + "All of these can be used for defining delay differential equations. ``brainpy.math.TimeDelay`` can be used to define delay variables which depend on states, and ``brainpy.math.NeutralDelay`` is used to define delay variables which depend on the derivative." ] }, { @@ -109,7 +109,7 @@ } ], "source": [ - "d = bm.FixedLenDelay(shape=1, delay_len=10, dt=1, t0=0, before_t0=lambda t: t)" + "d = bm.TimeDelay(bm.zeros(1), delay_len=10, dt=1, t0=0, before_t0=lambda t: t)" ] }, { @@ -119,9 +119,7 @@ "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([0.], dtype=float32)" - ] + "text/plain": "DeviceArray([0.], dtype=float32)" }, "execution_count": 3, "metadata": {}, @@ -141,9 +139,7 @@ "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([-0.5], dtype=float32)" - ] + "text/plain": "DeviceArray([-0.5], dtype=float32)" }, "execution_count": 4, "metadata": {}, @@ -167,26 +163,7 @@ "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR:absl:Outside call . at 0x000001F4686F41F0> threw exception \n", - "!!! Error in FixedLenDelay: \n", - "The request time should be less than the current time 0. But we got 0.10000000149011612 > 0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "!!! Error in FixedLenDelay: \n", - "The request time should be less than the current time 0. But we got 0.10000000149011612 > 0\n" - ] - } - ], + "outputs": [], "source": [ "try:\n", " d(0.1)\n", @@ -210,39 +187,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "['euler',\n", - " 'Euler',\n", - " 'midpoint',\n", - " 'MidPoint',\n", - " 'heun2',\n", - " 'Heun2',\n", - " 'ralston2',\n", - " 'Ralston2',\n", - " 'rk2',\n", - " 'RK2',\n", - " 'rk3',\n", - " 'RK3',\n", - " 'heun3',\n", - " 'Heun3',\n", - " 'ralston3',\n", - " 'Ralston3',\n", - " 'ssprk3',\n", - " 'SSPRK3',\n", - " 'rk4',\n", - " 'RK4',\n", - " 'ralston4',\n", - " 'Ralston4',\n", - " 'rk4_38rule',\n", - " 'RK4Rule38']" - ] + "text/plain": "['euler',\n 'midpoint',\n 'heun2',\n 'ralston2',\n 'rk2',\n 'rk3',\n 'heun3',\n 'ralston3',\n 'ssprk3',\n 'rk4',\n 'ralston4',\n 'rk4_38rule']" }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -291,14 +243,14 @@ "def equation(x, t, xdelay):\n", " return -xdelay(t-1)\n", "\n", - "case1_delay = bm.FixedLenDelay((1,), 1., before_t0=-1.)\n", - "case2_delay = bm.FixedLenDelay((1,), 1., before_t0=0.)\n", - "case3_delay = bm.FixedLenDelay((1,), 1., before_t0=1.)" + "case1_delay = bm.TimeDelay(bm.zeros((1,)), 1., before_t0=-1., interp_method='round')\n", + "case2_delay = bm.TimeDelay(bm.zeros((1,)), 1., before_t0=0., interp_method='round')\n", + "case3_delay = bm.TimeDelay(bm.zeros((1,)), 1., before_t0=1., interp_method='round')" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -313,72 +265,65 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [ { "data": { + "text/plain": " 0%| | 0/200 [00:00" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -428,78 +373,70 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def eq(x, t, xdelay): \n", " return -xdelay(t-2)\n", "\n", - "delay1 = bm.FixedLenDelay(1, 2., before_t0=lambda t: bm.exp(-t)-1, dt=0.01)\n", - "delay2 = bm.FixedLenDelay(1, 2., before_t0=lambda t: bm.exp(t)-1, dt=0.01)\n", - "delay3 = bm.FixedLenDelay(1, 2., before_t0=lambda t: bm.exp(-t)-1, dt=0.01)\n", - "delay4 = bm.FixedLenDelay(1, 2., before_t0=lambda t: bm.exp(t)-1, dt=0.01)" + "delay1 = bm.TimeDelay(bm.zeros(1), 2., before_t0=lambda t: bm.exp(-t)-1, dt=0.01, interp_method='round')\n", + "delay2 = bm.TimeDelay(bm.zeros(1), 2., before_t0=lambda t: bm.exp(t)-1, dt=0.01, interp_method='round')\n", + "delay3 = bm.TimeDelay(bm.zeros(1), 2., before_t0=lambda t: bm.exp(-t)-1, dt=0.01, interp_method='round')\n", + "delay4 = bm.TimeDelay(bm.zeros(1), 2., before_t0=lambda t: bm.exp(t)-1, dt=0.01, interp_method='round')" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "scrolled": false }, "outputs": [ { "data": { + "text/plain": " 0%| | 0/400 [00:00" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -570,19 +505,17 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { + "text/plain": " 0%| | 0/1000 [00:00" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -649,21 +580,19 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "lines_to_next_cell": 2 }, "outputs": [ { "data": { + "text/plain": " 0%| | 0/300 [00:00" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -746,19 +673,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { + "text/plain": " 0%| | 0/1600 [00:00" - ] + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -826,7 +749,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -848,43 +771,39 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "delay1 = bm.FixedLenDelay(1, 30., before_t0=-1, dt=0.01)\n", - "delay2 = bm.FixedLenDelay(1, 30., before_t0=1, dt=0.01)" + "delay1 = bm.TimeDelay(bm.ones(1), 30., before_t0=-1, dt=0.01)\n", + "delay2 = bm.TimeDelay(-bm.ones(1), 30., before_t0=1, dt=0.01)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { + "text/plain": " 0%| | 0/3000 [00:00" - ] + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAHACAYAAABaopmvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABM+UlEQVR4nO3de1xUZf4H8M+AMChXE+SigFgpKooCplhq6kZhma5WVJZoZmoX09Ey3S2M3PBa2npLRdvS1LylpZbsT0ELTEBQV01NEVBhCSpuKtfn98dZJscZYGYEzlw+79frvGTOnDN8z+FRPj7nOc9RCCEEiIiIiMycjdwFEBERETUFhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiMlJ6ejk6dOqGmpka9LjY2Ft27d0dtba3GtkIIxMbGIikpSb0uPj4eHTp0QHl5eYvVrC9DjqOl1dbWwsnJCTNnzjRov+LiYtjY2ODjjz9upsok9Z27plLfz6C+9mTK7YyoqTHUEBlpz5496Ny5M2xtbQEA169fx6JFixAbGwsbG82/WhcuXEBMTAzy8vLU66Kjo+Ho6IhFixa1aN2NMfQ4WtqZM2dQXl6Ovn37GrRfWloahBAG72eIhs5dU6nvZ1BfezLVdkbUHBhqiIyUkJCA119/Xf16+fLlcHNzw+jRo7W2TU9PBwCEhoaq17Vq1QqTJ0/G8uXLcePGjeYvWE+GHkdLO378OAAYFWpsbW3Rp0+f5igLQMPnrqnU9zOorz2ZajsjahaCiNT++te/ig4dOmitr6qqEsHBweIvf/mLEEKIP/74Q/j7+4uqqiohhBAVFRWiXbt24q233tLaNyQkRADQWJycnERtba3Iy8sTCoVCxMfHm8RxGXsczWXt2rUiKChIKJVK0aNHD/Hdd9+JV155RbRt21Zju6NHj4pHHnlEuLi4CDc3NzF8+HBx4cIFjW3GjBkjgoKCNNb99NNP4plnnhH+/v7CwcFBeHh4iFGjRolffvlFvU1TnDt9P6Mxjf0M6mtPLdXOiOTGnhqi2wwaNAjXrl1Ddna2xvqPPvoIP//8M1atWgUAOHToEF5++WW0atUKAPDTTz+hqKgIQ4YM0frMtWvXIiwsDCEhIUhJSUFKSgp++OEHKBQKeHl5ITAwEPv27au3JiEEqqur9Vru9riMPY7mMH36dEybNg2jRo3CgQMH8NprryE6OhoHDhxAWFiYert58+Zh8ODB8PX1xZYtW7B+/Xrk5uZi2LBhKCsrU2+Xlpam1buTmZmJ4OBgLF++HN9//z0+/vhjXLhwQaOnpSnOnb6f0ZjGfgb1tSd92hmRRZA7VRGZkvT0dAFAfPnll+p1ly9fFm3atBGxsbHqdXPnzhX5+fnq1wsXLhQANNbdrn379mLatGk63xs7dqzw9PSst6bDhw9r/e+8viUrK+uujutujqMp7dixQwAQW7du1Vj/4YcfCgBi7ty5QgghvvnmGwFALFq0SGO7CxcuCABi06ZNQgghfv31VwFArFq1qt7vWVNTI6qqqsT69esFAPH7778LIZrm3On7Gfpo7GdQX3tqrJ0RWYJWLZifiExe79694eLigh9//BHPPfccAGDq1Knw9fXF7Nmz1dv94x//0Njv+vXrUCgUcHd31/rM3NxcFBQU1DsOpX379igoKEB1dbW65+d2oaGhSE1N1at+Hx+fuzquuzkOAEhMTNTZU6FLRkYGevfurfO9Dz74AH379kVUVJTG+u7duwOAuqfmvffew7333os333xTo6cqICAArVu3xuXLlwFAff5u7+ERQmDnzp1YtWoVfv75Z+Tn50MIAQCwsbFB69atATTNudP3Mxqjz8+gvvbUWDsjsgRs2US3sbGxwYABA5CcnAwA2Lx5M77//nscPnwY9vb29e538+ZN2NnZqe+Eul1jg2sdHBwghMCtW7fg5OSk9b6Tk1O9v/zvVN8vK32P626OAwC6du2KdevW6VWrn5+fzvX5+fk4efKkzluvr169CkAaJJyfn4+MjAwAgFKp1PlZbm5uAKRLT/b29ujVq5f6vVdeeQWfffYZJk+ejGnTpsHDwwNKpRIvv/wybt68qf7Mpjh3xrarO+nzM6ivPTXWzogsAUMN0R0GDRqEd999Fzk5OVCpVIiOjsbDDz/c4D7u7u6orKxEeXk5HB0dNd5LT09HmzZtEBgYqHPf3377DUqlst5fNElJSXr3fmRlZaFTp04639PnuO7mOADA29sbL7/8sl611qcuuHh7e2u99+WXX8LLywsdO3ZU9758/PHHeOihh3R+1r333gtACjW9evVSB5Xz589j/fr1WLRoEd566y319oWFhThz5gyeeeYZjc+523On72c0Rp+fQX3tqbF2RmQJGGqI7jBo0CDU1NTgiSeeQE1NDZYsWdLoPnW/ZC5duqTRGwAAp06dQmBgoM7/wQPA5cuX1ZdVdGmKy0+Afsd1N8fRVDw8PAAA//nPfzQuP+3YsQPJycl44oknAAD33HMPAEChUGhcVtIlNTUVI0eOVL+uG7B753mvu4x15+fd7bnT9zMao8/PoL721Fg7I7IEDDVEd+jbty9at26N06dPY8OGDTrHSNyp7n/cx44d0/qF5ubmhqSkJOzZsweenp7w9vaGv78/AGl23OPHj2PixIn1frazs3Ojv7T1oc9xGXscTcnPzw99+/bFxx9/DA8PD/Tq1QtHjhzB8uXL1ccBSL0wQ4YMwd///neUlZWhX79+EEIgLy8Phw8fVveE5OXlIS8vT+POp+DgYLRp0wbvvvsuFAoFbt68iXXr1uGXX34BAK3zfbfnTt/PUCgUGDx4MBITE3Wem8Z+BvW1J33aGZFFkHOUMpEpqqqqEj4+PmLgwIEGzcEycOBAMXz4cK31ly5dEoMHDxaOjo4CgFi6dKn6vf/7v/8TAER6enqT1N4QfY/LmONoallZWeKxxx4TTk5Ows3NTYwYMULEx8cLAGLfvn3q7YqLi8WcOXNEly5dhIODg2jbtq0IDg4Wb7zxhvrupT179ggA4uTJkxrf49tvvxWBgYFCqVSK7t27i+XLl4v58+cLGxsbUVpaqrHt3Z47fT6jtLRUABDPPvtsvZ/f2M+gvvbUku2MSE4MNUR3WLx4sbC3txdnz541aL8dO3YIW1tbcfXqVb33eeGFF8SAAQMMLdEo+h6XMcdh6Zri3DX2Gfv27RMKhUKcOnXK6Drra08t2c6I5MRQQySEKC8vF8nJyWL58uXC3t5eLF682ODPqK2tFf379xevvfaaXtv/8ssvws7OThw9etTg76UvY47L0OOwVE1x7gz5jFmzZonnnnvO6Hrra08t0c6ITAVDDZEQYvfu3QKA8PLyEvPmzTP6c06fPi3+8Y9/iJqamka3PXTokPj000+N/l76MPa4DDkOS9UU566p2pU+6mtPLdHOiEyFQoj/zTZFREREZMb47CciIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiK3X9+nUoFAqsW7cOAFBcXAwbGxssW7ZMr/3LysowadIkdOjQAa1atULnzp0BALGxsejevTtqa2vV2wohEBsbi6SkJI3PiI+PR4cOHVBeXt40B9WCSktL8fbbbyMiIgIeHh5QKBSYN2+e3GURWTWGGiIr5ejoiJSUFDz33HMAgLS0NAgh8MADD+i1v0qlws6dO7F06VIcPXoU3377La5fv45FixYhNjYWNjZ//vNy4cIFxMTEIC8vT+MzoqOj4ejoiEWLFjXdgbWQoqIirF27FhUVFRg1apTc5RARgFZyF0BE8nB1dUX//v3Vr9PS0mBnZ4eQkJBG962srMSWLVswdepUPPvss+r1s2fPhpubG0aPHq2xfXp6OgAgNDRUY32rVq0wefJkfPDBB5g9ezbatGlzN4fUovz9/fH7779DoVCgsLAQ69evl7skIqvHnhoiKxUREYFBgwapX6empqJnz544duwYhg0bBicnJ3h5eSE2NlZjvwkTJkCpVKKsrAyLFy+GQqFA//79UVlZifj4eDz//PMavTShoaEYO3YsAKBLly5QKBRwdnaGEAIAMHbsWJSUlGDr1q0tcNRNR6FQQKFQyF0GEd2GoYbISmVkZGj0nKSlpeHXX3+FSqVCdHQ09u7di0GDBiEmJkZjLMzs2bMxZ84cAMDevXuRkpKCL774Aj/99BOKioowZMgQje+zdu1ahIWFISQkBCkpKUhJScEPP/ygDgReXl4IDAzEvn37dNYphEB1dbVeCxFZN7MKNUeOHMGIESPg4+MDhUKBr7/+2uDP+P7779G/f384OzvDw8MDY8aMQVZWVtMXS2TCsrOzUVhYqA41hYWFyM7OhpeXF1JSUjBu3DgMHToUH3/8MQDg7Nmz6n0DAwNRVlaGtm3bYsSIEejfvz/uv/9+pKSkAIDW5avQ0FDk5OTgoYceQv/+/dG/f38EBwdrbBMSEoIff/xRZ61JSUmws7PTa7ly5UpTnSIiMkNmNaamvLwcwcHBmDBhAsaMGWPw/pcvX8bIkSOhUqmwefNmFBcXY8aMGRg9ejQyMjKaoWIi01Q3xqUugKSmpgIA5s+fD6VSqd6uqKgIAODj46O1/53jY+rupnJ3d9dYn5ubi4KCAq3tb9e+fXsUFBSguroarVpp/rMUGhqqrq8xd9ZZn8TERK0epfpkZGSgd+/eem1LRPIyq1ATGRmJyMjIet+vrKzE3//+d2zevBl//PEHgoKCsHDhQjz88MMAgBMnTqCmpgbz589XX/OfNWsWRo4ciaqqKtjZ2bXEYRDJ7sSJE3B0dERgYCAA6dJT69atMXToUK3tAKBPnz7qdTU1NcjMzMQbb7yhse3NmzdhZ2cHW1tbjfX1DRK+nYODA4QQuHXrFpycnDTec3Jy0jtU3BmI6tO1a1f1reyN8fPz02s7IpKfWYWaxkyYMAFXrlzB1q1b4ePjg927d+Oxxx7D6dOncf/99yMsLAy2trbYuHEjxo8fj7KyMnzxxReIiIhgoCGrkp6ejt69e6vDfVpaGoKDg7VCQVpaGtzd3TV+sZ87dw43btzQCinu7u6orKxEeXk5HB0dNb5XmzZt1AFKl99++w1KpVIr0ADS5Sd9e1WysrLQqVOnRrfz9vbGyy+/rNdnEpH5sJhQc+nSJWzZsgVXr15Vd0HPmjUL3333HTZu3IgPP/wQnTp1wsGDB/H0009j8uTJqKmpQXh4OPbv3y9z9UQt68SJE4iKilK/Tk1N1boNG9B9mSktLQ2Ads9LXWi5dOkSevXqpV5/6tQpBAYGavXg3O7y5cvo3r27zvea4/ITEVkmiwk1J06cgBACXbp00VhfUVGBdu3aAQDy8/Px8ssvIzo6Gs899xxKS0vx3nvv4amnnkJCQgJvzySrcPXqVY0xLnl5ecjLy0NYWJjGdtXV1Th58iRUKpXG+vT0dLi5ualnEK5Td5n32LFjGqHGzc0NSUlJ2LNnDzw9PeHt7Q1/f3/1+7W1tTh+/DgmTpyos15nZ2et2kzFgQMHUF5ejtLSUgDSgOodO3YAAIYPH25W8+4QWQKLCTW1tbWwtbVFenq61v8I67q0V65cCRcXF43ZSzdt2gRfX1/89NNPGhOREVmq+gYJ39nzcvbsWdy8eVNrfXp6us4J+nx9fTFw4EDs2bMHr7zyinp9TEwMsrOzMXbsWJSXl2Pp0qUaQSkxMRHFxcXquWzMydSpU5Gdna1+vX37dmzfvh2A/pfCiKjpWEyo6dOnD2pqalBQUICBAwfq3ObGjRtagafu9e3PqSGyZCNHjlRPfAcATz75pMbrOr169dK5Pjk5ud7PfvPNNxEVFYVr166hQ4cOAIDOnTsjMTGx3n02btyIAQMG6DWTsanhLeREpsWs5qkpKytDZmYmMjMzAUj/E8rMzEROTg66dOmCsWPHYty4cdi1axeysrKQmpqKhQsXqsfMPP7440hNTUVsbCwuXryIEydOYMKECfD399e4u4OIjDN69Gj07dsXcXFxem1/6dIlbNu2DQsXLmzmyojIGphVqElLS0OfPn3UAUSlUqFPnz547733AEj/4xs3bhxmzpyJrl274sknn8RPP/0EX19fAMDQoUPx5Zdf4uuvv0afPn3w2GOPQalU4rvvvkPr1q1lOy4iS1H31G8fHx+9ej9zcnKwYsUKPPTQQy1QHRFZOoXQ1b9MREREZGbMqqeGiIiIqD4MNURERGQRzOLup9raWly/fh3Ozs6cS4aIiMjKCCFQWloKHx8f9UzouphFqLl+/bp6sC8RERFZp9zcXHTs2LHe980i1Dg7OwOQDsbFxUXmaoiIiKgllZSUwNfXV50H6mMWoabukpOLiwtDDRERkZVqbAgKBwoTERGRRWCoISIiIovAUENERER35+BBYPx44OZNWcswizE1REREZMLWrAEuXwYcHGQtgz01REREZLyCAuCbb4CJEwGZ55JjqCEiIiLjffEFYGsLjB0rdyUMNURERGQkIYD4eOCvfwXuuUfuahhqiIiIyEjHjgHnzkmXnkyAwaHmyJEjGDFiBHx8fKBQKPD11183uk9SUhJCQ0Ph4OCAzp07Y82aNcbUSkRERKYkPh7w9weGDpW7EgBGhJry8nIEBwdjxYoVem2flZWF4cOHY+DAgcjIyMDcuXMxbdo07Ny50+BiiYiIyESUlQHbtgETJgANPGSyJRl8S3dkZCQiIyP13n7NmjXw8/PDsmXLAADdunVDWloalixZgjFjxhj67YmIiMgUfPUVUF4uhRoT0ezRKiUlBRERERrrHn30UaSlpaGqqkrnPhUVFSgpKdFYiIiIyITExwOPPAL4+cldiVqzh5r8/Hx4enpqrPP09ER1dTUKCwt17hMXFwdXV1f14uvr29xlEhERkb5OnwaSk4FJk+SuREOLXAS786maQgid6+vMmTMHxcXF6iU3N7fZayQiIiI9rV4NeHsDI0fKXYmGZn9MgpeXF/Lz8zXWFRQUoFWrVmjXrp3OfZRKJZRKZXOXRkRERIYqLZUm3JsxA7Czk7saDc3eUxMeHo6EhASNdQcPHkRYWBjsTOxkEBERUSM2bwZu3DC5S0+AEaGmrKwMmZmZyMzMBCDdsp2ZmYmcnBwA0qWjcePGqbefMmUKsrOzoVKpcO7cOWzYsAHx8fGYNWtW0xwBERERtQwhpEtPI0YAJjje1eBQk5aWhj59+qBPnz4AAJVKhT59+uC9994DAOTl5akDDgAEBARg//79SExMRO/evfHBBx/gk08+4e3cRERE5iYlBTh1Cpg6Ve5KdFKIulG7JqykpASurq4oLi6Gi4uL3OUQERFZpxdflILNhQstOuGevjnANKYAJCIiItNWWChNuDd5ssnMIHwn06yKiIiITMvGjYBCYVIzCN+JoYaIiIgaVl0NrFwJREUB7u5yV1MvhhoiIiJq2J49QHY28OabclfSIIYaIiIiatiyZcCgQUBIiNyVNKjZZxQmIiIiM5aWBvzwA7Brl9yVNIo9NURERFS/5cuBTp2AJ5+Uu5JGMdQQERGRbtevA9u2AdOmAba2clfTKIYaIiIi0m31akCpBF56Se5K9MJQQ0RERNpu3gTWrJECjaur3NXohaGGiIiItH3xBVBUBLzxhtyV6I2hhoiIiDTV1ACLFwNjxgD33Sd3NXrjLd1ERESkadcu4JdfgC1b5K7EIOypISIioj8JASxYAAwbBoSFyV2NQdhTQ0RERH/697+BEyeAhAS5KzEYe2qIiIjoTwsWAKGhUk+NmWFPDREREUlSU4FDh4Dt2wGFQu5qDMaeGiIiIpIsXAjcfz/w17/KXYlR2FNDREREwNmz0l1Pn35qFo9E0IU9NURERAR88AHQsSMQHS13JUZjTw0REZG1O3NGenDl6tWAvb3c1RiNPTVERETW7oMPAF9fYMIEuSu5K+ypISIismZnzgBffSU9vNKMe2kA9tQQERFZt9hYwM8PGD9e7kruGntqiIiIrNV//iPNSfPpp2bfSwOwp4aIiMg6CQHMnCn10pjxHU+3Y08NERGRNdqxAzh4ENi0ySJ6aQD21BAREVmf6mrg3XeBxx4Dxo6Vu5omw54aIiIia/Phh8D588CWLXJX0qTYU0NERGRNcnOlUDNpEtCnj9zVNCmGGiIiImsSEwO4uABLl8pdSZPj5SciIiJrcfIk8NlnwCefAM7OclfT5NhTQ0REZA2EAFQqoEsXYPJkuatpFuypISIisgbffgscOgR88w1gZyd3Nc2CPTVERESWrqoKmDUL+MtfgMcfl7uaZsOeGiIiIku3ejXwyy/SIxEUCrmraTbsqSEiIrJkv/0GzJsHTJwI9OoldzXNiqGGiIjIks2bJ11+io2Vu5Jmx8tPREREliojA1i5Eli4EPDykruaZseeGiIiIktUWwu8+irQrRvw5ptyV9Mi2FNDRERkiTZuBI4dAxITLfYW7juxp4aIiMjSFBUBs2cDL74IDB4sdzUthqGGiIjI0sydC1RXA4sXy11Ji+LlJyIiIkuSnAysWyc938nTU+5qWhR7aoiIiCzFrVvSfDQPPABMnSp3NS2OPTVERESW4oMPgEuXpFu5bW3lrqbFsaeGiIjIEmRmSvPRvPsu0KOH3NXIwqhQs2rVKgQEBMDBwQGhoaE4evRovdsmJiZCoVBoLT///LPRRRMREdFtqqqAl14CuneX7nqyUgZfftq2bRumT5+OVatW4cEHH8Snn36KyMhInD17Fn5+fvXud/78ebi4uKhfe3h4GFcxERERaVqyBDh5UpqXxt5e7mpkY3BPzUcffYSJEyfi5ZdfRrdu3bBs2TL4+vpi9erVDe7Xvn17eHl5qRdbK7zWR0RE1OQyM4GYGGDWLKBvX7mrkZVBoaayshLp6emIiIjQWB8REYHk5OQG9+3Tpw+8vb0xbNgwHD58uMFtKyoqUFJSorEQERHRHW7dAl54QbrsZAUPrGyMQaGmsLAQNTU18LzjvndPT0/k5+fr3Mfb2xtr167Fzp07sWvXLnTt2hXDhg3DkSNH6v0+cXFxcHV1VS++vr6GlElERGQd5swBfvkF2LQJUCrlrkZ2Rt3SrVAoNF4LIbTW1enatSu6du2qfh0eHo7c3FwsWbIEgwYN0rnPnDlzoFKp1K9LSkoYbIiIiG73738Dy5YBH30EBAXJXY1JMKinxt3dHba2tlq9MgUFBVq9Nw3p378/Ll68WO/7SqUSLi4uGgsRERH9T1ERMH48MGyY1TyBWx8GhRp7e3uEhoYiISFBY31CQgIGDBig9+dkZGTA29vbkG9NREREgPRMp6goaTzNZ58BNpxyro7Bl59UKhVefPFFhIWFITw8HGvXrkVOTg6mTJkCQLp0dO3aNXz++ecAgGXLlqFTp07o0aMHKisrsWnTJuzcuRM7d+5s2iMhIiKyBjNnAomJQEIC0LGj3NWYFINDTVRUFIqKihAbG4u8vDwEBQVh//798Pf3BwDk5eUhJydHvX1lZSVmzZqFa9euoXXr1ujRowf27duH4cOHN91REBERWYMNG6QHVa5cCQwZInc1JkchhBByF9GYkpISuLq6ori4mONriIjIOv34oxRkJkwA1qwB6rlBxxLpmwN4IY6IiMjU5eYCo0cD/fsD//ynVQUaQzDUEBERmbIbN4BRowAHB2DHDqt+DEJjjJqnhoiIiFqAEMDEicDPP0uXn9q3l7sik8ZQQ0REZKoWLAC2bgW++gro3VvuakweLz8RERGZoq++AubOBd57D3j6abmrMQsMNURERKbmxx+BceOA558H5s2TuxqzwVBDRERkSi5eBEaOBPr1k+al4Z1OemOoISIiMhWFhcDw4YC7O7B7N5+8bSAOFCYiIjIFZWXAiBFAcTFw7Bhwzz1yV2R2GGqIiIjkVlEhzUVz5gxw6BDQubPcFZklhhoiIiI5VVcDzz0H/PAD8N13QFiY3BWZLYYaIiIiudTWAi+/DHzzjTSG5uGH5a7IrDHUEBERyaG2Fnj9deDzz4HNm4EnnpC7IrPHUENERNTSamuByZOB+Hhg/Xrp8hPdNYYaIiKillRTI11y+te/gM8+kybZoybBUENERNRSqquBCROAL78ENm2SZgymJsNQQ0RE1BJu3ACefRbYv18KNVFRcldkcRhqiIiImltRkTSx3smT0p1OkZFyV2SRGGqIiIiaU3a2FGJ+/RU4fBh44AG5K7JYfPYTERFRc9m+HejeHbh5U3ryNgNNs2KoISIiamrV1cCsWcAzz0gPqDx+HOjSRe6qLB4vPxERETWlvDxpQHByMrBsGTBtGqBQyF2VVWCoISIiaiqJiVKgsbGRHkw5cKDcFVkVXn4iIiK6W7W1wIIFwLBh0hiajAwGGhkw1BAREd2N/Hzpdu05c6QlIQHw9JS7KqvEy09ERETG2r0bmDQJsLUF9u2TBgWTbNhTQ0REZKiSEuCll4DRo4GHHgL+8x8GGhPAnhoiIiJD7NkDvP468Mcf0lO2J0zg3U0mgj01RERE+rh2TeqZGTUK6NkTOH1a6q1hoDEZDDVEREQNqaiQ5pvp1g1ISQG2bZPGz3TqJHdldAeGGiIiIl0qK4FPPwXuuw+YORMYOxY4d06aJZi9MyaJoYaIiOh21dXAxo1A167A1KnSfDNnzwKrVwNubnJXRw3gQGEiIiIAqKkBtm4F3n8fuHgRGDMG+OYbIChI7spIT+ypISIi61ZVBWzaJA3+feEFIDAQOHEC2LGDgcbMMNQQEZF1unED+Oc/gfvvB158URr4+9NPwN69QJ8+cldHRuDlJyIisi5XrwLr1gGrVgG//SY9gHLPHiA4WO7K6C4x1BARkeWrrZWemr1qldQT4+AAjB8v3dUUECB3ddREGGqIiMhyXbkCfPkl8K9/ARcuAD16AJ98Io2dcXGRuzpqYgw1RERkWX7/Hdi+XRr8e/Qo0KYN8Ne/AuvXS89p4hwzFouhhoiIzJsQ0qR4Bw5Iy5Ej0u3ZjzwCfPGF9FgDJye5q6QWwFBDRETmp6xMGiNTF2Sys6VxMg8/DCxdCjz1FODtLXeV1MIYaoiIyPRVVQFpaUBiohRmjhyRHmNw333Ak08CkZFSoGndWu5KSUYMNUREZHrKyqQJ8H78UQoyP/wgzSvj7Cw9tmDxYinI3H+/3JWSCWGoISIied26JT1b6fhxIDVV+vPsWek27LoQM2+e1BPTpw/Qir+6SDe2DCIian5CAPn5wM8/A+fP/7n8/LN027UQgK0t0KsXMGAAMH060Lcv0L07QwzpjS2FiIiaRlUVkJsrhZS65fLlPwNMaam0na0tcO+90lOwx4yR/uzeXeqF4ZgYugtGhZpVq1Zh8eLFyMvLQ48ePbBs2TIMHDiw3u2TkpKgUqlw5swZ+Pj44O2338aUKVOMLpqIiFrQjRtAQYG0/Pe/2l9fuyYFmKtXpUtGgDQXjI+P9Dylnj2Bp5+WwkvXrkDnzoC9vZxHRBbK4FCzbds2TJ8+HatWrcKDDz6ITz/9FJGRkTh79iz8/Py0ts/KysLw4cMxadIkbNq0CT/++CNeffVVeHh4YMyYMU1yEERE1AAhpHErN25IA3B//11a/vhD99d1S114KSvT/sx27YD27aWlQwdpUrtOnf5c/PwApbJFD5NIIYQQhuzQr18/hISEYPXq1ep13bp1w6hRoxAXF6e1/ezZs7F3716cO3dOvW7KlCk4efIkUlJS9PqeJSUlcHV1RXFxMVw4rTURyU0IqUeipkb68/avG1tXXS3dilxVJf1Ztxj6+uZNKaTouzTE2RlwcwPatpWWuq/btwc8Pf8ML3Vfu7sDdnYtcaaJAOifAwzqqamsrER6ejreeecdjfURERFITk7WuU9KSgoiIiI01j366KOIj49HVVUV7HT8xaioqEBFRYXGwTSb+Hjpaa0N0Sf3mdI2plSLpW5jSrVY6jYtXcudQaShgNKS7O2lAGFv/+fXdnbS1P91i6Oj9BwjLy/N9Xcujo7Sn7eHFzc3DsQli2FQSy4sLERNTQ08PT011nt6eiI/P1/nPvn5+Tq3r66uRmFhIbx1zPgYFxeH999/35DSjOfhAQQFNb6dPs8KMaVtTKkWS93GlGqx1G1ashYbG2kA6+1/6lrX0Hv6bG9r+2dA0RVYbv+6VSs+p4jIAEbFc8Udf8mEEFrrGtte1/o6c+bMgUqlUr8uKSmBr6+vMaU27sknpYWIiIjMmkGhxt3dHba2tlq9MgUFBVq9MXW8vLx0bt+qVSu0a9dO5z5KpRJKDjAjIiIiA9gYsrG9vT1CQ0ORkJCgsT4hIQEDBgzQuU94eLjW9gcPHkRYWJjO8TRERERExjAo1ACASqXC+vXrsWHDBpw7dw4zZsxATk6Oet6ZOXPmYNy4certp0yZguzsbKhUKpw7dw4bNmxAfHw8Zs2a1XRHQURERFbP4DE1UVFRKCoqQmxsLPLy8hAUFIT9+/fD398fAJCXl4ecnBz19gEBAdi/fz9mzJiBlStXwsfHB5988olBc9TUjcFp1rugiIiIyCTV/f5vbBYag+epkcPVq1ebb6AwERERmYXc3Fx07Nix3vfNItTU1tbi+vXrcHZ2bvAuK2PU3VmVm5vLif0MwPNmHJ434/C8GYfnzXA8Z8Zp7vMmhEBpaSl8fHxgY1P/yBmzmHHJxsamwWTWFFxcXNiAjcDzZhyeN+PwvBmH581wPGfGac7z5urq2ug2Bg8UJiIiIjJFDDVERERkEaw+1CiVSsTExHCyPwPxvBmH5804PG/G4XkzHM+ZcUzlvJnFQGEiIiKixlh9Tw0RERFZBoYaIiIisggMNURERGQRGGqIiIjIIjDUEBERkUWw6lCzatUqBAQEwMHBAaGhoTh69KjcJZm8efPmQaFQaCxeXl5yl2VSjhw5ghEjRsDHxwcKhQJff/21xvtCCMybNw8+Pj5o3bo1Hn74YZw5c0aeYk1IY+dt/PjxWm2vf//+8hRrQuLi4tC3b184Ozujffv2GDVqFM6fP6+xDducNn3OG9ucptWrV6NXr17qWYPDw8Nx4MAB9fum0M6sNtRs27YN06dPx9/+9jdkZGRg4MCBiIyM1HjCOOnWo0cP5OXlqZfTp0/LXZJJKS8vR3BwMFasWKHz/UWLFuGjjz7CihUrkJqaCi8vLzzyyCMoLS1t4UpNS2PnDQAee+wxjba3f//+FqzQNCUlJeG1117DsWPHkJCQgOrqakRERKC8vFy9DducNn3OG8A2d7uOHTtiwYIFSEtLQ1paGoYOHYqRI0eqg4tJtDNhpR544AExZcoUjXWBgYHinXfekaki8xATEyOCg4PlLsNsABC7d+9Wv66trRVeXl5iwYIF6nW3bt0Srq6uYs2aNTJUaJruPG9CCBEdHS1GjhwpSz3mpKCgQAAQSUlJQgi2OX3ded6EYJvTR9u2bcX69etNpp1ZZU9NZWUl0tPTERERobE+IiICycnJMlVlPi5evAgfHx8EBATg2WefxeXLl+UuyWxkZWUhPz9fo+0plUoMHjyYbU8PiYmJaN++Pbp06YJJkyahoKBA7pJMTnFxMQDgnnvuAcA2p687z1sdtjndampqsHXrVpSXlyM8PNxk2plVhprCwkLU1NTA09NTY72npyfy8/Nlqso89OvXD59//jm+//57rFu3Dvn5+RgwYACKiorkLs0s1LUvtj3DRUZGYvPmzTh06BCWLl2K1NRUDB06FBUVFXKXZjKEEFCpVHjooYcQFBQEgG1OH7rOG8A2p8vp06fh5OQEpVKJKVOmYPfu3ejevbvJtLNWLfadTJBCodB4LYTQWkeaIiMj1V/37NkT4eHhuPfee/Gvf/0LKpVKxsrMC9ue4aKiotRfBwUFISwsDP7+/ti3bx9Gjx4tY2Wm4/XXX8epU6fwww8/aL3HNle/+s4b25y2rl27IjMzE3/88Qd27tyJ6OhoJCUlqd+Xu51ZZU+Nu7s7bG1ttdJjQUGBVsqkhjk6OqJnz564ePGi3KWYhbo7xdj27p63tzf8/f3Z9v7njTfewN69e3H48GF07NhRvZ5trmH1nTdd2OYAe3t73HfffQgLC0NcXByCg4OxfPlyk2lnVhlq7O3tERoaioSEBI31CQkJGDBggExVmaeKigqcO3cO3t7ecpdiFgICAuDl5aXR9iorK5GUlMS2Z6CioiLk5uZafdsTQuD111/Hrl27cOjQIQQEBGi8zzanW2PnTRe2OW1CCFRUVJhOO2uxIckmZuvWrcLOzk7Ex8eLs2fPiunTpwtHR0dx5coVuUszaTNnzhSJiYni8uXL4tixY+KJJ54Qzs7OPG+3KS0tFRkZGSIjI0MAEB999JHIyMgQ2dnZQgghFixYIFxdXcWuXbvE6dOnxXPPPSe8vb1FSUmJzJXLq6HzVlpaKmbOnCmSk5NFVlaWOHz4sAgPDxcdOnSw+vM2depU4erqKhITE0VeXp56uXHjhnobtjltjZ03tjltc+bMEUeOHBFZWVni1KlTYu7cucLGxkYcPHhQCGEa7cxqQ40QQqxcuVL4+/sLe3t7ERISonErH+kWFRUlvL29hZ2dnfDx8RGjR48WZ86ckbssk3L48GEBQGuJjo4WQki32MbExAgvLy+hVCrFoEGDxOnTp+Ut2gQ0dN5u3LghIiIihIeHh7CzsxN+fn4iOjpa5OTkyF227HSdMwBi48aN6m3Y5rQ1dt7Y5rS99NJL6t+ZHh4eYtiwYepAI4RptDOFEEK0XL8QERERUfOwyjE1REREZHkYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiIiILAJDDREREVkEhhoiIiKyCAw1REREZBEYaoiIiMgiMNQQERGRRWCoISIiIovAUENEREQWgaGGiBp1/fp1KBQKrFu3DgBQXFwMGxsbLFu2TK/9y8rKMGnSJHTo0AGtWrVC586dAQCxsbHo3r07amtr1dsKIRAbG4ukpCSNz4iPj0eHDh1QXl7eNAfVgNLSUrz99tuIiIiAh4cHFAoF5s2b1+zfl4juDkMNETXK0dERKSkpeO655wAAaWlpEELggQce0Gt/lUqFnTt3YunSpTh69Ci+/fZbXL9+HYsWLUJsbCxsbP78p+jChQuIiYlBXl6exmdER0fD0dERixYtaroDq0dRURHWrl2LiooKjBo1qtm/HxE1jVZyF0BEps/V1RX9+/dXv05LS4OdnR1CQkIa3beyshJbtmzB1KlT8eyzz6rXz549G25ubhg9erTG9unp6QCA0NBQjfWtWrXC5MmT8cEHH2D27Nlo06bN3RxSg/z9/fH7779DoVCgsLAQ69evb7bvRURNhz01RNSoiIgIDBo0SP06NTUVPXv2xLFjxzBs2DA4OTnBy8sLsbGxGvtNmDABSqUSZWVlWLx4MRQKBfr374/KykrEx8fj+eef1+ilCQ0NxdixYwEAXbp0gUKhgLOzM4QQAICxY8eipKQEW7dubdbjVSgUUCgUzfo9iKjpMdQQUaMyMjI0ek7S0tLw66+/QqVSITo6Gnv37sWgQYMQExOjMRZm9uzZmDNnDgBg7969SElJwRdffIGffvoJRUVFGDJkiMb3Wbt2LcLCwhASEoKUlBSkpKTghx9+UAcMLy8vBAYGYt++fTrrFEKgurpar4WILA8vPxFRg7Kzs1FYWKgONYWFhcjOzkbfvn1x9OhRKJVKAEDXrl2xfft2nD17FoMHDwYABAYGoqysDG3btsWIESPUn7l7924A0Lp8FRoaipycHDz77LMal7tuFxISgn//+98630tKStIKSvXJyspCp06d9NqWiMyDWYWaI0eOYPHixUhPT0deXh52795t8CC+77//HjExMThz5gwcHBwwaNAgLFmyBAEBAc1TNJGZqxvjUhdAUlNTAQDz589XBxpAGlwLAD4+Plr73zk+pu5uKnd3d431ubm5KCgo0Nr+du3bt0dBQQGqq6vRqpXmP2GhoaHq+hpzZ51EZP7MKtSUl5cjODgYEyZMwJgxYwze//Llyxg5ciRUKhU2b96M4uJizJgxA6NHj0ZGRkYzVExk/k6cOAFHR0cEBgYCkC49tW7dGkOHDtXaDgD69OmjXldTU4PMzEy88cYbGtvevHkTdnZ2sLW11Vhf3yDh2zk4OEAIgVu3bsHJyUnjPScnJ/Tu3Vuv47ozEBGR+TOrMTWRkZGYP3++1t0SdSorK/H222+jQ4cOcHR0RL9+/ZCYmKh+/8SJE6ipqcH8+fNx7733IiQkBLNmzcLJkydRVVXVQkdBZF7S09PRu3dv9YDetLQ0BAcHa4WCtLQ0uLu7w8/PT73u3LlzuHHjhlZIcXd3R2VlpdacM+np6WjTpo06QOny22+/QalUagUaQLr8ZGdnp9dy5coVQ08FEZk4i/qvyoQJE3DlyhVs3boVPj4+2L17Nx577DGcPn0a999/P8LCwmBra4uNGzdi/PjxKCsrwxdffIGIiAjY2dnJXT6RSTpx4gSioqLUr1NTU3X+x0LXZaa0tDQA2j0vdaHl0qVL6NWrl3r9qVOnEBgYqNWDc7vLly+je/fuOt/j5Sci62YxoebSpUvYsmULrl69qv7HatasWfjuu++wceNGfPjhh+jUqRMOHjyIp59+GpMnT0ZNTQ3Cw8Oxf/9+masnMk1Xr17VGOOSl5eHvLw8hIWFaWxXXV2NkydPQqVSaaxPT0+Hm5ubegbhOg8//DAA4NixYxqhxs3NDUlJSdizZw88PT3h7e0Nf39/9fu1tbU4fvw4Jk6cqLNeZ2dnrdqMdeDAAZSXl6O0tBQAcPbsWezYsQMAMHz48GadJ4eIjGNWl58acuLECQgh0KVLFzg5OamXpKQkXLp0CQCQn5+Pl19+GdHR0UhNTUVSUhLs7e3x1FNPqefBIKI/1TdI+M6el7Nnz+LmzZta69PT03VO0Ofr64uBAwdiz549GutjYmLQu3dvjB07FuHh4di5c6fG+4mJiSguLlbPZdOcpk6diqeffhovvfQSAGD79u14+umn8fTTT6OgoKDZvz8RGU4hzPS3uUKh0Lj7adu2bRg7dizOnDmj1XVdNzHYu+++iwMHDqi7xAHpf6K+vr5ISUmp9xZSImp6O3fuRFRUFLKzs9GhQwe99nnxxRdx+fJl/Pjjj81cHRGZI4u5/NSnTx/U1NSgoKAAAwcO1LnNjRs3tAJP3evbH6hHRM1v9OjR6Nu3L+Li4rBixYpGt7906RK2bduGQ4cOtUB1RGSOzOryU1lZGTIzM5GZmQlAmjwrMzMTOTk56NKlC8aOHYtx48Zh165dyMrKQmpqKhYuXKgeM/P4448jNTUVsbGxuHjxIk6cOIEJEybA399f4zZUImp+dU/99vHx0es/FTk5OVixYgUeeuihFqiOiMyRWV1+SkxM1DlbaHR0ND777DNUVVVh/vz5+Pzzz3Ht2jW0a9cO4eHheP/999GzZ08AwNatW7Fo0SJcuHABbdq0QXh4OBYuXNjgLaRERERk+swq1BARERHVx6wuPxERERHVxywGCtfW1uL69etwdnZWP62XiIiIrIMQAqWlpfDx8VHPbq6LWYSa69evw9fXV+4yiIiISEa5ubno2LFjve+bRahxdnYGIB2Mi4uLzNUQERFRSyopKYGvr686D9THLEJN3SUnFxcXhhoiIiIr1dgQFA4UJiIiIovAUENEREQWgaGGiIiI7s6JE8DixUBFhaxlMNQQERHR3Vm5Eli1CrCzk7UMhhoiIiIyXmkpsG0bMGEC0MAcMi2BoYaIiIiM99VXwI0bwPjxclfCUENERER3IT4eiIgA/PzkrsQ85qkhIiIiE3TuHJCSIvXWmAD21BAREZFxNmwA2rUDnnxS7koAGBFqjhw5ghEjRsDHxwcKhQJff/11o/skJSUhNDQUDg4O6Ny5M9asWWNMrURERGQqqqqAzz8HXnwRUCrlrgaAEaGmvLwcwcHBWLFihV7bZ2VlYfjw4Rg4cCAyMjIwd+5cTJs2DTt37jS4WCIiIjIR334LFBQAEyfKXYmawWNqIiMjERkZqff2a9asgZ+fH5YtWwYA6NatG9LS0rBkyRKMGTNG5z4VFRWouG0Cn5KSEkPLJCIiouYUHw888AAQFCR3JWrNPqYmJSUFERERGuseffRRpKWloaqqSuc+cXFxcHV1VS++vr7NXSYRERHpKycHOHDApHppgBYINfn5+fD09NRY5+npierqahQWFurcZ86cOSguLlYvubm5zV0mERER6WvtWsDREXj+ebkr0dAit3Tf+ahwIYTO9XWUSiWUJjLoiIiIiG5TWQmsXw+MGwc4OcldjYZm76nx8vJCfn6+xrqCggK0atUK7dq1a+5vT0RERE3p66+B//4XmDpV7kq0NHuoCQ8PR0JCgsa6gwcPIiwsDHYyP/iKiIiIDLR6NTBwINCjh9yVaDE41JSVlSEzMxOZmZkApFu2MzMzkZOTA0AaDzNu3Dj19lOmTEF2djZUKhXOnTuHDRs2ID4+HrNmzWqaIyAiIqKWce4ckJhokr00gBFjatLS0jBkyBD1a5VKBQCIjo7GZ599hry8PHXAAYCAgADs378fM2bMwMqVK+Hj44NPPvmk3tu5iYiIyEStWQN4eACjR8tdiU4KUTdq14SVlJTA1dUVxcXFcHFxkbscIiIi61NeDnToIPXSxMW16LfWNwfw2U9ERETUuK1bgZISYPJkuSupF0MNERERNUwI4J//BIYPBzp1kruaejHUEBERUcOSkoCTJ4Hp0+WupEEMNURERNSwZcukW7iHDZO7kga1yIzCREREZKYuXQL27pUejVDPkwBMBXtqiIiIqH7//Cdwzz3A2LFyV9IohhoiIiLSrbgYiI8HpkwBWreWu5pGMdQQERGRbhs2ALduAa++KnclemGoISIiIm01NcAnnwBRUYCPj9zV6IUDhYmIiEjbnj3AlSvA9u1yV6I39tQQERGRJiGAhQuBwYOBsDC5q9Ebe2qIiIhIU2IicPw4cOCA3JUYhD01REREpGnBAiA4GHj0UbkrMQh7aoiIiOhPJ04ABw8CW7aY/GR7d2JPDREREf1p4UKgc2fgqafkrsRg7KkhIiIiyS+/ADt2ACtXAq3MLyKwp4aIiIgkS5YAHh7A+PFyV2IUhhoiIiICrl8HPvsMePNNwMFB7mqMwlBDRERE0h1PrVubzSMRdGGoISIisnbXrgFr1wIzZwKurnJXYzSGGiIiImu3cCHQpg0wbZrcldwVhhoiIiJrdnsvjYuL3NXcFYYaIiIia7ZggdRL88Ybcldy1xhqiIiIrNXVqxbTSwMw1BAREVmv994DnJwsopcGYKghIiKyTkeOABs3Am+/bRG9NABDDRERkfURApgzBwgKAt56S+5qmoz5PdiBiIiI7s5nnwHJycB33wE2ltO/YTlHQkRERI374w9pYPCjjwIREXJX06QYaoiIiKzJwoVARYU0nkahkLuaJsVQQ0REZC1ycoBlywCVCvD2lruaJsdQQ0REZC3mzpWe7fT223JX0iw4UJiIiMgaHD8ObN4MrFsHODvLXU2zYE8NERGRpRMCmDED6NULmDBB7mqaDXtqiIiILN327dIt3P/+N2BrK3c1zYY9NURERJbs1i1g9mxgxAhg2DC5q2lW7KkhIiKyZB9/LD248rvv5K6k2bGnhoiIyFLl5ADz5wPTpgFdu8pdTbNjqCEiIrJU06cDbm7AvHkyF9IyePmJiIjIEh04AOzeDWzdarG3cN+JPTVERESW5tYt4I03gL/8BXjmGbmraTHsqSEiIrI0CxdK42n27bO45zs1hD01REREluTiRSAuDpg1yyoGB9+OoYaIiMhS1NYCEycCHTsCf/+73NW0OF5+IiIishSffgocPQocOgS0aSN3NS2OPTVERESWICdHevr2K68AQ4bIXY0sjAo1q1atQkBAABwcHBAaGoqjR4/Wu21iYiIUCoXW8vPPPxtdNBEREd1GCGDKFMDVFVi0SO5qZGPw5adt27Zh+vTpWLVqFR588EF8+umniIyMxNmzZ+Hn51fvfufPn4eLi4v6tYeHh3EVExERkaZNm6R5afbulYKNlVIIIYQhO/Tr1w8hISFYvXq1el23bt0watQoxMXFaW2fmJiIIUOG4Pfff4ebm5tRRZaUlMDV1RXFxcUawYiIiMjq5eYCPXsCjz8ObN4sdzXNQt8cYNDlp8rKSqSnpyMiIkJjfUREBJKTkxvct0+fPvD29sawYcNw+PDhBretqKhASUmJxkJERER3qK0FoqOlGYNXrJC7GtkZFGoKCwtRU1MDT09PjfWenp7Iz8/XuY+3tzfWrl2LnTt3YteuXejatSuGDRuGI0eO1Pt94uLi4Orqql58fX0NKZOIiMg6LFsGHD4MfPYZ0Lat3NXIzqhbuhV3zE4ohNBaV6dr167oetvkP+Hh4cjNzcWSJUswaNAgnfvMmTMHKpVK/bqkpITBhoiI6Hb/+Q8wZ4700Mphw+SuxiQY1FPj7u4OW1tbrV6ZgoICrd6bhvTv3x8XL16s932lUgkXFxeNhYiIiP6nogIYOxa4/35p9mACYGCosbe3R2hoKBISEjTWJyQkYMCAAXp/TkZGBry9vQ351kRERARIt2+/+irw88/SXU8ODnJXZDIMvvykUqnw4osvIiwsDOHh4Vi7di1ycnIwZcoUANKlo2vXruHzzz8HACxbtgydOnVCjx49UFlZiU2bNmHnzp3YuXNn0x4JERGRNfjnP4ENG6RxNL17y12NSTE41ERFRaGoqAixsbHIy8tDUFAQ9u/fD39/fwBAXl4ecnJy1NtXVlZi1qxZuHbtGlq3bo0ePXpg3759GD58eNMdBRERkTX4v/8DVCpgxgzprifSYPA8NXLgPDVERGT1Ll0C+vaVln37gFbW8/jGZpmnhoiIiGRQUgI8+STg7g5s3WpVgcYQPCtERESmrLYWeOEF4OpV4NgxzkfTAIYaIiIiU/buu8C330pLt25yV2PSGGqIiIhM1bZtwIcfAgsXArzBplEcU0NERGSKUlKA8eOlSfbeekvuaswCQw0REZGpuXRJGhgcFgasXw/U8ygi0sRQQ0REZEqKiqRLTW3bAl9/zRmDDcAxNURERKbi1i1g1Cjgt9+ky0/t2sldkVlhqCEiIjIFNTXSLMGpqcDhw8B998ldkdlhqCEiIpKbEMDUqcCOHcD27UB4uNwVmSWGGiIiIjkJAcyeDaxbB2zcCIweLXdFZosDhYmIiOS0YAGweDGwbJl0CzcZjaGGiIhILp98AsydC8TEAG++KXc1Zo+hhoiISA4ffSQFmVmzpFBDd42hhoiIqKUtXAjMnAm88w6waBEn12siDDVEREQt6R//kMLMu+9Kz3VioGkyvPuJiIioJdTWSnc5LVkCvP8+8N57cldkcRhqiIiImltlJfDSS8CXX0p3OXFQcLNgqCEiImpOpaXAU09JswRv2QJERcldkcViqCEiImou6enAM88Av/4KfPcdMHSo3BVZNA4UJiIiag4bNgAPPgi4ugLJyQw0LYChhoiIqCndugW88gowcaL0gMrkZCAoSO6qrAIvPxERETWVy5el8TNnzwLx8dLgYGox7KkhIiJqCnv3AiEhQEkJcOwYA40MGGqIiIjuRkWF9KiDkSOlcTPp6UDv3nJXZZV4+YmIiMhYp08DL7wAnDsHLF0KzJjBGYJlxJ4aIiIiQ9XWSiEmLEz6OjUVUKkYaGTGUENERGSIs2eBwYOBt94Cpk2TAk1wsNxVERhqiIiI9HPrlvQQyt69gYICaYbgxYsBBwe5K6P/4ZgaIiKixiQkAK+9BmRnA3PnSk/ZZpgxOeypISIiqs8PP0h3NEVEAN7ewMmTwLx5DDQmiqGGiIjoTsePA48+CgwcCPz2G7BnD5CYCAQGyl0ZNYChhoiIqE5GBjBiBNCvH3D1KrB9O3DiBPDkk7yzyQww1BAREWVkAGPGSDMCnz8PbN4MnDolPfLAhr8qzQV/UkREZJ2EAA4dki4zhYQAmZnAxo3SLdvPPw/Y2spdIRmIoYaIiKxLZSXw1VfSJaZhw6Tbs7dskXpoxo8HWvHGYHPFnxwREVmH3Fxg7Vpg/XogPx94+GHgu++kO5s4XsYiMNQQEZHlqqwEDhyQLit98w3g6Ai8+CIwdSoQFCR3ddTEGGqIiMiyCAEkJwObNkmXmX77DejTB1i5Ehg7FnB2lrtCaiYMNUREZP5u3gSSkqRemb17gStXAD8/YPJkKcj06CF3hdQCGGqIiMg8/fKLFGIOHJCew3TrlhRkhg8Hnn1WmjiPt2NbFYYaIiIyD7/9Bhw9Kt2GfeAAcPEiYGcnhZf584HISKBbNw76tWIMNUREZJoKC4Eff5QeT5CYKD13SQjA31+aW2bxYum5TBwjQ//DUENERPIrL5ceR3D8OJCaKv2ZlSW95+cHDBkCvPmmdBt2p05yVkomjKGGiIhahhBS78vPP0sT3Z0//+fXly4BtbVA69bS7L6jRgF9+wL9+wMBAXJXTmaCoYaIiJqOENIMvVeuSMvly38GmPPngd9/l7azsZF6XLp2BR5/HOjeHXjgAekuJc7oS0YyquWsWrUKixcvRl5eHnr06IFly5Zh4MCB9W6flJQElUqFM2fOwMfHB2+//TamTJlidNFERCSD8nLgv/+VQktBwZ9fX7smBZisLCA7W7q9uo6bG9ClCxAYKD39umtXabnvPsDBQa4jIQtlcKjZtm0bpk+fjlWrVuHBBx/Ep59+isjISJw9exZ+fn5a22dlZWH48OGYNGkSNm3ahB9//BGvvvoqPDw8MGbMmCY5CCIiMkBVldRj8scf0p93fl233BlebtzQ/ByFAmjXDvDxkS4RPfqo1PvSqZP02t9fCjVELUQhhBCG7NCvXz+EhIRg9erV6nXdunXDqFGjEBcXp7X97NmzsXfvXpw7d069bsqUKTh58iRSUlL0+p4lJSVwdXVFcXExXFxcDCmXiMj01NZKwaKyUlrq+7qh927elEKGoUtZmdTjooutLdC27Z9L+/bS4un559e3v27XjpeKqEXomwMMao2VlZVIT0/HO++8o7E+IiICycnJOvdJSUlBRESExrpHH30U8fHxqKqqgp2dndY+FRUVqKio0DiYZrN3L7BnT8Pb6JP7TGkbU6rFUrcxpVosdZuWrqW2VlpqarS/vvNPQ9+7/evqaunru6VQAG3a1L84OkqhQ9d7daHFzU0zxDg6co4XMmsGhZrCwkLU1NTA09NTY72npyfy8/N17pOfn69z++rqahQWFsLb21trn7i4OLz//vuGlGa8X38FbutFqpc+f9H1/cegqT7Lkmsy17pb+vs1dd2NbWuqdTfFNjY2Uk/F7X/qWtfQe/psb2sL2NtrLnZ2ur+u77WdHaBUMoAQ3cGofkPFHX+RhBBa6xrbXtf6OnPmzIFKpVK/Likpga+vrzGlNm7iRGkhIiIis2ZQqHF3d4etra1Wr0xBQYFWb0wdLy8vndu3atUK7dq107mPUqmEUqk0pDQiIiKycgY96cve3h6hoaFISEjQWJ+QkIABAwbo3Cc8PFxr+4MHDyIsLEzneBoiIiIiYxj8+FKVSoX169djw4YNOHfuHGbMmIGcnBz1vDNz5szBuHHj1NtPmTIF2dnZUKlUOHfuHDZs2ID4+HjMmjWr6Y6CiIiIrJ7BY2qioqJQVFSE2NhY5OXlISgoCPv374e/vz8AIC8vDzk5OertAwICsH//fsyYMQMrV66Ej48PPvnkE4PmqKkbg9Osd0ERERGRSar7/d/YLDQGz1Mjh6tXrzbfQGEiIiIyC7m5uejYsWO975tFqKmtrcX169fh7Ozc4F1Wxqi7syo3N5cT+xmA5804PG/G4XkzDs+b4XjOjNPc500IgdLSUvj4+MDGpv6RM2YxFaSNjU2DyawpuLi4sAEbgefNODxvxuF5Mw7Pm+F4zozTnOfN1dW10W0MHihMREREZIoYaoiIiMgiWH2oUSqViImJ4WR/BuJ5Mw7Pm3F43ozD82Y4njPjmMp5M4uBwkRERESNsfqeGiIiIrIMDDVERERkERhqiIiIyCIw1BAREZFFYKghIiIii2DVoWbVqlUICAiAg4MDQkNDcfToUblLMnnz5s2DQqHQWLy8vOQuy6QcOXIEI0aMgI+PDxQKBb7++muN94UQmDdvHnx8fNC6dWs8/PDDOHPmjDzFmpDGztv48eO12l7//v3lKdaExMXFoW/fvnB2dkb79u0xatQonD9/XmMbtjlt+pw3tjlNq1evRq9evdSzBoeHh+PAgQPq902hnVltqNm2bRumT5+Ov/3tb8jIyMDAgQMRGRmp8YRx0q1Hjx7Iy8tTL6dPn5a7JJNSXl6O4OBgrFixQuf7ixYtwkcffYQVK1YgNTUVXl5eeOSRR1BaWtrClZqWxs4bADz22GMabW///v0tWKFpSkpKwmuvvYZjx44hISEB1dXViIiIQHl5uXobtjlt+pw3gG3udh07dsSCBQuQlpaGtLQ0DB06FCNHjlQHF5NoZ8JKPfDAA2LKlCka6wIDA8U777wjU0XmISYmRgQHB8tdhtkAIHbv3q1+XVtbK7y8vMSCBQvU627duiVcXV3FmjVrZKjQNN153oQQIjo6WowcOVKWesxJQUGBACCSkpKEEGxz+rrzvAnBNqePtm3bivXr15tMO7PKnprKykqkp6cjIiJCY31ERASSk5Nlqsp8XLx4ET4+PggICMCzzz6Ly5cvy12S2cjKykJ+fr5G21MqlRg8eDDbnh4SExPRvn17dOnSBZMmTUJBQYHcJZmc4uJiAMA999wDgG1OX3eetzpsc7rV1NRg69atKC8vR3h4uMm0M6sMNYWFhaipqYGnp6fGek9PT+Tn58tUlXno168fPv/8c3z//fdYt24d8vPzMWDAABQVFcldmlmoa19se4aLjIzE5s2bcejQISxduhSpqakYOnQoKioq5C7NZAghoFKp8NBDDyEoKAgA25w+dJ03gG1Ol9OnT8PJyQlKpRJTpkzB7t270b17d5NpZ61a7DuZIIVCofFaCKG1jjRFRkaqv+7ZsyfCw8Nx77334l//+hdUKpWMlZkXtj3DRUVFqb8OCgpCWFgY/P39sW/fPowePVrGykzH66+/jlOnTuGHH37Qeo9trn71nTe2OW1du3ZFZmYm/vjjD+zcuRPR0dFISkpSvy93O7PKnhp3d3fY2tpqpceCggKtlEkNc3R0RM+ePXHx4kW5SzELdXeKse3dPW9vb/j7+7Pt/c8bb7yBvXv34vDhw+jYsaN6Pdtcw+o7b7qwzQH29va47777EBYWhri4OAQHB2P58uUm086sMtTY29sjNDQUCQkJGusTEhIwYMAAmaoyTxUVFTh37hy8vb3lLsUsBAQEwMvLS6PtVVZWIikpiW3PQEVFRcjNzbX6tieEwOuvv45du3bh0KFDCAgI0HifbU63xs6bLmxz2oQQqKioMJ121mJDkk3M1q1bhZ2dnYiPjxdnz54V06dPF46OjuLKlStyl2bSZs6cKRITE8Xly5fFsWPHxBNPPCGcnZ153m5TWloqMjIyREZGhgAgPvroI5GRkSGys7OFEEIsWLBAuLq6il27donTp0+L5557Tnh7e4uSkhKZK5dXQ+ettLRUzJw5UyQnJ4usrCxx+PBhER4eLjp06GD1523q1KnC1dVVJCYmiry8PPVy48YN9TZsc9oaO29sc9rmzJkjjhw5IrKyssSpU6fE3LlzhY2NjTh48KAQwjTamdWGGiGEWLlypfD39xf29vYiJCRE41Y+0i0qKkp4e3sLOzs74ePjI0aPHi3OnDkjd1km5fDhwwKA1hIdHS2EkG6xjYmJEV5eXkKpVIpBgwaJ06dPy1u0CWjovN24cUNEREQIDw8PYWdnJ/z8/ER0dLTIycmRu2zZ6TpnAMTGjRvV27DNaWvsvLHNaXvppZfUvzM9PDzEsGHD1IFGCNNoZwohhGi5fiEiIiKi5mGVY2qIiIjI8jDUEBERkUVgqCEiIiKLwFBDREREFoGhhoiIiCwCQw0RERFZBIYaIiIisggMNURERGQRGGqIiIjIIjDUEBERkUVgqCEiIiKL8P/CrEHK16LqZgAAAABJRU5ErkJggg==\n" }, "metadata": {}, "output_type": "display_data" @@ -948,9 +865,9 @@ "notebook_metadata_filter": "-all" }, "kernelspec": { - "display_name": "Python 3", + "name": "brainpy", "language": "python", - "name": "python3" + "display_name": "brainpy" }, "language_info": { "codemirror_mode": { From e50e54f31e4d968ff39dcb82e27f18c1b4c3b70c Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:10:40 +0800 Subject: [PATCH 08/22] feat: add new models, including rate neuron models and rate synapse models --- brainpy/dyn/neurons/__init__.py | 1 + brainpy/dyn/neurons/noise_models.py | 72 ++ brainpy/dyn/neurons/rate_models.py | 737 ++++++++++++++---- brainpy/dyn/neurons/reduced_models.py | 156 +++- brainpy/dyn/rates/__init__.py | 4 - brainpy/dyn/rates/base.py | 34 - brainpy/dyn/rates/fhn.py | 142 ---- brainpy/dyn/rates/models.py | 25 - brainpy/dyn/rates/qif.py | 111 --- brainpy/dyn/rates/vdp.py | 8 - .../dyn/{runners/ds_runner.py => runners.py} | 0 brainpy/dyn/runners/__init__.py | 3 - brainpy/dyn/synapses/__init__.py | 2 + brainpy/dyn/synapses/delay_coupling.py | 203 +++++ 14 files changed, 1029 insertions(+), 469 deletions(-) create mode 100644 brainpy/dyn/neurons/noise_models.py delete mode 100644 brainpy/dyn/rates/__init__.py delete mode 100644 brainpy/dyn/rates/base.py delete mode 100644 brainpy/dyn/rates/fhn.py delete mode 100644 brainpy/dyn/rates/models.py delete mode 100644 brainpy/dyn/rates/qif.py delete mode 100644 brainpy/dyn/rates/vdp.py rename brainpy/dyn/{runners/ds_runner.py => runners.py} (100%) delete mode 100644 brainpy/dyn/runners/__init__.py create mode 100644 brainpy/dyn/synapses/delay_coupling.py diff --git a/brainpy/dyn/neurons/__init__.py b/brainpy/dyn/neurons/__init__.py index 6a7277cea..3824555f3 100644 --- a/brainpy/dyn/neurons/__init__.py +++ b/brainpy/dyn/neurons/__init__.py @@ -3,5 +3,6 @@ from .biological_models import * from .fractional_models import * from .input_models import * +from .noise_models import * from .rate_models import * from .reduced_models import * diff --git a/brainpy/dyn/neurons/noise_models.py b/brainpy/dyn/neurons/noise_models.py new file mode 100644 index 000000000..6d1dc13df --- /dev/null +++ b/brainpy/dyn/neurons/noise_models.py @@ -0,0 +1,72 @@ +# -*- coding: utf-8 -*- + +import brainpy.math as bm +from brainpy.dyn.base import NeuGroup +from brainpy.integrators.sde import sdeint +from brainpy.types import Parameter, Shape + +__all__ = [ + 'OUProcess', +] + + +class OUProcess(NeuGroup): + r"""The Ornstein–Uhlenbeck process. + + The Ornstein–Uhlenbeck process :math:`x_{t}` is defined by the following + stochastic differential equation: + + .. math:: + + \tau dx_{t}=-\theta \,x_{t}\,dt+\sigma \,dW_{t} + + where :math:`\theta >0` and :math:`\sigma >0` are parameters and :math:`W_{t}` + denotes the Wiener process. + + Parameters + ---------- + size: int, sequence of int + The model size. + mean: Parameter + The noise mean value. + sigma: Parameter + The noise amplitude. + tau: Parameter + The decay time constant. + method: str + The numerical integration method for stochastic differential equation. + name: str + The model name. + """ + + def __init__( + self, + size: Shape, + mean: Parameter, + sigma: Parameter, + tau: Parameter, + method: str = 'euler', + name: str = None + ): + super(OUProcess, self).__init__(size=size, name=name) + + # parameters + self.mean = mean + self.sigma = sigma + self.tau = tau + + # variables + self.x = bm.Variable(bm.ones(self.num) * mean) + + # integral functions + self.integral = sdeint(f=self.df, g=self.dg, method=method) + + def df(self, x, t): + f_x_ou = (self.mean - x) / self.tau + return f_x_ou + + def dg(self, x, t): + return self.sigma + + def update(self, _t, _dt): + self.x.value = self.integral(self.x, _t, _dt) diff --git a/brainpy/dyn/neurons/rate_models.py b/brainpy/dyn/neurons/rate_models.py index 39b283f1b..71a45c811 100644 --- a/brainpy/dyn/neurons/rate_models.py +++ b/brainpy/dyn/neurons/rate_models.py @@ -1,144 +1,146 @@ # -*- coding: utf-8 -*- +import numpy as np +from jax.experimental.host_callback import id_tap import brainpy.math as bm +from brainpy import check from brainpy.dyn.base import NeuGroup from brainpy.integrators.dde import ddeint from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint +from brainpy.tools.checking import check_float from brainpy.types import Parameter, Shape +from .noise_models import OUProcess __all__ = [ - 'FHN', + 'RateGroup', + 'RateFHN', 'FeedbackFHN', + 'RateQIF', + 'StuartLandauOscillator', + 'WilsonCowanModel', ] -class FHN(NeuGroup): - r"""FitzHugh-Nagumo neuron model. - - **Model Descriptions** - - The FitzHugh–Nagumo model (FHN), named after Richard FitzHugh (1922–2007) - who suggested the system in 1961 [1]_ and J. Nagumo et al. who created the - equivalent circuit the following year, describes a prototype of an excitable - system (e.g., a neuron). +class RateGroup(NeuGroup): + def update(self, _t, _dt): + raise NotImplementedError - The motivation for the FitzHugh-Nagumo model was to isolate conceptually - the essentially mathematical properties of excitation and propagation from - the electrochemical properties of sodium and potassium ion flow. The model - consists of - - a *voltage-like variable* having cubic nonlinearity that allows regenerative - self-excitation via a positive feedback, and - - a *recovery variable* having a linear dynamics that provides a slower negative feedback. +class RateFHN(NeuGroup): + r"""FitzHugh-Nagumo system used in [1]_. .. math:: - \begin{aligned} - {\dot {v}} &=v-{\frac {v^{3}}{3}}-w+RI_{\rm {ext}}, \\ - \tau {\dot {w}}&=v+a-bw. - \end{aligned} - - The FHN Model is an example of a relaxation oscillator - because, if the external stimulus :math:`I_{\text{ext}}` - exceeds a certain threshold value, the system will exhibit - a characteristic excursion in phase space, before the - variables :math:`v` and :math:`w` relax back to their rest values. - This behaviour is typical for spike generations (a short, - nonlinear elevation of membrane voltage :math:`v`, - diminished over time by a slower, linear recovery variable - :math:`w`) in a neuron after stimulation by an external - input current. - - **Model Examples** + \frac{dx}{dt} = -\alpha V^3 + \beta V^2 + \gamma V - w + I_{ext}\\ + \tau \frac{dy}{dt} = (V - \delta - \epsilon w) - .. plot:: - :include-source: True - - >>> import brainpy as bp - >>> fhn = bp.dyn.FHN(1) - >>> runner = bp.dyn.DSRunner(fhn, inputs=('input', 1.), monitors=['V', 'w']) - >>> runner.run(100.) - >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.w, legend='w') - >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.V, legend='V', show=True) - - **Model Parameters** - - ============= ============== ======== ======================== - **Parameter** **Init Value** **Unit** **Explanation** - ------------- -------------- -------- ------------------------ - a 1 \ Positive constant - b 1 \ Positive constant - tau 10 ms Membrane time constant. - V_th 1.8 mV Threshold potential of spike. - ============= ============== ======== ======================== - - **Model Variables** - - ================== ================= ========================================================= - **Variables name** **Initial Value** **Explanation** - ------------------ ----------------- --------------------------------------------------------- - V 0 Membrane potential. - w 0 A recovery variable which represents - the combined effects of sodium channel - de-inactivation and potassium channel - deactivation. - input 0 External and synaptic input current. - spike False Flag to mark whether the neuron is spiking. - t_last_spike -1e7 Last spike time stamp. - ================== ================= ========================================================= + Parameters + ---------- + size: Shape + The model size. + x_ou_mean + The noise mean of the :math:`x` variable, [mV/ms] + y_ou_mean + The noise mean of the :math:`y` variable, [mV/ms]. + x_ou_sigma + The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. + y_ou_sigma + The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. + x_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. + y_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. - **References** - .. [1] FitzHugh, Richard. "Impulses and physiological states in theoretical models of nerve membrane." Biophysical journal 1.6 (1961): 445-466. - .. [2] https://en.wikipedia.org/wiki/FitzHugh%E2%80%93Nagumo_model - .. [3] http://www.scholarpedia.org/article/FitzHugh-Nagumo_model + References + ---------- + .. [1] Kostova, T., Ravindran, R., & Schonbek, M. (2004). FitzHugh–Nagumo + revisited: Types of bifurcations, periodical forcing and stability + regions by a Lyapunov functional. International journal of + bifurcation and chaos, 14(03), 913-925. """ - def __init__(self, - size: Shape, - a: Parameter = 0.7, - b: Parameter = 0.8, - tau: Parameter = 12.5, - Vth: Parameter = 1.8, - method: str = 'exp_auto', - name: str = None): - # initialization - super(FHN, self).__init__(size=size, name=name) - - # parameters - self.a = a - self.b = b + def __init__( + self, + size: Shape, + + # fhn parameters + alpha: Parameter = 3.0, + beta: Parameter = 4.0, + gamma: Parameter = -1.5, + delta: Parameter = 0.0, + epsilon: Parameter = 0.5, + tau: Parameter = 20.0, + + # noise parameters + x_ou_mean: Parameter = 0.0, + x_ou_sigma: Parameter = 0.0, + x_ou_tau: Parameter = 5.0, + y_ou_mean: Parameter = 0.0, + y_ou_sigma: Parameter = 0.0, + y_ou_tau: Parameter = 5.0, + + # other parameters + method: str = None, + sde_method: str = None, + name: str = None, + ): + super(RateFHN, self).__init__(size=size, name=name) + + # model parameters + self.alpha = alpha + self.beta = beta + self.gamma = gamma + self.delta = delta + self.epsilon = epsilon self.tau = tau - self.Vth = Vth + + # noise parameters + self.x_ou_mean = x_ou_mean # mV/ms, OU process + self.y_ou_mean = y_ou_mean # mV/ms, OU process + self.x_ou_sigma = x_ou_sigma # mV/ms/sqrt(ms), noise intensity + self.y_ou_sigma = y_ou_sigma # mV/ms/sqrt(ms), noise intensity + self.x_ou_tau = x_ou_tau # ms, timescale of the Ornstein-Uhlenbeck noise process + self.y_ou_tau = y_ou_tau # ms, timescale of the Ornstein-Uhlenbeck noise process # variables - self.w = bm.Variable(bm.zeros(self.num)) - self.V = bm.Variable(bm.zeros(self.num)) + self.x = bm.Variable(bm.random.random(self.num) * 0.05) + self.y = bm.Variable(bm.random.random(self.num) * 0.05) self.input = bm.Variable(bm.zeros(self.num)) - self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) - self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) - # integral - self.integral = odeint(method=method, f=self.derivative) + # noise variables + self.x_ou = self.y_ou = None + if bm.any(self.x_ou_mean > 0.) or bm.any(self.x_ou_sigma > 0.): + self.x_ou = OUProcess(self.num, + self.x_ou_mean, self.x_ou_sigma, self.x_ou_tau, + method=sde_method) + if bm.any(self.y_ou_mean > 0.) or bm.any(self.y_ou_sigma > 0.): + self.y_ou = OUProcess(self.num, + self.y_ou_mean, self.y_ou_sigma, self.y_ou_tau, + method=sde_method) - def dV(self, V, t, w, I_ext): - return V - V * V * V / 3 - w + I_ext + # integral functions + self.integral = odeint(f=JointEq([self.dx, self.dy]), method=method) - def dw(self, w, t, V): - return (V + self.a - self.b * w) / self.tau + def dx(self, x, t, y, x_ext): + return - self.alpha * x ** 3 + self.beta * x ** 2 + self.gamma * x - y + x_ext - @property - def derivative(self): - return JointEq([self.dV, self.dw]) + def dy(self, y, t, x, y_ext=0.): + return (x - self.delta - self.epsilon * y) / self.tau + y_ext def update(self, _t, _dt): - V, w = self.integral(self.V, self.w, _t, self.input, dt=_dt) - self.spike.value = bm.logical_and(V >= self.Vth, self.V < self.Vth) - self.t_last_spike.value = bm.where(self.spike, _t, self.t_last_spike) - self.V.value = V - self.w.value = w + if self.x_ou is not None: + self.input += self.x_ou.x + self.x_ou.update(_t, _dt) + y_ext = 0. + if self.y_ou is not None: + y_ext = self.y_ou.x + self.y_ou.update(_t, _dt) + x, y = self.integral(self.x, self.y, _t, x_ext=self.input, y_ext=y_ext, dt=_dt) + self.x.value = x + self.y.value = y self.input[:] = 0. @@ -150,8 +152,8 @@ class FeedbackFHN(NeuGroup): .. math:: \begin{aligned} - \frac{dv}{dt} &= v(t) - \frac{v^3(t)}{3} - w(t) + \mu[v(t-\mathrm{delay}) - v_0] \\ - \frac{dw}{dt} &= [v(t) + a - b w(t)] / \tau + \frac{dx}{dt} &= x(t) - \frac{x^3(t)}{3} - y(t) + \mu[x(t-\mathrm{delay}) - x_0] \\ + \frac{dy}{dt} &= [x(t) + a - b y(t)] / \tau \end{aligned} @@ -159,10 +161,10 @@ class FeedbackFHN(NeuGroup): >>> import brainpy as bp >>> fhn = bp.dyn.FeedbackFHN(1, delay=10.) - >>> runner = bp.dyn.DSRunner(fhn, inputs=('input', 1.), monitors=['V', 'w']) + >>> runner = bp.dyn.DSRunner(fhn, inputs=('input', 1.), monitors=['x', 'y']) >>> runner.run(100.) - >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.w, legend='w') - >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.V, legend='V', show=True) + >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.y, legend='y') + >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.x, legend='x', show=True) **Model Parameters** @@ -180,6 +182,23 @@ class FeedbackFHN(NeuGroup): when negative, it is a inhibitory feedback. ============= ============== ======== ======================== + Parameters + ---------- + x_ou_mean + The noise mean of the :math:`x` variable, [mV/ms] + y_ou_mean + The noise mean of the :math:`y` variable, [mV/ms]. + x_ou_sigma + The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. + y_ou_sigma + The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. + x_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. + y_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. + + + References ---------- .. [4] Plant, Richard E. (1981). *A FitzHugh Differential-Difference @@ -188,50 +207,492 @@ class FeedbackFHN(NeuGroup): """ - def __init__(self, - size: Shape, - a: Parameter = 0.7, - b: Parameter = 0.8, - delay: Parameter = 10., - tau: Parameter = 12.5, - mu: Parameter = 1.6886, - v0: Parameter = -1, - method: str = 'rk4', - name: str = None): + def __init__( + self, + size: Shape, + + # model parameters + a: Parameter = 0.7, + b: Parameter = 0.8, + delay: Parameter = 10., + tau: Parameter = 12.5, + mu: Parameter = 1.6886, + x0: Parameter = -1, + + # noise parameters + x_ou_mean: Parameter = 0.0, + x_ou_sigma: Parameter = 0.0, + x_ou_tau: Parameter = 5.0, + y_ou_mean: Parameter = 0.0, + y_ou_sigma: Parameter = 0.0, + y_ou_tau: Parameter = 5.0, + + # other parameters + method: str = 'rk4', + sde_method: str = None, + name: str = None, + dt: float = None + ): super(FeedbackFHN, self).__init__(size=size, name=name) + # dt + self.dt = bm.get_dt() if dt is None else dt + check_float(self.dt, 'dt', allow_none=False, min_bound=0., allow_int=False) + # parameters self.a = a self.b = b self.delay = delay self.tau = tau self.mu = mu # feedback strength - self.v0 = v0 # resting potential + self.v0 = x0 # resting potential + + # noise parameters + self.x_ou_mean = x_ou_mean + self.y_ou_mean = y_ou_mean + self.x_ou_sigma = x_ou_sigma + self.y_ou_sigma = y_ou_sigma + self.x_ou_tau = x_ou_tau + self.y_ou_tau = y_ou_tau # variables - self.w = bm.Variable(bm.zeros(self.num)) - self.V = bm.Variable(bm.zeros(self.num)) - self.Vdelay = bm.TimeDelay(self.V, self.delay, interp_method='round') + self.x = bm.Variable(bm.zeros(self.num)) + self.y = bm.Variable(bm.zeros(self.num)) + self.x_delay = bm.TimeDelay(self.x, self.delay, dt=self.dt, interp_method='round') self.input = bm.Variable(bm.zeros(self.num)) + # noise variables + self.x_ou = self.y_ou = None + if bm.any(self.x_ou_mean > 0.) or bm.any(self.x_ou_sigma > 0.): + self.x_ou = OUProcess(self.num, + self.x_ou_mean, self.x_ou_sigma, self.x_ou_tau, + method=sde_method) + if bm.any(self.y_ou_mean > 0.) or bm.any(self.y_ou_sigma > 0.): + self.y_ou = OUProcess(self.num, + self.y_ou_mean, self.y_ou_sigma, self.y_ou_tau, + method=sde_method) + # integral self.integral = ddeint(method=method, - f=self.derivative, - state_delays={'V': self.Vdelay}) + f=JointEq([self.dx, self.dy]), + state_delays={'V': self.x_delay}) + + def dx(self, x, t, y, x_ext): + return x - x * x * x / 3 - y + x_ext + self.mu * (self.x_delay(t - self.delay) - self.v0) + + def dy(self, y, t, x, y_ext): + return (x + self.a - self.b * y + y_ext) / self.tau + + def _check_dt(self, dt, *args): + if np.absolute(dt - self.dt) > 1e-6: + raise ValueError(f'The "dt" {dt} used in model running is ' + f'not consistent with the "dt" {self.dt} ' + f'used in model definition.') + + def update(self, _t, _dt): + if check.is_checking(): + id_tap(self._check_dt, _dt) + if self.x_ou is not None: + self.input += self.x_ou.x + self.x_ou.update(_t, _dt) + y_ext = 0. + if self.y_ou is not None: + y_ext = self.y_ou.x + self.y_ou.update(_t, _dt) + x, y = self.integral(self.x, self.y, _t, x_ext=self.input, y_ext=y_ext, dt=_dt) + self.x.value = x + self.y.value = y + self.input[:] = 0. + + +class RateQIF(NeuGroup): + r"""A mean-field model of a quadratic integrate-and-fire neuron population. + + **Model Descriptions** + + The QIF population mean-field model, which has been derived from a + population of all-to-all coupled QIF neurons in [5]_. + The model equations are given by: + + .. math:: + + \begin{aligned} + \tau \dot{r} &=\frac{\Delta}{\pi \tau}+2 r v \\ + \tau \dot{v} &=v^{2}+\bar{\eta}+I(t)+J r \tau-(\pi r \tau)^{2} + \end{aligned} + + where :math:`r` is the average firing rate and :math:`v` is the + average membrane potential of the QIF population [5]_. + + This mean-field model is an exact representation of the macroscopic + firing rate and membrane potential dynamics of a spiking neural network + consisting of QIF neurons with Lorentzian distributed background + excitabilities. While the mean-field derivation is mathematically + only valid for all-to-all coupled populations of infinite size, it + has been shown that there is a close correspondence between the + mean-field model and neural populations with sparse coupling and + population sizes of a few thousand neurons [6]_. + + **Model Parameters** + + ============= ============== ======== ======================== + **Parameter** **Init Value** **Unit** **Explanation** + ------------- -------------- -------- ------------------------ + tau 1 ms the population time constant + eta -5. \ the mean of a Lorenzian distribution over the neural excitability in the population + delta 1.0 \ the half-width at half maximum of the Lorenzian distribution over the neural excitability + J 15 \ the strength of the recurrent coupling inside the population + ============= ============== ======== ======================== + + Parameters + ---------- + x_ou_mean + The noise mean of the :math:`x` variable, [mV/ms] + y_ou_mean + The noise mean of the :math:`y` variable, [mV/ms]. + x_ou_sigma + The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. + y_ou_sigma + The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. + x_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. + y_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. - def dV(self, V, t, w): - return (V - V * V * V / 3 - w + self.input + - self.mu * (self.Vdelay(t - self.delay) - self.v0)) - def dw(self, w, t, V): - return (V + self.a - self.b * w) / self.tau + References + ---------- + .. [5] E. Montbrió, D. Pazó, A. Roxin (2015) Macroscopic description for + networks of spiking neurons. Physical Review X, 5:021028, + https://doi.org/10.1103/PhysRevX.5.021028. + .. [6] R. Gast, H. Schmidt, T.R. Knösche (2020) A Mean-Field Description + of Bursting Dynamics in Spiking Neural Networks with Short-Term + Adaptation. Neural Computation 32.9 (2020): 1615-1634. + + """ + + def __init__( + self, + size: Shape, + + # model parameters + tau: Parameter = 1., + eta: Parameter = -5.0, + delta: Parameter = 1.0, + J: Parameter = 15., + + # noise parameters + x_ou_mean: Parameter = 0.0, + x_ou_sigma: Parameter = 0.0, + x_ou_tau: Parameter = 5.0, + y_ou_mean: Parameter = 0.0, + y_ou_sigma: Parameter = 0.0, + y_ou_tau: Parameter = 5.0, + + # other parameters + method: str = 'exp_auto', + name: str = None, + sde_method: str = None, + ): + super(RateQIF, self).__init__(size=size, name=name) - @property - def derivative(self): - return JointEq([self.dV, self.dw]) + # parameters + self.tau = tau # + self.eta = eta # the mean of a Lorenzian distribution over the neural excitability in the population + self.delta = delta # the half-width at half maximum of the Lorenzian distribution over the neural excitability + self.J = J # the strength of the recurrent coupling inside the population + + # noise parameters + self.x_ou_mean = x_ou_mean + self.y_ou_mean = y_ou_mean + self.x_ou_sigma = x_ou_sigma + self.y_ou_sigma = y_ou_sigma + self.x_ou_tau = x_ou_tau + self.y_ou_tau = y_ou_tau + + # variables + self.y = bm.Variable(bm.ones(self.num)) + self.x = bm.Variable(bm.ones(self.num)) + self.input = bm.Variable(bm.zeros(self.num)) + + # noise variables + self.x_ou = self.y_ou = None + if bm.any(self.x_ou_mean > 0.) or bm.any(self.x_ou_sigma > 0.): + self.x_ou = OUProcess(self.num, + self.x_ou_mean, self.x_ou_sigma, self.x_ou_tau, + method=sde_method) + if bm.any(self.y_ou_mean > 0.) or bm.any(self.y_ou_sigma > 0.): + self.y_ou = OUProcess(self.num, + self.y_ou_mean, self.y_ou_sigma, self.y_ou_tau, + method=sde_method) + + # functions + self.integral = odeint(JointEq([self.dx, self.dy]), method=method) + + def dy(self, y, t, x, y_ext): + return (self.delta / (bm.pi * self.tau) + 2. * x * y + y_ext) / self.tau + + def dx(self, x, t, y, x_ext): + return (x ** 2 + self.eta + x_ext + self.J * y * self.tau - + (bm.pi * y * self.tau) ** 2) / self.tau def update(self, _t, _dt): - V, w = self.integral(self.V, self.w, _t, dt=_dt) - self.V.value = V - self.w.value = w + if self.x_ou is not None: + self.input += self.x_ou.x + self.x_ou.update(_t, _dt) + y_ext = 0. + if self.y_ou is not None: + y_ext = self.y_ou.x + self.y_ou.update(_t, _dt) + x, y = self.integral(self.x, self.y, t=_t, x_ext=self.input, y_ext=y_ext, dt=_dt) + self.x.value = x + self.y.value = y self.input[:] = 0. + + +class StuartLandauOscillator(RateGroup): + r""" + Stuart-Landau model with Hopf bifurcation. + + .. math:: + + \frac{dx}{dt} = (a - x^2 - y^2) * x - w*y + I^x_{ext} \\ + \frac{dy}{dt} = (a - x^2 - y^2) * y + w*x + I^y_{ext} + + Parameters + ---------- + x_ou_mean + The noise mean of the :math:`x` variable, [mV/ms] + y_ou_mean + The noise mean of the :math:`y` variable, [mV/ms]. + x_ou_sigma + The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. + y_ou_sigma + The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. + x_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. + y_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. + + """ + + def __init__( + self, + size: Shape, + + # model parameters + a=0.25, + w=0.2, + + # noise parameters + x_ou_mean: Parameter = 0.0, + x_ou_sigma: Parameter = 0.0, + x_ou_tau: Parameter = 5.0, + y_ou_mean: Parameter = 0.0, + y_ou_sigma: Parameter = 0.0, + y_ou_tau: Parameter = 5.0, + + # other parameters + method: str = None, + sde_method: str = None, + name: str = None, + ): + super(StuartLandauOscillator, self).__init__(size=size, + name=name) + + # model parameters + self.a = a + self.w = w + + # noise parameters + self.x_ou_mean = x_ou_mean + self.y_ou_mean = y_ou_mean + self.x_ou_sigma = x_ou_sigma + self.y_ou_sigma = y_ou_sigma + self.x_ou_tau = x_ou_tau + self.y_ou_tau = y_ou_tau + + # variables + self.x = bm.Variable(bm.random.random(self.num) * 0.5) + self.y = bm.Variable(bm.random.random(self.num) * 0.5) + self.input = bm.Variable(bm.zeros(self.num)) + + # noise variables + self.x_ou = self.y_ou = None + if bm.any(self.x_ou_mean > 0.) or bm.any(self.x_ou_sigma > 0.): + self.x_ou = OUProcess(self.num, + self.x_ou_mean, self.x_ou_sigma, self.x_ou_tau, + method=sde_method) + if bm.any(self.y_ou_mean > 0.) or bm.any(self.y_ou_sigma > 0.): + self.y_ou = OUProcess(self.num, + self.y_ou_mean, self.y_ou_sigma, self.y_ou_tau, + method=sde_method) + + # integral functions + self.integral = odeint(f=JointEq([self.dx, self.dy]), method=method) + + def dx(self, x, t, y, x_ext, a, w): + return (a - x * x - y * y) * x - w * y + x_ext + + def dy(self, y, t, x, y_ext, a, w): + return (a - x * x - y * y) * y - w * y + y_ext + + def update(self, _t, _dt): + if self.x_ou is not None: + self.input += self.x_ou.x + self.x_ou.update(_t, _dt) + y_ext = 0. + if self.y_ou is not None: + y_ext = self.y_ou.x + self.y_ou.update(_t, _dt) + x, y = self.integral(self.x, self.y, _t, x_ext=self.input, + y_ext=y_ext, a=self.a, w=self.w, dt=_dt) + self.x.value = x + self.y.value = y + self.input[:] = 0. + + +class WilsonCowanModel(RateGroup): + """Wilson-Cowan population model. + + + Parameters + ---------- + x_ou_mean + The noise mean of the :math:`x` variable, [mV/ms] + y_ou_mean + The noise mean of the :math:`y` variable, [mV/ms]. + x_ou_sigma + The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. + y_ou_sigma + The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. + x_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. + y_ou_tau + The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. + + + """ + + def __init__( + self, + size: Shape, + + # Excitatory parameters + E_tau=2.5, # excitatory time constant + E_a=1.5, # excitatory gain + E_theta=3.0, # excitatory firing threshold + + # Inhibitory parameters + I_tau=3.75, # inhibitory time constant + I_a=1.5, # inhibitory gain + I_theta=3.0, # inhibitory firing threshold + + # connection parameters + wEE=16., # local E-E coupling + wIE=15., # local E-I coupling + wEI=12., # local I-E coupling + wII=3., # local I-I coupling + + # Refractory parameter + r=1, + + # noise parameters + x_ou_mean: Parameter = 0.0, + x_ou_sigma: Parameter = 0.0, + x_ou_tau: Parameter = 5.0, + y_ou_mean: Parameter = 0.0, + y_ou_sigma: Parameter = 0.0, + y_ou_tau: Parameter = 5.0, + + # other parameters + sde_method: str = None, + method: str = None, + name: str = None, + ): + super(WilsonCowanModel, self).__init__(size=size, name=name) + + # model parameters + self.E_tau = E_tau + self.E_a = E_a + self.E_theta = E_theta + self.I_tau = I_tau + self.I_a = I_a + self.I_theta = I_theta + self.wEE = wEE + self.wIE = wIE + self.wEI = wEI + self.wII = wII + self.r = r + + # noise parameters + self.x_ou_mean = x_ou_mean + self.y_ou_mean = y_ou_mean + self.x_ou_sigma = x_ou_sigma + self.y_ou_sigma = y_ou_sigma + self.x_ou_tau = x_ou_tau + self.y_ou_tau = y_ou_tau + + # variables + self.x = bm.Variable(bm.random.random(self.num) * 0.05) + self.y = bm.Variable(bm.random.random(self.num) * 0.05) + self.input = bm.Variable(bm.zeros(self.num)) + + # noise variables + self.x_ou = self.y_ou = None + if bm.any(self.x_ou_mean > 0.) or bm.any(self.x_ou_sigma > 0.): + self.x_ou = OUProcess(self.num, + self.x_ou_mean, self.x_ou_sigma, self.x_ou_tau, + method=sde_method) + if bm.any(self.y_ou_mean > 0.) or bm.any(self.y_ou_sigma > 0.): + self.y_ou = OUProcess(self.num, + self.y_ou_mean, self.y_ou_sigma, self.y_ou_tau, + method=sde_method) + + # functions + self.integral = odeint(f=JointEq([self.dx, self.dy]), method=method) + + # functions + def F(self, x, a, theta): + return 1 / (1 + bm.exp(-a * (x - theta))) + + def dx(self, x, t, y, x_ext): + x = self.wEE * x - self.wIE * y + x_ext + return (-x + (1 - self.r * x) * self.F(x, self.E_a, self.E_theta)) / self.E_tau + + def dy(self, y, t, x, y_ext): + x = self.wEI * x - self.wII * y + y_ext + return (-y + (1 - self.r * y) * self.F(x, self.I_a, self.I_theta)) / self.I_tau + + def update(self, _t, _dt): + if self.x_ou is not None: + self.input += self.x_ou.x + self.x_ou.update(_t, _dt) + y_ext = 0. + if self.y_ou is not None: + y_ext = self.y_ou.x + self.y_ou.update(_t, _dt) + x, y = self.integral(self.x, self.y, _t, x_ext=self.input, y_ext=y_ext, dt=_dt) + self.x.value = x + self.y.value = y + self.input[:] = 0. + + +class JansenRitModel(RateGroup): + pass + + +class KuramotoOscillator(RateGroup): + pass + + +class ThetaNeuron(RateGroup): + pass + + +class RateQIFWithSFA(RateGroup): + pass + + +class VanDerPolOscillator(RateGroup): + pass diff --git a/brainpy/dyn/neurons/reduced_models.py b/brainpy/dyn/neurons/reduced_models.py index c8dff8f01..b0a90b154 100644 --- a/brainpy/dyn/neurons/reduced_models.py +++ b/brainpy/dyn/neurons/reduced_models.py @@ -4,6 +4,7 @@ from brainpy.dyn.base import NeuGroup from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint +from brainpy.types import Shape, Parameter __all__ = [ 'LIF', @@ -14,6 +15,7 @@ 'GIF', 'Izhikevich', 'HindmarshRose', + 'FHN', ] @@ -70,8 +72,15 @@ class LIF(NeuGroup): neuron (1907)." Brain research bulletin 50, no. 5-6 (1999): 303-304. """ - def __init__(self, size, V_rest=0., V_reset=-5., V_th=20., tau=10., - tau_ref=1., method='exp_auto', name=None): + def __init__(self, + size: Shape, + V_rest: Parameter = 0., + V_reset: Parameter = -5., + V_th: Parameter = 20., + tau: Parameter = 10., + tau_ref: Parameter = 1., + method: str = 'exp_auto', + name: str = None): # initialization super(LIF, self).__init__(size=size, name=name) @@ -206,8 +215,18 @@ class ExpIF(NeuGroup): .. [5] https://en.wikipedia.org/wiki/Exponential_integrate-and-fire """ - def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_T=-59.9, delta_T=3.48, - R=1., tau=10., tau_ref=1.7, method='exp_auto', name=None): + def __init__(self, + size: Shape, + V_rest: Parameter = -65., + V_reset: Parameter = -68., + V_th: Parameter = -30., + V_T: Parameter = -59.9, + delta_T: Parameter = 3.48, + R: Parameter = 1., + tau: Parameter = 10., + tau_ref: Parameter = 1.7, + method: str = 'exp_auto', + name: str = None): # initialize super(ExpIF, self).__init__(size=size, name=name) @@ -1012,3 +1031,132 @@ def update(self, _t, _dt): self.y.value = y self.z.value = z self.input[:] = 0. + + +class FHN(NeuGroup): + r"""FitzHugh-Nagumo neuron model. + + **Model Descriptions** + + The FitzHugh–Nagumo model (FHN), named after Richard FitzHugh (1922–2007) + who suggested the system in 1961 [1]_ and J. Nagumo et al. who created the + equivalent circuit the following year, describes a prototype of an excitable + system (e.g., a neuron). + + The motivation for the FitzHugh-Nagumo model was to isolate conceptually + the essentially mathematical properties of excitation and propagation from + the electrochemical properties of sodium and potassium ion flow. The model + consists of + + - a *voltage-like variable* having cubic nonlinearity that allows regenerative + self-excitation via a positive feedback, and + - a *recovery variable* having a linear dynamics that provides a slower negative feedback. + + .. math:: + + \begin{aligned} + {\dot {v}} &=v-{\frac {v^{3}}{3}}-w+RI_{\rm {ext}}, \\ + \tau {\dot {w}}&=v+a-bw. + \end{aligned} + + The FHN Model is an example of a relaxation oscillator + because, if the external stimulus :math:`I_{\text{ext}}` + exceeds a certain threshold value, the system will exhibit + a characteristic excursion in phase space, before the + variables :math:`v` and :math:`w` relax back to their rest values. + This behaviour is typical for spike generations (a short, + nonlinear elevation of membrane voltage :math:`v`, + diminished over time by a slower, linear recovery variable + :math:`w`) in a neuron after stimulation by an external + input current. + + **Model Examples** + + .. plot:: + :include-source: True + + >>> import brainpy as bp + >>> fhn = bp.dyn.FHN(1) + >>> runner = bp.dyn.DSRunner(fhn, inputs=('input', 1.), monitors=['V', 'w']) + >>> runner.run(100.) + >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.w, legend='w') + >>> bp.visualize.line_plot(runner.mon.ts, runner.mon.V, legend='V', show=True) + + **Model Parameters** + + ============= ============== ======== ======================== + **Parameter** **Init Value** **Unit** **Explanation** + ------------- -------------- -------- ------------------------ + a 1 \ Positive constant + b 1 \ Positive constant + tau 10 ms Membrane time constant. + V_th 1.8 mV Threshold potential of spike. + ============= ============== ======== ======================== + + **Model Variables** + + ================== ================= ========================================================= + **Variables name** **Initial Value** **Explanation** + ------------------ ----------------- --------------------------------------------------------- + V 0 Membrane potential. + w 0 A recovery variable which represents + the combined effects of sodium channel + de-inactivation and potassium channel + deactivation. + input 0 External and synaptic input current. + spike False Flag to mark whether the neuron is spiking. + t_last_spike -1e7 Last spike time stamp. + ================== ================= ========================================================= + + **References** + + .. [1] FitzHugh, Richard. "Impulses and physiological states in theoretical models of nerve membrane." Biophysical journal 1.6 (1961): 445-466. + .. [2] https://en.wikipedia.org/wiki/FitzHugh%E2%80%93Nagumo_model + .. [3] http://www.scholarpedia.org/article/FitzHugh-Nagumo_model + + """ + + def __init__(self, + size: Shape, + a: Parameter = 0.7, + b: Parameter = 0.8, + tau: Parameter = 12.5, + Vth: Parameter = 1.8, + method: str = 'exp_auto', + name: str = None): + # initialization + super(FHN, self).__init__(size=size, name=name) + + # parameters + self.a = a + self.b = b + self.tau = tau + self.Vth = Vth + + # variables + self.w = bm.Variable(bm.zeros(self.num)) + self.V = bm.Variable(bm.zeros(self.num)) + self.input = bm.Variable(bm.zeros(self.num)) + self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) + self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) + + # integral + self.integral = odeint(method=method, f=self.derivative) + + def dV(self, V, t, w, I_ext): + return V - V * V * V / 3 - w + I_ext + + def dw(self, w, t, V): + return (V + self.a - self.b * w) / self.tau + + @property + def derivative(self): + return JointEq([self.dV, self.dw]) + + def update(self, _t, _dt): + V, w = self.integral(self.V, self.w, _t, self.input, dt=_dt) + self.spike.value = bm.logical_and(V >= self.Vth, self.V < self.Vth) + self.t_last_spike.value = bm.where(self.spike, _t, self.t_last_spike) + self.V.value = V + self.w.value = w + self.input[:] = 0. diff --git a/brainpy/dyn/rates/__init__.py b/brainpy/dyn/rates/__init__.py deleted file mode 100644 index b371df655..000000000 --- a/brainpy/dyn/rates/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# -*- coding: utf-8 -*- - -from .base import * -from .fhn import * diff --git a/brainpy/dyn/rates/base.py b/brainpy/dyn/rates/base.py deleted file mode 100644 index 8fb14e1b3..000000000 --- a/brainpy/dyn/rates/base.py +++ /dev/null @@ -1,34 +0,0 @@ -# -*- coding: utf-8 -*- - -from brainpy.dyn.base import DynamicalSystem -from brainpy.tools.others import to_size, size2num -from brainpy.types import Shape - -__all__ = [ - 'RateModel', -] - - -class RateModel(DynamicalSystem): - """Base class of rate models.""" - - def __init__(self, - size: Shape, - name: str = None): - super(RateModel, self).__init__(name=name) - - self.size = to_size(size) - self.num = size2num(self.size) - - def update(self, _t, _dt): - """The function to specify the updating rule. - - Parameters - ---------- - _t : float - The current time. - _dt : float - The time step. - """ - raise NotImplementedError(f'Subclass of {self.__class__.__name__} must ' - f'implement "update" function.') diff --git a/brainpy/dyn/rates/fhn.py b/brainpy/dyn/rates/fhn.py deleted file mode 100644 index 72b9c49b9..000000000 --- a/brainpy/dyn/rates/fhn.py +++ /dev/null @@ -1,142 +0,0 @@ -# -*- coding: utf-8 -*- - -import brainpy.math as bm -from brainpy.integrators import odeint, sdeint, JointEq -from brainpy.types import Parameter, Shape -from brainpy.tools.checking import check_float -from .base import RateModel - -__all__ = [ - 'FHN' -] - - -class FHN(RateModel): - r"""FitzHugh-Nagumo system used in [1]_. - - .. math:: - - \frac{dx}{dt} = -\alpha V^3 + \beta V^2 + \gamma V - w + I_{ext}\\ - \tau \frac{dy}{dt} = (V - \delta - \epsilon w) - - Parameters - ---------- - size: Shape - The model size. - - coupling: str - The way of coupling. - gc: float - The global coupling strength. - signal_speed: float - Signal transmission speed between areas. - sc_mat: optional, tensor - Structural connectivity matrix. Adjacency matrix of coupling strengths, - will be normalized to 1. If not given, then a single node simulation - will be assumed. Default None - fl_mat: optional, tensor - Fiber length matrix. Will be used for computing the - delay matrix together with the signal transmission - speed parameter `signal_speed`. Default None. - - References - ---------- - .. [1] Kostova, T., Ravindran, R., & Schonbek, M. (2004). FitzHugh–Nagumo - revisited: Types of bifurcations, periodical forcing and stability - regions by a Lyapunov functional. International journal of - bifurcation and chaos, 14(03), 913-925. - - """ - - def __init__(self, - size: Shape, - - # fhn parameters - alpha: Parameter = 3.0, - beta: Parameter = 4.0, - gamma: Parameter = -1.5, - delta: Parameter = 0.0, - epsilon: Parameter = 0.5, - tau: Parameter = 20.0, - - # noise parameters - x_ou_mean: Parameter = 0.0, - y_ou_mean: Parameter = 0.0, - ou_sigma: Parameter = 0.0, - ou_tau: Parameter = 5.0, - - # coupling parameters - coupling: str = 'diffusive', - gc=0.6, - signal_speed=20.0, - sc_mat=None, - fl_mat=None, - - # other parameters - method: str = None, - name: str = None): - super(FHN, self).__init__(size, name=name) - - # model parameters - self.alpha = alpha - self.beta = beta - self.gamma = gamma - self.delta = delta - self.epsilon = epsilon - self.tau = tau - - # noise parameters - self.x_ou_mean = x_ou_mean # mV/ms, OU process - self.y_ou_mean = y_ou_mean # mV/ms, OU process - self.ou_sigma = ou_sigma # mV/ms/sqrt(ms), noise intensity - self.ou_tau = ou_tau # ms, timescale of the Ornstein-Uhlenbeck noise process - - # coupling parameters - # ---- - # The coupling parameter determines how nodes are coupled. - # "diffusive" for diffusive coupling, - # "additive" for additive coupling - self.coupling = coupling - assert coupling in ['diffusive', 'additive'], (f'Only support "diffusive" and "additive" ' - f'coupling, while we got {coupling}') - check_float(gc, 'gc', allow_none=False, allow_int=False) - self.gc = gc # global coupling strength - check_float(signal_speed, 'signal_speed', allow_none=False, allow_int=True) - self.signal_speed = signal_speed # signal transmission speed between areas - - - # variables - self.x = bm.Variable(bm.random.random(self.num) * 0.05) - self.y = bm.Variable(bm.random.randint(self.num) * 0.05) - self.x_ou = bm.Variable(bm.ones(self.num) * x_ou_mean) - self.y_ou = bm.Variable(bm.ones(self.num) * y_ou_mean) - self.x_ext = bm.Variable(bm.zeros(self.num)) - self.y_ext = bm.Variable(bm.zeros(self.num)) - - # integral functions - self.int_ou = sdeint(f=self.df_ou, g=self.dg_ou, method='euler') - self.int_xy = odeint(f=JointEq([self.dx, self.dy]), method=method) - - def dx(self, x, t, y, x_ext): - return - self.alpha * x ** 3 + self.beta * x ** 2 + self.gamma * x - y + x_ext - - def dy(self, y, t, x, y_ext=0.): - return (x - self.delta - self.epsilon * y + y_ext) / self.tau - - def df_ou(self, x_ou, y_ou, t): - f_x_ou = (self.x_ou_mean - x_ou) / self.ou_tau - f_y_ou = (self.y_ou_mean - y_ou) / self.ou_tau - return f_x_ou, f_y_ou - - def dg_ou(self, x_ou, y_ou, t): - return self.ou_sigma, self.ou_sigma - - def update(self, _t, _dt): - x_ext = self.x_ext + self.x_ou - y_ext = self.y_ext + self.y_ou - x, y = self.int_xy(self.x, self.y, _t, x_ext=x_ext, y_ext=y_ext, dt=_dt) - self.x.value = x - self.y.value = y - x_ou, y_ou = self.int_ou(self.x_ou, self.y_ou, _t, _dt) - self.x_ou.value = x_ou - self.y_ou.value = y_ou diff --git a/brainpy/dyn/rates/models.py b/brainpy/dyn/rates/models.py deleted file mode 100644 index fd16302dd..000000000 --- a/brainpy/dyn/rates/models.py +++ /dev/null @@ -1,25 +0,0 @@ -# -*- coding: utf-8 -*- - -import brainpy.math as bm -from brainpy.integrators import odeint, sdeint, JointEq -from brainpy.types import Parameter, Shape -from .base import RateModel - -__all__ = [ -] - -class JansenRitModel(RateModel): - pass - - -class WilsonCowanModel(RateModel): - pass - - -class StuartLandauOscillator(RateModel): - pass - - -class KuramotoOscillator(RateModel): - pass - diff --git a/brainpy/dyn/rates/qif.py b/brainpy/dyn/rates/qif.py deleted file mode 100644 index 838482ada..000000000 --- a/brainpy/dyn/rates/qif.py +++ /dev/null @@ -1,111 +0,0 @@ -# -*- coding: utf-8 -*- - -import brainpy.math as bm -from brainpy.integrators import odeint, JointEq -from brainpy.types import Parameter, Shape -from .base import RateModel - -__all__ = [ - 'MeanFieldQIF' -] - - -class MeanFieldQIF(RateModel): - r"""A mean-field model of a quadratic integrate-and-fire neuron population. - - **Model Descriptions** - - The QIF population mean-field model, which has been derived from a - population of all-to-all coupled QIF neurons in [5]_. - The model equations are given by: - - .. math:: - - \begin{aligned} - \tau \dot{r} &=\frac{\Delta}{\pi \tau}+2 r v \\ - \tau \dot{v} &=v^{2}+\bar{\eta}+I(t)+J r \tau-(\pi r \tau)^{2} - \end{aligned} - - where :math:`r` is the average firing rate and :math:`v` is the - average membrane potential of the QIF population [5]_. - - This mean-field model is an exact representation of the macroscopic - firing rate and membrane potential dynamics of a spiking neural network - consisting of QIF neurons with Lorentzian distributed background - excitabilities. While the mean-field derivation is mathematically - only valid for all-to-all coupled populations of infinite size, it - has been shown that there is a close correspondence between the - mean-field model and neural populations with sparse coupling and - population sizes of a few thousand neurons [6]_. - - **Model Parameters** - - ============= ============== ======== ======================== - **Parameter** **Init Value** **Unit** **Explanation** - ------------- -------------- -------- ------------------------ - tau 1 ms the population time constant - eta -5. \ the mean of a Lorenzian distribution over the neural excitability in the population - delta 1.0 \ the half-width at half maximum of the Lorenzian distribution over the neural excitability - J 15 \ the strength of the recurrent coupling inside the population - ============= ============== ======== ======================== - - - References - ---------- - .. [5] E. Montbrió, D. Pazó, A. Roxin (2015) Macroscopic description for - networks of spiking neurons. Physical Review X, 5:021028, - https://doi.org/10.1103/PhysRevX.5.021028. - .. [6] R. Gast, H. Schmidt, T.R. Knösche (2020) A Mean-Field Description - of Bursting Dynamics in Spiking Neural Networks with Short-Term - Adaptation. Neural Computation 32.9 (2020): 1615-1634. - - """ - - def __init__(self, - size: Shape, - tau: Parameter = 1., - eta: Parameter = -5.0, - delta: Parameter = 1.0, - J: Parameter = 15., - method: str = 'exp_auto', - name: str = None): - super(MeanFieldQIF, self).__init__(size=size, name=name) - - # parameters - self.tau = tau # - self.eta = eta # the mean of a Lorenzian distribution over the neural excitability in the population - self.delta = delta # the half-width at half maximum of the Lorenzian distribution over the neural excitability - self.J = J # the strength of the recurrent coupling inside the population - - # variables - self.r = bm.Variable(bm.ones(1)) - self.V = bm.Variable(bm.ones(1)) - self.input = bm.Variable(bm.zeros(1)) - - # functions - self.integral = odeint(self.derivative, method=method) - - def dr(self, r, t, v): - return (self.delta / (bm.pi * self.tau) + 2. * r * v) / self.tau - - def dV(self, v, t, r, I_ext): - return (v ** 2 + self.eta + I_ext + self.J * r * self.tau - - (bm.pi * r * self.tau) ** 2) / self.tau - - @property - def derivative(self): - return JointEq([self.dV, self.dr]) - - def update(self, _t, _dt): - v, r = self.integral(self.V, self.r, t=_t, I_ext=self.input, dt=_dt) - self.V.value = v - self.r.value = r - self.input[:] = 0. - - -class ThetaNeuron(RateModel): - pass - - -class MeanFieldQIFWithSFA(RateModel): - pass diff --git a/brainpy/dyn/rates/vdp.py b/brainpy/dyn/rates/vdp.py deleted file mode 100644 index d0de53789..000000000 --- a/brainpy/dyn/rates/vdp.py +++ /dev/null @@ -1,8 +0,0 @@ -# -*- coding: utf-8 -*- - -from .base import RateModel - - -class VanDerPolOscillator(RateModel): - pass - diff --git a/brainpy/dyn/runners/ds_runner.py b/brainpy/dyn/runners.py similarity index 100% rename from brainpy/dyn/runners/ds_runner.py rename to brainpy/dyn/runners.py diff --git a/brainpy/dyn/runners/__init__.py b/brainpy/dyn/runners/__init__.py deleted file mode 100644 index f816b1477..000000000 --- a/brainpy/dyn/runners/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -# -*- coding: utf-8 -*- - -from .ds_runner import * diff --git a/brainpy/dyn/synapses/__init__.py b/brainpy/dyn/synapses/__init__.py index 74d93ede1..3953e6ef9 100644 --- a/brainpy/dyn/synapses/__init__.py +++ b/brainpy/dyn/synapses/__init__.py @@ -3,3 +3,5 @@ from .abstract_models import * from .biological_models import * from .learning_rules import * +from .delay_coupling import * + diff --git a/brainpy/dyn/synapses/delay_coupling.py b/brainpy/dyn/synapses/delay_coupling.py new file mode 100644 index 000000000..826255ca8 --- /dev/null +++ b/brainpy/dyn/synapses/delay_coupling.py @@ -0,0 +1,203 @@ +# -*- coding: utf-8 -*- + +from typing import Optional, Union, Sequence, Dict, List +from jax import vmap +import brainpy.math as bm +from brainpy.dyn.base import TwoEndConn +from brainpy.initialize import Initializer, ZeroInit +from brainpy.tools.checking import check_sequence +from brainpy.types import Tensor + +__all__ = [ + 'DelayCoupling', + 'DiffusiveDelayCoupling', + 'AdditiveDelayCoupling', +] + + +class DelayCoupling(TwoEndConn): + """ + Delay coupling base class. + + coupling: str + The way of coupling. + gc: float + The global coupling strength. + signal_speed: float + Signal transmission speed between areas. + sc_mat: optional, tensor + Structural connectivity matrix. Adjacency matrix of coupling strengths, + will be normalized to 1. If not given, then a single node simulation + will be assumed. Default None + fl_mat: optional, tensor + Fiber length matrix. Will be used for computing the + delay matrix together with the signal transmission + speed parameter `signal_speed`. Default None. + + + """ + + + """Global delay variables. Useful when the same target + variable is used in multiple mappings.""" + global_delay_vars: Dict[str, bm.LengthDelay] = dict() + + def __init__(self, + pre, + post, + from_to: Union[str, Sequence[str]], + conn_mat: Tensor, + delay_mat: Optional[Tensor] = None, + delay_initializer: Initializer = ZeroInit(), + domain: str = 'local', + name: str = None): + super(DelayCoupling, self).__init__(pre, post, name=name) + + # local delay variables + self.local_delay_vars: Dict[str, bm.LengthDelay] = dict() + + # domain + if domain not in ['global', 'local']: + raise ValueError('"domain" must be a string in ["global", "local"]. ' + f'Bug we got {domain}.') + self.domain = domain + + # pairs of (source, destination) + self.source_target_pairs: Dict[str, List[bm.Variable]] = dict() + source_vars = {} + if isinstance(from_to, str): + from_to = [from_to] + check_sequence(from_to, 'from_to', elem_type=str, allow_none=False) + for pair in from_to: + splits = [v.strip() for v in pair.split('->')] + if len(splits) != 2: + raise ValueError('The (source, target) pair in "from_to" ' + 'should be defined as "a -> b".') + if not hasattr(self.pre, splits[0]): + raise ValueError(f'"{splits[0]}" is not defined in pre-synaptic group {self.pre.name}') + if not hasattr(self.post, splits[1]): + raise ValueError(f'"{splits[1]}" is not defined in post-synaptic group {self.post.name}') + source = f'{self.pre.name}.{splits[0]}' + target = getattr(self.post, splits[1]) + if splits[0] not in self.source_target_pairs: + self.source_target_pairs[source] = [target] + source_vars[source] = getattr(self.pre, splits[0]) + if not isinstance(source_vars[source], bm.Variable): + raise ValueError(f'The target variable {source} for delay should ' + f'be an instance of brainpy.math.Variable, while ' + f'we got {type(source_vars[source])}') + else: + if target in self.source_target_pairs: + raise ValueError(f'{pair} has been defined twice in {from_to}.') + self.source_target_pairs[source].append(target) + + # Connection matrix + conn_mat = bm.asarray(conn_mat) + required_shape = (self.post.num, self.pre.num) + if conn_mat.shape != required_shape: + raise ValueError(f'we expect the structural connection matrix has the shape of ' + f'(post.num, pre.num), i.e., {required_shape}, ' + f'while we got {conn_mat.shape}.') + self.conn_mat = bm.asarray(conn_mat) + bm.fill_diagonal(self.conn_mat, 0) + + # Delay matrix + if delay_mat is None: + self.delay_mat = bm.zeros(required_shape, dtype=bm.int_) + else: + if delay_mat.shape != required_shape: + raise ValueError(f'we expect the fiber length matrix has the shape of ' + f'(post.num, pre.num), i.e., {required_shape}. ' + f'While we got {delay_mat.shape}.') + self.delay_mat = bm.asarray(delay_mat, dtype=bm.int_) + + # delay variables + num_delay_step = int(self.delay_mat.max()) + for var in self.source_target_pairs.keys(): + if domain == 'local': + variable = source_vars[var] + shape = (num_delay_step,) + variable.shape + delay_data = delay_initializer(shape, dtype=variable.dtype) + self.local_delay_vars[var] = bm.LengthDelay(variable, num_delay_step, delay_data) + else: + if var not in self.global_delay_vars: + variable = source_vars[var] + shape = (num_delay_step,) + variable.shape + delay_data = delay_initializer(shape, dtype=variable.dtype) + self.global_delay_vars[var] = bm.LengthDelay(variable, num_delay_step, delay_data) + # save into local delay vars when first seen "var", + # for later update current value! + self.local_delay_vars[var] = self.global_delay_vars[var] + else: + if self.global_delay_vars[var].delay_len < num_delay_step: + variable = source_vars[var] + shape = (num_delay_step,) + variable.shape + delay_data = delay_initializer(shape, dtype=variable.dtype) + self.global_delay_vars[var].init(variable, num_delay_step, delay_data) + + self.register_implicit_nodes(self.local_delay_vars) + self.register_implicit_nodes(self.global_delay_vars) + + def update(self, _t, _dt): + raise NotImplementedError('Must implement the update() function by users.') + + +class DiffusiveDelayCoupling(DelayCoupling): + def update(self, _t, _dt): + for source, targets in self.source_target_pairs.items(): + # delay variable + if self.domain == 'local': + delay_var: bm.LengthDelay = self.local_delay_vars[source] + elif self.domain == 'global': + delay_var: bm.LengthDelay = self.global_delay_vars[source] + else: + raise ValueError(f'Unknown domain: {self.domain}') + + # current data + name, var = source.split('.') + assert name == self.pre.name + variable = getattr(self.pre, var) + + # delays + f = vmap(lambda i: delay_var(self.delay_mat[i], bm.arange(self.pre.num))) # (pre.num,) + delays = f(bm.arange(self.post.num).value) + diffusive = delays - bm.expand_dims(variable, axis=1) # (post.num, pre.num) + diffusive = (self.conn_mat * diffusive).sum(axis=1) + + # output to target variable + for target in targets: + target.value += diffusive + + # update + if source in self.local_delay_vars: + delay_var.update(variable) + + +class AdditiveDelayCoupling(DelayCoupling): + def update(self, _t, _dt): + for source, targets in self.source_target_pairs.items(): + # delay variable + if self.domain == 'local': + delay_var: bm.LengthDelay = self.local_delay_vars[source] + elif self.domain == 'global': + delay_var: bm.LengthDelay = self.global_delay_vars[source] + else: + raise ValueError(f'Unknown domain: {self.domain}') + + # current data + name, var = source.split('.') + assert name == self.pre.name + variable = getattr(self.pre, var) + + # delay function + f = bm.vmap(lambda i: delay_var(self.delay_mat[i], bm.arange(self.pre.num))) # (pre.num,) + delays = f(bm.arange(self.post.num)) # (post.num, pre.num) + additive = (self.conn_mat * delays).sum(axis=1) + + # output to target variable + for target in targets: + target.value += additive + + # update + if source in self.local_delay_vars: + delay_var.update(variable) From 6744924a25b47a74148d97dffd0c908a4cd0974d Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:11:13 +0800 Subject: [PATCH 09/22] doc: documentation for add new models --- docs/auto_generater.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/docs/auto_generater.py b/docs/auto_generater.py index e9909367a..811322af9 100644 --- a/docs/auto_generater.py +++ b/docs/auto_generater.py @@ -8,7 +8,6 @@ jit, operators, parallels, setting, delay_vars, compat) - block_list = ['test', 'register_pytree_node'] for module in [jit, autograd, function, controls, activations, @@ -230,19 +229,26 @@ def generate_dyn_docs(path='apis/auto/dyn/'): filename=os.path.join(path, 'base.rst'), header='Base Class') - module_and_name = [('biological_models', 'Biological Models'), - ('input_models', 'Input Models'), - ('rate_models', 'Rate Models'), - ('reduced_models', 'Reduced Models'), ] + module_and_name = [ + ('biological_models', 'Biological Models'), + ('fractional_models', 'Fractional-order Models'), + ('input_models', 'Input Models'), + ('noise_models', 'Noise Models'), + ('rate_models', 'Rate Models'), + ('reduced_models', 'Reduced Models'), + ] write_submodules(module_name='brainpy.dyn.neurons', filename=os.path.join(path, 'neurons.rst'), header='Neuron Models', submodule_names=[a[0] for a in module_and_name], section_names=[a[1] for a in module_and_name]) - module_and_name = [('biological_models', 'Biological Models'), - ('abstract_models', 'Abstract Models'), - ('learning_rules', 'Learning Rules'), ] + module_and_name = [ + ('biological_models', 'Biological Models'), + ('abstract_models', 'Abstract Models'), + ('delay_coupling', 'Delay Coupling Models'), + ('learning_rules', 'Learning Rule Models'), + ] write_submodules(module_name='brainpy.dyn.synapses', filename=os.path.join(path, 'synapses.rst'), header='Synapse Models', @@ -457,8 +463,6 @@ def generate_nn_docs(path='apis/auto/nn/'): header='Nodes: reservoir computing') - - def generate_optimizers_docs(path='apis/auto/'): if not os.path.exists(path): os.makedirs(path) @@ -540,4 +544,3 @@ def generate_math_compact_docs(path='apis/auto/math_compat/'): write_module(module_name='brainpy.math.compat.losses', filename=os.path.join(path, 'losses.rst'), header='Losses') - From 1c54e1ae891f79879699a8f570575c182a8202bf Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:16:02 +0800 Subject: [PATCH 10/22] feat: update delay variables --- brainpy/integrators/dde/base.py | 20 ++- brainpy/math/compat/delay_vars.py | 45 +++++++ brainpy/math/delay_vars.py | 202 +++++++++++------------------- 3 files changed, 131 insertions(+), 136 deletions(-) create mode 100644 brainpy/math/compat/delay_vars.py diff --git a/brainpy/integrators/dde/base.py b/brainpy/integrators/dde/base.py index 380fb6ba4..10ba9dd17 100644 --- a/brainpy/integrators/dde/base.py +++ b/brainpy/integrators/dde/base.py @@ -59,7 +59,9 @@ def __init__( # delays self._state_delays = dict() if state_delays is not None: - check_dict_data(state_delays, key_type=str, val_type=bm.TimeDelay) + check_dict_data(state_delays, + key_type=str, + val_type=(bm.TimeDelay, bm.LengthDelay)) for key, delay in state_delays.items(): if key not in self.variables: raise DiffEqError(f'"{key}" is not defined in the variables: {self.variables}') @@ -67,7 +69,9 @@ def __init__( self.register_implicit_nodes(self._state_delays) self._neutral_delays = dict() if neutral_delays is not None: - check_dict_data(neutral_delays, key_type=str, val_type=bm.NeutralDelay) + check_dict_data(neutral_delays, + key_type=str, + val_type=bm.NeutralDelay) for key, delay in neutral_delays.items(): if key not in self.variables: raise DiffEqError(f'"{key}" is not defined in the variables: {self.variables}') @@ -111,11 +115,19 @@ def __call__(self, *args, **kwargs): else: new_dvars = {k: new_dvars[i] for i, k in enumerate(self.variables)} for key, delay in self.neutral_delays.items(): - delay.update(kwargs['t'] + dt, new_dvars[key]) + if isinstance(delay, bm.LengthDelay): + delay.update(new_dvars[key]) + elif isinstance(delay, bm.TimeDelay): + delay.update(kwargs['t'] + dt, new_dvars[key]) + raise ValueError('Unknown delay variable.') # update state delay variables for key, delay in self.state_delays.items(): - delay.update(kwargs['t'] + dt, dict_vars[key]) + if isinstance(delay, bm.LengthDelay): + delay.update(dict_vars[key]) + elif isinstance(delay, bm.TimeDelay): + delay.update(kwargs['t'] + dt, dict_vars[key]) + raise ValueError('Unknown delay variable.') return new_vars diff --git a/brainpy/math/compat/delay_vars.py b/brainpy/math/compat/delay_vars.py new file mode 100644 index 000000000..93321538c --- /dev/null +++ b/brainpy/math/compat/delay_vars.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- + +import warnings +from typing import Union, Callable + +import jax.numpy as jnp + +from brainpy.math.jaxarray import ndarray +from brainpy.math.numpy_ops import zeros +from brainpy.math.delay_vars import TimeDelay + + +__all__ = [ + 'FixedLenDelay' +] + + +def FixedLenDelay(shape, + delay_len: Union[float, int], + before_t0: Union[Callable, ndarray, jnp.ndarray, float, int] = None, + t0: Union[float, int] = 0., + dt: Union[float, int] = None, + name: str = None, + interp_method='linear_interp', ): + """Delay variable which has a fixed delay length. + + .. deprecated:: 2.1.2 + Please use "brainpy.math.TimeDelay" instead. + + See Also + -------- + TimeDelay + + """ + warnings.warn('Please use "brainpy.math.TimeDelay" instead. ' + '"brainpy.math.FixedLenDelay" is deprecated since version 2.1.2. ', + DeprecationWarning) + return TimeDelay(inits=zeros(shape), + delay_len=delay_len, + before_t0=before_t0, + t0=t0, + dt=dt, + name=name, + interp_method=interp_method) + diff --git a/brainpy/math/delay_vars.py b/brainpy/math/delay_vars.py index f9be0bf23..4b2ffb3b4 100644 --- a/brainpy/math/delay_vars.py +++ b/brainpy/math/delay_vars.py @@ -1,7 +1,6 @@ # -*- coding: utf-8 -*- -import warnings -from typing import Union, Callable, Tuple +from typing import Union, Callable import jax.numpy as jnp import numpy as np @@ -10,16 +9,16 @@ from jax.lax import cond from brainpy import check -from brainpy import math as bm from brainpy.base.base import Base from brainpy.errors import UnsupportedError +from brainpy.math import numpy_ops as ops +from brainpy.math.jaxarray import ndarray, Variable +from brainpy.math.setting import get_dt from brainpy.tools.checking import check_float, check_integer -from brainpy.tools.others import to_size __all__ = [ 'AbstractDelay', 'TimeDelay', - 'FixedLenDelay', 'NeutralDelay', 'LengthDelay', ] @@ -76,7 +75,7 @@ class TimeDelay(AbstractDelay): Parameters ---------- inits: int, sequence of int - The delay data shape. + The initial delay data. t0: float, int The zero time. delay_len: float, int @@ -104,35 +103,35 @@ class TimeDelay(AbstractDelay): at ``t-0.53``. .. versionadded:: 2.1.1 + + See Also + -------- + LengthDelay """ def __init__( self, - inits: Union[bm.ndarray, jnp.ndarray], + inits: Union[ndarray, jnp.ndarray], delay_len: Union[float, int], - before_t0: Union[Callable, bm.ndarray, jnp.ndarray, float, int] = None, + before_t0: Union[Callable, ndarray, jnp.ndarray, float, int] = None, t0: Union[float, int] = 0., dt: Union[float, int] = None, name: str = None, - dtype=None, interp_method='linear_interp', ): super(TimeDelay, self).__init__(name=name) - # dtype - self.dtype = dtype - # shape - assert isinstance(inits, (bm.ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' - f'or jax.numpy.ndarray. But we got {type(inits)}') - self.shape = bm.asarray(inits).shape + assert isinstance(inits, (ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' + f'or jax.numpy.ndarray. But we got {type(inits)}') + self.shape = inits.shape # delay_len self.t0 = t0 - self._dt = bm.get_dt() if dt is None else dt + self.dt = get_dt() if dt is None else dt check_float(delay_len, 'delay_len', allow_none=False, allow_int=True, min_bound=0.) self.delay_len = delay_len - self.num_delay_step = int(bm.ceil(self.delay_len / self._dt).value) + 1 + self.num_delay_step = int(ops.ceil(self.delay_len / self.dt).value) + 1 # interp method if interp_method not in [_INTERP_LINEAR, _INTERP_ROUND]: @@ -141,81 +140,42 @@ def __init__( self.interp_method = interp_method # time variables - self._idx = bm.Variable(bm.asarray([0])) + self.idx = ops.Variable(ops.asarray([0])) check_float(t0, 't0', allow_none=False, allow_int=True, ) - self._current_time = bm.Variable(bm.asarray([t0])) + self.current_time = Variable(ops.asarray([t0])) # delay data - self._data = bm.Variable(bm.zeros((self.num_delay_step,) + self.shape, dtype=dtype)) + self.data = Variable(ops.zeros((self.num_delay_step,) + self.shape, + dtype=inits.dtype)) if before_t0 is None: self._before_type = _DATA_BEFORE elif callable(before_t0): - self._before_t0 = lambda t: jnp.asarray(bm.broadcast_to(before_t0(t), self.shape).value, - dtype=self.dtype) + self._before_t0 = lambda t: jnp.asarray(ops.broadcast_to(before_t0(t), self.shape).value, + dtype=inits.dtype) self._before_type = _FUNC_BEFORE - elif isinstance(before_t0, (bm.ndarray, jnp.ndarray, float, int)): + elif isinstance(before_t0, (ndarray, jnp.ndarray, float, int)): self._before_type = _DATA_BEFORE - self._data[:-1] = before_t0 - # try: - # pass - # except: - # raise ValueError(f'Cannot set delay data by using "before_t0". ' - # f'The delay data has the shape of ' - # f'{((self.num_delay_step,) + self.shape)}, while ' - # f'we got "before_t0" of {bm.asarray(before_t0).shape}. ' - # f'They are not compatible. Note that the delay length ' - # f'{self._delay_len} will automatically add a dt {self.dt} ' - # f'to {self.delay_len}.') + self.data[:-1] = before_t0 else: raise ValueError(f'"before_t0" does not support {type(before_t0)}') # set initial data - self._data[-1] = inits + self.data[-1] = inits # interpolation function self.f = jnp.interp for dim in range(1, len(self.shape) + 1, 1): self.f = vmap(self.f, in_axes=(None, None, dim), out_axes=dim - 1) - @property - def idx(self): - return self._idx - - @idx.setter - def idx(self, value): - raise ValueError('Cannot set "idx" by users.') - - @property - def dt(self): - return self._dt - - @dt.setter - def dt(self, value): - raise ValueError('Cannot set "dt" by users.') - - @property - def data(self): - return self._data - - @data.setter - def data(self, value): - self._data[:] = value - - @property - def current_time(self): - return self._current_time[0] - def _check_time(self, times, transforms): prev_time, current_time = times - current_time = np.asarray(current_time, dtype=bm.float_) - prev_time = np.asarray(prev_time, dtype=bm.float_) - if prev_time > current_time: + if prev_time > current_time + 1e-6: raise ValueError(f'\n' f'!!! Error in {self.__class__.__name__}: \n' f'The request time should be less than the ' f'current time {current_time}. But we ' f'got {prev_time} > {current_time}') - lower_time = np.asarray(current_time - self.delay_len) - if prev_time < lower_time: + lower_time = current_time - self.delay_len + if prev_time < lower_time - self.dt: raise ValueError(f'\n' f'!!! Error in {self.__class__.__name__}: \n' f'The request time of the variable should be in ' @@ -235,14 +195,14 @@ def __call__(self, time, indices=None): def _after_t0(self, prev_time): diff = self.delay_len - (self.current_time - prev_time) - if isinstance(diff, bm.ndarray): + if isinstance(diff, ndarray): diff = diff.value if self.interp_method == _INTERP_LINEAR: - req_num_step = jnp.asarray(diff / self._dt, dtype=bm.get_dint()) - extra = diff - req_num_step * self._dt + req_num_step = jnp.asarray(diff / self.dt, dtype=ops.int32) + extra = diff - req_num_step * self.dt return cond(extra == 0., self._true_fn, self._false_fn, (req_num_step, extra)) elif self.interp_method == _INTERP_ROUND: - req_num_step = jnp.asarray(jnp.round(diff / self._dt), dtype=bm.get_dint()) + req_num_step = jnp.asarray(jnp.round(diff / self.dt), dtype=ops.int32) return self._true_fn([req_num_step, 0.]) else: raise UnsupportedError(f'Un-supported interpolation method {self.interp_method}, ' @@ -250,40 +210,19 @@ def _after_t0(self, prev_time): def _true_fn(self, div_mod): req_num_step, extra = div_mod - return self._data[self.idx[0] + req_num_step] + return self.data[self.idx[0] + req_num_step] def _false_fn(self, div_mod): req_num_step, extra = div_mod idx = jnp.asarray([self.idx[0] + req_num_step, self.idx[0] + req_num_step + 1]) idx %= self.num_delay_step - return self.f(extra, jnp.asarray([0., self._dt]), self._data[idx]) + return self.f(extra, jnp.asarray([0., self.dt]), self.data[idx]) def update(self, time, value): - self._data[self._idx[0]] = value - self._current_time[0] = time - self._idx.value = (self._idx + 1) % self.num_delay_step - - -def FixedLenDelay(inits: Union[bm.ndarray, jnp.ndarray], - delay_len: Union[float, int], - before_t0: Union[Callable, bm.ndarray, jnp.ndarray, float, int] = None, - t0: Union[float, int] = 0., - dt: Union[float, int] = None, - name: str = None, - dtype=None, - interp_method='linear_interp', ): - warnings.warn('Please use "brainpy.math.TimeDelay" instead. ' - '"brainpy.math.FixedLenDelay" is deprecated since version 2.1.2. ', - DeprecationWarning) - return TimeDelay(inits=inits, - delay_len=delay_len, - before_t0=before_t0, - t0=t0, - dt=dt, - name=name, - dtype=dtype, - interp_method=interp_method) + self.data[self.idx[0]] = value + self.current_time[0] = time + self.idx.value = (self.idx + 1) % self.num_delay_step class NeutralDelay(TimeDelay): @@ -292,22 +231,37 @@ class NeutralDelay(TimeDelay): class LengthDelay(AbstractDelay): """Delay variable which has a fixed delay length. + + Parameters + ---------- + inits: int, sequence of int + The initial delay data. + delay_len: int + The maximum delay length. + delay_data: Tensor + The delay data. + name: str + The delay object name. + + See Also + -------- + TimeDelay """ + def __init__( self, - inits: Union[bm.ndarray, jnp.ndarray], + inits: Union[ndarray, jnp.ndarray], delay_len: int, - delay_data: Union[bm.ndarray, jnp.ndarray, float, int] = None, + delay_data: Union[ndarray, jnp.ndarray, float, int] = None, name: str = None, - dtype=None, ): super(LengthDelay, self).__init__(name=name) + self.init(inits, delay_len, delay_data) - # shape and dtype - assert isinstance(inits, (bm.ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' - f'or jax.numpy.ndarray. But we got {type(inits)}') + def init(self, inits, delay_len, delay_data): + assert isinstance(inits, (ndarray, np.ndarray)), (f'Must be an instance of brainpy.math.ndarray ' + f'or jax.numpy.ndarray. But we got {type(inits)}') self.shape = inits.shape - self.dtype = dtype # delay_len check_integer(delay_len, 'delay_len', allow_none=False, min_bound=0) @@ -315,35 +269,20 @@ def __init__( self.num_delay_step = delay_len + 1 # time variables - self._idx = bm.Variable(bm.asarray([0], dtype=bm.int_)) + self.idx = Variable(ops.asarray([0], dtype=ops.int32)) # delay data - self._data = bm.Variable(bm.zeros((self.num_delay_step,) + self.shape, dtype=dtype)) + self.data = Variable(ops.zeros((self.num_delay_step,) + self.shape, + dtype=inits.dtype)) if delay_data is None: pass - elif isinstance(delay_data, (bm.ndarray, jnp.ndarray, float, int)): - self._data[:-1] = delay_data + elif isinstance(delay_data, (ndarray, jnp.ndarray, float, int)): + self.data[:-1] = delay_data else: raise ValueError(f'"delay_data" does not support {type(delay_data)}') - @property - def idx(self): - return self._idx - - @idx.setter - def idx(self, value): - raise ValueError('Cannot set "idx" by users.') - - @property - def data(self): - return self._data - - @data.setter - def data(self, value): - self._data[:-1] = value - def _check_delay(self, delay_len, transforms): - if isinstance(delay_len, bm.ndarray): + if isinstance(delay_len, ndarray): delay_len = delay_len.value if np.any(delay_len >= self.num_delay_step): raise ValueError(f'\n' @@ -358,7 +297,7 @@ def __call__(self, delay_len, indices=None): id_tap(self._check_delay, delay_len) # the delay length delay_idx = (self.idx[0] - delay_len - 1) % self.num_delay_step - if delay_idx.dtype not in [bm.int32, bm.int64]: + if delay_idx.dtype not in [ops.int32, ops.int64]: raise ValueError(f'"delay_len" must be integer, but we got {delay_len}') # the delay data if indices is None: @@ -367,8 +306,7 @@ def __call__(self, delay_len, indices=None): return self.data[delay_idx, indices] def update(self, value): - if bm.shape(value) != self.shape: - raise ValueError(f'value shape should be {self.shape}, but we got {bm.shape(value)}') - self._data[self.idx[0]] = value - self._idx.value = (self._idx + 1) % self.num_delay_step - + if ops.shape(value) != self.shape: + raise ValueError(f'value shape should be {self.shape}, but we got {ops.shape(value)}') + self.data[self.idx[0]] = value + self.idx.value = (self.idx + 1) % self.num_delay_step From 30b7fc19e77d5817e4afc2c4a32c86ad549ecf5b Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:16:17 +0800 Subject: [PATCH 11/22] feat: update initializer --- brainpy/initialize/base.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/brainpy/initialize/base.py b/brainpy/initialize/base.py index 00782f32e..c63524e13 100644 --- a/brainpy/initialize/base.py +++ b/brainpy/initialize/base.py @@ -13,7 +13,7 @@ class Initializer(abc.ABC): """Base Initialization Class.""" @abc.abstractmethod - def __call__(self, shape): + def __call__(self, shape, dtype=None): raise NotImplementedError @@ -21,7 +21,7 @@ class InterLayerInitializer(Initializer): """The superclass of Initializers that initialize the weights between two layers.""" @abc.abstractmethod - def __call__(self, shape): + def __call__(self, shape, dtype=None): raise NotImplementedError @@ -29,5 +29,5 @@ class IntraLayerInitializer(Initializer): """The superclass of Initializers that initialize the weights within a layer.""" @abc.abstractmethod - def __call__(self, shape): + def __call__(self, shape, dtype=None): raise NotImplementedError From 1c865d6157d06aae1789162969f45e944a2a76aa Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:36:03 +0800 Subject: [PATCH 12/22] feat: update correlation apis --- brainpy/measure/correlation.py | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/brainpy/measure/correlation.py b/brainpy/measure/correlation.py index 5514a56b6..7d228ac58 100644 --- a/brainpy/measure/correlation.py +++ b/brainpy/measure/correlation.py @@ -146,15 +146,14 @@ def voltage_fluctuation(potentials): potentials = bm.as_device_array(potentials) num_hist, num_neu = potentials.shape var_mean = jnp.mean(_var(potentials, jnp.arange(num_neu))) - avg = bm.mean(potentials, axis=1) - avg_var = bm.mean(avg * avg) - bm.mean(avg) ** 2 + avg = jnp.mean(potentials, axis=1) + avg_var = jnp.mean(avg * avg) - jnp.mean(avg) ** 2 return lax.cond(var_mean != 0., lambda _: avg_var / var_mean, lambda _: 1., ()) -@jit def matrix_correlation(x, y): """Pearson correlation of the lower triagonal of two matrices. @@ -172,17 +171,17 @@ def matrix_correlation(x, y): coef: tensor Correlation coefficient """ - x = bm.asarray(x) - y = bm.asarray(y) + x = bm.as_numpy(x) + y = bm.as_numpy(y) if x.ndim != 2: raise ValueError(f'Only support 2d tensor, but we got a tensor ' f'with the shape of {x.shape}') if y.ndim != 2: raise ValueError(f'Only support 2d tensor, but we got a tensor ' f'with the shape of {y.shape}') - x = x[bm.triu_indices_from(x, k=1)] - y = y[bm.triu_indices_from(y, k=1)] - cc = bm.corrcoef(x, y)[0, 1] + x = x[np.triu_indices_from(x, k=1)] + y = y[np.triu_indices_from(y, k=1)] + cc = np.corrcoef(x, y)[0, 1] return cc From c0450c4b56beb342d72152e4d342efee4b3a73bd Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 22 Mar 2022 21:48:48 +0800 Subject: [PATCH 13/22] example: add whole-brain modeling examples --- .../whole_brain_simulation_with_fhn.py | 70 +++++++++++++++++++ ...ole_brain_simulation_with_sl_oscillator.py | 67 ++++++++++++++++++ 2 files changed, 137 insertions(+) create mode 100644 examples/simulation/whole_brain_simulation_with_fhn.py create mode 100644 examples/simulation/whole_brain_simulation_with_sl_oscillator.py diff --git a/examples/simulation/whole_brain_simulation_with_fhn.py b/examples/simulation/whole_brain_simulation_with_fhn.py new file mode 100644 index 000000000..7fa0cf80a --- /dev/null +++ b/examples/simulation/whole_brain_simulation_with_fhn.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- + + +import matplotlib.pyplot as plt +import numpy as np + +import brainpy as bp +import brainpy.math as bm + +bp.check.turn_off() + + +def bifurcation_analysis(): + model = bp.dyn.RateFHN(1, method='exp_auto') + pp = bp.analysis.Bifurcation2D( + model, + target_vars={'x': [-2, 2], 'y': [-2, 2]}, + target_pars={'x_ext': [0, 2]}, + resolutions={'x_ext': 0.01} + ) + pp.plot_bifurcation() + pp.plot_limit_cycle_by_sim(duration=500) + pp.show_figure() + + +class Network(bp.dyn.Network): + def __init__(self, signal_speed=20.): + super(Network, self).__init__() + + # Please download the processed data "hcp.npz" of the + # ConnectomeDB of the Human Connectome Project (HCP) + # from the following link: + # - https://share.weiyun.com/wkPpARKy + hcp = np.load('hcp.npz') + conn_mat = bm.asarray(hcp['Cmat']) + bm.fill_diagonal(conn_mat, 0) + delay_mat = bm.round(hcp['Dmat'] / signal_speed / bm.get_dt()) + + self.fhn = bp.dyn.RateFHN(80, x_ou_sigma=0.01, y_ou_sigma=0.01, + name='fhn', method='exp_auto') + self.coupling = bp.dyn.DiffusiveDelayCoupling(self.fhn, self.fhn, + 'x->input', + conn_mat=conn_mat, + delay_mat=delay_mat, + delay_initializer=bp.init.Uniform(0, 0.05)) + + def update(self, _t, _dt): + self.coupling.update(_t, _dt) + self.fhn.update(_t, _dt) + + +def brain_simulation(): + net = Network() + runner = bp.dyn.DSRunner(net, monitors=['fhn.x'], inputs=['fhn.input', 0.72]) + runner.run(6e3) + + plt.rcParams['image.cmap'] = 'plasma' + fig, axs = plt.subplots(1, 2, figsize=(12, 4)) + fc = bp.measure.functional_connectivity(runner.mon['fhn.x']) + ax = axs[0].imshow(fc) + plt.colorbar(ax, ax=axs[0]) + axs[1].plot(runner.mon.ts, runner.mon['fhn.x'][:, ::5], alpha=0.8) + plt.tight_layout() + plt.show() + + +if __name__ == '__main__': + bifurcation_analysis() + brain_simulation() + diff --git a/examples/simulation/whole_brain_simulation_with_sl_oscillator.py b/examples/simulation/whole_brain_simulation_with_sl_oscillator.py new file mode 100644 index 000000000..b9484ecf1 --- /dev/null +++ b/examples/simulation/whole_brain_simulation_with_sl_oscillator.py @@ -0,0 +1,67 @@ +# -*- coding: utf-8 -*- + +import matplotlib.pyplot as plt +import numpy as np + +import brainpy as bp +import brainpy.math as bm + +bp.check.turn_off() + + +def bifurcation_analysis(): + model = bp.dyn.StuartLandauOscillator(1, method='exp_auto') + pp = bp.analysis.Bifurcation2D( + model, + target_vars={'x': [-2, 2], 'y': [-2, 2]}, + pars_update={'x_ext': 0., 'y_ext': 0., 'w': 0.2}, + target_pars={'a': [-2, 2]}, + resolutions={'a': 0.01} + ) + pp.plot_bifurcation() + pp.show_figure() + + +class Network(bp.dyn.Network): + def __init__(self): + super(Network, self).__init__() + + # Please download the processed data "hcp.npz" of the + # ConnectomeDB of the Human Connectome Project (HCP) + # from the following link: + # - https://share.weiyun.com/wkPpARKy + hcp = np.load('hcp.npz') + conn_mat = bm.asarray(hcp['Cmat']) + bm.fill_diagonal(conn_mat, 0) + gc = 0.6 # global coupling strength + + self.sl = bp.dyn.StuartLandauOscillator(80, x_ou_sigma=0.14, y_ou_sigma=0.14, + name='sl', method='exp_auto') + self.coupling = bp.dyn.DiffusiveDelayCoupling(self.sl, self.sl, + 'x->input', + conn_mat=conn_mat * gc, + delay_initializer=bp.init.Uniform(0, 0.05)) + + def update(self, _t, _dt): + self.coupling.update(_t, _dt) + self.sl.update(_t, _dt) + + +def simulation(): + net = Network() + runner = bp.dyn.DSRunner(net, monitors=['sl.x']) + runner.run(6e3) + + plt.rcParams['image.cmap'] = 'plasma' + fig, axs = plt.subplots(1, 2, figsize=(12, 4)) + fc = bp.measure.functional_connectivity(runner.mon['sl.x']) + ax = axs[0].imshow(fc) + plt.colorbar(ax, ax=axs[0]) + axs[1].plot(runner.mon.ts, runner.mon['sl.x'][:, ::5], alpha=0.8) + plt.tight_layout() + plt.show() + + +if __name__ == '__main__': + bifurcation_analysis() + simulation() From 1813673cfa53d9fcb7612593bdcf11776d83e20f Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 11:16:32 +0800 Subject: [PATCH 14/22] doc: add rate model quickstart --- docs/index.rst | 1 + docs/quickstart/rate_model.ipynb | 793 ++++++++++++++++++++++++++++++- 2 files changed, 786 insertions(+), 8 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index 3fc4df35d..deccd7129 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -38,6 +38,7 @@ The code of BrainPy is open-sourced at GitHub: quickstart/installation quickstart/simulation + quickstart/rate_model quickstart/training quickstart/analysis diff --git a/docs/quickstart/rate_model.ipynb b/docs/quickstart/rate_model.ipynb index 9fa48e0c3..1433e9af7 100644 --- a/docs/quickstart/rate_model.ipynb +++ b/docs/quickstart/rate_model.ipynb @@ -5,23 +5,800 @@ "id": "16ac58ee", "metadata": {}, "source": [ - "# Simulating a Rate Network Model" + "# Simulating a Whole-brain Neural Mass Model" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "id": "39953757", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "@[Chaoming Wang](https://github.com/chaoming0625)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Whole-brain modeling is the grand challenge of computational neuroscience. Simulating a whole-brain models with spiking neurons is still nearly impossible for normal users. However, by using rate-based neural mass models, in which each brain region is approximated to several simple variables, we can build an abstract whole-brain model. In recent years, whole-brain models can be used to address a wide range of problems. In this section, we are going to talk about how to simulate a whole-brain neural mass model with BrainPy." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "import brainpy as bp\n", + "import brainpy.math as bm\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams['image.cmap'] = 'plasma'" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Neural mass model" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "A neural mass models is a low-dimensional population model of spiking neural networks. It aims to describe the coarse grained activity of large populations of neurons and synapses. Mathematically, it is a dynamical system of non-linear ODEs. A classical neural mass model is the two dimensional [Wilson–Cowan model](https://en.wikipedia.org/wiki/Wilson%E2%80%93Cowan_model). This model tracks the activity of an excitatory population of neurons coupled to an inhibitory population. With the augmentation of such models by more realistic forms of synaptic and network interaction they have proved especially successful in providing fits to neuro-imaging data." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Here, let's try the Wilson-Cowan model." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + }, + { + "data": { + "text/plain": " 0%| | 0/100 [00:00", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "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", + "wc.x[:] = [-0.2, 1.]\n", + "wc.y[:] = [0.0, 1.]\n", + "\n", + "runner = bp.dyn.DSRunner(wc, monitors=['x', 'y'], inputs=['input', -0.5])\n", + "runner.run(10.)\n", + "\n", + "bp.visualize.line_plot(runner.mon.ts, runner.mon.x,\n", + " plot_ids=[0, 1], legend='e', show=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can see this model at least has two stable states." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "**Bifurcation diagram**\n", + "\n", + "With the automatic analysis module in BrainPy, we can easily inspect the bifurcation digram of the model. Bifurcation diagrams can give us an overview of how different parameters of the model affect its dynamics (the details of the automatic analysis support of BrainPy please see the introduction in [Analyzing a Dynamical Model](./analysis.ipynb) and tutorials in [Dynamics Analysis](../tutorial_analysis/index.rst)). In this case, we make ``x_ext`` as a bifurcation parameter, and try to see how the system behavior changes with the change of ``x_ext``." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I am making bifurcation analysis ...\n", + "I am filtering out fixed point candidates with auxiliary function ...\n", + "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", + "I am plotting the limit cycle ...\n", + "C:\\Users\\adadu\\miniconda3\\lib\\site-packages\\jax\\_src\\numpy\\lax_numpy.py:3610: UserWarning: Explicitly requested dtype requested in asarray is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"asarray\")\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEHCAYAAACwUAEWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAiLklEQVR4nO3deXxU9b3/8dcnIYAsQgRjkS1glZ8IGCAsXjfASlH6cPuVq7ZuWIva2tvlZ4u9vbegxWqvXn/qr1RLrUqrVYutVvvA2rpVreKDBAOyGArIEuGyGRGQJSGf3x8ziZNkcjKTTOZMMu/n48HDzMw353w4YN58l/M95u6IiIg0JSfsAkREJLMpKEREJJCCQkREAikoREQkkIJCREQCKShERCRQp7ALaAt9+/b1wsLCsMsQEWk3SktLd7n7sfE+CzUozOxh4EvADncfEedzA+4Dzgc+Ba5x92XNHbewsJCSkpJUlysi0mGZ2aamPgt76OlRYFrA5+cBJ0Z/zQIeSENNIiISI9SgcPfXgY8CmlwI/MYjlgC9zaxfeqoTEREIv0fRnP7AlpjXFdH3REQkTTJ9MtvivBd3cyozm0VkeIpBgwa1ZU0i0gpVVVVUVFRw8ODBsEvJSl27dmXAgAHk5eUl/D2ZHhQVwMCY1wOArfEauvsCYAFAcXGxdjoUyVAVFRX07NmTwsJCIutVJF3cnd27d1NRUcGQIUMS/r5MH3p6DrjKIiYCe9x9W9hFiUjLHTx4kD59+igkQmBm9OnTJ+neXNjLY58AJgF9zawCmAPkAbj7g8BiIktj1xFZHjsznEpFJJUUEuFpybUPe9XT5e7ez93z3H2Au//a3R+MhgTR1U7fdPcT3H2ku+vmCBEJzcaNGxkxotEtXwBMmjSp7v6twsJCdu3alba62vp8mT70JCIiIVNQiEjGK91UyfxX11G6qbLVx9q/fz/Tp0/n1FNPZcSIETz11FMA3HbbbYwbN44RI0Ywa9Ysap/+WVpayqmnnsppp53G/Pnz645z4MABLrvsMkaNGsWll17KgQMH4p7vscceY/z48RQVFXH99ddz5MiRRm0KCwuZM2cOY8aMYeTIkbz//vsAfPTRR1x00UWMGjWKiRMnsmLFCgB2797N1KlTGT16NNdffz2xTypN5HzJUlCISEYr3VTJVx9awn//tZyvPrSk1WHxl7/8heOPP57ly5ezcuVKpk2LbA5x0003sXTpUlauXMmBAwf485//DMDMmTO5//77efvtt+sd54EHHqBbt26sWLGCH/3oR5SWljY615o1a3jqqaf4xz/+QVlZGbm5uTz++ONx6+rbty/Lli3jxhtv5O677wZgzpw5jB49mhUrVvDTn/6Uq666CoBbb72VM844g3fffZcLLriAzZs3J32+ZCgoRCSjLdmwm8PVNdQ4VFXXsGTD7lYdb+TIkbz00kvMnj2bN954g169egHw6quvMmHCBEaOHMkrr7zCqlWr2LNnDx9//DFnn302AFdeeWXdcV5//XWuuOIKAEaNGsWoUaManevll1+mtLSUcePGUVRUxMsvv8yGDRvi1nXJJZcAMHbsWDZu3AjAm2++WXfOKVOmsHv3bvbs2VPv3NOnTyc/Pz/p8yUj0++jEJEsN3FoHzp3yqGquoa8TjlMHNqnVcc76aSTKC0tZfHixfzwhz9k6tSp/OAHP+Ab3/gGJSUlDBw4kLlz53Lw4EHcPXCVUHMriNydq6++mjvuuKPZurp06QJAbm4u1dXVdd/f1DnjnTuZ8yVDPQoRyWhjB+fz+HUT+d7UYTx+3UTGDs5v1fG2bt1Kt27duOKKK7j55ptZtmxZ3X0Fffv2Zd++fTz99NMA9O7dm169evHmm28C1BvGOeuss+per1y5sm7+INY555zD008/zY4dO4DInMOmTU1u0tpI7Dlee+01+vbty9FHH13v/RdeeIHKysqUnK8p6lGISMYbOzi/1QFR67333uP73/8+OTk55OXl8cADD9C7d2++/vWvM3LkSAoLCxk3blxd+0ceeYRrr72Wbt268cUvfrHu/RtvvJGZM2cyatQoioqKGD9+fKNzDR8+nHnz5jF16lRqamrIy8tj/vz5DB48OKFa586dW3eObt26sXDhQiAyd3H55ZczZswYzj777Lpti1p7vqZYvK5Ne1dcXOx6HoVIZlqzZg0nn3xy2GVktXh/BmZW6u7F8dpr6ElERAIpKEREJJCCQkREAikoREQkkIJCREQCKShERCSQgkJEBLj33nv59NNPm23X1Jbec+fOrdujKR3SeT4FhYgIiQdFNlJQiEjGK9tRxkPvPUTZjrJWHyveNuP3338/W7duZfLkyUyePBmI3HldXFzMKaecwpw5c+od46677mL8+PGMHz+edevWNTrH+vXrmTZtGmPHjuXMM8+s2zY81ty5c7n22muZNGkSQ4cO5f7776/77J577mHEiBGMGDGCe++9t+7922+/nWHDhvGFL3yB8vLypM7XKu7e4X6NHTvWRSQzrV69Oqn2725/14t/W+yjHh3lxb8t9ne3v9uq8z/99NN+3XXX1b3++OOP3d198ODBvnPnzrr3d+/e7e7u1dXVfvbZZ/vy5cvr2s2bN8/d3RcuXOjTp093d/c5c+b4XXfd5e7uU6ZM8bVr17q7+5IlS3zy5MmN6pgzZ46fdtppfvDgQd+5c6cfc8wxfvjwYS8pKfERI0b4vn37fO/evT58+HBftmxZ3fv79+/3PXv2+AknnJDU+WLF+zMASryJn6na60lEMlrJ9hIOHzlMDTVU1VRRsr2EooKiFh9v5MiR3HzzzcyePZsvfelLnHnmmXHb/f73v2fBggVUV1ezbds2Vq9eXbeV+OWXX1733+9+97v1vm/fvn289dZbzJgxo+69Q4cOxT3H9OnT6dKlC126dKGgoIDt27fz5ptvcvHFF9O9e3cgsv34G2+8QU1NDRdffDHdunUD4IILLkj6fC2loBCRjFZ8XDGdcztTVVNFXk4excfF3Y4oYfG2Gf/xj39cr80HH3zA3XffzdKlS8nPz+eaa66p22EW6m/x3XC775qaGnr37k1ZWVmztdRuLQ6fbS/uAfvvxdtaPJnztZTmKEQkoxUVFPGrqb/iptE38aupv2pVbwLibzMO0LNnT/bu3QvAJ598Qvfu3enVqxfbt2/nhRdeqHeM2senPvXUU5x22mn1Pjv66KMZMmQIixYtAiLD+8uXL0+4vrPOOotnn32WTz/9lP379/PMM89w5plnctZZZ/HMM89w4MAB9u7dy/PPP5+S8yVCPQoRyXhFBUWtDoha8bYZB5g1axbnnXce/fr149VXX2X06NGccsopDB06lNNPP73eMQ4dOsSECROoqanhiSeeaHSOxx9/nBtvvJF58+ZRVVXFZZddxqmnnppQfWPGjOGaa66p27b8uuuuY/To0QBceumlFBUVMXjw4HpDZq05XyK0zbiIpJW2GQ+fthkXEZGUUlCIiEggBYWIiAQKNSjMbJqZlZvZOjO7Jc7nvczseTNbbmarzGxmGHWKSGp1xLnR9qIl1z60oDCzXGA+cB4wHLjczIY3aPZNYLW7nwpMAv7bzDqntVARSamuXbuye/duhUUI3J3du3fTtWvXpL4vzOWx44F17r4BwMyeBC4EVse0caCnRe4y6QF8BFSnu1ARSZ0BAwZQUVHBzp07wy4lK3Xt2pUBAwYk9T1hBkV/YEvM6wpgQoM2PweeA7YCPYFL3b0mPeWJSFvIy8tjyJAhYZchSQhzjqLxveiRHkSsLwJlwPFAEfBzMzs67sHMZplZiZmV6F8qIiKpE2ZQVAADY14PINJziDUT+GN0c8N1wAfA/4p3MHdf4O7F7l587LHHtknBIiLZKMygWAqcaGZDohPUlxEZZoq1GTgHwMyOA4YBG9JapYhIlgttjsLdq83sJuBFIBd42N1XmdkN0c8fBH4CPGpm7xEZqprt7o2fQSgiIm0m1E0B3X0xsLjBew/GfL0VmJruukRE5DO6M1tERAIpKEREJJCCQkREAikoREQkkIJCREQCKShERCSQgkJERAIpKEREJJCCQkREAikoREQkkIJCREQCKShERCSQgkJERAIpKEREJJCCQkREAikoREQkkIJCREQCKShERCSQgkJERAIpKEREJJCCQkREAikoREQkkIJCREQCKShERCSQgkJERAKFGhRmNs3Mys1snZnd0kSbSWZWZmarzOzv6a5RRCTbdQrrxGaWC8wHzgUqgKVm9py7r45p0xv4BTDN3TebWUEoxYqIZLEwexTjgXXuvsHdDwNPAhc2aPMV4I/uvhnA3XekuUYRkawXZlD0B7bEvK6IvhfrJCDfzF4zs1Izuypt1YmICBDi0BNgcd7zBq87AWOBc4CjgLfNbIm7r210MLNZwCyAQYMGpbhUEZHsFWZQVAADY14PALbGabPL3fcD+83sdeBUoFFQuPsCYAFAcXFxw8Cps6h8Ec+se4bOOZ3p1aUXew7tofJQJYVHFzJzxEyKCopa97sSEelgwgyKpcCJZjYE+BC4jMicRKw/AT83s05AZ2AC8H9besJF5Yu4bcltcT/bsGcDr255lZPyT6Kqpor8Lvl1QXKo5hCXfP4SZgyb0dJTi4i0W6EFhbtXm9lNwItALvCwu68ysxuinz/o7mvM7C/ACqAGeMjdV7b0nC9tfim4JpzyyvK4n63ctZJHVz1Kp5xOdSEC0OeoPlxwwgXqiYhIh2XuTY7StFvFxcVeUlLS6P2gHkVrGMaYgjEAVB6qJL9LPkN7D1WAiEi7YWal7l4c97NsCgqIP0exbf82tu3fhjeaS28dw+jXvR/9uvfTMJaIZDQFRQLKdpTx/PrnWf/x+rpeQa8uvfhw34dNDke1xrD8YfTI61HvXBrGEpGwKChaKV6IACzbsSzlvRCIhEj/Hv21IktE0kZB0UZqA2TXgV0AdT/Y83LyWFu5NqUhYlijFVnqgYhIqigoQlC2o4xHVj7Cxk82pmUYSz0QEWkNBUUGie2F1P5gz++Sz76qfSkNEfVARCQZCop2Il0rsmJ7IFqFJSKgoGj34k2mp7oHMqjnoHo3E6r3IZJdFBQdVDp6IOp9iGQHBUWWaeseSMN7QHQXukj7p6AQoHEPJJWrsBreha6hK5H2RUEhTUpH76N/j8jzqBQeIplLQSFJa6veR+wGiprzEMkcCgpJiXj3gKTiLvTaOQ8Fh0h4FBTSphrehd7aoSsFh0j6KSgk7WKHrqB1GygqOETanoJCQtdwA8XWzHkoOERST0EhGSk2PFobHP179NeqKpFWUFBIu5CK4KhdVaWbAEWSo6CQdikVwTEsfxijjh2l0BBphoJCOoTWBsfYgrF8Z+x3FBgicSgopEOKvas80VVVGpoSiU9BIR1eS3obhjF54GQ9DVAEBYVkodr7OPYc2sPmvZsD2+aQw6SBkxQYktUUFJLVFpUv4rE1j/HBng8Ch6dyyOE/Jv6H7suQrKSgEOGzrUZe3fJqYGBMGThFvQvJOkFBkZPuYmKZ2TQzKzezdWZ2S0C7cWZ2xMy+nM76pGMpKijivin38ZvzfsO/nvSvjC0Yi2GN2r2y5RWu+cs1LCpfFEKVIpmnU1gnNrNcYD5wLlABLDWz59x9dZx2PwNeTH+V0hEVFRTV9RYWlS9i3pJ51FBTr80RP8LtS27nxPwT1bOQrNdsj8LMhsd5b1IKzj0eWOfuG9z9MPAkcGGcdt8C/gDsSME5ReqZMWwGC89byJSBU8hp8L/DEY7w/PrnQ6pMJHMkMvT0ezObbRFHmdn/A+5Iwbn7A1tiXldE36tjZv2Bi4EHU3A+kbhqh6QWnreQob2G1vusdhNDkWyWSFBMAAYCbwFLga3A6Sk4d+PBYRrNMN4LzHb3I80ezGyWmZWYWcnOnTtTUJ5km6KCIm79l1vpZJ+NyL5e8QZlO8rCK0okAyQSFFXAAeAooCvwgbvXBH9LQiqIBFCtAURCKFYx8KSZbQS+DPzCzC6KdzB3X+Duxe5efOyxx6agPMlGRQVFnPm586ldDFhVU82f3n8j3KJEQpZIUCwlEhTjgDOAy83s6RSceylwopkNMbPOwGXAc7EN3H2Iuxe6eyHwNPANd382BecWaVLVnjHgebgbeCeqPx0SdkkioUpk1dPX3L32poT/AS40sytbe2J3rzazm4isZsoFHnb3VWZ2Q/RzzUtI2pVuquRvZUdR0/k6OnXbgB36PBdNScVIq0j71WxQxIRE7Hu/TcXJ3X0xsLjBe3EDwt2vScU5RYL88u/rqT7icGAwhw8MZurw4xg7OD/sskRCFeoNdyKZ5HfvbOZvq7fXe69vzy4hVSOSOUK74U4kU5RuquTBv6/npTXb6y27yzX432MGhFaXSKZQUEhW+907m/mPZ9+jpsHC7ByDn1w0UsNOIigoJEvV9SJWb290806OwbyLRvKVCYNCqU0k0ygoJKuUbqrkzhfWsHRjZdzPTSEh0oiCQrJCUA+ilnoSIvEpKKRDa64HAZGA+MLJx3H92SdoTkIkDgWFdEi/e2czD7+5gXU79we2G1+Yz+zzTlZAiARQUEiHUbqpkj8sq+DdTZWs+Z+9TbYz4ISCHlx7+hANM4kkQEEh7V4iw0u11IMQSZ6CQtql2t7Duu17WbqxMuAJ2BGfVw9CpMUUFNKuJLJ6KZZ6ECKtp6CQdqF2cnr9zv3NBsTJn+vJmMH5XDJmgAJCJAUUFJKRaoeWdu09xJaPPg2cnAZNUIu0JQWFZJRkh5YMOHe47oEQaUsKCskIyQwtGTCuMJ8Tj+up4SWRNFBQSCiSHVqqpclpkfRTUEhatWRoSb0HkXApKCQtNLQk0n4pKKRNaGhJpONQUEhKaWhJpONRUEhKaGhJpONSUEiLJbpbaywNLYm0PwoKSVoyu7Wq9yDS/ikoJGGJzj8oHEQ6llCDwsymAfcBucBD7n5ng8+/CsyOvtwH3Ojuy9Nbpeh5DyLZLbSgMLNcYD5wLlABLDWz59x9dUyzD4Cz3b3SzM4DFgAT0l9tdkq0B6HdWkU6tjB7FOOBde6+AcDMngQuBOqCwt3fimm/BBiQ1gqz2J2L1/DL1zc0GRDarVUke4QZFP2BLTGvKwjuLXwNeKFNK5KEhpk0vCSSXcIMCovzXtx/wJrZZCJBcUaTBzObBcwCGDRI/8Jtid+9s5n/fPY9jsT5U1APQiR7hRkUFcDAmNcDgK0NG5nZKOAh4Dx3393Uwdx9AZE5DIqLixO5KVhiBA01qQchkt3CDIqlwIlmNgT4ELgM+EpsAzMbBPwRuNLd16a/xOxw5+I1PPj6hkbvm8H1Zw7llvNPDqEqEckUoQWFu1eb2U3Ai0SWxz7s7qvM7Ibo5w8CPwb6AL8wM4Bqdy8Oq+aO6HfvbOaXcUJiqp4aJyJR5t7xRmmKi4u9pKQk7DIyXummSi795dtU19T/O3DDWepFiGQbMytt6h/iujM7i/1xWUW9kDDgeoWEiDSgoMhSpZsqWVTy2erk3BzjJxeO0IomEWkkJ+wCJBxLNuyu600YcOm4gQoJEYlLQZGlJg7tQ+dOOeQdtYmjCl7j1BM+DrskEclQCoosNXZwPrfO6EH3Ib8mt8+L3Fn2bywqXxR2WSKSgRQUWWyvlVPjVYBT7dXMWzJPYSEijSgosljxccXkWm7d6xpq+MmSnygsRKQeBUUWKyoo4t8n/DsWs+2W49y25Da+/cq3KdtRFl5xIpIxFBRZbsawGUweOLnR+69seYWrXriKe0ruCaEqEckkCgph5oiZdLLGt9Q4ziOrHuHLz32Z296+TT0MkSylLTwEgLIdZTyy8hFe2/IaNdQ02W5swVi+M/Y7FBUUpa02EWl7QVt4KCiknrIdZdxbei+lO0qbbGMYJ+WfRF5uHpd8/hJmDJuRxgpFpC0oKCRp95Tcw6OrHsUDn5YdMSx/GP179KfPUX244IQL1NsQaYcUFNIiZTvKeH798yzfuZzyyvKEvscwxhSMYWjvoQoNkXZEQSGttqh8EY+teYwP9nyQUC+j1rD8YYw6dpRCQyTDKSgkZVrSy4BIT6Nf9370695PvQ2RDKSgkDZRGxrrP17Psh3LkuppKDhEMouCQtpcbWjsOrCLD/d9mFRvAxQcImFTUEjaLSpfxDPrnuHwkcOsrVybVG8D6gdHry69tKJKpI0pKCRUtTfzbfxkI3k5eS0Kjlq1S3EBhYdICikoJKOkMjhql+MCHKo5pBsARVpIQSEZLZXBAZFeR4+8HlQeqqTw6EJmjpipXodIMxQU0q7EBkd+l3z2Ve1LenK8oeO7H1833wEathJpSEEh7V7t5HjnnM4ASS/HjSd22Eq9D8l2CgrpcGKX4wItWpIbT+2Gh1U1VeR3ydeKK8kaCgrJCrHhsefQHrbt38bW/VtTdvzaFVd7Du3RxLl0OBkbFGY2DbgPyAUecvc7G3xu0c/PBz4FrnH3Zc0dV0EhtRrOd0Bqhq1qxU6c53fJ182C0m5lZFCYWS6wFjgXqACWApe7++qYNucD3yISFBOA+9x9QnPHVlBIkIbDVrW9j237t6UkQBreLKgeiLQHQUHR+PmX6TMeWOfuGwDM7EngQmB1TJsLgd94JM2WmFlvM+vn7tvSX650FEUFRXH/xR+7d1VtD6ElK64cZ+v+rY2GvVbuWslT5U/V64FoDkTagzCDoj+wJeZ1BZFeQ3Nt+gMKCkm5pgIkdsVVry69WjVx3tT3LVq7SHMgkrHCDAqL817Dfn8ibSINzWYBswAGDRrUuspEYswYNqPRD+yGE+eVhypbfbNgeWV5vSBRD0QyRZhBUQEMjHk9AGi4RCWRNgC4+wJgAUTmKFJXpkhjQcNXsZPnbd0DUYhIOoQ5md2JyGT2OcCHRCazv+Luq2LaTAdu4rPJ7PvdfXxzx9ZktmSaeD2QVN11Hk/sMJZuJpREZOSqJ6hb1XQvkeWxD7v77WZ2A4C7PxhdHvtzYBqR5bEz3b3ZBFBQSHuSyjmQIPFuJgRtZyIRGRsUbUVBIe1dunsgDbcz0T0h2UdBIdKBNNz3qi1DJN49IRrK6pgUFCJZouEwVqpvJoyloayORUEhkuXi3UwIqd3OJFa8oSytyspsCgoRiSvediapuCekOQ1XZWlOJHwKChFJWrx7QtpyKAu0T1aYFBQiklLpHsoCGNRzEJ1yOtULLYVI6igoRCQtmhrKasulvdB4u3dNrCdPQSEiGSHeqqy2nhPRxHpiFBQikvFSvU9WojSxHqGgEJF2K958SDpCJNtuNlRQiEiH1NRWJ9C2E+vxbjZs75PrCgoRyTphTaxD+5xcV1CIiDQQxsQ6ZO7kuoJCRCQJYdxsCOGGiIJCRCRFwppch7ZdoaWgEBFJgzAn11u7QktBISISsrA2YKwdzmqu56GgEBHJYOlaodU5pzO//uKv44ZFUFB0SsnZRUSkxYoKigKHh1K1QquqpoqS7SVJz2coKEREMtyMYTOavIkvmRVaeTl5FB8Xt9MQSEEhItKOFRUUcd+U++J+Fjuk1ZoltgoKEZEOqrkhrUTltL4UERHpyBQUIiISSEEhIiKBQgkKMzvGzP5mZv+M/jc/TpuBZvaqma0xs1Vm9u0wahURyXZh9ShuAV529xOBl6OvG6oG/o+7nwxMBL5pZsPTWKOIiBBeUFwILIx+vRC4qGEDd9/m7suiX+8F1gD901WgiIhEhBUUx7n7NogEAlAQ1NjMCoHRwDttX5qIiMRqs/sozOwl4HNxPvpRksfpAfwB+I67fxLQbhYwC2DQoEHJnEJERAK0WVC4+xea+szMtptZP3ffZmb9gB1NtMsjEhKPu/sfmznfAmABRDYFbHnlIiISK6yhp+eAq6NfXw38qWEDMzPg18Aad78njbWJiEiMsILiTuBcM/sncG70NWZ2vJktjrY5HbgSmGJmZdFf54dTrohI9gplryd33w2cE+f9rcD50a/fBCzNpYmISAMd8sFFZrYT2BTQpC+wK03lJCuTawPV11qqr3VUX8s1V9tgdz823gcdMiiaY2YlTT3JKWyZXBuovtZSfa2j+lquNbVprycREQmkoBARkUDZGhQLwi4gQCbXBqqvtVRf66i+lmtxbVk5RyEiIonL1h6FiIgkSEEhIiKBOnxQmNldZva+ma0ws2fMrHcT7aaZWbmZrTOzeM/HaKv6ZkQfzFRjZk0uXTOzjWb2XvQO9ZIMrC+s69fsQ7Ci7dJ6/Zq7HhZxf/TzFWY2pq1rSqK2SWa2J2ZHhB+nq7bo+R82sx1mtrKJz0O7dgnWF9r1S+SBby26fu7eoX8BU4FO0a9/BvwsTptcYD0wFOgMLAeGp6m+k4FhwGtAcUC7jUDfEK5fs/WFfP3+C7gl+vUt8f580339ErkeRHYgeIHI7gMTgXcyqLZJwJ/T/Xct5vxnAWOAlU18Hsq1S6K+0K4f0A8YE/26J7A2FX/3OnyPwt3/6u7V0ZdLgAFxmo0H1rn7Bnc/DDxJ5OFK6ahvjbuXp+NcLZFgfaFdPxJ4CFYIErkeFwK/8YglQO/oTsqZUFuo3P114KOAJmFdOyCh+kLjiT3wLenr1+GDooFriSRpQ/2BLTGvK8i8p+k58FczK40+eyOThHn9En0IVjqvXyLXI6xrluh5TzOz5Wb2gpmdkoa6ktEe/n8N/fpZ0w98S/r6hbIpYKpZwEOS3P1P0TY/IvIc7sfjHSLOeylbN5xIfQk43d23mlkB8Dczez/6L5tMqC+065fEYdrs+sWRyPVo02sWIJHzLiOy78++6I7NzwIntnVhSQjr2iUq9OtnwQ98S/r6dYig8ICHJAGY2dXAl4BzPDpI10AFMDDm9QBga7rqS/AYW6P/3WFmzxAZQkjJD7oU1Bfa9bMEH4LVltcvjkSuR5teswDNnjf2B4u7LzazX5hZX3fPlM3uwrp2CQn7+lnzD3xL+vp1+KEnM5sGzAYucPdPm2i2FDjRzIaYWWfgMiIPV8oIZtbdzHrWfk1kgj7uiouQhHn9EnkIVrqvXyLX4zngqugKlInAntohtDbWbG1m9jkzs+jX44n8nNidhtoSFda1S0iY1y963uYe+Jb89QtjZj6dv4B1RMbjyqK/Hoy+fzywOKbd+URWCKwnMuSSrvouJpLwh4DtwIsN6yOyQmV59NeqTKsv5OvXB3gZ+Gf0v8dkwvWLdz2AG4Abol8bMD/6+XsErHgLobabotdpOZEFIP+Srtqi538C2AZURf/ufS1Trl2C9YV2/YAziAwjrYj5mXd+a6+ftvAQEZFAHX7oSUREWkdBISIigRQUIiISSEEhIiKBFBQiGcbMiqI3aolkBAWFSOYpIrKkUSQjKChEWsjMxkW3ae4avalvlZmNaKLt981sabT9rdH3Ljazl6I3PvUzs7VmNgi4Dbg0ukX1pen8PYnEo/soRFrBzOYBXYGjgAp3vyNOm6nAl4Hridzs9BzwX+7+upk9RuSmrGlEtlx4wsyuIXIT1E1p+m2IBOoQez2JhOg2IttiHAT+rYk2U6O/3o2+7kFkk7jXgW8R2U5kibs/0balirSMgkKkdY4h8oM/j0jPYn+cNgbc4e6/jPNZf6AGOM7Mcty9ps0qFWkhzVGItM4C4D+JbF//sybavAhcG936GTPrb2YFZtYJeAT4CpEHzHwv2n4vkaeTiWQEzVGItJCZXQVc5O6XmFku8BbwQ3d/JU7bbwPXRV/uA64Avgr0dvfvRXe3XUpkE8btRMIlj0hP5Km2/92INE1BISIigTT0JCIigTSZLZIiZjYS+G2Dtw+5+4Qw6hFJFQ09iYhIIA09iYhIIAWFiIgEUlCIiEggBYWIiARSUIiISCAFhYiIBPr/r/1kRpi/uP4AAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bf = bp.analysis.Bifurcation2D(\n", + " wc,\n", + " target_vars={'x': [-0.2, 1.], 'y': [-0.2, 1.]},\n", + " target_pars={'x_ext': [-2, 2]},\n", + " pars_update={'y_ext': 0.},\n", + " resolutions={'x_ext': 0.01}\n", + ")\n", + "bf.plot_bifurcation()\n", + "bf.plot_limit_cycle_by_sim(duration=500)\n", + "bf.show_figure()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Similarly, simulating and analyzing a rate-based FitzHugh-Nagumo model is also a piece of cake by using BrainPy." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I am making bifurcation analysis ...\n", + "I am filtering out fixed point candidates with auxiliary function ...\n", + "I am trying to find fixed points by optimization ...\n", + "\tThere are 20000 candidates\n", + "I am trying to filter out duplicate fixed points ...\n", + "\tFound 200 fixed points.\n", + "I am plotting the limit cycle ...\n", + "C:\\Users\\adadu\\miniconda3\\lib\\site-packages\\jax\\_src\\numpy\\lax_numpy.py:3610: UserWarning: Explicitly requested dtype requested in asarray is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax._check_user_dtype_supported(dtype, \"asarray\")\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEHCAYAAABSjBpvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAzkUlEQVR4nO3deXxU5d3//9cnK0sCsoVNIWBB0AQChCClIBS0CgKieKtVK1iKSxX1rq21+EWtWGv1Ryl1K3WhICrWiituULxRrEKQgOwqRQxhCyokQBKSXL8/JhmzTJKTbSYk7+fjkQeZOdc558rkMO9c5zrzOeacQ0RExIuwUHdAREROHgoNERHxTKEhIiKeKTRERMQzhYaIiHim0BAREc8iQt2B+tC+fXsXHx8f6m6IiJw01q1bl+mc61BVu5CFhpmdBiwEOgGFwHzn3F/KtDHgL8BY4BgwxTn3aVXbjo+PJzU1te47LSLSSJnZV17ahXKkkQ/8yjn3qZnFAuvM7D3n3JYSbS4AehV9DQEeL/pXRERCIGRzGs65vcWjBudcFrAV6Fqm2URgofP5GDjFzDoHuasiIlKkQUyEm1k8MAD4pMyirsDXJR6nUz5YREQkSEI+EW5mMcC/gFudc0fKLg6wSsBiWWY2HZgO0K1bt3LLT5w4QXp6Ojk5ObXrsDQozZo149RTTyUyMjLUXRFpEkIaGmYWiS8wFjvnXg7QJB04rcTjU4GMQNtyzs0H5gMkJyeXC5b09HRiY2OJj4/HN78uJzvnHIcOHSI9PZ0ePXqEujsiTULITk8VXRn1FLDVOTengmavAT8zn7OBw865vTXZX05ODu3atVNgNCJmRrt27TR6FAmiUI40hgFXA5+ZWVrRc78DugE4554AluG73PYLfJfcTq3NDhUYjY9+pyLBFbLQcM59SOA5i5JtHPDL4PQoNObOncv06dNp0aJFpe2KP3vSvn37Us/fc889xMTEcPvtt9dnN0O2PxFpWBrE1VNN2dy5czl27FiouyEi4olCoxJpB9J48rMnSTuQVuttHT16lHHjxtG/f38SEhJYsmQJ8+bNIyMjg1GjRjFq1CgAbrjhBpKTkznrrLO4++67S23joYceIiUlhZSUFL744oty+/jyyy85//zzGTRoEMOHD2fbtm3l2txzzz1ce+21jBw5kp49ezJv3jz/sjlz5pCQkEBCQgJz5871P3///fdzxhlnMGbMGLZv316t/YlII+Oca3RfgwYNcmVt2bKl3HOVWb9/vUtelOz6Lejnkhclu/X711dr/bJeeuklN23aNP/j7777zjnnXPfu3d3Bgwf9zx86dMg551x+fr4755xz3IYNG/ztZs+e7Zxz7h//+IcbN26cc865u+++2z300EPOOed+/OMfux07djjnnPv444/dqFGjyvXj7rvvdkOHDnU5OTnu4MGDrm3bti4vL8+lpqa6hIQEl52d7bKystyZZ57pPv30U//zR48edYcPH3ann356tfYXDNX93YpIeUCq8/D+GvLPaTRUqftTySvIo5BCThSeIHV/KklxSTXeXmJiIrfffjt33HEHF154IcOHDw/Y7sUXX2T+/Pnk5+ezd+9etmzZQr9+/QC44oor/P/edtttpdbLzs7mo48+4tJLL/U/l5ubG3Af48aNIzo6mujoaOLi4ti/fz8ffvghkyZNomXLlgBcfPHFfPDBBxQWFjJp0iT/nMuECROqvT8RaTwUGhVI7phMVHgUJwpPEBkWSXLH5Fptr3fv3qxbt45ly5Zx5513ct555zFr1qxSbf773//y8MMPs3btWtq0acOUKVNKXU5a8kqhslcNFRYWcsopp5CWllZlX6Kjo/3fh4eHk5+fj+8PjcACXaFUnf2JSOOhOY0KJMUl8ffz/s5NA27i7+f9vVajDICMjAxatGjBVVddxe23386nn/qK9cbGxpKVlQXAkSNHaNmyJa1bt2b//v289dZbpbaxZMkS/79Dhw4ttaxVq1b06NGDf/7zn4DvtOOGDRs892/EiBG88sorHDt2jKNHj7J06VKGDx/OiBEjWLp0KcePHycrK4vXX3+9TvYnIicnjTQqkRSXVOuwKPbZZ5/x61//mrCwMCIjI3n88ccBmD59OhdccAGdO3dm5cqVDBgwgLPOOouePXsybNiwUtvIzc1lyJAhFBYW8vzzz5fbx+LFi7nhhhuYPXs2J06c4PLLL6d///6e+jdw4ECmTJlCSkoKANOmTWPAgAEAXHbZZSQlJdG9e/dSp9Vqsz8ROTlZZaclTlbJycmu7P00tm7dSt++fUPUI6lP+t2K1J6ZrXPOVXkeXqenRETEM4WGiIh4ptAQERHPFBoiIuKZQkNERDxTaIiIiGcKjRDzWuU2Pj6ezMzMcs/fc889PPzww573l5uby5gxY0hKSvJ/WFBExCuFRogFuzT6+vXrOXHiBGlpaVx22WVB26+INA4KjUrs23mYdW/vYt/Ow7XeVkMojX7gwAGuuuoq0tLSSEpK4ssvv2TFihUMGDCAxMRErr32Wn/RwbVr1/LDH/6Q/v37k5KSQlZWFgsWLOCmm27yb+/CCy/k/fffp6CggClTppCQkEBiYiJ//vOfa/16iUjDFNIyImb2NHAhcMA5lxBg+UjgVeC/RU+97Jz7fTD6tm/nYV7983oK8gsJjwhj4m0D6NSzdY239/bbb9OlSxfefPNNAA4fPkzr1q2ZM2cOK1eu9N+R7/7776dt27YUFBQwevRoNm7c6K9y26pVK9asWcPChQu59dZbeeONN0rtY/r06TzxxBP06tWLTz75hBtvvJF///vf/uVxcXE8+eSTPPzww7zxxhvk5OQwcuRIVqxYQe/evfnZz37G448/zo033shll13GkiVLGDx4MEeOHKF58+YV/mxpaWns2bOHTZs2AfDdd9/V+HUSkYYt1CONBcD5VbT5wDmXVPQVlMAA2LPjWwryC3EOCgoK2bPj21ptLzExkeXLl3PHHXfwwQcf0Lp14AB68cUXGThwIAMGDGDz5s1s2bLFv6xkafT//Oc/pdYrWao8KSmJ6667jr1791bap+3bt9OjRw969+4NwDXXXMOqVavYvn07nTt3ZvDgwYAvrCIiKv77omfPnuzcuZObb76Zt99+m1atWlX9gojISSmkoeGcWwV8E8o+VKRr7zaER4RhYRAeHkbX3m1qtb3i0uiJiYnceeed/P735fOvuDT6ihUr2LhxI+PGjatRafTir61bt1bap4rqjjnnApZDj4iIoLCw0P+4uG9t2rRhw4YNjBw5kkcffZRp06ZVul8ROXmFeqThxVAz22Bmb5nZWcHaaaeerZl42wCGTOhZ61NT0DBLo/fp04ddu3b550cWLVrEOeecQ58+fcjIyGDt2rUAZGVlkZ+fT3x8PGlpaRQWFvL111+zZs0aADIzMyksLOSSSy7hvvvu8/9sItL4NPTS6J8C3Z1z2WY2FngF6BWooZlNB6YDdOvWrU523qln61qHRbGGWBq9WbNmPPPMM1x66aXk5+czePBgrr/+eqKioliyZAk333wzx48fp3nz5ixfvpxhw4bRo0cPEhMTSUhIYODAgQDs2bOHqVOn+kchDzzwQJ28ZiLS8IS8NLqZxQNvBJoID9B2F5DsnCv/gYUSVBq9adHvVqT2GkVpdDPrZEUn180sBV9/D4W2VyIiTVeoL7l9HhgJtDezdOBuIBLAOfcEMBm4wczygePA5S7UQyMRkSYspKHhnLuiiuWPAI8EqTsiIlKFBn16SkREGhaFhoiIeKbQEBERzxQaJ5nvvvuOxx57rMp2u3btIiEh8FXMI0eOpOwlyZXZtm0bSUlJDBgwgC+//NLzeiLS+Cg0TjJeQ6MuvfLKK0ycOJH169dz+umnB3XfItKwKDQqkfvVEY6s/Jrcr47Ueltl//J/+OGHueeeewDfX/533HEHKSkp9O7dmw8++ACAzZs3k5KSQlJSEv369ePzzz/nt7/9LV9++SVJSUn8+te/Jjs7m9GjRzNw4EASExN59dVX/fvIz8/nmmuuoV+/fkyePDngfTveffddhg4dysCBA7n00kvJzs4utXzZsmXMnTuXJ5980l++fc6cOSQkJJCQkMDcuXP9bRcuXEi/fv3o378/V199NQBTpkzhpZde8reJiYkBYO/evYwYMYKkpCQSEhL8P7OINGwNvYxIyOR+dYTMJz/D5RdiEWG0n5ZIdPf6q96an5/PmjVrWLZsGffeey/Lly/niSee4JZbbuHKK68kLy+PgoIC/vjHP7Jp0ybS0tL86y1dupRWrVqRmZnJ2WefzYQJEwBfFdunnnqKYcOGce211/LYY49x++23+/eZmZnJ7NmzWb58OS1btuTBBx9kzpw5zJo1y99m7NixXH/99cTExHD77bezbt06nnnmGT755BOccwwZMoRzzjmHqKgo7r//flavXk379u355pvK61A+99xz/OQnP2HmzJkUFBQE9UZUIlJzCo0K5O48jMsvBAcuv5DcnYfrNTQuvvhiAAYNGsSuXbsAGDp0KPfffz/p6elcfPHF9OpVvuyWc47f/e53rFq1irCwMPbs2cP+/fsBOO200/z1q6666irmzZtXKjQ+/vhjtmzZ4m+Tl5dXrhBiWR9++CGTJk2iZcuW/n5/8MEHmBmTJ0/23xekbdu2lW5n8ODBXHvttZw4cYKLLrqIpKSkKl4hEWkIdHqqAtE9W2MRYWBgEWFE17JwYUVlxf37i44GIDw8nPz8fAB++tOf8tprr9G8eXN+8pOflLqhUrHFixdz8OBB1q1bR1paGh07dvRvu2x587KPnXOce+65/lLqW7Zs4amnnqr056hNOXXnHHl5eQCMGDGCVatW0bVrV66++moWLlxY6X5FpGFQaFQgunsr2k9LpNV58XVyaqpjx44cOHCAQ4cOkZubW+6ue4Hs3LmTnj17MmPGDCZMmMDGjRtLlVIH3x0A4+LiiIyMZOXKlXz11Vf+Zbt37/bfrOn555/nRz/6Uantn3322axevdpfGv3YsWPs2LGj0j6NGDGCV155hWPHjnH06FGWLl3K8OHDGT16NC+++CKHDvlKgxWfnoqPj2fdunUAvPrqq5w4cQKAr776iri4OH7xi1/w85//XOXURU4SOj1ViejurerslFRkZCSzZs1iyJAh9OjRgz59+lS5zpIlS3j22WeJjIykU6dOzJo1i7Zt2zJs2DASEhK44IILuOOOOxg/fjzJyckkJSWV2m7fvn35xz/+wXXXXUevXr244YYbSm2/Q4cOLFiwgCuuuMJ/b/DZs2f77+QXyMCBA5kyZQopKSkATJs2jQEDBgAwc+ZMzjnnHMLDwxkwYAALFizgF7/4BRMnTiQlJYXRo0f7T2u9//77PPTQQ0RGRhITE6ORhshJIuSl0euDSqM3LfrditReoyiNLiIiDYtCQ0REPFNoiIiIZwoNERHxTKEhIiKehTQ0zOxpMztgZpsqWG5mNs/MvjCzjWY2MNh9FBGR74V6pLEAOL+S5RcAvYq+pgOPB6FP9aa4WF9GRgaTJ0+u1rqzZs1i+fLlAMydO7deazXFx8eTmZlZrXUmT57Mzp0766lH8NlnnzFlypR6276IeBPS0HDOrQIqq2w3EVjofD4GTjGzzsHpHRw4ksP//O0/HMjKqbpxNXTp0qVU5Vcvfv/73zNmzBig/kOjujZv3kxBQQE9e/ast30kJiaSnp7O7t27620fIlK1UI80qtIV+LrE4/Si54Ji3orPWbvrG+Yt/7xOt1uyTPqCBQu46KKLGD9+PD169OCRRx5hzpw5DBgwgLPPPttfjqO4xPi8efPIyMhg1KhR/lLlJa1du5Yf/vCH9O/fn5SUFLKyshg+fLi/Ki7AsGHD2LhxI9nZ2UydOpXExET69evHv/71r3Lbe/bZZ/3l2a+77joKCgrKtVm8eDETJ070P46JieGOO+5g0KBBjBkzhjVr1jBy5Eh69uzJa6+95n8Nhg8fzsCBAxk4cCAfffQRAEuXLmXMmDE459i7dy+9e/dm3759AIwfP54XXnihhq+6iNSFhh4a5SvgQcCPsJvZdDNLNbPUgwcP1mqnZ9z1FvG/fZNnP9mNc/DsJ7uJ/+2bnHHXW7XabkU2bdrEc889x5o1a5g5cyYtWrRg/fr1DB06tFx5jRkzZtClSxdWrlzJypUrSy3Ly8vjsssu4y9/+QsbNmxg+fLlNG/enGnTprFgwQIAduzYQW5uLv369eO+++6jdevWfPbZZ2zcuJEf//jHpba3detWlixZwurVq0lLSyM8PJzFixeX6//q1asZNGiQ//HRo0cZOXIk69atIzY2lrvuuov33nuPpUuX+suux8XF8d577/Hpp5+yZMkSZsyYAcCkSZPo1KkTjz76KL/4xS+499576dSpEwDJycm674ZIiDX02lPpwGklHp8KZARq6JybD8wHXxmR2uz0g9+MYvayrby7eR85JwppFhnGT87qxMxx9VOqYtSoUcTGxhIbG0vr1q0ZP3484Dsls3HjRs/b2b59O507d2bw4MEAtGrlq5t16aWXct999/HQQw/x9NNP++cGli9fXuov9zZt2pTa3ooVK1i3bp1/e8ePHycuLq7cfvfu3UuHDh38j6Oiojj//PP9P0N0dDSRkZEkJib6y76fOHGCm266yR9GJQsl/vWvfyUhIYGzzz6bK664wv98XFwcGRkBf/0iEiQNPTReA24ysxeAIcBh59ze+t5pXKtmxEZHkJtfSHREGLn5hcRGRxAX26xe9ldcFh0gLCzM/zgsLMxfJt2LisqTt2jRgnPPPZdXX32VF1980X9/8Iral9zeNddcwwMPPFDpfps3b16q1HtkZKR/uxX9PH/+85/p2LEjGzZsoLCwkGbNvn9t9+zZQ1hYGPv376ewsJCwMN+AOCcnh+bNm3t5KUSknoT6ktvngf8AZ5hZupn93MyuN7Pri5osA3YCXwB/B24MVt8ys3O5ckh3lt44jCuHdOdgdm6wdl2lsuXRi/Xp04eMjAzWrl0LQFZWlv9Netq0acyYMYPBgwf7b5B03nnn8cgjj/jX//bbb0ttb/To0bz00kscOHAA8JU7L1l6vVjfvn395dW9Onz4MJ07dyYsLIxFixb550ry8/OZOnUqzz33HH379mXOnDn+dXbs2FHqlrkiEnwhHWk4566oYrkDfhmk7pTyt6u/L/Y4+6KG9UY1ffp0LrjgAjp37lxqXiMqKoolS5Zw8803c/z4cZo3b87y5cuJiYlh0KBBtGrViqlTp/rb33XXXfzyl78kISGB8PBw7r77bv8dBAHOPPNMZs+ezXnnnUdhYSGRkZE8+uijdO/evVR/xo0bx/vvv++/usuLG2+8kUsuuYR//vOfjBo1yl8y/Q9/+APDhw9n+PDhJCUlMXjwYMaNG0ffvn1ZuXIl48aNq+nLJiJ1QKXRm4iMjAxGjhzJtm3b/Kd76srx48cZNWoUq1evJjw8vE63XSw3N5dzzjmHDz/8kIiI0n/rNPXfrTRtaQfSeP3L13E4+rbty+G8w7SOas22b7aVei65YzJJcUkVbsdrafSGPqchdWDhwoXMnDmTOXPm1HlggG9O495772XPnj1069atzrcPvrsQ/vGPfywXGFIzB47kcNPz67ln/Jn8bukmzOD+ixK45/UtPPLTAfU2fyfepR1II3V/asAAKH4u83gmq9JXke++n/s0DFfmItMwwogKj+Lv5/290uDwQiMNOek1ld9tRW/0FX1/z+tbKmzbs31LXl6/hx90iOHzA9kA9IrzfR8XG82CqYPLrf+3qwcpTOpI2dFB2VA4knuERVsWUeAKygVAoFDwItzCuWnATUxLnBZwudeRhkJDTnon4++2sr/0a/JGH+j7Lw5mV9jWq5LrXDygK+nfHddIxIPKThkFGh2UVNNQqGx9LyMNhYZCo8loaL/bA0dymL5oXaV//U95Zi0Hs3PLvanXxRt9fQsz2PlA07wgoS5PGdVU2W1FWAQjTh1Bu+btgjKnodCQk16wf7dVhcJpbZrzr0/3ABWPBBqD6Igwts++INTdqFOVhUJ9nDIKpHhbhhFu4Vx95tUcPXG0wonuCadPqPU8BWgiXKROlA2I4lBI+/o7AG55Ic0fBOPmfYgD1vz3+/VLhkRDC4yOsdEczcunZbTvbeBQdi75hd7WjW/XghevH1qPvasf9RUKVQVGVaODQKMWL6ODUFBoBFFMTAzZ2dlkZGQwY8aMalW6nTVrFiNGjGDMmDHMnTuX6dOn06JFi3rpZ3x8PKmpqbRv397zOpMnT+ZPf/qT50q3qampLFy4kHnz5lXYJi8vjzFjxvDvf/87KFdNBZpn6Nm+pT8gqgqFYIzZy77RZ2bl0j42utz32Tn5REWEcaKgsFzb5O5t2Zj+HWd2aVXq80jXLUqlQ2wzdh7MJjM7l4NZuf719x8p/eHWXYeOkXL/CqLCjR33jw3CT149+3YeZtvHvuIRHU6LJefoCQ4U7OOfG//F17Hb2Rf731Lt6zsU6mt0EAoKjcpk7YOXpsLkBRDbsc42W9PS6MXmzp3LVVddVW+hUV01KY2enJxMcnLlI+GoqChGjx7NkiVLuPLKK2vbzYBKjiR6tm/J2l3flBo9rN/9nb9tfYRCRJjRLiYKqNkbfV2qbLtTnv6EXYeOsfdwDrklhiPj+3epl75UJVAoNGsZycGvszh2JI+vPsuksFxBZscAfkK/sNG8ceaj7I/dVWKJt1AI9imjhkihUZn/+xPs/hj+70G4cE7V7T3atWsXF154IZs2bWLBggW88sorFBQUsGnTJn71q1+Rl5fHokWLiI6OZtmyZbRt25YpU6Zw4YUXkpGR4S+N3r59+3KVbteuXcstt9zC0aNHiY6OZsWKFYwdO5a//vWvJCUlAb7S6I8//jg9e/bk5ptvJjU1FTPj7rvv5pJLLim1vWeffZZ58+aRl5fHkCFDeOyxx8p9gC9QafRf/vKXLF++nDZt2vCHP/yB3/zmN+zevZu5c+cyYcIE3n//fR5++GHeeOMN7rnnHnbv3s3OnTvZvXs3t956q7/q7UUXXcSdd95Zp6FRNiiKRxLFAVEXp5G6t21OTn5hwL/+O8RG0y4mitM7xHIwK6feQqAuLbh2CDOXfsbiT0rfz+Rfn+7hX5/uqbf5jbLhUHkoVMUIw6AwnC5HflAqNLyGQkM9ZRRMCo1AZsdBfonheOpTvq+IaLjrQJ3vbtOmTaxfv56cnBx+8IMf8OCDD7J+/Xpuu+02Fi5cyK233upvO2PGDObMmcPKlSvLnT4qLo2+ZMkSBg8ezJEjR0qVRp87d26p0uh33HGHvzQ6lK89VbI0emRkJDfeeCOLFy/mZz/7Wal2q1evLlWNtrg0+oMPPsikSZP8pdG3bNnCNddcw4QJE8q9Btu2bWPlypVkZWVxxhlncMMNNxAZGUlCQoK/llZtFZ9+KjknUXIkUR0VhUK/01qfVGFQHZnZuVw8sCvfZOfxwReZFBS6OqkAvW/nYfbs+NY/UoDvA2Lr6owahEMlDMLCjfOHjqBXs7YKhRpQaARyy0Z45y7Y9gbkH4eI5tD3Qjjv/nrZXVMsjV7WuHHjiI6OJjo6mri4OPbv38+pp55KeHg4UVFRZGVlERsb6/m1KKk4LFJ3fUOhKz0n4UVxQDT2UKhK8c87c+lnFDpX7QrQgU4p5R7LZ8PyryksrNuTf2Hh0D2xPS1aRZU6fZVz9ARde7ehU8/WwKQ63WdTodAIJLYTRMdCQS5ENPP9G92qTuc1SmqKpdHLKvkahIeHl2qXm5tbqnR6dRw4kkPKH1Z4bl9yorl4HqFP5/qbRzgZFVeA/mlKN55bs5uDJW6HXHLU4G2eoWYqCoXikUqfszsXBYPUNYVGRY4egEFTIXkqpD4D2ftD3SO/4tLoZU9PlSyNPnjwYLKysmjevDkRERFMmzaN8ePHM3z48HKl0efOnQv4Tk+VHG2MHj2aiRMncttttxEXF8c333xDVlZWuSq3xaXR4+Pj6/xnPXToEB06dCAyMrLa655x11ulJm0r0r1tcxK6nlLvE82Nxd+uTib3qyPkbj/Mbzu340hBNhuXbCc7MrxuRw0G4WFGt8R2/nBQKISeQqMil5e4rWkdToLXhcZQGt2rlStXMnZs9S/p7D3zLfIKKg6MkkHRp3MrHr1yYG262WjlfnWEo5/ux4DILjHkZWRTmJVHzo5vId8XDs45WgGbsgtqHBhhYUb/MaeRl+MbYRaPHr4/lSQNhT4R3kScrKXRL774Yh544AHOOOOMCtsE+t3+75I0Xl6/p1zb0X3i6HxK8yY5J1GR3K+OkLvzMGEtIsjLyC4VEMdS90Elp5QcYEChc2zLKeTz3IqD2ts8g4SKPhEufidrafS8vDwuuuiiSgOjrMpOSfWOiyEi3BrcTbWCqWRAFB7Lp/D4CbI/zIAajhCKA6MQyCwaeRSPGqJbRGieoREK6UjDzM4H/gKEA0865/5YZvlI4FWg+HqXl51zv6cKGmk0LSV/tweO5PA/f/sPuw4dAyDcYHjvDrSLiSI7J7/JjC4CjR4sOrxWAVFKOLRM7kRklxiOpGeTmV9IeJcYjRpOYg1+pGFm4cCjwLlAOrDWzF5zzm0p0/QD59yFQe+gnHQCjTIKHKzacbBRV2UtGxBl5xxqzIAwo9kZbQiPjfKfsjKgRR+I/ngGjFlAzJBehOZz4RIKoTw9lQJ84ZzbCWBmLwATgbKhUWequsRUTj4lR8pLb/whVz21hu+O5VHoICrC6NK6OfHtW4awh3Wv5OR0nY0ewoyYH3WhMLfAP6dReCyf6J6tie7eqnz7N/63XqolSMMXytDoCnxd4nE6MCRAu6FmtgHIAG53zm2uyc6aNWvGoUOHaNeunYKjkXDOcejQIf9nOJ77ZDffHM0DfGW78woK+dEP2jN7UmIou1kjtZmcrlJRQIQ1j/TPbVQYDmUFuVqCNDyhDI1A79xl/1z6FOjunMs2s7HAK0CvgBszmw5MBwJOxp566qmkp6dz8ODB2vRZGphmzZrxP4u2c/BY6QFqbn4hYQYHs3MrWLPhqOvJaaDUnEPJ0KlWQAQS5GoJ0vCEMjTSgdNKPD4V32jCzzl3pMT3y8zsMTNr75zLLLsx59x8YD74JsLLLo+MjKRHjx511XdpQN68tTP/79VNvLdlP4WOUvWQGuJtSYNxeqnFwI41D4aq7FoF+TlBqZYgDU8oQ2Mt0MvMegB7gMuBn5ZsYGadgP3OOWdmKUAYcCjoPZUGLa5VM3YePEqh810tVZ16SPWl3k4vBZicrvXooTr+70++6ggd+sAlTza4aglS/0IWGs65fDO7CXgH3yW3TzvnNpvZ9UXLnwAmAzeYWT5wHLjcNcZPI0qNlb1iqqDo6Hhuze6gzWXUy+klqP7kdH0qO5dxcBs88SPNZTRBTeYT4dI4HTiSw+xlW3l38z5yThQG5dRUfZ5eqtHkdDBk7YM3fwXbl4ErLD2XoVNTjUKD/5yGSF2Ia9WM2OgIcvMLq12quzKN9vRSTcV2gswvfIFh4ZrLaMIUGnLSq6xUtxdN4vRSbdwX5wuJYq4oMdc9o89oNEEKDTnplSwNUlldqXotrdHQTy/VxlkXw8bnfSMMV6DLbJs4hYY0Ol7KedfYyXp6qSbKTn4XjzDyj+vUVBOm0JCTUvEd4rq0jqJlTkHpukvbv6ndJ6aLNZbTSzWRtQ86JsLRg/DdV77nLBxO/zG07KDLbJswhYacFEreXzqqWQQbln9N6zBo3zKcgrooC9OYTy9VR9Y+eGmqr66UK1Ni3hXAlyvg7m9D0zdpEBQa0mCUvL908T0Yim/xuXV1Rrn7S7ePDAtYi6ZC9VVao7HI2gf/XyX3Lml7OrTtGbz+SIOk0JCgqSgUco6eIPdYfrXvL52Z78oVKwMgHJqd0bZ8Oe/6LK1xssraBy9cCXvWUb70WxELA+eg50hdLSUKDal7JU8l1SYUqnLYwfFhXekSG1XqiiiFQwWKA8IMxv0Z3v4NnNId9lTxQdi+E6BFO81jCKDQkBoqOWoovtfzwa+zOHYkj68+yyx3KqlWDMLDjG6J7UrdX7rUHeKy9sGWGTB5AcQqMPxzE+f/Cd641RcU7X7wfUD8bTjg4KuPKt5G7/OhVVdfWGiEIUUUGhJQRaEA309E1+WooVjx/aXzcvIBAgdEIP/3p6Z5U6Cyo4eSAbH7Y3h5mq9OFED62hIrVvG769AHwiKa1mspnqj2VBOWdiCN1798HYejb9u+bPtmGw7H4G/OY9ebx4MaCsXhVO37S5f9LEGxk72QXqCRQvEppbKjhw3P+9bp0Of7gKipMy/6/lTU5Ytr+UPIyUS1p6TCUCj+/uXPXybf5Zdap2NWPKdsPptwV/NDIywcuie2L3UqqcahUJWyNwUCOKUbxHSErP0N6wNoFQVBoFBYfAlkHyg9Unh5GmTuqHj0UNPAaBMPnZMgYz0U5mt0IZXSSOMkVpNQKGYYga49GrBnDIN3jyWM8Cr3XzxqiG4RUer0VZ+zO9dtMFTl3rbff1q5rOs+9L0RT15Q+wCpzpt+oOXtfgAbl0D73t+/wZccHdTFSKEqbeJ9I7PcLOgyENr30qhCAO8jDYVGA5R2II3U/am0jmpdLghqGwpV6ZgVz/gtvySiMKrCUPA8zxAsz14C3+z0fVUkphNc+VLlb+p18aafuaPi5cEW29kXDlGx0G2IbyTRKVEBIQEpNBpgaJQMg8N5hwOGQubxTD7c8yEnCk9U+qZf01AoFkYYEWER/Kjrj2jXvF2pUBoZeQEtMzs0nFDw4vXbfFVXvbwmFf1139De9L0qHj1kH4CWcQoIqRHNaYRAZaEQExnDoi2LKHAFOFyt3/SrWreyUOjbti+H8w6T3DGZpLikGvehQTl6AJKvhcPp8Pk7lbctGQKBvq9oeSiERUCLDr5CiblZEB7tK1NecvTQMUHhIEET0tAws/OBv+C73euTzrk/llluRcvHAseAKc65T4PZx4pOFdU2FGoTGNAEQ6EqxW+aL1wJ7ftA5nY8jTqCreQpI+P70UHJUIjp4HtO8w3SAIUsNMwsHHgUOBdIB9aa2WvOuS0lml0A9Cr6GgI8XvRvnSg7kVxVEJTqfy1DobL1IyyCSb0mBZzHaLKh4NXli33BET8MMj+HfRsh57u6276XN/3ikUDJ5TplJI1ElaFhZmeWeSPHzEY6596v5b5TgC+cczuLtvkCMBEoua+JwELnm3j52MxOMbPOzrm9Nd1pcVBkHs9kVfqqUhPJ1TllVJNQMIxwC+fqM6+mVXSrCie6J5w+QWFQGyXflF+40nf5bebnvlNY2QcDv6nrTV/EEy8jjRfNbBHwJ6BZ0b/JwNBa7rsr8HWJx+mUH0UEatMVqFFopB1I4+fv/Jy8wryAy6tzyqgmoaDRQQjoDV6kTnkJjSHAg8BHQCywGBhWB/sOVNW67Lu2lza+hmbTgekA3bp1C7jD1P2pnCg8UUmHKg+CoyeOVngqS6EgIk2Bl9A4ARwHmuMbafzXubJ3Z6mRdOC0Eo9PBTJq0AYA59x8YD74LrkN1Ca5YzKRYZH+kUaERTDi1BH+iWQFgYhI5byExlrgVWAw0A74m5lNds5NruW+1wK9zKwHsAe4HPhpmTavATcVzXcMAQ7XZj4jKS6Jp37ylH/yW3MHIiLV4yU0fu6cK/6k3D5gopldXdsdO+fyzewm4B18l9w+7ZzbbGbXFy1/AliG73LbL/Bdcju1tvtNiktSUIiI1JA+ES4iIp4/ER4WjM6IiEjjoNAQERHPFBoiIuKZQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEM4WGiIh4ptAQERHPFBoiIuKZQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEM4WGiIh45uV2r3XOzNoCS4B4YBfwP865bwO02wVkAQVAvpe7SomISP0J1Ujjt8AK51wvYEXR44qMcs4lKTBEREIvVKExEfhH0ff/AC4KUT9ERKQaQhUaHZ1zewGK/o2roJ0D3jWzdWY2PWi9ExGRgOptTsPMlgOdAiyaWY3NDHPOZZhZHPCemW1zzq2qYH/TgekA3bp1q3Z/RUSkavUWGs65MRUtM7P9ZtbZObfXzDoDByrYRkbRvwfMbCmQAgQMDefcfGA+QHJysqtt/0VEpLxQnZ56Dbim6PtrgFfLNjCzlmYWW/w9cB6wKWg9FBGRckIVGn8EzjWzz4Fzix5jZl3MbFlRm47Ah2a2AVgDvOmcezskvRURESBEn9Nwzh0CRgd4PgMYW/T9TqB/kLsmIiKV0CfCRUTEM4WGiIh4ptAQERHPFBoiIuKZQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEM4WGiIh4ptAQERHPFBoiIuKZQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEs5CEhpldamabzazQzJIraXe+mW03sy/M7LfB7KOIiJQXqpHGJuBiYFVFDcwsHHgUuAA4E7jCzM4MTvdERCSQUN0jfCuAmVXWLAX4ouhe4ZjZC8BEYEu9d1BERAJqyHMaXYGvSzxOL3ouIDObbmapZpZ68ODBeu+ciEhTVG8jDTNbDnQKsGimc+5VL5sI8JyrqLFzbj4wHyA5ObnCdiIiUnP1FhrOuTG13EQ6cFqJx6cCGbXcpoiI1EJDPj21FuhlZj3MLAq4HHgtxH0SEWnSQnXJ7SQzSweGAm+a2TtFz3cxs2UAzrl84CbgHWAr8KJzbnMo+isiIj6hunpqKbA0wPMZwNgSj5cBy4LYNRERqURDPj0lIiINjEJDREQ8U2iIiIhnCg0REfFMoSEiIp4pNERExDOFhoiIeKbQEBERzxQaIiLimUJDREQ8U2iIiIhnCg0REfFMoSEiIp4pNERExDOFhoiIeKbQEBERzxQaIiLiWahu93qpmW02s0IzS66k3S4z+8zM0swsNZh9FBGR8kJyu1dgE3Ax8DcPbUc55zLruT8iIuJBqO4RvhXAzEKxexERqaGGPqfhgHfNbJ2ZTa+soZlNN7NUM0s9ePBgkLonItK01NtIw8yWA50CLJrpnHvV42aGOecyzCwOeM/MtjnnVgVq6JybD8wHSE5OdjXqtIiIVKreQsM5N6YOtpFR9O8BM1sKpAABQ0NEROpfgz09ZWYtzSy2+HvgPHwT6CIiEiKhuuR2kpmlA0OBN83snaLnu5jZsqJmHYEPzWwDsAZ40zn3dij6KyIiPqG6emopsDTA8xnA2KLvdwL9g9w1ERGpRIM9PSUiIg2PQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEM4WGiIh4ptAQERHPFBoiIuKZQkNERDxTaIiIiGcKDRER8UyhISIinik0RETEM4WGiIh4ptAQERHPQnXnvofMbJuZbTSzpWZ2SgXtzjez7Wb2hZn9NsjdFBGRMkI10ngPSHDO9QN2AHeWbWBm4cCjwAXAmcAVZnZmUHspIiKlhCQ0nHPvOufyix5+DJwaoFkK8IVzbqdzLg94AZgYrD6KiEh5DWFO41rgrQDPdwW+LvE4veg5EREJkYj62rCZLQc6BVg00zn3alGbmUA+sDjQJgI85yrZ33RgOkC3bt2q3V8REalavYWGc25MZcvN7BrgQmC0cy5QGKQDp5V4fCqQUcn+5gPzAZKTkysMFxERqblQXT11PnAHMME5d6yCZmuBXmbWw8yigMuB14LVRxERKS9UcxqPALHAe2aWZmZPAJhZFzNbBlA0UX4T8A6wFXjRObc5RP0VERHq8fRUZZxzP6jg+QxgbInHy4BlweqXiIhUzgJPJ5zczOwg8FUlTdoDmUHqTnU15L6B+ldb6l/tqH81V1XfujvnOlS1kUYZGlUxs1TnXHKo+xFIQ+4bqH+1pf7VjvpXc3XVt4bwOQ0RETlJKDRERMSzphoa80PdgUo05L6B+ldb6l/tqH81Vyd9a5JzGiIiUjNNdaQhIiI1oNAQERHPGlVoVHXTJvOZV7R8o5kN9LpukPp3ZVG/NprZR2bWv8SyXWb2WdEn6FND1L+RZna4qA9pZjbL67pB6t+vS/Rtk5kVmFnbomX1+vqZ2dNmdsDMNlWwPNTHXlX9C/WxV1X/QnbseehbyI67on2cZmYrzWyrmW02s1sCtKm748851yi+gHDgS6AnEAVsAM4s02YsvjLsBpwNfOJ13SD174dAm6LvLyjuX9HjXUD7EL9+I4E3arJuMPpXpv144N9BfP1GAAOBTRUsD9mx57F/ITv2PPYvlMdepX0L5XFXtI/OwMCi72Px3diu3t77GtNIw8tNmyYCC53Px8ApZtbZ47r13j/n3EfOuW+LHlZ0c6r6UpvXoEG8fmVcATxfx32okHNuFfBNJU1CeexV2b8QH3teXr+K1PvrV82+BfW4A3DO7XXOfVr0fRa+Wn1l7z1UZ8dfYwoNLzdtqqhNMG74VN19/JzSN6dywLtmts589w6pa177N9TMNpjZW2Z2VjXXDUb/MLMWwPnAv0o8Xd+vX1VCeexVV7CPPa9Cdex50hCOOzOLBwYAn5RZVGfHX0gKFtYTLzdtqqhNtW74VEOe92Fmo/D9x/1RiaeHOecyzCwOX3XgbUV/AQWzf5/iq0+TbWZjgVeAXh7Xra3q7GM8sNo5V/Kvw/p+/aoSymPPsxAde16E8tjzKqTHnZnF4AusW51zR8ouDrBKjY6/xjTS8HLTporaVOuGT/XYP8ysH/AkMNE5d6j4eeerAIxz7gCwFN+wMqj9c84dcc5lF32/DIg0s/Ze1g1G/0q4nDKnCILw+lUllMeeJyE89qoU4mPPq5Add2YWiS8wFjvnXg7QpO6Ov/qcoAnmF75R006gB99P6JxVps04Sk8GrfG6bpD61w34AvhhmedbArElvv8IOD8E/evE9x8ITQF2F72WDeL1K2rXGt/555bBfP2Kth1PxRO5ITv2PPYvZMeex/6F7Nirqm8N4LgzYCEwt5I2dXb8NZrTU865fDMrvmlTOPC0c26zmV1ftPwJfPfmGIvvP8cxYGpl64agf7OAdsBjZgaQ73xVKTsCS4ueiwCec869HYL+TQZuMLN84DhwufMdeQ3l9QOYBLzrnDtaYvV6f/3M7Hl8V/i0N7N04G4gskTfQnbseexfyI49j/0L2bHnoW8QouOuyDDgauAzM0sreu53+P4QqPPjT2VERETEs8Y0pyEiIvVMoSEiIp4pNERExDOFhoiIeKbQEGlgzCyp6ANsIg2OQkOk4UnCd3mkSIOj0BCpITMbXFRmupmZtSwqS51QQdtfm9naovb3Fj03ycyWF5Wt7mxmO8ysG/B74LKictqXBfNnEqmKPqchUgtmNhtoBjQH0p1zDwRocx6+D6ddh+8Tua8Bf3LOrTKzZ/FVlT0fXwmI581sCpDsnLspSD+GiGeN5hPhIiHye2AtkAPMqKDNeUVf64sex+ArtrcKuBnYBHzsnAtqSW2RmlBoiNROW3whEIlvxHE0QBsDHnDO/S3Asq5AIdDRzMKcc4X11lOROqA5DZHamQ/8P2Ax8GAFbd4Bri0qXY2ZdTWzODOLAJ4Bforvxjn/W9Q+C98d2EQaHM1piNSQmf0MuMg5d7GZheOrYnqnc+7fAdreAkwrepgNXAVcCZzinPtfM4vFd5prErAfX9BE4huhLKn/n0bEG4WGiIh4ptNTIiLimSbCReqImSUCi8o8neucGxKK/ojUB52eEhERz3R6SkREPFNoiIiIZwoNERHxTKEhIiKeKTRERMQzhYaIiHj2/wPWZTgpEhsxdQAAAABJRU5ErkJggg==\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fhn = bp.dyn.RateFHN(1, method='exp_auto')\n", + "\n", + "bf = bp.analysis.Bifurcation2D(\n", + " fhn,\n", + " target_vars={'x': [-2, 2], 'y': [-2, 2]},\n", + " target_pars={'x_ext': [0, 2]},\n", + " pars_update={'y_ext': 0.},\n", + " resolutions={'x_ext': 0.01}\n", + ")\n", + "bf.plot_bifurcation()\n", + "bf.plot_limit_cycle_by_sim(duration=500)\n", + "bf.show_figure()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "In this model, we find that when the external input ``x_ext`` has the value in [0.72, 1.4], the model will generate limit cycles. We can verify this by simulation." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/1000 [00:00", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "runner = bp.dyn.DSRunner(fhn, monitors=['x', 'y'], inputs=['input', 1.0])\n", + "runner.run(100.)\n", + "\n", + "bp.visualize.line_plot(runner.mon.ts, runner.mon.x, legend='x')\n", + "bp.visualize.line_plot(runner.mon.ts, runner.mon.y, legend='y', show=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Whole-brain model" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "A rate-based whole-brain model is a network model which consists of coupled brain regions. Each brain region is represented by a neural mass model which is connected to other brain regions according to the underlying network structure of the brain, also known as the connectome. In order to illustrate how to use BrainPy's support for whole-brain modeling, here we provide a processed data in the following link:\n", + "\n", + "- A processed data from ConnectomeDB of the Human Connectome Project (HCP): [https://share.weiyun.com/wkPpARKy](https://share.weiyun.com/wkPpARKy)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Please download the dataset and place it in your favorite ``PATH``." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "PATH = './data/hcp.npz'" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "In genral, a dataset for whole-brain modeling consists of the following parts:\n", + "\n", + "1\\. A structural connectivity matrix which captures the synaptic connection strengths between brain areas. It often derived from DTI tractography of the whole brain. The connectome is then typically parcellated in a preferred atlas (for example the AAL2 atlas) and the number of axonal fibers connecting each brain area with every other area is counted. This number serves as an indication of the synaptic coupling strengths between the areas of the brain.\n", + "\n", + "2\\. A delay matrix which calculated from the average length of the axonal fibers connecting each brain area with another.\n", + "\n", + "3\\. A set of functional data that can act as a target for model optimization. Resting-state fMRI offers an easy and fairly unbiased way for calibrating whole-brain models. EEG data could be used as well." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Now, let's load the dataset." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [], + "source": [ + "data = bm.load(PATH)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "source": [ + "# The structural connectivity matrix\n", + "\n", + "data['Cmat'].shape" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "execution_count": 8, + "outputs": [ + { + "data": { + "text/plain": "(80, 80)" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "(80, 80)" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The fiber length matrix\n", + "\n", + "data['Dmat'].shape" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "data": { + "text/plain": "(7, 80, 80)" + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The functional data for 7 subjects\n", + "\n", + "data['FCs'].shape" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's have a look what the data looks like." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(15,5))\n", + "fig.subplots_adjust(wspace=0.28)\n", + "\n", + "im = axs[0].imshow(data['Cmat'])\n", + "axs[0].set_title(\"Connection matrix\")\n", + "fig.colorbar(im, ax=axs[0],fraction=0.046, pad=0.04)\n", + "im = axs[1].imshow(data['Dmat'], cmap='inferno')\n", + "axs[1].set_title(\"Fiber length matrix\")\n", + "fig.colorbar(im, ax=axs[1],fraction=0.046, pad=0.04)\n", + "im = axs[2].imshow(data['FCs'][0], cmap='inferno')\n", + "axs[2].set_title(\"Empirical FC of subject 1\")\n", + "fig.colorbar(im, ax=axs[2],fraction=0.046, pad=0.04)\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's first get the delay matrix according to the fiber length matrix, the signal transmission speed between areas, and the numerical integration step ``dt``. Here, we assume the axonal transmission speed is 20 and the simulation time step ``dt=0.1`` ms." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [], + "source": [ + "sigal_speed = 20.\n", + "\n", + "# the number of the delay steps\n", + "delay_mat = data['Dmat'] / sigal_speed / bm.get_dt()\n", + "delay_mat = bm.asarray(delay_mat, dtype=bm.int_)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The connectivity matrix can be directly obtained through the structural connectivity matrix, which times a global coupling strength parameter ``gc``. b" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, "outputs": [], - "source": [] + "source": [ + "gc = 1.\n", + "\n", + "conn_mat = bm.asarray(data['Cmat'] * gc)\n", + "\n", + "# It is necessary to exclude the self-connections\n", + "bm.fill_diagonal(conn_mat, 0)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We now are ready to intantiate a whole-brain model with the neural mass model and the dataset the processed before." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [], + "source": [ + "class WholeBrainNet(bp.dyn.Network):\n", + " def __init__(self, Cmat, Dmat):\n", + " super(WholeBrainNet, self).__init__()\n", + "\n", + " self.fhn = bp.dyn.RateFHN(80, x_ou_sigma=0.01, y_ou_sigma=0.01,\n", + " name='fhn', method='exp_auto')\n", + " self.syn = bp.dyn.DiffusiveDelayCoupling(self.fhn, self.fhn,\n", + " 'x->input',\n", + " conn_mat=Cmat,\n", + " delay_mat=Dmat,\n", + " delay_initializer=bp.init.Uniform(0, 0.05))\n", + "\n", + " def update(self, _t, _dt):\n", + " self.syn.update(_t, _dt)\n", + " self.fhn.update(_t, _dt)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/60000 [00:00", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "fc = bp.measure.functional_connectivity(runner.mon['fhn.x'])\n", + "ax = axs[0].imshow(fc)\n", + "plt.colorbar(ax, ax=axs[0])\n", + "axs[1].plot(runner.mon.ts, runner.mon['fhn.x'][:, ::5], alpha=0.8)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can compute the element-wise Pearson correlation of the functional connectivity matrices of the simulated data to the empirical data to estimate how well the model captures the inter-areal functional correlations found in empirical resting-state recordings." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation per subject: ['0.62', '0.49', '0.61', '0.5', '0.56', '0.5', '0.47']\n", + "Mean FC/FC correlation: 0.54\n" + ] + } + ], + "source": [ + "scores = [bp.measure.matrix_correlation(fc, fcemp)\n", + " for fcemp in data['FCs']]\n", + "print(\"Correlation per subject:\", [f\"{s:.2}\" for s in scores])\n", + "print(\"Mean FC/FC correlation: {:.2f}\".format(bm.mean(bm.asarray(scores))))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "name": "python3", "language": "python", - "name": "python3" + "display_name": "Python 3" }, "language_info": { "codemirror_mode": { @@ -38,4 +815,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From ec0d8526bf00ed3e65f3bcb8c4184fa67ff7dc05 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 12:00:33 +0800 Subject: [PATCH 15/22] feat: rewrite neuron and synapse arguments --- brainpy/dyn/neurons/biological_models.py | 71 +++++-- brainpy/dyn/neurons/fractional_models.py | 85 +++++--- brainpy/dyn/neurons/rate_models.py | 135 +++++++----- brainpy/dyn/neurons/reduced_models.py | 255 +++++++++++++++++------ brainpy/dyn/synapses/abstract_models.py | 29 ++- brainpy/dyn/synapses/delay_coupling.py | 23 +- 6 files changed, 415 insertions(+), 183 deletions(-) diff --git a/brainpy/dyn/neurons/biological_models.py b/brainpy/dyn/neurons/biological_models.py index ce1e5a583..35e68c18a 100644 --- a/brainpy/dyn/neurons/biological_models.py +++ b/brainpy/dyn/neurons/biological_models.py @@ -1,9 +1,14 @@ # -*- coding: utf-8 -*- +from typing import Union, Callable + import brainpy.math as bm +from brainpy.dyn.base import NeuGroup +from brainpy.initialize import OneInit, Uniform, Initializer, init_param from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint -from brainpy.dyn.base import NeuGroup +from brainpy.tools.checking import check_initializer +from brainpy.types import Shape, Parameter, Tensor __all__ = [ 'HH', @@ -178,8 +183,24 @@ class HH(NeuGroup): The Journal of Mathematical Neuroscience 6, no. 1 (2016): 1-92. """ - def __init__(self, size, ENa=50., gNa=120., EK=-77., gK=36., EL=-54.387, gL=0.03, - V_th=20., C=1.0, method='exp_auto', name=None): + def __init__( + self, + size: Shape, + ENa: Parameter = 50., + gNa: Parameter = 120., + EK: Parameter = -77., + gK: Parameter = 36., + EL: Parameter = -54.387, + gL: Parameter = 0.03, + V_th: Parameter = 20., + C: Parameter = 1.0, + V_initializer: Union[Initializer, Callable, Tensor] = Uniform(-70, -60.), + m_initializer: Union[Initializer, Callable, Tensor] = OneInit(0.5), + h_initializer: Union[Initializer, Callable, Tensor] = OneInit(0.6), + n_initializer: Union[Initializer, Callable, Tensor] = OneInit(0.32), + method: str = 'exp_auto', + name: str = None + ): # initialization super(HH, self).__init__(size=size, name=name) @@ -194,10 +215,14 @@ def __init__(self, size, ENa=50., gNa=120., EK=-77., gK=36., EL=-54.387, gL=0.03 self.V_th = V_th # variables - self.m = bm.Variable(0.5 * bm.ones(self.num)) - self.h = bm.Variable(0.6 * bm.ones(self.num)) - self.n = bm.Variable(0.32 * bm.ones(self.num)) - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(m_initializer, 'm_initializer', allow_none=False) + check_initializer(h_initializer, 'h_initializer', allow_none=False) + check_initializer(n_initializer, 'n_initializer', allow_none=False) + check_initializer(V_initializer, 'V_initializer', allow_none=False) + self.m = bm.Variable(init_param(m_initializer, (self.num,))) + self.h = bm.Variable(init_param(h_initializer, (self.num,))) + self.n = bm.Variable(init_param(n_initializer, (self.num,))) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -334,11 +359,29 @@ class MorrisLecar(NeuGroup): .. [3] https://en.wikipedia.org/wiki/Morris%E2%80%93Lecar_model """ - def __init__(self, size, V_Ca=130., g_Ca=4.4, V_K=-84., g_K=8., V_leak=-60., - g_leak=2., C=20., V1=-1.2, V2=18., V3=2., V4=30., phi=0.04, - V_th=10., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + V_Ca: Parameter = 130., + g_Ca: Parameter = 4.4, + V_K: Parameter = -84., + g_K: Parameter = 8., + V_leak: Parameter = -60., + g_leak: Parameter = 2., + C: Parameter = 20., + V1: Parameter = -1.2, + V2: Parameter = 18., + V3: Parameter = 2., + V4: Parameter = 30., + phi: Parameter = 0.04, + V_th: Parameter = 10., + W_initializer: Union[Callable, Initializer, Tensor] = OneInit(0.02), + V_initializer: Union[Callable, Initializer, Tensor] = Uniform(-70., -60.), + method: str = 'exp_auto', + name: str = None + ): # initialization - super(MorrisLecar, self).__init__(size=size, name=name) + super(MorrisLecar, self).__init__(size=size, name=name) # params self.V_Ca = V_Ca @@ -356,8 +399,10 @@ def __init__(self, size, V_Ca=130., g_Ca=4.4, V_K=-84., g_K=8., V_leak=-60., self.V_th = V_th # vars - self.W = bm.Variable(bm.ones(self.num) * 0.02) - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer', allow_none=False) + check_initializer(W_initializer, 'W_initializer', allow_none=False) + self.W = bm.Variable(init_param(W_initializer, (self.num,))) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) diff --git a/brainpy/dyn/neurons/fractional_models.py b/brainpy/dyn/neurons/fractional_models.py index 552dadb3b..fad1d6ea3 100644 --- a/brainpy/dyn/neurons/fractional_models.py +++ b/brainpy/dyn/neurons/fractional_models.py @@ -1,16 +1,19 @@ # -*- coding: utf-8 -*- -from typing import Union, Sequence +from typing import Union, Sequence, Callable import brainpy.math as bm from brainpy.dyn.base import NeuGroup +from brainpy.initialize import ZeroInit, OneInit, Initializer, init_param from brainpy.integrators.fde import CaputoL1Schema from brainpy.integrators.fde import GLShortMemory from brainpy.integrators.joint_eq import JointEq from brainpy.tools.checking import check_float, check_integer -from brainpy.types import Parameter, Shape +from brainpy.tools.checking import check_initializer +from brainpy.types import Parameter, Shape, Tensor __all__ = [ + 'FractionalNeuron', 'FractionalFHR', 'FractionalIzhikevich', ] @@ -75,18 +78,23 @@ class FractionalFHR(FractionalNeuron): .. [1] Mondal, A., Sharma, S.K., Upadhyay, R.K. *et al.* Firing activities of a fractional-order FitzHugh-Rinzel bursting neuron model and its coupled dynamics. *Sci Rep* **9,** 15721 (2019). https://doi.org/10.1038/s41598-019-52061-4 """ - def __init__(self, - size: Shape, - alpha: Union[float, Sequence[float]], - num_memory: int = 1000, - a: Parameter = 0.7, - b: Parameter = 0.8, - c: Parameter = -0.775, - d: Parameter = 1., - delta: Parameter = 0.08, - mu: Parameter = 0.0001, - Vth: Parameter = 1.8, - name: str = None): + def __init__( + self, + size: Shape, + alpha: Union[float, Sequence[float]], + num_memory: int = 1000, + a: Parameter = 0.7, + b: Parameter = 0.8, + c: Parameter = -0.775, + d: Parameter = 1., + delta: Parameter = 0.08, + mu: Parameter = 0.0001, + Vth: Parameter = 1.8, + V_initializer: Union[Initializer, Callable, Tensor] = OneInit(2.5), + w_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + y_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + name: str = None + ): super(FractionalFHR, self).__init__(size, name=name) # fractional order @@ -103,10 +111,13 @@ def __init__(self, self.Vth = Vth # variables + check_initializer(V_initializer, 'V_initializer', allow_none=False) + check_initializer(w_initializer, 'w_initializer', allow_none=False) + check_initializer(y_initializer, 'y_initializer', allow_none=False) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) + self.w = bm.Variable(init_param(w_initializer, (self.num,))) + self.y = bm.Variable(init_param(y_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) - self.V = bm.Variable(bm.ones(self.num) * 2.5) - self.w = bm.Variable(bm.zeros(self.num)) - self.y = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -201,21 +212,25 @@ class FractionalIzhikevich(FractionalNeuron): """ - def __init__(self, - size: Shape, - alpha: Union[float, Sequence[float]], - num_step: int, - a: Parameter = 0.02, - b: Parameter = 0.20, - c: Parameter = -65., - d: Parameter = 8., - f: Parameter = 0.04, - g: Parameter = 5., - h: Parameter = 140., - tau: Parameter = 1., - R: Parameter = 1., - V_th: Parameter = 30., - name: str = None): + def __init__( + self, + size: Shape, + alpha: Union[float, Sequence[float]], + num_step: int, + a: Parameter = 0.02, + b: Parameter = 0.20, + c: Parameter = -65., + d: Parameter = 8., + f: Parameter = 0.04, + g: Parameter = 5., + h: Parameter = 140., + tau: Parameter = 1., + R: Parameter = 1., + V_th: Parameter = 30., + V_initializer: Union[Initializer, Callable, Tensor] = OneInit(-65.), + u_initializer: Union[Initializer, Callable, Tensor] = OneInit(0.20 * -65.), + name: str = None + ): # initialization super(FractionalIzhikevich, self).__init__(size=size, name=name) @@ -234,8 +249,10 @@ def __init__(self, self.V_th = V_th # variables - self.V = bm.Variable(bm.ones(self.num) * c) - self.u = bm.Variable(b * self.V) + check_initializer(V_initializer, 'V_initializer', allow_none=False) + check_initializer(u_initializer, 'u_initializer', allow_none=False) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) + self.u = bm.Variable(init_param(u_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) diff --git a/brainpy/dyn/neurons/rate_models.py b/brainpy/dyn/neurons/rate_models.py index 71a45c811..fd1f1cfeb 100644 --- a/brainpy/dyn/neurons/rate_models.py +++ b/brainpy/dyn/neurons/rate_models.py @@ -1,15 +1,20 @@ # -*- coding: utf-8 -*- + +from typing import Union, Callable + import numpy as np from jax.experimental.host_callback import id_tap import brainpy.math as bm from brainpy import check from brainpy.dyn.base import NeuGroup +from brainpy.initialize import Initializer, Uniform +from brainpy.initialize import init_param from brainpy.integrators.dde import ddeint from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint -from brainpy.tools.checking import check_float -from brainpy.types import Parameter, Shape +from brainpy.tools.checking import check_float, check_initializer +from brainpy.types import Parameter, Shape, Tensor from .noise_models import OUProcess __all__ = [ @@ -39,17 +44,17 @@ class RateFHN(NeuGroup): ---------- size: Shape The model size. - x_ou_mean + x_ou_mean: Parameter The noise mean of the :math:`x` variable, [mV/ms] - y_ou_mean + y_ou_mean: Parameter The noise mean of the :math:`y` variable, [mV/ms]. - x_ou_sigma + x_ou_sigma: Parameter The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. - y_ou_sigma + y_ou_sigma: Parameter The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. - x_ou_tau + x_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. - y_ou_tau + y_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. @@ -83,6 +88,8 @@ def __init__( y_ou_tau: Parameter = 5.0, # other parameters + x_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), + y_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), method: str = None, sde_method: str = None, name: str = None, @@ -106,8 +113,10 @@ def __init__( self.y_ou_tau = y_ou_tau # ms, timescale of the Ornstein-Uhlenbeck noise process # variables - self.x = bm.Variable(bm.random.random(self.num) * 0.05) - self.y = bm.Variable(bm.random.random(self.num) * 0.05) + check_initializer(x_initializer, 'x_initializer') + check_initializer(y_initializer, 'y_initializer') + self.x = bm.Variable(init_param(x_initializer, (self.num,))) + self.y = bm.Variable(init_param(x_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) # noise variables @@ -184,17 +193,17 @@ class FeedbackFHN(NeuGroup): Parameters ---------- - x_ou_mean + x_ou_mean: Parameter The noise mean of the :math:`x` variable, [mV/ms] - y_ou_mean + y_ou_mean: Parameter The noise mean of the :math:`y` variable, [mV/ms]. - x_ou_sigma + x_ou_sigma: Parameter The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. - y_ou_sigma + y_ou_sigma: Parameter The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. - x_ou_tau + x_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. - y_ou_tau + y_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. @@ -228,6 +237,8 @@ def __init__( y_ou_tau: Parameter = 5.0, # other parameters + x_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), + y_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), method: str = 'rk4', sde_method: str = None, name: str = None, @@ -256,8 +267,10 @@ def __init__( self.y_ou_tau = y_ou_tau # variables - self.x = bm.Variable(bm.zeros(self.num)) - self.y = bm.Variable(bm.zeros(self.num)) + check_initializer(x_initializer, 'x_initializer') + check_initializer(y_initializer, 'y_initializer') + self.x = bm.Variable(init_param(x_initializer, (self.num,))) + self.y = bm.Variable(init_param(x_initializer, (self.num,))) self.x_delay = bm.TimeDelay(self.x, self.delay, dt=self.dt, interp_method='round') self.input = bm.Variable(bm.zeros(self.num)) @@ -346,17 +359,17 @@ class RateQIF(NeuGroup): Parameters ---------- - x_ou_mean + x_ou_mean: Parameter The noise mean of the :math:`x` variable, [mV/ms] - y_ou_mean + y_ou_mean: Parameter The noise mean of the :math:`y` variable, [mV/ms]. - x_ou_sigma + x_ou_sigma: Parameter The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. - y_ou_sigma + y_ou_sigma: Parameter The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. - x_ou_tau + x_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. - y_ou_tau + y_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. @@ -390,6 +403,8 @@ def __init__( y_ou_tau: Parameter = 5.0, # other parameters + x_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), + y_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.05), method: str = 'exp_auto', name: str = None, sde_method: str = None, @@ -411,8 +426,10 @@ def __init__( self.y_ou_tau = y_ou_tau # variables - self.y = bm.Variable(bm.ones(self.num)) - self.x = bm.Variable(bm.ones(self.num)) + check_initializer(x_initializer, 'x_initializer') + check_initializer(y_initializer, 'y_initializer') + self.x = bm.Variable(init_param(x_initializer, (self.num,))) + self.y = bm.Variable(init_param(x_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) # noise variables @@ -461,17 +478,17 @@ class StuartLandauOscillator(RateGroup): Parameters ---------- - x_ou_mean + x_ou_mean: Parameter The noise mean of the :math:`x` variable, [mV/ms] - y_ou_mean + y_ou_mean: Parameter The noise mean of the :math:`y` variable, [mV/ms]. - x_ou_sigma + x_ou_sigma: Parameter The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. - y_ou_sigma + y_ou_sigma: Parameter The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. - x_ou_tau + x_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. - y_ou_tau + y_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. """ @@ -493,6 +510,8 @@ def __init__( y_ou_tau: Parameter = 5.0, # other parameters + x_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.5), + y_initializer: Union[Initializer, Callable, Tensor] = Uniform(0, 0.5), method: str = None, sde_method: str = None, name: str = None, @@ -513,8 +532,10 @@ def __init__( self.y_ou_tau = y_ou_tau # variables - self.x = bm.Variable(bm.random.random(self.num) * 0.5) - self.y = bm.Variable(bm.random.random(self.num) * 0.5) + check_initializer(x_initializer, 'x_initializer') + check_initializer(y_initializer, 'y_initializer') + self.x = bm.Variable(init_param(x_initializer, (self.num,))) + self.y = bm.Variable(init_param(x_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) # noise variables @@ -558,17 +579,17 @@ class WilsonCowanModel(RateGroup): Parameters ---------- - x_ou_mean + x_ou_mean: Parameter The noise mean of the :math:`x` variable, [mV/ms] - y_ou_mean + y_ou_mean: Parameter The noise mean of the :math:`y` variable, [mV/ms]. - x_ou_sigma + x_ou_sigma: Parameter The noise intensity of the :math:`x` variable, [mV/ms/sqrt(ms)]. - y_ou_sigma + y_ou_sigma: Parameter The noise intensity of the :math:`y` variable, [mV/ms/sqrt(ms)]. - x_ou_tau + x_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`x` variable, [ms]. - y_ou_tau + y_ou_tau: Parameter The timescale of the Ornstein-Uhlenbeck noise process of :math:`y` variable, [ms]. @@ -579,24 +600,28 @@ def __init__( size: Shape, # Excitatory parameters - E_tau=2.5, # excitatory time constant - E_a=1.5, # excitatory gain - E_theta=3.0, # excitatory firing threshold + E_tau=1., # excitatory time constant + E_a=1.2, # excitatory gain + E_theta=2.8, # excitatory firing threshold # Inhibitory parameters - I_tau=3.75, # inhibitory time constant - I_a=1.5, # inhibitory gain - I_theta=3.0, # inhibitory firing threshold + I_tau=1., # inhibitory time constant + I_a=1., # inhibitory gain + I_theta=4.0, # inhibitory firing threshold # connection parameters - wEE=16., # local E-E coupling - wIE=15., # local E-I coupling - wEI=12., # local I-E coupling - wII=3., # local I-I coupling + wEE=12., # local E-E coupling + wIE=4., # local E-I coupling + wEI=13., # local I-E coupling + wII=11., # local I-I coupling # Refractory parameter r=1, + # state initializer + x_initializer: Union[Initializer, Callable, Tensor] = Uniform(max_val=0.05), + y_initializer: Union[Initializer, Callable, Tensor] = Uniform(max_val=0.05), + # noise parameters x_ou_mean: Parameter = 0.0, x_ou_sigma: Parameter = 0.0, @@ -607,7 +632,7 @@ def __init__( # other parameters sde_method: str = None, - method: str = None, + method: str = 'exp_euler_auto', name: str = None, ): super(WilsonCowanModel, self).__init__(size=size, name=name) @@ -634,8 +659,10 @@ def __init__( self.y_ou_tau = y_ou_tau # variables - self.x = bm.Variable(bm.random.random(self.num) * 0.05) - self.y = bm.Variable(bm.random.random(self.num) * 0.05) + check_initializer(x_initializer, 'x_initializer') + check_initializer(y_initializer, 'y_initializer') + self.x = bm.Variable(init_param(x_initializer, (self.num,))) + self.y = bm.Variable(init_param(x_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) # noise variables @@ -654,7 +681,7 @@ def __init__( # functions def F(self, x, a, theta): - return 1 / (1 + bm.exp(-a * (x - theta))) + return 1 / (1 + bm.exp(-a * (x - theta))) - 1 / (1 + bm.exp(a * theta)) def dx(self, x, t, y, x_ext): x = self.wEE * x - self.wIE * y + x_ext diff --git a/brainpy/dyn/neurons/reduced_models.py b/brainpy/dyn/neurons/reduced_models.py index b0a90b154..8d2a60369 100644 --- a/brainpy/dyn/neurons/reduced_models.py +++ b/brainpy/dyn/neurons/reduced_models.py @@ -1,10 +1,14 @@ # -*- coding: utf-8 -*- +from typing import Union, Callable + import brainpy.math as bm from brainpy.dyn.base import NeuGroup +from brainpy.initialize import ZeroInit, OneInit, Initializer, init_param from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint -from brainpy.types import Shape, Parameter +from brainpy.tools.checking import check_initializer +from brainpy.types import Shape, Parameter, Tensor __all__ = [ 'LIF', @@ -72,15 +76,18 @@ class LIF(NeuGroup): neuron (1907)." Brain research bulletin 50, no. 5-6 (1999): 303-304. """ - def __init__(self, - size: Shape, - V_rest: Parameter = 0., - V_reset: Parameter = -5., - V_th: Parameter = 20., - tau: Parameter = 10., - tau_ref: Parameter = 1., - method: str = 'exp_auto', - name: str = None): + def __init__( + self, + size: Shape, + V_rest: Parameter = 0., + V_reset: Parameter = -5., + V_th: Parameter = 20., + tau: Parameter = 10., + tau_ref: Parameter = 1., + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): # initialization super(LIF, self).__init__(size=size, name=name) @@ -92,7 +99,8 @@ def __init__(self, self.tau_ref = tau_ref # variables - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -215,18 +223,21 @@ class ExpIF(NeuGroup): .. [5] https://en.wikipedia.org/wiki/Exponential_integrate-and-fire """ - def __init__(self, - size: Shape, - V_rest: Parameter = -65., - V_reset: Parameter = -68., - V_th: Parameter = -30., - V_T: Parameter = -59.9, - delta_T: Parameter = 3.48, - R: Parameter = 1., - tau: Parameter = 10., - tau_ref: Parameter = 1.7, - method: str = 'exp_auto', - name: str = None): + def __init__( + self, + size: Shape, + V_rest: Parameter = -65., + V_reset: Parameter = -68., + V_th: Parameter = -30., + V_T: Parameter = -59.9, + delta_T: Parameter = 3.48, + R: Parameter = 1., + tau: Parameter = 10., + tau_ref: Parameter = 1.7, + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): # initialize super(ExpIF, self).__init__(size=size, name=name) @@ -241,11 +252,11 @@ def __init__(self, self.tau_ref = tau_ref # variables - self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) - # variables - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) + self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # integral @@ -302,7 +313,7 @@ class AdExIF(NeuGroup): **Model Examples** - - `Examples for different firing patterns `_ + - `Examples for different firing patterns `_ **Model Parameters** @@ -341,8 +352,24 @@ class AdExIF(NeuGroup): .. [2] http://www.scholarpedia.org/article/Adaptive_exponential_integrate-and-fire_model """ - def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_T=-59.9, delta_T=3.48, a=1., - b=1., tau=10., tau_w=30., R=1., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + V_rest: Parameter = -65., + V_reset: Parameter = -68., + V_th: Parameter = -30., + V_T: Parameter = -59.9, + delta_T: Parameter = 3.48, + a: Parameter = 1., + b: Parameter = 1., + tau: Parameter = 10., + tau_w: Parameter = 30., + R: Parameter = 1., + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + w_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): super(AdExIF, self).__init__(size=size, name=name) # parameters @@ -358,9 +385,11 @@ def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_T=-59.9, delta_ self.R = R # variables - self.w = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + check_initializer(w_initializer, 'w_initializer') + self.V = bm.Variable(init_param(V_initializer, (self.num,))) + self.w = bm.Variable(init_param(w_initializer, (self.num,))) self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) - self.V = bm.Variable(bm.zeros(self.num)) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -458,8 +487,21 @@ class QuaIF(NeuGroup): J. Neurophysiology 83, pp. 808–827. """ - def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, c=.07, - R=1., tau=10., tau_ref=0., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + V_rest: Parameter = -65., + V_reset: Parameter = -68., + V_th: Parameter = -30., + V_c: Parameter = -50.0, + c: Parameter = .07, + R: Parameter = 1., + tau: Parameter = 10., + tau_ref: Parameter = 0., + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): # initialization super(QuaIF, self).__init__(size=size, name=name) @@ -474,11 +516,10 @@ def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, c=.07, self.tau_ref = tau_ref # variables - self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) - # variables - self.V = bm.Variable(bm.zeros(self.num)) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) + self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # integral @@ -577,8 +618,23 @@ class AdQuaIF(NeuGroup): Mathematics 68, no. 4 (2008): 1045-1079. """ - def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, a=1., b=.1, - c=.07, tau=10., tau_w=10., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + V_rest: Parameter = -65., + V_reset: Parameter = -68., + V_th: Parameter = -30., + V_c: Parameter = -50.0, + a: Parameter = 1., + b: Parameter = .1, + c: Parameter = .07, + tau: Parameter = 10., + tau_w: Parameter = 10., + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + w_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): super(AdQuaIF, self).__init__(size=size, name=name) # parameters @@ -593,8 +649,10 @@ def __init__(self, size, V_rest=-65., V_reset=-68., V_th=-30., V_c=-50.0, a=1., self.tau_w = tau_w # variables - self.V = bm.Variable(bm.zeros(self.num)) - self.w = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + check_initializer(w_initializer, 'w_initializer') + self.V = bm.Variable(init_param(V_initializer, (self.num,))) + self.w = bm.Variable(init_param(w_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -707,9 +765,30 @@ class GIF(NeuGroup): Nature communications 9, no. 1 (2018): 1-15. """ - def __init__(self, size, V_rest=-70., V_reset=-70., V_th_inf=-50., V_th_reset=-60., - R=20., tau=20., a=0., b=0.01, k1=0.2, k2=0.02, R1=0., R2=1., A1=0., - A2=0., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + V_rest: Parameter = -70., + V_reset: Parameter = -70., + V_th_inf: Parameter = -50., + V_th_reset: Parameter = -60., + R: Parameter = 20., + tau: Parameter = 20., + a: Parameter = 0., + b: Parameter = 0.01, + k1: Parameter = 0.2, + k2: Parameter = 0.02, + R1: Parameter = 0., + R2: Parameter = 1., + A1: Parameter = 0., + A2: Parameter = 0., + V_initializer: Union[Initializer, Callable, Tensor] = OneInit(-70.), + I1_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + I2_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + Vth_initializer: Union[Initializer, Callable, Tensor] = OneInit(-50.), + method: str = 'exp_auto', + name: str = None + ): # initialization super(GIF, self).__init__(size=size, name=name) @@ -730,10 +809,14 @@ def __init__(self, size, V_rest=-70., V_reset=-70., V_th_inf=-50., V_th_reset=-6 self.A2 = A2 # variables - self.I1 = bm.Variable(bm.zeros(self.num)) - self.I2 = bm.Variable(bm.zeros(self.num)) - self.V_th = bm.Variable(bm.ones(self.num) * -50.) - self.V = bm.Variable(bm.zeros(self.num) - 70.) + check_initializer(V_initializer, 'V_initializer') + check_initializer(I1_initializer, 'I1_initializer') + check_initializer(I2_initializer, 'I2_initializer') + check_initializer(Vth_initializer, 'Vth_initializer') + self.I1 = bm.Variable(init_param(I1_initializer, (self.num,))) + self.I2 = bm.Variable(init_param(I2_initializer, (self.num,))) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) + self.V_th = bm.Variable(init_param(Vth_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -841,8 +924,20 @@ class Izhikevich(NeuGroup): IEEE transactions on neural networks 15.5 (2004): 1063-1070. """ - def __init__(self, size, a=0.02, b=0.20, c=-65., d=8., tau_ref=0., - V_th=30., method='exp_auto', name=None): + def __init__( + self, + size: Shape, + a: Parameter = 0.02, + b: Parameter = 0.20, + c: Parameter = -65., + d: Parameter = 8., + tau_ref: Parameter = 0., + V_th: Parameter = 30., + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + u_initializer: Union[Initializer, Callable, Tensor] = OneInit(), + method: str = 'exp_auto', + name: str = None + ): # initialization super(Izhikevich, self).__init__(size=size, name=name) @@ -855,11 +950,13 @@ def __init__(self, size, a=0.02, b=0.20, c=-65., d=8., tau_ref=0., self.tau_ref = tau_ref # variables - self.u = bm.Variable(bm.ones(self.num)) - self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + check_initializer(u_initializer, 'u_initializer') + self.u = bm.Variable(init_param(u_initializer, (self.num,))) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) + self.refractory = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) # functions @@ -984,8 +1081,23 @@ class HindmarshRose(NeuGroup): 033128. """ - def __init__(self, size, a=1., b=3., c=1., d=5., r=0.01, s=4., V_rest=-1.6, - V_th=1.0, method='exp_auto', name=None): + def __init__( + self, + size: Shape, + a: Parameter = 1., + b: Parameter = 3., + c: Parameter = 1., + d: Parameter = 5., + r: Parameter = 0.01, + s: Parameter = 4., + V_rest: Parameter = -1.6, + V_th: Parameter = 1.0, + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + y_initializer: Union[Initializer, Callable, Tensor] = OneInit(-10.), + z_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): # initialization super(HindmarshRose, self).__init__(size=size, name=name) @@ -1000,9 +1112,12 @@ def __init__(self, size, a=1., b=3., c=1., d=5., r=0.01, s=4., V_rest=-1.6, self.V_rest = V_rest # variables - self.z = bm.Variable(bm.zeros(self.num)) - self.y = bm.Variable(bm.ones(self.num) * -10.) - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + check_initializer(y_initializer, 'y_initializer') + check_initializer(z_initializer, 'z_initializer') + self.z = bm.Variable(init_param(V_initializer, (self.num,))) + self.y = bm.Variable(init_param(y_initializer, (self.num,))) + self.V = bm.Variable(init_param(z_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) @@ -1116,14 +1231,18 @@ class FHN(NeuGroup): """ - def __init__(self, - size: Shape, - a: Parameter = 0.7, - b: Parameter = 0.8, - tau: Parameter = 12.5, - Vth: Parameter = 1.8, - method: str = 'exp_auto', - name: str = None): + def __init__( + self, + size: Shape, + a: Parameter = 0.7, + b: Parameter = 0.8, + tau: Parameter = 12.5, + Vth: Parameter = 1.8, + V_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + w_initializer: Union[Initializer, Callable, Tensor] = ZeroInit(), + method: str = 'exp_auto', + name: str = None + ): # initialization super(FHN, self).__init__(size=size, name=name) @@ -1134,8 +1253,10 @@ def __init__(self, self.Vth = Vth # variables - self.w = bm.Variable(bm.zeros(self.num)) - self.V = bm.Variable(bm.zeros(self.num)) + check_initializer(V_initializer, 'V_initializer') + check_initializer(w_initializer, 'w_initializer') + self.w = bm.Variable(init_param(w_initializer, (self.num,))) + self.V = bm.Variable(init_param(V_initializer, (self.num,))) self.input = bm.Variable(bm.zeros(self.num)) self.spike = bm.Variable(bm.zeros(self.num, dtype=bool)) self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7) diff --git a/brainpy/dyn/synapses/abstract_models.py b/brainpy/dyn/synapses/abstract_models.py index 10a28d97d..39e54bd3f 100644 --- a/brainpy/dyn/synapses/abstract_models.py +++ b/brainpy/dyn/synapses/abstract_models.py @@ -1,9 +1,10 @@ # -*- coding: utf-8 -*- import brainpy.math as bm +from brainpy.dyn.base import NeuGroup +from brainpy.dyn.base import TwoEndConn, ConstantDelay from brainpy.integrators.joint_eq import JointEq from brainpy.integrators.ode import odeint -from brainpy.dyn.base import TwoEndConn, ConstantDelay __all__ = [ 'DeltaSynapse', @@ -67,8 +68,17 @@ class DeltaSynapse(TwoEndConn): """ - def __init__(self, pre, post, conn, delay=0., post_has_ref=False, w=1., - post_key='V', name=None): + def __init__( + self, + pre: NeuGroup, + post: NeuGroup, + conn, + delay=0., + post_has_ref=False, + w=1., + post_key='V', + name=None + ): super(DeltaSynapse, self).__init__(pre=pre, post=post, conn=conn, name=name) self.check_pre_attrs('spike') self.check_post_attrs(post_key) @@ -193,8 +203,17 @@ class ExpCUBA(TwoEndConn): Cambridge: Cambridge UP, 2011. 172-95. Print. """ - def __init__(self, pre, post, conn, g_max=1., delay=0., tau=8.0, - method='exp_auto', name=None): + def __init__( + self, + pre: NeuGroup, + post: NeuGroup, + conn, + g_max=1., + delay=0., + tau=8.0, + method='exp_auto', + name=None + ): super(ExpCUBA, self).__init__(pre=pre, post=post, conn=conn, name=name) self.check_pre_attrs('spike') self.check_post_attrs('input', 'V') diff --git a/brainpy/dyn/synapses/delay_coupling.py b/brainpy/dyn/synapses/delay_coupling.py index 826255ca8..06fdd2202 100644 --- a/brainpy/dyn/synapses/delay_coupling.py +++ b/brainpy/dyn/synapses/delay_coupling.py @@ -1,7 +1,9 @@ # -*- coding: utf-8 -*- from typing import Optional, Union, Sequence, Dict, List + from jax import vmap + import brainpy.math as bm from brainpy.dyn.base import TwoEndConn from brainpy.initialize import Initializer, ZeroInit @@ -37,20 +39,21 @@ class DelayCoupling(TwoEndConn): """ - """Global delay variables. Useful when the same target variable is used in multiple mappings.""" global_delay_vars: Dict[str, bm.LengthDelay] = dict() - def __init__(self, - pre, - post, - from_to: Union[str, Sequence[str]], - conn_mat: Tensor, - delay_mat: Optional[Tensor] = None, - delay_initializer: Initializer = ZeroInit(), - domain: str = 'local', - name: str = None): + def __init__( + self, + pre, + post, + from_to: Union[str, Sequence[str]], + conn_mat: Tensor, + delay_mat: Optional[Tensor] = None, + delay_initializer: Initializer = ZeroInit(), + domain: str = 'local', + name: str = None + ): super(DelayCoupling, self).__init__(pre, post, name=name) # local delay variables From 69a2466e17cdfe7ae0b54bbb437cb582bde800be Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 12:07:59 +0800 Subject: [PATCH 16/22] feat: remove 'brainpy.nn.init_param' to 'brainpy.init.init_param' --- brainpy/initialize/__init__.py | 1 + brainpy/initialize/generic.py | 46 +++++++++++++++++++++++ brainpy/initialize/random_inits.py | 15 ++++---- brainpy/nn/nodes/ANN/conv.py | 3 +- brainpy/nn/nodes/ANN/rnn_cells.py | 3 +- brainpy/nn/nodes/RC/reservoir.py | 3 +- brainpy/nn/nodes/base/dense.py | 3 +- brainpy/nn/utils.py | 26 +++++-------- examples/analysis/highdim_RNN_Analysis.py | 6 +-- examples/training/Song_2016_EI_RNN.py | 6 +-- 10 files changed, 73 insertions(+), 39 deletions(-) create mode 100644 brainpy/initialize/generic.py diff --git a/brainpy/initialize/__init__.py b/brainpy/initialize/__init__.py index 3998d9ae0..47d87c374 100644 --- a/brainpy/initialize/__init__.py +++ b/brainpy/initialize/__init__.py @@ -6,6 +6,7 @@ """ from .base import * +from .generic import * from .random_inits import * from .regular_inits import * from .decay_inits import * diff --git a/brainpy/initialize/generic.py b/brainpy/initialize/generic.py new file mode 100644 index 000000000..62f5240d0 --- /dev/null +++ b/brainpy/initialize/generic.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- + +from typing import Union, Callable + +import jax.numpy as jnp +import numpy as onp + +import brainpy.math as bm +from brainpy.tools.others import to_size +from brainpy.types import Shape +from .base import Initializer + +__all__ = [ + 'init_param', +] + + +def init_param(param: Union[Callable, Initializer, bm.ndarray, jnp.ndarray], + size: Shape): + """Initialize parameters. + + Parameters + ---------- + param: callable, Initializer, bm.ndarray, jnp.ndarray + The initialization of the parameter. + - If it is None, the created parameter will be None. + - If it is a callable function :math:`f`, the ``f(size)`` will be returned. + - If it is an instance of :py:class:`brainpy.init.Initializer``, the ``f(size)`` will be returned. + - If it is a tensor, then this function check whether ``tensor.shape`` is equal to the given ``size``. + size: int, sequence of int + The shape of the parameter. + """ + size = to_size(size) + if param is None: + return None + elif callable(param): + param = param(size) + elif isinstance(param, (onp.ndarray, jnp.ndarray)): + param = bm.asarray(param) + elif isinstance(param, (bm.JaxArray,)): + param = param + else: + raise ValueError(f'Unknown param type {type(param)}: {param}') + assert param.shape == size, f'"param.shape" is not the required size {size}' + return param + diff --git a/brainpy/initialize/random_inits.py b/brainpy/initialize/random_inits.py index 9ea1ad482..821c35acf 100644 --- a/brainpy/initialize/random_inits.py +++ b/brainpy/initialize/random_inits.py @@ -40,7 +40,7 @@ class Normal(InterLayerInitializer): def __init__(self, scale=1., seed=None): super(Normal, self).__init__() self.scale = scale - self.rng = bm.random.RandomState(seed=seed) + self.rng = np.random.RandomState(seed=seed) def __call__(self, shape, dtype=None): shape = [tools.size2num(d) for d in shape] @@ -64,7 +64,7 @@ def __init__(self, min_val=0., max_val=1., seed=None): super(Uniform, self).__init__() self.min_val = min_val self.max_val = max_val - self.rng = bm.random.RandomState(seed=seed) + self.rng = np.random.RandomState(seed=seed) def __call__(self, shape, dtype=None): shape = [tools.size2num(d) for d in shape] @@ -79,7 +79,7 @@ def __init__(self, scale, mode, distribution, in_axis=-2, out_axis=-1, seed=None self.in_axis = in_axis self.out_axis = out_axis self.distribution = distribution - self.rng = bm.random.RandomState(seed=seed) + self.rng = np.random.RandomState(seed=seed) def __call__(self, shape, dtype=None): shape = [tools.size2num(d) for d in shape] @@ -94,18 +94,17 @@ def __call__(self, shape, dtype=None): raise ValueError("invalid mode for variance scaling initializer: {}".format(self.mode)) variance = bm.array(self.scale / denominator, dtype=dtype) if self.distribution == "truncated_normal": + from scipy.stats import truncnorm # constant is stddev of standard normal truncated to (-2, 2) stddev = bm.sqrt(variance) / bm.array(.87962566103423978, dtype) - res = self.rng.truncated_normal(-2, 2, shape) * stddev - return bm.asarray(res, dtype=dtype) + res = truncnorm(-2, 2).rvs(shape) * stddev elif self.distribution == "normal": res = self.rng.normal(size=shape) * bm.sqrt(variance) - return bm.asarray(res, dtype=dtype) elif self.distribution == "uniform": res = self.rng.uniform(low=-1, high=1, size=shape) * bm.sqrt(3 * variance) - return bm.asarray(res, dtype=dtype) else: raise ValueError("invalid distribution for variance scaling initializer") + return bm.asarray(res, dtype=dtype) class KaimingUniform(VarianceScaling): @@ -180,7 +179,7 @@ def __init__(self, scale=1., axis=-1, seed=None): super(Orthogonal, self).__init__() self.scale = scale self.axis = axis - self.rng = bm.random.RandomState(seed=seed) + self.rng = np.random.RandomState(seed=seed) def __call__(self, shape, dtype=None): shape = [tools.size2num(d) for d in shape] diff --git a/brainpy/nn/nodes/ANN/conv.py b/brainpy/nn/nodes/ANN/conv.py index 84a77c9bf..85c378a6c 100644 --- a/brainpy/nn/nodes/ANN/conv.py +++ b/brainpy/nn/nodes/ANN/conv.py @@ -4,9 +4,8 @@ import jax.lax import brainpy.math as bm -from brainpy.initialize import XavierNormal, ZeroInit +from brainpy.initialize import XavierNormal, ZeroInit, init_param from brainpy.nn.base import Node -from brainpy.nn.utils import init_param __all__ = [ 'Conv2D', diff --git a/brainpy/nn/nodes/ANN/rnn_cells.py b/brainpy/nn/nodes/ANN/rnn_cells.py index ef1d20acd..b8f6de2e3 100644 --- a/brainpy/nn/nodes/ANN/rnn_cells.py +++ b/brainpy/nn/nodes/ANN/rnn_cells.py @@ -3,9 +3,8 @@ import brainpy.math as bm from brainpy.initialize import (XavierNormal, ZeroInit, - Uniform, Orthogonal) + Uniform, Orthogonal, init_param) from brainpy.nn.base import RecurrentNode -from brainpy.nn.utils import init_param from brainpy.tools.checking import (check_integer, check_initializer, check_shape_consistency) diff --git a/brainpy/nn/nodes/RC/reservoir.py b/brainpy/nn/nodes/RC/reservoir.py index c137501ab..782331428 100644 --- a/brainpy/nn/nodes/RC/reservoir.py +++ b/brainpy/nn/nodes/RC/reservoir.py @@ -3,9 +3,8 @@ from typing import Optional, Union, Callable import brainpy.math as bm -from brainpy.initialize import Normal, ZeroInit, Initializer +from brainpy.initialize import Normal, ZeroInit, Initializer, init_param from brainpy.nn.base import RecurrentNode -from brainpy.nn.utils import init_param from brainpy.tools.checking import (check_shape_consistency, check_float, check_initializer, diff --git a/brainpy/nn/nodes/base/dense.py b/brainpy/nn/nodes/base/dense.py index 0f8ea2067..1d28aa301 100644 --- a/brainpy/nn/nodes/base/dense.py +++ b/brainpy/nn/nodes/base/dense.py @@ -7,9 +7,8 @@ from brainpy import math as bm from brainpy.errors import UnsupportedError, MathError -from brainpy.initialize import XavierNormal, ZeroInit, Initializer +from brainpy.initialize import XavierNormal, ZeroInit, Initializer, init_param from brainpy.nn.base import Node -from brainpy.nn.utils import init_param from brainpy.tools.checking import (check_shape_consistency, check_initializer) from brainpy.types import Tensor diff --git a/brainpy/nn/utils.py b/brainpy/nn/utils.py index 307e10cba..a767088db 100644 --- a/brainpy/nn/utils.py +++ b/brainpy/nn/utils.py @@ -1,17 +1,15 @@ # -*- coding: utf-8 -*- +import warnings from typing import Union, Sequence, Dict, Any, Callable, Optional import jax.numpy as jnp -import numpy as onp import brainpy.math as bm -from brainpy.initialize import Initializer +from brainpy.initialize import Initializer, init_param as true_init_param from brainpy.tools.checking import check_dict_data -from brainpy.tools.others import to_size from brainpy.types import Tensor, Shape - __all__ = [ 'tensor_sum', 'init_param', @@ -40,6 +38,9 @@ def init_param(param: Union[Callable, Initializer, bm.ndarray, jnp.ndarray], size: Shape): """Initialize parameters. + .. deprecated:: 2.1.2 + Please use "brainpy.init.init_param" instead. + Parameters ---------- param: callable, Initializer, bm.ndarray, jnp.ndarray @@ -51,19 +52,10 @@ def init_param(param: Union[Callable, Initializer, bm.ndarray, jnp.ndarray], size: int, sequence of int The shape of the parameter. """ - size = to_size(size) - if param is None: - return None - elif callable(param): - param = param(size) - elif isinstance(param, (onp.ndarray, jnp.ndarray)): - param = bm.asarray(param) - elif isinstance(param, (bm.JaxArray,)): - param = param - else: - raise ValueError(f'Unknown param type {type(param)}: {param}') - assert param.shape == size, f'"param.shape" is not the required size {size}' - return param + warnings.warn('Please use "brainpy.init.init_param" instead. ' + '"brainpy.nn.init_param" is deprecated since version 2.1.2. ', + DeprecationWarning) + return true_init_param(param, size) def check_rnn_data_batch_size(data: Dict, num_batch=None): diff --git a/examples/analysis/highdim_RNN_Analysis.py b/examples/analysis/highdim_RNN_Analysis.py index d5d309874..896eb9dc0 100644 --- a/examples/analysis/highdim_RNN_Analysis.py +++ b/examples/analysis/highdim_RNN_Analysis.py @@ -89,15 +89,15 @@ def __init__(self, num_input, num_hidden, num_output, num_batch, dt=None, seed=N self.rng = bm.random.RandomState(seed=seed) # input weight - self.w_ir = bm.TrainVar(bp.nn.init_param(w_ir, (num_input, num_hidden))) + self.w_ir = bm.TrainVar(bp.init.init_param(w_ir, (num_input, num_hidden))) # recurrent weight bound = 1 / num_hidden ** 0.5 - self.w_rr = bm.TrainVar(bp.nn.init_param(w_rr, (num_hidden, num_hidden))) + self.w_rr = bm.TrainVar(bp.init.init_param(w_rr, (num_hidden, num_hidden))) self.b_rr = bm.TrainVar(self.rng.uniform(-bound, bound, num_hidden)) # readout weight - self.w_ro = bm.TrainVar(bp.nn.init_param(w_ro, (num_hidden, num_output))) + self.w_ro = bm.TrainVar(bp.init.init_param(w_ro, (num_hidden, num_output))) self.b_ro = bm.TrainVar(self.rng.uniform(-bound, bound, num_output)) # variables diff --git a/examples/training/Song_2016_EI_RNN.py b/examples/training/Song_2016_EI_RNN.py index 602f1fedd..4c2cb29cf 100644 --- a/examples/training/Song_2016_EI_RNN.py +++ b/examples/training/Song_2016_EI_RNN.py @@ -128,17 +128,17 @@ def __init__(self, num_input, num_hidden, num_output, num_batch, self.mask = bm.asarray(mask, dtype=bm.float_) # input weight - self.w_ir = bm.TrainVar(bp.nn.init_param(w_ir, (num_input, num_hidden))) + self.w_ir = bm.TrainVar(bp.init.init_param(w_ir, (num_input, num_hidden))) # recurrent weight bound = 1 / num_hidden ** 0.5 - self.w_rr = bm.TrainVar(bp.nn.init_param(w_rr, (num_hidden, num_hidden))) + self.w_rr = bm.TrainVar(bp.init.init_param(w_rr, (num_hidden, num_hidden))) self.w_rr[:, :self.e_size] /= (self.e_size / self.i_size) self.b_rr = bm.TrainVar(self.rng.uniform(-bound, bound, num_hidden)) # readout weight bound = 1 / self.e_size ** 0.5 - self.w_ro = bm.TrainVar(bp.nn.init_param(w_ro, (self.e_size, num_output))) + self.w_ro = bm.TrainVar(bp.init.init_param(w_ro, (self.e_size, num_output))) self.b_ro = bm.TrainVar(self.rng.uniform(-bound, bound, num_output)) # variables From fabc507438a60c70058e65e9950417d796050526 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 12:10:56 +0800 Subject: [PATCH 17/22] compat behavior for brainpy.math.TimeDelay --- README.md | 27 ++++++++++++++++++++++++++- brainpy/datasets/chaotic_systems.py | 2 +- brainpy/integrators/runner.py | 2 +- brainpy/math/compat/__init__.py | 4 +++- 4 files changed, 31 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 15a6b8dbb..906c186d4 100644 --- a/README.md +++ b/README.md @@ -150,7 +150,7 @@ runner.run(100.) Numerical methods for delay differential equations (SDEs). ```python -xdelay = bm.TimeDelay(1, delay_len=1., before_t0=1., dt=0.01) +xdelay = bm.TimeDelay(bm.zeros(1), delay_len=1., before_t0=1., dt=0.01) @bp.ddeint(method='rk4', state_delays={'x': xdelay}) @@ -191,6 +191,31 @@ runner = bp.dyn.DSRunner(net) runner(100.) ``` +Simulating a whole brain network by using rate models. + +```python +import numpy as np + +class WholeBrainNet(bp.dyn.Network): + def __init__(self, signal_speed=20.): + super(WholeBrainNet, self).__init__() + + self.fhn = bp.dyn.RateFHN(80, x_ou_sigma=0.01, y_ou_sigma=0.01, name='fhn') + self.syn = bp.dyn.DiffusiveDelayCoupling(self.fhn, self.fhn, + 'x->input', + conn_mat=conn_mat, + delay_mat=delay_mat) + + def update(self, _t, _dt): + self.syn.update(_t, _dt) + self.fhn.update(_t, _dt) + + +net = WholeBrainNet() +runner = bp.dyn.DSRunner(net, monitors=['fhn.x'], inputs=['fhn.input', 0.72]) +runner.run(6e3) +``` + ### 4. Dynamics training level diff --git a/brainpy/datasets/chaotic_systems.py b/brainpy/datasets/chaotic_systems.py index 9da48420a..98885a68b 100644 --- a/brainpy/datasets/chaotic_systems.py +++ b/brainpy/datasets/chaotic_systems.py @@ -167,7 +167,7 @@ def mackey_glass_series(duration, dt=0.1, beta=2., gamma=1., tau=2., n=9.65, assert isinstance(inits, (bm.ndarray, jnp.ndarray)) rng = bm.random.RandomState(seed) - xdelay = bm.TimeDelay(inits.shape, tau, dt=dt) + xdelay = bm.TimeDelay(inits, tau, dt=dt) xdelay.data = inits + 0.2 * (rng.random((xdelay.num_delay_step,) + inits.shape) - 0.5) @ddeint(method=method, state_delays={'x': xdelay}) diff --git a/brainpy/integrators/runner.py b/brainpy/integrators/runner.py index 39239e481..f38ca8f5e 100644 --- a/brainpy/integrators/runner.py +++ b/brainpy/integrators/runner.py @@ -93,7 +93,7 @@ class IntegratorRunner(Runner): >>> dt = 0.01; beta=2.; gamma=1.; tau=2.; n=9.65 >>> mg_eq = lambda x, t, xdelay: (beta * xdelay(t - tau) / (1 + xdelay(t - tau) ** n) >>> - gamma * x) - >>> xdelay = bm.TimeDelay(1, delay_len=tau, dt=dt, before_t0=lambda t: 1.2) + >>> xdelay = bm.TimeDelay(bm.asarray([1.2]), delay_len=tau, dt=dt, before_t0=lambda t: 1.2) >>> integral = bp.ddeint(mg_eq, method='rk4', state_delays={'x': xdelay}) >>> runner = bp.integrators.IntegratorRunner( >>> integral, diff --git a/brainpy/math/compat/__init__.py b/brainpy/math/compat/__init__.py index 8559e955e..727f41eab 100644 --- a/brainpy/math/compat/__init__.py +++ b/brainpy/math/compat/__init__.py @@ -1,8 +1,10 @@ # -*- coding: utf-8 -*- __all__ = [ - 'optimizers', 'losses' + 'optimizers', 'losses', + 'FixedLenDelay', ] from . import optimizers, losses +from .delay_vars import * From 28d2d2815e1e04bc34f181c9185138fd15a5f964 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 13:50:38 +0800 Subject: [PATCH 18/22] fix: fix nn bugs --- brainpy/nn/base.py | 17 +++--- brainpy/nn/nodes/ANN/rnn_cells.py | 43 ++++++++------- brainpy/nn/nodes/RC/nvar.py | 2 +- brainpy/nn/runners/ridge_regression.py | 4 +- .../Gauthier_2021_ngrc_double_scroll.py | 4 +- examples/training/echo_state_network.py | 52 +++++++++---------- 6 files changed, 66 insertions(+), 56 deletions(-) diff --git a/brainpy/nn/base.py b/brainpy/nn/base.py index adf4b781d..36a3c8d55 100644 --- a/brainpy/nn/base.py +++ b/brainpy/nn/base.py @@ -308,11 +308,11 @@ def set_feedforward_shapes(self, feedforward_shapes: Dict): if self.feedforward_shapes is not None: for key, size in self._feedforward_shapes.items(): if key not in feedforward_shapes: - raise ValueError(f"Impossible to reset the input data of {self.name}. " + raise ValueError(f"Impossible to reset the input shape of {self.name}. " f"Because this Node has the input dimension {size} from {key}. " f"While we do not find it in the given feedforward_shapes") if not check_batch_shape(size, feedforward_shapes[key], mode='bool'): - raise ValueError(f"Impossible to reset the input data of {self.name}. " + raise ValueError(f"Impossible to reset the input shape of {self.name}. " f"Because this Node has the input dimension {size} from {key}. " f"While the give shape is {feedforward_shapes[key]}") @@ -1014,7 +1014,7 @@ def initialize(self, num_batch: int): fb_sizes = dict() for sender in self.fb_senders.keys(): fb_sizes[sender] = sender.output_shape - self.set_feedforward_shapes(fb_sizes) + self.set_feedback_shapes(fb_sizes) # feedback initialization if self.feedback_shapes is not None: @@ -1234,7 +1234,7 @@ def plot_node_graph(self, fig_size: tuple = (10, 10), node_size: int = 2000, arrow_size: int = 20, - layout='spectral_layout'): + layout='shell_layout'): """Plot the node graph based on NetworkX package Parameters @@ -1346,10 +1346,12 @@ def plot_node_graph(self, proxie = [] labels = [] if len(nodes_trainable): - proxie.append(Line2D([], [], color='white', marker='o', markerfacecolor=trainable_color)) + proxie.append(Line2D([], [], color='white', marker='o', + markerfacecolor=trainable_color)) labels.append('Trainable') if len(nodes_untrainable): - proxie.append(Line2D([], [], color='white', marker='o', markerfacecolor=untrainable_color)) + proxie.append(Line2D([], [], color='white', marker='o', + markerfacecolor=untrainable_color)) labels.append('Untrainable') if len(ff_edges): proxie.append(Line2D([], [], color=ff_color, linewidth=2)) @@ -1361,8 +1363,7 @@ def plot_node_graph(self, proxie.append(Line2D([], [], color=rec_color, linewidth=2)) labels.append('Recurrent') - plt.legend(proxie, labels, scatterpoints=1, markerscale=2, - loc='best') + plt.legend(proxie, labels, scatterpoints=1, markerscale=2, loc='best') plt.tight_layout() plt.show() diff --git a/brainpy/nn/nodes/ANN/rnn_cells.py b/brainpy/nn/nodes/ANN/rnn_cells.py index b8f6de2e3..3d5683b1c 100644 --- a/brainpy/nn/nodes/ANN/rnn_cells.py +++ b/brainpy/nn/nodes/ANN/rnn_cells.py @@ -1,13 +1,20 @@ # -*- coding: utf-8 -*- +from typing import Union, Callable + import brainpy.math as bm -from brainpy.initialize import (XavierNormal, ZeroInit, - Uniform, Orthogonal, init_param) +from brainpy.initialize import (XavierNormal, + ZeroInit, + Uniform, + Orthogonal, + init_param, + Initializer) from brainpy.nn.base import RecurrentNode from brainpy.tools.checking import (check_integer, check_initializer, check_shape_consistency) +from brainpy.types import Tensor __all__ = [ 'VanillaRNN', @@ -32,12 +39,12 @@ class VanillaRNN(RecurrentNode): def __init__( self, num_unit: int, - state_initializer=Uniform(), - wi_initializer=XavierNormal(), - wh_initializer=XavierNormal(), - bias_initializer=ZeroInit(), - activation='relu', - trainable=True, + state_initializer: Union[Tensor, Callable, Initializer] = Uniform(), + wi_initializer: Union[Tensor, Callable, Initializer] = XavierNormal(), + wh_initializer: Union[Tensor, Callable, Initializer] = XavierNormal(), + bias_initializer: Union[Tensor, Callable, Initializer] = ZeroInit(), + activation: str = 'relu', + trainable: bool = True, **kwargs ): super(VanillaRNN, self).__init__(trainable=trainable, **kwargs) @@ -129,11 +136,11 @@ class GRU(RecurrentNode): def __init__( self, num_unit: int, - wi_initializer=Orthogonal(), - wh_initializer=Orthogonal(), - bias_initializer=ZeroInit(), - state_initializer=ZeroInit(), - trainable=True, + wi_initializer: Union[Tensor, Callable, Initializer] = Orthogonal(), + wh_initializer: Union[Tensor, Callable, Initializer] = Orthogonal(), + bias_initializer: Union[Tensor, Callable, Initializer] = ZeroInit(), + state_initializer: Union[Tensor, Callable, Initializer] = ZeroInit(), + trainable: bool = True, **kwargs ): super(GRU, self).__init__(trainable=trainable, **kwargs) @@ -244,11 +251,11 @@ class LSTM(RecurrentNode): def __init__( self, num_unit: int, - wi_initializer=XavierNormal(), - wh_initializer=XavierNormal(), - bias_initializer=ZeroInit(), - state_initializer=ZeroInit(), - trainable=True, + wi_initializer: Union[Tensor, Callable, Initializer] = XavierNormal(), + wh_initializer: Union[Tensor, Callable, Initializer] = XavierNormal(), + bias_initializer: Union[Tensor, Callable, Initializer] = ZeroInit(), + state_initializer: Union[Tensor, Callable, Initializer] = ZeroInit(), + trainable: bool = True, **kwargs ): super(LSTM, self).__init__(trainable=trainable, **kwargs) diff --git a/brainpy/nn/nodes/RC/nvar.py b/brainpy/nn/nodes/RC/nvar.py index 83d9546b0..142b84559 100644 --- a/brainpy/nn/nodes/RC/nvar.py +++ b/brainpy/nn/nodes/RC/nvar.py @@ -100,7 +100,7 @@ def init_ff_conn(self): # monomials. Precompute them to improve efficiency. for order in self.order: idx = np.array(list(combinations_with_replacement(np.arange(linear_dim), order))) - self.comb_ids = bm.asarray(idx) + self.comb_ids.append(bm.asarray(idx)) # number of non-linear components is (d + n - 1)! / (d - 1)! n! # i.e. number of all unique monomials of order n made from the # linear components. diff --git a/brainpy/nn/runners/ridge_regression.py b/brainpy/nn/runners/ridge_regression.py index 9c4b692c8..0f3715883 100644 --- a/brainpy/nn/runners/ridge_regression.py +++ b/brainpy/nn/runners/ridge_regression.py @@ -41,7 +41,7 @@ class RidgeTrainer(RNNTrainer): The target model. beta: float The regularization coefficient. - **kwargs: dict + **kwarg Other common parameters for :py:class:`brainpy.nn.RNNTrainer``. """ @@ -152,6 +152,8 @@ def f_train(self, shared_kwargs: Dict = None): return self._f_train[shared_kwargs_str] def _make_fit_func(self, shared_kwargs): + shared_kwargs = dict() if shared_kwargs is None else shared_kwargs + def train_func(monitor_data: Dict[str, Tensor], target_data: Dict[str, Tensor]): for node in self.train_nodes: ff = monitor_data[f'{node.name}.inputs'] diff --git a/examples/training/Gauthier_2021_ngrc_double_scroll.py b/examples/training/Gauthier_2021_ngrc_double_scroll.py index 33863c0c4..81343afc2 100644 --- a/examples/training/Gauthier_2021_ngrc_double_scroll.py +++ b/examples/training/Gauthier_2021_ngrc_double_scroll.py @@ -126,13 +126,13 @@ def plot_double_scroll(ground_truth, predictions): # -------- # # warm-up -trainer = bp.nn.RidgeTrainer(model, beta=1e-5) +trainer = bp.nn.RidgeTrainer(model, beta=1e-5, jit=True) # training outputs = trainer.predict(X_warmup) print('Warmup NMS: ', bp.losses.mean_squared_error(outputs, Y_warmup)) trainer.fit([X_train, {'readout': dX_train}]) -plot_weights(di.Wff.numpy(), di.bias.numpy(), r.comb_ids.numpy()) +plot_weights(di.Wff.numpy(), di.bias.numpy(), r.comb_ids[0].numpy()) # prediction model = bm.jit(model) diff --git a/examples/training/echo_state_network.py b/examples/training/echo_state_network.py index 0c1d0930d..a3935e63d 100644 --- a/examples/training/echo_state_network.py +++ b/examples/training/echo_state_network.py @@ -66,38 +66,38 @@ def ngrc(num_in=10, num_out=30): outputs = trainer.predict(X) print(outputs.shape) print(bp.losses.mean_absolute_error(outputs, Y)) - trainer.fit(X, Y) + trainer.fit([X, Y]) outputs = trainer.predict(X) print(bp.losses.mean_absolute_error(outputs, Y)) -def ngrc_bacth(num_in=10, num_out=30): - bp.base.clear_name_cache() - model = ( - bp.nn.Input(num_in) - >> - bp.nn.NVAR(delay=2, order=2, name='l1') - >> - bp.nn.Dense(num_out, weight_initializer=bp.init.Normal(0.1), trainable=True) - ) - batch_size = 10 - model.initialize(num_batch=batch_size) - - X = bm.random.random((batch_size, 200, num_in)) - Y = bm.random.random((batch_size, 200, num_out)) - trainer = bp.nn.RidgeTrainer(model, beta=1e-6) - outputs = trainer.predict(X) - # print() - # print(trainer.mon['l1.output'].shape) - print(bp.losses.mean_absolute_error(outputs, Y)) - trainer.fit(X, Y) - outputs = trainer.predict(X) - print(bp.losses.mean_absolute_error(outputs, Y)) +# def ngrc_bacth(num_in=10, num_out=30): +# bp.base.clear_name_cache() +# model = ( +# bp.nn.Input(num_in) +# >> +# bp.nn.NVAR(delay=2, order=2, name='l1') +# >> +# bp.nn.Dense(num_out, weight_initializer=bp.init.Normal(0.1), trainable=True) +# ) +# batch_size = 10 +# model.initialize(num_batch=batch_size) +# +# X = bm.random.random((batch_size, 200, num_in)) +# Y = bm.random.random((batch_size, 200, num_out)) +# trainer = bp.nn.RidgeTrainer(model, beta=1e-6) +# outputs = trainer.predict(X) +# # print() +# # print(trainer.mon['l1.output'].shape) +# print(bp.losses.mean_absolute_error(outputs, Y)) +# trainer.fit([X, Y]) +# outputs = trainer.predict(X) +# print(bp.losses.mean_absolute_error(outputs, Y)) if __name__ == '__main__': - # print('ESN') - # esn(10, 30) + print('ESN') + esn(10, 30) print('NGRC') ngrc(10, 30) - ngrc_bacth() + # ngrc_bacth() From 079eb8f384e0239767627d78f3724c8b050506f5 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 14:04:47 +0800 Subject: [PATCH 19/22] changes: "opt_setting" -> "optimizer" --- brainpy/analysis/highdim/slow_points.py | 51 ++++++++++++------- examples/analysis/2d_decision_making_model.py | 3 +- examples/analysis/highdim_CANN.py | 4 +- examples/analysis/highdim_RNN_Analysis.py | 5 +- examples/analysis/highdim_gj_coupled_fhn.py | 3 +- 5 files changed, 39 insertions(+), 27 deletions(-) diff --git a/brainpy/analysis/highdim/slow_points.py b/brainpy/analysis/highdim/slow_points.py index 57c581140..4b865b0af 100644 --- a/brainpy/analysis/highdim/slow_points.py +++ b/brainpy/analysis/highdim/slow_points.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- -import inspect import time +import warnings from functools import partial import jax.numpy @@ -9,9 +9,9 @@ from jax.scipy.optimize import minimize import brainpy.math as bm +from brainpy import optimizers as optim from brainpy.analysis import utils from brainpy.errors import AnalyzerError -from brainpy import optimizers as optim __all__ = [ 'SlowPointFinder', @@ -87,8 +87,13 @@ def selected_ids(self): """The selected ids of candidate points.""" return self._selected_ids - def find_fps_with_gd_method(self, candidates, tolerance=1e-5, num_batch=100, - num_opt=10000, opt_setting=None): + def find_fps_with_gd_method(self, + candidates, + tolerance=1e-5, + num_batch=100, + num_opt=10000, + optimizer=None, + opt_setting=None): """Optimize fixed points with gradient descent methods. Parameters @@ -104,17 +109,30 @@ def find_fps_with_gd_method(self, candidates, tolerance=1e-5, num_batch=100, Print training information during optimization every so often. opt_setting: optional, dict The optimization settings. + + .. deprecated:: 2.1.2 + Use "optimizer" to set optimization method instead. + + optimizer: optim.Optimizer + The optimizer instance. + + .. versionadded:: 2.1.2 """ # optimization settings if opt_setting is None: - opt_method = optim.Adam - opt_lr = optim.ExponentialDecay(0.2, 1, 0.9999) - opt_setting = {'beta1': 0.9, - 'beta2': 0.999, - 'eps': 1e-8, - 'name': None} + if optimizer is None: + optimizer = optim.Adam(lr=optim.ExponentialDecay(0.2, 1, 0.9999), + beta1=0.9, beta2=0.999, eps=1e-8) + else: + assert isinstance(optimizer, optim.Optimizer), (f'Must be an instance of ' + f'{optim.Optimizer.__name__}, ' + f'while we got {type(optimizer)}') else: + warnings.warn('Please use "optimizer" to set optimization method. ' + '"opt_setting" is deprecated since version 2.1.2. ', + DeprecationWarning) + assert isinstance(opt_setting, dict) assert 'method' in opt_setting assert 'lr' in opt_setting @@ -122,26 +140,25 @@ def find_fps_with_gd_method(self, candidates, tolerance=1e-5, num_batch=100, if isinstance(opt_method, str): assert opt_method in optim.__dict__ opt_method = getattr(optim, opt_method) - assert isinstance(opt_method, type) - if optim.Optimizer not in inspect.getmro(opt_method): - raise ValueError + assert issubclass(opt_method, optim.Optimizer) opt_lr = opt_setting.pop('lr') assert isinstance(opt_lr, (int, float, optim.Scheduler)) opt_setting = opt_setting + optimizer = opt_method(lr=opt_lr, **opt_setting) if self.verbose: - print(f"Optimizing with {opt_method.__name__} to find fixed points:") + print(f"Optimizing with {optimizer.__name__} to find fixed points:") # set up optimization fixed_points = bm.Variable(bm.asarray(candidates)) grad_f = bm.grad(lambda: self.f_loss_batch(fixed_points.value).mean(), grad_vars={'a': fixed_points}, return_value=True) - opt = opt_method(train_vars={'a': fixed_points}, lr=opt_lr, **opt_setting) - dyn_vars = opt.vars() + {'_a': fixed_points} + optimizer.register_vars({'a': fixed_points}) + dyn_vars = optimizer.vars() + {'_a': fixed_points} def train(idx): gradients, loss = grad_f() - opt.update(gradients) + optimizer.update(gradients) return loss @partial(bm.jit, dyn_vars=dyn_vars, static_argnames=('start_i', 'num_batch')) diff --git a/examples/analysis/2d_decision_making_model.py b/examples/analysis/2d_decision_making_model.py index 7b2552582..20e8c81b3 100644 --- a/examples/analysis/2d_decision_making_model.py +++ b/examples/analysis/2d_decision_making_model.py @@ -75,8 +75,7 @@ def step(s): finder.find_fps_with_gd_method( candidates=bm.random.random((1000, 2)), tolerance=1e-5, num_batch=200, - opt_setting=dict(method=bm.optimizers.Adam, - lr=bm.optimizers.ExponentialDecay(0.01, 1, 0.9999)), + optimizer=bp.optim.Adam(lr=bp.optim.ExponentialDecay(0.01, 1, 0.9999)), ) # finder.find_fps_with_opt_solver(bm.random.random((1000, 2))) finder.filter_loss(1e-5) diff --git a/examples/analysis/highdim_CANN.py b/examples/analysis/highdim_CANN.py index c8828570b..b28a06217 100644 --- a/examples/analysis/highdim_CANN.py +++ b/examples/analysis/highdim_CANN.py @@ -90,9 +90,7 @@ def find_fixed_points(): # finder.find_fps_with_gd_method( # candidates=candidates, # tolerance=1e-6, - # opt_setting=dict(method=bm.optimizers.Adam, - # # lr=bm.optimizers.ExponentialDecay(0.05, 1, 0.9999)), - # lr=bm.optimizers.ExponentialDecay(0.1, 2, 0.999)), + # optimizer = bp.optim.Adam(lr=bp.optim.ExponentialDecay(0.1, , 0.999)), # num_batch=200 # ) finder.find_fps_with_opt_solver(candidates) diff --git a/examples/analysis/highdim_RNN_Analysis.py b/examples/analysis/highdim_RNN_Analysis.py index 896eb9dc0..52b19d43b 100644 --- a/examples/analysis/highdim_RNN_Analysis.py +++ b/examples/analysis/highdim_RNN_Analysis.py @@ -150,7 +150,7 @@ def loss(self, xs, ys): predict = bm.jit(net.predict, dyn_vars=net.vars()) # Adam optimizer -opt = bm.optimizers.Adam(lr=0.001, train_vars=net.train_vars().unique()) +opt = bp.optimizers.Adam(lr=0.001, train_vars=net.train_vars().unique()) # gradient function grad_f = bm.grad(net.loss, @@ -264,8 +264,7 @@ def train(xs, ys): finder.find_fps_with_gd_method( candidates=fp_candidates, tolerance=1e-5, num_batch=200, - opt_setting=dict(method=bm.optimizers.Adam, - lr=bm.optimizers.ExponentialDecay(0.01, 1, 0.9999)) + optimizer=bp.optim.Adam(lr=bp.optim.ExponentialDecay(0.01, 1, 0.9999)), ) finder.filter_loss(tolerance=1e-5) finder.keep_unique(tolerance=0.03) diff --git a/examples/analysis/highdim_gj_coupled_fhn.py b/examples/analysis/highdim_gj_coupled_fhn.py index e00c7ba01..f77e210e5 100644 --- a/examples/analysis/highdim_gj_coupled_fhn.py +++ b/examples/analysis/highdim_gj_coupled_fhn.py @@ -115,8 +115,7 @@ def step(vw): candidates=bm.random.normal(0., 2., (1000, model.num * 2)), tolerance=1e-5, num_batch=200, - opt_setting=dict(method=bm.optimizers.Adam, - lr=bm.optimizers.ExponentialDecay(0.05, 1, 0.9999)), + optimizer=bp.optim.Adam(lr=bp.optim.ExponentialDecay(0.05, 1, 0.9999)), ) finder.filter_loss(1e-7) finder.keep_unique() From b9da0400d1cefcfa96789ff8994c1a484bb16e41 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 14:33:04 +0800 Subject: [PATCH 20/22] changes: remove brainpy.math.vmap --- brainpy/analysis/highdim/slow_points.py | 9 ++-- brainpy/analysis/lowdim/lowdim_analyzer.py | 39 +++++++++--------- brainpy/analysis/lowdim/lowdim_bifurcation.py | 5 ++- brainpy/analysis/lowdim/lowdim_phase_plane.py | 3 +- brainpy/analysis/utils/optimization.py | 8 ++-- brainpy/analysis/utils/others.py | 3 +- brainpy/dyn/synapses/delay_coupling.py | 2 +- brainpy/errors.py | 3 +- brainpy/math/__init__.py | 2 +- brainpy/math/parallels.py | 41 ++++++++++--------- examples/simulation/Wu_2008_CANN_2D.py | 3 +- 11 files changed, 63 insertions(+), 55 deletions(-) diff --git a/brainpy/analysis/highdim/slow_points.py b/brainpy/analysis/highdim/slow_points.py index 4b865b0af..9cec0107d 100644 --- a/brainpy/analysis/highdim/slow_points.py +++ b/brainpy/analysis/highdim/slow_points.py @@ -4,6 +4,7 @@ import warnings from functools import partial +from jax import vmap import jax.numpy import numpy as np from jax.scipy.optimize import minimize @@ -56,15 +57,15 @@ def __init__(self, f_cell, f_type='continuous', f_loss_batch=None, verbose=True) if f_loss_batch is None: if f_type == 'discrete': self.f_loss = bm.jit(lambda h: bm.mean((h - f_cell(h)) ** 2)) - self.f_loss_batch = bm.jit(lambda h: bm.mean((h - bm.vmap(f_cell, auto_infer=False)(h)) ** 2, axis=1)) + self.f_loss_batch = bm.jit(lambda h: bm.mean((h - vmap(f_cell)(h)) ** 2, axis=1)) if f_type == 'continuous': self.f_loss = bm.jit(lambda h: bm.mean(f_cell(h) ** 2)) - self.f_loss_batch = bm.jit(lambda h: bm.mean((bm.vmap(f_cell, auto_infer=False)(h)) ** 2, axis=1)) + self.f_loss_batch = bm.jit(lambda h: bm.mean((vmap(f_cell)(h)) ** 2, axis=1)) else: self.f_loss_batch = f_loss_batch self.f_loss = bm.jit(lambda h: bm.mean(f_cell(h) ** 2)) - self.f_jacob_batch = bm.jit(bm.vmap(bm.jacobian(f_cell))) + self.f_jacob_batch = bm.jit(vmap(bm.jacobian(f_cell))) # essential variables self._losses = None @@ -208,7 +209,7 @@ def find_fps_with_opt_solver(self, candidates, opt_method=None): opt_method = lambda f, x0: minimize(f, x0, method='BFGS') if self.verbose: print(f"Optimizing to find fixed points:") - f_opt = bm.jit(bm.vmap(lambda x0: opt_method(self.f_loss, x0))) + f_opt = bm.jit(vmap(lambda x0: opt_method(self.f_loss, x0))) res = f_opt(bm.as_device_array(candidates)) valid_ids = jax.numpy.where(res.success)[0] self._fixed_points = np.asarray(res.x[valid_ids]) diff --git a/brainpy/analysis/lowdim/lowdim_analyzer.py b/brainpy/analysis/lowdim/lowdim_analyzer.py index 877c25a46..0d7ac1b6f 100644 --- a/brainpy/analysis/lowdim/lowdim_analyzer.py +++ b/brainpy/analysis/lowdim/lowdim_analyzer.py @@ -3,6 +3,7 @@ from functools import partial import numpy as np +from jax import vmap from jax import numpy as jnp from jax.scipy.optimize import minimize @@ -262,7 +263,7 @@ def F_fx(self): @property def F_vmap_fx(self): if C.F_vmap_fx not in self.analyzed_results: - self.analyzed_results[C.F_vmap_fx] = bm.jit(bm.vmap(self.F_fx), device=self.jit_device) + self.analyzed_results[C.F_vmap_fx] = bm.jit(vmap(self.F_fx), device=self.jit_device) return self.analyzed_results[C.F_vmap_fx] @property @@ -289,7 +290,7 @@ def F_vmap_fp_aux(self): # --- # "X": a two-dimensional matrix: (num_batch, num_var) # "args": a list of one-dimensional vectors, each has the shape of (num_batch,) - self.analyzed_results[C.F_vmap_fp_aux] = bm.jit(bm.vmap(self.F_fixed_point_aux)) + self.analyzed_results[C.F_vmap_fp_aux] = bm.jit(vmap(self.F_fixed_point_aux)) return self.analyzed_results[C.F_vmap_fp_aux] @property @@ -308,7 +309,7 @@ def F_vmap_fp_opt(self): # --- # "X": a two-dimensional matrix: (num_batch, num_var) # "args": a list of one-dimensional vectors, each has the shape of (num_batch,) - self.analyzed_results[C.F_vmap_fp_opt] = bm.jit(bm.vmap(self.F_fixed_point_opt)) + self.analyzed_results[C.F_vmap_fp_opt] = bm.jit(vmap(self.F_fixed_point_opt)) return self.analyzed_results[C.F_vmap_fp_opt] def _get_fixed_points(self, candidates, *args, num_seg=None, tol_aux=1e-7, loss_screen=None): @@ -501,7 +502,7 @@ def F_y_by_x_in_fy(self): @property def F_vmap_fy(self): if C.F_vmap_fy not in self.analyzed_results: - self.analyzed_results[C.F_vmap_fy] = bm.jit(bm.vmap(self.F_fy), device=self.jit_device) + self.analyzed_results[C.F_vmap_fy] = bm.jit(vmap(self.F_fy), device=self.jit_device) return self.analyzed_results[C.F_vmap_fy] @property @@ -663,7 +664,7 @@ def _get_fx_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux if self.F_x_by_y_in_fx is not None: utils.output("I am evaluating fx-nullcline by F_x_by_y_in_fx ...") - vmap_f = bm.jit(bm.vmap(self.F_x_by_y_in_fx), device=self.jit_device) + vmap_f = bm.jit(vmap(self.F_x_by_y_in_fx), device=self.jit_device) for j, pars in enumerate(par_seg): if len(par_seg.arg_id_segments[0]) > 1: utils.output(f"{C.prefix}segment {j} ...") mesh_values = jnp.meshgrid(*((ys,) + pars)) @@ -679,7 +680,7 @@ def _get_fx_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux elif self.F_y_by_x_in_fx is not None: utils.output("I am evaluating fx-nullcline by F_y_by_x_in_fx ...") - vmap_f = bm.jit(bm.vmap(self.F_y_by_x_in_fx), device=self.jit_device) + vmap_f = bm.jit(vmap(self.F_y_by_x_in_fx), device=self.jit_device) for j, pars in enumerate(par_seg): if len(par_seg.arg_id_segments[0]) > 1: utils.output(f"{C.prefix}segment {j} ...") mesh_values = jnp.meshgrid(*((xs,) + pars)) @@ -697,9 +698,9 @@ def _get_fx_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux utils.output("I am evaluating fx-nullcline by optimization ...") # auxiliary functions f2 = lambda y, x, *pars: self.F_fx(x, y, *pars) - vmap_f2 = bm.jit(bm.vmap(f2), device=self.jit_device) - vmap_brentq_f2 = bm.jit(bm.vmap(utils.jax_brentq(f2)), device=self.jit_device) - vmap_brentq_f1 = bm.jit(bm.vmap(utils.jax_brentq(self.F_fx)), device=self.jit_device) + vmap_f2 = bm.jit(vmap(f2), device=self.jit_device) + vmap_brentq_f2 = bm.jit(vmap(utils.jax_brentq(f2)), device=self.jit_device) + vmap_brentq_f1 = bm.jit(vmap(utils.jax_brentq(self.F_fx)), device=self.jit_device) # num segments for _j, Ps in enumerate(par_seg): @@ -756,7 +757,7 @@ def _get_fy_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux if self.F_x_by_y_in_fy is not None: utils.output("I am evaluating fy-nullcline by F_x_by_y_in_fy ...") - vmap_f = bm.jit(bm.vmap(self.F_x_by_y_in_fy), device=self.jit_device) + vmap_f = bm.jit(vmap(self.F_x_by_y_in_fy), device=self.jit_device) for j, pars in enumerate(par_seg): if len(par_seg.arg_id_segments[0]) > 1: utils.output(f"{C.prefix}segment {j} ...") mesh_values = jnp.meshgrid(*((ys,) + pars)) @@ -772,7 +773,7 @@ def _get_fy_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux elif self.F_y_by_x_in_fy is not None: utils.output("I am evaluating fy-nullcline by F_y_by_x_in_fy ...") - vmap_f = bm.jit(bm.vmap(self.F_y_by_x_in_fy), device=self.jit_device) + vmap_f = bm.jit(vmap(self.F_y_by_x_in_fy), device=self.jit_device) for j, pars in enumerate(par_seg): if len(par_seg.arg_id_segments[0]) > 1: utils.output(f"{C.prefix}segment {j} ...") mesh_values = jnp.meshgrid(*((xs,) + pars)) @@ -791,9 +792,9 @@ def _get_fy_nullcline_points(self, coords=None, tol=1e-7, num_segments=1, fp_aux # auxiliary functions f2 = lambda y, x, *pars: self.F_fy(x, y, *pars) - vmap_f2 = bm.jit(bm.vmap(f2), device=self.jit_device) - vmap_brentq_f2 = bm.jit(bm.vmap(utils.jax_brentq(f2)), device=self.jit_device) - vmap_brentq_f1 = bm.jit(bm.vmap(utils.jax_brentq(self.F_fy)), device=self.jit_device) + vmap_f2 = bm.jit(vmap(f2), device=self.jit_device) + vmap_brentq_f2 = bm.jit(vmap(utils.jax_brentq(f2)), device=self.jit_device) + vmap_brentq_f1 = bm.jit(vmap(utils.jax_brentq(self.F_fy)), device=self.jit_device) for j, Ps in enumerate(par_seg): if len(par_seg.arg_id_segments[0]) > 1: utils.output(f"{C.prefix}segment {j} ...") @@ -841,7 +842,7 @@ def _get_fp_candidates_by_aux_rank(self, num_segments=1, num_rank=100): xs = self.resolutions[self.x_var].value ys = self.resolutions[self.y_var].value P = tuple(self.resolutions[p].value for p in self.target_par_names) - f_select = bm.jit(bm.vmap(lambda vals, ids: vals[ids], in_axes=(1, 1))) + f_select = bm.jit(vmap(lambda vals, ids: vals[ids], in_axes=(1, 1))) # num seguments if isinstance(num_segments, int): @@ -921,10 +922,10 @@ def _get_fixed_points(self, candidates, *args, tol_aux=1e-7, if self.convert_type() == C.x_by_y: num_seg = len(self.resolutions[self.y_var]) - f_vmap = bm.jit(bm.vmap(self.F_y_convert[1])) + f_vmap = bm.jit(vmap(self.F_y_convert[1])) else: num_seg = len(self.resolutions[self.x_var]) - f_vmap = bm.jit(bm.vmap(self.F_x_convert[1])) + f_vmap = bm.jit(vmap(self.F_x_convert[1])) # get the signs signs = jnp.sign(f_vmap(candidates, *args)) signs = signs.reshape((num_seg, -1)) @@ -954,10 +955,10 @@ def _get_fixed_points(self, candidates, *args, tol_aux=1e-7, # get another value if self.convert_type() == C.x_by_y: y_values = fps - x_values = bm.jit(bm.vmap(self.F_y_convert[0]))(y_values, *args) + x_values = bm.jit(vmap(self.F_y_convert[0]))(y_values, *args) else: x_values = fps - y_values = bm.jit(bm.vmap(self.F_x_convert[0]))(x_values, *args) + y_values = bm.jit(vmap(self.F_x_convert[0]))(x_values, *args) fps = jnp.stack([x_values, y_values]).T return fps, selected_ids, args diff --git a/brainpy/analysis/lowdim/lowdim_bifurcation.py b/brainpy/analysis/lowdim/lowdim_bifurcation.py index 43bb886fc..58ac84694 100644 --- a/brainpy/analysis/lowdim/lowdim_bifurcation.py +++ b/brainpy/analysis/lowdim/lowdim_bifurcation.py @@ -3,6 +3,7 @@ from functools import partial import jax.numpy as jnp +from jax import vmap import numpy as np import brainpy.math as bm @@ -42,7 +43,7 @@ def __init__(self, model, target_pars, target_vars, fixed_vars=None, @property def F_vmap_dfxdx(self): if C.F_vmap_dfxdx not in self.analyzed_results: - f = bm.jit(bm.vmap(bm.vector_grad(self.F_fx, argnums=0)), device=self.jit_device) + f = bm.jit(vmap(bm.vector_grad(self.F_fx, argnums=0)), device=self.jit_device) self.analyzed_results[C.F_vmap_dfxdx] = f return self.analyzed_results[C.F_vmap_dfxdx] @@ -159,7 +160,7 @@ def F_vmap_jacobian(self): if C.F_vmap_jacobian not in self.analyzed_results: f1 = lambda xy, *args: jnp.array([self.F_fx(xy[0], xy[1], *args), self.F_fy(xy[0], xy[1], *args)]) - f2 = bm.jit(bm.vmap(bm.jacobian(f1)), device=self.jit_device) + f2 = bm.jit(vmap(bm.jacobian(f1)), device=self.jit_device) self.analyzed_results[C.F_vmap_jacobian] = f2 return self.analyzed_results[C.F_vmap_jacobian] diff --git a/brainpy/analysis/lowdim/lowdim_phase_plane.py b/brainpy/analysis/lowdim/lowdim_phase_plane.py index c49757995..693d93f7d 100644 --- a/brainpy/analysis/lowdim/lowdim_phase_plane.py +++ b/brainpy/analysis/lowdim/lowdim_phase_plane.py @@ -2,6 +2,7 @@ import jax.numpy as jnp import numpy as np +from jax import vmap import brainpy.math as bm from brainpy import errors, math @@ -158,7 +159,7 @@ def __init__(self, @property def F_vmap_brentq_fy(self): if C.F_vmap_brentq_fy not in self.analyzed_results: - f_opt = bm.jit(bm.vmap(utils.jax_brentq(self.F_fy))) + f_opt = bm.jit(vmap(utils.jax_brentq(self.F_fy))) self.analyzed_results[C.F_vmap_brentq_fy] = f_opt return self.analyzed_results[C.F_vmap_brentq_fy] diff --git a/brainpy/analysis/utils/optimization.py b/brainpy/analysis/utils/optimization.py index c1a5a6181..f24fc11b0 100644 --- a/brainpy/analysis/utils/optimization.py +++ b/brainpy/analysis/utils/optimization.py @@ -4,7 +4,7 @@ import jax.lax import jax.numpy as jnp import numpy as np -from jax import grad, jit +from jax import grad, jit, vmap from jax.flatten_util import ravel_pytree import brainpy.math as bm @@ -197,7 +197,7 @@ def brentq_candidates(vmap_f, *values, args=()): def brentq_roots(f, starts, ends, *vmap_args, args=()): in_axes = (0, 0, tuple([0] * len(vmap_args)) + tuple([None] * len(args))) - vmap_f_opt = bm.jit(bm.vmap(jax_brentq(f), in_axes=in_axes)) + vmap_f_opt = bm.jit(vmap(jax_brentq(f), in_axes=in_axes)) all_args = vmap_args + args if len(all_args): res = vmap_f_opt(starts, ends, all_args) @@ -397,7 +397,7 @@ def roots_of_1d_by_x(f, candidates, args=()): return fps starts = candidates[candidate_ids] ends = candidates[candidate_ids + 1] - f_opt = bm.jit(bm.vmap(jax_brentq(f), in_axes=(0, 0, None))) + f_opt = bm.jit(vmap(jax_brentq(f), in_axes=(0, 0, None))) res = f_opt(starts, ends, args) valid_idx = jnp.where(res['status'] == ECONVERGED)[0] fps2 = res['root'][valid_idx] @@ -406,7 +406,7 @@ def roots_of_1d_by_x(f, candidates, args=()): def roots_of_1d_by_xy(f, starts, ends, args): f = f_without_jaxarray_return(f) - f_opt = bm.jit(bm.vmap(jax_brentq(f))) + f_opt = bm.jit(vmap(jax_brentq(f))) res = f_opt(starts, ends, (args,)) valid_idx = jnp.where(res['status'] == ECONVERGED)[0] xs = res['root'][valid_idx] diff --git a/brainpy/analysis/utils/others.py b/brainpy/analysis/utils/others.py index 446ebe89e..5266ca231 100644 --- a/brainpy/analysis/utils/others.py +++ b/brainpy/analysis/utils/others.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- import jax.numpy as jnp +from jax import vmap import numpy as np import brainpy.math as bm @@ -76,7 +77,7 @@ def get_sign(f, xs, ys): def get_sign2(f, *xyz, args=()): in_axes = tuple(range(len(xyz))) + tuple([None] * len(args)) - f = bm.jit(bm.vmap(f_without_jaxarray_return(f), in_axes=in_axes)) + f = bm.jit(vmap(f_without_jaxarray_return(f), in_axes=in_axes)) xyz = tuple((v.value if isinstance(v, bm.JaxArray) else v) for v in xyz) XYZ = jnp.meshgrid(*xyz) XYZ = tuple(jnp.moveaxis(v, 1, 0).flatten() for v in XYZ) diff --git a/brainpy/dyn/synapses/delay_coupling.py b/brainpy/dyn/synapses/delay_coupling.py index 06fdd2202..bee346314 100644 --- a/brainpy/dyn/synapses/delay_coupling.py +++ b/brainpy/dyn/synapses/delay_coupling.py @@ -193,7 +193,7 @@ def update(self, _t, _dt): variable = getattr(self.pre, var) # delay function - f = bm.vmap(lambda i: delay_var(self.delay_mat[i], bm.arange(self.pre.num))) # (pre.num,) + f = vmap(lambda i: delay_var(self.delay_mat[i], bm.arange(self.pre.num))) # (pre.num,) delays = f(bm.arange(self.post.num)) # (post.num, pre.num) additive = (self.conn_mat * delays).sum(axis=1) diff --git a/brainpy/errors.py b/brainpy/errors.py index e44211853..90ee3d904 100644 --- a/brainpy/errors.py +++ b/brainpy/errors.py @@ -101,7 +101,8 @@ def __init__(self, variables=None): else: raise ValueError - msg += 'While there are changed variables which are not wrapped into "dyn_vars". Please check!' + # msg += 'While there are changed variables which are not wrapped into "dyn_vars". Please check!' + msg = 'While there are changed variables which are not wrapped into "dyn_vars". Please check!' super(JaxTracerError, self).__init__(msg) diff --git a/brainpy/math/__init__.py b/brainpy/math/__init__.py index 993691048..4d5619f06 100644 --- a/brainpy/math/__init__.py +++ b/brainpy/math/__init__.py @@ -46,7 +46,7 @@ from .autograd import * from .controls import * from .jit import * -from .parallels import * +# from .parallels import * # settings from . import setting diff --git a/brainpy/math/parallels.py b/brainpy/math/parallels.py index a8e0de7c2..84d86dc65 100644 --- a/brainpy/math/parallels.py +++ b/brainpy/math/parallels.py @@ -36,29 +36,31 @@ ] -def _make_vmap(func, dyn_vars, rand_vars, in_axes, out_axes, - batch_idx, axis_name, reduce_func, f_name=None): +def _make_vmap(func, nonbatched_vars, batched_vars, in_axes, out_axes, + batch_idx, axis_name, f_name=None): @functools.partial(jax.vmap, in_axes=in_axes, out_axes=out_axes, axis_name=axis_name) - def vmapped_func(dyn_data, rand_data, *args, **kwargs): - dyn_vars.assign(dyn_data) - rand_vars.assign(rand_data) + def vmapped_func(nonbatched_data, batched_data, *args, **kwargs): + nonbatched_vars.assign(nonbatched_data) + batched_vars.assign(batched_data) out = func(*args, **kwargs) - dyn_changes = dyn_vars.dict() - rand_changes = rand_vars.dict() - return out, dyn_changes, rand_changes + nonbatched_changes = nonbatched_vars.dict() + batched_changes = batched_vars.dict() + return nonbatched_changes, batched_changes, out def call(*args, **kwargs): - dyn_data = dyn_vars.dict() n = args[batch_idx[0]].shape[batch_idx[1]] - rand_data = {key: val.split_keys(n) for key, val in rand_vars.items()} + nonbatched_data = nonbatched_vars.dict() + batched_data = {key: val.split_keys(n) for key, val in batched_vars.items()} try: - out, dyn_changes, rand_changes = vmapped_func(dyn_data, rand_data, *args, **kwargs) + out, dyn_changes, rand_changes = vmapped_func(nonbatched_data, batched_data, *args, **kwargs) except UnexpectedTracerError as e: - dyn_vars.assign(dyn_data) - rand_vars.assign(rand_data) - raise errors.JaxTracerError(variables=dyn_vars) from e - for key, v in dyn_changes.items(): dyn_vars[key] = reduce_func(v) - for key, v in rand_changes.items(): rand_vars[key] = reduce_func(v) + nonbatched_vars.assign(nonbatched_data) + batched_vars.assign(batched_data) + raise errors.JaxTracerError() from e + # for key, v in dyn_changes.items(): + # dyn_vars[key] = reduce_func(v) + # for key, v in rand_changes.items(): + # rand_vars[key] = reduce_func(v) return out return change_func_name(name=f_name, f=call) if f_name else call @@ -256,13 +258,12 @@ def vmap(func, dyn_vars=None, batched_vars=None, # jit function return _make_vmap(func=func, - dyn_vars=_dyn_vars, - rand_vars=_rand_vars, + nonbatched_vars=_dyn_vars, + batched_vars=_rand_vars, in_axes=in_axes, out_axes=out_axes, axis_name=axis_name, - batch_idx=batch_idx, - reduce_func=reduce_func) + batch_idx=batch_idx) else: raise errors.BrainPyError(f'Only support instance of {Base.__name__}, or a callable ' diff --git a/examples/simulation/Wu_2008_CANN_2D.py b/examples/simulation/Wu_2008_CANN_2D.py index a6e6ec182..93c19cae2 100644 --- a/examples/simulation/Wu_2008_CANN_2D.py +++ b/examples/simulation/Wu_2008_CANN_2D.py @@ -2,6 +2,7 @@ # - Si Wu, Kosuke Hamaguchi, and Shun-ichi Amari. "Dynamics and computation # of continuous attractors." Neural computation 20.4 (2008): 994-1025. +import jax import matplotlib.pyplot as plt import numpy as np @@ -98,7 +99,7 @@ def update(self, _t, _dt): length = 20 positions = bp.inputs.ramp_input(-bm.pi, bm.pi, duration=length, t_start=0) positions = bm.stack([positions, positions]).T -Iext = bm.vmap(cann.get_stimulus_by_pos)(positions) +Iext = jax.vmap(cann.get_stimulus_by_pos)(positions) runner = bp.dyn.DSRunner(cann, inputs=['input', Iext, 'iter'], monitors=['r'], From cb9f0cfc019ff0ac85f951101ddeb8650503adfd Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 14:33:14 +0800 Subject: [PATCH 21/22] format codes --- .gitignore | 1 + brainpy/__init__.py | 4 ++-- brainpy/math/autograd.py | 5 ++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index 846764118..548a943fd 100644 --- a/.gitignore +++ b/.gitignore @@ -17,6 +17,7 @@ BrainModels/ book/ docs/examples docs/apis/jaxsetting.rst +docs/quickstart/data examples/recurrent_neural_network/neurogym develop/iconip_paper develop/benchmark/COBA/results diff --git a/brainpy/__init__.py b/brainpy/__init__.py index 29e3b9234..de8728447 100644 --- a/brainpy/__init__.py +++ b/brainpy/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -__version__ = "2.1.1" +__version__ = "2.1.2" try: @@ -15,7 +15,7 @@ # fundamental modules -from . import errors, tools +from . import errors, tools, check # "base" module diff --git a/brainpy/math/autograd.py b/brainpy/math/autograd.py index 39ef6ee8e..0e8364c6b 100644 --- a/brainpy/math/autograd.py +++ b/brainpy/math/autograd.py @@ -1,8 +1,7 @@ # -*- coding: utf-8 -*- -from typing import Union, Callable, Dict, Sequence - from functools import partial +from typing import Union, Callable, Dict, Sequence import jax import numpy as np @@ -41,7 +40,7 @@ def call_func(*args, **kwargs): except UnexpectedTracerError as e: for v, d in zip(grad_vars, old_grad_vs): v.value = d for v, d in zip(dyn_vars, old_dyn_vs): v.value = d - raise errors.JaxTracerError(variables=dyn_vars+grad_vars) from e + raise errors.JaxTracerError(variables=dyn_vars + grad_vars) from e for v, d in zip(grad_vars, new_grad_vs): v.value = d for v, d in zip(dyn_vars, new_dyn_vs): v.value = d From 0de0693d8c15883d6ac4c2b990d0a4f062867aa7 Mon Sep 17 00:00:00 2001 From: chaoming Date: Wed, 23 Mar 2022 14:47:04 +0800 Subject: [PATCH 22/22] fi test bugs --- brainpy/connect/tests/test_regular_conn.py | 4 ++-- brainpy/math/delay_vars.py | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/brainpy/connect/tests/test_regular_conn.py b/brainpy/connect/tests/test_regular_conn.py index f2f464670..f6d9e79a7 100644 --- a/brainpy/connect/tests/test_regular_conn.py +++ b/brainpy/connect/tests/test_regular_conn.py @@ -14,7 +14,7 @@ def test_one2one(): num = bp.tools.size2num(size) actual_mat = bp.math.zeros((num, num), dtype=bp.math.bool_) - actual_mat = bp.math.fill_diagonal(actual_mat, True) + bp.math.fill_diagonal(actual_mat, True) assert bp.math.array_equal(actual_mat, conn_mat) assert bp.math.array_equal(pre_ids, bp.math.arange(num)) @@ -42,7 +42,7 @@ def test_all2all(): print(mat) actual_mat = bp.math.ones((num, num), dtype=bp.math.bool_) if not has_self: - actual_mat = bp.math.fill_diagonal(actual_mat, False) + bp.math.fill_diagonal(actual_mat, False) assert bp.math.array_equal(actual_mat, mat) diff --git a/brainpy/math/delay_vars.py b/brainpy/math/delay_vars.py index 4b2ffb3b4..a18a7c5bd 100644 --- a/brainpy/math/delay_vars.py +++ b/brainpy/math/delay_vars.py @@ -168,6 +168,7 @@ def __init__( def _check_time(self, times, transforms): prev_time, current_time = times + current_time = current_time[0] if prev_time > current_time + 1e-6: raise ValueError(f'\n' f'!!! Error in {self.__class__.__name__}: \n' @@ -194,7 +195,7 @@ def __call__(self, time, indices=None): return self._after_t0(time) def _after_t0(self, prev_time): - diff = self.delay_len - (self.current_time - prev_time) + diff = self.delay_len - (self.current_time[0] - prev_time) if isinstance(diff, ndarray): diff = diff.value if self.interp_method == _INTERP_LINEAR: