From c0ac3790047f944b166df704f5dc366bfdd502ad Mon Sep 17 00:00:00 2001 From: chaoming Date: Sun, 15 May 2022 21:35:16 +0800 Subject: [PATCH 1/3] feat: fix `io` for brainpy.Base --- .gitignore | 3 +- brainpy/__init__.py | 2 +- brainpy/base/base.py | 31 +-- brainpy/base/collector.py | 24 ++ brainpy/base/io.py | 445 +++++++++++++++++++++++++++++--------- brainpy/tools/checking.py | 13 +- 6 files changed, 392 insertions(+), 126 deletions(-) diff --git a/.gitignore b/.gitignore index a5212d0bf..1d40ddd9e 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,8 @@ publishment.md .vscode +brainpy/base/tests/io_test_tmp* + development examples/simulation/data @@ -53,7 +55,6 @@ develop/benchmark/CUBA/annarchy* develop/benchmark/CUBA/brian2* - *~ \#*\# *.pyc diff --git a/brainpy/__init__.py b/brainpy/__init__.py index d9b214c0c..e2ac8336b 100644 --- a/brainpy/__init__.py +++ b/brainpy/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -__version__ = "2.1.11" +__version__ = "2.1.12" try: diff --git a/brainpy/base/base.py b/brainpy/base/base.py index d4c8c9401..70996bf3d 100644 --- a/brainpy/base/base.py +++ b/brainpy/base/base.py @@ -208,7 +208,7 @@ def unique_name(self, name=None, type_=None): naming.check_name_uniqueness(name=name, obj=self) return name - def load_states(self, filename, verbose=False, check_missing=False): + def load_states(self, filename, verbose=False): """Load the model states. Parameters @@ -216,41 +216,42 @@ def load_states(self, filename, verbose=False, check_missing=False): filename : str The filename which stores the model states. verbose: bool - check_missing: bool + Whether report the load progress. """ if not os.path.exists(filename): raise errors.BrainPyError(f'Cannot find the file path: {filename}') elif filename.endswith('.hdf5') or filename.endswith('.h5'): - io.load_h5(filename, target=self, verbose=verbose, check=check_missing) + io.load_by_h5(filename, target=self, verbose=verbose) elif filename.endswith('.pkl'): - io.load_pkl(filename, target=self, verbose=verbose, check=check_missing) + io.load_by_pkl(filename, target=self, verbose=verbose) elif filename.endswith('.npz'): - io.load_npz(filename, target=self, verbose=verbose, check=check_missing) + io.load_by_npz(filename, target=self, verbose=verbose) elif filename.endswith('.mat'): - io.load_mat(filename, target=self, verbose=verbose, check=check_missing) + io.load_by_mat(filename, target=self, verbose=verbose) else: raise errors.BrainPyError(f'Unknown file format: {filename}. We only supports {io.SUPPORTED_FORMATS}') - def save_states(self, filename, all_vars=None, **setting): + def save_states(self, filename, variables=None, **setting): """Save the model states. Parameters ---------- filename : str The file name which to store the model states. - all_vars: optional, dict, TensorCollector + variables: optional, dict, TensorCollector + The variables to save. If not provided, all variables retrieved by ``~.vars()`` will be used. """ - if all_vars is None: - all_vars = self.vars(method='relative').unique() + if variables is None: + variables = self.vars(method='absolute', level=-1) if filename.endswith('.hdf5') or filename.endswith('.h5'): - io.save_h5(filename, all_vars=all_vars) - elif filename.endswith('.pkl'): - io.save_pkl(filename, all_vars=all_vars) + io.save_as_h5(filename, variables=variables) + elif filename.endswith('.pkl') or filename.endswith('.pickle'): + io.save_as_pkl(filename, variables=variables) elif filename.endswith('.npz'): - io.save_npz(filename, all_vars=all_vars, **setting) + io.save_as_npz(filename, variables=variables, **setting) elif filename.endswith('.mat'): - io.save_mat(filename, all_vars=all_vars) + io.save_as_mat(filename, variables=variables) else: raise errors.BrainPyError(f'Unknown file format: {filename}. We only supports {io.SUPPORTED_FORMATS}') diff --git a/brainpy/base/collector.py b/brainpy/base/collector.py index 1b0178bf9..f86ba372a 100644 --- a/brainpy/base/collector.py +++ b/brainpy/base/collector.py @@ -39,11 +39,35 @@ def update(self, other, **kwargs): self[key] = value def __add__(self, other): + """Merging two dicts. + + Parameters + ---------- + other: dict + The other dict instance. + + Returns + ------- + gather: Collector + The new collector. + """ gather = type(self)(self) gather.update(other) return gather def __sub__(self, other): + """Remove other item in the collector. + + Parameters + ---------- + other: dict + The items to remove. + + Returns + ------- + gather: Collector + The new collector. + """ if not isinstance(other, dict): raise ValueError(f'Only support dict, but we got {type(other)}.') gather = type(self)() diff --git a/brainpy/base/io.py b/brainpy/base/io.py index 7e1fcbe8a..97cf03f87 100644 --- a/brainpy/base/io.py +++ b/brainpy/base/io.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- +from typing import Dict, Type, Union, Tuple, List import logging -import os import pickle import numpy as np @@ -9,35 +9,47 @@ from brainpy import errors from brainpy.base.collector import TensorCollector -Base = math = None logger = logging.getLogger('brainpy.base.io') -try: - import h5py -except (ModuleNotFoundError, ImportError): - h5py = None - -try: - import scipy.io as sio -except (ModuleNotFoundError, ImportError): - sio = None - __all__ = [ 'SUPPORTED_FORMATS', - 'save_h5', - 'save_npz', - 'save_pkl', - 'save_mat', - 'load_h5', - 'load_npz', - 'load_pkl', - 'load_mat', + 'save_as_h5', + 'save_as_npz', + 'save_as_pkl', + 'save_as_mat', + 'load_by_h5', + 'load_by_npz', + 'load_by_pkl', + 'load_by_mat', ] SUPPORTED_FORMATS = ['.h5', '.hdf5', '.npz', '.pkl', '.mat'] -def _check(module, module_name, ext): +def check_dict_data( + a_dict: Dict, + key_type: Union[Type, Tuple[Type, ...]] = None, + val_type: Union[Type, Tuple[Type, ...]] = None, + name: str = None +): + """Check the dict data.""" + name = '' if (name is None) else f'"{name}"' + if not isinstance(a_dict, dict): + raise ValueError(f'{name} must be a dict, while we got {type(a_dict)}') + if key_type is not None: + for key, value in a_dict.items(): + if not isinstance(key, key_type): + raise ValueError(f'{name} must be a dict of ({key_type}, {val_type}), ' + f'while we got ({type(key)}, {type(value)})') + if val_type is not None: + for key, value in a_dict.items(): + if not isinstance(value, val_type): + raise ValueError(f'{name} must be a dict of ({key_type}, {val_type}), ' + f'while we got ({type(key)}, {type(value)})') + + +def _check_module(module, module_name, ext): + """Check whether the required module is installed.""" if module is None: raise errors.PackageMissingError( '"{package}" must be installed when you want to save/load data with {ext} ' @@ -52,104 +64,329 @@ def _check_missing(variables, filename): f'The missed variables are: {list(variables.keys())}.') -def save_h5(filename, all_vars): - _check(h5py, module_name='h5py', ext=os.path.splitext(filename)) - assert isinstance(all_vars, dict) - all_vars = TensorCollector(all_vars).unique() +def _check_target(target): + from .base import Base + if not isinstance(target, Base): + raise TypeError(f'"target" must be instance of "{Base.__name__}", but we got {type(target)}') + + +not_found_msg = ('"{key}" is stored in {filename}. But we does ' + 'not find it is defined as variable in {target}.') +id_dismatch_msg = ('{key1} and {key2} is the same data in {filename}. ' + 'But we found they are different in {target}.') + +DUPLICATE_KEY = 'duplicate_keys' +DUPLICATE_TARGET = 'duplicate_targets' + + +def _load( + target, + verbose: bool, + filename: str, + load_vars: dict, + duplicates: Tuple[List[str], List[str]], + remove_first_axis: bool = False +): + from brainpy import math as bm + + # get variables + _check_target(target) + variables = target.vars(method='absolute', level=-1) + all_names = list(variables.keys()) + + # read data from file + for key in load_vars.keys(): + if verbose: + print(f'Loading {key} ...') + if key not in variables: + raise KeyError(not_found_msg.format(key=key, target=target.name, filename=filename)) + if remove_first_axis: + value = load_vars[key][0] + else: + value = load_vars[key] + variables[key].value = bm.asarray(value) + all_names.remove(key) + + # check duplicate names + duplicate_keys = duplicates[0] + duplicate_targets = duplicates[1] + for key1, key2 in zip(duplicate_keys, duplicate_targets): + if key1 not in all_names: + raise KeyError(not_found_msg.format(key=key1, target=target.name, filename=filename)) + if id(variables[key1]) != id(variables[key2]): + raise ValueError(id_dismatch_msg.format(key1=key1, key2=target, filename=filename, target=target.name)) + all_names.remove(key1) + + # check missing names + if len(all_names): + logger.warning(f'There are variable states missed in {filename}. ' + f'The missed variables are: {all_names}.') + + +def _unique_and_duplicate(collector: dict): + gather = TensorCollector() + id2name = dict() + duplicates = ([], []) + for k, v in collector.items(): + id_ = id(v) + if id_ not in id2name: + gather[k] = v + id2name[id_] = k + else: + k2 = id2name[id_] + duplicates[0].append(k) + duplicates[1].append(k2) + duplicates = (duplicates[0], duplicates[1]) + return gather, duplicates + + +def save_as_h5(filename: str, variables: dict): + """Save variables into a HDF5 file. + + Parameters + ---------- + filename: str + The filename to save. + variables: dict + All variables to save. + """ + if not (filename.endswith('.hdf5') or filename.endswith('.h5')): + raise ValueError(f'Cannot save variables as a HDF5 file. We only support file with ' + f'postfix of ".hdf5" and ".h5". But we got {filename}') + + from brainpy import math as bm + import h5py + + # check variables + check_dict_data(variables, name='variables') + variables, duplicates = _unique_and_duplicate(variables) # save f = h5py.File(filename, "w") - for key, data in all_vars.items(): - f[key] = np.asarray(data.value) + for key, data in variables.items(): + f[key] = bm.as_numpy(data) + if len(duplicates[0]): + f.create_dataset(DUPLICATE_TARGET, data='+'.join(duplicates[1])) + f.create_dataset(DUPLICATE_KEY, data='+'.join(duplicates[0])) f.close() -def load_h5(filename, target, verbose=False, check=False): - global math, Base - if Base is None: from brainpy.base.base import Base - if math is None: from brainpy import math - assert isinstance(target, Base) - _check(h5py, module_name='h5py', ext=os.path.splitext(filename)) +def load_by_h5(filename: str, target, verbose: bool = False): + """Load variables in a HDF5 file. - all_vars = target.vars(method='absolute') - f = h5py.File(filename, "r") - for key in f.keys(): - if verbose: print(f'Loading {key} ...') - var = all_vars.pop(key) - var[:] = math.asarray(f[key][:]) - f.close() - if check: _check_missing(all_vars, filename=filename) + Parameters + ---------- + filename: str + The filename to load variables. + target: Base + The instance of :py:class:`~.brainpy.Base`. + verbose: bool + Whether report the load progress. + """ + if not (filename.endswith('.hdf5') or filename.endswith('.h5')): + raise ValueError(f'Cannot load variables from a HDF5 file. We only support file with ' + f'postfix of ".hdf5" and ".h5". But we got {filename}') + # read data + import h5py + load_vars = dict() + with h5py.File(filename, "r") as f: + for key in f.keys(): + if key in [DUPLICATE_KEY, DUPLICATE_TARGET]: continue + load_vars[key] = np.asarray(f[key]) + if DUPLICATE_KEY in f: + duplicate_keys = np.asarray(f[DUPLICATE_KEY]).item().decode("utf-8").split('+') + duplicate_targets = np.asarray(f[DUPLICATE_TARGET]).item().decode("utf-8").split('+') + duplicates = (duplicate_keys, duplicate_targets) + else: + duplicates = ([], []) + + # assign values + _load(target, verbose, filename, load_vars, duplicates) + + +def save_as_npz(filename, variables, compressed=False): + """Save variables into a numpy file. + + Parameters + ---------- + filename: str + The filename to store. + variables: dict + Variables to save. + compressed: bool + Whether we use the compressed mode. + """ + if not filename.endswith('.npz'): + raise ValueError(f'Cannot save variables as a .npz file. We only support file with ' + f'postfix of ".npz". But we got {filename}') + + from brainpy import math as bm + check_dict_data(variables, name='variables') + variables, duplicates = _unique_and_duplicate(variables) -def save_npz(filename, all_vars, compressed=False): - assert isinstance(all_vars, dict) - all_vars = TensorCollector(all_vars).unique() - all_vars = {k.replace('.', '--'): np.asarray(v.value) for k, v in all_vars.items()} + # save + variables = {k: bm.as_numpy(v) for k, v in variables.items()} + if len(duplicates[0]): + variables[DUPLICATE_KEY] = np.asarray(duplicates[0]) + variables[DUPLICATE_TARGET] = np.asarray(duplicates[1]) if compressed: - np.savez_compressed(filename, **all_vars) + np.savez_compressed(filename, **variables) else: - np.savez(filename, **all_vars) - - -def load_npz(filename, target, verbose=False, check=False): - global math, Base - if Base is None: from brainpy.base.base import Base - if math is None: from brainpy import math - assert isinstance(target, Base) - - all_vars = target.vars(method='absolute') + np.savez(filename, **variables) + + +def load_by_npz(filename, target, verbose=False): + """Load variables from a numpy file. + + Parameters + ---------- + filename: str + The filename to load variables. + target: Base + The instance of :py:class:`~.brainpy.Base`. + verbose: bool + Whether report the load progress. + """ + if not filename.endswith('.npz'): + raise ValueError(f'Cannot load variables from a .npz file. We only support file with ' + f'postfix of ".npz". But we got {filename}') + + # load data + load_vars = dict() all_data = np.load(filename) for key in all_data.files: - if verbose: print(f'Loading {key} ...') - var = all_vars.pop(key) - var[:] = math.asarray(all_data[key]) - if check: _check_missing(all_vars, filename=filename) - - -def save_pkl(filename, all_vars): - assert isinstance(all_vars, dict) - all_vars = TensorCollector(all_vars).unique() - targets = {k: np.asarray(v) for k, v in all_vars.items()} - f = open(filename, 'wb') - pickle.dump(targets, f, protocol=pickle.HIGHEST_PROTOCOL) - f.close() - - -def load_pkl(filename, target, verbose=False, check=False): - global math, Base - if Base is None: from brainpy.base.base import Base - if math is None: from brainpy import math - assert isinstance(target, Base) - f = open(filename, 'rb') - all_data = pickle.load(f) - f.close() - - all_vars = target.vars(method='absolute') - for key, data in all_data.items(): - if verbose: print(f'Loading {key} ...') - var = all_vars.pop(key) - var[:] = math.asarray(data) - if check: _check_missing(all_vars, filename=filename) - - -def save_mat(filename, all_vars): - assert isinstance(all_vars, dict) - all_vars = TensorCollector(all_vars).unique() - _check(sio, module_name='scipy', ext=os.path.splitext(filename)) - all_vars = {k.replace('.', '--'): np.asarray(v.value) for k, v in all_vars.items()} - sio.savemat(filename, all_vars) + if key in [DUPLICATE_KEY, DUPLICATE_TARGET]: continue + load_vars[key] = all_data[key] + if DUPLICATE_KEY in all_data: + duplicate_keys = all_data[DUPLICATE_KEY].tolist() + duplicate_targets = all_data[DUPLICATE_TARGET].tolist() + duplicates = (duplicate_keys, duplicate_targets) + else: + duplicates = ([], []) + + # assign values + _load(target, verbose, filename, load_vars, duplicates) + + +def save_as_pkl(filename, variables): + """Save variables into a pickle file. + + Parameters + ---------- + filename: str + The filename to save. + variables: dict + All variables to save. + """ + if not (filename.endswith('.pkl') or filename.endswith('.pickle')): + raise ValueError(f'Cannot save variables into a pickle file. We only support file with ' + f'postfix of ".pkl" and ".pickle". But we got {filename}') + + check_dict_data(variables, name='variables') + variables, duplicates = _unique_and_duplicate(variables) + import brainpy.math as bm + targets = {k: bm.as_numpy(v) for k, v in variables.items()} + if len(duplicates[0]) > 0: + targets[DUPLICATE_KEY] = np.asarray(duplicates[0]) + targets[DUPLICATE_TARGET] = np.asarray(duplicates[1]) + with open(filename, 'wb') as f: + pickle.dump(targets, f, protocol=pickle.HIGHEST_PROTOCOL) + + +def load_by_pkl(filename, target, verbose=False): + """Load variables from a pickle file. + + Parameters + ---------- + filename: str + The filename to load variables. + target: Base + The instance of :py:class:`~.brainpy.Base`. + verbose: bool + Whether report the load progress. + """ + if not (filename.endswith('.pkl') or filename.endswith('.pickle')): + raise ValueError(f'Cannot load variables from a pickle file. We only support file with ' + f'postfix of ".pkl" and ".pickle". But we got {filename}') + + # load variables + load_vars = dict() + with open(filename, 'rb') as f: + all_data = pickle.load(f) + for key, data in all_data.items(): + if key in [DUPLICATE_KEY, DUPLICATE_TARGET]: continue + load_vars[key] = data + if DUPLICATE_KEY in all_data: + duplicate_keys = all_data[DUPLICATE_KEY].tolist() + duplicate_targets = all_data[DUPLICATE_TARGET].tolist() + duplicates = (duplicate_keys, duplicate_targets) + else: + duplicates = ([], []) + + # assign data + _load(target, verbose, filename, load_vars, duplicates) + + +def save_as_mat(filename, variables): + """Save variables into a HDF5 file. + + Parameters + ---------- + filename: str + The filename to save. + variables: dict + All variables to save. + """ + if not filename.endswith('.mat'): + raise ValueError(f'Cannot save variables into a .mat file. We only support file with ' + f'postfix of ".mat". But we got {filename}') + + from brainpy import math as bm + import scipy.io as sio + check_dict_data(variables, name='variables') + variables, duplicates = _unique_and_duplicate(variables) + variables = {k: np.expand_dims(bm.as_numpy(v), axis=0) for k, v in variables.items()} + if len(duplicates[0]): + variables[DUPLICATE_KEY] = np.expand_dims(np.asarray(duplicates[0]), axis=0) + variables[DUPLICATE_TARGET] = np.expand_dims(np.asarray(duplicates[1]), axis=0) + sio.savemat(filename, variables) + + +def load_by_mat(filename, target, verbose=False): + """Load variables from a numpy file. + + Parameters + ---------- + filename: str + The filename to load variables. + target: Base + The instance of :py:class:`~.brainpy.Base`. + verbose: bool + Whether report the load progress. + """ + if not filename.endswith('.mat'): + raise ValueError(f'Cannot load variables from a .mat file. We only support file with ' + f'postfix of ".mat". But we got {filename}') -def load_mat(filename, target, verbose=False, check=False): - global math, Base - if Base is None: from brainpy.base.base import Base - if math is None: from brainpy import math - assert isinstance(target, Base) + import scipy.io as sio + # load data + load_vars = dict() all_data = sio.loadmat(filename) - all_vars = target.vars(method='absolute') for key, data in all_data.items(): - if verbose: print(f'Loading {key} ...') - var = all_vars.pop(key) - var[:] = math.asarray(data) - if check: _check_missing(all_vars, filename=filename) + if key.startswith('__'): + continue + if key in [DUPLICATE_KEY, DUPLICATE_TARGET]: + continue + load_vars[key] = data[0] + if DUPLICATE_KEY in all_data: + duplicate_keys = [a.strip() for a in all_data[DUPLICATE_KEY].tolist()[0]] + duplicate_targets = [a.strip() for a in all_data[DUPLICATE_TARGET].tolist()[0]] + duplicates = (duplicate_keys, duplicate_targets) + else: + duplicates = ([], []) + + # assign values + _load(target, verbose, filename, load_vars, duplicates) diff --git a/brainpy/tools/checking.py b/brainpy/tools/checking.py index 39cd5eea1..0d47feb1a 100644 --- a/brainpy/tools/checking.py +++ b/brainpy/tools/checking.py @@ -155,12 +155,15 @@ def check_dict_data(a_dict: Dict, """Check the dictionary data. """ name = '' if (name is None) else f'"{name}"' - assert isinstance(a_dict, dict), f'{name} must be a dict, while we got {type(a_dict)}' + if not isinstance(a_dict, dict): + raise ValueError(f'{name} must be a dict, while we got {type(a_dict)}') for key, value in a_dict.items(): - assert isinstance(key, key_type), (f'{name} must be a dict of ({key_type}, {val_type}), ' - f'while we got ({type(key)}, {type(value)})') - assert isinstance(value, val_type), (f'{name} must be a dict of ({key_type}, {val_type}), ' - f'while we got ({type(key)}, {type(value)})') + if not isinstance(key, key_type): + raise ValueError(f'{name} must be a dict of ({key_type}, {val_type}), ' + f'while we got ({type(key)}, {type(value)})') + if not isinstance(value, val_type): + raise ValueError(f'{name} must be a dict of ({key_type}, {val_type}), ' + f'while we got ({type(key)}, {type(value)})') def check_initializer(initializer: Union[Callable, init.Initializer, Tensor], From 6630bd8afc7e39ca5962cd2f135e1edd9ea919e3 Mon Sep 17 00:00:00 2001 From: chaoming Date: Sun, 15 May 2022 21:40:16 +0800 Subject: [PATCH 2/3] test: add io tests --- brainpy/base/tests/test_io.py | 170 ++++++++++++++++++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 brainpy/base/tests/test_io.py diff --git a/brainpy/base/tests/test_io.py b/brainpy/base/tests/test_io.py new file mode 100644 index 000000000..666482b07 --- /dev/null +++ b/brainpy/base/tests/test_io.py @@ -0,0 +1,170 @@ +# -*- coding: utf-8 -*- + + +import brainpy as bp +import brainpy.math as bm +import unittest + + +class TestIO1(unittest.TestCase): + def __init__(self, *args, **kwargs): + super(TestIO1, self).__init__(*args, **kwargs) + + rng = bm.random.RandomState() + + class IO1(bp.dyn.DynamicalSystem): + def __init__(self): + super(IO1, self).__init__() + + self.a = bm.Variable(bm.zeros(1)) + self.b = bm.Variable(bm.ones(3)) + self.c = bm.Variable(bm.ones((3, 4))) + self.d = bm.Variable(bm.ones((2, 3, 4))) + + class IO2(bp.dyn.DynamicalSystem): + def __init__(self): + super(IO2, self).__init__() + + self.a = bm.Variable(rng.rand(3)) + self.b = bm.Variable(rng.randn(10)) + + io1 = IO1() + io2 = IO2() + io1.a2 = io2.a + io1.b2 = io2.b + io2.a2 = io1.a + io2.b2 = io2.b + + self.net = bp.dyn.Container(io1, io2) + + print(self.net.vars().keys()) + print(self.net.vars().unique().keys()) + + def test_h5(self): + bp.base.save_as_h5('io_test_tmp.h5', self.net.vars()) + bp.base.load_by_h5('io_test_tmp.h5', self.net, verbose=True) + + bp.base.save_as_h5('io_test_tmp.hdf5', self.net.vars()) + bp.base.load_by_h5('io_test_tmp.hdf5', self.net, verbose=True) + + def test_h5_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_h5('io_test_tmp.h52', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_h5('io_test_tmp.h52', self.net, verbose=True) + + def test_npz(self): + bp.base.save_as_npz('io_test_tmp.npz', self.net.vars()) + bp.base.load_by_npz('io_test_tmp.npz', self.net, verbose=True) + + bp.base.save_as_npz('io_test_tmp_compressed.npz', self.net.vars(), compressed=True) + bp.base.load_by_npz('io_test_tmp_compressed.npz', self.net, verbose=True) + + def test_npz_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_npz('io_test_tmp.npz2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_npz('io_test_tmp.npz2', self.net, verbose=True) + + def test_pkl(self): + bp.base.save_as_pkl('io_test_tmp.pkl', self.net.vars()) + bp.base.load_by_pkl('io_test_tmp.pkl', self.net, verbose=True) + + bp.base.save_as_pkl('io_test_tmp.pickle', self.net.vars()) + bp.base.load_by_pkl('io_test_tmp.pickle', self.net, verbose=True) + + def test_pkl_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_pkl('io_test_tmp.pkl2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_pkl('io_test_tmp.pkl2', self.net, verbose=True) + + def test_mat(self): + bp.base.save_as_mat('io_test_tmp.mat', self.net.vars()) + bp.base.load_by_mat('io_test_tmp.mat', self.net, verbose=True) + + def test_mat_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_mat('io_test_tmp.mat2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_mat('io_test_tmp.mat2', self.net, verbose=True) + + +class TestIO2(unittest.TestCase): + def __init__(self, *args, **kwargs): + super(TestIO2, self).__init__(*args, **kwargs) + + rng = bm.random.RandomState() + + class IO1(bp.dyn.DynamicalSystem): + def __init__(self): + super(IO1, self).__init__() + + self.a = bm.Variable(bm.zeros(1)) + self.b = bm.Variable(bm.ones(3)) + self.c = bm.Variable(bm.ones((3, 4))) + self.d = bm.Variable(bm.ones((2, 3, 4))) + + class IO2(bp.dyn.DynamicalSystem): + def __init__(self): + super(IO2, self).__init__() + + self.a = bm.Variable(rng.rand(3)) + self.b = bm.Variable(rng.randn(10)) + + io1 = IO1() + io2 = IO2() + + self.net = bp.dyn.Container(io1, io2) + + print(self.net.vars().keys()) + print(self.net.vars().unique().keys()) + + def test_h5(self): + bp.base.save_as_h5('io_test_tmp.h5', self.net.vars()) + bp.base.load_by_h5('io_test_tmp.h5', self.net, verbose=True) + + bp.base.save_as_h5('io_test_tmp.hdf5', self.net.vars()) + bp.base.load_by_h5('io_test_tmp.hdf5', self.net, verbose=True) + + def test_h5_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_h5('io_test_tmp.h52', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_h5('io_test_tmp.h52', self.net, verbose=True) + + def test_npz(self): + bp.base.save_as_npz('io_test_tmp.npz', self.net.vars()) + bp.base.load_by_npz('io_test_tmp.npz', self.net, verbose=True) + + bp.base.save_as_npz('io_test_tmp_compressed.npz', self.net.vars(), compressed=True) + bp.base.load_by_npz('io_test_tmp_compressed.npz', self.net, verbose=True) + + def test_npz_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_npz('io_test_tmp.npz2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_npz('io_test_tmp.npz2', self.net, verbose=True) + + def test_pkl(self): + bp.base.save_as_pkl('io_test_tmp.pkl', self.net.vars()) + bp.base.load_by_pkl('io_test_tmp.pkl', self.net, verbose=True) + + bp.base.save_as_pkl('io_test_tmp.pickle', self.net.vars()) + bp.base.load_by_pkl('io_test_tmp.pickle', self.net, verbose=True) + + def test_pkl_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_pkl('io_test_tmp.pkl2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_pkl('io_test_tmp.pkl2', self.net, verbose=True) + + def test_mat(self): + bp.base.save_as_mat('io_test_tmp.mat', self.net.vars()) + bp.base.load_by_mat('io_test_tmp.mat', self.net, verbose=True) + + def test_mat_postfix(self): + with self.assertRaises(ValueError): + bp.base.save_as_mat('io_test_tmp.mat2', self.net.vars()) + with self.assertRaises(ValueError): + bp.base.load_by_mat('io_test_tmp.mat2', self.net, verbose=True) From 55e9cfa1ce5a4591227558e5f84bcfe67c758a97 Mon Sep 17 00:00:00 2001 From: chaoming Date: Sun, 15 May 2022 21:41:26 +0800 Subject: [PATCH 3/3] doc: update advanced tutorial documentation --- docs/quickstart/training.ipynb | 568 ++++++++--- docs/tutorial_math/base.ipynb | 1146 ++++++++++++++-------- docs/tutorial_math/compilation.ipynb | 457 ++++++--- docs/tutorial_math/control_flows.ipynb | 156 +-- docs/tutorial_math/differentiation.ipynb | 869 ++++++++++------ docs/tutorial_math/variables.ipynb | 611 +++++++++--- 6 files changed, 2543 insertions(+), 1264 deletions(-) diff --git a/docs/quickstart/training.ipynb b/docs/quickstart/training.ipynb index 2d53c265c..c96c0d943 100644 --- a/docs/quickstart/training.ipynb +++ b/docs/quickstart/training.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "39d2c36a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Training a Recurrent Neural Network" ] @@ -23,7 +27,11 @@ { "cell_type": "markdown", "id": "963febbb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In recent years, we saw the revolution that training a dynamical system from data or tasks has provided important insights to understand brain functions. To support this, BrainPy porvides various interfaces to help users train dynamical systems. " ] @@ -32,7 +40,11 @@ "cell_type": "code", "execution_count": 1, "id": "a1b728b3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import brainpy as bp\n", @@ -48,7 +60,11 @@ "cell_type": "code", "execution_count": 2, "id": "4dc60d4f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" @@ -57,7 +73,11 @@ { "cell_type": "markdown", "id": "df1fb3e0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## General usage" ] @@ -65,7 +85,11 @@ { "cell_type": "markdown", "id": "d4b786dc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In BrainPy, we provide a general interface to build neural networks, supporting feedforward, recurrent, feedback connections. " ] @@ -73,7 +97,11 @@ { "cell_type": "markdown", "id": "c1137498", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Model Building\n", "\n", @@ -103,7 +131,11 @@ { "cell_type": "markdown", "id": "384f3cad", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Model running & training\n", "\n", @@ -129,7 +161,11 @@ { "cell_type": "markdown", "id": "a0c11a8b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Bellow, we demonstrate these supports with several examples. " ] @@ -137,7 +173,11 @@ { "cell_type": "markdown", "id": "2f7f7554", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Echo state network" ] @@ -145,7 +185,11 @@ { "cell_type": "markdown", "id": "a7f32d28", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We first illustrate the training interface of BrainPy using an echo state network. " ] @@ -153,7 +197,11 @@ { "cell_type": "markdown", "id": "694639fe", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For an echo state network, we have three components: an input node (\"I\"), a reservoir node (\"R\") for dimension expansion, and an output node (\"O\") for linear readout. " ] @@ -161,7 +209,11 @@ { "cell_type": "markdown", "id": "9b05212e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "" ] @@ -170,7 +222,11 @@ "cell_type": "code", "execution_count": 3, "id": "97e1dc05", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# create the components we need\n", @@ -185,20 +241,23 @@ "execution_count": 4, "id": "215cd4cc", "metadata": { - "scrolled": false + "scrolled": false, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "# crerate the model we need\n", + "# create the model we need\n", "\n", "model = i >> r >> o\n", "model.plot_node_graph(fig_size=(5, 5), node_size=2000)" @@ -207,7 +266,11 @@ { "cell_type": "markdown", "id": "1556b04c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We use this created network to predict the chaotic time series, named as Lorenz attractor. Particurlaly, we expect the network has the ability to predict $P(t+l)$ from $P(t)$, where $l$ is the length of the prediction ahead. " ] @@ -216,7 +279,11 @@ "cell_type": "code", "execution_count": 5, "id": "d5e98200", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stderr", @@ -235,27 +302,33 @@ "cell_type": "code", "execution_count": 6, "id": "15315b50", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(10, 5))\n", "plt.subplot(311)\n", - "plt.plot(data['ts'].numpy(), data['x'].flatten().numpy())\n", + "plt.plot(bm.as_numpy(data['ts']), bm.as_numpy(data['x'].flatten()))\n", "plt.ylabel('x')\n", "plt.subplot(312)\n", - "plt.plot(data['ts'].numpy(), data['y'].flatten().numpy())\n", + "plt.plot(bm.as_numpy(data['ts']), bm.as_numpy(data['y'].flatten()))\n", "plt.ylabel('y')\n", "plt.subplot(313)\n", - "plt.plot(data['ts'].numpy(), data['z'].flatten().numpy())\n", + "plt.plot(bm.as_numpy(data['ts']), bm.as_numpy(data['z'].flatten()))\n", "plt.ylabel('z')\n", "plt.show()" ] @@ -264,7 +337,11 @@ "cell_type": "code", "execution_count": 7, "id": "b0307a30", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def get_subset(data, start, end):\n", @@ -278,7 +355,11 @@ { "cell_type": "markdown", "id": "1b724874", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "To complish this task, we use Ridge Regression method to train the network. Before that, we first initialize the network with the batch size of 1, and then construct a Ridge Regression trainer. " ] @@ -287,7 +368,11 @@ "cell_type": "code", "execution_count": 8, "id": "082b5afb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "model.initialize(num_batch=1)\n", @@ -298,7 +383,11 @@ { "cell_type": "markdown", "id": "987258e2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We warm-up the network with 20 ms. " ] @@ -308,7 +397,10 @@ "execution_count": 9, "id": "5b22aec8", "metadata": { - "scrolled": false + "scrolled": false, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { @@ -317,7 +409,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "78634c618aca41408fe4f14e2c884a24" + "model_id": "6af4ff11cde2496d90e0f06588e6ee20" } }, "metadata": {}, @@ -343,7 +435,11 @@ { "cell_type": "markdown", "id": "7c18d1e6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The training data is the time series from 20 ms to 80 ms. We want the network has the abilitty to forecast 1 time step ahead. " ] @@ -352,7 +448,11 @@ "cell_type": "code", "execution_count": 10, "id": "0c8e656f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -360,7 +460,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "41f460b810de4ff09d278b17a862749a" + "model_id": "6e37f0f47a694cd3ac6aacffd1dbff73" } }, "metadata": {}, @@ -372,7 +472,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "56445da9f9cf4b1aa3ae96be1fdfd202" + "model_id": "bf1eb86de0ff4f5bb47f237d5d3e35d8" } }, "metadata": {}, @@ -389,7 +489,11 @@ { "cell_type": "markdown", "id": "32fb0308", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Then we test the trained network with the next 20 ms. " ] @@ -398,7 +502,11 @@ "cell_type": "code", "execution_count": 11, "id": "f5409c62", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -406,7 +514,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "9d00b7dde4284b629d835036a89af3b0" + "model_id": "3c41730b94af4bc99d382c05a8382b36" } }, "metadata": {}, @@ -414,7 +522,7 @@ }, { "data": { - "text/plain": "DeviceArray(0.00120781, dtype=float64)" + "text/plain": "DeviceArray(0.00014552, dtype=float64)" }, "execution_count": 11, "metadata": {}, @@ -434,7 +542,11 @@ "cell_type": "code", "execution_count": 12, "id": "4d8641aa", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def plot_difference(truths, predictions):\n", @@ -464,15 +576,20 @@ "execution_count": 13, "id": "41439296", "metadata": { - "lines_to_next_cell": 2 + "lines_to_next_cell": 2, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -483,7 +600,11 @@ { "cell_type": "markdown", "id": "52e828f6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We can make the task harder to forecast 10 time step ahead. " ] @@ -492,7 +613,11 @@ "cell_type": "code", "execution_count": 14, "id": "40a1f139", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -500,7 +625,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "1f770b38661b48b7adad44f8d785ba79" + "model_id": "350c138e220548908db0ae2aa95912cd" } }, "metadata": {}, @@ -512,7 +637,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "3d68fb52a1e54325bcc862b034bde1af" + "model_id": "040d77444c674aecbc7d234311987445" } }, "metadata": {}, @@ -524,7 +649,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "5686021679674dc3af822e1310784997" + "model_id": "9d6585c0632f42398e22cc65fd046fc5" } }, "metadata": {}, @@ -536,7 +661,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "6bdf9a3fc351452da2b849bdb15a1351" + "model_id": "5fc7b2a8f50b490a9f263011c9327a29" } }, "metadata": {}, @@ -544,10 +669,12 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -569,7 +696,11 @@ { "cell_type": "markdown", "id": "7f6cd7be", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Or forecast 100 time step ahead. " ] @@ -578,7 +709,11 @@ "cell_type": "code", "execution_count": 15, "id": "2a369627", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -586,7 +721,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "b90b10efc365432198df409746c31683" + "model_id": "2b034993782146a6972931221c0a423f" } }, "metadata": {}, @@ -598,7 +733,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "90b49300b2884d3db59533bd80f3b8be" + "model_id": "d97a1247baf94a34ad23e465141f10df" } }, "metadata": {}, @@ -610,7 +745,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "3535d23325044629aa5c044bd342f98e" + "model_id": "c388f9f0f0844c88a0575da28a44974b" } }, "metadata": {}, @@ -622,7 +757,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "d2be763e3f4042698a5e04017d9515ff" + "model_id": "1e8edac4873f4f6f8776d548351bc50f" } }, "metadata": {}, @@ -630,10 +765,12 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAC77ElEQVR4nOydd3gc1bXAf3e7eu/dtlxkWZZ7L9iYEjC9BAKYDgmQBgSSvFBeXhJqaKFDaAEMAUw3GDDuXbbcLVuWJVm9d+1qd+e+P2YlrSxptbJXloz39336NDtz587Z2d0595R7rpBS4sWLFy9evDijGWwBvHjx4sXL0MOrHLx48eLFSze8ysGLFy9evHTDqxy8ePHixUs3vMrBixcvXrx0QzfYAniC8PBwmZycPNhiePHixcspRVZWVpWUMqKnYz8J5ZCcnMy2bdsGWwwvXrx4OaUQQhT0dszrVjqdaK6GnR+Ad26LFy9e+sCrHE4n1j8Ny26FI6sHWxIvXrwMcbzK4XSi6qD6/+0LIWf54MrixYuXIc1PIubgxU3MDZ3b656CUecOnix9YLVaKSoqwmw2D7YoXgCTyUR8fDx6vX6wRfFykvAqh9MJc33ntil40MRwh6KiIgICAkhOTkYIMdjinNZIKamurqaoqIiUlJTBFsfLScLrVjqdsDTAmAsgOBEU22BL4xKz2UxYWJhXMQwBhBCEhYV5rbjTDK/lcDphboCAGGitBWvLYEvTJ17FMHTwfhanH17L4XRBUVTLwRQIBr9TQjl48eJl8PAqh9OFtiZAgjEQ9D5gbR1siYY85eXlXH311QwbNoxJkyYxY8YMli1bdlJlyM/PJz09vcu+3bt3k5mZSWZmJqGhoaSkpJCZmcmZZ57pdp/vvfdex+s333yTO++806Nyezn18SqH0wWLI1PJFAh6X2jzWg6ukFJy0UUXMXfuXPLy8sjKymLp0qUUFRV1a2uzndz4zbhx48jOziY7O5sLLriAxx9/nOzsbL7//nu3ZDpWOXjx0hNe5XC60J7G2mE5eJWDK1auXInBYOD222/v2JeUlMRdd90FqKPtyy+/nMWLF3PWWWdRU1PDRRddREZGBtOnT2fXrl0APPTQQzzxxBMdfaSnp5Ofn09+fj5jxozhlltuYezYsZx11lm0tqrWXFZWFuPHj2fGjBk8//zzbss8f/58/vSnPzFv3jyeeeYZrr/+ej766KOO4/7+/gDcf//9rF27lszMTJ566ikASkpKOOecc0hNTeUPf/jDcd41Lz8lvAHp04UOyyFItRxOIeXw8Bd72VfS0HfDfpAWG8iDi8f2enzv3r1MnDjRZR8bN25k165dhIaGctdddzFhwgQ+/fRTVq5cyXXXXUd2drbL8w8dOsT777/Pq6++yhVXXMHHH3/MNddcww033MBzzz3HvHnzuPfee/v1vurq6li9Wp0Bf/311/fY5pFHHuGJJ57gyy+/BFRFl52dzY4dOzAajYwaNYq77rqLhISEfl3by0+LQbMchBAJQogfhRD7hRB7hRC/cewPFUJ8J4Q45PgfMlgy/qQwH6McbGY1SO3FLe644w7Gjx/PlClTOvYtWrSI0NBQANatW8e1114LwIIFC6iurqa+vr7HvtppjxUATJo0ifz8fOrr66mrq2PevHkAHX26y5VXXtmv9u0sXLiQoKAgTCYTaWlpFBT0Wo/Ny2nCYFoONuBuKeV2IUQAkCWE+A64HvhBSvmIEOJ+4H7gvkGU86eB5Ri3EoCtVc1cGuK4GuEPFGPHjuXjjz/ueP38889TVVXF5MmTO/b5+XXeO9lDMUMhBDqdDsVJCTvPFTAajR3bWq2W1tZWpJQnlDbqLJPztaWUtLW19XresbKc7DiKl6HHoFkOUspSKeV2x3YjsB+IAy4E3nI0ewu46CQKddIuddJpnx3dHpAGb8aSCxYsWIDZbObFF1/s2NfS0rsrbu7cubz77rsArFq1ivDwcAIDA0lOTmb79u0AbN++nSNHjri8bnBwMEFBQaxbtw6go8/jITk5maysLAA+++wzrFYrAAEBATQ2Nh53v15OD4ZEQFoIkQxMADYDUVLKUlAVCBDZyzm3CiG2CSG2VVZWnrgQK/4Cz0386Wbx9GQ5nEJxh5ONEIJPP/2U1atXk5KSwtSpU1myZAmPPvpoj+0feughtm3bRkZGBvfffz9vvaWOby699FJqamrIzMzkxRdfZOTIkX1e+4033uCOO+5gxowZ+Pj4HPd7uOWWW1i9ejVTp05l8+bNHVZFRkYGOp2O8ePHdwSkvQwRNr8Cez4ZbCkAED2ZwydVACH8gdXA36SUnwgh6qSUwU7Ha6WULuMOkydPlie02I+1Ff4WrW7f/APET3bd/lTk+4dhw7PwlyrY8zF8fBPcsRUi+n5YDQb79+9nzJgxgy2GFye8n8kA09YCf49Rtx+sg5MwK10IkSWl7PGBN6iWgxBCD3wMvCulbFeX5UKIGMfxGKBiwAWpdQq+NZYN+OW6sf9LdRGegcTSoFoNQji5lbyWQweKHVpqvEF6L4NHbX7ndrMHvCEnyGBmKwngdWC/lPKfToc+B5Y4tpcAnw24MK01ndtN5V2PffcgrH1yYK//wS/URXgGErOjdAaA3qT+98YcOmkogboCaK0ebEmGNm3N8NwkWPNE322PFyl/2vG/3qh1ikdV5w6eHA4G03KYBVwLLBBCZDv+fgY8AiwSQhwCFjleDywtvSgHKdXV037434EbUdYd7dy2DmDVS0sjGAPUbVeWQ0sNbHkVbJYBE6XBbOWPL7zPgX/fPrDv2V3sVmhxKIUhFnMqqzeTV9mEMlQelge+Uh9cK/86MP1LCe//HB4fDg2lA3ON42TAXfA1TsqhvvtM/JPNYGYrrZNSCillhpQy0/H3tZSyWkq5UEqZ6vhf03dvJ4iz5dBc1fN2VY57fVXmwOMj4ND3fbcF6rM+7HzRWOLeNY4HSwMYg9TtduXQ1ty93fqn4et7YN/nAybKir3lLCx9mdGF76OU7Byw67iLbK0FJHahHzhrqrmyu1XaB4oiqWg002Sx0WwZGqmlRzd2zrimeQCsrMKNcPAbaKnGNoRWK/xkexHTH/6czftdZ5udCHkH92BrfyQ3DOCzwE2GRLbSoNNuOQTGd/X1OfsAy/a41ZV972dqH9te77uxoiDWOWWLDOQXwtmt5Beh/u8pvtIef3FTGa5Yv4Un/vUcVU3uWxr7CsuJE6rirSwd/MlW9tYGLFJPjeKLtJk979KQUh0JNpRgrnM/ptVqtXdsN1vsLlqeJKQksHQ9+UqU+rpoq8cvYc1TU3gtUk/JrlUe77+d7/aVs6eozu32L60+zGP2J0j779wBc3k1F+1hj5KCWeMLjYNvNXmVQ91R1XLQGiAkqdO9AF2UQ01e39lQUkqyN6oWQ2t53z7DsuI8AmUjr9kcy3UOoHKQlno1IA3gHwl+kbDv027t2ipVucvy+laGUkqiv7+Te6r+h9rXLwO7G6NbKbl995WM0ajutPLyQR4hSYnG2kITJizoEUjPu9TsnZPPjC2lSDcXWmpXDlqNwGwdfOVgs1oIoonn7RdiRzMgyqEpP4sjShQ/Kpn4lp9ABqIL8j/+C4s+HEn6a0m05K7rs31dSxvRleuZp91FgNKAUlvocZkse75gnG03O5QRlMkQr+Uw6BRnwTMZsP0d8AkBv/AeLYdDShz7tq/nSFUPbhgnDmStYpJlMwC6+iNqBowLcg/sBqA0ZBIAsr74ON+Iaz7cdpT62mq2lqqToNBoYcz5UL63a0PFDlUHAagoysVicyF/URYNH/6KDKlaGKm1a+Dopj5laasuIFLpvMd11QOfjOYSxYoGOzaNkVbhiwRoUa0arVZLZmYm6enpXH755S4nwblCWlu5/rcP8voXGxDATTfexL59+3ptv2rVKjZs2EBrmx29VsNn773F0vf+c1zX9iTS2ooiBYa089mrJGHLW+3xa2jLd7FHplAaNJ7wtmKoyfP4NcL3vdWxfXTLF322P7h7M28bOue3VB/J9rhM9hUPUC6D2Rl/NUdtIVjrBuZZ0B9Ob+UQOkytNdRaAz6hqrvlGOXQqI9ghzKCUaKQ9za7doFEfv9bFCn4MWAxemnF3scIo6LgAABjxs+gXvrSXDUAIxKbnX98tQ9/WtlSaqO8wREA9o8Gc50aG3njZ9BaR0NZHgapjnKjZCVrD1b13vF3fyFov1r2eX/gbACai/b23t5B2Z4fu7xubRjc7CDpCIhr9D7oDCZa8ekISvv4+JCdnc2ePXswGAy89NJLXc61290bzVstan8aozoJ7dmnnyAtLa3X9u3KoaXNjo9ey0233srPLrkSRRnkOUk2C3vFcM6cPIbNyhg0Zbs8m6jRUkOguYQSn1GI9EsBMO/+1HP9A0pLLf72en4IuYIaAmiq6DuGoOz+GEUKss98H4Dawv0elQlLE74NebxtP4tzZk+nnFCUARoo9ofTWzn4hGCPn65u+zqUQ2stfHUPALJiPwftUWjCRxAh6qnZvQJa63ruq7WOMHM+SwNvRDv+cgCOHnIdbG2rPIQNLcNGjKJUhtFc6XnlsDqnEnNrEzqh0CB9+WKnw1z1ccwrfPdSKFgPez9hV/YWAOpj5xIl6th8yIXf0ymzonXRIzRLIzWFfSsH/a73u7y2tdT27w15GJvjwa03+WHSazBLHdLe3a00Z84ccnNzWbVqFWeccQZXX30148aNw263c++99zJlyhQyMjJ4+eWXAdXlduedd5KWlsaFl19NWVUtPiY1hfic8y6gfdLmN998w8SJExk/fjwLFy4kPz+fl156iaeeeooLF85k17aNPPXo33jrpeew2BSys7OZPn06GRkZXHzxxdTWqvdv/vz53HfffUydOpWRI0eydu1az94oRUErrRwJnMLYmEAKZBQauwWaPDcvqD05QRObSVLyCAqVCJrzPOu6yt+n9mdMXUCVMRltQ99ZQdHla9mrT2PYpDOpl75YKj2cZupIYW0LTGZaSihlMgR9a2WfnoeB5rQu2b0tv4atOSZ+qUEtQOcbph7Y+ios+DOiJIvttp+RkToWtsKT5gdpe+NjDL/q/sOrKNxPJBCePJaRaRNhHZQf3kXy9It6vHZtcxv+LUU0+ccxJjaUzYQSMgCjha92l5LgYwUJJv9g1hyq4uY5wzqVQzsbnqNGzgEgMP1sKFnDkSMHgczundrakI2l/KBMon7ERZw7agxHZSS+ZbvUYF1vMztLdxFTs5mXxJXcNrIBkbMcYa7Hrki0GhezQZffD2W7j+v990r0ODj3EextLUipxddkgDY7ZnQIxdZlRGyz2Vi+fDnnnHMOAFu2bGHPnj2kpKTwyiuvEBQUxNatW7FYLMyaNYuzzjqLHTt2kJOTw+7duynauZrxZ1zEzVotCqIjoFlZWcktt9zCmjVrSElJoaamhtDQUG6//Xb0Rh8WX3sbo/xb2bLmO6zCgMVm57rrruso5/3AAw/w8MMP8/TTT3fIuWXLFr7++msefvjhLov/nCh2aysCiYjNJCLASJ0xFhRU12tgrEeuUZ27hQggcuQUxsYGslMmMtndLEE3Kdm/kWHA6ImzqD/yMf7le6lushDmb+yxvb2xkmRrLt9G38Y4HwP7NTEY6w57VCZ7dR5aIDh+FCF+BlqNkWjsdtWLERDt0Wv1h9PachgdE0iO4qhZ31QBQfGdBz/9FQBrxCTS0yd07DZU7Oqxr9z96qhn9NjxRMfEU48/lvKDvV57S34Nw0QZhA7Dx6ClyRiFT6tnMxTMVjvf7yvnnFQ1dTUhJpotR6rV4OaxyqEmj/E139KgC0NEjwOgpSKfBrO1e8eNJQgkK+wTiZh+Fb4GHQ3GKBIadsA3f+xdoKNqPOZQ3IWIq5ZSFZxBgGyiuHbwJuNpbGbahBG9VoNJr8UqHeMlpY3W1lYyMzOZPHkyiYmJ3HTTTQBMnTqVlJQUAFasWMHbb79NZmYm06ZNo7q6mkOHDrFmzRquuuoqBJKk6BDmzJ4FQqAIHUiJIiWbNm1i7ty5HX21l/8GsNoV/GnF2FKGzlIHQGV1bZdy3kuWLGHNmjUd51xyySVAZ/lvT2I1q/G2yNTJCCEwRSSrB5zn6ZwgzQXbOapEMH7kMCICjJTq4vBvOerZEXTxdipFOOHRiQSERhEqGtheWNdr85Ic1dLwSZkKQKH/eJJbdvecBn6cVBaobqrkVHU5WEOo4zk0yK6l09py8Dfq8ItPhzKQPiGI5DmdB3O+poJQ/EedgV90atcT7VbQ6rvsqnLEDxKGpYEQ1PokYWo40msJZrHxX6RpCrAlXQSALSiZwKoVavVUU5BH3t/KAxU0t9lZmOIDB2FEQgzmAwpZBbXMclYOKXPhyBqSRBnVYTMhWFWYMVSTlV/LGaOPqX3oeCBUaiKZmqI+0A7FXcqU/G2w+UU486HOWdhOtJUfwCx9SUgaAYDOP4ygmnwOVzWRGObb+xs5d2DmQUqpoJNttGpDEEJg1GmwCcdPwm7tiDkcy7Glup977jnOPvvsLm2+/vprhBCYW5vxBTQarXpAo0MgabPZXZbn1lkbGabpdNloNWCxu/bvt5fdHoiS20pbCwqC0aPVgUNY3AgoB6Wu0GMjTL+q3ezWDuOMMF+EENhChqOvaVPTgEOSTrj/JouNuNYD1ISOJQIIjYhBc6CZ7flVLEqL6vGcysM7SACSxqjreFTFzseQ8wn2w6vRjvnZCcsEUF98EL0MYPyIRAB8Y8dAJdjK9qGLn+SRaxwPfX6uQohukTMhxPyBEGYwGDN+Gn+1XkPe7MfB6A+/6Jzk870tk8XjY9WZxTHjO/YrNfld+rC1NmKq3UedPhJhUB9y2qA4wpRqciuaul/UbuWsoucA0KUuAsAQNQqAppID7gvfR+roFztLCPc3kh6ufsyjkuPRawWrD1aCT3Bnw2s6q0AGps6CwDgkghRtBZuOdA8Yyzo1NhIRPwKTXn3omTIu4BdtDqvh4Dc9ytNQcZRyGcLEJFWh+ASEEkQzeZWeG4X1B6vFjAaJ1qBWPhVCIHQG9aCb6axnn302L774Ykc57IMHD9Lc3MzcuXNZunQp5uZGSssrWbNuvXoNrZoua7YqzJgxg9WrV3eU8a6pUefb+Pv7Y2lsv++q8jBpFIw+/oSEhHTEE955550OK2Kg0djM2NAR5KcqoNS4SCplII1lnskmkq11RFiLaQ5L71CYxii1KKS14pBHrpF14AgpogxTklpnThcQgUZIDub3Huuzlu6jhkASE9QHt3HYLOxS0JC32SMyAcjqw5RqY4gPUZ8dkclpNEkTDUcGJpXXXdxR+h8KIe4TKj5CiOeAfwy0YCeLRWOjed3+M74pcIzgHA9rgHJdLAvaR823/MiqmW8DUJTb1f/d+vIizmIz9tARHfuCohKJFHVsPtJ9gneDI8i2fOT/QopqrUTEDwegpMDNYFfWm/DXsF5nqda3WFl5oILzM2LQtqnlun38Q5g+LIzv9pUjfTpdGDa0HCEOAP2ka0BnRESMYrpPEZvyustfU3wIRQrGp6d37JuYGMJGZSzNpmhVth5oqyuhgmAmJAYDYPAPJUTTzOHKHhToScDSql7XYOq0WnR6k5rD7+ZM6Ztvvpm0tDQmTpxIeno6t912GzabjYsvvpjU1FRmzpnP7X/8R8dDXKMzIITEYlOIiIjglVde4ZJLLmH8+PEdq7ids2gBn32zkoyzr2XtQfX++ymNtNkU3nzzTe69914yMjLIzs7mgQce8OQt6RFFSvSKBanptJZHRweQJ2ORpZ6Z4V68X02DDkjpLBAanqyOS6sKek/77Q+5O9U5DTFpM9UdjhhjSUkxbbbuVpmUEr/6g5SbhnUorBGx4eTLaNqK3ZsU2xd2u0KU+TAtQZ3VkdNig9krk5El2R65xvHijltpGvAosAEIAN5FrYv0kyAq0MT4hGC+2VPGHWeoD3e7bwTalkqik8d0jIzRaEkbPwU2QNmBjSTOUP27KHYC6lSfYXBMp3IIiEhAiFZ2Hi7imulOJrGlifqVT+MnBUlTL+zYnZSinltT5uaM4Y0vqP8r9qpuoWN4f2shFpvCTeF7YYej4qtvGGeN9eMvn+7hUKOOkemXwbB5rD5YyZ/N9/P4RanMCUlW28ZOZEzdN+wprqPRbCXA1PlgqMnfQyORLBqX2Cl/mC/Bfia2+85mTuFXakBX03XsoWsux2wa29GX8AnBnxaOVHh2fWh3UdpakYDe2KkcTHot5lY9PtZWmpq6K6358+czf/78jtcajYa///3v/P3vf+/W9smnnsFWkYNep+2wDGksZfVHr3JIqw4Gzj33XM4999wu5w2Pj2Dndx9iiRiLyWBgTmYqtFRxULEwMmM8mzZ1n0+yatWqju3w8HCPxhzMra34CgVNu1UFpEb585Icy7S6j1X/+wmuKFi8bxPxQOr42R37RqQMp0maaCrthzXdCxabnaYjajaeId6xNrhfOAAB9jr2lTaQmRDc5ZzD5fUkK4UURV3SKVOkP2tkAjNrPBMoP5B7iLE0YorP6NiXEu7HepnChPof1XhLu0vyJOOO5WAFWgEfwAQckVL+pOoaXzIhjt3F9WzKU0fhSqu6atq86VO7tIuMiuWwLpWpBa8gHROAyorUzAWLxhft3N93tBUBal32gvzDXQt2ffk7Ekq/Zan+IsYM71QaEZGxWNHRWu1mgE/r+KE2d5+LUN9q5fV1R5g5LJSEFbdA7veAAN8wzk6LQqcRLN1yFC57HTnhWp7/MRcC45g+ZVpnJ7ET8LPWEKFU8/3+zppA9tLdpFZ9R4VpOJGBnXEFIQQTEoLZ1hKpLj/a4Aim1RXCZ3dSXV5EkL2GgAinRet9gtEgqfDEYk39xK4oCJsZmzAgnJSYSa+hFSPC2nrCZRJqWtow0YbW4BRPcYy+7da23udJtLVgEQaMeodC9lfLnfgKC5ZBmCnd2qIqSa2+M6PHqNPS5D9MfeGBiWrmwu1UaiKIi+8ccCSH+3OYeAyVJz5K/25fOam2XFr9E9S0deiwHEJEI22rnuw2KXTL5vX4CzNRo2d07PM36igxDiPQXOSRoPTObaq7MWVs57NGp9XQGDAMg2Ie1DIa7iiHrajKYQowG7hKCPGR61NOLa6ckkB0oIm7P9zJA5/t4fG2S7ELHbHD0ru13T/3BaxSS/Hat5G1BdS+fxsAjRe9CaEpnQ0DVeWgbS5T4w6HvodVj2A/+C3/tc2lbtb/dAlGCo2Wem0YZ1S9517RvvbRREt3t9Ijy/dT3WThL/MjnPZK0OqIDDRxwfhY3ttSQE5ZIy+sOsz2wjp+tygVvdbp6xCrZmjNDyjmv9s6c8EP/KjOU2id192dMSExmE31jnRgx0xrtrwCO96h/Mv/wyhsJCYO6zzBVx25jWrJorGnrKgBpK6pFX9aEceMeE16LWYMCJQuZS/6i82u0NTchFZ0xjSAjkSGRFGOtrz7JDKrXUGvmLHrfDu/H1ojUmjwwYKlB/fHQGJXJJq2BiQCja5rEoY+0uEKqT6x1M7swlqSzAdoDuv6e9NqBIf9JhDXtEetKnyc2BXJ89/vZ652L8akKZ0HHN+/Sb4VTD38LLx2Zschq13BZ9dbWNETMu6cLv3ZwkajQUL5cbi7nMqRm612Kg+rS8gGJI7v0swY4XiWeDAbrL+4oxxuklI+IKW0SinLpJQXcjLWWDiJmPRaXr52EhabwtsbC6jJ/CX2P5WDoXsGzdmzJrNZPwXNkVXsful6xrSqH254/DErqgWoud8pmkr+vf4IfH4nrPoHWks9O3QZXD018diuMRpUL5/y4bV9C93+4GgvGliyA6py2Xi4mve3HOXmOcMYY+y5NMUfzhmNv1HH2U+v4fFvczgvI4YrJid0bRSdDhodV8ZWsOFwNSv2lrGvsJyyg1sp00QzZ/r0bv1OTArhsHTkvLfPS3D8Tz36X7Xb+OTOE0b/DEVoWajdzuEegtIDVSLZZlcIaMpDIyQ63+Aux3RaDYrGYZX1RzlIRf0s7DaklJTUtpAkHdlGRv/OdgZ/JAJf4ejb1jW2UdfQiE4oGHyczhECjIEE00Sb9eQq0daaIkJoxK7zBdH1cRGaMBoAc/nxB4wVmw3bez8nWVNO9MTu2T91MbPRYUfZ8tpxX+Pp73L4fe3f8KcZTepZnQccFsRCX4dycyph/8M3y7jAtoKKlIvUWmROBI5UXV8NB9fQL4q2wcPB6iqMwFsb8km05mHxjem0ZhyExKiDqIZyz5cPcZc+lYOUslvIXEr5zsCI04kQ4hwhRI4QIlcIcf9AX298QjAb/7iAnQ+exROXj8eg7zkco9dqGDPnYmKpIsOyvfOA8xwJUEtzBMZxS/A2PtyS38U8nLXwQkL8DByLj1CzjzTWFtjXh/5tN2nbLYfXz4J/TeKvy7ZxZ8Ba7i/6FTjXvhl/VcdmdJCJZb+axa8XpvLYZRk89/MJ3VMq9T4QOYYM7RHSYgK59Z1tyNcWsZAtBCWMRdPDpLWpyaEYgxwpgd8/CBUHoEhd4F6PI7MqyEkJGQOwRWUSRS3b8rsGvk0mE9XV1R5XEHa7neqqCgzYaPOL7Zq15cBgUN1lirsF+KSEmnx1saDy3bRWHiHKko9B2NRZ9zqntF6Ntou1YrN0KoeWNhvSoez1JiflAAj/SLRCIiwnLz7TZLZistRgxkgdQZhMXdOTx6bEUS6Djy9gnPMN8rM7aftHMpPNmyiIORfTpGu6NYtOnw+A5oeHoHh7t+N9sfnHL7h74zQWabOQKXNh3OWdB3Wqm2x4Q2fmkd1uZ/3+AmK3/I02jYnYC/6nW58Zo0dSJMOpO9zPbKLXFqr/93zMjzkVvPDdbs7WZ2NM7J6uOnyEqniLjnh2EmB/GJLzHIQQWuB51MV+ioCtQojPpZSeSVvoBb1WQ5BP38ZU2JQroGS1OqLwDVMzW46Z94BGA9N/ScqK/+GfUd9APeyTyYikmZw3Z2qP/ep+/g5b3nuIqeYN2Le+gTbtwh7bAWqZD1CVQ2tdxyh3Xu0n3KNfCiVAiePH9KcS0HVdqD4h1JffL+pj/ejYCWj3f8HSX09j5YrPGbtDDZb7RA3vWX6thrsWplL3lR/Bopmj3/yThLZGHrX+nPv0S9VGxyhRQ3AMieXbWbN3DYTvhTGLAYiPj6eoqIhKD8Yj7IrE1liBUVqoRiCCjFDSPRvLbLVT3VyJom1CFxDuRsdtavlzjQ4UGx0r2woNBBqh5JhaPNbWjhpeLaIJjW8IVruCNDcQSDNVGh2iPr/rOVIiG6polQ1U19ShGeD1hc0tzZja1IGH9A3DJ9CH+Piun93UlFCyRRwhZf0IGCt2eONcOLoZgRrE3O8/jdG3vNtj4PWMsQn8bdkN/FnzBiy7HX65AbRuPLYKN1Odu5Vpa/7csUuc+3j3c2feBRue63h52//+k6d4kgDRSsu03yPaEzScSIsJZIMuhaSKvsvFdHDMIOeM91PZqUOdZT6qu8WUOSyWGgKpOJpL71W4BpYhqRyAqUCulDIPQAixFLgQGFDl4Da+oXDV+323m3Q9rHqUC+vfBWDEzf/GkOBiUkviNOyX/4fP3ryGMwp3oP3hcfyaC2HCtaoS+uF/4ey/q+UKOpRDlbo4j4OZfsVI6YtoN5HPe/L4M0liJ8D2twk8spyLdtzkkHEmTFzS6ylXTkngsdLPuXX7hSTkqVlSkdMuR+78BGFvU0uFOxMQQ6Is4U9lv4EPgD+VgsEXvV7fMXO4GyU7YOk1cP2XXeM8LqhpMmN+MoNY6QiuT78DZnTPMAJ1kZ3Nf/89M2ybsUy+HeOiv3R1DR3L9w/D+mcovmkHN7yympcMz5Di04K4bXU3l0QHbc20PDsd36ZCnrZdwm916lwTRe+L5vZ1ENZdAVe8/zyROf9h3+i7GPPz/3PrfQPqd2XDv2DeHzpGy70hpeSrd57g/Dyn/v9U0uN3SKsRtMZNZ1Lx61Qtu5/wC/6v7wf3phc6ZsqvsE9ioTabUUueR/SSkeNj0KKdcTt/XWflL1X/gc/ugItf6r1EC6jlXd6+gDCbWlSxadKv8J99G/TwoGfRX7soh9dE5/v2Tel5EKfRCAyx44gtfIPDm79k+JSfdcvM68ZHN/a8P3kOTPhFj9doCUghqD6HPcX1pMd5ZmJsfxiq5TPiAOdITJFj36mFMQCu+7TjpSF6bJ+nzBgeRtyoyQTa6/Bb+3+w/W1alt6Ifevr6voLWW+oq7q1rwmQtwp2q/78fCWKscYKhM0CSbPgNzthys3HL3/yXHX0++F16uslX8KNy9V4RC8IIbjvwskYxl3Use+GxQsRv9kJv9rc/UcUfEys44gbZaC3vg4NRWoA0dYGjX2vsPbyex90Kobrv4az/9ZrW41GEHTWHwAwbnuJhneXqDPXe0JKyH4PRpzJPzfUcVRGYrz9e8Svt/euGAAMfvhOVxVuu2IA0Pw6u0fFABB+wf9hRUfageeQO5eqbjt3+P4hWPsEHFrRZ9OPtx7pUAxy2AK4M8vl4CLjfLXMTPjOF2l7dnLfS3vu+ZiqoHSSze+Ru/AVtA9Wo4lIdXnKnQtGsD7sct62nwO7lmL79n9cl9So2IewmSmS4ayc8Az+i//Rs2IAVcn8Zif8/kDnComgpocn9Z6xP27KfLRCMnz5L6jd9LbqPnVVoXbvJ933TboBLu09lhKefibjNHn8+OaD1H/4q5O+rvZQVQ49DQu63BkhxK1CiG1CiG2edD14nPjJcO9huHVVjyUlemLyTNU3WWFKBsC3+SjaTc+rB/d/ARuf73ZORXAma5QMQhtzQNphwjW9/yDcJXwE/MyxkHzGlR0T9tzBb/5v1Y1RP1N/gIGxEDm6e8Nj3F1NB9eok+g+ua33ztvTeFuqyHnjdnhyZM+r2jnYeSifK4r+oS4DettaSJ7leuQJpE09k11nqmsoBBZ+D48kYq7rQQk1VUBTGS2J8/h8ZzFXTI4nLjxEjdn0xcxfd98X0HMZBwCNXwjL53wMgFh2G7wwTS3l4oKmhtrOSYkfXANPZ8DOpT22te77khlfq2VAlLGXIq58R/0OuCAwZgQHLl6BBT2G+iPwz9G9K626o1Cyg6WN45maEsov5w3v83MANX30vdtmsnPkHQDoNv2Lylcu6n0Wu2Ni3i3iAWac60ZyR0iyml147mPq6zMfhiVfdK6c2AM+Y8+jPlGdMBuy4jfw2gLY00sSp9NntMEwC2XRX1ULefHTLgvrmUbMQYfCXdY3CNr3Lj+u8/z6Ga4YqsqhCHAeUsajetE7kFK+IqWcLKWcHBERwZDGL7wjNdQtUubBVR8Q+fuN2C7sXEOgQEZB5QFY7Vh4xOnBulE3Va2U2U6Ie+6WPplykzrSXvxs/84LT4VfboSLX3bdLu1CSJ5D/nVb2C+T8c96Ab74Dexa2utqWLWFnXnvo4rVh2VhTlbP/St2gpZdQ4KooO2q/0JMRs/teiBj9mKaL3qz47Xp6ZFYmo4pMe5YEGpncwhWu+SiCf0wcDUa+P1++O0euHEF3Nl3gPO8M+bxSPDDnTtczDGob7Wy69kru+6sK4Blt6kWlzN2G3xyKzrZxp5Zz6K59DXXrjQnRo+fRu0dnQqh/t+X9KysCzcC8EXrOG6bO6zXulI9Eepn4Mlr53Johvrdjyhbw5Yvex51y5JsGvFlWGo6PoZ+TCDLvBruzoHZv+27rVZH0I0fcfScNzt25e/Z0HNbpxUlY1NGo5n16x4zIbsR19UFvfKbZby02rMVYV0xVJXDViBVCJEihDAAPwcGbsX7oYYQMOocMPiiS5kNOh8sYy7hGsOz7NY5XDp+EV18lQV1VkyRTu6IuImekyd5lttWTxei0lyOvgB1pHz9lyQPG0Vk7DHF1Sq6h5gsJXsIqehe1ybxy6uxfNfdDy+PrCG5ZTcfR/8Wn5Fn9Et8AL/xF8Ht6zmQeisAqz9+sWuDOjVIv7rSj1A/Axnxwf27QGCs6lpLnKYq1D7QagS33PxLbjapFp1lxUO9zgF49/PlzLT1UgPo2LIX9YXobc28qLmKMQuv69uHfgzREeFYf7mFryJuJshcTP6K7tYt1bkoaKg0JjAn9fgGdKln347lz1XUa4Ip3/4VhdXdV+czH93Obnsy80a5cOv1hEbb7xLZCdMvpv48dQBkyPmcA4d7UNYOpfiuOI+4i//qfuemQLjyPzD3XmRgLFcH7eGR5QfYkOtiES4PMiSVg5TSBtwJfAvsBz6UUvYjNeAnRHAC/PEoxivf4LfnpPPzpt+RdeaHcG8unPFnSLsIgE0tsZiTF6oB6D8W9xl4HIqEjV3QdUdF9xW3dm36AYDcad0VgXH94932Veeqo3Hj+EuPTyghIDqd0Vc/Rokxhei8j6hsdHJnOEaFayt9mZAQ7HpdCg8R5m/knqvVrC7joa9hVfeqtQ111fxqf3eXyhXCcY/Kupael46JbCEJY477PeijRnHmbY+xXTsO3Z6PUI6tIlt9mApNBOMSIzHojv/RY9TrMaTO52diA999/m7Xg3Yrhqp97JEpjDtJQdygKT/HMu4XxIpqgt47r1tsQB78hlIi2DDibvSmfiaHjFkMC/4HMfF6xrRs44yQCh7+Yt+AzQFyZkgqBwAp5ddSypFSyuFSyt6jh6cDjjTZxeNjMfoF8XqBI73SNxQuf5OCq9ewQRlLfESwGoB20x0w5Jj5a5TbN3JhxNcUEoOyZ1m3JtX5u7BgYPjcznkbxGTSoAkGwFzTdWWv2uJD1Ep/MlNPsOSzEBimLCFDHOb7VSs799ccQQbEcLDayoiok3ffRydGU+ujvqeWA991O75z/fLOF8lzICYTgAXzFtAgfag5Zh3khmLVLRQ7rO+kCVcYdVrEuCuIlyXs2LKqyzGlOpdcWySjowNO6BoAPnN+jV1j4Nr8+2koy+88UJmDVmljr0wmJfzE6j31B+NsNR4SYy8hf/2HnQdsbcjDq1lpy2BqStjxX2Cymu30Lx4jt7yOtYcG3noYssrBS3cMOg3npkezKqeys4qkEBxWVFM4ydWaCKcCGg2a6DTuOWskS61z0ZRkdabsAq1tdvR1R6jzSUC0r9o3ZjHctpq8happv3dr16CdUptPsYjyyIMifMZ12NCh3e304y/fQ2vwSKx2yYiIk6uUjbev5DVxKb61OV2WbQVoO+y0WuGV76hpv/ce5udTE9knUxCHfwDH+tkAjSU5NEofkhJPPFY1dsHV2NFQsc1JuUuJrD7MYSWaUR5QDsRP4uDlP6DFTtn3z3TuL1D9/mUBYzuLZp4MosbS8IcyimQ4ti3/7txftAWNtYnVSgaTkkJ6P78v/CNg+AL8Wku41bSST7MHfiEgr3I4xZiTGkFLm53so3Ud+9r9rgmhp7hycDBreDgtAY6RvlNQeldRHcmUIMJGqO6eew/DpeoPcdyk2djR0Ly/6yg6oKWIBlNsv4KfveIXRkXIBGaY11KWu0MN6lYeoNxXjRWMiDy5ysE3KBxbmloxtDl3fecBRSG99nsO+EyAPxxRV/0zBoBfOMG+BjZGXUWIpRiZ83XnKVWHKZBRjPTAg9sQGE6xz0giq7dibXctNVehbWskX3pIOQBpo9P5UTud+LwPwOKooFuwjjJNFD5RfcdvPE2grw8HguYQ37Ad2a54C9UKupvl2BP/flz6OviGcy9vErjvvc57O0B4lcMpxoxhYQgBGw93FtwrqGnB16Alopd1cE81NBpB6gh19nZTRX7H/u0FVSSICgLiHOWv/cLBUUZaa/JnW+AiZtZ9jnQEaKViJ9xejjXgmLkUJ4BhzLkkaCqJ/s98OPAF2Ns4pFFH28NPsnIAmDNjJq3SwNF9Gzv21eduIEpWUZx8abeaPQBRE36GXQrqCjqD0j5NBZTqYgn27V7W5Xiwx88gXeayI8+RtVStrlNSSIzHlKhGI8iJ/zm+SjPykDookJU57LEnMPwkW3Ht6IbPx0Qb5rcuVTPAyvdSpYsmJDT8xC0Z31C44m3s+gDukW+xN39gK7Z6lcMpRpCvnmHhfuwp6ZyUVVjdQmKor2dGx0OEzLQxAOTkdi5+lJuXh0HY8QlP7vGctlGL0WHn6H51MaXasgIM2NCFDeux/fEQdsYd/BtHWZPvHgJge1s8UYFGAk363k8cINLiQijUxGGv6FyvvH7LUixSR3Dm4h7PmTI8iiIZQWORI+BvtxLaVkqL/4kvxdlO+Nj5GIWVon2O9E5Hld62kBEYdZ5z94SOmUuD9KVp33fqfILqXA7aYwdNOSROVAv7+RStg6KtUL6XQyQyItIz1hLJs2i+4BX8hZmSXSv7bn8CeJXDKUh6XBB7izuVQ0GNqhx+SowZro7Gi4rVALOUkorifPWgY62MY0kYrZY7qMxV5zyU5qtB1sBYz7kYhN7E6sQ7OaAdCfWFYPBnc13ISXcpdcgjBC2BwwluOYLN4WYIK/iS75XJpKX0bDENj/CnWBODcKTh2msL0aIgQnuemX08BKSqlUsjDv1Xnc1cdRALBoJiPKeoASYNi2CrMgpZuBFq8hCKjUNKHMMjTl4w2pmU+BjO1b6ivijNRtYcJtsSw0gPJisEj5qLFR2a/LV9Nz4BvMrhFCQ9NoiSejPVTRYURXK0puXUD0Yfg8boR5swUldVil2RlNSbMZkdBe0Ce1YOicmpNEhfrKVq1nN9sVrRMjp5jEdly0wI5geLOttbRozmUJX5pAejnfGNHU2MrGJ3QRlYmvCz1lIVMKrXCWAajaAtIIGgVlXxVjqqqvrF9lGIsT/4hZMVdDZzmr5BbnoBW/kBcpUYRkUHe+4aqIouW4whsCkPHK6lHJkwKC4+UJV1SspwGvCHb/+EUGwctMeS6slMNoMfhb5jSazfOqAprV7lcAqSFqtOLDtQ1khFo7oAzE/NcgCwmULwtdWzp7ieXUfriBKOzKVeLAeNVkOpMYXhtWuhtZa2qiPYpIbwOM+OVjMTg1llzwSgKelMmiy2QbMcAOJSJ6ARkorNH2GvV7NY/CJcu4j0EcMJpIn6mgpqC1XlEJ3s2fqfB2c+zi4lBcuuZdgr9pMr4zwWjG5HqxHURjgW8FnxZ1q0gZSZhhHWQ0n8k8XEpFDylCh1jQ9gvZJOqqfcSg5a4mYxWh7haHHPVQQ8gVc5nIK054nvL22goFpd1yExbHDM6IHEEBBBrKhm3YFSdhbVE6upRQqtOju8Fw4mXkGEUoVt/b/Q1+dTpY1EHFtO/QQZFxfEVjmaD6d/yo4ktXiex3zKx4H/uPMo1CYwLvclivLVhXei4l3XRApNGgdAzY/PMWL3P6mUQaQke6jkioMJSSGsV9IxlWVhbComV4lldHQfM+aPA/+UyR3bLwXcRUpk0KDG3yYlhbBPURfz+nTMP6kUIR6PgQSmLUAjJMU73Vg18jjxKodTkDB/I5EBRvaXNlJQo6axJv0ELQedfziztHuZtu3XFOYfZr4xB+Ef5XLBdX3mz9loT0O37gnSzDto8PVcplI74f5G4oJ9WFsbTK5jBbvBtBzQ+1AQcy7RthIKDmar8qSOcnlKwtQL2KyMJmX3s+gVMzt0mfgaPFvBPzUygF2aTmvkqDaB+BA3ChL2k7EJ4fy27VcULnyR95omDlq8oUOe2CCe4hd8OPxRvm0bT3KYX/9qPLlBfPpcWqQRjvRzNbp+4FUOpyijYwLZX9rA0ZoWNALiBuBHN+ho1IfVZMsWHiz7FWm2/Wr6qgsmJgXzlTINgBAasIT2UAnWA4yLC2J3UR25lU0E+egJ9x88NwZAxLDxaITEkqNmsMTEu7YC/H2MvBn0K9rQ87nuHD5PuNfjMmk1AnNs53KyjeETelxB8EQZHx/Mp8psvrRPparJwrBBjP+AOlk1KS6O9xvHkVPe5NFgdDtavZFDpnRiard4vO92vMrhFGVMTAC5FU3kVjQRG+yDXvsT/Cjn/aFjM0rUqRt9LDQfGWBibeBinuAamqURpYdVtjzBuPgg8qtb2HS4mtHRAYOeRjxipDpCn6TJoUkX6lZtraDkCaRbXufXTdcxOrF/BefcZUxyLG/azmaZfTbxSZ7LhnImIdSHEF89/92mBtg9Hdc4HiYlhbCjsI68qmZGRQ2MPA1R00i2F9JS1/Na8SfKT/CJcnowJjqQNrvCN3vLSB1Ml8ZAkjAVeeUxhdXS+y6gNzE5jH+Zf8Z4y6skT1w0IKJlxKtF3fKqmk9agTdX6ELUAHSoaMIUnujWORMTQ2iTqnWWmXACpR1cMCExhIdsS/id9VdkJgYPyDWEEIyLD+ZIleriGxvr+bhGf5noVCpjcnL3iYiewNeRLlyw44cB6d+rHE5RxsSoPwAp8UjJg6GKCHdKr7z0dZh3X5/nXDBeXddi1sgYgnwGZmJaRlxwx/YJ1czxFL6hHSuZ6YLj+2iscvbYaAKMOqIDTUwbNjAPsGnDQvEzaNFrBXOPs0y3O2Q4FHSgSUdkwHGUl/cw04eFEeKrJy7Yh6kpA3NvR06YhwX9gCmHobqGtJc+GOYUdEuLGfyR0oDhvJrdyLM7ymW4Yv6oCD64dTpjBnAEGeSr5/eLRrKrqI4FY/q5bsBAIAQExkH1IQh2b6ZzkK+e734/D71WDJhbMtCk55NfzcJqVwgbwPIu546L5vV1R7hxtmczro6XIB89K++eDzBgBQAD/P2pSFjIjOjYvhsfB17lcIqi12q4ZnoiP+yvYOGY3peWPOXRGWD4QjVn3OiehSSEYNqwEyiP7Ca/Xnjyi7u5RYTrTCVnooMGfpR9MmIAY2OD2PHAopNbibUPQk7CXIvImz4YsL4Hxa0khHhcCHFACLFLCLFMCBHsdOyPQohcIUSOEOLswZDvVOGvF6az4f4F+Bt/4jr+F/+Faz4ebCmGPlNuBq0REqf33fYnyFBSDD8FBivm8B2QLqXMAA4CfwQQQqShLgk6FjgHeEEI4f3Ee0EIMehZMicFjdbl3AYvDqbfDn/I65fl4MVLbwyKcpBSrnAsBQqwCWiPoF0ILJVSWqSUR4BcYOpgyOjFyynJqboKoJchx1DwR9wItDvO4lCVRTtFjn3dEELcCtzqeNkkhMg5ARnCgZOzavfx4ZXvxPDKd2J45TsxhrJ8vWYvDJhyEEJ8D/Q0s+bPUsrPHG3+DNiA9mT2nnwkPZYdlFK+ArziAVERQmyTUk7uu+Xg4JXvxPDKd2J45Tsxhrp8vTFgykFKeaar40KIJcD5wELZWXe2CHAuhhMPDFzZQS9evHjx0iODla10DnAfcIGUssXp0OfAz4UQRiFECpAKDFzxEC9evHjx0iODFXP4F2AEvnNk22ySUt4updwrhPgQ2IfqbrpDSmk/CfJ4xD01gHjlOzG88p0YXvlOjKEuX4+IgVxJyIsXL168nJp4ayt58eLFi5dueJWDFy9evHjpxmmtHIQQ5zjKdOQKIe4fJBkShBA/CiH2CyH2CiF+49j/kBCiWAiR7fj7mdM5J7XEiBAiXwix2yHHNse+UCHEd0KIQ47/IU7tT5p8QohRTvcoWwjRIIT47WDePyHEv4UQFUKIPU77+n2/hBCTHPc9VwjxrPDQdPhe5OuxpI0QIlkI0ep0H18aJPn6/XmeZPk+cJItXwiR7dh/0u+fx5BSnpZ/gBY4DAwDDMBOIG0Q5IgBJjq2A1DLiaQBDwH39NA+zSGrEUhxvAftAMuYD4Qfs+8x4H7H9v3Ao4Ml3zGfaRnqxJ5Bu3/AXGAisOdE7hdqpt4M1Pk/y4FzB1C+swCdY/tRJ/mSndsd08/JlK/fn+fJlO+Y408CDwzW/fPU3+lsOUwFcqWUeVLKNmApavmOk4qUslRKud2x3Qjsp5dZ4Q6GSomRC4G3HNtvARc57R8s+RYCh6WUBS7aDLh8Uso1QE0P13X7fgkhYoBAKeVGqT5J3nY6x+Pyyd5L2vTIyZbPBUPi/rXjGP1fAbzvqo+BlM9TnM7KIQ446vS611IdJwshRDIwAdjs2HWnw8z/t5MbYjDklsAKIUSWUMuWAERJKUtBVXBA+6IGg3lff07XH+VQuX/Q//sV59g+2XKCWtJmudPrFCHEDiHEaiHEHMe+wZCvP5/nYN2/OUC5lPKQ076hcv/6xemsHNwu1XEyEEL4Ax8Dv5VSNgAvAsOBTKAU1VSFwZF7lpRyInAucIcQYq6LtoNyX4UQBuAC4L+OXUPp/rmiN3kG6z4eW9KmFEiUUk4Afg+8J4QIHAT5+vt5DtbnfBVdByhD5f71m5/EPIfw8HCZnJw82GJ48eLFyylFVlZWlZSyx/Vbh0JV1hMmOTmZbdu2DbYYXrx48XJKIYToNT53OruVTl9W/AX2fjrYUnjx4mUI85OwHLz0A2srbHhW3R5bP7iyePHiZcjitRxON5qH6pojXrx4GUp4LYfTDUvjYEvgFlarlaKiIsxm82CL4gUwmUzEx8ej1+sHWxQvJwmvcjjdsLYOtgRuUVRUREBAAMnJyQy1qgKnG1JKqqurKSoqIiUlZbDF8XKS8LqVTjesLX23GQKYzWbCwsK8imEIIIQgLCzMa8WdZniVw+nGKWI5AF7FMITwfhanH17lcLpxilgOXrx4GVwGVTmIfpaC9uIBnC0HRRk8OU4BysvLufrqqxk2bBiTJk1ixowZLFu27KTKkJ+fT3p6epd9u3fvJjMzk8zMTEJDQ0lJSSEzM5MzzzzT7T7fe++9jtdvvvkmd955p0fl9nLqMxQshzOklJlSysmO1/cDP0gpU4EfHK+9eApny8FuGTw5hjhSSi666CLmzp1LXl4eWVlZLF26lKKiom5tbTZbDz0MHOPGjSM7O5vs7GwuuOACHn/8cbKzs/n+++/dkulY5eDFS08MBeVwLL2VNvbiCZyVg80bYOyNlStXYjAYuP322zv2JSUlcddddwHqaPvyyy9n8eLFnHXWWdTU1HDRRReRkZHB9OnT2bVrFwAPPfQQTzzxREcf6enp5Ofnk5+fz5gxY7jlllsYO3YsZ511Fq2tqlWXlZXF+PHjmTFjBs8//7zbMs+fP58//elPzJs3j2eeeYbrr7+ejz76qOO4v78/APfffz9r164lMzOTp556CoCSkhLOOeccUlNT+cMf/nCcd83LT4nBTmVtLwUtgZellK9wTGljIURkTyc6SkffCpCYmHiy5D31cXYr2U4Ny+HhL/ayr6TBo32mxQby4OKxvR7fu3cvEydOdNnHxo0b2bVrF6Ghodx1111MmDCBTz/9lJUrV3LdddeRnZ3t8vxDhw7x/vvv8+qrr3LFFVfw8ccfc80113DDDTfw3HPPMW/ePO69995+va+6ujpWr14NwPXXX99jm0ceeYQnnniCL7/8ElAVXXZ2Njt27MBoNDJq1CjuuusuEhIS+nVtLz8tBtty6E8p6C5IKV+RUk6WUk6OiOixqKCXnvBaDsfFHXfcwfjx45kyZUrHvkWLFhEaGgrAunXruPbaawFYsGAB1dXV1Ne7Lk/SHisAmDRpEvn5+dTX11NXV8e8efMAOvp0lyuvvLJf7dtZuHAhQUFBmEwm0tLSKChwtV6Sl9OBQbUcpJQljv8VQohlqCtylQshYhxWQwxQMZgy/uQ4BS0HVyP8gWLs2LF8/PHHHa+ff/55qqqqmDx5csc+Pz+/ju2eSt8LIdDpdChOgX/nuQJGo7FjW6vV0traipTyhNJGnWVyvraUkra2tl7PO1aWkx1H8TL0GDTLQQjhJ4QIaN9GXcN2D/A5sMTRbAnw2eBI+BPFazm4xYIFCzCbzbz44osd+1paek8Dnjt3Lu++q66Ps2rVKsLDwwkMDCQ5OZnt27cDsH37do4cOeLyusHBwQQFBbFu3TqAjj6Ph+TkZLKysgD47LPPsFqtAAQEBNDYeGqUUfEyeAym5RAFLHOMknTAe1LKb4QQW4EPhRA3AYXA5YMo40+PU9ByGAyEEHz66af87ne/47HHHiMiIgI/Pz8effTRHts/9NBD3HDDDWRkZODr68tbb6k5FZdeeilvv/02mZmZTJkyhZEjR/Z57TfeeIMbb7wRX19fzj777ON+D7fccgsXXnghU6dOZeHChR1WRUZGBjqdjvHjx3P99dcTEuLNFvfSnZ/ESnCTJ0+W3sV+3GTpL+CAGohkyReQ4naY56Syf/9+xowZM9hieHHC+5n89BBCZDlNI+jCYAekvZxsrC10LF/rtRy8ePHSC17lcLphbQXf0M5tL168eOkBr3I43WhrAh+HcvAGpL148dILXuVwutHWDP6OeYXeInxevHjpBa9yON2wNIFfuLrtdSt58eKlF7zK4XSjrRn8vJaDFy9eXONVDqcTigLWZvANAwRYvTEHV2i1WjIzM0lPT+fyyy93OQmuL5yL4N18883s27ev17arVq1iw4YNHa9feukl3n777eO+thcvx4NXOZxOWJvV/0Z/0Pt4LYc+8PHxITs7mz179mAwGHjppZe6HLfb7cfV72uvvUZaWlqvx49VDrfffjvXXXfdcV3Li5fjxascTicsjpIJBj+HcvDGHNxlzpw55ObmsmrVKs444wyuvvpqxo0bh91u595772XKlClkZGTw8ssvA2otozvvvJO0tDTOO+88Kio6S4TNnz+f9kmb33zzDRMnTmT8+PEsXLiQ/Px8XnrpJZ566ikyMzNZu3Ztl7Lf2dnZTJ8+nYyMDC6++GJqa2s7+rzvvvuYOnUqI0eOZO3atSf5Dnn5qTHYJbu9nEyaq9T/vuGg9z11lMPy+6Fst2f7jB4H5z7iVlObzcby5cs555xzANiyZQt79uwhJSWFV155haCgILZu3YrFYmHWrFmcddZZ7Nixg5ycHHbv3k15eTlpaWnceOONXfqtrKzklltuYc2aNaSkpFBTU0NoaCi33347/v7+3HPPPQD88MMPHedcd911HeW8H3jgAR5++GGefvrpDjm3bNnC119/zcMPP9xl8R8vXvqL13Loi7LdPx3ffHOl+t8vwutWcoPW1lYyMzOZPHkyiYmJ3HTTTQBMnTqVlJQUAFasWNFRO2natGlUV1dz6NAh1qxZw1VXXYVWqyU2NpYFCxZ063/Tpk3MnTu3o6/28t+9cWw57yVLlrBmzZqO45dccgnQWf7byylE0TZY+X9gHzrVcL2WgyssTfDSbBh2Blz36WBLc+K0Kwf/yFPLreTmCP+4aaoEcx2EDgONtmN3e8zhWI4t1f3cc891K5D39ddf91l6+0TLcx9Le9ltb8ntU5BPboWaw5A0C4afMdjSAB6yHIQQdwohfnqlHesK1f95Pw7cNWy919j3OB2Wg8OtZDsB5VCyA6oPH9eplY0Wmi1D5OElFWgoUmeOm10vztMTZ599Ni+++GJHOeyDBw/S3NzM3LlzWbp0KXa7ndLSUn78sft3aMaMGaxevbqjjHdNTQ3QWVJbkRKLtTPoHRQUREhISEc84Z133umwIk4KigLf/Om4P3cvvdBSoyoGgIL1gyuLE55yK0UDW4UQHwohzhGeHA4NJvVHB7b/lhp4chR89+DAXqedpgrQGsEYCDrT8VsOih1emQ/PT4N+VvWtaW7jzH+u5pIXNvS4QM5Jp83JtdbW1O/Tb775ZtLS0pg4cSLp6encdttt2Gw2Lr74YlJTUxk3bhy/vP125s2Y3JkQ4CAiIoJXXnmFSy65hPHjx3es4rZ48WKWLVtGesZ43v/8W6z2zsWC3nrrLe69914yMjLIzs7mgQceOL73fRxISz1seh7lmz8N3EWObkG+uhBq8gbuGq21YHZ/2Vm7Ivkxp4KmgRrQVB7o2FSKsgbmGseBx0p2OxTCWcANwGTgQ+B1KeWADzMGrGT3llfhazUoyP9Ugs7g0e5zVn/IqB9vUV/cfRACojzafzc+vgWOboLf7ob3r4a6AvjlenVEiFRdKke3wrp/wiWvgDGg535qC+CZDAAql6wjImWc2yIs3VLI/Z+oweUf75lPSrhfj+1OVnlo2VSBaCimFSMmLYio3lNMj5vmSqgvQgotIibDrVPsisJex7rZkQEmooNMnperP0iFfZt/IO2by7ALLdp7czsLOHoKRaHq8YmEtx6hcvLdRJw/AIpPscPzU9VBzV1Z4MY49uXVh/nH8gNcNyOJ/70w3fMybX8bPr+LdfaxTDIexefPhW7J5QlOSsluqWqZMsefDQgBPhJCPOapa5x0nC0HN6yIfSUNvLUhH4vNvfz3HZudXA3r/tlf6fpPXSEEJ6nbeh91pLz1dfjfEHgkCRQ7lpWPQM7XkL+u935qO1cz0755Dlk//Ne96zdXEbD5SQJQR+sHSt0fvQ0UNnMzVqmlXvoi7JYBCQhaWxzvU9pVN5YbNFs6v0Nm6/HNp/Ak0tqKkAov2C5AK+1w8FuPX6N196eEt6rfrYacNX20Pj6s+7+C6lyoOYyscb0qXzu1m9/j3/rH2Lp7/4DIRNUh2tCzXJmGj61hyLjtPBVz+LUQIgt4DFgPjJNS/hKYBFzqiWsMBkrZno5tW1Wuy7bmxlr8X5nC1G8Wc+j1Wxyj8d4prW8lrPEAh5Q4sjTparbCAFDfYuWFVbnkVjQ5lEOiekDvA7X58NXv1ddtjXy3cRtFh/eqrytzeu/U8aPKUlIJFU2EbnIvYCx3LuW86jfZbbqZWZrd5FU1H+e78iDWVlox0iIdI3NPZ3BJiXBMPhSA3ereGhpNFhsaIQgw6WmzuadQBhKbWXW5fWk4l1ZpwF7q4dRioCr7a2qlPx/Y5xPVtL/fLkt3yN/8Zcd23u4NLlqqlBcd5v6WJ1igzeYy88eUN3g+c7GlNIcjShQ79apV2Za7yuPXOB48ZTmEA5dIKc+WUv5XSmkFkFIqwPkeusbJpb4YzeEf+NI+DYC9e7JdNt+96kMSKWOMppD00o+h1HX71Vm7ma3ZQ11YJvnWEJSGUg8J3pXPXnsY+/d/5ZZ/r0c2ljopB99ubX9cs4o4oc6FqC852HuntUewCz1XtD3ACt/ziWvLd+uhV1faOSL6g/ET8ipdK4eBjklIxY5OWlB0JjR6NdMHu2cTBKxWCzrsNKrLpWMxu6d8miw2fA1aTHoNFrsy6PEZa2sTdim4ZP408mUULWUuBg/Hia5kG3vFCHySp+Evm7BXeX4ErSnJIluMwSY1VBza3mf70rXvAFAVMIYLtOs5XFbncZnspbs5JOP42bzZFMswWg985/FrHA8eUQ5SygeklAW9HBsgW2xgse9W6+B8G3kzLZgozT/gsv3RA9uxoeXfk5cB0Hpkk8v2qZv/B72ww8TrqJRBql/aww+ArCOVXFfzHHfpPiWyfjcC2dVycEIi+GXrq5iEmnXTUObC5K7Jo0wTRXJEIIGj52MQNkpytvYpT0vpQSplEHbfSFIoRVu+s9e2JpOJ6urqAX0otplbEIDW6IdWb0CCx5VDa7MahDYEqJVw7W19jzxtdgWz1Y6fUYdBp0FK2SUofbKRUlJfX4+1qYrZIyMokhEotZ5N1rA3VhJlyacufCI+KVMAqDro+jfUX3JLa0mwHoGEaZRoY9HX9P1oshbtoIRIxPz7iRANsOcjj8pEay0B5hJKfEZydnoM6+zj8CneoMZGBhnvPIdjaa6Cdy6CioMcVmK4YOE8Gr6Ix9iQT5tNwaDrrk/zKpvwbzhEQ0AiI0eOo3arP+b8nfjM7vkSNYezmGTZzMbEW4lNm0PVN5+jUdrUVEqfYI+9lWXfrWKSY/t6g2O2bIg64QqDUyD4zIfIXfshqZZ9yNARrK0PZ0RjUS/C58H+L9hvn8gFM+IITYmH7RD7ySUw8kjXfo9BX3+EndqxLJw8m8A1j/FY9V3QeHaPgfj4+HiKioqorKw8jnfuHubmekzWeuz+WlpsUG+uRmNoRvj2P6W1N1rqq/CRrYggI0p9FW2aRkyVrmMt5jYbsqWaKp0GqzGUyqY2lBoDRr3W5XkDhaIo+BzdjKWskDFnXMl2gtG15nv0GgVbv2QYkoCxZxM8LBPzaj2t+Vth1jUeu8bqjRu5SdhJSZ9CQV0+kQ0HXM41sdjsRDTlUBs8mjHjz+fg5/Ek5H0I3OkxmVoLd+AD+CZNIjHUlxdI40rrKtWtOxDJEf3AqxyOZdOLULYbLVCnC2fh6Egq1qUQ37yP3cV1TErqnqHx5abdXKPJwTduPuMTgzkg44it6N3SaP3qj1TJQCIX3kV8iC91mmD1QHOlx5TDvpIGGvJ3gCPB6lyxEQAZlaauIO30EC8aextvLD/K3/X7EHETEQKCq3dgtytotccow50fAPCq7TwezYwlLsSHL5SZLGYDFGdBytwe5bG1WQi1liLDFiDCRnTst1QcwtiDctDr9R0zhweK7x65gqmWjQQ9UMjyPWUYli9heEI8Abd84ZH+D1c0ELD0fAhLJf7X33Dk0VtoNUvGPOja1/3tK3/i7JLnASi77Asu+ryRxy7N4IqMBI/I1V/WrvyKOZvuR1nwCia9FospAh9rrRq813rmEdK871tqZACZ085Ao9GwVyYTU5Htkb4BFEVSsG8LAEGJ4yFyL/H1qzlaXkVidESP52zPKWCGKOVw/BVodDpyDOmc0eLZeQj5uzcwBhgzYRZ6rYb6gFHQClTsG3TlcHqXz6gvhtWPQX2RmoN+cAVsfbXjcHBkPBqNIDhuJImigo253Uex5jYbv8i6klDRhCl6FAEmPZWmZIKaDvfsJqrJI65mM8t9L2B4UiJajcAQ6Fhfodlzo+RnfjhIpr4QqTXC2IsByFaGc7jBMfp0ijm8s7GAL5UZNKX/AhY+QGDMMHyxkFtQ2K1fWb6XoyIWe+JMksP90Gs1fBJ6s3qwpyyL5mpY9ksObP0eHQpRKWnqTGQHNRW9WCgDTEF1Mwkt+6gLHgtCMCLSn0oZgtJY1r+OrK3w5vmw9bVuhzb/+AXxooqAadcCYAtOIV4pocJFUFNRJKNLllFgSAWNjuiPFjNee4SjtYNX6qRotzrpLiVDNYW1AdFokNBc4eo0t7Hb7cRWbSTHbzJBvkYCTHpydSMJazjgseyxH3MqmGlZh8UQAuGjCErORCMkBQd6jzvkbfoUgLjMhQC0BCTjrzSq85M8RFPBdsoII3N0KgDayFTsaFTlMMic3sqhtRZ+/BtK/nr44jfw3uVdZskmJiQDYIoagVFY2X/QKQgnJexcytZPniYMxznD1S+RPXwU/kojSpPTw74oC/JWU/bDC1ilFv3kzhLMgeFx6kZ/lEPOcnjn4h4nsn2zp5Rv95ZzZkg5InI0zL2XlhGLeci6hNUHHdcw+KtvQ2h5a2M+C8aPwP+yFyA4gbgk9Yt6MGdvt75binaxxxbHNdOTOvZFxQ3Hgh7Zk3I48AXsfI/ElaopPiotE6LTaYrIBKCxstj99+xBvv9hBaM1RwlJPwuApDA/KglG39LPB97RzZC/Fr66Gwo2duyub7YwYt/ztGr8CJqgKmdTTBrRopYD+b2/5y279pJECY2pF8Ho8wC43/gxhTWDoxyOVjWSVr2CalMS2mD1e+oTpv63N5T3r7Ps9+G/N3T7zu5f/hJh1OGXdlbHvpqgsRilGapOPPCtKJIvv13OmdosdJOuBZ2BmJETAagv2NXjOQ1VpSwo/BcVhkRMw2YCoA1TLVl7TY/h1X5T3mAmpGE/9UFpaDWqaysxMoQ8GYss9yqHQWVDYzgt0khZ9rew5+Nux/VBDneHw09/WemTNGerAWdyv4dltzHnwF/V19d+CsmzAAhMUCfKlB5ymu34wTXw9gVE732VtWISi2dP6jgUE6u6C1pr+zFqXXYbHF4JFftosylsff9/2frGPfxzRQ5rPnyarb6/JqF5L8SMh6ix+F7zHxrDx7Mqx/Hwc7iVrGiREn63aGRH1+HxqnKoKOjqGmuqr8GnqZBSn1QWj4/t2J8WH8xRJQJzZQ+zWkuy1Xtir0FBgzFuHOh9aLl2OTapwVw3MFlarjha08LIPU/RqA0hcOYNABh0Gqy+kfja6vpX0sQ5BXndUyAlUkre/PC/TBV7qZ9xPxhUKy18mJqqWH44u8eupJRsXfU5ACOnnQMXvwwJ0xkhigZNOaz/+FnGaw6jnXd3x77gyHgAqsu6W5YuWf0o7P0E3ruiY5e5uYHh2/6XIyKBMQt+0bHfFp0JgCw+jhnDrbVQvB3sanLFK2sOc0PN01iNYWjn/A4AQ/gwLBgQ7SP0htIun3vVO9cTSQ0t5z4DWj0AgdHqc6Cy+DiyqGqOqANEJ9794luGUUrU6Okd+4ZF+JOjxGP3KofecZThyBFC5Aoh7h+Ia0wZFskRTSKxR1TFcDh4Fvdab2Vb0CK1QbvrxeEGOUOTjd+n10PxdlrXvdC1s6SZHZsJaTMAqDjgyLZoqYHGko7jPhOvxM/Y6atNTlSVQ3V5P1wsWkcwoeIAT31/kCk5TzKl4FVeXrmPP2vfIUKpUvPrY8Z3nHJmWhQbD1dTVNtCq1BTN82KlgcXjyUpzCmQHDEaqzBgLN+BzZElY7baWfrOi2iQzJx3bsdIB2BsbCCFMhKf3K9g/5fqj2zPJ6AoKE4Pz7akeR2zriMCfKghsP+jzxOktL6V/31jGXM0O1Gm3QY+nSXBdEEx6kZ/3CUF65ERYzgy6hY49C0bvnmP336QTXze+9iEnug5Szqa+sSqPuTWkr3qPJg2p1ReKVn70b+4tfZJWgzhGOIy1Yyy1EVE2CuYWPVFn3NnThi7rcMVKqXkjXV5ZBa/T4XfSIKnd1q6kbHJANS5Snc+FktTZ62yI2sg601aKvLZ+vKv8MFM7RmPovcN6mgenDCGBulDa34/lYPdivmFefDqGax95fe88MrzLFp5PhmaI5gW3tc5q1ujpdonheCmXCyNVfDP0bDifwDYun4Fw+o3sS3kPJIndFbTjU1UB021JcdR2uNfU+C1BfDhEtjwHO9sKmDMgeew6AIInnNbR7OUcD8OKAno6gvUezaIDMmAtBBCCzwPLAKKUOs2fS6l9Kg61Ws1+MeNgaJDtEgjZ5fdxqWTU5hgegu2AYrD3xkU3/XEV8/AB/iMeWTOWERSqA/ojB2HUxITKBMRNBXuREpJ6d61xALr7GOJDzIw/dyuGRhj4sOolgE0VfZjJCbU2IGsPsxnW4O5z7F759wsTAdCoMHx4Imf2nHKkhnJvLUhn6tf3cywtkO8CRj1Wq6elti1b52RxrAM0iv28v6WQuJDfPnqs/d5sOU5qoLHMXrGeV2ap8cF8YwYxwKy4YPO0d+hWTUMK9/La7ZzyZh5LlMXXNwpvhA0aoMRLY41Jlpq1IdlsIugq6URPrsT5t8Pke6V1vjPxnzWfLeMQ8Z0hvs284vKp3lVswO71kjQrFu6tDWFp0AFWHK+xzj1+r47t1uhcDMHYxZz/s45HDK9yszNv2ImgBbk2EvB1PnAIziJNmFAW30QZfWjaFY/AvcfpcxiYPlXH3PDwf+hWeuPz8XPdAZ6He/zL8qLWHZNwph5uVvvm6ZK0Jt6L4FyDPsLy4l6czp7NaN4JepBhtdv5KGmh0EDtgX/6lLOITFpBIeUOIJyPwPudU+eoq0g7Tyk/x0PWZ+CL36DLzAHyA+fx8Q5P+vSPDU6iD1KCun9nBzauOMTAhpVt8+c8reZA6ABqTMhxnW9d5qIVBLyN7M3ewsTAba8zPPKJdyxTW03fmrX5IphjkHcmJ1/gwW/gKC4vgVqqiQ/P5dkRbVi2Pcp7PuUaPsyZuv2Yxh/Bfh3BsSHR/jzunT8BvLXwqhz+/X+PclQtRymArlSyjwpZRuwFLhwIC6UNCoTgHr/FP5z62wevSwD7ezfQuIMyFALoTmXcW7HLExMv/J+ks6+C6bc3OWYEAJ7aCohLUe45/Hnif1KHXUVLHqNpLt/ROi71smJDDBxWD8S/4osNTj+7hXY93+FXZHw4z9g8ytqobCv7laroe77DJpUF5RY9yQLzJ2TZkyHl3ccY/gCdVEbB7HBPrx87WRC/QyERakKzxh6jGJwEDzmDMZp8nn8sy3c+uZG/tL6GLqAcMKXvNPtfhh1Wo6Oup4L+Sc1cQs779Ha59CiMGHOYqb+bAmYArveQ0MYBrNDOSz/A7y+yGV+tyzerv64XphOfmnf8ZniulZ2fPUyrygP8WPrZbxWvYQzNDsA0KZfolandSI2cxF5SjTN297v3Jm/Tr3nPVGdC9ZmPiyLZlxiOI1n/F/nsegMxEVdlxVFo8USkESUtQjb+n8B8MWL9/PHx57ihoO/UuX6zQ40Y5zmjUZ11vJR1j3jXv67omB7fhr8I56yT/6EbChx2VxKyScfvkmoUsMc20beKT5HVQyA1BrRZVzWpX2Iv5H1ummEN+zrcN3QVKG6cnqjcCN2NPyoTOC1kS93iqoxkLzk1W61hDITgtkrhuNXe0CNVbw4Wx3Z91Ewrzx7OXXSj6JFTvf+rL8h7s7plgkYnjiKWE01367f0rHvjm2dpddNMV2zhXyNevZrHe7XTcd4Dnrjg1+Q/NE53XYv0mbhI1vQHvPwjwgwkh88jUpdDGx83r1rDBBD0nIA4gDnWTZFwDTnBkKIW4FbARITe37AuUXocABiUtKJGRam7gtOgBu/6druirdBa0CufwbFLwLTle/gqhRazIjxRNZm8Qv7pwCY06/mF3N7T01TEmcRn/cseS9cxjDLfooOZvOkdQPPGtSHSHXBHsL2vQU536glpp34P/0b6sbYS1SfLsClr8O4rj9qgHkjI5g3MkJ1H2z8G6Rd0KM8mmHzYO3jPD/bjNFXT9CaJjj/VQjtOb3012eO4oIDVVyRdzbfG9WVy8Zp8gGYNOusHs/RBUXhW1pIZYOZiPx10FgKhRshuecJIis3Z9GuepJfHoEdDXuuP8D45J4LFn63t4w5Irv7gam3wRndK4tOGhbF15oxXFTxI+u//g+tZYc4s/BpAMx/rMRkPKbwYq06Qt3RGMwF82IJmDULNG1q1dspN/dYPM0vZhSjmrOpsJqIF00srn+XxfrO46agyK4nhCRRdfFSXvzwS/5S9R81u27YPAiI7pL15Uzljy8Q0VoNQPSu52HX89i1JjR/OKymMRv9u7TPKW9kfP1KzD4hmEafDbuWdhwTNyzvNmESwC8uDe3RTyha/gTV/iMZt/oWNNIO9+R2GQm301K8l1IlimsXjuPmOcOgbTHU5KFxGrw4Y9JrUWImoC3/Aj69Xd1Zvpsjuzdgn3o7I2Ze3BELcManIpv9mpFMn/lzsBZCzlcw7fYeU251YcMBhWHm7okXpF0I8VO67f5u3D/x33EDkXu/Yv+Ye5BFWcSPHE+Ev7Hb4Adrq5qwAFh0gRh9/GDyTfCjYxAx7XZI7f7bmD4ynu+2p3Nl8Say86vxyX6DeCoIPOM37lkrHmKoWg49zUrpkhcqpXxFSjlZSjk5IqLnPGW3GL5A/cB6eFh0Ie1CGHUu4sZv0F75Tp/daiJHo1csTLRshem/wnTZiy7bT5ytjliGWdRZm0mivEMxAKpigK6KYXinP1Qa/CHdqYyV04izR4SAmXd2zpg+ltgJIDTM8cln6tF/g0YPKXN67S41KoAVv5vL76++gLIlG2CJY65AWGqPDwuAsMh4EjSVZL33gKoYANuXd8POpbC96z02W+3kHOj6I9ai8Oqrz7HmjT8jewgibzpczRzdfki/DB6sg1t+hMXPwrmP9jifxKDTkDhGLVA5a8sdHYoBwPSPCKq+eKCr379OVQ5HZSSTkx2+7Dl3w9Rbeq2qqQkfTrwsI1bbw0Q70fPPMXz8ufwYchmb9VNh9SPwxrnw7AR1gZhj06XbWghdq1YztRs6H1Zauxnxjzj4Rxxkv9fllO25xSzQ7MA2ajFc8jIs+RKm/RJ+sxPiJ9ET06ar34X4bY8wftWNqmIAeGIELVnvd5PLXHmEIhnBnFTHd8Hg18Wq7YmzzrkQ5ZhHQUpjFiN+uIV9T1+EzXrMZ25pJKYtn+rgcerEtvn3wW1rep+L4RjoXBFxzGzvCdeog0F99+HfxXMn8bK8FGPDEXa8chsTVlxKxL9GwCMJWLe93bVxqVoB4Oa2uyn/ZQ7cfQDm3ave1wfr1O+hpvtnftPsFA6QhNbayNJXHyEt+68EZr8MT6XRUn7yivINVeVQBDg7n+MB17bx8WIKhPP/CWHDPdtv+KjO7dHn9d7OgSF+YucL5xHLvPs6NidZXkLRGMA/Si0hftVSDvqrMQUx6Xr1PK1BXU0qwun6x4PRX30Pa59UA4ijf9an/zoh1JefjYshOmWsOhnumk/gyv/02j48Q1WI55Spbob9SgK6qgNqJtbnd6oZJA42Hq4mwl6BxScKRnXez3/pn2Nuwb9oeCJTzVJxwly2nzBZq8oiBMRNhElLXJZDnjjjzC6vlZs7K+eGZz1D3b7O9ZypLcCqMVJJEMMiep8Z3oXQ4QjFhkaxwnynAckvPoJf9V4u4jdnjuRvTYu77tz1AbJ8T5ddbdX5aLGzIuJ6tFe80WNfctu/u7y2HPgBX2HBL1NdZpSUOerqeyHJvcqTODKzy+uj572LTaiWle8Xt2Pf1bVSr6m5iBIRSWpkV6vFFSkpI2j79V6qLv4A2x/L4KbONbHTGtfx9btPd2mvFG1Hg6Q5oqtsveLIQhSV+9VBzBRHDMrF+04I9eX6X/2RyqBx3KDrWpk274fXu5Z7ccRLcg2jSAh1sr5Ckl1+B5PD/bj9ctWif1z/Spdj7733RkeSyEAzVJXDViBVCJEihDAAPwc+H2SZ+ofzwzlheu/t2jE4FcI7408QEAM3LIf5f4QpN2O57D+YgqK4w/8p5A3L1bUldEaW+TmCbMPPUMtQ3JsL13/lmXrwsZnq/7BUuPgVl017ZMRCiBzd+/HUM5EOn2vzqMswXHKMH9dpEZSNh6sYqy1EH5YEV70HD3SdiBRkLqb2+86y52arnaR6RzCzl1nbPZIwDX7+HoxZDFe8gyZ+ItydQ+kZTwGQu6LTX05dATX6aML9Tfga3PTQOg9CUuaCzkdVwqmLXCr0CzPjeO7uGyic/Cdyf/Yhz454HYAtK5d1aVdUqGbSBIw+A0acCX8sgltWQoCaevypfSayeEeXuQbJVStpEv6IXtx5PaI3wa2rVKv7zIdJmHI+unv2sz1TjVUUr3mzs62lEV9bPc0+cWg0/ftemkLjCB9/DjqjDyRMURXqFW9TbYgjKe999uZ3DiBad3+OTWoQPbiDeiQgWr3/AOGpMO5yCIyH0a5rhY6IDibipg87d1z3GW1aP/xaivg022kOy9HNVGijCItK6PdysLFjpoOvw83tEwoP1tFiiiK6Zitvb/TMPIu+GJLKQUppQy1g8i2wH/hQStmDY3AI4xsKE66FC/7lfomBhQ9A4kx1zeq7D6jpsULAeU9iTF/MbxamsrwihG2NnemXP1pGc0fSl+qDANTsGE8tFBLncClMvrFHE9sTiFTVevAbvYDhmXOp+G0xz4qrAZBVnamSIw68RJrIRxMQre7QaFUXEdAy6z52yJE07/m6o31eZTPTNXtp8Y11ORLsLpBQLb0r/9MZjwmIJmbejWRFXkJ6/SqKih0PgLoCiokkKax7hdteiXSKO8VkqAsv3bDcrVOTwgNIPP8+Rkw9mzuvvpQKXQzTDj5JbXbnuKm0WH1wJCc74hHGAPVzvHYZygXPsytoIRppQylSg8eyrYXJ5g3kBM/t0YfvktgJqtU9+7fqa79wJlz4G77xv5io6i2Ymx3B4zrVbWMP8kD5j/n3QdqF+M77NeM1eQS+v1hNwbU04rP7HT6xzyEqOsa9voQAP4ebKzINEqfB7/e6lwkXGKtae7eshGHz0S38E/GiisAvb8feWKHOdzm6ma32kYyMct9a6kBnVC3JuEmw+BkQAp8xZ3OOdivfrfzO7TVjToQhqRwApJRfSylHSimHSyn/NtjyHBcX/gsmXut++zl3w43Le324n5cRg69ByyfbO+MOZQ1mQkKCT1DQXphwrfqQPCYby6NMXAJXfQDjrwIgMtgf3zPuoVkaqSxUZ8dKKRnW6MgomXlX57mTlsADtfgu+hONMTOINudR36BWQc2rbGC6Zj+W+NkeU5aJZ92BSVip/Op/YfdHUHOEPFsEiaH9UA6+oXDhC3DRS6rf3T8C/ML6LYtGI9DMV12OjT881bG/rlx9EEfHHhNLihyNZuI1TJ2rWmqFO1V3WVPOKgJopSKpb9enOwghSJh+MUas7Fj9KQBKTT4AxnDP1crymXkbX8f/ngTLIVp2LoOyPWjsFpYrU0kI6R5A75WxF6mu2Iwr+mzajdRFHQMoTfqlVETOZp5tPfX/WQK1+YimcjZaRzAi0r104m74R6rKxzFIEYseBr0vv7B+zIq9Az8/aMgqBy/d8TPqmD8qgh8PVCKlxGy1U9diJSaoHz+G/qA3qe4VDy+P2gWNBkad0yUwd+XURIqIorJADc4XVLcQLSs5Ens+JEztfj6QPHYaOqGwabNaGK0tbwMhogmf0QvxFBEjJrPfkM6EkqXw8U3Q1sROcxQJ/VEOABN+AZlXnbA84bNv4MuQ64hv3IG5Tk1fNteVYhFGhPP8CifmTxhNIVEkZz8OpbtozN2EXQp8h8/ssf3xMGbaOTThS9s+1ZKrL1ODqIExHozrCUH0mXeQp0RjWfMMlKllMPbLJOL6oxzOfBjuOXjiMbrAGIJu/ZxnuJrQ8g2w/mkAtiqjGNbLUrj9xjcU7eQbOF+7icL1H/bd/gTxKodTjNkjIihrMHO4somyerWAW1TgIK8v7GECTHrsQUkYGwtoMFvZW1hOvKjCN2Zkr+ckjFb9zDE71FF0fOGnNOGDKX1xr+ccD4fG3c139s4Mnn1KIkn9VQ4eJH7mFWiQ7F/1AWarHV1LJa2GsF6tJZNey/YIdTKi3PZvREkWh2Q8iTGeW79cozdSGDKdMY0baWxupqUslxZpJCbGs1VlMxPD+EC3mJC63bD5ZZq0QYiAGIy6fpQ212i6zJI/EYw6LTWpl9GGDrLepMkvkRyZ0D+3Yx+Iub+nzDScC8v/hbnN80vaOuNVDqcYs0eoE7c2Hq6m1KEcon9iygEgdFgmKZTw7Y48ih1Ll4Yl9u4LFmHDUdCQ0bIJa/FORtRvZJdpisv1JY6HkVPO5Bbr3Syf/zmHJj9ElhxJogd//P0lY+IsikUU4sAX7CttIIw68It0fdLMX7PWno75yGZCanayU44gvj+jbTcwjLuISFFHwOOxxOW8yREZTUrEcfjeXaDRCGpTL6OWQKg5TK52OAmhnv28+8vs8aNZ0nYfBZP/zAejnkEjBPEhHvx++IRQn76EeFHJrl29TM70EF7lcIqREOpDVKCRLfm1lNarGSexwT895RA1egZaIcnesqZjyVJd+IjeT9Bo2T5XLZtdsf4dQpUaSoIne1yuUVEBhPsbWV4ayKawiwHRv5iDh9FoNZTFLiKtdTsrdxwiXDRgCol2ec7ckRHsksPxqdmHyd5Iju8E9Meu23GCpMy5iq/EXI6YxgKwhXSiAo19nNV/po6M5y2bmoyx0T6a+NABcrG6yezUcLaJdN7TLia7OYS4EJ8eFwg7EZInqRPnynZ930fLE2OozpD20gtCCCYnh7L1SA2jHFkQAxZzGESEI9BnrNhJG3bQ0+uM4HZGz7yAhtW+xO1T1+SwxvQ8geuE5BKCWSPCWJ9bTYivHn+jjsgAzz/0+kPCzCsw/Pc/FG7+jChDPcZg19k6oX4GGkLHQcNnKAgKohZ5XCat3sCqtP/j/r1lnBleR76M4gZPZdE5MWtEGPNsFzI2bRzP7kriV2GDazkEmPRMTQnlxwMVGHVakgdAHmP0aOq0ofiVbODjrCKiAk3MTg3v+8R+4rUcTkGmJodS1mBma34toX4GfAyDs3zkgBIQjd0/hqmaA2RqcrGawvpcJc/fpCfXMVJdZR9PyLAJAyLarOHhVDVZWL6njOERfv3OYfc0kWPmUKcJ5QLteoJpRPj34VYCgsacQZaSysWWhxke7Rmf+7GcNTaaRrONZUX+A3aNmCAf4sOD+Z/8DFoxMczDrqvj4YxRkRwsb2J3cT0jo44zU8kVQlATMZ0M607Wfvw829Z/2/c5x4FXOZyCTHGUalh9sJKYoJ+eS6kdbeI0ztFu5TztFvTDei/d4cyuSf/gCstfuN56H+MTuy/p6glmjlBTTysaLQwfAg8jNBr0E37OmdodCGT3KsI9MGPscC5te5idcgQTE4MHRKz2+BioZd0HipkjwihvsAC4P1N9AFkwulM5T0wcGKUYkHkBEaKepw0vcKHFM8vaHotXOZyCjIoOIMCxHsRAmK1DhjMfVOdBTLxOLdPtBudOH8cB4zjmjYwYMHdbfIgvccFq39OGDYwC6i9+0zrXjSBqbJ/tMxOCmZMazrAIP+aP6tvSOB58DFrOy4hBrxWck+46DnIizBreqYSGgrIeFuHPmWMiSQ7zZeGYgbm3EVOv5OPA6/haziLgvP/r+4TjQMie1jk+xZg8ebLctq1/dd9PdX7x2ibW51Zz3zmj+eV8D9eFOsVpbbOj1wp0Hg6yOrO9sJavd5Xy+7NGul86Y6B54zyoL4Q7t3VZX2QwMVvtmK12gn0Hbq5Ma5udW9/ZxrSUUO5ckDpg1+kPUkqkpN/lQvpDm02h1WonyKefM9udEEJkSSl7zNwYIt9qL/1lyYxk6lqsXJAZ23fj04yTEYOZmBgyYC6D4+baZSCVIaMYQJ1XYdIP7OfhY9Dyzk3T+m54EhFCeKyKTW8YdBqPZ0I541UOpyhnjY3mrLEDZ6p7OQUZyJnsXk47vDEHL168ePHSjZ9EzEEIUQmcSB3bcKDKQ+IMBF75TgyvfCeGV74TYyjLlySl7HE1rp+EcjhRhBDbegvKDAW88p0YXvlODK98J8ZQl683vG4lL168ePHSDa9y8OLFixcv3fAqB5XjWAPzpOKV78TwyndieOU7MYa6fD3ijTl48eLFi5dueC0HL168ePHSDa9y8OLFixcv3TitlYMQ4hwhRI4QIlcI4V5lN8/LkCCE+FEIsV8IsVcI8RvH/oeEEMVCiGzH38+czvmjQ+YcIcTZJ0HGfCHEbocc2xz7QoUQ3wkhDjn+hzi1P2nyCSFGOd2jbCFEgxDit4N5/4QQ/xZCVAgh9jjt6/f9EkJMctz3XCHEs8JDtcF7ke9xIcQBIcQuIcQyIUSwY3+yEKLV6T6+NEjy9fvzPMnyfeAkW74QItux/6TfP4+hFog6/f4ALXAYGAYYgJ1A2iDIEQNMdGwHAAeBNOAh4J4e2qc5ZDUCKY73oB1gGfOB8GP2PQbc79i+H3h0sOQ75jMtA5IG8/4Bc4GJwJ4TuV/AFmAGIIDlwLkDKN9ZgM6x/aiTfMnO7Y7p52TK1+/P82TKd8zxJ4EHBuv+eervdLYcpgK5Uso8KWUbsBS48GQLIaUslVJud2w3AvuBOBenXAgslVJapJRHgFzU93KyuRB4y7H9FnCR0/7Bkm8hcFhK6Wq2/IDLJ6VcA9T0cF2375cQIgYIlFJulOqT5G2nczwun5RyhZSyfcX6TYDLRSFOtnwuGBL3rx3H6P8K4H1XfQykfJ7idFYOccBRp9dFuH4oDzhCiGRgArDZsetOh5n/byc3xGDILYEVQogsIcStjn1RUspSUBUc0F64fjDv68/p+qMcKvcP+n+/4hzbJ1tOgBtRR7LtpAghdgghVgsh2lddGgz5+vN5Dtb9mwOUSykPOe0bKvevX5zOyqEn/96g5fUKIfyBj4HfSikbgBeB4UAmUIpqqsLgyD1LSjkROBe4Qwgx10XbQbmvQggDcAHwX8euoXT/XNGbPIN1H/8M2IB3HbtKgUQp5QTg98B7QojAQZCvv5/nYH3OV9F1gDJU7l+/+UnMcwgPD5fJycmDLYYXL168nFJkZWVVyV4K7/0k1nNITk7mdFsJzosXL15OFCFEr/G509mt5AXgP5fBf68fbCm8ePEyxPAqh9OZkh2Q+x3sXTbYknjx4mWI4VUOpzOFmwZbAi9evAxRfhIxBy/HSVO5+l/vO7hyePnJYbVaKSoqwmw2D7YoXgCTyUR8fDx6vd7tc7zK4XSm0aEcbJbBlcPLT46ioiICAgJITk5mqFWFON2QUlJdXU1RUREpKSlun+d1K53ONJWp/6Ud7NbBlcXLTwqz2UxYWJhXMQwBhBCEhYX124rzKofTGavTl8XaOnhyePlJ4lUMQ4fj+Sy8yuF0xt7WuX2yXUv1xVC+9+Re04sXL27jVQ6nOCc0w11xciXZTrLl8MJ0eHEm/ARm6LtNWzOs/Bs0lA62JKcF5eXlXH311QwbNoxJkyYxY8YMli07uWnb+fn5pKend9m3e/duMjMzyczMJDQ0lJSUFDIzMznzzDPd7vO9997reP3mm29y5513elRu8CqHUxq7IjnjiVU8+Nmevhv32IGzcjjGcvjiN/DibLC1MSBYGtT/zZUD0/9Q5MDXsOYxWPfUYEvyk0dKyUUXXcTcuXPJy8sjKyuLpUuXUlRU1K2tzWbroYeBY9y4cWRnZ5Odnc0FF1zA448/TnZ2Nt9//71bMh2rHAaKQc9WEkJogW1AsZTyfCFEKPABah30fOAKKWXt4Ek4RGmpIb+ggPzqFvI3FvDwhel9n3MsditoDap7yTnmYDVD1pvqdtluiJ/kEZF7pO4o+Ef23e5ksOIv6vu9dhkMhL+8cr/6v10xukldSxsBJj1azRDy4TdXgV+4W00f/mIv+0r69577Ii02kAcXj+2yT0qJ1S4x6DSsXLkSg8HA7bff3nE8KSmJu+66C4A333iDrz79CLPVTrO5jY8++ogbb7yRvLw8fH19eeWVV8jIyOChhx7C39+fe+65B4D09HS+/PJLAM4991xmz57Nhg0biIuL47PPPsPHx4esrCxuvPFGfH19mT17ttvvaf78+cycOZP169dzwQUXsHv3bs4//3wuu+wyAPz9/WlqauL+++9n//79ZGZmsmTJEkJCQigpKeGcc87h8OHDXHzxxTz22GMndH9haFgOv0Fdw6Cd+4EfpJSpwA+O1z9tFAUOrugaIO6L1xcx/IP5GFBH/w3m48g2sreBMUDdtjlduzq3c7tiAOICbc0dmzk5QyTuICVseBbyfoTGMrdPe+CzPXy+s8S9xu0xFkuj2/2brXbmPvYjt70zhGqH7VwKjw+Hgg2DLUkXqpvbOFDWQGubjb179zJx4sTeG9ssbNyyjbee+DMrV67kwQcfZMKECezatYu///3vXHfddX1e79ChQ9xxxx3s3buX4OBgPv74YwBuuOEGnn32WTZu3Njv91BXW8vqVau4++67e23zyCOPMGfOHLKzs/nd734HQHZ2Nh988AG7d+/mgw8+4OjRo72e7y6DajkIIeKB84C/oZazBXXxjvmO7beAVcB9J1u2k0rO1/DBL2DO3bDwAffOcTzAM0UuW+QYSupaCYzuZYLLzqVQkwdn/KnrfsWmKoeW6q7Koepg53ZdYT/eiJs4uZIK8nIYtdDzlzhY3siTK3J4cPFYYoN9+j6h3unHVHMYAmP6PKWwuoW3Nxbw9sYCFmfE9J0RUuuocdZS3bc8Drbl19JgtvH9/gqklB7PAFIUyevrjnDG6EhGRPq7dU7z7i/xA8hbBUkz+2z/l/PTKKhuIdhHT4ifwT3BpKL+F+6PX2tbVBdoo7m7S+aOO+5g3bp1GAwGtm7dCjYzi+ZOIzRYfc/r1q3reLgvWLCA6upq6uvru/RhttqxK50xsvZYAcCkSZPIz8+nvr6euro65s2bp7q2LryAr7/6wu33cNm581Aq9qOJHOP2OQALFy4kKCgIgLS0NAoKCkhISOhXH8cy2JbD08AfAMVpX2+LonRBCHGrEGKbEGJbZeUQ81vXHIF9n0Fbi1vNa4/uUzdKdrjXv6WpY/N8rVoCo7jWRUB52W2w+lForeu6327ttBycrZaaw+p/Y1C/RtFuY3ZyMdSd+AinJ95Yn8+3e8v5KKu7j7knGsoOd76oyXPrnL0lnQ+PqiY3YjMNDgujucqt/gGqmy3400IM1VQ2uplRZnffh74ut4q/fb2f3yx187sH5B1R75W1eJdb7VssNhrNVo7Wuvd7AGgtP4ytbJ/b7UE1wAHMVoWxY8eyffv2jmPPP/88P/zwAx3PCsWGn69j0KDYe0zsEEKg0+lQHB3nVzfT0tKCxaJ+DkajsaOtVqvFZrN1UeDNFhsB5hKEYgPF7tZ7CNTb0dgtWK1tXa4tpaStrffvWE+ynCiDphyEEOcDFVLKrOM5X0r5ipRyspRyckREj+XI3ePA13Dgq+M/v7tg8ME18OF18PldbjSXfLtZ/ZEp7maxOLl95mrUc4vr3Mg2qjjmx2ZvA2Oguu2crdRcpe4PSYKmij67bWmzUdfSj8C1k1sltmW/i4ZONJb1K7Mpv0p1XWUVuBeu2rfPKahfX+zWOSX1nQo1r7LJRUvU92xxKJN+WA71zWa+MPyZH42/p6ToSN8n7PoQHk2G/HVu9b/zaB0Ahyqa3Mp8a7bYCLepAwZbiXvKodXa+WB0Hnn3RptNwUdpQiet2N1MiJBSYrI3EiHqsdjsLFiwALPZzIsvvtjRpqXFSTkpti7bc+fO5d131fWNVq1aRXh4OIGBgSQnJ7N9+3aklOzekUXR0UK0Db0PaIKDgwkKCmLdunW0tNl5d5m6oJ60ueMydro3dQUkJyWRlaU+Hj/77DOsVtV1HBAQQGOj+67J42UwLYdZwAVCiHzU9ZsXCCH+A5Q71ldtX2e176fT8dJUAUuvgqVXu63Z3eqz3PGgObK6zwdaeYMFnzb1YaHUuunCqVJXIDwcOJUIUY9Bq+ndcnAeRR7rImp3K0HXbKWWGvAJAf+ozlnULrj61c2c+c/VmK3u3UNpVh+SW5RRDFfyaevjPJm/Dp4cRc7X/3Krf1BHeQB5VX08tB1YqvJRpKBG+mNz83Moq++853lVzS5a0mE15CtRSHOd2983Q8UuUjTlmIQV8+H1fbav3fQfaGt0u9JufrX6wGyzKVQ29W2ZVNXVEyNqaJUGfFqKu1ujPWC1d/4GLLa+37elrTN+1tbq3udnVyRJopwYUQN29X18+umnrF69mpSUFKZOncqSJUt49NFHAZCKDdm+GJti46GHHmLbtm1kZGRw//3389Zb6nLfl156KTU1NWRmTuCjd15j5LBEdIrF5ef3xhtvcMcdd3Duwrn4mNQRvWLp4/sBSCfFqbc1c8svLmb16tVMnTqVzZs34+fnB0BGRgY6nY7x48fz1FMDl/k2aDEHKeUfgT8CCCHmA/dIKa8RQjwOLAEecfz/bMCEaC88B1BfpI6UeyJvNXx8Myx+Bkb/zHWfteroLts0hczmreo1AqJ7bZ5b0UQEdQDobM2qy8UU6PoaVQdBaMg3jGK42EJCkI6i3iyHVqeR87FWgHNA2ilbSbbUYNYFYvKPQpTtdilKRaOZbMfoc8PhKhaMjnItO2BtacAAVBmT8LHmcKSiipS43s8r2fEtcUD5pg9IPfdONH1k7UgpqXC4YIpqWzFb7Zj0WpfniIZiqgiiWIaTWl2IO973qqY2YoNMVDW3caQv5eD4rh2U8STLcjDXg29on9cw1XUuRdzXZyGlxFq8EwQ0lhwkoO+3QInT9ya3oonIAJPL9g3VqnW7WhnPOdqtUJkDidNcntNmU7ps+/YRdrBZO60Fpc29JA27onQ8zPxlM3YllJiYGJYuXdq9sZRcf/l5XHbZpYAZFDuhoaF89ln3R42Pjw8rVqyg2WKjrqqUOOFwCYZHs2dPp7XZns0Eavxh586dFFdUE2cr5KG7b8dqaUbbwwfy5ptvdmyvWP4FxvpOl2ZUWDCbNnVWTv7HP/4BgF6v54cffujSz/XXX9+x3Z5NdaIMdsyhJx4BFgkhDgGLHK8HhuhxcLVjyWFX7pPVj0FzBQ1b3u29jYOGEjWY+3njaHVHexCyF4pqW4gQToGvRjdcS9W5EJxEJcEAjAqy9245tDj5t5uPVQ7WHi2HqsoytpbDrlodtNa4tH72l3aatzuP1vfazpnWJlVhyeBEAErLXL/n1nLVxx0vKvseoQMNZht2RZIRH4SUUFjTt69b31ZHoyaQEhmKrHMvTlHfaiXEz0BCiA8F1X3I5bCWjkjHQKGlxq1r+DQXoSAoIxxdg2uLpqi6kXDU69ir3XBBoQZxM+LVQObhir5H6S01qpLL0aaqO9xIWLApEl+D+ui22JQ+WoPi7Epyyx0D0umcAFpos7u4jrQjAAuqllLcqCtmUxS0OFkLbmQWahX1N2WROjTWvr+37e87jzja0Lv13isazNQ2D8xcpCGhHKSUq6SU5zu2q6WUC6WUqY7/7v2KjpcAx4jVhfvEXpINQO3hrV1GQT1RXZSDIgUblTR1R51r5VDZaCFC1HFU76iW2OBGWmRLFfhHUm1XS20PC7BR1Kty6PRvf71xFz/mOBSEYgekk3LoPN/eXE0tAeyolKp14eJLWuoYefoatOwrdS+Xva25DgD/qOEAVFe6Vg72RlXmJFHOrvxyl20Bahw/lomJIcRSRVN23y4WH1s9iimEMsIxtZa6Fd+ob7US5KMnOcyPgmrXCkg6LLgCh3JorXcvicKntZxaEUqlMYGAVtdKq/BoPhohMUs9Bot7P5vq5jZGRwfgo9dypKpvJWqpVz8LW/R4AKQbysGuSPRagV6r6fP3A3TM3Leh7XjA9nmK48Fq1frgi5k2q4uArMMl1OawNWw2N5SDXaLFjoJAkQLpRkUBH6UZO1pqCEIrrX2XqHEoKa3BhxZpQLpR0qamuY0my8BM4hsSymGwyClr5M4vHMHH3rJy7Fa0VnVEFU8F2/NcP5ysFYcpIQxL0DB1R22+y/bV9Y0Ei2Zqg9UJPfYjbgQSzQ1gCqLSpmZbJPlaqWqy9Ozzd2TGWIQRf1sNz690BLPb6yodk60kpcTH1kCt9OdgvcNQd+FXLqk3oxEwb2QE+91UDraWetqkluAo1XKoq3Z9T/UWVcFphaQsz7VrBTqVw+TkEF4yPMXEjXf1qXT97Q3YTKGYfWPQK5au7rheaFcOSWF+FNa0uAzomhvUh7VvtDriLil1zzoxWOtp0QXQ4pfQEQjujcZK9btcbEjGVzb3WWlXSkltcxth/kZGhukZc/g1aHYdLLc6FHVs0iiqZCDmyr4tFLsi0WkERp3GLctBOJSDWeuPQVq6Bo97ey/tbQwBaATYXY3sHcpBozMiJdis7lgOEh0KUqPDgr5Pd5eUEh9ppk3rS5tWjRU4Zxn2iN2KXWrwMeox45ic2kdsyq7IAZsceVorh0AfHV/n2VHQ9O5WcrgD9jICrZDs2ec6Q0PXXEKlCGfayFgqCEHWuv7xWOocmR8xk6iXvohN/+q7ZIWlAYyBVFvVeQ2xPuoPo0frwWE5HFTiiBD1bC+spb7F2vng0JlA02nCVtY3EySaCYuIpkH6drkHPVFW30pEgJFxcYH41h2kobVvE9fWUk8TPvgEqTNsm+pdP5D8bfUUmFQ3XVtp39lN7WZ2YqgvGRrH/a/M6bW92WoniAYUUwiaoHh1Z33fKbadysGXlja7y4Buc0MVdilISVUtysoK9zLTTLZGzLogZFASoTTQWN+7RdBSrSoHa6h6r2r7ULqNFhs2RRLmZ+AS01Yur3sdNr/k8hzFMdhISkykWIZjqXZtGUspkYqdKPMRopQKtwLSQrGhILAZgtAgUdrcyMRzJF4Io+NBbO39s5COB65er8cutChupP7aFYkOO8KhHNqD3r2hSNCiIDV60JuwoVUTBVwgFCtWtPjqdVikXg2Xu7iOIiV26VUOA0JMkA9jYoOp1wT17lZyjJpL/NUfdd3RAy779LVU0WiIYGxsEPlKJG19jawcMYaQmGQetV2Fxmbu+8FkrgdTIJVtqs800qR+2XtMZ3UohxwlnjGaQl7XPcrO/fs7lYPWoCoIh3IoLVfvQ0JcPA20K4e6XkUprTcTHeTDHOt6Vhjvo2b9m65lB6S5gUbpi29ACADNDb2P0qWiECzrKA/OREGDqf5QnymX7ZZDiI/TpEAXcxdqmy0E0ww+ofhEqEkJ9lr3lUOGso9LNWsoqOzdcrI01tCAH6OHJavnVvXtHgPwVRqx6QMxRKqWaFnBwV7b2upV68gQq1qhRwpdv4cax9yMEF8DI3Xq4MhefdjVKWhaqrGiIyk2hmIZjujju2qXklDRgE624WevB8WOzVU8ANBKG3ahQ6tXM32sLh70HTgsB2FQUwmEi4eq3aEMtFodCtpOq8MFNrtEJ5QO5aBR2jon6vV4DTtaoYBGh1GnxSL1yL5iG9KOIrQY9Rqs7eF1F+cojuwmr3IYIKYPC6PEHoTS0JtyUB9cdSHjAFCqD7t8OAXaajCbIkiPC6JIRqD0EZD2a1F9tlFJozmoxKk7XVkbUoK5AWkMpNKsfoEiDOqPvKinSUYt1Vj1ARTLMADO0O7EuP21zoqsGh3oO5VDVYV6H6KjojH4O7JpXFoOZmICTaTUbQbAVuDGutSWRprwISBI7b+tua7ji34s9bXVGIQdGRBHk28C8faiPud01DjmXIRqnEZqLu5pXV01emFH6x9GWLSqHGorXLt9zFY7AbZafn74PiZ8fxVPGl4iYuU9vba3NddRL/2IDAvHghGbG0FvRZH4y0bsxiACY1R3VFNx75aTaCpHQRCWosYDiktcz9fouE9+BhLs6kO+rQ9LQGepoUEEEhPkQ5mIwLe1xGV8xq5IAun8XvrT2qdrSSttKEKH3uAIGFvdCLgqNuxSg0arxYYOndK726dDOeh0SI0Wodj6HHDYFAUdCkKrwy4M6qjehYXffg2h1WHUabCjQfZhoQhpR6JBpxHYRd/Kweb4zei8ymFgmJQUQrkSjLm2Z590S4NqRusiRtCmCyDaVtJ79oulEV9asftFMTo6gHJCMbSWd07d7IEQSzESgW/EMKwBDpeGK4ViM4NixaYPpEFRR1aB2jb0WtGrW6lFF0SlDO7YVdgknCwHvWo5OHy07a6IkPBooiMdwXpXyqHBTFSgEb8SNQdfV+t65AmgaWugEV/8A1XLwVc2d6SeHku1w49uDIpCBMYQKeq6ZEj1RG1zGwadBt8973fss5b3bvE116ijZkNABLHxiShS0FDpekRc32rlRt1yUqpXd+wLq+i91pBsraUBXyICTRT7p3Fey6fIPmafN1psBNGM9AkmakQmbVILpb3PZDaYK2nWBhEUHgv07bpqd78l1W4kvnQFANoa15+fsa2WZl0wGo3A7BenxmdczPi2KxIjbbQZ1M86SVOBzYUloEjVfSM1egx6PXYp3MomEtKOXWgRQtCmDyBANqPVasnMzCQ9PZ3LL7+8YxJcuxtJp9MhNDq0KH0qrHvuvI1lX34DGh1333sf+w7m9RpgXrVqFevXq7FDjVbHO2+8yn8++qzP+IGQCtLxHrQ6R76v0vt7tyuSVFGMX4t7kzb7y2mvHCYmhlAuQxCNPSuHGof5HxoWhS1kGMmijJ1FPT8s2+rUPjQB0Zj0WhT/WLTS3jWd1Lm9TSHaXkazIQL0JoKjElXfZL2LUaWj9ESr1o8m1Jx0jbWZ+BDfntMpm6uoF0G0GsI6djXW1yDbA9IdbiVVsTTWqlk0xoBwEuLUh4ylseeYgNlqp9Fs/f/2zjtOsqrM+99zb8Wuqq6q7uocpsP0DJMjwwwwAxIFCZIEREFBggHDrr66uLq4r+uaZdFVRMWAKIKIYECSjOQBJsMMk2N3T+dY1dUV7nn/OLdSV1VP6pkeX+r3+fSnq26dc+u55946T34eZrEdYUZlFY0c3JauR4cZEUXoFgsxiws3I3kZ7mC3Ol+RvwKnv5IyBg7q+O4LRZjuHEQ8eycAf4/Px7Lz2VTP7DEImZFDDm+A5gofvXgY7Rv/OgZCEa7Snyfoqocz7+DnlvfhiXTlLaonIsOMaC4cVp3W5msUnZtXjv8dQ0FcYhTN6cfj9rBVNOLtWZ9zrJQSd7SbkC2QzJ8YOIjPIWF+a3zmZgBC0o4t0gfd2/POKYr1E7b6ANDMUOTxwlnjcQOLMMBiQxYr4cc1tCuvSUbZ9mNIzYImTAn6kJhDjLi5nRk2D0KoHIV169bx5ptvYrPZuOce5U+RcbVJCyHQLFasxA6awCmRaEjQLHzn+/cwc1oTMp5bO1m5ciWrXlGCgtAtfOyjH+WqK69Q7XjHgYaB1NQ12BJ5OQdhvBbiiMOoP3U4mPSS3ZONSq+DPkctzshzORPQBvvUzSmvqMRRPpWmzuf5+b5+LplXnXWu/o59lAM2v/qsKFAH+0AOtCJylKXuD0WooJcRZyVuoLncS3ivDfeL34VTb8+dJGWWew6JIkawIxGI0WGmlrvZ2pEjGiLUQ4/hRnhrMHPtcMSGaO0ZohbSzEpmTPawyQicPppqrbAKurs7qcmxdj3BCB/W/8b71t4PwFue02gZWqXMDOMUiLPFhhnVzfWzF+MJj7C7J8iSxuzrDfUp6dpTWoVloIIybfCgzKE/FGWhbR9EoWPF1/nh0yHO0tdB+3rwnJc1fnRQMQeXrxxvkY03RTn2wfHNK+HObZSLfrbO+izTzryd4Y3fgh7gwevghsezxuuRIWJWFcZaPPNsWA/dB/YxXhrccL+iy+JSUvcexwzODj2tJFAtM6lvaDRGQPYRcVaC0zTXDfcQiRnYLLk3j/5QFD+Dyj5fOpXP9H2AHxt3wsaHsos0miiODxC0q03eWd4I7RDt3YM1T1l3Ix6Fl7+PpX8fQrcRj4SwEAdrEYjsxERNGujRIHbNBhY7lkgQHQG2osyBlXPggq+nzYsTM8+n2d0QJIMBLV++nA0bNrBy5Uq+/MV/o6bMx/qte9iwaiX/9sUv8cyrG4nH43z84x/n1ltvRUrJ7bffzt///ncaGxsZSgRaaDpXXXoh3/m3j7JkWSlP/u1v3HHHHcTjcQKBAD/72c+455570DTBw799gLvu/j4rX3gZjAh33nYV69au4baPfoxQKERzczP33Xcffr+fM888kyWzGnj25XUMBUN86+4fUjsngGbElLXAkp2cGDfM8Fp9/ATPI8U7XnMAsJUre67MoVKHBhRzqK6oQqucRa3oonLLr3OeZ7hbSfyuUrWVBqoaABjozL3R9AQjBMQg8SJVG6qlws2rhpk8t/2ZnHMSJp4hXIAgbimCSJDpFR52dQezo0FCPbRHXUTL58CCDwBQLEJsbTOZQEJzMDOkjWEzGsbpZ059OSFpp68nd0x+99Ao52pmaazSFgarTsVGjJ6u8cNGbfEgMatyHOrOYq62rKRnT+7S3dFBZfLxl1WDuww3IXa0jV+4rj8U5SRNmYV8p1zDXkzzWJ6ck5jJEF0+xcC7HQ2UhsYPJDA6VeayqFB9NAYrlwIgW9fkHG+LD2OYztKmujriUjDQPb5ZKRHFZfUora+/ZB4OGYbObL9D5+Ao5aIfw1UONhWx83n9N+xoy59P0T8SoUU3aTj/v+kpO4U2vSbn+UFpin4GiDsVPSU1Kk9loH2cQoWm1J+QbmPCDBLI58xN2P5N4UIKDYFEMr5PQJNxDNNOb7NmVieOxWI88cQTzJmj/Iar167nzi98kk2bNnHfA3/A7fHy4l8f4vXXX+cnP/kJu3bt4tFHH2XLli1s3LiRH//4Xtatfs38IqXRRNHpbG/j5ptv5pFHHmH9+vU8/PDDNDQ0cNttt/GxW29m3dMPcsYZZ5rXo67/erOEx4YNG5gzZw5f+cpXEhdOPBZn5dN/4a677uJ73/gae6T53ObxbcSNOJoATTs2Mv47XnMAqK2ugTbo6uqkfIxCEBnuIYgDr6cIFt/EgZd/y02DPyQ68Ems3syyGCOm3yIRv1/fMBVegwP7duJbkP29fcEI08QAcVOrmFru5sbox9mofwQG89gRk8yhCDAwrC7Y9EdusL3Br40b2dUd5KRKU/sxDGSwi32RhdSVFsP5/4vs3IJ//wgb23s5C1I+B1NzEOF+pBAIh5cKp0ancBHME2raPTTCYm03fY0X4b/6R3hfegy2wr49Oygtz6VrAFLiNILErGoDE6bD/91vfxF4d9ZwwwwxdngrwKWYaLDvAMHRGC577se3fyRCs9wD3nrsLj8OXzWRsA1bHuYgzdh+i1tteiO+qZQceEZFqjl9OecYZt6Eo1RJ0XW1dTy24VTe42zN+aNyGsFkkUNPkYM+4WF0YHyzT9g05zlM5uCsnQ1tMNi2heLKzOZOXYMjTGGAjuKqDK1teM3DUJ+7hWRfKMpsW4eq9xaYSmNgiN2dZVTniUDqGQxSI0IIl6KnrqqKQVlEqDM/c5DxiNKCA9PBVkRff5DK0FakpwqRo6xMaHAAz/BOYt4GbC4/ke592Ee7iZTPwW7Nv13pxJGm5mDRNbooYSQ8miypvXz5cm666SZefvllFi2YS0O9+o0+9cwzrF+7mj/85WmE1cHAwADbtm3j+eef59prr0XXdSqqqlh26mnqizQLQsAoVla9/horVqygsVElsJaUpOmBJvMTpoYnhM7A4FCynDfADTfcwFVXXaWGS8nlF56F0HQWLVrEvr17CWMyuTyRV4noJ6Efm228oDkA0+oVR9ixP1uSM0J9BDUzUczpY8vS/0YTkgNrn8geO9BKWFopD6jNvqWpkZjUGMjj3OwdClHCEJZikzmUuRmiiJjmyF9ewTQrDUiz3LDNBYOtlHWvYoW2kS0H0mzeoW5EPEKrUUJ9qVLLhd1FmT3G1jYzfFS3Ku1h78vE717EUrmOUYsHNOUYi1mLGQ3mDjUNd2zDK0LI5rPAUUxljfqRdLXuzk07QCyMhTiGzWRgZkmPxuj2nBEj1mA7A8IDFhu4zHUSrbx9IL9Tuj8UpT66BypU+PGM6mIOUJbX0S/Cfcpe7fABYAlMBWCwfVvO8QBi6ACGFLhL1LMzs6qYTulDDHdkRe/E4wYuOYKlyJs8FrL6kQcp3R1NaDReczOuU+vb2ZZ9Hf097VhFHJs/sw9Ff3d+30l/KMJUa6fKc/HW01LhZle0NG8ByMEe9fvQPYpJT6tws1+WEesdxwSXjNpRG53dpv6LofacDlppOmA1c7xmc6IJiITHiVAz4mhIpEhtkkK34HTYWbf6ddatW8f3v/99bGb0k8vpSDISKSXf+dpXWPPUg7y+eg27du3ivPOU6TFRejtmSERCc0lqDlaENBD5opykgYFImv903dxq8w2XErvNhtB0dF0nHo8Rw6KG5/G5JKKfxDHSHCaEOQghnhVCXDjm2L0Tce7jgSnVSn3bd2CMJCclReEOIpZUxaymWUsZlEWEtz+fdR5tuIMOSvCalcWKHHYGNC+jfbnNB6GBTjQhsZkaiN9lI+C2EdTc+TN0TYd0f1wxB01L3cISPcSGdGe5KQG2yQBTSkybrc2N3xKlrce022tW2KGKeOm921mgbSfqSLV/FE4vemSQoRyd5iydqvCYa4qyN/srTFv0vuehK088vkm/SJQKX5jquNU1lO3gC4zspt1qOj7d6j790vaNvH4HKSXBkRHKInvAbJgyu9rLzliAeB7mYAn3MizcYK5loFYxh9Zd+XMK9FAHPRRT7FbrelJVMV340OPhrLyQ3r5edZ9dvhSdDh/WyMC4jtCYyZRdXrUZT21sICY1hnIIGyNmApzL1GT4hDL3RfvyR7L0h6I0iA5VcFK3MLtaFR7URnoyuvUlMNynfh92r2LSRTYL/bYKbMP5AyiEEVMbnLmBOa06IWlG4uSI9klseJpFMQerQ61vfJzeKImktnQ/jMWcnyvSSSCTzOH888/np7/6DUYsQjgSZevWrQSDQVasWMGDDz5IPB6ntbWNV00Hc+I6pG5n2aK5/OP559m1S5kge3uVQOfxeBgeHiJOih5dt+At9uD1eXnhhRcAuP/++5NaREKg0NK0AIdVJ4Y1f8hs8rpPYOYANAKfF0L8R9qxxRN07mMO3aE2//bOTEnOePx2FsY3YNhTTuraUjfrxAxKOl7JClG1hzro1wMZ3brCtpKMzmfpGO1XP7aiNGlvRlUxvYYrP3MwNYfeuBmplFbj5U79PoLb08pvmFnBu2UFU0rNzFGbC7cWRseMudatSXNN8rq9qQ5SNncJxQR5szV7M3b2biYqdexVahMW5uZ9es/D8L8n56FfSfya01zTd3+d1lm3ALBjZ3aUTFV0Lz1Os+5U9fzk8a2tuaXucNRgdnyLihKrVm0iZ9UUs18GkHmYgz3az4glJdU3m1nMPW35o3bsI510i5JkApLbbsGe2PwfyzTjdPeY5iG3L3nM4g7gZYjt4xS7M0LqGbC4lLnC73bQK3zJqLh0RPvNqC5TkyEwlS5bLZbggbwx/H2hKLWyHUpUgt0sMzcHyNmEKWyawYp8KXNQ1FOHP5q/14Ymo2qTNH8TdotGO6bwkSNMU5gJaZpmag5Wh2Iu45TDSCaXpW2SFtPvEB1TGiO5FqYg8JGPfISZM05i4buvY8miBdx6663EYjEuu+wyWlpamDNnDp+6/eMsXWpWnjUZkGZ1UFbq58f/8w0uv/xy5s2bx9VXXw3AxRdfzJ+feIrF516VZAS6Rc275+7v8rnPfY65c+eybt06vvzlL2fQlc4cnFadCHoqsnAsEsl7J7jPoR84G7hbCPEn4AMTdN7jA9NRODI8QM/wKKVulT+gmVE4HlJSlBCCzYHzWdH9Ndj8GMy6LPmZO9JJh/2kjFNLVxmekW5VYM9jz/jMMEMr9eJUueoFdT469zipD/WlyR1pCA+A0OiJqIbzYkxRvHN7f8tI5CacNh1a1zCqFdGq11Ke+G6bC7sRxi4SzMEG1z8OP1qWPIde0pB87fEFCO1/k5f397OsuZR0+Ia306pX02Axz211EhM2LDJ/ctBosA87YHF6k/R4F1wGb91L/9svwPw5qbUb7sLHEEGPWadK0+GSH8Djn6CjbQ+QHSHTPxLhXfpalWHbdCYAs6q9rJLlWEb7zexyb8YcR2yAcJpvobiknBEcjHbnd0oXjXaxT8tcj2DlKbDnh3Ags8RKf69iZO7ilE26yFcGbWt48cAQs2sy6UlAJGpapdEbtJUp09UYGGbORLodXzi8nBd5hd6NT1Ey9/ysOeHgENWRPVB+EQBep5VocR2EURnl5ZnPctSM6nL7U8+rpXwarr5H6GnfTWl1Y9Z3aGa2c2KjUeGjdoijStaMuReYpTOSGrHQMNDxGb1Iow6hZcuzRjyGRqbt3WazMbztJYYiERIVNQBOX3EGy6fdTdTcUDVN4+tf/U++/i830GGrpyKQuqc/+IHqH9IbHMXo30+pFgShsXLlSnqDESL9Wzj/zFO58IrM3JNp06bx2jN/RNM0HJXTWb58OUhJrH0D82Y08eorr2RF8/31T4/iGWklplsIBDzs3r2b7uFRRkcsFOXL9pbZGtNEYqI0ByGljEkpPwY8ArxInvaeJySsTqTQcYkwr+1K2foNzbRRRjPt/3LWZbTKUsLrfp86GI/hN3qIFGU62ey+SgIMZLSUTJ4noVG4Uks1v95Hv3QnnZFZGOkDh4+hUQOPw4KIZtpiy+ll/f5+9ebABvbYmqktcad6INhcaNEgDT5zQ9csyjZ/0kXJczgal6Tod/vxaSO8vjvbB+KKdNFnyezDkMEYctiUR0zntiXNxOJuWEwcjciYzmKhNtW5LlY6LXXQo7Qse+dGojlaIfYFoyzVNjNQOj8ZllzusdPhMDeuMZE4hiHxxAeJ2f2pg0LQ7phK+WDuCCqA4mg3Q9ZM5lDVPJcX47OIOjM1sQHzmot9Kebg9ldSwhBvt+XREAF9dICQcEK6w7G4Gk+0m54xdZz0RDl2d+p++EZNk9KL3815/vqRTViIwZTTk8eKalTpDbqyI5biwyaTK0l9h3eKysZ23Z/NfAD0tCiiBBK2fyLD2QmiRjzDHAMQtygTaiycW8syko7ZVJSS1Wqadsfk3cTiBjpG0lEMJCXvWJ5M7JiZT5C+CTttOqNY83Z402XKQa6IExjCgtsYQuYoy5/IvdDSwlKdVl2V0TCiOaO7xprsJhoTxRyS1bqklL8APgQ8Nd4EIUSdEOI5IcRmIcRbQohPmcdLhBBPCyG2mf/9451nQiBUHLXPEuHvb6cK8AUd6kcQaXlPxvDTWip4xZiF2PNi8uGOta7BTpRQyayMscWBagJigLdas5mDJWQyB3dqM5lf52dAupChPJvGSB84/QyGoxQ7rNBwesbHM8ReNm1creg68CZvxutpCKSJTjY3REPMrlDMYcQwH8ZrHuArLb/nHv39WOa+LzXe4cVNiNd2dmfVxPHEehmxZ26QGcjhVE9kouvetLAwi42Qxcelg78ltve11PRWtTlr5dPTvlQx37v17xL/foqJJdAfCtMi9jNaOjN5TAiBq26uejOmYc7ASBS/GMJwZD5mQxWLmSO30rs1R/e1eBSP0U/QnskETm4soVWWER/joA2axfIS5UIAtMBUbCLG/l35M7dtkT6GtUzJuqiiiUZxgDXbMs0+zpF2hjVPZj7Aog8D0JdD8AxH48w1NqtuaHWpdZzRUMN+GWCkNZsxCrNOl3CmrqNpljIfOkayHfGQKoWRDpfdgiETXdgyN2Rt7KYKxM3KAdHR3H6HpJ8ijYkmnLQZPRhQYa1CZI4l4fw2IkRz1H2KGxIr8eQ4AIdFIyJsaPFI1nUbUqqEtjHXkaxykcvMbGoB6WGpijmYBfhymNV0GcdIM9lNNCaEOUgpfzzm/Wop5Y0HmRYD/lVKOQNYCnxcCDET+ALwrJSyBXjWfH/MIWxumr2C57Z0Juv8ROOSN+R0nJd8O2PszOpiNllmYI/0Q/9uNfYf32VQOhmpy9ys7cUVOEWEjbuy7cS2cDdRYU31cUbVuTFMZ2VOjPSB08dQOIbHYYErfwY3PQOX/Ri89ViEwY1rr1JmgWiQV0I1zKxKS+yzqs1jTkA9UOtaU9LY2v4inq+8QUUGJeDwoWFgjA7zVlvK7yANA7/RT7xojIL4rn9Pvc6RGZ4oDmf3Z8YMj3pVzHz0sc8kj4U7thOWVnyVaeaKNMnYMbAj64cZ6dqNS4wiyzOZdMvU6fRLF8N7MzOMe4ZHKWUwg0ED+KqVU7rkNzk6/w13oiEZdWZqTbOqi2nXKnCMdsMbP08NN8t1J01pkHSWy47NBPPU43fEBjJ8IQD+k6/CIaIEN/wpeUxKiTdygCF7ZqSS5ex/Z5elmXAwO7JrYCTKdG0fw86ajHDdUxpL2WrUEml7M2uONtLLoPBkaDJF3gBPOcwQ5DGVjePxeLIURjqKbBZ2J2L4xziMNbKZg93hIC6F0gJy9N+WRgwpx2z4QjBsV9+R7ndIaJt6+lhzQ/YzlPNexOMSm4gi9JRZWAiB1O1oGFnXEE9qGplMUTNzHZLtSTOuIW5GN6W2ZE0TxKxmMMyYiq6GlOhmJvmh4FD6g4/FpIWySinbpZRrzNdDwGagBrgU+KU57JfAe48LQZEgpw78hYWhl1i7T0ntWjRIt7MxWR0yAV0TOGrNZicHNkI8in3XMzwcP5Pq6vrM85o5DP2712clqDkiPQQtJVmc3+Mvwy7DuWvGh3rB4WNgxNQcHF6oOxnmXQNX/SI5rOetvwOwyWhgVnUaczATpBrd6oF+ebfa8KWU7OwapqksTcuApE3YS5BXdqZ+mAO9XVhFHEtx5gbJGZ/j3oa7AIgPZ0tIcrCdAVmEx5OZiS4v/CZtsgRL3/akOSo+0MYBWcKUQFrTzrFZ42Md953KFGWvycwDWNIU4G1ZT6R1rD9AXYfuyWRyVacpt1mnoyHrGhK9P2JjGKNV19he8171ZuPDyeOG2QMhw/FfprShZvaxek9uLdEVHyBi82Ucs9UvIYKVWFuKyfUEI9TJdkY9Y5493cKorxlXpDsr2qw3GGGqaCNkMuUEZlYXs1urxzW0M7P/OGAb7WVYz6QHoKvhYgAibSmtzOFw0N3VBchMsxiojO2EFJ4mRUspc2oOmmmSAXKX6jBiqjHQmAJ0VpupHY+kTK+GWddJSxeAhEDaPThElFAO5mDEo0pzsGTuAxa7MnfFx5RMiZvaydj8A1GsmLcm41nPrSpTnr0dO+x2YlLL7I5HigGNXatckFLS09ODwzF+C9ixOCGS4IQQDcACYBVQIaVsB8VAhBA5fRdCiFuAWwDq6+tzDTk8mFFAn7A+ziOvnseCTY/jM/pweXw5hzfPOpn4XkH3ttVUBKajGVHeNBq4qHxM92HTn/Cg/iVe23YxS2YoKTg4GqPc6GLEWcXYb6iqrIYu2LZ7N9OnZToFGdgPVXPp74wwvXJMU9raRQwvug336nvoXftHijUH26hl0ZQ0k4npfLeM9gPw7NZ+PhU36B6OMBiO0Vw2hn6TOcwJSJ7f2sVtZ6jNpOvAXnxAkT87kWlqYwPshn3799HQlPmZFjxAp/TjdWZKk2XNC/m263o+G7oLenZA2TS04QN04GdRel9jTQdffXKTiA+0oqcxDGuPspV76+ekn57plR4e1uqYO/hKxvGQWUPJ7s1kcja3n5WuC5gXyi6mZwy2ogHSXZX12azp0/nhvkv46N6/IAbboLgaS6iTODp6UZoJzu7BcFfSNNDBa7t6WTEtU3OJxQ08xhAhR0vmF2g6g+4mAgM72d8XotZfRHvrPuZoHWyrvJ6x8ARqqOl+itH/mQm3PQdmv4rO/mGWinb6SjMTD3VNEC+bgaX7caV9lqX8PY5oH6M5kgLrTloEb0Pb1tU0TD8HgNraWrZu2khvqJNRexx7R3/GnL7gKKPRTqATvGEQgrghYbAdQ3di7c1kZuHhIRwxU3Pt35QhUMWGOpHxGPrAFrR0QSsWgeFOgno4+TseHuqnKz4IvXqGmYjRIRjpo0szGCjOLNUxONBPUA6CRwM9talHYnH2D3eDZRjdnQr/Ho2MYg91EnVEsR7IvG76TUGhbRhcqTnh/k6sIoY+kOnrCUfjdAa70fR+dE9Ky4/EDLThdoTFht578AZKDoeD2trag45Lx6QzByGEG+XE/rSUclAcov1MSnkvcC/A4sWLD19nyoNiVxGlb/0cTXsIgPJAIOe4c+Y20vZEGXVr/wfcahn3W6ekooIS8E9JvtyyaW2SORwYDFNDN7Hi7Obs9bNPg43QvvaJTOYQHlSmmpImBkai+HJ0andPXQ6r76Gl/yVeZh5z6suS0VdAUnNI9KnoDMZ5YVs3I2a8/YL6MS4e08Z/Tk2cz2/spS8Ywe+y0depnJ2eQHYm9NzpzfAc9G99CVZcl/GZJdhBh/Qxu8iaNa+seQFshNHnv4f9ih/hGOlgyNaccqYncPNKVr30DKe8fAs7du1gWlWKEXgGtrKfcmqLMs0xuibQSxop6n0KOdKHcKrrHOpRzKE4x3XYK0/Cv+MJ+t58Gv/sc5PHw72tFAG6N5s5nDOjnI88eSYfszwOGx4iuuyTOEe7CTpLKR4TaaO5y5kSCfHAjm4+y/SMz3pDEfxiiJBzjKYE2GrnsWDoz/z1zZ1cu3w2g9sVA3M2L8saW141Bd5Wobe89ajKVgaCHTuxixi2qplZc0oa50E39O1eh99kDoYhKY73E7U3Z42fN12Z4BpWfw3mnAYNp2O1WjF6tzPrHzez6cI/MGNGZmjzH9e28pdHf8l/We+Dm5+DmoVs2NfHjIdOZ9+Mm2i65lsZ41fv6uQvP72Dz1ofhusegZZzkp+1fucW9gzEWXrnS5nPyugQ0a+fQ4fhpeyOjdhHuuF3qswJd7Rn+mfeehT++CE+Pfp1fvGFD1HldSY/evYr5zNd34nvi1szmFI0bvD8f36KufYOyu5ImeGee+ox3vXy9XRc+hsqZmT6xUJfew9FkR6C096L6/2/TB5/4T9upckdpeZzmcJLcDTGq/91O7Ndg1R8fnXy+N83H2DJ384iNOtayt93V9Y9mQhMaoa0EMKKYgwPSCn/YB7uEEJUmZ9XAXlatB0blPuLCcsUz2yorsg5zltkpdVtbkovfAcDgbN6JlnMLdACZyi3yd4dKamgo6uHatGdjDHPmDLtFLpFCdY9L2R+YJbUkN56+kNRfM7sDRZnanPfFKvh9rOmZn6eZA5KAnIXOfnpizt5eUc3DquW6Z8AKFXzT/X2Ejckz5oO+26zHHRldR1jEShT/oT5+x/Ias9pD3fRLUqyNAeAeQsUo7Rv/A2EeimOdWN4sjdgXKXMnKXMelt3ZJZuCIS2p/pxj0FVk9oIIz86M6l5JDQHT0n2ffafrBzz/t9fCQOpZLKRnlZiUqM4kF18cWq5G+lvokuvhPb17N27hzO0tYwWT8kaiytAnS3Eun39WdFHvYNBisUIujvb4e9Z/jG8IsR7nrsQnrmTwNYHiUidqhmnZo21VqSYTnqQg9GpHOGu2mzmMH/BycSlYPi1XydbW/YFR6kW3UQ92UzU67Sy2Wr6eDanfCHhXrVmvvJsifXM6WW8Is05Hcr53dbZjVXEk0l/6ZhbH+Ah68UqkmlPZitd+2gPw2YZ8cwPPGxf8n+pFV2E7r2Q0R2qvPqq2huzC/mZJr9SMcizm1NbTtyQzDHeptW/OMv8a9U1QqVzKIvswxhJ+QhHzZwTb1n2b6P3ykfU/96UP254NIZbBlNVA9LJsluQxTVUjGzPKJ3f292JW4SxBxqy5kwUJo05CLWL/gzYLKVMj7V7HLjBfH0D8NjxpKvIWcQ581Mbtr0o+4YlED7/W7xuKMmqVQZY1Jy9WQBJae2LoW/SuuZvAAztXIUuJJ4c0h5CMOBuxhPcnekgM+PbRxwBYobEl0P6TmcOV561lDOnj7HKmWalRBbvh1dM46XtPfz61b2cP6syu4JnUQmUNFH92n9xm/tFHl2rsmEHutWmX+TLwTx1C7uKVQ5kcE9aITopcUe6GbIGspkoMK+xkh/ZVRxDcMNjOIjgCOTYVAFPqVrr9tY0G3RslIrofrqc2dItwIxl72GXUYl9cDc8r4IMNJNJCF+2aXLatBmpN/tfT76MDrTRiY8Kb1HWHCEEF8ypZG20lljbBiKv3UeZGCS8+OPZBBUFKGEQKeG5LZn+mWEzCzojqivxHTULWFt3PcXGALz4PaYPvMQuawu6zZk1lvqlqXkvficZXWftU6VB7JUzsqY0VZXRo5VQ1/UPeEiZqjo6OnCLcKpM9xisWvpDolIn1JOKooqZDbRKK7M3SV+RjbK6GcrBvUP5x3q7TC2uJNuSbNU1Tplez37Kkb27Mz5zRfsYseXW8FvOUluJv2cNwxv/SlhaGVqaoymTyRxO8oR5ZnMqj6S3Yx/loj8rCjEB/1Ql0Ox+M9XkKtE4zOHLFmxqpy3gFf1kqrpfgdW/AKCtf4RigmhFvpzfUVmqftPDj3wyeSzSpYqEuiqn5pwzEZhMzeE04IPAWUKIdebfhcDXgXOFENuAc833xx5mxVJ0Gwsr080w7tzjgTPmNPGk71oAthq1vGduDikXwJ46h+0ZFc0jWt8AwNuyNOcUV/VJNNDGyrTQWkwH76DmA8DnzDYrpTMHX2VD9udjzErXndrMB5dOYVlTKf/n3Sdljwe45jfgq+cLsR9y7Z4vs721k1DfARVdkcPsATB08c8A2Lk5jTmEerEQY9SZOwVGCEHFAhU27PrbpwGomjI951jsHmKaHTncmepj0bkJHYOgP/ec0tIyPlv1c56znqEk3HgMx/A+FQKaw5auaYI75z5LXApiretSdA620yl9VBTbs+YAXHNyPZuMevS+HVhaX2OXrKR88SXZA701WEMHqPfAs2kbEkDYbC9rD+TWguqu/O+M9yOluTcvikoILrw19d6M9ika3EGPKMlOQkPdh5VTv8AOWa1Kq/TuoqtVlRIprsrNeJfPncqTxsmwd1UyoEAMH6AfN3ZHNhMFOHtWJX+ILkNu/jNEw4TMa3bmEQjOmVHO3nhpchwA4UGcMkQkzzNlsTv50wwlCJTu/gs9eDm5OcfYIsVclpQZvLyjJ+nA79muhAJb7fyc55+5aDkAe99KhTzbB3YQpCjDp5AOe0mtimb606dgsJ1d3UGKRQiHJ/dvyX+2iuBLd/gn2t5aSrMtDxOFyYxWelFKKaSUc6WU882/v0ope6SUZ0spW8z/+TuqTyQu+QGUzVC10yNpyTY5KkcmIITgpg/fzBPlHyF27n8xdawzOmOwiipoH9GI9rfh71lHq16LyNWzAShvnEOxGOHF9ZtSB81Ep17hA5RpKwvp5yvO4YBKMCozB8FitfN/3zub396ylBpfDskTVNjl8n8F4CJ9FXff90tso71Erd6sSJQEZjdPoRcvw3vTooPM5J+4K7epDuDCFZk+mMaTFuYeKAS4yykX/fxhjTJfhN5SxRBlbbYfJ4H3zq/md8EFMNJLdOcLVIZ30l/UkHf82XOmsEXWE199f7IWkDXUTrsspdyTO/qjMeBCr5qHQNIy+CrdrhbslhxRJXWnIIwo10/pZeWWLobTtMRYpyp9UlKbm9EFvG5ebP4X1hpKcqxeclnOcQCuS77Jt31fBECaTa1KQrvpdua/7qnLr+KGyOfVm02PEWpT9ATqctPTXObmLfcyiiLd8PLdAFiCBxjQ8+fBvHd+DavkbIQRgQMbCXeYJfNLcjPEM6eV00YZMj1iqW83ABFPtnaSwNkXXc3bmlqnTeUX5zRp4vSD0JhfEiUSM/jzBvWsRve8jiEFgZbc1YBKKmrp0QNE961R7UylxB/cqaLc8vhPa+rSrq9vF7u6hvEyjNuXm5nU1Ddxv/ODlAR3pHKHzOvG35D3uo8WhaqsCQihOH00lLSzUtIEFXkkMhNVfg8XfOw7nL/itPHPf9sLROx+5sotWO+awcmRVfT45+UdrpWpKJX27etTxdmGO0C30R5WEmtFcY7NKT3czpuDOSQkxVC3YliHmkAz+8pkFnVNeDtT7MNYi/MnwWuaIFRUw7Lhpwm9+COAZGaoJYepJEleUSoCq++Mr6EFckuqAJaSBmY7e/j96v0YPbtwvPI9no4vpKou/5xLF9SwSl/IsO7D+PO/Mk9sI1KRo566iaVNpfxdX4Z9tDtpTy8Kd9BvKVMlSvLgkis+wF6UYFE1dX7uQXWKiV1uPMVINM7f3kwVaCztfJku/BSV594oAU697st0vO/PbP7gesoXXZx3HMCCWcp81P/EVxnd9DdmGNsJe/Ov04I6H67yJrbq02DNr3AfWMUoVuw5HNgJlCy7ntVGC6NrfweAO9xByJlHmwbKix14mpXDdmTP68wbfI6QXpxbqEEJQ9bSBtzRXmJhpS1Guk2fUx6GAlDkKibwLy/z7GVrWHHLt3MP0jRwlVFBNy3lbn73utkPpP1F3qSJqvL8As1I1SnMj60neM/ZxO+/gvr4XoaLW/KOL69IEzgH29jf3o5NxLHnCHBIIFH+ZP+rj6iuf8E9DFoC2b6TCUSBOaTDqhrnEBlSyVafXJthpjkqVMzCuvhDGYdKTxqHoZSqh2tqfAdPbTJNDsNd4CqnfVBJsFXeg8Qtu7Ide9g8qvFILJwZyncw2N1wzQPgrecTM0c43d+HFhjf3qkvVJFK4Vd+CsBgp/rBlVTkl/KApBPcf+bHxh/nn8LUyNv4Bjbz1itPoBkRvh67lmljQ3zTUOywcuHCJj4bvgn7wA4swsAzP4fJx4RV1+hfeDud0sfoxj9CeBCHEcLw5GdwAFMqA5TccD/R0pOoPfWa3INMLa9k5+M0l1h55A3TXh/sYcbAi7ziXDEu89Y0wbtnVzGjuWFcWgCWzVN5H/69T2F/6Go0IdHrcndvA6UVX7e0nv8cuQJ6d7B84HF2Fs0d95l574IanjCWYu/ZTO+O1ZTLLvDm6eth4sozl3BA+tn33M9Yrm3gwPTr82qjAM3TFHNau1Zl0vftNzWsmvybMUDAbefsec3j9oSgZhFiw++4cZ6Tdfv6ef3tXVQH32Kr++RsZ3cayk/9AGViEE/PBvSdzxIQg1irsn05CYi0IIsdO7exd69pJsvRLTKB01ecT5sspXft47QNhGkxdjLoy2MGniAUmEM6bEWqI9ro8Li+hiOFGPNDqVmQ3dwmieIapL2Yf7c+wEOvmup2sBPcZRwYCKNrgoA7t82bmkWquUqOImVoWiojW88zfzxUzsHV/ipa785kIlc+VJ3zCZ50XKAqgxoGfSZzqKzNL+UBcN3DcPuag2s1JuP+i/0OGt/4KnE04t4p+c1jJj59zjRW2ZfyvegVPO65mrLZ54w7/ppTGngyvhht+1MY+5UPxeY/eMy4u3EJ1ttXwZjGPBmYo5q9PBu6ilP33aP6cWx+HAtxNpdflH/eYSJZrTUN9Yvfk2NkCu9bXMeu4iX8NP4eDCnonzN+0YMyjx197hX0SjeO315OiRjOzG7PgSVNpayruJxpcVUBt+6US8cdP+O0SxnFSvBlJXBEW9fTJkuYUjM+EzokmBnM72v7Ju91b+Khh3+DjgFN7xp3mm3GBVnH6lrm559w0kVErv8rI9gZWvN7Phs043Hc+bUTr8tGR9kypgy+wU+f2UCLaMVRn1/jnQgUmEM6rC5lVhrYl5UNOSFoPAPsXlh8I5z171CaX61H0xCnfxqAgd3r2NE1rMoTuCtoHwhT4bFnZYQmceOTcNuLuT+DlGnJksOhfTBUzlbmLSMKM8f/IQOUTz+FYoZ59bk/EercRZ9001KT27aaREnT+GuTgD3lTHUTpNUo5YqTD+6gK/PYefi2U3Gc+0WW3fL9gzKhqeVutjdcSywuiT6iyouX1UyQI3BqKn/idssf+eHK7UTW/54dRhUlTfkl+8OGxc7I+/+YfPvleSspLh8/edRh1fmfa+bzY9uH+GTlr1h07vsP+jUfOn8pXxW3UBTrB6BiysGl23M/8Pnka2ttHh+TCZu3gq2VF7Fs8Ene3roFZ/ebvCWbsjP7jwRnfQkAfcfT3BX7Kh+OPUQQByvOzlFCJR1CELniV3SnVel11eQ3v6Fp2JpOw2q1MV9sZ662C2n3QNXccb9m6ikX4RUhPrnxcizCoHTGGYd8aUeCSU+CO6FgK1K5BIOtOZufHzXKpsEX9hy6nX/u1fDsf/IN20/51TNz+cpwJ1TNY3dbkFr/OLbGg5mLnD7VT1k/AuZQZfpJAtOgav5Bh89dciash2UvqJDI3Xo9Dfk0nsNFomSxCUugmdvOPASmgtrwxw0gGIPrLj6fv/zvqVw5shKAuXPy+4sOCzMuhkfVy4jmZOv6V7DZX+Sx+JWcN/UgTPQw4Zz2LozASQw46/iPS+cf0pzFDSW8/qXzDvk7qrxOPvyhW+EXShrWag/O4PTiCrjw2yqS7hBaXjZe/H+w/OSPtPxmKToGHcXn4LBOwO+1/CQVfTeinL4zxW4iJ3+Ucl/+cPYEbHMuxVM+E35kOq7zhPymw2JuA/LaBxG1S3JGjqXDM/sCwm8sxN+xhph3CpbGFQf9jqNBQXNIhy1N+mgeX5U8YhxOBcXiGrC6mCl284m3PwjDB5CucrYeGMounXE4SDyER8IcWs6D93wH3v+7Q7oWvXIOPdOvTb535jBvHDESwQKVKhmxuq4Rq35sHulpFR6aTrsy+b6kMne45WHDVgSf2QTeemzGCN8oup9BWcSaqqsya2JNELSPvoT/ww/l1zonAHMaKuGye+H0z4D/ICbEBJbcDPMPrpkAuGtm8tqyHymTD1Cx7H0HmXEYKE4zT+l2bBd87ZCnJsOOS5oP7Xd+zn/A7CsR094NrnGqGyfg9OH46HPwmbew3PaPY2PdSEOBOaTDbA4DwLxr8w47bhACrvk1wcUfo0yo7Mj2eDFDozHm1/mO/LxHwxx0K5z8kZyZ3bnHWyi99h56zlaSZIVzwiqdqOipT2+EhWbO5LHQ9tKw8F2XK43ptE9PbJlkbw286w4A5sY30TrrZn5w41k5EwWPGrolty9qojHvajjnzmNWTnrZ+dey+YKHWX3GLznn1Pyhy4eN69Nybm9ffXhrpVvgUxvg5r8f2vglN6uqyoe7Rt7aiQuUGQcFs1I6ms5UTMHmhtlXTDY1Cs1n4WpYDm/8EIC7Xu3HpmucMT1HJNKhwmZqHUficzhClM6/CDb8BFZ8buJOKoRS31vOUxFOy3JkIU8kbC74xOsHH3ckmHOlKmkS6mbGis+B9fjdm39WzDjl0M1dhwxXKVz+U6heAL6DRNXlgn+CNMoTAAXmMBaX3XPwMccbaT6Efs3PHReelD9S6VCQMJ8dieZwpPBUwMdfPfi4I4F/ipLy/pmhW2HZQUJ3Czg+mHvVZFNwQqDAHP5Z0HI+bHuSez9z7bjx0IeERJb0kYSyFlBAAe8IFJjDPwsuuRt6th89Y4BMx3sBBRRQQA4UmMM/CzyV49Z5OiwkEvyM6PjjCiiggHcsCtFK70QkNId4ZPxxBRRQwDsWBebwTkSSOeRubF9AAQUUUGAO70QkzEpjMowLKKCAAhI4YZmDEOLdQogtQojtQogvTDY9/18hwRyOcdJYAQUU8M+LE5I5CCF04H+BC4CZwLVCiHEqWRVwWEiEspYf25K/BRRQwD8vTtRopSXAdinlTgAhxIPApcCmcWcVcGiomAPLP6uycgsooIACcuBEZQ41wL609/uBjAIqQohbgFsA6usPXgGxgDRoGpz9pcmmooACCjiBcUKalYBclagyKrZJKe+VUi6WUi4uKzuKOkMFFFBAAQVk4UTVHPYD6VWvaoG2fINXr17dLYTYcxTfFwC6j2L+sUaBvqNDgb6jQ4G+o8OJTF/eSoFCygksoTxBEEJYgK3A2UAr8DrwfinlW8fo+96QUi4+FueeCBToOzoU6Ds6FOg7Opzo9OXDCak5SCljQohPAE8COnDfsWIMBRRQQAEFZOOEZA4AUsq/An+dbDoKKKCAAt6JOFEd0scb9042AQdBgb6jQ4G+o0OBvqPDiU5fTpyQPocCCiiggAImFwXNoYACCiiggCwUmEMBBRRQQAFZeEczhxOhuJ8Qok4I8ZwQYrMQ4i0hxKfM43cKIVqFEOvMvwvT5vybSfMWIcT5x4HG3UKIjSYdb5jHSoQQTwshtpn//ZNBnxBietoarRNCDAohPj2Z6yeEuE8I0SmEeDPt2GGvlxBikbnu24UQdwshciWHThR93xJCvC2E2CCEeFQI4TOPNwghRtLW8Z60OceTvsO+n8eZvt+l0bZbCLHOPH7c12/CIKV8R/6hQmR3AE2ADVgPzJwEOqqAheZrDyq/YyZwJ/DZHONnmrTagUbzGvRjTONuIDDm2DeBL5ivvwB8Y7LoG3NPD6ASeyZt/YAVwELgzaNZL+A1YBmqYsATwAXHkL7zAIv5+htp9DWkjxtznuNJ32Hfz+NJ35jPvwN8ebLWb6L+3smaQ7K4n5QyAiSK+x1XSCnbpZRrzNdDwGZUbal8uBR4UEo5KqXcBWxHXcvxxqXAL83XvwTem3Z8sug7G9ghpRwvW/6Y0yelfB7ozfG9h7xeQogqoFhK+YpUO8mv0uZMOH1SyqeklInuT6+iqhLkxfGmbxycEOuXgCn9vw/47XjnOJb0TRTeycwhV3G/8TblYw4hRAOwAFhlHvqEqebfl2aGmAy6JfCUEGK1UAUPASqklO2gGBxQPon0JXANmT/KE2X94PDXq8Z8fbzpBLgRJckm0CiEWCuE+IcQYrl5bDLoO5z7OVnrtxzokFJuSzt2oqzfYeGdzBwOWtzveEII4QYeAT4tpRwEfgQ0A/OBdpSqCpND92lSyoWo/hofF0KsGGfspKyrEMIGXAI8bB46kdZvPOSjZ7LW8YtADHjAPNQO1EspFwD/AvxGCFE8CfQd7v2crPt8LZkCyomyfoeNdzJzOKzifscSQggrijE8IKX8A4CUskNKGZdSGsBPSJk+jjvdUso2838n8KhJS4epGidU5M7Jos/EBcAaKWWHSesJs34mDne99pNp2jnmdAohbgAuAq4zTR2Y5poe8/VqlE1/2vGm7wju52SsnwW4HPhdGt0nxPodCd7JzOF1oEUI0WhKndcAjx9vIkwb5c+AzVLK76Ydr0obdhmQiIx4HLhGCGEXQjQCLSjH1rGizyWE8CReoxyXb5p03GAOuwF4bDLoS0OGxHairF8aDmu9TNPTkBBiqfmMXJ82Z8IhhHg38HngEillKO14mVCdGRFCNJn07ZwE+g7rfh5v+kycA7wtpUyai06U9TsiTLZHfDL/gAtR0UE7gC9OEg2no9TJDcA68+9C4H5go3n8caAqbc4XTZq3cIwjHFDRXOvNv7cS6wSUAs8C28z/JZNBn/l9RUAP4E07Nmnrh2JS7UAUJSHedCTrBSxGbYI7gB9gVjQ4RvRtR9nuE8/gPebYK8z7vh5YA1w8SfQd9v08nvSZx38B3DZm7HFfv4n6K5TPKKCAAgooIAvvZLNSAQUUUEABeVBgDgUUUEABBWShwBwKKKCAAgrIQoE5FFBAAQUUkIUCcyiggAIKKCALBeZQQAEFFFBAFgrMoYACCiiggCz8Py1VYgwPluBSAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -655,7 +792,11 @@ { "cell_type": "markdown", "id": "af6d0dd9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "As you see, forecasting larger time step makes the learning more difficult. " ] @@ -663,7 +804,11 @@ { "cell_type": "markdown", "id": "4db7a226", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Next generation RC" ] @@ -671,7 +816,11 @@ { "cell_type": "markdown", "id": "fe660d93", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "(Gauthier, et. al., Nature Communications, 2021) has proposed a next generation reservoir computing (NG-RC) model by using nonlinear vector autoregression (NVAR). " ] @@ -679,7 +828,11 @@ { "cell_type": "markdown", "id": "52a7d495", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "![](../_static/NG-RC-vs-Traditional-RC.png)\n", "\n", @@ -689,7 +842,11 @@ { "cell_type": "markdown", "id": "2d5290db", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In BrainPy, we can easily implement this kind of network. Here, let's try to use NG-RC to infer the $z$ variable according to $x$ and $y$ variables. This task is important for applications where it is possible to obtain high-quality information about a dynamical variable in a laboratory setting, but not in field deployment. " ] @@ -697,7 +854,11 @@ { "cell_type": "markdown", "id": "aa38a237", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's first initialize the data we need. " ] @@ -706,7 +867,11 @@ "cell_type": "code", "execution_count": 16, "id": "b76ad29f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "dt = 0.02\n", @@ -741,7 +906,11 @@ { "cell_type": "markdown", "id": "06794a58", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The network architecture is the same with the above echo state network. Specifically, we have an input node, a reservoir node and an output node. To accomplish this task, (Gauthier, et. al., Nature Communications, 2021) used 4 delay history information with stride of 5, and their quadratic polynomial monomials. Therefore, we create the network as:" ] @@ -750,7 +919,11 @@ "cell_type": "code", "execution_count": 17, "id": "840f0934", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "i = bp.nn.Input(2)\n", @@ -763,7 +936,11 @@ { "cell_type": "markdown", "id": "8ec81aee", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We train the network using the Ridge Regression method too. " ] @@ -772,7 +949,11 @@ "cell_type": "code", "execution_count": 18, "id": "3d7f96e7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -780,7 +961,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "b67f0bd8dda64e529419f5cd9ce79957" + "model_id": "92738852fe1f491d8508da77c8ed516c" } }, "metadata": {}, @@ -790,7 +971,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Warmup NMS: 3452.0045170055173\n" + "Warmup NMS: 10729.250973138222\n" ] }, { @@ -799,7 +980,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "36636f6eeefb4ac7898cdf54bba8dded" + "model_id": "00262d178467449fa535d307ce07278c" } }, "metadata": {}, @@ -811,7 +992,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "cca694d1301f4fd4a335050939b9c3a2" + "model_id": "ff91d66b26824f30830cc4608cd83db2" } }, "metadata": {}, @@ -823,7 +1004,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "1b1748c36ef6466bab7e7f37591f8017" + "model_id": "1ec674571fca46d986db0257ca570cd0" } }, "metadata": {}, @@ -833,7 +1014,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Prediction NMS: 0.20419239590114113\n" + "Prediction NMS: 0.3374043793562189\n" ] } ], @@ -856,14 +1037,20 @@ "cell_type": "code", "execution_count": 19, "id": "c03bbe49", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -890,7 +1077,11 @@ { "cell_type": "markdown", "id": "07b13583", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Recurrent neural network" ] @@ -899,7 +1090,10 @@ "cell_type": "markdown", "id": "56299bb3", "metadata": { - "lines_to_next_cell": 2 + "lines_to_next_cell": 2, + "pycharm": { + "name": "#%% md\n" + } }, "source": [ "In recent years, artificial recurrent neural networks trained with back propagation through time (BPTT) have been a useful tool to study the network mechanism of brain functions. To support training networks with BPTT, BrainPy provides ``brainpy.nn.BPTT`` method. " @@ -908,7 +1102,11 @@ { "cell_type": "markdown", "id": "24ecc1e2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Here, we demonstrate how to train an artificial recurrent neural network by using a white noise integration task. In this task, we want our trained RNN model has the ability to integrate white noise. For example, if we has a time series of noise data, " ] @@ -917,14 +1115,20 @@ "cell_type": "code", "execution_count": 20, "id": "6a669645", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -932,30 +1136,40 @@ "noises = bm.random.normal(0, 0.2, size=10)\n", "\n", "plt.figure(figsize=(8, 2))\n", - "plt.plot(noises.numpy().flatten())\n", + "plt.plot(noises.to_numpy().flatten())\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7037d3fe", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now, we want to get a model which can integrate the noise ``bm.cumsum(noises) * dt``: " ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "199e9d77", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -964,23 +1178,31 @@ "integrals = bm.cumsum(noises) * dt\n", "\n", "plt.figure(figsize=(8, 2))\n", - "plt.plot(integrals.numpy().flatten())\n", + "plt.plot(integrals.to_numpy().flatten())\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "13ded3c7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Here, we first define a task which generates the input data and the target integration results. " ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "080c7634", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "from functools import partial\n", @@ -1012,16 +1234,24 @@ { "cell_type": "markdown", "id": "8a304e0c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Then, we create and initialize the model. Note here we need the model train its initial state, so we need set ``state_trainable=True`` for the used `VanillaRNN` instance. " ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "20cc5e5b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "model = (\n", @@ -1037,7 +1267,11 @@ { "cell_type": "markdown", "id": "addbaddd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``brainpy.nn.BPTT`` trainer receives a ``loss`` function setting, and an ``optimizer`` setting. Loss function can be selected from the ``brainpy.losses`` module, or it can be a callable function receives `(predictions, targets)` argument. Optimizer setting must be an instance of ``brainpy.optim.Optimizer``. " ] @@ -1045,16 +1279,24 @@ { "cell_type": "markdown", "id": "21af35b1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Here we define a loss function which use Mean Squared Error (MSE) to measure the error between the targets and the predictions. We also apply a L2 regularization. " ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "934d84f1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# define loss function\n", @@ -1066,9 +1308,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "fadde858", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# define optimizer\n", @@ -1078,9 +1324,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "46d4c4bc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# create a trainer\n", @@ -1092,20 +1342,24 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "26086c65", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Train 500 steps, use 10.0881 s, train loss 0.58875\n", - "Train 1000 steps, use 7.8295 s, train loss 0.02959\n", - "Train 1500 steps, use 7.8285 s, train loss 0.02747\n", - "Train 2000 steps, use 7.7275 s, train loss 0.02597\n", - "Train 2500 steps, use 7.6710 s, train loss 0.02476\n", - "Train 3000 steps, use 7.6240 s, train loss 0.02363\n" + "Train 500 steps, use 9.3755 s, train loss 0.03093\n", + "Train 1000 steps, use 6.7661 s, train loss 0.0275\n", + "Train 1500 steps, use 6.9309 s, train loss 0.02998\n", + "Train 2000 steps, use 6.6827 s, train loss 0.02409\n", + "Train 2500 steps, use 6.6528 s, train loss 0.02289\n", + "Train 3000 steps, use 6.6663 s, train loss 0.02187\n" ] } ], @@ -1120,23 +1374,33 @@ { "cell_type": "markdown", "id": "3adb6bfe", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The training losses is recorded in the ``.train_losses`` attribute." ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "2419503e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -1151,16 +1415,24 @@ { "cell_type": "markdown", "id": "05125733", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Finally, let's try the trained network, and test whether it can generate the correct integration results." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "id": "c594fd12", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -1168,7 +1440,7 @@ "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "0ed001538c31416eac0e91a2746fe40f" + "model_id": "83adebdcf0dd4174bc6b767c8ca03d97" } }, "metadata": {}, @@ -1183,16 +1455,22 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "id": "84472515", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], @@ -1207,7 +1485,11 @@ { "cell_type": "markdown", "id": "45414688", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Further reading" ] @@ -1215,7 +1497,11 @@ { "cell_type": "markdown", "id": "cf32b897", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "- More about Node specifications, please see [Node Specification](../tutorial_training/node_specification.ipynb). \n", "- Details about Node operations, please see [Node Operations](../tutorial_training/node_operations.ipynb).\n", @@ -1230,9 +1516,9 @@ "notebook_metadata_filter": "-all" }, "kernelspec": { - "display_name": "brainpy", + "name": "python3", "language": "python", - "name": "brainpy" + "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { diff --git a/docs/tutorial_math/base.ipynb b/docs/tutorial_math/base.ipynb index 12295ac78..66ba35f42 100644 --- a/docs/tutorial_math/base.ipynb +++ b/docs/tutorial_math/base.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "1aaab85c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Base Class" ] @@ -11,7 +15,11 @@ { "cell_type": "markdown", "id": "17e64f22", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "@[Chaoming Wang](https://github.com/chaoming0625)\n", "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" @@ -20,7 +28,11 @@ { "cell_type": "markdown", "id": "b8c07b0c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this section, we are going to talk about:\n", "\n", @@ -32,7 +44,11 @@ "cell_type": "code", "execution_count": 1, "id": "1a9986eb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import brainpy as bp\n", @@ -44,7 +60,11 @@ { "cell_type": "markdown", "id": "45babeb2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## `brainpy.Base`" ] @@ -52,7 +72,11 @@ { "cell_type": "markdown", "id": "fa23d77e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The foundation of BrainPy is [brainpy.Base](../apis/auto/generated/brainpy.base.Base.rst). A Base instance is an object which has variables and methods. All methods in the Base object can be [JIT compiled](./compilation.ipynb) or [automatically differentiated](./differentiation.ipynb). In other words, any **class objects** that will be JIT compiled or automatically differentiated must inherent from ``brainpy.Base``. " ] @@ -60,7 +84,11 @@ { "cell_type": "markdown", "id": "d9e372bc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "A Base object can have many variables, children Base objects, integrators, and methods. Below is the implemention of a [FitzHugh-Nagumo neuron model](https://brainmodels.readthedocs.io/en/brainpy-2.x/apis/generated/brainmodels.neurons.FHN.html) as an example. " ] @@ -69,7 +97,11 @@ "cell_type": "code", "execution_count": 2, "id": "0c0b30c2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class FHN(bp.Base):\n", @@ -106,7 +138,11 @@ { "cell_type": "markdown", "id": "50e1d9f4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Note this model has three variables: ``self.V``, ``self.w``, and ``self.spike``. It also has an integrator ``self.integral``. " ] @@ -114,7 +150,11 @@ { "cell_type": "markdown", "id": "530d0156", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### The naming system" ] @@ -122,7 +162,11 @@ { "cell_type": "markdown", "id": "de4f203d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Every Base object has a unique name. Users can specify a unique name when you instantiate a Base class. A used name will cause an error. " ] @@ -131,13 +175,15 @@ "cell_type": "code", "execution_count": 3, "id": "e3c3be92", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "'X'" - ] + "text/plain": "'X'" }, "execution_count": 3, "metadata": {}, @@ -152,13 +198,15 @@ "cell_type": "code", "execution_count": 4, "id": "0d60e778", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "'Y'" - ] + "text/plain": "'Y'" }, "execution_count": 4, "metadata": {}, @@ -173,16 +221,12 @@ "cell_type": "code", "execution_count": 5, "id": "3444aa16", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "UniqueNameError : In BrainPy, each object should have a unique name. However, we detect that <__main__.FHN object at 0x00000224FA317BB0> has a used name \"Y\".\n" - ] + "metadata": { + "pycharm": { + "name": "#%%\n" } - ], + }, + "outputs": [], "source": [ "try:\n", " FHN(10, name='Y').name\n", @@ -193,7 +237,11 @@ { "cell_type": "markdown", "id": "af29b018", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If a name is not specified to the Base oject, BrainPy will assign a name for this object automatically. The rule for generating object name is ``class_name + number_of_instances``. For example, ``FHN0``, ``FHN1``, etc." ] @@ -202,13 +250,15 @@ "cell_type": "code", "execution_count": 6, "id": "9a4db12e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "'FHN0'" - ] + "text/plain": "'FHN0'" }, "execution_count": 6, "metadata": {}, @@ -223,13 +273,15 @@ "cell_type": "code", "execution_count": 7, "id": "293c2a6e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "'FHN1'" - ] + "text/plain": "'FHN1'" }, "execution_count": 7, "metadata": {}, @@ -243,7 +295,11 @@ { "cell_type": "markdown", "id": "05ec44a4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Therefore, in BrainPy, you can access any object by its unique name, no matter how insignificant this object is." ] @@ -251,7 +307,11 @@ { "cell_type": "markdown", "id": "001de0c7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Collection functions" ] @@ -259,44 +319,57 @@ { "cell_type": "markdown", "id": "f64009e3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Three important collection functions are implemented for each Base object. Specifically, they are:\n", "\n", "- ``nodes()``: to collect all instances of Base objects, including children nodes in a node.\n", - "- ``ints()``: to collect all integrators defined in the Base node and in its children nodes. \n", - "- ``vars()``: to collect all variables defined in the Base node and in its children nodes. " - ] - }, - { - "cell_type": "markdown", - "id": "1928b24a", - "metadata": {}, - "source": [ - "All integrators can be collected through one method ``Base.ints()``. The result container is a [Collector](../apis/auto/generated/brainpy.base.Collector.rst). " + "- ``vars()``: to collect all variables defined in the Base node and in its children nodes." ] }, { "cell_type": "code", "execution_count": 8, - "id": "f1dbd3e2", - "metadata": {}, "outputs": [], "source": [ "fhn = FHN(10)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "id": "923cb0fc", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "All variables in a Base object can be collected through ``Base.vars()``. The returned container is a [TensorCollector](../apis/auto/generated/brainpy.base.TensorCollector.rst) (a subclass of ``Collector``)." ] }, { "cell_type": "code", "execution_count": 9, - "id": "d980f7cb", - "metadata": {}, + "id": "bc97484a", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN2.integral': }" - ] + "text/plain": "{'FHN2.V': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN2.spike': Variable([False, False, False, False, False, False, False, False,\n False, False], dtype=bool),\n 'FHN2.w': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)}" }, "execution_count": 9, "metadata": {}, @@ -304,22 +377,24 @@ } ], "source": [ - "ints = fhn.ints()\n", + "vars = fhn.vars()\n", "\n", - "ints" + "vars" ] }, { "cell_type": "code", "execution_count": 10, - "id": "d627a129", - "metadata": {}, + "id": "4996b36f", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "brainpy.base.collector.Collector" - ] + "text/plain": "brainpy.base.collector.TensorCollector" }, "execution_count": 10, "metadata": {}, @@ -327,31 +402,34 @@ } ], "source": [ - "type(ints)" + "type(vars)" ] }, { "cell_type": "markdown", - "id": "923cb0fc", - "metadata": {}, + "id": "e8dd1dbb", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "Similarly, all variables in a Base object can be collected through ``Base.vars()``. The returned container is a [TensorCollector](../apis/auto/generated/brainpy.base.TensorCollector.rst) (a subclass of ``Collector``). " + "All nodes in the model can also be collected through one method ``Base.nodes()``. The result container is an instance of [Collector](../apis/auto/generated/brainpy.base.Collector.rst)." ] }, { "cell_type": "code", "execution_count": 11, - "id": "bc97484a", - "metadata": {}, + "id": "5a687cbf", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN2.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN2.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False,\n", - " False, False], dtype=bool)),\n", - " 'FHN2.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'RK45': ,\n 'FHN2': <__main__.FHN at 0x2155a7a65e0>}" }, "execution_count": 11, "metadata": {}, @@ -359,22 +437,24 @@ } ], "source": [ - "vars = fhn.vars()\n", + "nodes = fhn.nodes()\n", "\n", - "vars" + "nodes # note: integrator is also a node" ] }, { "cell_type": "code", "execution_count": 12, - "id": "4996b36f", - "metadata": {}, + "id": "e43569c6", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "brainpy.base.collector.TensorCollector" - ] + "text/plain": "brainpy.base.collector.Collector" }, "execution_count": 12, "metadata": {}, @@ -382,29 +462,28 @@ } ], "source": [ - "type(vars)" + "type(nodes)" ] }, { "cell_type": "markdown", - "id": "e8dd1dbb", - "metadata": {}, "source": [ - "All nodes in the model can also be collected through one method ``Base.nodes()``. The result container is an instance of [Collector](../apis/auto/generated/brainpy.base.Collector.rst). " - ] + "All integrators can be collected by:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } }, { "cell_type": "code", "execution_count": 13, - "id": "5a687cbf", - "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "{'RK44': ,\n", - " 'FHN2': <__main__.FHN at 0x224fa317a60>}" - ] + "text/plain": "{'RK45': }" }, "execution_count": 13, "metadata": {}, @@ -412,22 +491,24 @@ } ], "source": [ - "nodes = fhn.nodes()\n", + "ints = fhn.nodes().subset(bp.integrators.Integrator)\n", "\n", - "nodes # note: integrator is also a node" - ] + "ints" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } }, { "cell_type": "code", "execution_count": 14, - "id": "e43569c6", - "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "brainpy.base.collector.Collector" - ] + "text/plain": "brainpy.base.collector.Collector" }, "execution_count": 14, "metadata": {}, @@ -435,13 +516,23 @@ } ], "source": [ - "type(nodes)" - ] + "type(ints)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } }, { "cell_type": "markdown", "id": "49eca479", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now, let's make a more complicated model by using the previously defined model ``FHN``. " ] @@ -450,7 +541,11 @@ "cell_type": "code", "execution_count": 15, "id": "e636baa0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class FeedForwardCircuit(bp.Base):\n", @@ -460,8 +555,8 @@ " self.pre = FHN(num1, a=a, b=b, tau=tau, Vth=Vth)\n", " self.post = FHN(num2, a=a, b=b, tau=tau, Vth=Vth)\n", " \n", - " conn = bm.ones((num1, num2), dtype=bool)\n", - " self.conn = bm.fill_diagonal(conn, False) * w\n", + " self.conn = bm.ones((num1, num2), dtype=bool) * w\n", + " bm.fill_diagonal(self.conn, 0.)\n", "\n", " def update(self, _t, _dt, x):\n", " self.pre.update(_t, _dt, x)\n", @@ -472,7 +567,11 @@ { "cell_type": "markdown", "id": "2a0e9bcc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "This model ``FeedForwardCircuit`` defines two layers. Each layer is modeled as a FitzHugh-Nagumo model (``FHN``). The first layer is densely connected to the second layer. The input to the second layer is the product of the first layer's spike and the connection strength ``w``. " ] @@ -481,68 +580,43 @@ "cell_type": "code", "execution_count": 16, "id": "6aafd6c0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "net = FeedForwardCircuit(8, 5)" ] }, - { - "cell_type": "markdown", - "id": "e0d95f88", - "metadata": {}, - "source": [ - "We can retrieve all integrators in the network by ``.ints()`` :" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "381034d5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'FHN3.integral': ,\n", - " 'FHN4.integral': }" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "net.ints()" - ] - }, { "cell_type": "markdown", "id": "54808da9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "Retrieve all variables by ``.vars()``:" + "We can retrieve all variables by ``.vars()``:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "c2f7692a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN3.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN3.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False], dtype=bool)),\n", - " 'FHN3.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN4.V': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN4.spike': Variable(DeviceArray([False, False, False, False, False], dtype=bool)),\n", - " 'FHN4.w': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'FHN3.V': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN3.spike': Variable([False, False, False, False, False, False, False, False], dtype=bool),\n 'FHN3.w': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN4.V': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'FHN4.spike': Variable([False, False, False, False, False], dtype=bool),\n 'FHN4.w': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -554,28 +628,30 @@ { "cell_type": "markdown", "id": "4c9eec24", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "And retrieve all nodes (instances of the Base class) by ``.nodes()``:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "bd98a238", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN3': <__main__.FHN at 0x224fb8780a0>,\n", - " 'FHN4': <__main__.FHN at 0x224fa3173a0>,\n", - " 'RK45': ,\n", - " 'RK46': ,\n", - " 'FeedForwardCircuit0': <__main__.FeedForwardCircuit at 0x224fb878070>}" - ] + "text/plain": "{'FHN3': <__main__.FHN at 0x2155ace3130>,\n 'FHN4': <__main__.FHN at 0x2155a798d30>,\n 'RK46': ,\n 'RK47': ,\n 'FeedForwardCircuit0': <__main__.FeedForwardCircuit at 0x2155a743c40>}" }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -587,25 +663,30 @@ { "cell_type": "markdown", "id": "8d859dca", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If we only care about a subtype of class, we can retrieve them through:" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "89dc3aeb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'RK45': ,\n", - " 'RK46': }" - ] + "text/plain": "{'RK46': ,\n 'RK47': }" }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -617,7 +698,11 @@ { "cell_type": "markdown", "id": "32906d25", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Absolute paths\n", "\n", @@ -627,7 +712,11 @@ { "cell_type": "markdown", "id": "1abda9ea", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For absolute paths, all keys in the resulting Collector (``Base.nodes()``) has the format of ``key = node_name [+ field_name]``. " ] @@ -635,24 +724,30 @@ { "cell_type": "markdown", "id": "8ce8ea30", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "**.nodes() example 1**: In the above ``fhn`` instance, there are two nodes: \"fnh\" and its integrator \"fhn.integral\"." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "1b947d76", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "('RK44', 'FHN2')" - ] + "text/plain": "('RK45', 'FHN2')" }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -664,24 +759,30 @@ { "cell_type": "markdown", "id": "434edabf", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Calling ``.nodes()`` returns their names and models. " ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "05faecf5", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "dict_keys(['RK44', 'FHN2'])" - ] + "text/plain": "dict_keys(['RK45', 'FHN2'])" }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -693,24 +794,30 @@ { "cell_type": "markdown", "id": "cc3fb400", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "**.nodes() example 2**: In the above ``net`` instance, there are five nodes:" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "bc3b0041", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "('FHN3', 'FHN4', 'RK45', 'RK46', 'FeedForwardCircuit0')" - ] + "text/plain": "('FHN3', 'FHN4', 'RK46', 'RK47', 'FeedForwardCircuit0')" }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -722,24 +829,30 @@ { "cell_type": "markdown", "id": "37e3835d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Calling ``.nodes()`` also returns the names and instances of all models. " ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "a6757d5e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "dict_keys(['FHN3', 'FHN4', 'RK45', 'RK46', 'FeedForwardCircuit0'])" - ] + "text/plain": "dict_keys(['FHN3', 'FHN4', 'RK46', 'RK47', 'FeedForwardCircuit0'])" }, - "execution_count": 24, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -751,27 +864,30 @@ { "cell_type": "markdown", "id": "fe07b062", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "**.vars() example 1**: In the above ``fhn`` instance, there are three variables: \"V\", \"w\" and \"input\". Calling ``.vars()`` returns a dict of ``. " ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "e7b0014e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN2.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN2.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False,\n", - " False, False], dtype=bool)),\n", - " 'FHN2.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'FHN2.V': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN2.spike': Variable([False, False, False, False, False, False, False, False,\n False, False], dtype=bool),\n 'FHN2.w': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -783,29 +899,30 @@ { "cell_type": "markdown", "id": "146bf744", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "**.vars() example 2**: This also applies in the ``net`` instance:" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "1696e602", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'FHN3.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN3.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False], dtype=bool)),\n", - " 'FHN3.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN4.V': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'FHN4.spike': Variable(DeviceArray([False, False, False, False, False], dtype=bool)),\n", - " 'FHN4.w': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'FHN3.V': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN3.spike': Variable([False, False, False, False, False, False, False, False], dtype=bool),\n 'FHN3.w': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'FHN4.V': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'FHN4.spike': Variable([False, False, False, False, False], dtype=bool),\n 'FHN4.w': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -817,7 +934,11 @@ { "cell_type": "markdown", "id": "8381a0b0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Relative paths" ] @@ -825,24 +946,30 @@ { "cell_type": "markdown", "id": "79dbb038", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Variables, integrators, and nodes can also be accessed by relative paths. For example, the ``pre`` instance in the ``net`` can be accessed by" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "id": "8d921a96", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "<__main__.FHN at 0x224fb8780a0>" - ] + "text/plain": "<__main__.FHN at 0x2155ace3130>" }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -854,28 +981,30 @@ { "cell_type": "markdown", "id": "c041cd24", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Relative paths preserve the dependence relationship. For example, all nodes retrieved from the perspective of ``net`` are:" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "id": "c8c1cb0e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'': <__main__.FeedForwardCircuit at 0x224fb878070>,\n", - " 'pre': <__main__.FHN at 0x224fb8780a0>,\n", - " 'post': <__main__.FHN at 0x224fa3173a0>,\n", - " 'pre.integral': ,\n", - " 'post.integral': }" - ] + "text/plain": "{'': <__main__.FeedForwardCircuit at 0x2155a743c40>,\n 'pre': <__main__.FHN at 0x2155ace3130>,\n 'post': <__main__.FHN at 0x2155a798d30>,\n 'pre.integral': ,\n 'post.integral': }" }, - "execution_count": 28, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -887,25 +1016,30 @@ { "cell_type": "markdown", "id": "60fd0239", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "However, nodes retrieved from the start point of ``net.pre`` will be:" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "id": "ac50b5b5", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'': <__main__.FHN at 0x224fb8780a0>,\n", - " 'integral': }" - ] + "text/plain": "{'': <__main__.FHN at 0x2155ace3130>,\n 'integral': }" }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -917,29 +1051,30 @@ { "cell_type": "markdown", "id": "ca6b200f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Variables can also br relatively inferred from the model. For example, variables that can be relatively accessed from ``net`` include:" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "id": "7ec908d2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'pre.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'pre.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False], dtype=bool)),\n", - " 'pre.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'post.V': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'post.spike': Variable(DeviceArray([False, False, False, False, False], dtype=bool)),\n", - " 'post.w': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'pre.V': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'pre.spike': Variable([False, False, False, False, False, False, False, False], dtype=bool),\n 'pre.w': Variable([0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'post.V': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'post.spike': Variable([False, False, False, False, False], dtype=bool),\n 'post.w': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 30, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -951,26 +1086,30 @@ { "cell_type": "markdown", "id": "16fa7a2f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "While variables relatively accessed from ``net.post`` are:" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "id": "1f77f979", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'V': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'spike': Variable(DeviceArray([False, False, False, False, False], dtype=bool)),\n", - " 'w': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'V': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'spike': Variable([False, False, False, False, False], dtype=bool),\n 'w': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 31, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -982,7 +1121,11 @@ { "cell_type": "markdown", "id": "e63c7c80", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Elements in containers" ] @@ -990,16 +1133,24 @@ { "cell_type": "markdown", "id": "f8aec9ca", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "One drawback of collection functions is that they don not look for elements in *list*, *dict* or any other container structure. " ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "id": "4544d9fe", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class ATest(bp.Base):\n", @@ -1012,9 +1163,13 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "id": "b1199b05", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "t1 = ATest()" @@ -1023,24 +1178,30 @@ { "cell_type": "markdown", "id": "3d3bcbac", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The above class defines a list of variables, and a dict of children nodes, but the variables and children nodes cannot be retrieved from the collection functions ``vars()`` and ``nodes()``. " ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "id": "c4efd7c6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{}" - ] + "text/plain": "{}" }, - "execution_count": 34, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1051,17 +1212,19 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "id": "df9fd51b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'ATest0': <__main__.ATest at 0x224fa309430>}" - ] + "text/plain": "{'ATest0': <__main__.ATest at 0x2155ae60a00>}" }, - "execution_count": 35, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1073,16 +1236,24 @@ { "cell_type": "markdown", "id": "23f81f1e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "To solve this problem, BrianPy provides ``implicit_vars`` and ``implicit_nodes`` (an instance of \"dict\") to hold variables and nodes in container structures. Variables registered in ``implicit_vars`` and integrators and nodes registered in ``implicit_nodes`` can be retrieved by collection functions." ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "id": "767f2f74", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class AnotherTest(bp.Base):\n", @@ -1100,9 +1271,13 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "id": "e5fc3ec0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "t2 = AnotherTest()" @@ -1110,21 +1285,19 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "id": "55ee8df8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'T1': <__main__.FHN at 0x224fb8a51c0>,\n", - " 'T2': <__main__.FHN at 0x224fb8a5c70>,\n", - " 'RK49': ,\n", - " 'RK410': ,\n", - " 'AnotherTest0': <__main__.AnotherTest at 0x224fb8a5250>}" - ] + "text/plain": "{'T1': <__main__.FHN at 0x2155ae6bca0>,\n 'T2': <__main__.FHN at 0x2155ae6b3a0>,\n 'RK410': ,\n 'RK411': ,\n 'AnotherTest0': <__main__.AnotherTest at 0x2155ae6f0d0>}" }, - "execution_count": 38, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1138,25 +1311,19 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "id": "3740e867", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'T1.V': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'T1.spike': Variable(DeviceArray([False, False, False, False, False, False, False, False,\n", - " False, False], dtype=bool)),\n", - " 'T1.w': Variable(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'T2.V': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'T2.spike': Variable(DeviceArray([False, False, False, False, False], dtype=bool)),\n", - " 'T2.w': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'AnotherTest0.v0': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'AnotherTest0.v1': Variable(DeviceArray([1., 1., 1., 1., 1., 1.], dtype=float32))}" - ] + "text/plain": "{'T1.V': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'T1.spike': Variable([False, False, False, False, False, False, False, False,\n False, False], dtype=bool),\n 'T1.w': Variable([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'T2.V': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'T2.spike': Variable([False, False, False, False, False], dtype=bool),\n 'T2.w': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'AnotherTest0.v0': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'AnotherTest0.v1': Variable([1., 1., 1., 1., 1., 1.], dtype=float32)}" }, - "execution_count": 39, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1171,7 +1338,11 @@ { "cell_type": "markdown", "id": "2d0cdd12", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Saving and loading" ] @@ -1179,7 +1350,11 @@ { "cell_type": "markdown", "id": "4b9da3ea", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Because ``Base.vars()`` returns a Python dictionary object [Collector](#Collector), they can be easily saved, updated, altered, and restored, adding a great deal of modularity to BrainPy models. Therefore, each Base object has standard exporting and loading methods (for more details, please see [Saving and Loading](../tutorial_simulation/save_and_load.ipynb)). Specifically, they are implemented by ``Base.save_states()`` and ``Base.load_states()``. " ] @@ -1187,7 +1362,11 @@ { "cell_type": "markdown", "id": "662d9e97", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Save" ] @@ -1195,7 +1374,11 @@ { "cell_type": "markdown", "id": "a7ca0e22", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "```python\n", "Base.save_states(PATH, [vars])\n", @@ -1205,7 +1388,11 @@ { "cell_type": "markdown", "id": "3638e370", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Models exported from BrainPy support various Python standard file formats, including \n", "\n", @@ -1217,9 +1404,13 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "id": "9760ec40", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "net.save_states('./data/net.h5')" @@ -1227,9 +1418,13 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 40, "id": "ea8a9377", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "net.save_states('./data/net.pkl')" @@ -1238,7 +1433,11 @@ { "cell_type": "markdown", "id": "0d522213", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Load" ] @@ -1246,7 +1445,11 @@ { "cell_type": "markdown", "id": "5a0646bb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "```python\n", "\n", @@ -1256,9 +1459,13 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 41, "id": "9674e20d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "net.load_states('./data/net.h5')" @@ -1266,9 +1473,13 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 42, "id": "52d68885", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "net.load_states('./data/net.pkl')" @@ -1277,7 +1488,11 @@ { "cell_type": "markdown", "id": "d38d5954", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Collector" ] @@ -1285,7 +1500,11 @@ { "cell_type": "markdown", "id": "886dab02", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Collection functions return an ``brainpy.Collector`` that is a dictionary mapping names to elements. It has some useful methods. " ] @@ -1293,7 +1512,11 @@ { "cell_type": "markdown", "id": "b61c9ced", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``subset()``" ] @@ -1301,25 +1524,30 @@ { "cell_type": "markdown", "id": "30d0ff65", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``Collector.subset(cls)`` returns a part of elements whose type is the given ``cls``. For example, ``Base.nodes()`` returns all instances of Base class. If you are only interested in one type, like ``ODEIntegrator``, you can use:" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 43, "id": "8d3f0dea", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'RK45': ,\n", - " 'RK46': }" - ] + "text/plain": "{'RK46': ,\n 'RK47': }" }, - "execution_count": 45, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1331,7 +1559,11 @@ { "cell_type": "markdown", "id": "371f4933", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Actually, ``Collector.subset(cls)`` travels all the elements in this collection, and find the element whose type matches the given ``cls``. " ] @@ -1339,7 +1571,11 @@ { "cell_type": "markdown", "id": "a0e4226a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``unique()``" ] @@ -1347,7 +1583,11 @@ { "cell_type": "markdown", "id": "a0d3e4e7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "It is common in machine learning that weights are shared with several objects, or the same weight can be accessed by various dependence relationships. Collection functions of Base usually return a collection in which the same value have multiple keys. The duplicate elements will not be automatically excluded. However, it is important not to apply operations such as gradient descent twice or more to the same elements. \n", "\n", @@ -1356,9 +1596,13 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 44, "id": "73870138", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class ModelA(bp.Base):\n", @@ -1385,19 +1629,19 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 45, "id": "0b975732", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'A.a': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'A_shared.a': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'A_shared.source.a': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'A.a': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'A_shared.a': Variable([0., 0., 0., 0., 0.], dtype=float32),\n 'A_shared.source.a': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 47, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1408,17 +1652,19 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 46, "id": "fc55069f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'A.a': Variable(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'A.a': Variable([0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 48, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -1429,20 +1675,19 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 47, "id": "898f898b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'': <__main__.Group at 0x224fb9e8130>,\n", - " 'A': <__main__.ModelA at 0x224fb9e8040>,\n", - " 'A_shared': <__main__.SharedA at 0x224fb9e8280>,\n", - " 'A_shared.source': <__main__.ModelA at 0x224fb9e8040>}" - ] + "text/plain": "{'': <__main__.Group at 0x2155b13b550>,\n 'A': <__main__.ModelA at 0x2155b13b460>,\n 'A_shared': <__main__.SharedA at 0x2155a7a6580>,\n 'A_shared.source': <__main__.ModelA at 0x2155b13b460>}" }, - "execution_count": 49, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } @@ -1453,19 +1698,19 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 48, "id": "532bd337", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'': <__main__.Group at 0x224fb9e8130>,\n", - " 'A': <__main__.ModelA at 0x224fb9e8040>,\n", - " 'A_shared': <__main__.SharedA at 0x224fb9e8280>}" - ] + "text/plain": "{'': <__main__.Group at 0x2155b13b550>,\n 'A': <__main__.ModelA at 0x2155b13b460>,\n 'A_shared': <__main__.SharedA at 0x2155a7a6580>}" }, - "execution_count": 50, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1477,7 +1722,11 @@ { "cell_type": "markdown", "id": "942093ce", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``update()``" ] @@ -1485,24 +1734,30 @@ { "cell_type": "markdown", "id": "23f70fce", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The Collector can also catch potential conflicts during the assignment. The bracket assignment of a Collector (``[key]``) and ``Collector.update()`` will check whether the same key is mapped to a different value. If it is, an error will occur. " ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 49, "id": "9cf6c7f6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'a': JaxArray(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'a': JaxArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 51, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1515,9 +1770,13 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 50, "id": "db8804d7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1536,9 +1795,13 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 51, "id": "531922ec", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1558,7 +1821,11 @@ { "cell_type": "markdown", "id": "15fc1991", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``replace()``" ] @@ -1566,24 +1833,30 @@ { "cell_type": "markdown", "id": "6bb2976c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``Collector.replace(old_key, new_value)`` is used to update the value of a key. " ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 52, "id": "c91f4373", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'a': JaxArray(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32))}" - ] + "text/plain": "{'a': JaxArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)}" }, - "execution_count": 54, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -1594,17 +1867,19 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 53, "id": "ecf2a15c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'a': JaxArray(DeviceArray([1., 1., 1.], dtype=float32))}" - ] + "text/plain": "{'a': JaxArray([1., 1., 1.], dtype=float32)}" }, - "execution_count": 55, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } @@ -1618,7 +1893,11 @@ { "cell_type": "markdown", "id": "6401d334", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``__add()__``" ] @@ -1626,25 +1905,30 @@ { "cell_type": "markdown", "id": "3c2b83ee", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Two Collectors can be merged. " ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 54, "id": "93bde37c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'a': JaxArray(DeviceArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n", - " 'b': JaxArray(DeviceArray([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32))}" - ] + "text/plain": "{'a': JaxArray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32),\n 'b': JaxArray([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32)}" }, - "execution_count": 56, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -1659,7 +1943,11 @@ { "cell_type": "markdown", "id": "7cb93e3d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## TensorCollector" ] @@ -1667,25 +1955,21 @@ { "cell_type": "markdown", "id": "0cbd07f6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ - "``TensorCollector`` is subclass of ``Collector``, but it is specifically to collect tensors. " + "``TensorCollector`` is subclass of ``Collector``, but it is specifically to collect tensors." ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c6c14e8", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:root] *", + "name": "python3", "language": "python", - "name": "conda-root-py" + "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { @@ -1738,4 +2022,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/docs/tutorial_math/compilation.ipynb b/docs/tutorial_math/compilation.ipynb index 689201b68..918457e04 100644 --- a/docs/tutorial_math/compilation.ipynb +++ b/docs/tutorial_math/compilation.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "b9f48e9b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Compilation" ] @@ -11,7 +15,11 @@ { "cell_type": "markdown", "id": "355bb9b6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "@[Chaoming Wang](https://github.com/chaoming0625)\n", "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" @@ -20,7 +28,11 @@ { "cell_type": "markdown", "id": "a625b0ab", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this section, we are going to talk about code compilation that can accelerate your model running performance. " ] @@ -29,7 +41,11 @@ "cell_type": "code", "execution_count": 1, "id": "13e791f8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import brainpy as bp\n", @@ -41,7 +57,11 @@ { "cell_type": "markdown", "id": "cdfd2be7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## ``brainpy.math.jit()``" ] @@ -49,7 +69,11 @@ { "cell_type": "markdown", "id": "123027f3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "[JAX](https://github.com/google/jax) provides JIT compilation ``jax.jit()`` for [pure functions](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#pure-functions).In most cases, however, we code with Python classes. ``brainpy.math.jit()`` is intended to extend just-in-time compilation to class objects. " ] @@ -57,7 +81,11 @@ { "cell_type": "markdown", "id": "9406eacd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### JIT compilation for class objects" ] @@ -65,7 +93,11 @@ { "cell_type": "markdown", "id": "1fae4adb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The constraints for class-object JIT ciompilation include:\n", "\n", @@ -78,7 +110,11 @@ "cell_type": "code", "execution_count": 2, "id": "a5374857", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class LogisticRegression(bp.Base):\n", @@ -106,7 +142,11 @@ { "cell_type": "markdown", "id": "2440bf0e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this example, weight *self.w* is a dynamically changed variable, thus marked as ``Variable``. During the update phase ``__call__()``, *self.w* is in-place updated through ``self.w[:] = ...``. Alternatively, one can replace the data in the variable by ``self.w.value = ...`` or ``self.w.update(...)``." ] @@ -114,7 +154,11 @@ { "cell_type": "markdown", "id": "893ec359", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now this logistic regression can be accelerated by JIT compilation." ] @@ -123,7 +167,11 @@ "cell_type": "code", "execution_count": 3, "id": "462f745b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "num_dim, num_points = 10, 200000\n", @@ -135,13 +183,17 @@ "cell_type": "code", "execution_count": 4, "id": "f5e5b98c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "3.11 ms ± 98.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "3.73 ms ± 589 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], @@ -156,14 +208,17 @@ "execution_count": 5, "id": "c70b1eba", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.54 ms ± 25.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" + "1.75 ms ± 57.9 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" ] } ], @@ -176,7 +231,11 @@ { "cell_type": "markdown", "id": "25a3b576", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### JIT mechanism" ] @@ -184,7 +243,11 @@ { "cell_type": "markdown", "id": "f1046bd0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The mechanism of JIT compilation is that BrainPy automatically transforms your class methods into functions. \n", "\n", @@ -195,13 +258,15 @@ "cell_type": "code", "execution_count": 6, "id": "42fbe267", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "True" - ] + "text/plain": "True" }, "execution_count": 6, "metadata": {}, @@ -217,7 +282,11 @@ { "cell_type": "markdown", "id": "e65f0e22", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Therefore, the secrete of ``brainpy.math.jit()`` is providing \"dyn_vars\". No matter your target is a class object, a method in the class object, or a pure function, if there are dynamically changed variables, you just pack them into ``brainpy.math.jit()`` as \"dyn_vars\". Then, all the compilation and acceleration will be handled by BrainPy automatically. Let's illustrate this by several examples. " ] @@ -225,7 +294,11 @@ { "cell_type": "markdown", "id": "c29d5d84", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Example 1: JIT compiled methods in a class" ] @@ -233,7 +306,11 @@ { "cell_type": "markdown", "id": "02e79a7f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this example, we try to run a method just-in-time in a class, in which the object variable are used to compute the final results. " ] @@ -242,7 +319,11 @@ "cell_type": "code", "execution_count": 7, "id": "076fc88b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class Linear(bp.Base):\n", @@ -259,7 +340,11 @@ "cell_type": "code", "execution_count": 8, "id": "0e5eca39", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "x = bm.zeros(10) # the input data\n", @@ -269,7 +354,11 @@ { "cell_type": "markdown", "id": "f3af6f71", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "First, we mark \"w\" and \"b\" as dynamically changed variables. Changing \"w\" or \"b\" will change the final results. " ] @@ -278,13 +367,15 @@ "cell_type": "code", "execution_count": 9, "id": "4cca2e8b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0., 0., 0.], dtype=float32))" - ] + "text/plain": "JaxArray([0., 0., 0.], dtype=float32)" }, "execution_count": 9, "metadata": {}, @@ -303,13 +394,15 @@ "cell_type": "code", "execution_count": 10, "id": "c4c9c2f2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([1., 1., 1.], dtype=float32))" - ] + "text/plain": "JaxArray([1., 1., 1.], dtype=float32)" }, "execution_count": 10, "metadata": {}, @@ -325,7 +418,11 @@ { "cell_type": "markdown", "id": "2572c4d8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "This time, we only mark \"w\" as a dynamically changed variable. We will find that no matter how \"b\" is modified, the results will not change. " ] @@ -334,13 +431,15 @@ "cell_type": "code", "execution_count": 11, "id": "c7bdf120", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([1., 1., 1.], dtype=float32))" - ] + "text/plain": "JaxArray([1., 1., 1.], dtype=float32)" }, "execution_count": 11, "metadata": {}, @@ -359,13 +458,15 @@ "cell_type": "code", "execution_count": 12, "id": "446ea19c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([1., 1., 1.], dtype=float32))" - ] + "text/plain": "JaxArray([1., 1., 1.], dtype=float32)" }, "execution_count": 12, "metadata": {}, @@ -381,7 +482,11 @@ { "cell_type": "markdown", "id": "dfb25ba8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Example 2: JIT compiled functions" ] @@ -389,7 +494,11 @@ { "cell_type": "markdown", "id": "9b424f80", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now, we change the above \"Linear\" object to a function. " ] @@ -398,7 +507,11 @@ "cell_type": "code", "execution_count": 13, "id": "675ce89d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "n_in = 10; n_out = 3\n", @@ -413,7 +526,11 @@ { "cell_type": "markdown", "id": "1a9ffb7e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If we do not provide ``dyn_vars``, \"w\" and \"b\" will be compiled as constant values. " ] @@ -422,13 +539,15 @@ "cell_type": "code", "execution_count": 14, "id": "a5e3c1c4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0., 0., 0.], dtype=float32))" - ] + "text/plain": "JaxArray([0., 0., 0.], dtype=float32)" }, "execution_count": 14, "metadata": {}, @@ -445,14 +564,15 @@ "execution_count": 15, "id": "922fd101", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0., 0., 0.], dtype=float32))" - ] + "text/plain": "JaxArray([0., 0., 0.], dtype=float32)" }, "execution_count": 15, "metadata": {}, @@ -470,7 +590,11 @@ { "cell_type": "markdown", "id": "2dbbd220", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Providing \"w\" and \"b\" as ``dyn_vars`` will make them dynamically changed again. " ] @@ -479,13 +603,15 @@ "cell_type": "code", "execution_count": 16, "id": "c301f14b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([1., 1., 1.], dtype=float32))" - ] + "text/plain": "JaxArray([1., 1., 1.], dtype=float32)" }, "execution_count": 16, "metadata": {}, @@ -501,13 +627,15 @@ "cell_type": "code", "execution_count": 17, "id": "165bb3b2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([2., 2., 2.], dtype=float32))" - ] + "text/plain": "JaxArray([2., 2., 2.], dtype=float32)" }, "execution_count": 17, "metadata": {}, @@ -522,7 +650,11 @@ { "cell_type": "markdown", "id": "4f2c54d3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Example 3: JIT compiled neural networks" ] @@ -530,7 +662,11 @@ { "cell_type": "markdown", "id": "654a0425", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now, let's use SGD to train a neural network with JIT acceleration. Here we use the autograd function ``brainpy.math.grad()``, which will be discussed in detail in [the next section](./differentiation.ipynb)." ] @@ -540,7 +676,10 @@ "execution_count": 18, "id": "4b89b7af", "metadata": { - "lines_to_next_cell": 2 + "lines_to_next_cell": 2, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [], "source": [ @@ -584,42 +723,46 @@ "cell_type": "code", "execution_count": 19, "id": "8ae01dee", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Train 0, loss = 6542776.00\n", - "Train 1, loss = 3632715.50\n", - "Train 2, loss = 2029160.00\n", - "Train 3, loss = 1137243.50\n", - "Train 4, loss = 638561.00\n", - "Train 5, loss = 358928.81\n", - "Train 6, loss = 201870.97\n", - "Train 7, loss = 113577.14\n", - "Train 8, loss = 63915.05\n", - "Train 9, loss = 35973.81\n", - "Train 10, loss = 20250.74\n", - "Train 11, loss = 11402.26\n", - "Train 12, loss = 6422.33\n", - "Train 13, loss = 3619.55\n", - "Train 14, loss = 2042.07\n", - "Train 15, loss = 1154.22\n", - "Train 16, loss = 654.50\n", - "Train 17, loss = 373.25\n", - "Train 18, loss = 214.94\n", - "Train 19, loss = 125.85\n", - "Train 20, loss = 75.70\n", - "Train 21, loss = 47.47\n", - "Train 22, loss = 31.59\n", - "Train 23, loss = 22.65\n", - "Train 24, loss = 17.61\n", - "Train 25, loss = 14.78\n", - "Train 26, loss = 13.19\n", - "Train 27, loss = 12.29\n", - "Train 28, loss = 11.78\n", - "Train 29, loss = 11.50\n" + "Train 0, loss = 6649731.50\n", + "Train 1, loss = 3748688.50\n", + "Train 2, loss = 2126231.00\n", + "Train 3, loss = 1210147.88\n", + "Train 4, loss = 690106.50\n", + "Train 5, loss = 393984.28\n", + "Train 6, loss = 225071.75\n", + "Train 7, loss = 128625.49\n", + "Train 8, loss = 73524.97\n", + "Train 9, loss = 42035.37\n", + "Train 10, loss = 24035.91\n", + "Train 11, loss = 13746.33\n", + "Train 12, loss = 7863.82\n", + "Train 13, loss = 4500.70\n", + "Train 14, loss = 2577.91\n", + "Train 15, loss = 1478.59\n", + "Train 16, loss = 850.07\n", + "Train 17, loss = 490.72\n", + "Train 18, loss = 285.26\n", + "Train 19, loss = 167.80\n", + "Train 20, loss = 100.63\n", + "Train 21, loss = 62.24\n", + "Train 22, loss = 40.28\n", + "Train 23, loss = 27.73\n", + "Train 24, loss = 20.55\n", + "Train 25, loss = 16.45\n", + "Train 26, loss = 14.10\n", + "Train 27, loss = 12.76\n", + "Train 28, loss = 11.99\n", + "Train 29, loss = 11.56\n" ] } ], @@ -635,7 +778,11 @@ { "cell_type": "markdown", "id": "967345db", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### RandomState" ] @@ -643,7 +790,11 @@ { "cell_type": "markdown", "id": "26106295", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We have talked about RandomState in the [Variables](./variables.ipynb) section. RandomeState is also a Variable. Therefore, if the default RandomState (``brainpy.math.random.DEFAULT``) is used in your function, you should mark it as one of the ``dyn_vars`` in the function. Otherwise, they will be treated as constants and the jitted function will always return the same value. " ] @@ -652,7 +803,11 @@ "cell_type": "code", "execution_count": 20, "id": "fe1a5925", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def function():\n", @@ -663,14 +818,15 @@ "cell_type": "code", "execution_count": 21, "id": "93c3d479", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([ True, True, True, True, True, True, True, True,\n", - " True, True], dtype=bool))" - ] + "text/plain": "JaxArray([ True, True, True, True, True, True, True, True,\n True, True], dtype=bool)" }, "execution_count": 21, "metadata": {}, @@ -686,7 +842,11 @@ { "cell_type": "markdown", "id": "95276b4b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The correct way to make JIT for this function is:" ] @@ -695,14 +855,15 @@ "cell_type": "code", "execution_count": 22, "id": "5dfba12e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([False, False, False, False, False, False, False, False,\n", - " False, False], dtype=bool))" - ] + "text/plain": "JaxArray([False, False, False, False, False, False, False, False,\n False, False], dtype=bool)" }, "execution_count": 22, "metadata": {}, @@ -720,7 +881,11 @@ { "cell_type": "markdown", "id": "54f23e60", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Static arguments" ] @@ -728,7 +893,11 @@ { "cell_type": "markdown", "id": "cf607131", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Static arguments are treated as static/constant in the jitted function. \n", "\n", @@ -739,7 +908,11 @@ "cell_type": "code", "execution_count": 23, "id": "c624ede7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "@bm.jit\n", @@ -754,7 +927,11 @@ "cell_type": "code", "execution_count": 24, "id": "43d03199", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -762,7 +939,7 @@ "text": [ " Abstract tracer value encountered where concrete value is expected: Tracedwith\n", "The problem arose with the `bool` function. \n", - "While tracing the function f at :1 for jit, this concrete value was not available in Python because it depends on the value of the argument 'x'.\n", + "While tracing the function f at C:\\Users\\adadu\\AppData\\Local\\Temp\\ipykernel_44816\\1408095738.py:1 for jit, this concrete value was not available in Python because it depends on the value of the argument 'x'.\n", "\n", "See https://jax.readthedocs.io/en/latest/errors.html#jax.errors.ConcretizationTypeError\n" ] @@ -778,7 +955,11 @@ { "cell_type": "markdown", "id": "aa080dcc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Simply speaking, arguments resulting in boolean values must be declared as static arguments. In ``brainpy.math.jit()`` function, we can set the names of static arguments. " ] @@ -787,7 +968,11 @@ "cell_type": "code", "execution_count": 25, "id": "3005cf57", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def f(x):\n", @@ -803,13 +988,15 @@ "cell_type": "code", "execution_count": 26, "id": "41349cb1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray(3., dtype=float32, weak_type=True)" - ] + "text/plain": "DeviceArray(3., dtype=float32, weak_type=True)" }, "execution_count": 26, "metadata": {}, @@ -823,7 +1010,11 @@ { "cell_type": "markdown", "id": "86485a58", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "However, it's worth noting that calling the jitted function with different values for these static arguments will trigger recompilation. Therefore, declaring static arguments may be suitable to the following situations:\n", "\n", @@ -837,18 +1028,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "74e02031", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:root] *", + "name": "python3", "language": "python", - "name": "conda-root-py" + "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { @@ -901,4 +1096,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/docs/tutorial_math/control_flows.ipynb b/docs/tutorial_math/control_flows.ipynb index 2fc76d426..b96d1ee67 100644 --- a/docs/tutorial_math/control_flows.ipynb +++ b/docs/tutorial_math/control_flows.ipynb @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "id": "38a2bb50", "metadata": { "pycharm": { @@ -164,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "id": "dd570c81", "metadata": { "pycharm": { @@ -173,7 +173,7 @@ }, "outputs": [], "source": [ - "class RNN(bp.DynamicalSystem):\n", + "class RNN(bp.dyn.DynamicalSystem):\n", " def __init__(self, n_in, n_h, n_out, n_batch, g=1.0, **kwargs):\n", " super(RNN, self).__init__(**kwargs)\n", "\n", @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "id": "0bd5330a", "metadata": { "lines_to_next_cell": 2, @@ -239,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "18b8d270", "metadata": { "scrolled": true, @@ -250,11 +250,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(100, 5, 100)" - ] + "text/plain": "(100, 5, 100)" }, - "execution_count": 4, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -265,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "3424de49", "metadata": { "pycharm": { @@ -275,11 +273,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(100, 5, 3)" - ] + "text/plain": "(100, 5, 3)" }, - "execution_count": 5, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -302,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "c4159b0b", "metadata": { "pycharm": { @@ -312,26 +308,15 @@ "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", - " [ 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n", - " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", - " [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n", - " [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n", - " [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n", - " [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n", - " [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n", - " [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n", - " [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]], dtype=float32))" - ] + "text/plain": "Variable([[ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n [ 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]], dtype=float32)" }, - "execution_count": 6, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "a = bm.zeros(10)\n", + "a = bm.Variable(bm.zeros(10))\n", "\n", "def body(x):\n", " x1, x2 = x # \"x\" is a tuple/list of JaxArray\n", @@ -343,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "id": "65c1c1e7", "metadata": { "pycharm": { @@ -353,26 +338,15 @@ "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", - " [ 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n", - " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", - " [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n", - " [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n", - " [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n", - " [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n", - " [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n", - " [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n", - " [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]], dtype=float32))" - ] + "text/plain": "Variable([[ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n [ 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n [10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n [15., 15., 15., 15., 15., 15., 15., 15., 15., 15.],\n [21., 21., 21., 21., 21., 21., 21., 21., 21., 21.],\n [28., 28., 28., 28., 28., 28., 28., 28., 28., 28.],\n [36., 36., 36., 36., 36., 36., 36., 36., 36., 36.],\n [45., 45., 45., 45., 45., 45., 45., 45., 45., 45.],\n [55., 55., 55., 55., 55., 55., 55., 55., 55., 55.]], dtype=float32)" }, - "execution_count": 7, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "a = bm.zeros(10)\n", + "a = bm.Variable(bm.zeros(10))\n", "\n", "def body(x): # \"x\" is a dict of JaxArray\n", " a.value += x['a'] + x['b']\n", @@ -447,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "id": "21056150", "metadata": { "pycharm": { @@ -456,8 +430,8 @@ }, "outputs": [], "source": [ - "i = bm.zeros(1)\n", - "counter = bm.zeros(1)\n", + "i = bm.Variable(bm.zeros(1))\n", + "counter = bm.Variable(bm.zeros(1))\n", "\n", "def cond_f(x): \n", " return i[0] < 10\n", @@ -483,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "5e23e1bd", "metadata": { "pycharm": { @@ -497,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "id": "3ad97ccb", "metadata": { "pycharm": { @@ -507,11 +481,9 @@ "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([55.], dtype=float32))" - ] + "text/plain": "Variable([55.], dtype=float32)" }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -522,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "id": "1025f8e2", "metadata": { "pycharm": { @@ -532,11 +504,9 @@ "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([10.], dtype=float32))" - ] + "text/plain": "Variable([10.], dtype=float32)" }, - "execution_count": 11, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -603,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "id": "6291da01", "metadata": { "pycharm": { @@ -612,8 +582,8 @@ }, "outputs": [], "source": [ - "a = bm.zeros(2)\n", - "b = bm.ones(2)\n", + "a = bm.Variable(bm.zeros(2))\n", + "b = bm.Variable(bm.ones(2))\n", "\n", "def true_f(x): a.value += 1\n", "\n", @@ -636,7 +606,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "id": "838bde45", "metadata": { "pycharm": { @@ -646,12 +616,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([1., 1.], dtype=float32)),\n", - " JaxArray(DeviceArray([1., 1.], dtype=float32)))" - ] + "text/plain": "(Variable([1., 1.], dtype=float32), Variable([1., 1.], dtype=float32))" }, - "execution_count": 13, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -664,7 +631,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "id": "8bda2e64", "metadata": { "scrolled": true, @@ -675,12 +642,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([2., 2.], dtype=float32)),\n", - " JaxArray(DeviceArray([1., 1.], dtype=float32)))" - ] + "text/plain": "(Variable([2., 2.], dtype=float32), Variable([1., 1.], dtype=float32))" }, - "execution_count": 14, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -693,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 21, "id": "302b7342", "metadata": { "pycharm": { @@ -703,12 +667,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([2., 2.], dtype=float32)),\n", - " JaxArray(DeviceArray([0., 0.], dtype=float32)))" - ] + "text/plain": "(Variable([2., 2.], dtype=float32), Variable([0., 0.], dtype=float32))" }, - "execution_count": 15, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -721,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "id": "320ef7f9", "metadata": { "pycharm": { @@ -731,12 +692,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([2., 2.], dtype=float32)),\n", - " JaxArray(DeviceArray([-1., -1.], dtype=float32)))" - ] + "text/plain": "(Variable([2., 2.], dtype=float32), Variable([-1., -1.], dtype=float32))" }, - "execution_count": 16, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -761,7 +719,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 23, "id": "a07844d5", "metadata": { "pycharm": { @@ -770,8 +728,8 @@ }, "outputs": [], "source": [ - "a = bm.zeros(2)\n", - "b = bm.ones(2)\n", + "a = bm.Variable(bm.zeros(2))\n", + "b = bm.Variable(bm.ones(2))\n", "\n", "def true_f(x): a.value += x\n", "\n", @@ -782,7 +740,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "id": "d1219455", "metadata": { "pycharm": { @@ -792,12 +750,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([10., 10.], dtype=float32)),\n", - " JaxArray(DeviceArray([1., 1.], dtype=float32)))" - ] + "text/plain": "(Variable([10., 10.], dtype=float32), Variable([1., 1.], dtype=float32))" }, - "execution_count": 18, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -810,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "id": "d6098980", "metadata": { "pycharm": { @@ -820,12 +775,9 @@ "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([10., 10.], dtype=float32)),\n", - " JaxArray(DeviceArray([-4., -4.], dtype=float32)))" - ] + "text/plain": "(Variable([10., 10.], dtype=float32), Variable([-4., -4.], dtype=float32))" }, - "execution_count": 19, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -842,9 +794,9 @@ "main_language": "python" }, "kernelspec": { - "display_name": "Python [conda env:root] *", + "name": "python3", "language": "python", - "name": "conda-root-py" + "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { diff --git a/docs/tutorial_math/differentiation.ipynb b/docs/tutorial_math/differentiation.ipynb index f1cd726a3..434e0bd77 100644 --- a/docs/tutorial_math/differentiation.ipynb +++ b/docs/tutorial_math/differentiation.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "b55233d4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Differentiation" ] @@ -11,7 +15,11 @@ { "cell_type": "markdown", "id": "355bb9b6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "@[Chaoming Wang](https://github.com/chaoming0625)\n", "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" @@ -20,7 +28,11 @@ { "cell_type": "markdown", "id": "fbc1e2d7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In this section, we are going to talk about how to realize automatic differentiation on your variables in a function or a class object. In current machine learning systems, gradients are commonly used in various situations. Therefore, we should understand:\n", "\n", @@ -32,7 +44,11 @@ "cell_type": "code", "execution_count": 1, "id": "e0ae6076", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import brainpy as bp\n", @@ -44,7 +60,11 @@ { "cell_type": "markdown", "id": "7afa7421", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Preliminary" ] @@ -52,7 +72,11 @@ { "cell_type": "markdown", "id": "01ca8416", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Every autograd function in BrainPy has several keywords. All examples below are illustrated through [brainpy.math.grad()](../apis/auto/math/generated/brainpy.math.autograd.grad.rst). Other autograd functions have the same settings. " ] @@ -60,7 +84,11 @@ { "cell_type": "markdown", "id": "8d75313f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``argnums`` and ``grad_vars``" ] @@ -68,16 +96,24 @@ { "cell_type": "markdown", "id": "772965c3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The autograd functions in BrainPy can compute derivatives of *function arguments* (specified by `argnums`) or *non-argument variables* (specified by ``grad_vars``). For instance, the following is a linear readout model:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "id": "be17f596", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class Linear(bp.Base):\n", @@ -96,25 +132,30 @@ { "cell_type": "markdown", "id": "47d93392", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If we try to focus on the derivative of the argument \"x\" when calling the update function, we can set this through ``argnums``:" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "id": "7bf6ae1f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.0940454 , 0.24210012, 0.10360408, 0.2991985 , 0.22486198,\n", - " 0.9399384 , 0.88925755, 0.84567535, 0.94881094, 0.7843926 ], dtype=float32))" - ] + "text/plain": "JaxArray([0.9865978 , 0.14363837, 0.03861248, 0.42379665, 0.7038013 ,\n 0.11866355, 0.67538667, 0.15790391, 0.6050298 , 0.778468 ], dtype=float32)" }, - "execution_count": 9, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -128,25 +169,30 @@ { "cell_type": "markdown", "id": "7beb97b5", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "By contrast, if you focus on the derivatives of parameters \"self.w\" and \"self.b\", we should label them with ``grad_vars``: " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "id": "f1f0d2c7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32)),\n", - " JaxArray(DeviceArray([1.], dtype=float32)))" - ] + "text/plain": "(DeviceArray([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32),\n DeviceArray([1.], dtype=float32))" }, - "execution_count": 10, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -160,16 +206,24 @@ { "cell_type": "markdown", "id": "17ea78df", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If we pay attention to the derivatives of both argument \"x\" and parameters \"self.w\" and \"self.b\", ``argnums`` and ``grad_vars`` can be used together. In this condition, the gradient function will return gradients with the format of ``(var_grads, arg_grads)``, where ``arg_grads`` refers to the gradients of \"argnums\" and ``var_grads`` refers to the gradients of \"grad_vars\". " ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "id": "5cc0347c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "grad = bm.grad(l.update, grad_vars=(l.w, l.b), argnums=0)\n", @@ -179,18 +233,19 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "id": "ce6f0f99", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32)),\n", - " JaxArray(DeviceArray([1.], dtype=float32)))" - ] + "text/plain": "(DeviceArray([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32),\n DeviceArray([1.], dtype=float32))" }, - "execution_count": 13, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -201,18 +256,19 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "id": "aa0d8b7f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.0940454 , 0.24210012, 0.10360408, 0.2991985 , 0.22486198,\n", - " 0.9399384 , 0.88925755, 0.84567535, 0.94881094, 0.7843926 ], dtype=float32))" - ] + "text/plain": "JaxArray([0.9865978 , 0.14363837, 0.03861248, 0.42379665, 0.7038013 ,\n 0.11866355, 0.67538667, 0.15790391, 0.6050298 , 0.778468 ], dtype=float32)" }, - "execution_count": 14, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -224,7 +280,11 @@ { "cell_type": "markdown", "id": "93f20772", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``return_value``" ] @@ -232,16 +292,24 @@ { "cell_type": "markdown", "id": "42e5b9dd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "As is mentioned above, autograd functions return a function which computes gradients regardless of the returned value. Sometimes, however, we care about the value the function returns, not just the gradients. In this condition, you can set ``return_value=True`` in the autograd function." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "id": "600ea97e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "grad = bm.grad(l.update, argnums=0, return_value=True)\n", @@ -251,18 +319,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "id": "d6909c04", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.0940454 , 0.24210012, 0.10360408, 0.2991985 , 0.22486198,\n", - " 0.9399384 , 0.88925755, 0.84567535, 0.94881094, 0.7843926 ], dtype=float32))" - ] + "text/plain": "JaxArray([0.9865978 , 0.14363837, 0.03861248, 0.42379665, 0.7038013 ,\n 0.11866355, 0.67538667, 0.15790391, 0.6050298 , 0.778468 ], dtype=float32)" }, - "execution_count": 16, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -273,17 +342,19 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "id": "528b392f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray(5.3718853, dtype=float32)" - ] + "text/plain": "DeviceArray(4.6318984, dtype=float32)" }, - "execution_count": 17, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -295,7 +366,11 @@ { "cell_type": "markdown", "id": "a5f829bd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### ``has_aux``" ] @@ -303,16 +378,24 @@ { "cell_type": "markdown", "id": "5d9f4e2b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In some situations, we are interested in the intermediate values in a function, and ``has_aux=True`` can be of great help. The constraint is that you must return values with the format of ``(loss, aux_data)``. For instance, " ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 11, "id": "28e93b87", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class LinearAux(bp.Base):\n", @@ -332,9 +415,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "id": "3c683624", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "grad = bm.grad(l2.update, argnums=0, has_aux=True)\n", @@ -344,18 +431,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "id": "828ae73f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.7740855 , 0.6669129 , 0.74336326, 0.7743118 , 0.08353662,\n", - " 0.1557033 , 0.27870536, 0.3860656 , 0.14068758, 0.46460104], dtype=float32))" - ] + "text/plain": "JaxArray([0.20289445, 0.4745227 , 0.36053288, 0.94524395, 0.8360598 ,\n 0.06507981, 0.7748591 , 0.8377187 , 0.5767547 , 0.47604012], dtype=float32)" }, - "execution_count": 20, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -366,18 +454,19 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "id": "d921e0d6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(DeviceArray(4.4679728, dtype=float32),\n", - " JaxArray(DeviceArray([4.4679728], dtype=float32)))" - ] + "text/plain": "(DeviceArray(5.5497055, dtype=float32), JaxArray([5.5497055], dtype=float32))" }, - "execution_count": 21, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -389,7 +478,11 @@ { "cell_type": "markdown", "id": "6becdd17", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "When multiple keywords (``argnums``, ``grad_vars``, ``has_aux`` or``return_value``) are set simulatenously, the return format of the gradient function can be inspected through the corresponding API documentation [brainpy.math.grad()](../apis/auto/math/generated/brainpy.math.autograd.grad.rst)." ] @@ -397,7 +490,11 @@ { "cell_type": "markdown", "id": "df6b31f4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## ``brainpy.math.grad()``" ] @@ -405,7 +502,11 @@ { "cell_type": "markdown", "id": "d289c868", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "[brainpy.math.grad()](../apis/auto/math/generated/brainpy.math.autograd.grad.rst) takes a function/object ($f : \\mathbb{R}^n \\to \\mathbb{R}$) as the input and returns a new function ($\\partial f(x) \\to \\mathbb{R}^n$) which computes the gradient of the original function/object. It's worthy to note that ``brainpy.math.grad()`` only supports returning scalar values. " ] @@ -413,7 +514,11 @@ { "cell_type": "markdown", "id": "56075f51", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Pure functions" ] @@ -421,16 +526,24 @@ { "cell_type": "markdown", "id": "98b4cccc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For pure function, the gradient is taken with respect to the first argument: " ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "id": "45352485", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def f(a, b):\n", @@ -441,17 +554,19 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "id": "6009405f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray(2., dtype=float32)" - ] + "text/plain": "DeviceArray(2., dtype=float32, weak_type=True)" }, - "execution_count": 3, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -463,24 +578,30 @@ { "cell_type": "markdown", "id": "c06f4f4e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "However, this can be controlled via the `argnums` argument." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "id": "58aa6fbc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(DeviceArray(2., dtype=float32), DeviceArray(1., dtype=float32))" - ] + "text/plain": "(DeviceArray(2., dtype=float32, weak_type=True),\n DeviceArray(1., dtype=float32, weak_type=True))" }, - "execution_count": 4, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -494,7 +615,11 @@ { "cell_type": "markdown", "id": "2f0874ef", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Class objects" ] @@ -502,16 +627,24 @@ { "cell_type": "markdown", "id": "00906f22", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For a class object or a class bound function, the gradient is taken with respect to the provided ``grad_vars`` and ``argnums`` setting: " ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 18, "id": "acc95d4c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class F(bp.Base):\n", @@ -532,25 +665,30 @@ { "cell_type": "markdown", "id": "18d64bc3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The ``grad_vars`` can be a JaxArray, or a list/tuple/dict of JaxArray. " ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 19, "id": "30484eab", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "{'F0.a': TrainVar(DeviceArray([2.], dtype=float32)),\n", - " 'F0.b': TrainVar(DeviceArray([2.], dtype=float32))}" - ] + "text/plain": "{'F0.a': DeviceArray([2.], dtype=float32),\n 'F0.b': DeviceArray([2.], dtype=float32)}" }, - "execution_count": 23, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -561,18 +699,19 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 20, "id": "fa99d3ef", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "[TrainVar(DeviceArray([2.], dtype=float32)),\n", - " TrainVar(DeviceArray([2.], dtype=float32))]" - ] + "text/plain": "(DeviceArray([2.], dtype=float32), DeviceArray([2.], dtype=float32))" }, - "execution_count": 24, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -584,16 +723,24 @@ { "cell_type": "markdown", "id": "0847c77f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If there are dynamically changed values in the gradient function, you can provide them in the ``dyn_vars`` argument. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, "id": "f77b4c0e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class F2(bp.Base):\n", @@ -611,17 +758,19 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "id": "a0cf62b0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "TrainVar(DeviceArray([2.], dtype=float32))" - ] + "text/plain": "DeviceArray([2.], dtype=float32)" }, - "execution_count": 9, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -634,16 +783,24 @@ { "cell_type": "markdown", "id": "6998ec7c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Besides, if you are interested in the gradient of the input value, please use the ``argnums`` argument. Then, the gradient function will return ``(grads_of_grad_vars, grads_of_args)``. " ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 23, "id": "42c0dca2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class F3(bp.Base):\n", @@ -660,16 +817,20 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 24, "id": "3fe1c9ce", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grads_of_gv : [TrainVar(DeviceArray([2.], dtype=float32)), TrainVar(DeviceArray([2.], dtype=float32))]\n", - "grads_of_args : 3.0\n" + "grads_of_gv : (DeviceArray([2.], dtype=float32), DeviceArray([2.], dtype=float32))\n", + "grad_of_args : 3.0\n" ] } ], @@ -683,17 +844,20 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "id": "ba55cac6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grads_of_gv : [TrainVar(DeviceArray([2.], dtype=float32)), TrainVar(DeviceArray([2.], dtype=float32))]\n", - "grad_of_arg0 : 3.0\n", - "grad_of_arg1 : 10.0\n" + "grads_of_gv : (DeviceArray([2.], dtype=float32), DeviceArray([2.], dtype=float32))\n", + "grad_of_args : (DeviceArray(3., dtype=float32, weak_type=True), DeviceArray(10., dtype=float32, weak_type=True))\n" ] } ], @@ -708,7 +872,11 @@ { "cell_type": "markdown", "id": "06491457", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Actually, it is recommended to provide all dynamically changed variables, whether or not they are updated in the gradient function, in the ``dyn_vars`` argument. " ] @@ -716,7 +884,11 @@ { "cell_type": "markdown", "id": "73cedb4d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### Auxiliary data" ] @@ -724,22 +896,30 @@ { "cell_type": "markdown", "id": "1469a67f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Usually, we want to get the loss value, or we want to return some intermediate variables during the gradient computation. In these situation, users can set ``has_aux=True`` to return auxiliary data and set ``return_value=True`` to return the loss value. " ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 26, "id": "a34a7e5a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grad: TrainVar(DeviceArray([2.], dtype=float32))\n", + "grad: [2.]\n", "loss: 12.0\n" ] } @@ -755,16 +935,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 27, "id": "4a1ad862", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "grad: TrainVar(DeviceArray([1.], dtype=float32))\n", - "aux_data: (JaxArray(DeviceArray([1.], dtype=float32)), JaxArray(DeviceArray([2.], dtype=float32)))\n" + "grad: [1.]\n", + "aux_data: (JaxArray([1.], dtype=float32), JaxArray([2.], dtype=float32))\n" ] } ], @@ -794,7 +978,11 @@ { "cell_type": "markdown", "id": "33d2c322", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "```note\n", "Any function used to compute gradients through ``brainpy.math.grad()`` must return a scalar value. Otherwise an error will raise. \n", @@ -803,15 +991,19 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, "id": "ea6a89f5", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " Gradient only defined for scalar-output functions. Output was [0. 0.].\n" + " Gradient only defined for scalar-output functions. Output had shape: (2,).\n" ] } ], @@ -824,17 +1016,19 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 29, "id": "d08e3753", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.5, 0.5], dtype=float32))" - ] + "text/plain": "JaxArray([0.5, 0.5], dtype=float32)" }, - "execution_count": 24, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -848,7 +1042,11 @@ { "cell_type": "markdown", "id": "119967c0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## ``brainpy.math.vector_grad()``" ] @@ -856,16 +1054,24 @@ { "cell_type": "markdown", "id": "1542356e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "If users want to take gradients for a vector-output values, please use the [brainpy.math.vector_grad()](../apis/auto/math/generated/brainpy.math.autograd.vector_grad.rst) function. For example, " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 30, "id": "9a0a9b71", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def f(a, b): \n", @@ -875,16 +1081,24 @@ { "cell_type": "markdown", "id": "fcb68361", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Gradients for vectors" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "1323e89d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# vectors\n", @@ -895,17 +1109,19 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 32, "id": "a776e614", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.829829 , 0.3382971 , 0.13563846, 0.5101524 , 0.28861028], dtype=float32))" - ] + "text/plain": "JaxArray([0.22263631, 0.19832121, 0.47522876, 0.40596786, 0.2040254 ], dtype=float32)" }, - "execution_count": 9, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -916,18 +1132,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 33, "id": "85748195", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([0.829829 , 0.3382971 , 0.13563846, 0.5101524 , 0.28861028], dtype=float32)),\n", - " JaxArray(DeviceArray([0. , 0.9410394, 1.9815168, 2.580252 , 3.8297865], dtype=float32)))" - ] + "text/plain": "(JaxArray([0.22263631, 0.19832121, 0.47522876, 0.40596786, 0.2040254 ], dtype=float32),\n JaxArray([0. , 0.9801371, 1.7597246, 2.741662 , 3.9158623], dtype=float32))" }, - "execution_count": 10, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -939,16 +1156,24 @@ { "cell_type": "markdown", "id": "10694945", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "#### Gradients for matrices" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 34, "id": "19acd682", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# matrix\n", @@ -959,18 +1184,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 35, "id": "4c049c25", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[0. , 0.6934817, 1.9375703],\n", - " [2.142562 , 2.5830717, 4.9865813]], dtype=float32))" - ] + "text/plain": "JaxArray([[0. , 0.8662993, 1.1221857],\n [2.9322515, 2.3293345, 3.024507 ]], dtype=float32)" }, - "execution_count": 12, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -981,20 +1207,19 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 36, "id": "060fb4f2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([[0.09120136, 0.72047424, 0.24790175],\n", - " [0.6999546 , 0.7635338 , 0.07321358]], dtype=float32)),\n", - " JaxArray(DeviceArray([[0. , 0.6934817, 1.9375703],\n", - " [2.142562 , 2.5830717, 4.9865813]], dtype=float32)))" - ] + "text/plain": "(JaxArray([[0.45055482, 0.49952534, 0.8277529 ],\n [0.21131878, 0.8129499 , 0.79630035]], dtype=float32),\n JaxArray([[0. , 0.8662993, 1.1221857],\n [2.9322515, 2.3293345, 3.024507 ]], dtype=float32))" }, - "execution_count": 13, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -1006,16 +1231,24 @@ { "cell_type": "markdown", "id": "55e96324", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Similar to [brainpy.math.grad()](../apis/auto/math/generated/brainpy.math.autograd.grad.rst) , ``brainpy.math.vector_grad()`` also supports derivatives of variables in a class object. Here is a simple example. " ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 37, "id": "34e4f7bd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class Test(bp.Base):\n", @@ -1032,17 +1265,19 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 38, "id": "91fb638c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([2., 2., 2., 2., 2.], dtype=float32))" - ] + "text/plain": "DeviceArray([2., 2., 2., 2., 2.], dtype=float32)" }, - "execution_count": 24, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1053,17 +1288,19 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 39, "id": "678e2a24", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([2., 2., 2., 2., 2.], dtype=float32)),)" - ] + "text/plain": "(DeviceArray([2., 2., 2., 2., 2.], dtype=float32),)" }, - "execution_count": 25, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1074,18 +1311,19 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 40, "id": "d3279ad8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(JaxArray(DeviceArray([2., 2., 2., 2., 2.], dtype=float32)),\n", - " JaxArray(DeviceArray([3., 3., 3., 3., 3.], dtype=float32)))" - ] + "text/plain": "(DeviceArray([2., 2., 2., 2., 2.], dtype=float32),\n DeviceArray([3., 3., 3., 3., 3.], dtype=float32))" }, - "execution_count": 26, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1097,7 +1335,11 @@ { "cell_type": "markdown", "id": "25b9cb39", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Other operations like ``return_value`` and ``has_aux`` in [brainpy.math.vector_grad()](../apis/auto/math/generated/brainpy.math.autograd.vector_grad.rst) are the same as those in [brainpy.math.grad()](../apis/auto/math/generated/brainpy.math.autograd.grad.rst) ." ] @@ -1105,7 +1347,11 @@ { "cell_type": "markdown", "id": "1ca257d2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## ``brainpy.math.jacobian()``" ] @@ -1113,7 +1359,11 @@ { "cell_type": "markdown", "id": "f68747a3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Another way to take gradients of a vector-output value is using [brainpy.math.jacobian()](../apis/auto/math/generated/brainpy.math.autograd.jacobian.rst). ``brainpy.math.jacobian()`` aims to automatically compute the Jacobian matrices $\\partial f(x) \\in \\mathbb{R}^{m \\times n}$ by the given function $f : \\mathbb{R}^n \\to \\mathbb{R}^m$ at the given point of $x \\in \\mathbb{R}^n$. Here, we will not go to the details of the implementation and usage of the ``brainpy.math.jacobian()``. Instead, we only show two examples about the pure function and class function. " ] @@ -1121,16 +1371,24 @@ { "cell_type": "markdown", "id": "253df55c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Given the following function, " ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 41, "id": "13ff570b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import jax.numpy as jnp\n", @@ -1143,9 +1401,13 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 42, "id": "1aefb47d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "_x = bm.array([1., 2., 3.])\n", @@ -1156,20 +1418,19 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 43, "id": "a6ea00cb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[10. , 0. , 0. ],\n", - " [ 0. , 0. , 25. ],\n", - " [ 0. , 16. , -2. ],\n", - " [ 1.6209068 , 0. , 0.84147096]], dtype=float32))" - ] + "text/plain": "JaxArray([[10. , 0. , 0. ],\n [ 0. , 0. , 25. ],\n [ 0. , 16. , -2. ],\n [ 1.6209068 , 0. , 0.84147096]], dtype=float32)" }, - "execution_count": 36, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1180,17 +1441,19 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 44, "id": "c08984b8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([10. , 75. , 10. , 2.5244129], dtype=float32)" - ] + "text/plain": "DeviceArray([10. , 75. , 10. , 2.5244129], dtype=float32)" }, - "execution_count": 37, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -1201,17 +1464,19 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 45, "id": "2b64116c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray(10., dtype=float32)" - ] + "text/plain": "DeviceArray(10., dtype=float32)" }, - "execution_count": 38, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1223,16 +1488,24 @@ { "cell_type": "markdown", "id": "c1ad1eae", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Given the following class objects," ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 46, "id": "4f451a90", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "class Test(bp.Base):\n", @@ -1251,9 +1524,13 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 47, "id": "5f68ee77", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "t = Test()\n", @@ -1264,20 +1541,19 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 48, "id": "3db0d7d1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[10. , 0. , 0. ],\n", - " [ 0. , 0. , 25. ],\n", - " [ 0. , 16. , -2. ],\n", - " [ 1.6209068 , 0. , 0.84147096]], dtype=float32))" - ] + "text/plain": "DeviceArray([[10. , 0. , 0. ],\n [ 0. , 0. , 25. ],\n [ 0. , 16. , -2. ],\n [ 1.6209068 , 0. , 0.84147096]], dtype=float32)" }, - "execution_count": 43, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1288,20 +1564,19 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 49, "id": "82547a2f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([[ 1., 0.],\n", - " [ 0., 15.],\n", - " [ 0., 0.],\n", - " [ 0., 0.]], dtype=float32))" - ] + "text/plain": "JaxArray([[ 1., 0.],\n [ 0., 15.],\n [ 0., 0.],\n [ 0., 0.]], dtype=float32)" }, - "execution_count": 44, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1312,17 +1587,19 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 50, "id": "382e1ab2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([10. , 75. , 10. , 2.5244129], dtype=float32)" - ] + "text/plain": "DeviceArray([10. , 75. , 10. , 2.5244129], dtype=float32)" }, - "execution_count": 45, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -1333,17 +1610,19 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 51, "id": "de401f68", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "(DeviceArray(10., dtype=float32), DeviceArray(2.5244129, dtype=float32))" - ] + "text/plain": "(DeviceArray(10., dtype=float32), DeviceArray(2.5244129, dtype=float32))" }, - "execution_count": 46, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } @@ -1355,25 +1634,21 @@ { "cell_type": "markdown", "id": "8a486499", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For more details on automatical differentation, please see our [API documentation](../apis/auto/math/autograd.rst)." ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "656b311e", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:root] *", + "name": "python3", "language": "python", - "name": "conda-root-py" + "display_name": "Python 3 (ipykernel)" }, "language_info": { "codemirror_mode": { @@ -1426,4 +1701,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/docs/tutorial_math/variables.ipynb b/docs/tutorial_math/variables.ipynb index 9a8ce2914..2f58b6b7d 100644 --- a/docs/tutorial_math/variables.ipynb +++ b/docs/tutorial_math/variables.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "6445f581", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Variables" ] @@ -11,7 +15,11 @@ { "cell_type": "markdown", "id": "348b02c2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "@[Chaoming Wang](https://github.com/chaoming0625)\n", "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn)" @@ -20,7 +28,11 @@ { "cell_type": "markdown", "id": "e72cc93b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In BrainPy, the [JIT compilation](../apis/auto/math/generated/brainpy.math.jit.jit.rst) for class objects relies on [Variables](../apis/auto/math/generated/brainpy.math.jaxarray.Variable.rst). In this section, we are going to understand:\n", "\n", @@ -33,7 +45,11 @@ "cell_type": "code", "execution_count": 1, "id": "7188b466", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import brainpy as bp\n", @@ -45,7 +61,11 @@ { "cell_type": "markdown", "id": "53b1704b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## ``brainpy.math.Variable``" ] @@ -53,7 +73,11 @@ { "cell_type": "markdown", "id": "95f7dc2b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``brainpy.math.Variable`` is a pointer referring to a [tensor](./tensors.ipynb). It stores a tensor as its value. The data in a Variable can be changed during JIT compilation. **If a tensor is labeled as a Variable, it means that it is a dynamical variable that changes over time.**" ] @@ -61,7 +85,11 @@ { "cell_type": "markdown", "id": "ecb246c1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Tensors that are not marked as Variables will be JIT compiled as static data. Modifications of these tensors will be invalid or cause an error. " ] @@ -69,7 +97,11 @@ { "cell_type": "markdown", "id": "5c80bdb1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "- **Creating a Variable**\n", "\n", @@ -80,13 +112,15 @@ "cell_type": "code", "execution_count": 2, "id": "9bdceead", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.6998724 , 0.78383434, 0.4570111 , 0.5986333 , 0.7165228 ], dtype=float32))" - ] + "text/plain": "JaxArray([0.9116168 , 0.6901083 , 0.43920577, 0.13220644, 0.771458 ], dtype=float32)" }, "execution_count": 2, "metadata": {}, @@ -102,13 +136,15 @@ "cell_type": "code", "execution_count": 3, "id": "d9d16723", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "Variable(DeviceArray([0.6998724 , 0.78383434, 0.4570111 , 0.5986333 , 0.7165228 ], dtype=float32))" - ] + "text/plain": "Variable([0.9116168 , 0.6901083 , 0.43920577, 0.13220644, 0.771458 ], dtype=float32)" }, "execution_count": 3, "metadata": {}, @@ -123,7 +159,11 @@ { "cell_type": "markdown", "id": "214010c1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "- **Accessing the value in a Variable**\n", "\n", @@ -134,13 +174,15 @@ "cell_type": "code", "execution_count": 4, "id": "a7c53a9a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([0.6998724 , 0.78383434, 0.4570111 , 0.5986333 , 0.7165228 ], dtype=float32)" - ] + "text/plain": "DeviceArray([0.9116168 , 0.6901083 , 0.43920577, 0.13220644, 0.771458 ], dtype=float32)" }, "execution_count": 4, "metadata": {}, @@ -155,13 +197,15 @@ "cell_type": "code", "execution_count": 5, "id": "1c6621b7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray(True, dtype=bool)" - ] + "text/plain": "DeviceArray(True, dtype=bool)" }, "execution_count": 5, "metadata": {}, @@ -175,7 +219,11 @@ { "cell_type": "markdown", "id": "6b5281a9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "- **Supported operations on Variables**\n", "\n", @@ -186,13 +234,15 @@ "cell_type": "code", "execution_count": 6, "id": "c7b121ae", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "True" - ] + "text/plain": "True" }, "execution_count": 6, "metadata": {}, @@ -208,14 +258,15 @@ "execution_count": 7, "id": "6c11ce23", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "data": { - "text/plain": [ - "True" - ] + "text/plain": "True" }, "execution_count": 7, "metadata": {}, @@ -230,13 +281,15 @@ "cell_type": "code", "execution_count": 8, "id": "d2861370", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "True" - ] + "text/plain": "True" }, "execution_count": 8, "metadata": {}, @@ -252,7 +305,11 @@ { "cell_type": "markdown", "id": "2ed84eec", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "```{note}\n", "After performing any operation on a Variable, the resulting value will be a JaxArray (``brainpy.math.ndarray`` is an alias for ``brainpy.math.JaxArray``). This means that the Variable can only be used to refer to a single value. \n", @@ -263,13 +320,15 @@ "cell_type": "code", "execution_count": 9, "id": "0824d649", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([1.6998724, 1.7838343, 1.4570111, 1.5986333, 1.7165228], dtype=float32))" - ] + "text/plain": "JaxArray([1.9116168, 1.6901083, 1.4392058, 1.1322064, 1.771458 ], dtype=float32)" }, "execution_count": 9, "metadata": {}, @@ -284,13 +343,15 @@ "cell_type": "code", "execution_count": 10, "id": "628fbecc", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.48982134, 0.6143963 , 0.20885915, 0.3583618 , 0.51340497], dtype=float32))" - ] + "text/plain": "JaxArray([0.8310452 , 0.47624946, 0.1929017 , 0.01747854, 0.5951475 ], dtype=float32)" }, "execution_count": 10, "metadata": {}, @@ -305,13 +366,15 @@ "cell_type": "code", "execution_count": 11, "id": "4bb90bb0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0., 0., 0., 0., 0.], dtype=float32))" - ] + "text/plain": "JaxArray([0., 0., 0., 0., 0.], dtype=float32)" }, "execution_count": 11, "metadata": {}, @@ -325,7 +388,11 @@ { "cell_type": "markdown", "id": "f4432226", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Subtypes of ``Variable``\n", "\n", @@ -335,7 +402,11 @@ { "cell_type": "markdown", "id": "ad677bf0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 1. TrainVar" ] @@ -343,7 +414,11 @@ { "cell_type": "markdown", "id": "5504c217", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``brainpy.math.TrainVar`` is a trainable variable and a subclass of ``brainpy.math.Variable``. Usually, the trainable variables are meant to require their gradients and compute the corresponding update values. However, users can also use TrainVar for other purposes. " ] @@ -352,13 +427,15 @@ "cell_type": "code", "execution_count": 12, "id": "f8357f81", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.11834693, 0.23893237, 0.21002829, 0.22136414], dtype=float32))" - ] + "text/plain": "JaxArray([0.59062696, 0.618052 , 0.84173155, 0.34012556], dtype=float32)" }, "execution_count": 12, "metadata": {}, @@ -375,13 +452,15 @@ "cell_type": "code", "execution_count": 13, "id": "21f05b09", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "TrainVar(DeviceArray([0.11834693, 0.23893237, 0.21002829, 0.22136414], dtype=float32))" - ] + "text/plain": "TrainVar([0.59062696, 0.618052 , 0.84173155, 0.34012556], dtype=float32)" }, "execution_count": 13, "metadata": {}, @@ -395,7 +474,11 @@ { "cell_type": "markdown", "id": "e8284d53", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 2. Parameter" ] @@ -403,7 +486,11 @@ { "cell_type": "markdown", "id": "96aa1cf9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``brainpy.math.Parameter`` is to label a dynamically changed parameter. It is also a subclass of ``brainpy.math.Variable``. The advantage of using Parameter rather than Variable is that it can be easily retrieved by the ``Collector.subsets`` method (please see [Base class](./base.ipynb))." ] @@ -412,13 +499,15 @@ "cell_type": "code", "execution_count": 14, "id": "79105af2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "JaxArray(DeviceArray([0.9410963], dtype=float32))" - ] + "text/plain": "JaxArray([0.14782536], dtype=float32)" }, "execution_count": 14, "metadata": {}, @@ -435,13 +524,15 @@ "cell_type": "code", "execution_count": 15, "id": "773edf8b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "Parameter(DeviceArray([0.9410963], dtype=float32))" - ] + "text/plain": "Parameter([0.14782536], dtype=float32)" }, "execution_count": 15, "metadata": {}, @@ -455,7 +546,11 @@ { "cell_type": "markdown", "id": "afd5dfaa", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 3. RandomState" ] @@ -463,7 +558,11 @@ { "cell_type": "markdown", "id": "ba9c30c7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "``brainpy.math.random.RandomState`` is also a subclass of ``brainpy.math.Variable``. RandomState must store the dynamically changed **key** information (see [JAX random number designs](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#random-numbers)). Every time after a RandomState performs a random sampling, the \"key\" will change. Therefore, it is worthy to label a RandomState as the Variable. " ] @@ -472,13 +571,15 @@ "cell_type": "code", "execution_count": 16, "id": "e2ce1816", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "RandomState(DeviceArray([ 0, 1234], dtype=uint32))" - ] + "text/plain": "RandomState([ 0, 1234], dtype=uint32)" }, "execution_count": 16, "metadata": {}, @@ -495,13 +596,15 @@ "cell_type": "code", "execution_count": 17, "id": "b3360505", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "RandomState(DeviceArray([2113592192, 1902136347], dtype=uint32))" - ] + "text/plain": "RandomState([2113592192, 1902136347], dtype=uint32)" }, "execution_count": 17, "metadata": {}, @@ -519,13 +622,15 @@ "cell_type": "code", "execution_count": 18, "id": "27dfae54", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "RandomState(DeviceArray([1076515368, 3893328283], dtype=uint32))" - ] + "text/plain": "RandomState([1076515368, 3893328283], dtype=uint32)" }, "execution_count": 18, "metadata": {}, @@ -542,7 +647,11 @@ { "cell_type": "markdown", "id": "b5bcef7a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Every instance of RandomState can create a new seed from the current seed with ``.split_key()``. " ] @@ -551,13 +660,15 @@ "cell_type": "code", "execution_count": 19, "id": "ac30eb3d", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([3028232624, 826525938], dtype=uint32)" - ] + "text/plain": "DeviceArray([3028232624, 826525938], dtype=uint32)" }, "execution_count": 19, "metadata": {}, @@ -571,7 +682,11 @@ { "cell_type": "markdown", "id": "f9f8f0fb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "It can also create multiple seeds from the current seed with ``.split_keys(n)``. This is used internally by [pmap](../apis/auto/math/generated/brainpy.math.parallels.pmap.rst) and [vmap](../apis/auto/math/generated/brainpy.math.parallels.vmap.rst) to ensure that random numbers are different in parallel threads. " ] @@ -580,14 +695,15 @@ "cell_type": "code", "execution_count": 20, "id": "fd164f9e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([[4198471980, 1111166693],\n", - " [1457783592, 2493283834]], dtype=uint32)" - ] + "text/plain": "DeviceArray([[4198471980, 1111166693],\n [1457783592, 2493283834]], dtype=uint32)" }, "execution_count": 20, "metadata": {}, @@ -602,17 +718,15 @@ "cell_type": "code", "execution_count": 21, "id": "32b018e1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "DeviceArray([[3244149147, 2659778815],\n", - " [2548793527, 3057026599],\n", - " [ 874320145, 4142002431],\n", - " [3368470122, 3462971882],\n", - " [1756854521, 1662729797]], dtype=uint32)" - ] + "text/plain": "DeviceArray([[3244149147, 2659778815],\n [2548793527, 3057026599],\n [ 874320145, 4142002431],\n [3368470122, 3462971882],\n [1756854521, 1662729797]], dtype=uint32)" }, "execution_count": 21, "metadata": {}, @@ -626,7 +740,11 @@ { "cell_type": "markdown", "id": "3bd9149a", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "There is a default RandomState in ``brainpy.math.random`` module: `DEFAULT`. " ] @@ -636,14 +754,15 @@ "execution_count": 22, "id": "4f13cfae", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "data": { - "text/plain": [ - "RandomState(DeviceArray([ 866284373, 3459418158], dtype=uint32))" - ] + "text/plain": "RandomState([601887926, 339370966], dtype=uint32)" }, "execution_count": 22, "metadata": {}, @@ -657,7 +776,11 @@ { "cell_type": "markdown", "id": "75b36c67", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The inherent random methods like ``randint()``, ``rand()``, ``shuffle()``, etc. are using this DEFAULT state. If you try to change the default RandomState, please use ``seed()`` method. " ] @@ -666,13 +789,15 @@ "cell_type": "code", "execution_count": 23, "id": "9c93bdb6", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "text/plain": [ - "RandomState(DeviceArray([ 0, 654321], dtype=uint32))" - ] + "text/plain": "RandomState([ 0, 654321], dtype=uint32)" }, "execution_count": 23, "metadata": {}, @@ -688,7 +813,11 @@ { "cell_type": "markdown", "id": "10384b23", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## In-place updating" ] @@ -696,7 +825,11 @@ { "cell_type": "markdown", "id": "81cf35f3", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In BrainPy, the transformations (like [JIT](../apis/auto/math/generated/brainpy.math.jit.jit.rst)) usually need to update variables or tensors **in-place**. In-place updating does not change the reference pointing to the variable while changing the data stored in the variable. " ] @@ -704,7 +837,11 @@ { "cell_type": "markdown", "id": "e6b44bda", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "For example, here we have a variable ``a``." ] @@ -713,7 +850,11 @@ "cell_type": "code", "execution_count": 24, "id": "2c9da6cb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "a = bm.Variable(bm.zeros(5))" @@ -722,7 +863,11 @@ { "cell_type": "markdown", "id": "c1030c44", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The ids of the variable and the data stored in the variable are:" ] @@ -731,14 +876,18 @@ "cell_type": "code", "execution_count": 25, "id": "80cce760", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "id(a) = 2279866249808\n", - "id(a.value) = 2279843411968\n" + "id(a) = 2101001001088\n", + "id(a.value) = 2101018127136\n" ] } ], @@ -755,7 +904,11 @@ { "cell_type": "markdown", "id": "217566cb", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "In-place update (here we use `[:]`) does not change the pointer refered to the variable but changes its data:" ] @@ -765,15 +918,18 @@ "execution_count": 26, "id": "01a8e078", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "id(a) = 2279866249808\n", - "id(a.value) = 2279866472848\n" + "id(a) = 2101001001088\n", + "id(a.value) = 2101019514880\n" ] } ], @@ -788,7 +944,11 @@ "cell_type": "code", "execution_count": 27, "id": "29e1c7ed", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -807,7 +967,11 @@ { "cell_type": "markdown", "id": "b9d62d23", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "However, once you do not use in-place operators to assign data, the id that the variable ``a`` refers to will change. This will cause serious errors when using transformations in BrainPy. " ] @@ -816,13 +980,17 @@ "cell_type": "code", "execution_count": 28, "id": "f20fbb6b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "id(a) = 2279866349200\n", + "id(a) = 2101001187280\n", "(id(a) == id_of_a) = False\n" ] } @@ -837,7 +1005,11 @@ { "cell_type": "markdown", "id": "b7076ea7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "```note\n", "The following in-place operators are not limited to ``brainpy.math.Variable`` and its subclasses. They can also apply to ``brainpy.math.JaxArray``. \n", @@ -847,7 +1019,11 @@ { "cell_type": "markdown", "id": "f44d5bd7", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Here, we list several commonly used in-place operators." ] @@ -856,7 +1032,11 @@ "cell_type": "code", "execution_count": 29, "id": "00821ab9", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v = bm.Variable(bm.arange(10))" @@ -866,7 +1046,11 @@ "cell_type": "code", "execution_count": 30, "id": "3c751c58", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "old_id = id(v)\n", @@ -878,7 +1062,11 @@ { "cell_type": "markdown", "id": "d413c648", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 1. Indexing and slicing" ] @@ -886,7 +1074,11 @@ { "cell_type": "markdown", "id": "93573b82", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Indexing and slicing are the two most commonly used operators. The details of indexing and slicing are in [Array Objects Indexing](https://numpy.org/doc/stable/reference/arrays.indexing.html). " ] @@ -894,7 +1086,11 @@ { "cell_type": "markdown", "id": "e3767b90", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Indexing: ``v[i] = a`` or ``v[(1, 3)] = c`` (index multiple values)" ] @@ -903,7 +1099,11 @@ "cell_type": "code", "execution_count": 31, "id": "87ed7018", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v[0] = 1\n", @@ -914,7 +1114,11 @@ { "cell_type": "markdown", "id": "4fd5ff2f", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Slicing: ``v[i:j] = b``" ] @@ -923,7 +1127,11 @@ "cell_type": "code", "execution_count": 32, "id": "bbadb60b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v[1: 2] = 1\n", @@ -934,7 +1142,11 @@ { "cell_type": "markdown", "id": "750f5203", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Slicing all values: ``v[:] = d``, ``v[...] = e``" ] @@ -943,7 +1155,11 @@ "cell_type": "code", "execution_count": 33, "id": "4517b203", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v[:] = 0\n", @@ -955,7 +1171,11 @@ "cell_type": "code", "execution_count": 34, "id": "dcb6f8f8", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v[...] = bm.arange(10)\n", @@ -966,7 +1186,11 @@ { "cell_type": "markdown", "id": "076eb1a4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 2. Augmented assignment" ] @@ -974,7 +1198,11 @@ { "cell_type": "markdown", "id": "9e00a66e", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "All augmented assignment are in-place operations, which include \n", " - add: ``+=``\n", @@ -996,7 +1224,10 @@ "execution_count": 35, "id": "48eea0fa", "metadata": { - "scrolled": true + "scrolled": true, + "pycharm": { + "name": "#%%\n" + } }, "outputs": [], "source": [ @@ -1009,7 +1240,11 @@ "cell_type": "code", "execution_count": 36, "id": "122eafc4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v *= 2\n", @@ -1021,7 +1256,11 @@ "cell_type": "code", "execution_count": 37, "id": "1ff5afc4", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v |= bm.random.randint(0, 2, 10)\n", @@ -1033,7 +1272,11 @@ "cell_type": "code", "execution_count": 38, "id": "e1625cd0", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v **= 2\n", @@ -1045,7 +1288,11 @@ "cell_type": "code", "execution_count": 39, "id": "8a46a43c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v >>= 2\n", @@ -1056,7 +1303,11 @@ { "cell_type": "markdown", "id": "8d4ed316", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 3. ``.value`` assignment" ] @@ -1064,7 +1315,11 @@ { "cell_type": "markdown", "id": "34636eb2", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Another way to in-place update a variable is to assign new data to ``.value``. This operation is very **safe**, because it will check whether the type and shape of the new data are consistent with the current ones. " ] @@ -1073,7 +1328,11 @@ "cell_type": "code", "execution_count": 40, "id": "2f81a257", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v.value = bm.arange(10)\n", @@ -1085,7 +1344,11 @@ "cell_type": "code", "execution_count": 41, "id": "19611ce1", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1106,7 +1369,11 @@ "cell_type": "code", "execution_count": 42, "id": "c7911157", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1126,7 +1393,11 @@ { "cell_type": "markdown", "id": "efd1dcbd", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "### 4. ``.update()`` method" ] @@ -1134,7 +1405,11 @@ { "cell_type": "markdown", "id": "29630aaa", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Actually, the ``.value`` assignment is the same operation as the ``.update()`` method. Users who want a safe assignment can choose this method too. " ] @@ -1143,7 +1418,11 @@ "cell_type": "code", "execution_count": 43, "id": "d861440c", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "v.update(bm.random.randint(0, 20, size=10))" @@ -1153,7 +1432,11 @@ "cell_type": "code", "execution_count": 44, "id": "247f081b", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1174,7 +1457,11 @@ "cell_type": "code", "execution_count": 45, "id": "9ae0ce26", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -1244,4 +1531,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file