From ea55dda4c84484cadb1cb020b457c2ad3d54848a Mon Sep 17 00:00:00 2001 From: Christopher Earl <40307516+Cr0uton@users.noreply.github.com> Date: Tue, 6 Jul 2021 20:49:35 -0400 Subject: [PATCH 01/27] Update reservoir.py Reverted testing path for MNIST dataset --- examples/mnist/reservoir.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/mnist/reservoir.py b/examples/mnist/reservoir.py index 1370c0dd..4e542882 100644 --- a/examples/mnist/reservoir.py +++ b/examples/mnist/reservoir.py @@ -103,7 +103,7 @@ dataset = MNIST( PoissonEncoder(time=time, dt=dt), None, - root=os.path.join("..", "data", "MNIST"), + root=os.path.join("..", "..", "data", "MNIST"), download=True, transform=transforms.Compose( [transforms.ToTensor(), transforms.Lambda(lambda x: x * intensity)] From c92cc928a3cde78230dd0db322b4b0720ee16e1e Mon Sep 17 00:00:00 2001 From: Christopher Earl Date: Wed, 4 Aug 2021 22:03:45 -0400 Subject: [PATCH 02/27] Create topology (new).py New connection and feature pipeline --- bindsnet/network/topology (new).py | 491 +++++++++++++++++++++++++++++ 1 file changed, 491 insertions(+) create mode 100644 bindsnet/network/topology (new).py diff --git a/bindsnet/network/topology (new).py b/bindsnet/network/topology (new).py new file mode 100644 index 00000000..ff2dbf33 --- /dev/null +++ b/bindsnet/network/topology (new).py @@ -0,0 +1,491 @@ +from abc import ABC, abstractmethod +from typing import Union, Tuple, Optional, Sequence + +import numpy as np +import torch +from torch.nn import Module, Parameter +import torch.nn.functional as F +from torch.nn.modules.utils import _pair + +from nodes import Nodes, CSRMNodes +import warnings + +class AbstractConnection(ABC, Module): + # language=rst + """ + Abstract base method for connections between ``Nodes``. + """ + + def __init__( + self, + source: Nodes, + target: Nodes, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + weight_decay: float = 0.0, + **kwargs + ) -> None: + # language=rst + """ + Constructor for abstract base class for connection objects. + + :param source: A layer of nodes from which the connection originates. + :param target: A layer of nodes to which the connection connects. + :param nu: Learning rate for both pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param weight_decay: Constant multiple to decay weights by on each iteration. + + Keyword arguments: + + :param LearningRule update_rule: Modifies connection parameters according to + some rule. + :param float wmin: The minimum value on the connection weights. + :param float wmax: The maximum value on the connection weights. + :param float norm: Total weight per target neuron normalization. + :param dict features: Features to modify how connection behaves. + """ + super().__init__() + + + ### General Assertions ### + assert isinstance(source, Nodes), "Source is not a Nodes object" + assert isinstance(target, Nodes), "Target is not a Nodes object" + assert wmin < wmax, "wmin must be smaller than wmax" + + + ### Args/Kwargs ### + self.source = source + self.target = target + # self.nu = nu + self.weight_decay = weight_decay + self.reduction = reduction + + self.update_rule = kwargs.get("update_rule", NoOp) + self.wmin = kwargs.get("wmin", -np.inf) + self.wmax = kwargs.get("wmax", np.inf) + self.norm = kwargs.get("norm", None) + self.decay = kwargs.get("decay", None) + # self.features = kwargs.get("features", None) + + + # ### Update Rule ### + # from ..learning import NoOp + # if self.update_rule is None: + # self.update_rule = NoOp + # + # self.update_rule = self.update_rule( + # connection=self, + # nu=nu, + # reduction=reduction, + # weight_decay=weight_decay, + # **kwargs + # ) + + ### Feature Pipeline ### + order = ['delay', 'weights', 'probability', 'mask'] + funcs = [self.delay, self.weight, self.probability, self.mask] + self.pipeline = [] + + # Initialize present features + if 'delay' in features: + args = args['delay'] + + assert args['range'][0] < args['range'][1], "Invalid delay range: lower bound larger than upper bound" + assert args['range'][1] > 0, "Maximum delay must be greater than 0." + + # Indexing for delays (Keep track of how many outputs are needed) + self.delays_idx = Parameter( + torch.arange(0, source.n * target.n, dtype=torch.long), requires_grad=False + ) + + # Variable to record delays for each output signal + self.delay_buffer = Parameter( + torch.zeros(source.n * target.n, args['range'][1], dtype=torch.float), + requires_grad=False, + ) + + # Initialize time index + self.time_idx = 0 + + # Get smallest weight min and largest weight max (depends if tensor or float) + min = self.wmin if not isinstance(self.wmin, torch.Tensor) else torch.min(self.wmin) + max = self.wmax if not isinstance(self.wmax, torch.Tensor) else torch.max(self.wmax) + if 'weights' in features: + + # Clamp custom weights + if min != -np.inf or max != np.inf: + w = torch.clamp(w, self.wmin, self.wmax) + + else: + + # Randomly initialize weights if none provided + if min == -np.inf or max == np.inf: + w = torch.clamp(torch.rand(source.n, target.n), self.wmin, self.wmax) + else: + w = self.wmin + torch.rand(source.n, target.n) * (self.wmax - self.wmin) + + if 'probability' in features: + self.probabilities = features['probability']['probabilities'] + + if 'mask' in features: + self.mask = features['mask']['m'] + + + + @abstractmethod + def compute(self, s: torch.Tensor) -> None: + # language=rst + """ + Compute pre-activations of downstream neurons given spikes of upstream neurons. + + :param s: Incoming spikes. + """ + pass + + + @abstractmethod + def update(self, **kwargs) -> None: + # language=rst + """ + Compute connection's update rule. + + Keyword arguments: + + :param bool learning: Whether to allow connection updates. + :param ByteTensor mask: Boolean mask determining which weights to clamp to zero. + """ + learning = kwargs.get("learning", True) + + if learning: + self.update_rule.update(**kwargs) + + mask = kwargs.get("mask", None) + if mask is not None: + self.w.masked_fill_(mask, 0) + + @abstractmethod + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the connection. + """ + pass + + ######################### + ### Pipeline Features ### + ######################### + + @abstractmethod + def weight(self, s, params) -> torch.Tensor: + pass + + @abstractmethod + def probability(self, s, params) -> torch.Tensor: + pass + + @abstractmethod + def delay(self, s, params) -> torch.Tensor: + pass + + @abstractmethod + def mask(self, s, params) -> torch.Tensor: + pass + + +class Connection(AbstractConnection): + # language=rst + """ + Specifies synapses between one or two populations of neurons. + """ + + def __init__( + self, + source: Nodes, + target: Nodes, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + weight_decay: float = 0.0, + **kwargs + ) -> None: + # language=rst + """ + Instantiates a :code:`Connection` object. + + :param source: A layer of nodes from which the connection originates. + :param target: A layer of nodes to which the connection connects. + :param nu: Learning rate for both pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param weight_decay: Constant multiple to decay weights by on each iteration. + + Keyword arguments: + + :param LearningRule update_rule: Modifies connection parameters according to + some rule. + :param torch.Tensor w: Strengths of synapses. + :param torch.Tensor b: Target population bias. + :param float wmin: Minimum allowed value on the connection weights. + :param float wmax: Maximum allowed value on the connection weights. + :param float norm: Total weight per target neuron normalization constant. + """ + super().__init__(source, target, nu, reduction, weight_decay, **kwargs) + + w = kwargs.get("w", None) + if w is None: + if self.wmin == -np.inf or self.wmax == np.inf: + w = torch.clamp(torch.rand(source.n, target.n), self.wmin, self.wmax) + else: + w = self.wmin + torch.rand(source.n, target.n) * (self.wmax - self.wmin) + else: + if self.wmin != -np.inf or self.wmax != np.inf: + w = torch.clamp(torch.as_tensor(w), self.wmin, self.wmax) + + self.w = Parameter(w, requires_grad=False) + + b = kwargs.get("b", None) + if b is not None: + self.b = Parameter(b, requires_grad=False) + else: + self.b = None + + if isinstance(self.target, CSRMNodes): + self.s_w = None + + def compute(self, s: torch.Tensor) -> torch.Tensor: + # language=rst + """ + Compute pre-activations given spikes using connection weights. + + :param s: Incoming spikes. + :return: Incoming spikes multiplied by synaptic weights (with or without + decaying spike activation). + """ + + ### General connection setup ### + # Decay weights + if self.weight_decay is not None: + if self.weight_linear_decay: + self.w.data = self.w.data - self.weight_decay + else: + self.w.data = self.w.data - (self.w.data * self.weight_decay) + + # Clip min and max values + self.w.data = torch.clamp(self.w.data, min=self.wmin, max=self.wmax) + + # Prepare broadcast from incoming spikes to all output neurons + # Note: |conn_spikes| = [source.n * target.n] + conn_spikes = s.view(self.source.n, 1).repeat(1, self.target.n).flatten() + + # Run through pipeline + + + + def weights(self, conn_spikes, params) -> torch.Tensor: + return s @ self.w + + def probability(self, conn_spikes, params) -> torch.Tensor: + travel_gate = torch.bernoulli(self.probabilities) + return s & travel_gate + + def delay(self, conn_spikes, params) -> torch.Tensor: + + # convert weights to delays, in the given delay range + # delays = self.max_delay - (self.w.flatten() * self.max_delay).long() + delays = self.max_delay - (w_norm.flatten() * self.max_delay).long() + + # Drop late spikes and surpress new spikes in favor of old ones + if self.refrac_count is not None: + if conn_spikes.device != self.refrac_count.device: + self.refrac_count = self.refrac_count.to(conn_spikes.device) + if self.drop_late_spikes: + conn_spikes[delays == self.max_delay] = 0 + conn_spikes &= self.refrac_count <= 0 + self.refrac_count -= 1 + self.refrac_count[conn_spikes.bool()] = delays[conn_spikes.bool()] + + # add circular time index to delays + delays = (delays + self.time_idx) % self.max_delay + + return s + + + def compute_window(self, s: torch.Tensor) -> torch.Tensor: + # language=rst + """""" + + if self.s_w == None: + # Construct a matrix of shape batch size * window size * dimension of layer + self.s_w = torch.zeros( + self.target.batch_size, self.target.res_window_size, *self.source.shape + ) + + # Add the spike vector into the first in first out matrix of windowed (res) spike trains + self.s_w = torch.cat((self.s_w[:, 1:, :], s[:, None, :]), 1) + + # Compute multiplication of spike activations by weights and add bias. + if self.b is None: + post = ( + self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w + ) + else: + post = ( + self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w + + self.b + ) + + return post.view( + self.s_w.size(0), self.target.res_window_size, *self.target.shape + ) + + def update(self, **kwargs) -> None: + # language=rst + """ + Compute connection's update rule. + """ + super().update(**kwargs) + + def normalize(self) -> None: + # language=rst + """ + Normalize weights so each target neuron has sum of connection weights equal to + ``self.norm``. + """ + if self.norm is not None: + w_abs_sum = self.w.abs().sum(0).unsqueeze(0) + w_abs_sum[w_abs_sum == 0] = 1.0 + self.w *= self.norm / w_abs_sum + + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the connection. + """ + super().reset_state_variables() + + + +if __name__ == '__main__': + + from bindsnet.network.nodes import Input, LIFNodes + from bindsnet.learning import PostPre, MSTDP + + input_l = Input(n=784) + hidden_l = LIFNodes(n=2500) + m = torch.ones(784,2500) + + test_conn = Connection( + source=input_l, + target=hidden_l, + features={ + 'mask' : m, + 'probability': { + 'probabilities': 0.5 * torch.rand(784, 2500), + 'update_rule': PostPre, + 'nu': [1e-2, 0], + 'norm': 0.25, + 'range': [0.0, 0.5], + }, + 'weights': { + 'w': 0.5 + 0.5*torch.rand(784, 2500), + }, + 'delays': { + 'delays': torch.rand(784, 2500), + 'update_rule': MSTDP, # reward-modulated STDP + 'nu': [1e-2, 1e-3], + 'norm': 0.8, + 'range': [0.0, 1.0] + } + }) + + + +# if __name__ == '__main__': +# +# from nodes import LIFNodes +# from bindsnet.network.nodes import Input +# from bindsnet.network import Network +# from bindsnet.network.topology import Connection +# +# model = Network() +# +# input_l = Input(n=784, spike_value=1.2) +# +# # generate a 20% inh neuron map, with both exc and inh spike values +# v = torch.rand(2500) +# v[v < 0.2] = -5.0 +# v[v >= 0.2] = 2.5 +# hidden_l = LIFNodes(n=2500, spike_values=v) +# +# output_l = LIFNodes(n=10, spike_values=-1000.0) +# +# model.add_layer(input_l, name='X') +# model.add_layer(hidden_l, name='H') +# model.add_layer(output_l, name='Y') +# +# # input to hidden connection definition : +# # generating a statistical local con mask +# m = torch.zeros(784, 2500) +# for xi in range(28): +# for yi in range(28): +# for xo in range(50): +# for yo in range(50): +# dx = xi - xo +# dy = yi - yo +# m[xi + yi * 28, xo + 50 * yo] = dx * dx + dy * dy +# +# m = torch.sqrt(m) +# m /= m.max() +# m *= torch.rand(784, 2500) +# m = m > 0.5 +# +# in_hid_con = Connection( +# source=input_l, +# target=hidden_l, +# features={ +# 'mask': m, +# 'probability': { +# 'probabilities': 0.5 * torch.rand(784, 2500), +# 'update_rule': PostPre, +# 'nu': [1e-2, 0], +# 'norm': 0.25, +# 'range': [0.0, 0.5], +# }, +# 'weights': { +# 'w': 0.5 + 0.5 * torch.rand(784, 2500), +# }, +# 'delays': { +# 'delays': torch.rand(784, 2500), +# 'update_rule': MSTDP, # reward-modulated STDP +# 'nu': [1e-2, 1e-3], +# 'norm': 0.8, +# 'range': [0.0, 1.0] +# } +# } +# ) +# +# # hidden to output connection definition : +# hid_out_con = Connection( +# source=hidden_l, +# target=output_l, +# features={ +# 'weights': { +# 'w': torch.rand(784, 2500), +# } +# } +# ) +# +# # recurrent WTA connection on output definition : +# recurrent_con = Connection( +# source=output_l, +# target=output_l, +# features={ +# 'weights': { +# 'w': torch.ones(10, 10), +# } +# } +# ) +# +# model.add_connection(in_hid_con, source='X', target='H') +# model.add_connection(hid_out_con, source='H', target='Y') +# model.add_connection(recurrent_con, source='Y', target='Y') \ No newline at end of file From 9e9f744d8c38fb8246711aff78e077120237f09a Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 21:06:35 -0400 Subject: [PATCH 03/27] changes to plotting.py --- bindsnet/analysis/plotting.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/bindsnet/analysis/plotting.py b/bindsnet/analysis/plotting.py index 64e00a5e..c7c4cd75 100644 --- a/bindsnet/analysis/plotting.py +++ b/bindsnet/analysis/plotting.py @@ -40,8 +40,8 @@ def plot_input( if axes is None: fig, axes = plt.subplots(1, 2, figsize=figsize) ims = ( - axes[0].imshow(local_image, cmap="binary"), - axes[1].imshow(local_inpy, cmap="binary"), + axes[0].imshow(local_image, cmap="binary", aspect="auto"), + axes[1].imshow(local_inpy, cmap="binary", aspect="auto"), ) if label is None: @@ -182,6 +182,7 @@ def plot_weights( figsize: Tuple[int, int] = (5, 5), cmap: str = "hot_r", save: Optional[str] = None, + title: Optional[str] = None, ) -> AxesImage: # language=rst """ @@ -194,6 +195,7 @@ def plot_weights( :param figsize: Horizontal, vertical figure size in inches. :param cmap: Matplotlib colormap. :param save: file name to save fig, if None = not saving fig. + :param title: Title of the plot. :return: ``AxesImage`` for re-drawing the weights plot. """ local_weights = weights.detach().clone().cpu().numpy() @@ -209,6 +211,8 @@ def plot_weights( ax.set_xticks(()) ax.set_yticks(()) ax.set_aspect("auto") + if title != None: + ax.set_title(title + " Weights") plt.colorbar(im, cax=cax) fig.tight_layout() @@ -237,6 +241,8 @@ def plot_weights( ax.set_xticks(()) ax.set_yticks(()) ax.set_aspect("auto") + if title != None: + ax.set_title(title + " Weights") plt.colorbar(im, cax=cax) fig.tight_layout() @@ -597,7 +603,7 @@ def plot_voltages( .numpy()[ time[0] : time[1], n_neurons[v[0]][0] : n_neurons[v[0]][1], - ] + ], ) ) From 6a49ceb00463e77c5f0e2bae4579c971e0801ca3 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:02:47 -0400 Subject: [PATCH 04/27] compatability change, torch._six not supported (https://github.com/NVIDIA/apex/issues/1724) --- bindsnet/datasets/collate.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bindsnet/datasets/collate.py b/bindsnet/datasets/collate.py index acd42bf8..794e345b 100644 --- a/bindsnet/datasets/collate.py +++ b/bindsnet/datasets/collate.py @@ -8,7 +8,6 @@ """ import torch -from torch._six import string_classes import collections from torch.utils.data._utils import collate as pytorch_collate @@ -75,7 +74,7 @@ def time_aware_collate(batch): return torch.tensor(batch, dtype=torch.float64) elif isinstance(elem, int): return torch.tensor(batch) - elif isinstance(elem, string_classes): + elif isinstance(elem, str): return batch elif isinstance(elem, collections.Mapping): return {key: time_aware_collate([d[key] for d in batch]) for key in elem} From 7f0cf10bd23d70617f528bd5168cff9ea60d6938 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:04:04 -0400 Subject: [PATCH 05/27] compatability change, torch._six not supported (https://github.com/NVIDIA/apex/issues/1724) --- bindsnet/pipeline/base_pipeline.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bindsnet/pipeline/base_pipeline.py b/bindsnet/pipeline/base_pipeline.py index 6790a504..0d1550f6 100644 --- a/bindsnet/pipeline/base_pipeline.py +++ b/bindsnet/pipeline/base_pipeline.py @@ -2,7 +2,6 @@ from typing import Tuple, Dict, Any import torch -from torch._six import string_classes import collections from ..network import Network @@ -23,7 +22,7 @@ def recursive_to(item, device): if isinstance(item, torch.Tensor): return item.to(device) - elif isinstance(item, (string_classes, int, float, bool)): + elif isinstance(item, (str, int, float, bool)): return item elif isinstance(item, collections.Mapping): return {key: recursive_to(item[key], device) for key in item} From 4a7d680bed43a580f8f659e2250e2c037520b3d2 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:19:13 -0400 Subject: [PATCH 06/27] compatability change, package name change --- bindsnet/datasets/collate.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bindsnet/datasets/collate.py b/bindsnet/datasets/collate.py index 794e345b..9120ad98 100644 --- a/bindsnet/datasets/collate.py +++ b/bindsnet/datasets/collate.py @@ -76,11 +76,11 @@ def time_aware_collate(batch): return torch.tensor(batch) elif isinstance(elem, str): return batch - elif isinstance(elem, collections.Mapping): + elif isinstance(elem, collections.abc.Mapping): return {key: time_aware_collate([d[key] for d in batch]) for key in elem} elif isinstance(elem, tuple) and hasattr(elem, "_fields"): # namedtuple return elem_type(*(time_aware_collate(samples) for samples in zip(*batch))) - elif isinstance(elem, collections.Sequence): + elif isinstance(elem, collections.abc.Sequence): transposed = zip(*batch) return [time_aware_collate(samples) for samples in transposed] From c81eef4ad66ce8f13f50321f9a6255568950a779 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:44:33 -0400 Subject: [PATCH 07/27] Add new connection classes --- bindsnet/network/topology (new).py | 491 ----------------------------- bindsnet/network/topology.py | 236 ++++++++++++++ 2 files changed, 236 insertions(+), 491 deletions(-) delete mode 100644 bindsnet/network/topology (new).py diff --git a/bindsnet/network/topology (new).py b/bindsnet/network/topology (new).py deleted file mode 100644 index ff2dbf33..00000000 --- a/bindsnet/network/topology (new).py +++ /dev/null @@ -1,491 +0,0 @@ -from abc import ABC, abstractmethod -from typing import Union, Tuple, Optional, Sequence - -import numpy as np -import torch -from torch.nn import Module, Parameter -import torch.nn.functional as F -from torch.nn.modules.utils import _pair - -from nodes import Nodes, CSRMNodes -import warnings - -class AbstractConnection(ABC, Module): - # language=rst - """ - Abstract base method for connections between ``Nodes``. - """ - - def __init__( - self, - source: Nodes, - target: Nodes, - nu: Optional[Union[float, Sequence[float]]] = None, - reduction: Optional[callable] = None, - weight_decay: float = 0.0, - **kwargs - ) -> None: - # language=rst - """ - Constructor for abstract base class for connection objects. - - :param source: A layer of nodes from which the connection originates. - :param target: A layer of nodes to which the connection connects. - :param nu: Learning rate for both pre- and post-synaptic events. - :param reduction: Method for reducing parameter updates along the minibatch - dimension. - :param weight_decay: Constant multiple to decay weights by on each iteration. - - Keyword arguments: - - :param LearningRule update_rule: Modifies connection parameters according to - some rule. - :param float wmin: The minimum value on the connection weights. - :param float wmax: The maximum value on the connection weights. - :param float norm: Total weight per target neuron normalization. - :param dict features: Features to modify how connection behaves. - """ - super().__init__() - - - ### General Assertions ### - assert isinstance(source, Nodes), "Source is not a Nodes object" - assert isinstance(target, Nodes), "Target is not a Nodes object" - assert wmin < wmax, "wmin must be smaller than wmax" - - - ### Args/Kwargs ### - self.source = source - self.target = target - # self.nu = nu - self.weight_decay = weight_decay - self.reduction = reduction - - self.update_rule = kwargs.get("update_rule", NoOp) - self.wmin = kwargs.get("wmin", -np.inf) - self.wmax = kwargs.get("wmax", np.inf) - self.norm = kwargs.get("norm", None) - self.decay = kwargs.get("decay", None) - # self.features = kwargs.get("features", None) - - - # ### Update Rule ### - # from ..learning import NoOp - # if self.update_rule is None: - # self.update_rule = NoOp - # - # self.update_rule = self.update_rule( - # connection=self, - # nu=nu, - # reduction=reduction, - # weight_decay=weight_decay, - # **kwargs - # ) - - ### Feature Pipeline ### - order = ['delay', 'weights', 'probability', 'mask'] - funcs = [self.delay, self.weight, self.probability, self.mask] - self.pipeline = [] - - # Initialize present features - if 'delay' in features: - args = args['delay'] - - assert args['range'][0] < args['range'][1], "Invalid delay range: lower bound larger than upper bound" - assert args['range'][1] > 0, "Maximum delay must be greater than 0." - - # Indexing for delays (Keep track of how many outputs are needed) - self.delays_idx = Parameter( - torch.arange(0, source.n * target.n, dtype=torch.long), requires_grad=False - ) - - # Variable to record delays for each output signal - self.delay_buffer = Parameter( - torch.zeros(source.n * target.n, args['range'][1], dtype=torch.float), - requires_grad=False, - ) - - # Initialize time index - self.time_idx = 0 - - # Get smallest weight min and largest weight max (depends if tensor or float) - min = self.wmin if not isinstance(self.wmin, torch.Tensor) else torch.min(self.wmin) - max = self.wmax if not isinstance(self.wmax, torch.Tensor) else torch.max(self.wmax) - if 'weights' in features: - - # Clamp custom weights - if min != -np.inf or max != np.inf: - w = torch.clamp(w, self.wmin, self.wmax) - - else: - - # Randomly initialize weights if none provided - if min == -np.inf or max == np.inf: - w = torch.clamp(torch.rand(source.n, target.n), self.wmin, self.wmax) - else: - w = self.wmin + torch.rand(source.n, target.n) * (self.wmax - self.wmin) - - if 'probability' in features: - self.probabilities = features['probability']['probabilities'] - - if 'mask' in features: - self.mask = features['mask']['m'] - - - - @abstractmethod - def compute(self, s: torch.Tensor) -> None: - # language=rst - """ - Compute pre-activations of downstream neurons given spikes of upstream neurons. - - :param s: Incoming spikes. - """ - pass - - - @abstractmethod - def update(self, **kwargs) -> None: - # language=rst - """ - Compute connection's update rule. - - Keyword arguments: - - :param bool learning: Whether to allow connection updates. - :param ByteTensor mask: Boolean mask determining which weights to clamp to zero. - """ - learning = kwargs.get("learning", True) - - if learning: - self.update_rule.update(**kwargs) - - mask = kwargs.get("mask", None) - if mask is not None: - self.w.masked_fill_(mask, 0) - - @abstractmethod - def reset_state_variables(self) -> None: - # language=rst - """ - Contains resetting logic for the connection. - """ - pass - - ######################### - ### Pipeline Features ### - ######################### - - @abstractmethod - def weight(self, s, params) -> torch.Tensor: - pass - - @abstractmethod - def probability(self, s, params) -> torch.Tensor: - pass - - @abstractmethod - def delay(self, s, params) -> torch.Tensor: - pass - - @abstractmethod - def mask(self, s, params) -> torch.Tensor: - pass - - -class Connection(AbstractConnection): - # language=rst - """ - Specifies synapses between one or two populations of neurons. - """ - - def __init__( - self, - source: Nodes, - target: Nodes, - nu: Optional[Union[float, Sequence[float]]] = None, - reduction: Optional[callable] = None, - weight_decay: float = 0.0, - **kwargs - ) -> None: - # language=rst - """ - Instantiates a :code:`Connection` object. - - :param source: A layer of nodes from which the connection originates. - :param target: A layer of nodes to which the connection connects. - :param nu: Learning rate for both pre- and post-synaptic events. - :param reduction: Method for reducing parameter updates along the minibatch - dimension. - :param weight_decay: Constant multiple to decay weights by on each iteration. - - Keyword arguments: - - :param LearningRule update_rule: Modifies connection parameters according to - some rule. - :param torch.Tensor w: Strengths of synapses. - :param torch.Tensor b: Target population bias. - :param float wmin: Minimum allowed value on the connection weights. - :param float wmax: Maximum allowed value on the connection weights. - :param float norm: Total weight per target neuron normalization constant. - """ - super().__init__(source, target, nu, reduction, weight_decay, **kwargs) - - w = kwargs.get("w", None) - if w is None: - if self.wmin == -np.inf or self.wmax == np.inf: - w = torch.clamp(torch.rand(source.n, target.n), self.wmin, self.wmax) - else: - w = self.wmin + torch.rand(source.n, target.n) * (self.wmax - self.wmin) - else: - if self.wmin != -np.inf or self.wmax != np.inf: - w = torch.clamp(torch.as_tensor(w), self.wmin, self.wmax) - - self.w = Parameter(w, requires_grad=False) - - b = kwargs.get("b", None) - if b is not None: - self.b = Parameter(b, requires_grad=False) - else: - self.b = None - - if isinstance(self.target, CSRMNodes): - self.s_w = None - - def compute(self, s: torch.Tensor) -> torch.Tensor: - # language=rst - """ - Compute pre-activations given spikes using connection weights. - - :param s: Incoming spikes. - :return: Incoming spikes multiplied by synaptic weights (with or without - decaying spike activation). - """ - - ### General connection setup ### - # Decay weights - if self.weight_decay is not None: - if self.weight_linear_decay: - self.w.data = self.w.data - self.weight_decay - else: - self.w.data = self.w.data - (self.w.data * self.weight_decay) - - # Clip min and max values - self.w.data = torch.clamp(self.w.data, min=self.wmin, max=self.wmax) - - # Prepare broadcast from incoming spikes to all output neurons - # Note: |conn_spikes| = [source.n * target.n] - conn_spikes = s.view(self.source.n, 1).repeat(1, self.target.n).flatten() - - # Run through pipeline - - - - def weights(self, conn_spikes, params) -> torch.Tensor: - return s @ self.w - - def probability(self, conn_spikes, params) -> torch.Tensor: - travel_gate = torch.bernoulli(self.probabilities) - return s & travel_gate - - def delay(self, conn_spikes, params) -> torch.Tensor: - - # convert weights to delays, in the given delay range - # delays = self.max_delay - (self.w.flatten() * self.max_delay).long() - delays = self.max_delay - (w_norm.flatten() * self.max_delay).long() - - # Drop late spikes and surpress new spikes in favor of old ones - if self.refrac_count is not None: - if conn_spikes.device != self.refrac_count.device: - self.refrac_count = self.refrac_count.to(conn_spikes.device) - if self.drop_late_spikes: - conn_spikes[delays == self.max_delay] = 0 - conn_spikes &= self.refrac_count <= 0 - self.refrac_count -= 1 - self.refrac_count[conn_spikes.bool()] = delays[conn_spikes.bool()] - - # add circular time index to delays - delays = (delays + self.time_idx) % self.max_delay - - return s - - - def compute_window(self, s: torch.Tensor) -> torch.Tensor: - # language=rst - """""" - - if self.s_w == None: - # Construct a matrix of shape batch size * window size * dimension of layer - self.s_w = torch.zeros( - self.target.batch_size, self.target.res_window_size, *self.source.shape - ) - - # Add the spike vector into the first in first out matrix of windowed (res) spike trains - self.s_w = torch.cat((self.s_w[:, 1:, :], s[:, None, :]), 1) - - # Compute multiplication of spike activations by weights and add bias. - if self.b is None: - post = ( - self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w - ) - else: - post = ( - self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w - + self.b - ) - - return post.view( - self.s_w.size(0), self.target.res_window_size, *self.target.shape - ) - - def update(self, **kwargs) -> None: - # language=rst - """ - Compute connection's update rule. - """ - super().update(**kwargs) - - def normalize(self) -> None: - # language=rst - """ - Normalize weights so each target neuron has sum of connection weights equal to - ``self.norm``. - """ - if self.norm is not None: - w_abs_sum = self.w.abs().sum(0).unsqueeze(0) - w_abs_sum[w_abs_sum == 0] = 1.0 - self.w *= self.norm / w_abs_sum - - def reset_state_variables(self) -> None: - # language=rst - """ - Contains resetting logic for the connection. - """ - super().reset_state_variables() - - - -if __name__ == '__main__': - - from bindsnet.network.nodes import Input, LIFNodes - from bindsnet.learning import PostPre, MSTDP - - input_l = Input(n=784) - hidden_l = LIFNodes(n=2500) - m = torch.ones(784,2500) - - test_conn = Connection( - source=input_l, - target=hidden_l, - features={ - 'mask' : m, - 'probability': { - 'probabilities': 0.5 * torch.rand(784, 2500), - 'update_rule': PostPre, - 'nu': [1e-2, 0], - 'norm': 0.25, - 'range': [0.0, 0.5], - }, - 'weights': { - 'w': 0.5 + 0.5*torch.rand(784, 2500), - }, - 'delays': { - 'delays': torch.rand(784, 2500), - 'update_rule': MSTDP, # reward-modulated STDP - 'nu': [1e-2, 1e-3], - 'norm': 0.8, - 'range': [0.0, 1.0] - } - }) - - - -# if __name__ == '__main__': -# -# from nodes import LIFNodes -# from bindsnet.network.nodes import Input -# from bindsnet.network import Network -# from bindsnet.network.topology import Connection -# -# model = Network() -# -# input_l = Input(n=784, spike_value=1.2) -# -# # generate a 20% inh neuron map, with both exc and inh spike values -# v = torch.rand(2500) -# v[v < 0.2] = -5.0 -# v[v >= 0.2] = 2.5 -# hidden_l = LIFNodes(n=2500, spike_values=v) -# -# output_l = LIFNodes(n=10, spike_values=-1000.0) -# -# model.add_layer(input_l, name='X') -# model.add_layer(hidden_l, name='H') -# model.add_layer(output_l, name='Y') -# -# # input to hidden connection definition : -# # generating a statistical local con mask -# m = torch.zeros(784, 2500) -# for xi in range(28): -# for yi in range(28): -# for xo in range(50): -# for yo in range(50): -# dx = xi - xo -# dy = yi - yo -# m[xi + yi * 28, xo + 50 * yo] = dx * dx + dy * dy -# -# m = torch.sqrt(m) -# m /= m.max() -# m *= torch.rand(784, 2500) -# m = m > 0.5 -# -# in_hid_con = Connection( -# source=input_l, -# target=hidden_l, -# features={ -# 'mask': m, -# 'probability': { -# 'probabilities': 0.5 * torch.rand(784, 2500), -# 'update_rule': PostPre, -# 'nu': [1e-2, 0], -# 'norm': 0.25, -# 'range': [0.0, 0.5], -# }, -# 'weights': { -# 'w': 0.5 + 0.5 * torch.rand(784, 2500), -# }, -# 'delays': { -# 'delays': torch.rand(784, 2500), -# 'update_rule': MSTDP, # reward-modulated STDP -# 'nu': [1e-2, 1e-3], -# 'norm': 0.8, -# 'range': [0.0, 1.0] -# } -# } -# ) -# -# # hidden to output connection definition : -# hid_out_con = Connection( -# source=hidden_l, -# target=output_l, -# features={ -# 'weights': { -# 'w': torch.rand(784, 2500), -# } -# } -# ) -# -# # recurrent WTA connection on output definition : -# recurrent_con = Connection( -# source=output_l, -# target=output_l, -# features={ -# 'weights': { -# 'w': torch.ones(10, 10), -# } -# } -# ) -# -# model.add_connection(in_hid_con, source='X', target='H') -# model.add_connection(hid_out_con, source='H', target='Y') -# model.add_connection(recurrent_con, source='Y', target='Y') \ No newline at end of file diff --git a/bindsnet/network/topology.py b/bindsnet/network/topology.py index 0fe16fb7..7037d43d 100644 --- a/bindsnet/network/topology.py +++ b/bindsnet/network/topology.py @@ -1,8 +1,11 @@ from abc import ABC, abstractmethod from typing import Union, Tuple, Optional, Sequence +import warnings + import numpy as np import torch +from torch import device from torch.nn import Module, Parameter import torch.nn.functional as F from torch.nn.modules.utils import _pair @@ -114,6 +117,112 @@ def reset_state_variables(self) -> None: pass +class AbstractMulticompartmentConnection(ABC, Module): + # language=rst + """ + Abstract base method for connections between ``Nodes``. + """ + + def __init__( + self, + source: Nodes, + target: Nodes, + device: device, + pipeline: list = None, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for abstract base class for connection objects. + + :param source: A layer of nodes from which the connection originates. + :param target: A layer of nodes to which the connection connects. + :param device: The device which the connection will run on + :param pipeline: An ordered list of topology features to be used on the connection + """ + + super().__init__() + + #### General Assertions #### + assert isinstance(source, Nodes), "Source is not a Nodes object" + assert isinstance(target, Nodes), "Target is not a Nodes object" + + #### Assign class variables #### + self.source = source + self.target = target + self.device = device + self.pipeline = ( + [] if pipeline is None else pipeline + ) # <- *Ordered* executables for features + + # TODO: Make it so there can't be repeated names!!! + # Initialize feature index & prime + self.feature_index = ( + {} + ) # <- *Unordered* and named set of references for features + for feature in pipeline: + self.feature_index[feature.name] = feature + feature.prime_feature(connection=self, device=self.device, **kwargs) + + @abstractmethod + def compute(self, s: torch.Tensor) -> None: + # language=rst + """ + Compute pre-activations of downstream neurons given spikes of upstream neurons. + + :param s: Incoming spikes. + """ + pass + + @abstractmethod + def update(self, **kwargs) -> None: + # language=rst + """ + Compute connection's update rule. + + Keyword arguments: + + :param bool learning: Whether to allow connection updates. + """ + pass + + @abstractmethod + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the connection. + """ + pass + + def append_pipeline(self, feature) -> None: + # language=rst + """ + Append a feature to the pipeline + """ + self.pipeline.append(feature) + feature.prime_feature(connection=self, device=self.device) + self.feature_index[feature.name] = feature + + def insert_pipeline(self, feature, index) -> None: + # language=rst + """ + insert a feature into the pipeline + :param index: Index for where to insert the feature + """ + self.pipeline.insert(feature, index) + feature.prime_feature(connection=self, device=self.device) + self.feature_index[feature.name] = feature + + def remove_pipeline(self, feature) -> None: + # language=rst + """ + remove a feature frome the pipeline + :param feature: feature to be removed + """ + self.pipeline.remove(feature) + del self.feature_index[feature.name] + + class Connection(AbstractConnection): # language=rst """ @@ -243,6 +352,133 @@ def reset_state_variables(self) -> None: super().reset_state_variables() +class MulticompartmentConnection(AbstractMulticompartmentConnection): + # language=rst + """ + Specifies synapses between one or two populations of neurons. + """ + + def __init__( + self, + source: Nodes, + target: Nodes, + device: device, + pipeline: list = [], + manual_update: bool = False, + traces: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Instantiates a :code:`Connection` object. + + :param source: A layer of nodes from which the connection originates. + :param target: A layer of nodes to which the connection connects. + :param device: The device the connection will be run on. + :param list: Pipeline of features for the connection signals to be run through + :param manual_update: Set to :code:`True` to disable automatic updates (applying learning rules) to connection features. + False by default, updates called after each time step + :param traces: Set to :code:`True` to record history of connection activity (for monitors) + """ + + super().__init__(source, target, device, pipeline, **kwargs) + self.traces = traces + self.manual_update = manual_update + if self.traces: + self.activity = None + + def compute(self, s: torch.Tensor) -> torch.Tensor: + # language=rst + """ + Compute pre-activations given spikes using connection weights. + + :param s: Incoming spikes. + :return: Incoming spikes multiplied by synaptic weights (with or without + decaying spike activation). + """ + + # Change to numeric type (torch doesn't like booleans for matrix ops) + # Note: .float() is an expensive operation. Use as minimally as possible! + # if s.dtype != torch.float32: + # s = s.float() + + # Prepare broadcast from incoming spikes to all output neurons + # |conn_spikes| = [batch_size, source.n * target.n] + conn_spikes = s.view(s.size(0), self.source.n, 1).repeat(1, 1, self.target.n) + # TODO: ^ This could probably be optimized + + # Run through pipeline + for f in self.pipeline: + conn_spikes = f.compute(conn_spikes) + + # Sum signals for each of the output/terminal neurons + # |out_signal| = [batch_size, target.n] + out_signal = conn_spikes.view(s.size(0), self.source.n, self.target.n).sum(1) + + if self.traces: + self.activity = out_signal + + return out_signal.view(s.size(0), *self.target.shape) + + def compute_window(self, s: torch.Tensor) -> torch.Tensor: + # language=rst + """""" + + if self.s_w == None: + # Construct a matrix of shape batch size * window size * dimension of layer + self.s_w = torch.zeros( + self.target.batch_size, self.target.res_window_size, *self.source.shape + ) + + # Add the spike vector into the first in first out matrix of windowed (res) spike trains + self.s_w = torch.cat((self.s_w[:, 1:, :], s[:, None, :]), 1) + + # Compute multiplication of spike activations by weights and add bias. + if self.b is None: + post = ( + self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w + ) + else: + post = ( + self.s_w.view(self.s_w.size(0), self.s_w.size(1), -1).float() @ self.w + + self.b + ) + + return post.view( + self.s_w.size(0), self.target.res_window_size, *self.target.shape + ) + + def update(self, **kwargs) -> None: + # language=rst + """ + Compute connection's update rule. + """ + learning = kwargs.get("learning", False) + if learning and not self.manual_update: + # Pipeline learning + for f in self.pipeline: + f.update(**kwargs) + + def normalize(self) -> None: + # language=rst + """ + Normalize all features in the connection. + """ + # Normalize pipeline features + for f in self.pipeline: + f.normalize() + + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the connection. + """ + super().reset_state_variables() + + for f in self.pipeline: + f.reset_state_variables() + + class Conv2dConnection(AbstractConnection): # language=rst """ From 8a1a1d0d969330bd488c6d010a24803d54f2583c Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:51:02 -0400 Subject: [PATCH 08/27] reset state vars for Input nodes --- bindsnet/network/nodes.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/bindsnet/network/nodes.py b/bindsnet/network/nodes.py index 57ad0d94..ec332744 100644 --- a/bindsnet/network/nodes.py +++ b/bindsnet/network/nodes.py @@ -225,6 +225,8 @@ def reset_state_variables(self) -> None: """ Resets relevant state variables. """ + self.s.zero_() + self.v.zero_() super().reset_state_variables() From 4b577e906d0daab6ce3a8142306069b836541184 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 22:54:45 -0400 Subject: [PATCH 09/27] Add topology_features.py --- bindsnet/network/topology_features.py | 926 ++++++++++++++++++++++++++ 1 file changed, 926 insertions(+) create mode 100644 bindsnet/network/topology_features.py diff --git a/bindsnet/network/topology_features.py b/bindsnet/network/topology_features.py new file mode 100644 index 00000000..69d3bd5f --- /dev/null +++ b/bindsnet/network/topology_features.py @@ -0,0 +1,926 @@ +from abc import ABC, abstractmethod +from bindsnet.learning.learning import NoOp +from typing import Union, Tuple, Optional, Sequence + +import numpy as np +import torch +from torch import device +from torch.nn import Parameter +import torch.nn.functional as F +import torch.nn as nn +import bindsnet.learning + + +class AbstractFeature(ABC): + # language=rst + """ + Features to operate on signals traversing a connection. + """ + + @abstractmethod + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + range: Optional[Union[list, tuple]] = None, + clamp_frequency: Optional[int] = 1, + norm: Optional[Union[torch.Tensor, float, int]] = None, + learning_rule: Optional[bindsnet.learning.LearningRule] = None, + nu: Optional[Union[list, tuple, int, float]] = None, + reduction: Optional[callable] = None, + enforce_polarity: Optional[bool] = False, + decay: float = 0.0, + parent_feature=None, + **kwargs, + ) -> None: + # language=rst + """ + Instantiates a :code:`Feature` object. Will assign all incoming arguments as class variables + :param name: Name of the feature + :param value: Core numeric object for the feature. This parameters function will vary depending on the feature + :param range: Range of acceptable values for the :code:`value` parameter + :param norm: Value which all values in :code:`value` will sum to. Normalization of values occurs after each + sample and after the value has been updated by the learning rule (if there is one) + :param learning_rule: Rule which will modify the :code:`value` after each sample + :param nu: Learning rate for the learning rule + :param reduction: Method for reducing parameter updates along the minibatch + dimension + :param decay: Constant multiple to decay weights by on each iteration + :param parent_feature: Parent feature to inherit :code:`value` from + """ + + #### Initialize class variables #### + ## Args ## + self.name = name + self.value = value + self.range = [-1.0, 1.0] if range is None else range + self.clamp_frequency = clamp_frequency + self.norm = norm + self.learning_rule = learning_rule + self.nu = nu + self.reduction = reduction + self.decay = decay + self.parent_feature = parent_feature + self.kwargs = kwargs + + ## Backend ## + self.is_primed = False + + from ..learning import ( + NoOp, + PostPre, + WeightDependentPostPre, + Hebbian, + MSTDP, + MSTDPET, + Rmax, + ) + + supported_rules = [ + NoOp, + PostPre, + WeightDependentPostPre, + Hebbian, + MSTDP, + MSTDPET, + Rmax, + ] + + #### Assertions #### + # Assert correct instance of feature values + assert isinstance(name, str), "Feature {0}'s name should be of type str".format( + name + ) + assert value is None or isinstance( + value, (torch.Tensor, float, int) + ), "Feature {0} should be of type float, int, or torch.Tensor, not {1}".format( + name, type(value) + ) + assert norm is None or isinstance( + norm, (torch.Tensor, float, int) + ), "Feature {0}'s norm should be of type float, int, or torch.Tensor, not {1}".format( + name, type(norm) + ) + assert learning_rule is None or ( + learning_rule in supported_rules + ), "Feature {0}'s learning_rule should be of type bindsnet.LearningRule not {1}".format( + name, type(learning_rule) + ) + assert nu is None or isinstance( + nu, (list, tuple) + ), "Feature {0}'s nu should be of type list or tuple, not {1}".format( + name, type(nu) + ) + assert reduction is None or isinstance( + reduction, callable + ), "Feature {0}'s reduction should be of type callable, not {1}".format( + name, type(reduction) + ) + assert decay is None or isinstance( + decay, float + ), "Feature {0}'s decay should be of type float, not {1}".format( + name, type(decay) + ) + + self.assert_valid_range() + if value is not None: + self.assert_feature_in_range() + + @abstractmethod + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the feature. + """ + if self.learning_rule: + self.learning_rule.reset_state_variables() + pass + + @abstractmethod + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + # language=rst + """ + Computes the feature being operated on a set of incoming signals. + """ + pass + + def prime_feature(self, connection, device, **kwargs) -> None: + # language=rst + """ + Prepares a feature after it has been placed in a connection. This takes care of learning rules, feature + value initialization, and asserting that features have proper shape. Should occur after primary constructor. + """ + + # Note: DO NOT move NoOp to global; cyclical dependency + from ..learning import NoOp + + # Check if feature is already primed + if self.is_primed: + return + self.is_primed = True + + # Check if feature is a child feature + if self.parent_feature is not None: + self.link(self.parent_feature) + self.learning_rule = NoOp(connection=connection) + return + + # Check if values/norms are the correct shape + if isinstance(self.value, torch.Tensor): + assert tuple(self.value.shape) == (connection.source.n, connection.target.n) + + if self.norm is not None and isinstance(self.norm, torch.Tensor): + assert self.norm.shape[0] == connection.target.n + + #### Initialize feature value #### + if self.value is None: + self.value = ( + self.initialize_value() + ) # This should be defined per the sub-class + + if isinstance(self.value, (int, float)): + self.value = torch.Tensor([self.value]) + + # Parameterize and send to proper device + # Note: Floating is used here to avoid dtype conflicts + self.value = Parameter(self.value, requires_grad=False).to(device) + + ##### Initialize learning rule ##### + + # Default is NoOp + if self.learning_rule is None: + self.learning_rule = NoOp + + self.learning_rule = self.learning_rule( + connection=connection, + feature_value=self.value, + range=self.range, + nu=self.nu, + reduction=self.reduction, + decay=self.decay, + **kwargs, + ) + + #### Recycle unnecessary variables #### + del self.nu, self.reduction, self.decay, self.range + + def update(self, **kwargs) -> None: + # language=rst + """ + Compute feature's update rule + """ + + self.learning_rule.update(**kwargs) + + def normalize(self) -> None: + # language=rst + """ + Normalize feature so each target neuron has sum of feature values equal to + ``self.norm``. + """ + + if self.norm is not None: + abs_sum = self.value.sum(0).unsqueeze(0) + abs_sum[abs_sum == 0] = 1.0 + self.value *= self.norm / abs_sum + + def degrade(self) -> None: + # language=rst + """ + Degrade the value of the propagated spikes according to the features value. A lambda function should be passed + into the constructor which takes a single argument (which represent the value), and returns a value which will + be *subtracted* from the propagated spikes. + """ + + return self.degrade(self.value) + + def link(self, parent_feature) -> None: + # language=rst + """ + Allow two features to share tensor values + """ + + valid_features = (Probability, Weight, Bias, Intensity) + + assert isinstance(self, valid_features), f"A {self} cannot use feature linking" + assert isinstance( + parent_feature, valid_features + ), f"A {parent_feature} cannot use feature linking" + assert self.is_primed, f"Prime feature before linking: {self}" + assert ( + parent_feature.is_primed + ), f"Prime parent feature before linking: {parent_feature}" + + # Link values, disable learning for this feature + self.value = parent_feature.value + self.learning_rule = NoOp + + def assert_valid_range(self): + # language=rst + """ + Default range verifier (within [-1, +1]) + """ + + r = self.range + + ## Check dtype ## + assert isinstance( + self.range, (list, tuple) + ), f"Invalid range for feature {self.name}: range should be a list or tuple, not {type(self.range)}" + assert ( + len(r) == 2 + ), f"Invalid range for feature {self.name}: range should have a length of 2" + + ## Check min/max relation ## + if isinstance(r[0], torch.Tensor) or isinstance(r[1], torch.Tensor): + assert ( + r[0] < r[1] + ).all(), f"Invalid range for feature {self.name}: a min is larger than an adjacent max" + else: + assert ( + r[0] < r[1] + ), f"Invalid range for feature {self.name}: the min value is larger than the max value" + + def assert_feature_in_range(self): + r = self.range + f = self.value + + if isinstance(r[0], torch.Tensor) or isinstance(f, torch.Tensor): + assert ( + f >= r[0] + ).all(), f"Feature out of range for {self.name}: Features values not in [{r[0]}, {r[1]}]" + else: + assert ( + f >= r[0] + ), f"Feature out of range for {self.name}: Features values not in [{r[0]}, {r[1]}]" + + if isinstance(r[1], torch.Tensor) or isinstance(f, torch.Tensor): + assert ( + f <= r[1] + ).all(), f"Feature out of range for {self.name}: Features values not in [{r[0]}, {r[1]}]" + else: + assert ( + f <= r[1] + ), f"Feature out of range for {self.name}: Features values not in [{r[0]}, {r[1]}]" + + def assert_valid_shape(self, source_shape, target_shape, f): + # Multidimensional feat + if len(f.shape) > 1: + assert f.shape == ( + source_shape, + target_shape, + ), f"Feature {self.name} has an incorrect shape of {f.shape}. Should be of shape {(source_shape, target_shape)}" + # Else assume scalar, which is a valid shape + + +class Probability(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + range: Optional[Sequence[float]] = None, + norm: Optional[Union[torch.Tensor, float, int]] = None, + learning_rule: Optional[bindsnet.learning.LearningRule] = None, + nu: Optional[Union[list, tuple]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + parent_feature=None, + ) -> None: + # language=rst + """ + Will run a bernoulli trial using :code:`value` to determine if a signal will successfully traverse the synapse + :param name: Name of the feature + :param value: Number(s) in [0, 1] which represent the probability of a signal traversing a synapse. Tensor values + assume that probabilities will be matched to adjacent synapses in the connection. Scalars will be applied to + all synapses. + :param range: Range of acceptable values for the :code:`value` parameter. Should be in [0, 1] + :param norm: Value which all values in :code:`value` will sum to. Normalization of values occurs after each sample + and after the value has been updated by the learning rule (if there is one) + :param learning_rule: Rule which will modify the :code:`value` after each sample + :param nu: Learning rate for the learning rule + :param reduction: Method for reducing parameter updates along the minibatch + dimension + :param decay: Constant multiple to decay weights by on each iteration + :param parent_feature: Parent feature to inherit :code:`value` from + """ + + ### Assertions ### + super().__init__( + name=name, + value=value, + range=[0, 1] if range is None else range, + norm=norm, + learning_rule=learning_rule, + nu=nu, + reduction=reduction, + decay=decay, + parent_feature=parent_feature, + ) + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + return conn_spikes * torch.bernoulli(self.value) + + def reset_state_variables(self) -> None: + pass + + def prime_feature(self, connection, device, **kwargs) -> None: + ## Initialize value ### + if self.value is None: + self.initialize_value = lambda: torch.clamp( + torch.rand(connection.source.n, connection.target.n, device=device), + self.range[0], + self.range[1], + ) + + super().prime_feature(connection, device, **kwargs) + + def assert_valid_range(self): + super().assert_valid_range() + + r = self.range + + ## Check min greater than 0 ## + if isinstance(r[0], torch.Tensor): + assert ( + r[0] >= 0 + ).all(), ( + f"Invalid range for feature {self.name}: a min value is less than 0" + ) + elif isinstance(r[0], (float, int)): + assert ( + r[0] >= 0 + ), f"Invalid range for feature {self.name}: the min value is less than 0" + else: + assert ( + False + ), f"Invalid range for feature {self.name}: the min value must be of type torch.Tensor, float, or int" + + +class Mask(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + ) -> None: + # language=rst + """ + Boolean mask which determines whether or not signals are allowed to traverse certain synapses. + :param name: Name of the feature + :param value: Boolean mask. :code:`True` means a signal can pass, :code:`False` means the synapse is impassable + """ + + ### Assertions ### + if isinstance(value, torch.Tensor): + assert ( + value.dtype == torch.bool + ), "Mask must be of type bool, not {}".format(value.dtype) + elif value is not None: + assert isinstance(value, bool), "Mask must be of type bool, not {}".format( + value.dtype + ) + + # Send boolean to tensor (priming wont work if it's not a tensor) + value = torch.tensor(value) + + super().__init__( + name=name, + value=value, + ) + + self.name = name + self.value = value + + def compute(self, conn_spikes) -> torch.Tensor: + return conn_spikes * self.value + + def reset_state_variables(self) -> None: + pass + + def prime_feature(self, connection, device, **kwargs) -> None: + # Check if feature is already primed + if self.is_primed: + return + self.is_primed = True + + #### Initialize feature value #### + if self.value is None: + self.value = ( + torch.rand(connection.source.n, connection.target.n) > 0.99 + ).to(device=device) + self.value = Parameter(self.value, requires_grad=False).to(device) + + #### Assertions #### + # Check if tensor values are the correct shape + if isinstance(self.value, torch.Tensor): + self.assert_valid_shape( + connection.source.n, connection.target.n, self.value + ) + + ##### Initialize learning rule ##### + # Note: DO NOT move NoOp to global; cyclical dependency + from ..learning import NoOp + + # Default is NoOp + if self.learning_rule is None: + self.learning_rule = NoOp + + self.learning_rule = self.learning_rule( + connection=connection, + feature=self.value, + range=self.range, + nu=self.nu, + reduction=self.reduction, + decay=self.decay, + **kwargs, + ) + + +class MeanField(AbstractFeature): + def __init__(self) -> None: + # language=rst + """ + Takes the mean of all outgoing signals, and outputs that mean across every synapse in the connection + """ + pass + + def reset_state_variables(self) -> None: + pass + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + return conn_spikes.mean() * torch.ones( + self.source_n * self.target_n, device=self.device + ) + + def prime_feature(self, connection, device, **kwargs) -> None: + self.source_n = connection.source.n + self.target_n = connection.target.n + + super().prime_feature(connection, device, **kwargs) + + +class Weight(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + range: Optional[Sequence[float]] = None, + norm: Optional[Union[torch.Tensor, float, int]] = None, + norm_frequency: Optional[str] = "sample", + learning_rule: Optional[bindsnet.learning.LearningRule] = None, + nu: Optional[Union[list, tuple]] = None, + reduction: Optional[callable] = None, + enforce_polarity: Optional[bool] = False, + decay: float = 0.0, + ) -> None: + # language=rst + """ + Multiplies signals by scalars + :param name: Name of the feature + :param value: Values to scale signals by + :param range: Range of acceptable values for the :code:`value` parameter + :param norm: Value which all values in :code:`value` will sum to. Normalization of values occurs after each sample + and after the value has been updated by the learning rule (if there is one) + :param norm_frequency: How often to normalize weights: + * 'sample': weights normalized after each sample + * 'time step': weights normalized after each time step + :param learning_rule: Rule which will modify the :code:`value` after each sample + :param nu: Learning rate for the learning rule + :param reduction: Method for reducing parameter updates along the minibatch + dimension + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + :param decay: Constant multiple to decay weights by on each iteration + """ + + self.norm_frequency = norm_frequency + self.enforce_polarity = enforce_polarity + super().__init__( + name=name, + value=value, + range=[-torch.inf, +torch.inf] if range is None else range, + norm=norm, + learning_rule=learning_rule, + nu=nu, + reduction=reduction, + decay=decay, + ) + + def reset_state_variables(self) -> None: + pass + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + if self.enforce_polarity: + pos_mask = ~torch.logical_xor(self.value > 0, self.positive_mask) + neg_mask = ~torch.logical_xor(self.value < 0, ~self.positive_mask) + self.value = self.value * torch.logical_or(pos_mask , neg_mask) + self.value[~pos_mask] = 0.0001 + self.value[~neg_mask] = -0.0001 + + return_val = self.value * conn_spikes + if self.norm_frequency == "time step": + self.normalize(time_step_norm=True) + + return return_val + + def prime_feature(self, connection, device, **kwargs) -> None: + #### Initialize value #### + if self.value is None: + self.initialize_value = lambda: torch.rand( + connection.source.n, connection.target.n + ) + + super().prime_feature( + connection, device, enforce_polarity=self.enforce_polarity, **kwargs + ) + if self.enforce_polarity: + self.positive_mask = ((self.value > 0).sum(1) / self.value.shape[1]) >0.5 + tmp = torch.zeros_like(self.value) + tmp[self.positive_mask,:] = 1 + self.positive_mask = tmp.bool() + + + + def normalize(self, time_step_norm=False) -> None: + # 'time_step_norm' will indicate if normalize is being called from compute() + # or from network.py (after a sample is completed) + + if self.norm_frequency == "time step" and time_step_norm: + super().normalize() + + if self.norm_frequency == "sample" and not time_step_norm: + super().normalize() + + +class Bias(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + range: Optional[Sequence[float]] = None, + norm: Optional[Union[torch.Tensor, float, int]] = None, + ) -> None: + # language=rst + """ + Adds scalars to signals + :param name: Name of the feature + :param value: Values to add to the signals + :param range: Range of acceptable values for the :code:`value` parameter + :param norm: Value which all values in :code:`value` will sum to. Normalization of values occurs after each sample + and after the value has been updated by the learning rule (if there is one) + """ + + super().__init__( + name=name, + value=value, + range=[-torch.inf, +torch.inf] if range is None else range, + norm=norm, + ) + + def reset_state_variables(self) -> None: + pass + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + return conn_spikes + self.value + + def prime_feature(self, connection, device, **kwargs) -> None: + #### Initialize value #### + if self.value is None: + self.initialize_value = lambda: torch.rand( + connection.source.n, connection.target.n + ) + + super().prime_feature(connection, device, **kwargs) + + +class Intensity(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + range: Optional[Sequence[float]] = None, + ) -> None: + # language=rst + """ + Adds scalars to signals + :param name: Name of the feature + :param value: Values to scale signals by + """ + + super().__init__(name=name, value=value, range=range) + + def reset_state_variables(self) -> None: + pass + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + return conn_spikes * self.value + + def prime_feature(self, connection, device, **kwargs) -> None: + #### Initialize value #### + if self.value is None: + self.initialize_value = lambda: torch.clamp( + torch.sign( + torch.randint(-1, +2, (connection.source.n, connection.target.n)) + ), + self.range[0], + self.range[1], + ) + + super().prime_feature(connection, device, **kwargs) + + +class Degradation(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + degrade_function: callable = None, + parent_feature: Optional[AbstractFeature] = None, + ) -> None: + # language=rst + """ + Degrades propagating spikes according to :code:`degrade_function`. + Note: If :code:`parent_feature` is provided, it will override :code:`value`. + :param name: Name of the feature + :param value: Value used to degrade feature + :param degrade_function: Callable function which takes a single argument (:code:`value`) and returns a tensor or + constant to be *subtracted* from the propagating spikes. + :param parent_feature: Parent feature with desired :code:`value` to inherit + """ + + # Note: parent_feature will override value. See abstract constructor + super().__init__(name=name, value=value, parent_feature=parent_feature) + + self.degrade_function = degrade_function + + def reset_state_variables(self) -> None: + pass + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + return conn_spikes - self.degrade_function(self.value) + + +class AdaptationBaseSynapsHistory(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + ann_values: Union[list, tuple] = None, + const_update_rate: float = 0.1, + const_decay: float = 0.001, + ) -> None: + # language=rst + """ + The ANN will be use on each synaps to messure the previous activity of the neuron and descide to close or open connection. + + :param name: Name of the feature + :param ann_values: Values to be use to build an ANN that will adapt the connectivity of the layer. + :param value: Values to be use to build an initial mask for the synapses. + :param const_update_rate: The mask upatate rate of the ANN decision. + :param const_decay: The spontaneous activation of the synapses. + """ + + #Define the ANN + class ANN(nn.Module): + def __init__(self, input_size, hidden_size, output_size): + super(ANN, self).__init__() + self.fc1 = nn.Linear(input_size, hidden_size, bias=False) + self.fc2 = nn.Linear(hidden_size, output_size, bias=False) + + def forward(self, x): + x = torch.relu(self.fc1(x)) + x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 + return x + + self.init_value = value.clone().detach() # initial mask + self.mask = value # final decision of the ANN + value = torch.zeros_like(value) # initial mask + self.ann = ANN(ann_values[0].shape[0], ann_values[0].shape[1], 1) + + # load weights from ann_values + with torch.no_grad(): + self.ann.fc1.weight.data = ann_values[0] + self.ann.fc2.weight.data = ann_values[1] + self.ann.to(ann_values[0].device) + + self.spike_buffer = torch.zeros((value.numel(), ann_values[0].shape[1]), device=ann_values[0].device, dtype=torch.bool) + self.counter = 0 + self.start_counter = False + self.const_update_rate = const_update_rate + self.const_decay = const_decay + + super().__init__(name=name, value=value) + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + + # Update the spike buffer + if self.start_counter == False or conn_spikes.sum() > 0: + self.start_counter = True + self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = conn_spikes.flatten() + self.counter += 1 + + # Update the masks + if self.counter % self.spike_buffer.shape[1] == 0 : + with torch.no_grad(): + ann_decision = self.ann(self.spike_buffer.to(torch.float32)) + self.mask += ann_decision.view(self.mask.shape) * self.const_update_rate # update mask with learning rate fraction + self.mask += self.const_decay # spontaneous activate synapses + self.mask = torch.clamp(self.mask, -1, 1) # cap the mask + + # self.mask = torch.clamp(self.mask, -1, 1) + self.value = (self.mask > 0).float() + + return conn_spikes * self.value + + def reset_state_variables(self, ): + self.spike_buffer = torch.zeros_like(self.spike_buffer) + self.counter = 0 + self.start_counter = False + self.value = self.init_value.clone().detach() # initial mask + pass + +class AdaptationBaseOtherSynaps(AbstractFeature): + def __init__( + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + ann_values: Union[list, tuple] = None, + const_update_rate: float = 0.1, + const_decay: float = 0.01, + ) -> None: + # language=rst + """ + The ANN will be use on each synaps to messure the previous activity of the neuron and descide to close or open connection. + + :param name: Name of the feature + :param ann_values: Values to be use to build an ANN that will adapt the connectivity of the layer. + :param value: Values to be use to build an initial mask for the synapses. + :param const_update_rate: The mask upatate rate of the ANN decision. + :param const_decay: The spontaneous activation of the synapses. + """ + + #Define the ANN + class ANN(nn.Module): + def __init__(self, input_size, hidden_size, output_size): + super(ANN, self).__init__() + self.fc1 = nn.Linear(input_size, hidden_size, bias=False) + self.fc2 = nn.Linear(hidden_size, output_size, bias=False) + + def forward(self, x): + x = torch.relu(self.fc1(x)) + x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 + return x + + self.init_value = value.clone().detach() # initial mask + self.mask = value # final decision of the ANN + value = torch.zeros_like(value) # initial mask + self.ann = ANN(ann_values[0].shape[0], ann_values[0].shape[1], 1) + + # load weights from ann_values + with torch.no_grad(): + self.ann.fc1.weight.data = ann_values[0] + self.ann.fc2.weight.data = ann_values[1] + self.ann.to(ann_values[0].device) + + self.spike_buffer = torch.zeros((value.numel(), ann_values[0].shape[1]), device=ann_values[0].device, dtype=torch.bool) + self.counter = 0 + self.start_counter = False + self.const_update_rate = const_update_rate + self.const_decay = const_decay + + super().__init__(name=name, value=value) + + def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: + + # Update the spike buffer + if self.start_counter == False or conn_spikes.sum() > 0: + self.start_counter = True + self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = conn_spikes.flatten() + self.counter += 1 + + # Update the masks + if self.counter % self.spike_buffer.shape[1] == 0 : + with torch.no_grad(): + ann_decision = self.ann(self.spike_buffer.to(torch.float32)) + self.mask += ann_decision.view(self.mask.shape) * self.const_update_rate # update mask with learning rate fraction + self.mask += self.const_decay # spontaneous activate synapses + self.mask = torch.clamp(self.mask, -1, 1) # cap the mask + + # self.mask = torch.clamp(self.mask, -1, 1) + self.value = (self.mask > 0).float() + + return conn_spikes * self.value + + def reset_state_variables(self, ): + self.spike_buffer = torch.zeros_like(self.spike_buffer) + self.counter = 0 + self.start_counter = False + self.value = self.init_value.clone().detach() # initial mask + pass + +### Sub Features ### + + +class AbstractSubFeature(ABC): + # language=rst + """ + A way to inject a features methods (like normalization, learning, etc.) into the pipeline for user controlled + execution. + """ + + @abstractmethod + def __init__( + self, + name: str, + parent_feature: AbstractFeature, + ) -> None: + # language=rst + """ + Instantiates a :code:`Augment` object. Will assign all incoming arguments as class variables. + :param name: Name of the augment + :param parent_feature: Primary feature which the augment will modify + """ + + self.name = name + self.parent = parent_feature + self.sub_feature = None # <-- Defined in non-abstract constructor + + def compute(self, _) -> None: + # language=rst + """ + Proxy function to catch a pipeline execution from topology.py's :code:`compute` function. Allows :code:`SubFeature` + objects to be executed like real features in the pipeline. + """ + + # sub_feature should be defined in the non-abstract constructor + self.sub_feature() + + +class Normalization(AbstractSubFeature): + # language=rst + """ + Normalize parent features values so each target neuron has sum of feature values equal to a desired value :code:`norm`. + """ + + def __init__( + self, + name: str, + parent_feature: AbstractFeature, + ) -> None: + super().__init__(name, parent_feature) + + self.sub_feature = self.parent.normalize + + +class Updating(AbstractSubFeature): + # language=rst + """ + Update parent features values using the assigned update rule. + """ + + def __init__( + self, + name: str, + parent_feature: AbstractFeature, + ) -> None: + super().__init__(name, parent_feature) + + self.sub_feature = self.parent.update From 9d1139ae3d4390db2f147eb41ca82d78e7f88c31 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 23:17:01 -0400 Subject: [PATCH 10/27] Update monitors.py --- bindsnet/network/monitors.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/bindsnet/network/monitors.py b/bindsnet/network/monitors.py index c5b19a5d..f32dd0db 100644 --- a/bindsnet/network/monitors.py +++ b/bindsnet/network/monitors.py @@ -6,7 +6,8 @@ from typing import Union, Optional, Iterable, Dict from .nodes import Nodes -from .topology import AbstractConnection +from .topology import AbstractConnection, AbstractMulticompartmentConnection +from .topology_features import AbstractFeature class AbstractMonitor(ABC): @@ -24,7 +25,7 @@ class Monitor(AbstractMonitor): def __init__( self, - obj: Union[Nodes, AbstractConnection], + obj: Union[Nodes, AbstractMulticompartmentConnection, AbstractFeature], state_vars: Iterable[str], time: Optional[int] = None, batch_size: int = 1, @@ -169,7 +170,7 @@ def __init__( self.time, *getattr(self.network.connections[c], v).size() ) - def get(self) -> Dict[str, Dict[str, Union[Nodes, AbstractConnection]]]: + def get(self) -> Dict[str, Dict[str, Union[Nodes, AbstractConnection, AbstractMulticompartmentConnection, AbstractFeature]]]: # language=rst """ Return entire recording to user. From 6ad2ce28c615a43e266d636d6c1128261004ed33 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 2 Sep 2024 23:21:38 -0400 Subject: [PATCH 11/27] Revert changes to Input --- bindsnet/network/nodes.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/bindsnet/network/nodes.py b/bindsnet/network/nodes.py index ec332744..57ad0d94 100644 --- a/bindsnet/network/nodes.py +++ b/bindsnet/network/nodes.py @@ -225,8 +225,6 @@ def reset_state_variables(self) -> None: """ Resets relevant state variables. """ - self.s.zero_() - self.v.zero_() super().reset_state_variables() From 63682025ef25c4761f6b194b872a2e33db142411 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 3 Sep 2024 09:30:39 -0400 Subject: [PATCH 12/27] Add new learning file for multicompartment connections --- bindsnet/learning/MCC_learning.py | 693 ++++++++++++++++++++++++++++++ 1 file changed, 693 insertions(+) create mode 100644 bindsnet/learning/MCC_learning.py diff --git a/bindsnet/learning/MCC_learning.py b/bindsnet/learning/MCC_learning.py new file mode 100644 index 00000000..105f7bdf --- /dev/null +++ b/bindsnet/learning/MCC_learning.py @@ -0,0 +1,693 @@ +from abc import ABC, abstractmethod +from typing import Union, Optional, Sequence +import warnings + +import torch +import numpy as np + +from ..network.nodes import SRM0Nodes +from ..network.topology import ( + AbstractMulticompartmentConnection, + MulticompartmentConnection, +) +from ..utils import im2col_indices + + +class MCC_LearningRule(ABC): + # language=rst + """ + Abstract base class for learning rules. + """ + + def __init__( + self, + connection: AbstractMulticompartmentConnection, + # TODO: Will not work properly with primitive types int/float (not by reference) + feature_value: Union[float, int, torch.Tensor], + range: Optional[Union[list, tuple]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Abstract constructor for the ``LearningRule`` object. + + :param connection: An ``AbstractConnection`` object. + :param feature_value: Value(s) to be updated. Can be only tensor (scalar currently not supported) + :param range: Allowed range for :code:`feature_value` + :param nu: Single or pair of learning rates for pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the batch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + """ + # Connection parameters. + self.connection = connection + self.source = connection.source + self.target = connection.target + self.feature_value = feature_value + self.enforce_polarity = enforce_polarity + self.min, self.max = range + + # Learning rate(s). + if nu is None: + nu = [0.2, 0.1] + elif isinstance(nu, (float, int)): + nu = [nu, nu] + + # Keep track of polarities + if enforce_polarity: + self.polarities = torch.sign(self.feature_value) + + self.nu = torch.zeros(2, dtype=torch.float) + self.nu[0] = nu[0] + self.nu[1] = nu[1] + + if (self.nu == torch.zeros(2)).all() and not isinstance(self, NoOp): + warnings.warn( + f"nu is set to [0., 0.] for {type(self).__name__} learning rule. " + + "It will disable the learning process." + ) + + # Parameter update reduction across minibatch dimension. + if reduction is None: + if self.source.batch_size == 1: + self.reduction = torch.squeeze + else: + self.reduction = torch.sum + else: + self.reduction = reduction + + # Weight decay. + self.decay = 1.0 - decay if decay else 1.0 + + def update(self, **kwargs) -> None: + # language=rst + """ + Abstract method for a learning rule update. + """ + + # Implement decay. + if self.decay: + self.feature_value *= self.decay + + # Enforce polarities + if self.enforce_polarity: + polarity_swaps = self.polarities == torch.sign(self.feature_value) + self.feature_value[polarity_swaps == 0] = 0 + + # TODO: FIX THIS + # Bound weights. + if ((self.min is not None) or (self.max is not None)) and not isinstance( + self, NoOp + ): + self.feature_value.clamp_(self.min, self.max) + + @abstractmethod + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the feature. + """ + pass + + +class NoOp(MCC_LearningRule): + # language=rst + """ + Learning rule with no effect. + """ + + def __init__(self, **args) -> None: + # language=rst + """ + No operation done during runtime + """ + pass + + def update(self, **kwargs) -> None: + # language=rst + """ + No operation done during runtime + """ + pass + + def reset_state_variables(self) -> None: + # language=rst + """ + Contains resetting logic for the feature. + """ + pass + + +class PostPre(MCC_LearningRule): + # language=rst + """ + Simple STDP rule involving both pre- and post-synaptic spiking activity. By default, + pre-synaptic update is negative and the post-synaptic update is positive. + """ + + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``PostPre`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``PostPre`` learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the batch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + + Keyword arguments: + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, + ) + + assert self.source.traces and self.target.traces, ( + "Both pre- and post-synaptic nodes must record spike traces " + "(use traces='True' on source/target layers)" + ) + + if isinstance( + connection, (MulticompartmentConnection) + ): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) + + if self.average_update > 0: + self.average_buffer_pre = torch.zeros( + self.average_update, *self.feature_value.shape, device=self.feature_value.device + ) + self.average_buffer_post = torch.zeros_like(self.average_buffer_pre) + self.average_buffer_index_pre = 0 + self.average_buffer_index_post = 0 + + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + Post-pre learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + """ + batch_size = self.source.batch_size + + # Pre-synaptic update. + if self.nu[0]: + source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() + target_x = self.target.x.view(batch_size, -1).unsqueeze(1) * self.nu[0] + + if self.average_update > 0: + self.average_buffer_pre[self.average_buffer_index_pre] = ( + self.reduction(torch.bmm(source_s, target_x), dim=0) + ) + + self.average_buffer_index_pre = (self.average_buffer_index_pre + 1) % self.average_update + + if self.continues_update: + self.feature_value -= torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt + elif self.average_buffer_index_pre == 0: + self.feature_value -= torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt + else: + self.feature_value -= self.reduction(torch.bmm(source_s, target_x), dim=0) * self.connection.dt + del source_s, target_x + + # Post-synaptic update. + if self.nu[1]: + target_s = ( + self.target.s.view(batch_size, -1).unsqueeze(1).float() * self.nu[1] + ) + source_x = self.source.x.view(batch_size, -1).unsqueeze(2) + + if self.average_update > 0: + self.average_buffer_post[self.average_buffer_index_post] = ( + self.reduction(torch.bmm(source_x, target_s), dim=0) + ) + + self.average_buffer_index_post = (self.average_buffer_index_post + 1) % self.average_update + + if self.continues_update: + self.feature_value += torch.mean(self.average_buffer_post, dim=0) * self.connection.dt + elif self.average_buffer_index_post == 0: + self.feature_value += torch.mean(self.average_buffer_post, dim=0) * self.connection.dt + else: + self.feature_value += self.reduction(torch.bmm(source_x, target_s), dim=0) * self.connection.dt + del source_x, target_s + + super().update() + + def reset_state_variables(self): + return + + class Hebbian(MCC_LearningRule): + # language=rst + """ + Simple Hebbian learning rule. Pre- and post-synaptic updates are both positive. + """ + + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``Hebbian`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``Hebbian`` learning rule will modify. + :param nu: Single or pair of learning rates for pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the batch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + """ + super().__init__( + connection=connection, + feature_value=feature_value, + nu=nu, + reduction=reduction, + decay=decay, + **kwargs, + ) + + assert ( + self.source.traces and self.target.traces + ), "Both pre- and post-synaptic nodes must record spike traces." + + if isinstance(MulticompartmentConnection): + self.update = self._connection_update + self.feature_value = feature_value + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + Hebbian learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + """ + + # Add polarities back to feature after updates + if self.enforce_polarity: + self.feature_value = torch.abs(self.feature_value) + + batch_size = self.source.batch_size + + source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() + source_x = self.source.x.view(batch_size, -1).unsqueeze(2) + target_s = self.target.s.view(batch_size, -1).unsqueeze(1).float() + target_x = self.target.x.view(batch_size, -1).unsqueeze(1) + + # Pre-synaptic update. + update = self.reduction(torch.bmm(source_s, target_x), dim=0) + self.feature_value += self.nu[0] * update + + # Post-synaptic update. + update = self.reduction(torch.bmm(source_x, target_s), dim=0) + self.feature_value += self.nu[1] * update + + # Add polarities back to feature after updates + if self.enforce_polarity: + self.feature_value = self.feature_value * self.polarities + + super().update() + + def reset_state_variables(self): + return + + +class MSTDP(MCC_LearningRule): + # language=rst + """ + Reward-modulated STDP. Adapted from `(Florian 2007) + `_. + """ + + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``MSTDP`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the ``MSTDP`` + learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events, + respectively. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + + Keyword arguments: + + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + + :param tc_plus: Time constant for pre-synaptic firing trace. + :param tc_minus: Time constant for post-synaptic firing trace. + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, + ) + + if isinstance( + connection, (MulticompartmentConnection) + ): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + self.tc_plus = torch.tensor(kwargs.get("tc_plus", 20.0)) + self.tc_minus = torch.tensor(kwargs.get("tc_minus", 20.0)) + + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) + + if self.average_update > 0: + self.average_buffer = torch.zeros( + self.average_update, *self.feature_value.shape, device=self.feature_value.device + ) + self.average_buffer_index = 0 + + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + MSTDP learning rule for ``Connection`` subclass of ``AbstractConnection`` class. + + Keyword arguments: + + :param Union[float, torch.Tensor] reward: Reward signal from reinforcement + learning task. + :param float a_plus: Learning rate (post-synaptic). + :param float a_minus: Learning rate (pre-synaptic). + """ + batch_size = self.source.batch_size + + # Initialize eligibility, P^+, and P^-. + if not hasattr(self, "p_plus"): + self.p_plus = torch.zeros( + # batch_size, *self.source.shape, device=self.source.s.device + batch_size, + self.source.n, + device=self.source.s.device, + ) + if not hasattr(self, "p_minus"): + self.p_minus = torch.zeros( + # batch_size, *self.target.shape, device=self.target.s.device + batch_size, + self.target.n, + device=self.target.s.device, + ) + if not hasattr(self, "eligibility"): + self.eligibility = torch.zeros( + batch_size, *self.feature_value.shape, device=self.feature_value.device + ) + + # Reshape pre- and post-synaptic spikes. + source_s = self.source.s.view(batch_size, -1).float() + target_s = self.target.s.view(batch_size, -1).float() + + # Parse keyword arguments. + reward = kwargs["reward"] + a_plus = torch.tensor( + kwargs.get("a_plus", 1.0), device=self.feature_value.device + ) + a_minus = torch.tensor( + kwargs.get("a_minus", -1.0), device=self.feature_value.device + ) + + # Compute weight update based on the eligibility value of the past timestep. + update = reward * self.eligibility + + if self.average_update > 0: + self.average_buffer[self.average_buffer_index] = self.reduction(update, dim=0) + self.average_buffer_index = (self.average_buffer_index + 1) % self.average_update + + if self.continues_update: + self.feature_value += self.nu[0] * torch.mean(self.average_buffer, dim=0) + elif self.average_buffer_index == 0: + self.feature_value += self.nu[0] * torch.mean(self.average_buffer, dim=0) + else: + self.feature_value += self.nu[0] * self.reduction(update, dim=0) + + # Update P^+ and P^- values. + self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) + self.p_plus += a_plus * source_s + self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) + self.p_minus += a_minus * target_s + + # Calculate point eligibility value. + self.eligibility = torch.bmm( + self.p_plus.unsqueeze(2), target_s.unsqueeze(1) + ) + torch.bmm(source_s.unsqueeze(2), self.p_minus.unsqueeze(1)) + + super().update() + + def reset_state_variables(self): + return + + +class MSTDPET(MCC_LearningRule): + # language=rst + """ + Reward-modulated STDP with eligibility trace. Adapted from + `(Florian 2007) `_. + """ + + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``MSTDPET`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``MSTDPET`` learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events, + respectively. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + + Keyword arguments: + + :param float tc_plus: Time constant for pre-synaptic firing trace. + :param float tc_minus: Time constant for post-synaptic firing trace. + :param float tc_e_trace: Time constant for the eligibility trace. + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, + ) + + if isinstance( + connection, (MulticompartmentConnection) + ): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + self.tc_plus = torch.tensor( + kwargs.get("tc_plus", 20.0) + ) # How long pos reinforcement effects weights + self.tc_minus = torch.tensor( + kwargs.get("tc_minus", 20.0) + ) # How long neg reinforcement effects weights + self.tc_e_trace = torch.tensor( + kwargs.get("tc_e_trace", 25.0) + ) # How long trace effects weights + self.eligibility = torch.zeros( + *self.feature_value.shape, device=self.feature_value.device + ) + self.eligibility_trace = torch.zeros( + *self.feature_value.shape, device=self.feature_value.device + ) + + # Initialize eligibility, eligibility trace, P^+, and P^-. + if not hasattr(self, "p_plus"): + self.p_plus = torch.zeros((self.source.n), device=self.feature_value.device) + if not hasattr(self, "p_minus"): + self.p_minus = torch.zeros((self.target.n), device=self.feature_value.device) + + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) + if self.average_update > 0: + self.average_buffer = torch.zeros( + self.average_update, *self.feature_value.shape, device=self.feature_value.device + ) + self.average_buffer_index = 0 + + # @profile + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + MSTDPET learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + + Keyword arguments: + + :param Union[float, torch.Tensor] reward: Reward signal from reinforcement + learning task. + :param float a_plus: Learning rate (post-synaptic). + :param float a_minus: Learning rate (pre-synaptic). + """ + # Reshape pre- and post-synaptic spikes. + source_s = self.source.s.view(-1).float() + target_s = self.target.s.view(-1).float() + + # Parse keyword arguments. + reward = kwargs["reward"] + a_plus = kwargs.get("a_plus", 1.0) + # if isinstance(a_plus, dict): + # for k, v in a_plus.items(): + # a_plus[k] = torch.tensor(v, device=self.feature_value.device) + # else: + a_plus = torch.tensor(a_plus, device=self.feature_value.device) + a_minus = kwargs.get("a_minus", -1.0) + # if isinstance(a_minus, dict): + # for k, v in a_minus.items(): + # a_minus[k] = torch.tensor(v, device=self.feature_value.device) + # else: + a_minus = torch.tensor(a_minus, device=self.feature_value.device) + + # Calculate value of eligibility trace based on the value + # of the point eligibility value of the past timestep. + # Note: eligibility = [source.n, target.n] > 0 where source and target spiked + # Note: high negs. -> + self.eligibility_trace *= torch.exp( + -self.connection.dt / self.tc_e_trace + ) # Decay + self.eligibility_trace += self.eligibility / self.tc_e_trace # Additive changes + # ^ Also effected by delay in last step + + # Compute weight update. + + if self.average_update > 0: + self.average_buffer[self.average_buffer_index] = ( + self.nu[0] * self.connection.dt * reward * self.eligibility_trace + ) + self.average_buffer_index = (self.average_buffer_index + 1) % self.average_update + + if self.continues_update: + self.feature_value += torch.mean(self.average_buffer, dim=0) + elif self.average_buffer_index == 0: + self.feature_value += torch.mean(self.average_buffer, dim=0) + else: + self.feature_value += ( + self.nu[0] * self.connection.dt * reward * self.eligibility_trace + ) + + # Update P^+ and P^- values. + self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) # Decay + self.p_plus += a_plus * source_s # Scaled source spikes + self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) # Decay + self.p_minus += a_minus * target_s # Scaled target spikes + + # Notes: + # + # a_plus -> How much a spike in src contributes to the eligibility + # a_minus -> How much a spike in trg contributes to the eligibility (neg) + # p_plus -> +a_plus every spike, with decay + # p_minus -> +a_minus every spike, with decay + + # Calculate point eligibility value. + self.eligibility = torch.outer(self.p_plus, target_s) + torch.outer( + source_s, self.p_minus + ) + + super().update() + + def reset_state_variables(self) -> None: + self.eligibility.zero_() + self.eligibility_trace.zero_() + return \ No newline at end of file From fe99de3839b11de7f436d8f4714f76745ff85b46 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 3 Sep 2024 10:29:55 -0400 Subject: [PATCH 13/27] Added MCC reservoir --- bindsnet/learning/MCC_learning.py | 2 +- bindsnet/network/topology_features.py | 12 +- examples/mnist/MCC_reservoir.py | 309 ++++++++++++++++++++++++++ 3 files changed, 313 insertions(+), 10 deletions(-) create mode 100644 examples/mnist/MCC_reservoir.py diff --git a/bindsnet/learning/MCC_learning.py b/bindsnet/learning/MCC_learning.py index 105f7bdf..822a8437 100644 --- a/bindsnet/learning/MCC_learning.py +++ b/bindsnet/learning/MCC_learning.py @@ -690,4 +690,4 @@ def _connection_update(self, **kwargs) -> None: def reset_state_variables(self) -> None: self.eligibility.zero_() self.eligibility_trace.zero_() - return \ No newline at end of file + return diff --git a/bindsnet/network/topology_features.py b/bindsnet/network/topology_features.py index 69d3bd5f..2ad7f537 100644 --- a/bindsnet/network/topology_features.py +++ b/bindsnet/network/topology_features.py @@ -66,24 +66,18 @@ def __init__( ## Backend ## self.is_primed = False - from ..learning import ( + from ..learning.MCC_learning import ( NoOp, PostPre, - WeightDependentPostPre, - Hebbian, MSTDP, MSTDPET, - Rmax, ) supported_rules = [ NoOp, PostPre, - WeightDependentPostPre, - Hebbian, MSTDP, MSTDPET, - Rmax, ] #### Assertions #### @@ -152,7 +146,7 @@ def prime_feature(self, connection, device, **kwargs) -> None: """ # Note: DO NOT move NoOp to global; cyclical dependency - from ..learning import NoOp + from ..learning.MCC_learning import NoOp # Check if feature is already primed if self.is_primed: @@ -458,7 +452,7 @@ def prime_feature(self, connection, device, **kwargs) -> None: ##### Initialize learning rule ##### # Note: DO NOT move NoOp to global; cyclical dependency - from ..learning import NoOp + from ..learning.MCC_learning import NoOp # Default is NoOp if self.learning_rule is None: diff --git a/examples/mnist/MCC_reservoir.py b/examples/mnist/MCC_reservoir.py new file mode 100644 index 00000000..89145d6f --- /dev/null +++ b/examples/mnist/MCC_reservoir.py @@ -0,0 +1,309 @@ +import os +import numpy as np +import torch +import torch.nn as nn +import argparse +import matplotlib.pyplot as plt + +from torchvision import transforms +from tqdm import tqdm + +from bindsnet.analysis.plotting import ( + plot_input, + plot_spikes, + plot_voltages, + plot_weights, +) +from bindsnet.datasets import MNIST +from bindsnet.encoding import PoissonEncoder +from bindsnet.network import Network +from bindsnet.network.nodes import Input +from bindsnet.network.topology_features import Probability, Weight, Mask + +# Build a simple two-layer, input-output network. +from bindsnet.network.monitors import Monitor +from bindsnet.network.nodes import LIFNodes +from bindsnet.network.topology import MulticompartmentConnection +from bindsnet.utils import get_square_weights + + +parser = argparse.ArgumentParser() +parser.add_argument("--seed", type=int, default=0) +parser.add_argument("--n_neurons", type=int, default=500) +parser.add_argument("--n_epochs", type=int, default=100) +parser.add_argument("--examples", type=int, default=500) +parser.add_argument("--n_workers", type=int, default=-1) +parser.add_argument("--time", type=int, default=250) +parser.add_argument("--dt", type=int, default=1.0) +parser.add_argument("--intensity", type=float, default=64) +parser.add_argument("--progress_interval", type=int, default=10) +parser.add_argument("--update_interval", type=int, default=250) +parser.add_argument("--plot", dest="plot", action="store_true") +parser.add_argument("--gpu", dest="gpu", action="store_true") +parser.set_defaults(plot=False, gpu=True, train=True) + +args = parser.parse_args() + +seed = args.seed +n_neurons = args.n_neurons +n_epochs = args.n_epochs +examples = args.examples +n_workers = args.n_workers +time = args.time +dt = args.dt +intensity = args.intensity +progress_interval = args.progress_interval +update_interval = args.update_interval +train = args.train +plot = args.plot +gpu = args.gpu + +np.random.seed(seed) +torch.cuda.manual_seed_all(seed) +torch.manual_seed(seed) + +# Sets up Gpu use +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") +if gpu and torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) +else: + torch.manual_seed(seed) + device = "cpu" + if gpu: + gpu = False +torch.set_num_threads(os.cpu_count() - 1) +print("Running on Device = ", device) + + +### Base model ### +model = Network() +model.to(device) + + +### Layers ### +input_l = Input(n=784, shape=(1, 28, 28), traces=True) +output_l = LIFNodes( + n=n_neurons, thresh=-52 + np.random.randn(n_neurons).astype(float), traces=True +) + +model.add_layer(input_l, name="X") +model.add_layer(output_l, name="Y") + + +### Connections ### +p = torch.rand(input_l.n, output_l.n) +d = torch.rand(input_l.n, output_l.n) / 5 +w = torch.sign(torch.randint(-1, +2, (input_l.n, output_l.n))) +prob_feature = Probability(name="input_prob_feature", value=p) +weight_feature = Weight(name="input_weight_feature", value=w) +pipeline = [prob_feature, weight_feature] +input_con = MulticompartmentConnection( + source=input_l, + target=output_l, + device=device, + pipeline=pipeline, +) + +p = torch.rand(output_l.n, output_l.n) +d = torch.rand(output_l.n, output_l.n) / 5 +w = torch.sign(torch.randint(-1, +2, (output_l.n, output_l.n))) +prob_feature = Probability(name="recc_prob_feature", value=p) +weight_feature = Weight(name="recc_weight_feature", value=w) +pipeline = [prob_feature, weight_feature] +recurrent_con = MulticompartmentConnection( + source=output_l, + target=output_l, + device=device, + pipeline=pipeline, +) + +model.add_connection(input_con, source="X", target="Y") +model.add_connection(recurrent_con, source="Y", target="Y") + +# Directs network to GPU +if gpu: + model.to("cuda") + +### MNIST ### +dataset = MNIST( + PoissonEncoder(time=time, dt=dt), + None, + root=os.path.join("../../test", "..", "data", "MNIST"), + download=True, + transform=transforms.Compose( + [transforms.ToTensor(), transforms.Lambda(lambda x: x * intensity)] + ), +) + + +### Monitor setup ### +inpt_axes = None +inpt_ims = None +spike_axes = None +spike_ims = None +weights_im = None +weights_im2 = None +voltage_ims = None +voltage_axes = None +spikes = {} +voltages = {} +for l in model.layers: + spikes[l] = Monitor(model.layers[l], ["s"], time=time, device=device) + model.add_monitor(spikes[l], name="%s_spikes" % l) + +voltages = {"Y": Monitor(model.layers["Y"], ["v"], time=time, device=device)} +model.add_monitor(voltages["Y"], name="Y_voltages") + + +### Running model on MNIST ### + +# Create a dataloader to iterate and batch data +dataloader = torch.utils.data.DataLoader( + dataset, batch_size=1, shuffle=True, num_workers=0, pin_memory=True +) + +n_iters = examples +training_pairs = [] +pbar = tqdm(enumerate(dataloader)) +for i, dataPoint in pbar: + if i > n_iters: + break + + # Extract & resize the MNIST samples image data for training + # int(time / dt) -> length of spike train + # 28 x 28 -> size of sample + datum = dataPoint["encoded_image"].view(int(time / dt), 1, 1, 28, 28).to(device) + label = dataPoint["label"] + pbar.set_description_str("Train progress: (%d / %d)" % (i, n_iters)) + + # Run network on sample image + model.run(inputs={"X": datum}, time=time, input_time_dim=1, reward=1.0) + training_pairs.append([spikes["Y"].get("s").sum(0), label]) + + # Plot spiking activity using monitors + if plot: + inpt_axes, inpt_ims = plot_input( + dataPoint["image"].view(28, 28), + datum.view(int(time / dt), 784).sum(0).view(28, 28), + label=label, + axes=inpt_axes, + ims=inpt_ims, + ) + spike_ims, spike_axes = plot_spikes( + {layer: spikes[layer].get("s").view(time, -1) for layer in spikes}, + axes=spike_axes, + ims=spike_ims, + ) + voltage_ims, voltage_axes = plot_voltages( + {layer: voltages[layer].get("v").view(time, -1) for layer in voltages}, + ims=voltage_ims, + axes=voltage_axes, + ) + + plt.pause(1e-8) + model.reset_state_variables() + + +### Classification ### +# Define logistic regression model using PyTorch. +# These neurons will take the reservoirs output as its input, and be trained to classify the images. +class NN(nn.Module): + def __init__(self, input_size, num_classes): + super(NN, self).__init__() + # h = int(input_size/2) + self.linear_1 = nn.Linear(input_size, num_classes) + # self.linear_1 = nn.Linear(input_size, h) + # self.linear_2 = nn.Linear(h, num_classes) + + def forward(self, x): + out = torch.sigmoid(self.linear_1(x.float().view(-1))) + # out = torch.sigmoid(self.linear_2(out)) + return out + + +# Create and train logistic regression model on reservoir outputs. +learning_model = NN(n_neurons, 10).to(device) +criterion = torch.nn.MSELoss(reduction="sum") +optimizer = torch.optim.SGD(learning_model.parameters(), lr=1e-4, momentum=0.9) + +# Training the Model +print("\n Training the read out") +pbar = tqdm(enumerate(range(n_epochs))) +for epoch, _ in pbar: + avg_loss = 0 + + # Extract spike outputs from reservoir for a training sample + # i -> Loop index + # s -> Reservoir output spikes + # l -> Image label + for i, (s, l) in enumerate(training_pairs): + # Reset gradients to 0 + optimizer.zero_grad() + + # Run spikes through logistic regression model + outputs = learning_model(s) + + # Calculate MSE + label = torch.zeros(1, 1, 10).float().to(device) + label[0, 0, l] = 1.0 + loss = criterion(outputs.view(1, 1, -1), label) + avg_loss += loss.data + + # Optimize parameters + loss.backward() + optimizer.step() + + pbar.set_description_str( + "Epoch: %d/%d, Loss: %.4f" + % (epoch + 1, n_epochs, avg_loss / len(training_pairs)) + ) + +# Run same simulation on reservoir with testing data instead of training data +# (see training section for intuition) +n_iters = examples +test_pairs = [] +pbar = tqdm(enumerate(dataloader)) +for i, dataPoint in pbar: + if i > n_iters: + break + datum = dataPoint["encoded_image"].view(int(time / dt), 1, 1, 28, 28).to(device) + label = dataPoint["label"] + pbar.set_description_str("Testing progress: (%d / %d)" % (i, n_iters)) + + model.run(inputs={"X": datum}, time=time, input_time_dim=1) + test_pairs.append([spikes["Y"].get("s").sum(0), label]) + + if plot: + inpt_axes, inpt_ims = plot_input( + dataPoint["image"].view(28, 28), + datum.view(time, 784).sum(0).view(28, 28), + label=label, + axes=inpt_axes, + ims=inpt_ims, + ) + spike_ims, spike_axes = plot_spikes( + {layer: spikes[layer].get("s").view(time, -1) for layer in spikes}, + axes=spike_axes, + ims=spike_ims, + ) + voltage_ims, voltage_axes = plot_voltages( + {layer: voltages[layer].get("v").view(time, -1) for layer in voltages}, + ims=voltage_ims, + axes=voltage_axes, + ) + + plt.pause(1e-8) + model.reset_state_variables() + +# Test learning model with previously trained logistic regression classifier +correct, total = 0, 0 +for s, label in test_pairs: + outputs = learning_model(s) + _, predicted = torch.max(outputs.data.unsqueeze(0), 1) + total += 1 + correct += int(predicted == label.long().to(device)) + +print( + "\n Accuracy of the model on %d test images: %.2f %%" + % (n_iters, 100 * correct / total) +) From 6226e5909e4a5f6eec279fb50f40d79c5d103542 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 3 Sep 2024 10:39:31 -0400 Subject: [PATCH 14/27] Removed old TODO's --- bindsnet/learning/MCC_learning.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/bindsnet/learning/MCC_learning.py b/bindsnet/learning/MCC_learning.py index 822a8437..33c3936e 100644 --- a/bindsnet/learning/MCC_learning.py +++ b/bindsnet/learning/MCC_learning.py @@ -22,7 +22,6 @@ class MCC_LearningRule(ABC): def __init__( self, connection: AbstractMulticompartmentConnection, - # TODO: Will not work properly with primitive types int/float (not by reference) feature_value: Union[float, int, torch.Tensor], range: Optional[Union[list, tuple]] = None, nu: Optional[Union[float, Sequence[float]]] = None, @@ -99,7 +98,6 @@ def update(self, **kwargs) -> None: polarity_swaps = self.polarities == torch.sign(self.feature_value) self.feature_value[polarity_swaps == 0] = 0 - # TODO: FIX THIS # Bound weights. if ((self.min is not None) or (self.max is not None)) and not isinstance( self, NoOp From 88cf538ee591d56c576f7b7856e73eb303f04e76 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 3 Sep 2024 10:51:54 -0400 Subject: [PATCH 15/27] Updated requirements.txt and setup.py dependency versions --- requirements.txt | 32 ++++++++++++++++---------------- setup.py | 31 ++++++++++++++++--------------- 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/requirements.txt b/requirements.txt index 14fe2432..93d8a452 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,19 +1,19 @@ foolbox -scipy>=1.5.4 -numpy>=1.19.5 -cython>=0.29.5 -torch==1.9.0 -torchvision==0.10.0 -tensorboardX==2.2 -tqdm>=4.60.0 -setuptools>=39.0.1 -matplotlib>=2.1.0 -gym>=0.10.4 -scikit-build>=0.11.0 -scikit_image>=0.13.1 -scikit_learn>=0.19.1 -opencv-python>=3.4.0.12 -pytest>=3.4.0 -pandas>=0.23.4 +scipy>=1.14.1 +numpy>=2.1.0 +cython>=3.0.11 +torch==2.4.0 +torchvision==0.19.0 +tensorboardX==2.6.2.2 +tqdm>=4.66.5 +setuptools>=74.1.1 +matplotlib>=3.9.2 +gym>=0.26.2 +scikit-build>=0.18.0 +scikit_image>=0.24.0 +scikit_learn>=1.5.1 +opencv-python>=4.10.0.84 +pytest>=8.3.2 +pandas>=2.2.2 pre-commit diff --git a/setup.py b/setup.py index 7860a443..a9753eae 100644 --- a/setup.py +++ b/setup.py @@ -16,20 +16,21 @@ packages=find_packages(), zip_safe=False, install_requires=[ - "numpy>=1.19.5", - "torch==1.9.0", - "torchvision==0.10.0", - "tensorboardX==2.2", - "tqdm>=4.60.0", - "matplotlib>=2.1.0", - "gym>=0.10.4", - "scikit-build>=0.11.1", - "scikit_image>=0.13.1", - "scikit_learn>=0.19.1", - "opencv-python>=3.4.0.12", - "pytest>=6.2.0", - "scipy>=1.5.4", - "cython>=0.29.0", - "pandas>=0.23.4", + "scipy>=1.14.1," + "numpy>=2.1.0," + "cython>=3.0.11," + "torch==2.4.0," + "torchvision==0.19.0," + "tensorboardX==2.6.2.2," + "tqdm>=4.66.5," + "setuptools>=74.1.1," + "matplotlib>=3.9.2," + "gym>=0.26.2," + "scikit-build>=0.18.0," + "scikit_image>=0.24.0," + "scikit_learn>=1.5.1," + "opencv-python>=4.10.0.84," + "pytest>=8.3.2," + "pandas>=2.2.2," ], ) From 8e1fa07e4edf7e9586037e52f0c4fe3866077e85 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Sun, 8 Sep 2024 00:00:20 -0400 Subject: [PATCH 16/27] Grid Cell model files --- scripts/Chris/DQN/ANN.py | 199 ++++++++++++++ scripts/Chris/DQN/Environment.py | 71 +++++ scripts/Chris/DQN/Eval.ipynb | 252 ++++++++++++++++++ scripts/Chris/DQN/Grid_Cells.py | 133 +++++++++ scripts/Chris/DQN/Memory.py | 118 ++++++++ scripts/Chris/DQN/Reservoir.py | 63 +++++ scripts/Chris/DQN/classify_recalls.py | 133 +++++++++ scripts/Chris/DQN/pipeline_executor.py | 66 +++++ scripts/Chris/DQN/recall_memories.py | 38 +++ scripts/Chris/DQN/recall_reservoir.py | 55 ++++ .../Chris/DQN/recalled_mem_preprocessing.py | 68 +++++ scripts/Chris/DQN/sample_generator.py | 85 ++++++ scripts/Chris/DQN/spike_train_generator.py | 48 ++++ scripts/Chris/DQN/store_memories.py | 82 ++++++ scripts/Chris/DQN/store_reservoir.py | 65 +++++ 15 files changed, 1476 insertions(+) create mode 100644 scripts/Chris/DQN/ANN.py create mode 100644 scripts/Chris/DQN/Environment.py create mode 100644 scripts/Chris/DQN/Eval.ipynb create mode 100644 scripts/Chris/DQN/Grid_Cells.py create mode 100644 scripts/Chris/DQN/Memory.py create mode 100644 scripts/Chris/DQN/Reservoir.py create mode 100644 scripts/Chris/DQN/classify_recalls.py create mode 100644 scripts/Chris/DQN/pipeline_executor.py create mode 100644 scripts/Chris/DQN/recall_memories.py create mode 100644 scripts/Chris/DQN/recall_reservoir.py create mode 100644 scripts/Chris/DQN/recalled_mem_preprocessing.py create mode 100644 scripts/Chris/DQN/sample_generator.py create mode 100644 scripts/Chris/DQN/spike_train_generator.py create mode 100644 scripts/Chris/DQN/store_memories.py create mode 100644 scripts/Chris/DQN/store_reservoir.py diff --git a/scripts/Chris/DQN/ANN.py b/scripts/Chris/DQN/ANN.py new file mode 100644 index 00000000..bd54ff2b --- /dev/null +++ b/scripts/Chris/DQN/ANN.py @@ -0,0 +1,199 @@ +import pickle as pkl +import random +from collections import namedtuple, deque + +from matplotlib import pyplot as plt +from sklearn.metrics import confusion_matrix +from torch.nn import Module, Linear, ReLU, Sequential +from torch.optim import Adam +import torch + +# https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html +Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward')) + +# https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html +class ReplayMemory(object): + + def __init__(self, capacity): + self.memory = deque([], maxlen=capacity) + + def push(self, *args): + """Save a transition""" + self.memory.append(Transition(*args)) + + def sample(self, batch_size): + return random.sample(self.memory, batch_size) + + def __len__(self): + return len(self.memory) + + +class ANN(Module): + def __init__(self, input_dim, output_dim): + super(ANN, self).__init__() + self.sequence = Sequential( + Linear(input_dim, 1000), + ReLU(), + Linear(1000, 100), + ReLU(), + Linear(100, output_dim) + ) + + def forward(self, x): + x = x.to(torch.float32) + return self.sequence(x) + + +class DQN: + def __init__(self, input_dim, output_dim, gamma=0.99, batch_size=128, device='cpu'): + self.policy_net = ANN(input_dim, output_dim) + self.target_net = ANN(input_dim, output_dim) + self.optimizer = Adam(self.policy_net.parameters()) + self.memory = ReplayMemory(10000) + self.gamma = gamma + self.batch_size = batch_size + self.device = device + + def select_action(self, state, epsilon): + # Random action + if random.random() < epsilon: + return torch.tensor([[random.randrange(2)]], dtype=torch.float32) + + # ANN action + else: + with torch.no_grad(): + return self.policy_net(state).argmax() + + def optimize_model(self): + if len(self.memory) < self.batch_size: + return + transitions = self.memory.sample(self.batch_size) + batch = Transition(*zip(*transitions)) + + non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, + batch.next_state)), device=self.device, dtype=torch.bool) + non_final_next_states = torch.cat([s for s in batch.next_state + if s is not None]).reshape(-1, 2) + state_batch = torch.cat(batch.state).reshape(-1, 2) + action_batch = torch.tensor(batch.action).to(torch.int64) + reward_batch = torch.tensor(batch.reward) + + # Compute Q(s_t, a) + state_action_values = self.policy_net(state_batch)[action_batch] + + # Compute V(s_{t+1}) for all next states. + next_state_values = torch.zeros(self.batch_size, device=self.device) + with torch.no_grad(): + next_state_values[non_final_mask] = self.target_net(non_final_next_states).max(1).values + + # Compute the expected Q values + expected_state_action_values = (next_state_values * self.gamma) + reward_batch + + # Compute Loss + criterion = torch.nn.SmoothL1Loss() + loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1)) + + # Optimize the model + self.optimizer.zero_grad() + loss.backward() + # In-place gradient clipping + torch.nn.utils.clip_grad_value_(self.policy_net.parameters(), 100) + self.optimizer.step() + + def update_target(self, tau=0.005): + target_net_state_dict = self.target_net.state_dict() + policy_net_state_dict = self.policy_net.state_dict() + for key in policy_net_state_dict: + target_net_state_dict[key] = policy_net_state_dict[key]*tau + target_net_state_dict[key] * (1 - tau) + + +class Mem_Dataset(torch.utils.data.Dataset): + def __init__(self, samples, labels): + self.samples = samples + self.labels = labels + + def __len__(self): + return len(self.samples) + + def __getitem__(self, idx): + # Compress spike train into windows for dimension reduction + return self.samples[idx].sum(0).squeeze(), self.labels[idx] + + +if __name__ == '__main__': + ### ANN for input spike trains ### + # Load recalled memory samples ## + with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: + samples, labels = pkl.load(f) + + ## Initialize ANN ## + in_dim = samples[0].shape[1] + model = ANN(in_dim, 2) + optimizer = Adam(model.parameters()) + criterion = torch.nn.MSELoss() + dataset = Mem_Dataset(samples, labels) + train_size = int(0.8 * len(dataset)) + test_size = len(dataset) - train_size + train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) + train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True) + test_loader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=True) + + ## Training ## + loss_log = [] + accuracy_log = [] + for epoch in range(10): + total_loss = 0 + correct = 0 + for memory_batch, positions in train_loader: + # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) + optimizer.zero_grad() + outputs = model(memory_batch) + loss = criterion(outputs, positions.to(torch.float32)) + loss.backward() + optimizer.step() + total_loss += loss.item() + correct += torch.all(outputs.round() == positions.round(), + dim=1).sum().item() + accuracy_log.append(correct / len(train_set)) + loss_log.append(total_loss) + + plt.xlabel('Epoch') + plt.ylabel('Loss') + plt.title('Training Loss') + plt.plot(loss_log) + plt.show() + plt.xlabel('Epoch') + plt.ylabel('Accuracy') + plt.title('Training Accuracy') + plt.plot(accuracy_log) + plt.show() + + ## Testing ## + total = 0 + correct = 0 + confusion_matrix = torch.zeros(25, 25) + out_of_bounds = 0 + with torch.no_grad(): + for memories, labels in test_loader: + outputs = model(memories) + loss = criterion(outputs, labels) + total += len(labels) + correct += torch.all(outputs.round() == labels.round(), + dim=1).sum().item() # Check if prediction for both x and y are correct + for t, p in zip(labels, outputs): + label_ind = int(t[0].round() * 5 + t[1].round()) + pred_ind = int(p[0].round() * 5 + p[1].round()) + if label_ind < 0 or label_ind >= 25 or pred_ind < 0 or pred_ind >= 25: + out_of_bounds += 1 + else: + confusion_matrix[label_ind, pred_ind] += 1 + + plt.imshow(confusion_matrix) + plt.title('Confusion Matrix') + plt.xlabel('Predicted') + plt.ylabel('True Label') + plt.colorbar() + plt.show() + + print(f'Accuracy: {round(correct / total, 3)*100}%') + diff --git a/scripts/Chris/DQN/Environment.py b/scripts/Chris/DQN/Environment.py new file mode 100644 index 00000000..e7986cbb --- /dev/null +++ b/scripts/Chris/DQN/Environment.py @@ -0,0 +1,71 @@ +from labyrinth.generate import DepthFirstSearchGenerator +from labyrinth.grid import Cell, Direction +from labyrinth.maze import Maze +from labyrinth.solve import MazeSolver +import pickle as pkl +import matplotlib.pyplot as plt + +class Maze_Environment(Maze): + def __init__(self, width, height): + + # Generate basic maze & solve + super().__init__(width=width, height=height, generator=DepthFirstSearchGenerator()) + solver = MazeSolver() + self.path = solver.solve(self) + self.agent_cell = self.start_cell + + def plot(self): + # Box around maze + plt.plot([-0.5, self.width-1+0.5], [-0.5, -0.5], color='black') + plt.plot([-0.5, self.width-1+0.5], [self.height-1+0.5, self.height-1+0.5], color='black') + plt.plot([-0.5, -0.5], [-0.5, self.height-1+0.5], color='black') + plt.plot([self.width-1+0.5, self.width-1+0.5], [-0.5, self.height-1+0.5], color='black') + + # Plot maze + for row in range(self.height): + for column in range(self.width): + # Path + cell = self[column, row] # Tranpose maze coordinates (just how the maze is stored) + if cell == self.start_cell: + plt.plot(row, column, 'go') + elif cell == self.end_cell: + plt.plot(row, column,'bo') + elif cell in self.path: + plt.plot(row, column, 'ro') + + # Walls + if Direction.S not in cell.open_walls: + plt.plot([row-0.5, row+0.5], [column+0.5, column+0.5], color='black') + if Direction.E not in cell.open_walls: + plt.plot([row+0.5, row+0.5], [column-0.5, column+0.5], color='black') + + def reset(self): + pass + + # Takes action, returns next state, reward, done, info + def step(self, action): + # Check if action runs into wall + if action not in self.agent_cell.open_walls: + return self.agent_cell, -1, False, {} + + # Move agent + else: + self.agent_cell = self.agent_pos.neighbor(action) + if self.agent_cell == self.end_cell: + return self.agent_cell, 1, True, {} + else: + return self.agent_cell, 0, False, {} + + def save(self, filename): + with open(filename, 'wb') as f: + pkl.dump(self, f) + + +if __name__ == '__main__': + maze = Maze_Environment(width=25, height=25) + solver = MazeSolver() + path = solver.solve(maze) + maze.path = path + print(maze) + print(f'start: {maze.start_cell}') + print(f'end: {maze.end_cell}') \ No newline at end of file diff --git a/scripts/Chris/DQN/Eval.ipynb b/scripts/Chris/DQN/Eval.ipynb new file mode 100644 index 00000000..372dba60 --- /dev/null +++ b/scripts/Chris/DQN/Eval.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-09-07T22:31:51.993246Z", + "start_time": "2024-09-07T22:31:51.769117Z" + } + }, + "source": [ + "import pickle as pkl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np # Plot input spikes\n", + "from matplotlib.gridspec import GridSpec " + ], + "outputs": [], + "execution_count": 3 + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "# Plot input spikes\n", + "with open('Data/grid_cell_spk_trains.pkl', 'rb') as f:\n", + " spike_trains, labels = pkl.load(f)\n", + "with open('Data/grid_cell_spk_trains_sorted.pkl', 'rb') as f:\n", + " spike_trains_sorted = pkl.load(f)\n", + "positions = np.array([key for key in spike_trains_sorted.keys()])\n", + "rand_inds = np.random.choice(range(len(positions)), 5)\n", + "sim_time = spike_trains.shape[1]\n", + "for pos in positions[rand_inds]:\n", + " fig = plt.figure(figsize=(10, 5))\n", + " fig.suptitle(f\"Position: {pos}\")\n", + " gs = fig.add_gridspec(1, 6)\n", + " ax1 = fig.add_subplot(gs[0, 0])\n", + " avg_mem = np.mean(spike_trains_sorted[tuple(pos)], axis=0).reshape(sim_time, -1)\n", + " im = ax1.imshow(avg_mem.T)\n", + " fig.colorbar(im, ax=ax1)\n", + " # ax1.set_aspect('auto')\n", + " random_inds = np.random.choice(range(len(spike_trains_sorted[tuple(pos)])), 5)\n", + " random_samples = np.array(spike_trains_sorted[tuple(pos)])[random_inds]\n", + " vmin = np.min(random_samples)\n", + " vmax = np.max(random_samples)\n", + " for i in range(1, 5):\n", + " ax = fig.add_subplot(gs[0, i])\n", + " rand_sample = spike_trains_sorted[tuple(pos)][random_inds[i]].reshape(sim_time, -1)\n", + " im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax)\n", + " ax.set(xticklabels=[])\n", + " ax.set(yticklabels=[])\n", + " # ax.set_aspect('auto')\n", + " plt.tight_layout()\n", + " plt.show()" + ], + "id": "90ce759a18d4f156", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-08T01:57:39.528962Z", + "start_time": "2024-09-08T01:57:38.519304Z" + } + }, + "cell_type": "code", + "source": [ + "# Plot input spikes\n", + "with open('Data/grid_cell_spk_trains.pkl', 'rb') as f:\n", + " spike_trains, labels = pkl.load(f)\n", + "with open('Data/grid_cell_spk_trains_sorted.pkl', 'rb') as f:\n", + " spike_trains_sorted = pkl.load(f)\n", + "sim_time = spike_trains.shape[1]\n", + "positions = np.array([key for key in spike_trains_sorted.keys()])\n", + "fig = plt.figure(figsize=(10, 10))\n", + "gs = fig.add_gridspec(nrows=5, ncols=5)\n", + "for i, pos in enumerate(positions):\n", + " ax = fig.add_subplot(gs[pos[0], pos[1]])\n", + " avg_mem = np.mean(spike_trains_sorted[tuple(pos)], axis=0).reshape(sim_time, -1)\n", + " ax.set_title(f\"Conf-Mat: {pos[0]*5 + pos[1]}\")\n", + " im = ax.imshow(np.expand_dims(avg_mem.sum(0), axis=0))\n", + " ax.set_aspect('auto')\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "id": "5d8ba0301681f835", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 36 + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "# Average of grid cell intensities per position\n", + "# With raw samples on side for comparison\n", + "with open('Data/grid_cell_intensities_sorted.pkl', 'rb') as f:\n", + " grid_cell_intensities, true_labels = pkl.load(f)\n", + "positions = [key for key in grid_cell_intensities.keys()]\n", + "for pos in positions[0:5]:\n", + " fig = plt.figure()\n", + " gs = fig.add_gridspec(1, 6)\n", + " ax1 = fig.add_subplot(gs[0, 0])\n", + " avg_intensities = np.mean(grid_cell_intensities[pos], axis=0)\n", + " ax1.imshow(np.expand_dims(avg_intensities, axis=1))\n", + " ax1.set(xticklabels=[])\n", + " ax1.set_title(\"Avg.\")\n", + " for j in range(len(avg_intensities)):\n", + " ax1.text(0, j, f'{avg_intensities[j]:.2f}', color='red')\n", + " random_inds = np.random.choice(range(len(grid_cell_intensities[pos])), 5)\n", + " random_samples = np.array(grid_cell_intensities[pos])[random_inds]\n", + " vmin = np.min(random_samples)\n", + " vmax = np.max(random_samples)\n", + " for i in range(1, 5):\n", + " ax = fig.add_subplot(gs[0, i])\n", + " ax.set_title(f\"S{i}\")\n", + " rand_sample = grid_cell_intensities[pos][random_inds[i]]\n", + " im = ax.imshow(np.expand_dims(rand_sample, axis=1), vmin=vmin, vmax=vmax)\n", + " ax.set(xticklabels=[])\n", + " ax.set(yticklabels=[])\n", + " for j in range(len(rand_sample)):\n", + " ax.text(0, j, f'{rand_sample[j]:.2f}', color='red')\n", + " fig.subplots_adjust(right=0.8)\n", + " cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", + " fig.colorbar(im, cax=cbar_ax)\n", + " # plt.tight_layout()\n", + " plt.show()" + ], + "id": "2cdae84a47c79f73", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "# Plot memory module weights\n", + "with open('Data/memory_module.pkl', 'rb') as f:\n", + " memory_module = pkl.load(f)\n", + "plt.imshow(memory_module.connections['key', 'value'].feature_index['assoc_weight_feature'].value.numpy())\n", + "plt.colorbar()" + ], + "id": "9203f5bc892b669e", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "source": [ + "# Plot recalls\n", + "with open('Data/recalled_memories.pkl', 'rb') as f:\n", + " recalled_memories, r_labels = pkl.load(f)\n", + "with open('Data/recalled_memories_sorted.pkl', 'rb') as f:\n", + " recalled_memories_sorted = pkl.load(f)\n", + "positions = np.array([key for key in recalled_memories_sorted.keys()])\n", + "rand_inds = np.random.choice(range(len(positions)), 5)\n", + "for pos in positions[rand_inds]:\n", + " fig = plt.figure(figsize=(10, 3))\n", + " gs = fig.add_gridspec(1, 6)\n", + " ax1 = fig.add_subplot(gs[0, 0])\n", + " avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0)\n", + " ax1.imshow(avg_mem.T)\n", + " random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5)\n", + " random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds]\n", + " vmin = np.min(random_samples)\n", + " vmax = np.max(random_samples)\n", + " for i in range(1, 5):\n", + " ax = fig.add_subplot(gs[0, i])\n", + " rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]]\n", + " im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax)\n", + " ax.set(xticklabels=[])\n", + " ax.set(yticklabels=[])" + ], + "id": "f30e1a968c75d36", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-02T19:16:47.907983Z", + "start_time": "2024-09-02T19:16:46.090175Z" + } + }, + "cell_type": "code", + "source": [ + "# Plot reservoir module weights\n", + "with open('Data/reservoir_module.pkl', 'rb') as f:\n", + " memory_module = pkl.load(f)\n", + "plt.imshow(memory_module.connections['key', 'value'].feature_index['assoc_weight_feature'].value.numpy())\n", + "plt.colorbar()" + ], + "id": "c3c66743119f2d75", + "outputs": [ + { + "ename": "KeyError", + "evalue": "('key', 'value')", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mKeyError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[9], line 4\u001B[0m\n\u001B[1;32m 2\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mopen\u001B[39m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mData/reservoir_module.pkl\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mrb\u001B[39m\u001B[38;5;124m'\u001B[39m) \u001B[38;5;28;01mas\u001B[39;00m f:\n\u001B[1;32m 3\u001B[0m memory_module \u001B[38;5;241m=\u001B[39m pkl\u001B[38;5;241m.\u001B[39mload(f)\n\u001B[0;32m----> 4\u001B[0m plt\u001B[38;5;241m.\u001B[39mimshow(\u001B[43mmemory_module\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnections\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mkey\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mvalue\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241m.\u001B[39mfeature_index[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124massoc_weight_feature\u001B[39m\u001B[38;5;124m'\u001B[39m]\u001B[38;5;241m.\u001B[39mvalue\u001B[38;5;241m.\u001B[39mnumpy())\n\u001B[1;32m 5\u001B[0m plt\u001B[38;5;241m.\u001B[39mcolorbar()\n", + "\u001B[0;31mKeyError\u001B[0m: ('key', 'value')" + ] + } + ], + "execution_count": 9 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "a2fcc559fb17b11e" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scripts/Chris/DQN/Grid_Cells.py b/scripts/Chris/DQN/Grid_Cells.py new file mode 100644 index 00000000..308891c4 --- /dev/null +++ b/scripts/Chris/DQN/Grid_Cells.py @@ -0,0 +1,133 @@ +from scipy.stats import multivariate_normal +import numpy as np +from matplotlib import pyplot as plt + +class Grid_Cell: + def __init__(self, x_range, y_range, x_offset, y_offset, scale=1, var=1, color='b'): + self.centers = np.mgrid[x_range[0]:x_range[1]:scale, y_range[0]:y_range[1]:scale].transpose(1, 2, 0).astype(float) + self.centers[:, :, 0] += x_offset + self.centers[:, :, 1] += y_offset + self.centers[:, ::2, 0] += 0.5 * scale + # self.centers[::2, :, 1] += 0.5 * scale + self.x_range = x_range + self.y_range = y_range + self.color = color + self.var = var + + # Produce Grid Cell spike behavior relative to position + # scale: Distance between grid cells + def generate(self, pos): + # Find closest center + distances = np.linalg.norm(self.centers - pos, axis=2) + closest_center = self.centers[np.unravel_index(np.argmin(distances), distances.shape)] + mvn = multivariate_normal(mean=closest_center, cov=np.eye(2) * (self.var / (2 * np.pi))) + activity = mvn.pdf(pos) + return activity, closest_center + + def plot_activity(self, activity, center, color): + for i in range(self.centers.shape[0]): + for j in range(self.centers.shape[1]): + x, y = self.centers[i, j] + if np.all(center == (x, y)): + c = plt.Circle((x, y), activity + 0.01, fill=True, alpha=0.5) + plt.plot(x, y, '.', alpha=0.5, color=color) + plt.gca().add_artist(c) + else: + plt.plot(x, y, '.', alpha=0.5, color=color) + # c = plt.Circle((x, y), activity[i, j] + 0.01, color=color, fill=True, alpha=0.5) + plt.xlim(self.x_range[0]-1, self.x_range[1]+1) + plt.ylim(self.y_range[0]-1, self.y_range[1]+1) + + def plot_centers(self, color): + for i in range(self.centers.shape[0]): + for j in range(self.centers.shape[1]): + x, y = self.centers[i, j] + plt.plot(x, y, '.', alpha=0.5, color=color) + # c = plt.Circle((x, y), activity[i, j] + 0.01, color=color, fill=True, alpha=0.5) + plt.xlim(self.x_range[0]-1, self.x_range[1]+1) + plt.ylim(self.y_range[0]-1, self.y_range[1]+1) + + +# Module of Grid Cell populations, each with a different scale +class GC_Module: + def __init__(self, x_range, y_range, scales, offsets, vars): + # self.colors = + self.grid_cells = [Grid_Cell(x_range, y_range, x_ofst, y_ofst, s, v) for + (x_ofst, y_ofst), s, v in zip(offsets, scales, vars)] + self.scales = scales + self.x_range = x_range + self.y_range = y_range + self.offsets = offsets + self.colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w', 'orange', 'purple', 'brown', + 'pink', 'gray', 'olive', 'cyan', 'lime', 'teal', 'lavender', 'tan', 'salmon', + 'gold', 'indigo', 'maroon', 'navy', 'peru', 'sienna', 'tomato', 'violet', 'wheat',] + + # Generate Grid Cell activity + def generate(self, pos): + activities = [] + centers = [] + for gc in self.grid_cells: + a, c = gc.generate(pos) + activities.append(a) + centers.append(c) + return np.array(activities), np.array(centers) + + # Plot Grid Cell activity + def plot_activity(self, activities, centers): + for i, gc in enumerate(self.grid_cells): + gc.plot_activity(activities[i], centers[i], self.colors[i]) + + # Plot Grid Cell Centers + def plot_centers(self): + for i, gc in enumerate(self.grid_cells): + gc.plot_centers(self.colors[i]) + + +# Take in grid cell activity vector and turn into spike train +# Activity converted to spike rate +# max_freq: Maximum frequency of spikes +def activity_to_spike(activity, time, max_freq): + # Normalize [0, 1] + activity = (activity - min(activity)) / (max(activity) - min(activity)) + + # Convert to spike rate + spike_rate = activity * max_freq + spike_train = np.zeros((time, len(activity))) + for i, rate in enumerate(spike_rate): + if rate != 0: + spike_train[:, i] = np.zeros(time) + spike_train[:, i][np.random.rand(time) < rate] = 1 + else: + spike_train[:, i] = np.zeros(time) + + return spike_train + +if __name__ == '__main__': + np.random.seed(5) + num_cells = 5 + + # Grid Cell activity range + x_range_ = (0, +5) + y_range_ = (0, +5) + + # Agent position + pos_ = (0, 0) + + # Grid Cell offsets + x_offsets_ = np.random.uniform(-1, 1, num_cells) + y_offsets_ = np.random.uniform(-1, 1, num_cells) + offsets = list(zip(x_offsets_, y_offsets_)) + + # How far apart Grid Cells are + scales = [1 + 0.1*i for i in range(num_cells)] + + # Variance for activity sampling around Grid Cell centers + vars_ = [1]*num_cells + + # Initialize Grid Cell Module + module = GC_Module(x_range_, y_range_, scales, offsets, vars_) + a_, c_ = module.generate(pos_) + # test = activity_to_spike(a_, 50, 0.5) + print(f"Activity vector: {a_}") + module.plot_activity(a_, c_) + plt.show() diff --git a/scripts/Chris/DQN/Memory.py b/scripts/Chris/DQN/Memory.py new file mode 100644 index 00000000..4bd9ac0a --- /dev/null +++ b/scripts/Chris/DQN/Memory.py @@ -0,0 +1,118 @@ +import pickle as pkl +import torch +import numpy as np +import matplotlib.pyplot as plt +from Grid_Cells import activity_to_spike + +from bindsnet.learning.MCC_learning import PostPre, MSTDP +from bindsnet.network import Network +from bindsnet.network.monitors import Monitor +from bindsnet.network.nodes import Input, AdaptiveLIFNodes +from bindsnet.network.topology import MulticompartmentConnection +from bindsnet.network.topology_features import Weight + + +class Memory_SNN(Network): + def __init__(self, + key_size, val_size, in_size, + w_in_key, w_in_val, w_assoc, + hyper_params, device='cpu'): + super().__init__() + + ## Layers ## + key_input = Input(n=in_size) + val_input = Input(n=in_size) + key = AdaptiveLIFNodes( + n=key_size, + thresh=hyper_params['thresh'], + theta_plus=hyper_params['theta_plus'], + refrac=hyper_params['refrac'], + reset=hyper_params['reset'], + tc_theta_decay=hyper_params['tc_theta_decay'], + tc_decay=hyper_params['tc_decay'], + traces=True, + ) + value = AdaptiveLIFNodes( + n=val_size, + thresh=hyper_params['thresh'], + theta_plus=hyper_params['theta_plus'], + refrac=hyper_params['refrac'], + reset=hyper_params['reset'], + tc_theta_decay=hyper_params['tc_theta_decay'], + tc_decay=hyper_params['tc_decay'], + traces = True, + ) + val_monitor = Monitor(value, ["s"], device=device) + self.add_monitor(val_monitor, name='val_monitor') + self.val_monitor = val_monitor + self.add_layer(key_input, name='key_input') + self.add_layer(val_input, name='val_input') + self.add_layer(key, name='key') + self.add_layer(value, name='value') + + ## Connections ## + # Key + in_key_wfeat = Weight(name='in_key_weight_feature', value=w_in_key) + in_key_conn = MulticompartmentConnection( + source=key_input, target=key, + device=device, pipeline=[in_key_wfeat], + ) + # Value + in_val_wfeat = Weight(name='in_val_weight_feature', value=w_in_val) + in_val_conn = MulticompartmentConnection( + source=val_input, target=value, + device=device, pipeline=[in_val_wfeat], + ) + # Association + assoc_wfeat = Weight(name='assoc_weight_feature', value=w_assoc, + learning_rule=MSTDP, nu=hyper_params['nu'], range=[0, 1], decay=hyper_params['decay']) + assoc_conn = MulticompartmentConnection( + source=key, target=value, + device=device, pipeline=[assoc_wfeat], traces=True, + ) + assoc_monitor = Monitor(assoc_wfeat, ["value"], device=device) + self.add_connection(in_key_conn, source='key_input', target='key') + self.add_connection(in_val_conn, source='val_input', target='value') + self.add_connection(assoc_conn, source='key', target='value') + self.add_monitor(assoc_monitor, name='assoc_monitor') + self.assoc_monitor = assoc_monitor + + ## Migrate device ## + self.to(device) + + # Store memory + # input: torch.Tensor of shape (time, in_size) + # output: Association output (time, key_size, val_size), Value output (time, val_size) + def store(self, key_train, sim_time=100, lr_params={}): + self.learning = True + self.run(inputs={'key_input':key_train, 'val_input':key_train}, time=sim_time, reward=1, **lr_params) + assoc_out = self.assoc_monitor.get('value') + val_spikes = self.val_monitor.get('s') + return assoc_out, val_spikes + + # Recall memory given a key + # input: torch.Tensor of shape (in_size) (key) + # output: torch.Tensor of shape (val_size) (value) + def recall(self, key_train, sim_time=100): + self.learning = False + self.run(inputs={'val_input':key_train}, time=sim_time) + val_spikes = self.val_monitor.get('s') + return val_spikes + + +def assign_inhibition(weights, percent, inhib_scale): + layer_shape = weights.shape + layer_size = np.prod(layer_shape) + indices_to_flip = np.random.choice(layer_size, int(layer_size * percent), replace=False) + indices_to_flip = np.unravel_index(indices_to_flip, layer_shape) + weights[indices_to_flip] = -weights[indices_to_flip]*inhib_scale + return weights + +# Note: percent = number of weights to zero out +def sparsify(weights, percent): + layer_shape = weights.shape + layer_size = np.prod(layer_shape) + indices_to_zero = np.random.choice(layer_size, int(layer_size * percent), replace=False) + indices_to_zero = np.unravel_index(indices_to_zero, layer_shape) + weights[indices_to_zero] = 0 + return weights diff --git a/scripts/Chris/DQN/Reservoir.py b/scripts/Chris/DQN/Reservoir.py new file mode 100644 index 00000000..91683228 --- /dev/null +++ b/scripts/Chris/DQN/Reservoir.py @@ -0,0 +1,63 @@ +from bindsnet.network import Network +from bindsnet.network.monitors import Monitor +from bindsnet.network.nodes import Input, AdaptiveLIFNodes +from bindsnet.network.topology import MulticompartmentConnection +from bindsnet.network.topology_features import Weight +from bindsnet.learning.MCC_learning import MSTDP + + +class Reservoir(Network): + def __init__(self, in_size, res_size, hyper_params, + w_in_res, w_res_res, device='cpu'): + super().__init__() + + ## Layers ## + input = Input(n=in_size) + res = AdaptiveLIFNodes( + n=res_size, + thresh=hyper_params['thresh'], + theta_plus=hyper_params['theta_plus'], + refrac=hyper_params['refrac'], + reset=hyper_params['reset'], + tc_theta_decay=hyper_params['tc_theta_decay'], + tc_decay=hyper_params['tc_decay'], + traces=True, + ) + res_monitor = Monitor(res, ["s"], device=device) + self.add_monitor(res_monitor, name='res_monitor') + self.res_monitor = res_monitor + self.add_layer(input, name='input') + self.add_layer(res, name='res') + + ## Connections ## + in_res_wfeat = Weight(name='in_res_weight_feature', value=w_in_res,) + in_res_conn = MulticompartmentConnection( + source=input, target=res, + device=device, pipeline=[in_res_wfeat], + ) + res_res_wfeat = Weight(name='res_res_weight_feature', value=w_res_res, + # learning_rule=MSTDP, + nu=hyper_params['nu'], range=hyper_params['range'], decay=hyper_params['decay']) + res_res_conn = MulticompartmentConnection( + source=res, target=res, + device=device, pipeline=[res_res_wfeat], + ) + self.add_connection(in_res_conn, source='input', target='res') + self.add_connection(res_res_conn, source='res', target='res') + self.res_res_conn = res_res_conn + + ## Migrate ## + self.to(device) + + def store(self, spike_train, sim_time): + self.learning = True + self.run(inputs={'input': spike_train}, time=sim_time, reward=1) + res_spikes = self.res_monitor.get('s') + self.learning = False + return res_spikes + + def recall(self, spike_train, sim_time): + self.learning = False + self.run(inputs={'input': spike_train}, time=sim_time,) + res_spikes = self.res_monitor.get('s') + return res_spikes diff --git a/scripts/Chris/DQN/classify_recalls.py b/scripts/Chris/DQN/classify_recalls.py new file mode 100644 index 00000000..79c8b243 --- /dev/null +++ b/scripts/Chris/DQN/classify_recalls.py @@ -0,0 +1,133 @@ +from torch.optim import Adam +from matplotlib import pyplot as plt +from ANN import ANN +import pickle as pkl +import torch + +class Recalled_Mem_Dataset(torch.utils.data.Dataset): + def __init__(self, samples, labels): + self.samples = samples + self.labels = labels + + def __len__(self): + return len(self.samples) + + def __getitem__(self, idx): + # Compress spike train into windows for dimension reduction + return self.samples[idx].flatten(), self.labels[idx] + +def classify_recalls(out_dim, train_ratio, batch_size): + print("Classifying recalled memories...") + + ## Load recalled memory samples ## + with open('Data/preprocessed_recalls.pkl', 'rb') as f: + samples, labels = pkl.load(f) + + ## Initialize ANN ## + in_dim = samples[0].shape[0] + model = ANN(in_dim, out_dim) + optimizer = Adam(model.parameters()) + criterion = torch.nn.MSELoss() + dataset = Recalled_Mem_Dataset(samples, labels) + train_size = int(train_ratio * len(dataset)) + test_size = len(dataset) - train_size + train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) + train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) + test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=True) + + ## Training ## + loss_log = [] + accuracy_log = [] + for epoch in range(20): + total_loss = 0 + correct = 0 + for memory_batch, positions in train_loader: + # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) + optimizer.zero_grad() + outputs = model(memory_batch) + loss = criterion(outputs, positions.to(torch.float32)) + loss.backward() + optimizer.step() + total_loss += loss.item() + correct += torch.all(outputs.round() == positions.round(), + dim=1).sum().item() + accuracy_log.append(correct / len(train_set)) + loss_log.append(total_loss) + + plt.xlabel('Epoch') + plt.ylabel('Loss') + plt.title('Training Loss') + plt.plot(loss_log) + plt.show() + plt.xlabel('Epoch') + plt.ylabel('Accuracy') + plt.title('Training Accuracy') + plt.plot(accuracy_log) + plt.show() + + ## Testing ## + total = 0 + correct = 0 + with torch.no_grad(): + for memories, labels in test_loader: + outputs = model(memories) + loss = criterion(outputs, labels) + total += len(labels) + correct += torch.all(outputs.round() == labels.round(), + dim=1).sum().item() # Check if prediction for both x and y are correct + + print(f'Accuracy: {round(correct / total, 3)*100}%') + + +# if __name__ == '__main__': + # ## Constants ## + # OUT_DIM = 2 + # TRAIN_RATIO = 0.8 + # BATCH_SIZE = 10 + # + # ## Load recalled memory samples ## + # with open('Data/preprocessed_recalls.pkl', 'rb') as f: + # samples, labels = pkl.load(f) + # + # ## Initialize ANN ## + # in_dim = samples[0].shape[0] * samples[0].shape[1] + # model = ANN(in_dim, OUT_DIM) + # optimizer = Adam(model.parameters()) + # criterion = torch.nn.MSELoss() + # dataset = Recalled_Mem_Dataset(samples, labels) + # train_size = int(TRAIN_RATIO * len(dataset)) + # test_size = len(dataset) - train_size + # train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) + # train_loader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True) + # test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=True) + # + # ## Training ## + # loss_log = [] + # for epoch in range(20): + # total_loss = 0 + # for memory_batch, positions in train_loader: + # # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) + # optimizer.zero_grad() + # outputs = model(memory_batch) + # loss = criterion(outputs, positions.to(torch.float32)) + # loss.backward() + # optimizer.step() + # total_loss += loss.item() + # loss_log.append(total_loss) + # print(f'Epoch: {epoch}, Total Loss: {total_loss}') + # plt.xlabel('Epoch') + # plt.ylabel('Loss') + # plt.plot(loss_log) + # plt.show() + # + # ## Testing ## + # total = 0 + # correct = 0 + # with torch.no_grad(): + # for memories, labels in test_loader: + # outputs = model(memories) + # loss = criterion(outputs, labels) + # total += len(labels) + # correct += torch.all(outputs.round() == labels.round(), dim=1).sum().item() # Check if prediction for both x and y are correct + # + # print(f'Accuracy: {round(correct/total, 3)}%') diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py new file mode 100644 index 00000000..2a7281e3 --- /dev/null +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -0,0 +1,66 @@ +import numpy as np +import pickle as pkl +from sample_generator import sample_generator +from spike_train_generator import spike_train_generator +from store_reservoir import store_reservoir +from recall_reservoir import recall_reservoir +from recalled_mem_preprocessing import recalled_mem_preprocessing +from classify_recalls import classify_recalls + +if __name__ == '__main__': + ## Constants ## + WIDTH = 5 + HEIGHT = 5 + SAMPLES_PER_POS = 1000 + NOISE = 0.1 # Noise in sampling + WINDOW_FREQ = 10 + WINDOW_SIZE = 10 + NUM_CELLS = 20 + X_RANGE = (0, 5) + Y_RANGE = (0, 5) + SIM_TIME = 50 + MAX_SPIKE_FREQ = 0.3 + GC_MULTIPLES = 1 + RES_SIZE = 250 + STORE_SAMPLES = 100 + hyper_params = { + 'thresh': -55, + 'theta_plus': 0, + 'refrac': 1, + 'reset': -65, + 'tc_theta_decay': 500, + 'tc_decay': 30, + 'nu': (0.01, -0.01), + 'range': [-1, 1], + 'decay': None, + } + WINDOW_FREQ = 10 + WINDOW_SIZE = 10 + OUT_DIM = 2 + TRAIN_RATIO = 0.8 + BATCH_SIZE = 10 + PLOT = True + + ## Sample Generation ## + x_offsets = np.random.uniform(-1, 1, NUM_CELLS) + y_offsets = np.random.uniform(-1, 1, NUM_CELLS) + offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets + scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks + vars = [.85] * NUM_CELLS # Variance of Grid Cell activity + # samples, labels, sorted_samples = sample_generator(scales, offsets, vars, X_RANGE, Y_RANGE, SAMPLES_PER_POS, + # noise=NOISE, padding=1, plot=PLOT) + # + # ## Spike Train Generation ## + # spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) + + ## Association (Store) ## + store_reservoir(RES_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) + + ## Association (Recall) ## + # recall_reservoir(RES_SIZE, SIM_TIME, PLOT) + + # # Preprocess Recalls ## + # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) + + ## Train ANN ## + # classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE) diff --git a/scripts/Chris/DQN/recall_memories.py b/scripts/Chris/DQN/recall_memories.py new file mode 100644 index 00000000..58a6f7a0 --- /dev/null +++ b/scripts/Chris/DQN/recall_memories.py @@ -0,0 +1,38 @@ +import pickle as pkl +import numpy as np +import torch + +from Memory import Memory_SNN + +if __name__ == '__main__': + ## Constants ## + KEY_SIZE = 150 + VAL_SIZE = 150 + NUM_GRID_CELLS = 20 + SIM_TIME = 50 + + ## Load memory module and memory keys ## + with open('Data/memory_module.pkl', 'rb') as f: + memory_module = pkl.load(f) + with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: + memory_keys, labels = pkl.load(f) + + ## Recall memories ## + recalled_memories = np.zeros((len(memory_keys), SIM_TIME, VAL_SIZE)) + recalled_memories_sorted = {} + for i, (key, label) in enumerate(zip(memory_keys, labels)): + if i % 100 == 0: + print(f'Recalling memory {i}...') + value_spike_train = memory_module.recall(torch.tensor(key), sim_time=SIM_TIME) # Recall the sample + recalled_memories[i] = value_spike_train.squeeze() # Store the recalled memory + label = tuple(label.round()) + if label not in recalled_memories_sorted: + recalled_memories_sorted[label] = [value_spike_train.squeeze()] + else: + recalled_memories_sorted[label].append(value_spike_train.squeeze()) + + ## Save recalled memories ## + with open('Data/recalled_memories.pkl', 'wb') as f: + pkl.dump((recalled_memories, labels), f) + with open('Data/recalled_memories_sorted.pkl', 'wb') as f: + pkl.dump(recalled_memories_sorted, f) diff --git a/scripts/Chris/DQN/recall_reservoir.py b/scripts/Chris/DQN/recall_reservoir.py new file mode 100644 index 00000000..9fe87d49 --- /dev/null +++ b/scripts/Chris/DQN/recall_reservoir.py @@ -0,0 +1,55 @@ +import pickle as pkl +import numpy as np +import torch +from matplotlib import pyplot as plt + +def recall_reservoir(res_size, sim_time, plot=False): + print("Recalling memories...") + + ## Load memory module and memory keys ## + with open('Data/reservoir_module.pkl', 'rb') as f: + res_module = pkl.load(f) + with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: + memory_keys, labels = pkl.load(f) + + ## Recall memories ## + recalled_memories = np.zeros((len(memory_keys), sim_time, res_size)) + recalled_memories_sorted = {} + for i, (key, label) in enumerate(zip(memory_keys, labels)): + res_spike_train = res_module.recall(torch.tensor(key.reshape(sim_time, -1)), sim_time=sim_time) # Recall the sample + recalled_memories[i] = res_spike_train.squeeze() # Store the recalled memory + label = tuple(label.round()) + if label not in recalled_memories_sorted: + recalled_memories_sorted[label] = [res_spike_train.squeeze()] + else: + recalled_memories_sorted[label].append(res_spike_train.squeeze()) + + ## Save recalled memories ## + with open('Data/recalled_memories.pkl', 'wb') as f: + pkl.dump((recalled_memories, labels), f) + with open('Data/recalled_memories_sorted.pkl', 'wb') as f: + pkl.dump(recalled_memories_sorted, f) + + # Plot recalls + if plot: + positions = np.array([key for key in recalled_memories_sorted.keys()]) + rand_inds = np.random.choice(range(len(positions)), 5) + for pos in positions[rand_inds]: + fig = plt.figure(figsize=(10, 3)) + gs = fig.add_gridspec(1, 6) + ax1 = fig.add_subplot(gs[0, 0]) + ax1.set_title(f"Position: {pos}") + avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) + ax1.imshow(avg_mem.T) + random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5) + random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds] + vmin = np.min(random_samples) + vmax = np.max(random_samples) + for i in range(1, 5): + ax = fig.add_subplot(gs[0, i]) + rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]] + im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax) + ax.set_title(f"S{i}") + ax.set(xticklabels=[]) + ax.set(yticklabels=[]) + plt.show() diff --git a/scripts/Chris/DQN/recalled_mem_preprocessing.py b/scripts/Chris/DQN/recalled_mem_preprocessing.py new file mode 100644 index 00000000..39de5913 --- /dev/null +++ b/scripts/Chris/DQN/recalled_mem_preprocessing.py @@ -0,0 +1,68 @@ +import matplotlib.pyplot as plt +import pickle as pkl +import numpy as np + + +def recalled_mem_preprocessing(window_freq, window_size, plot): + print('Preprocessing recalled memories...') + + ## Load recalled memory spike-trains ## + with open('Data/recalled_memories.pkl', 'rb') as f: + samples, labels = pkl.load(f) # Used as training data, hence samples & labels + + ## Load recalled memory spike-trains ## + with open('Data/recalled_memories_sorted.pkl', 'rb') as f: + recalled_memories_sorted = pkl.load(f) # Used as training data, hence samples & labels + + ## Transformer (reduces sample dimensions) ## + # def windowed_spike_train(spike_train): + # windowed_spikes = np.zeros((len(spike_train) // window_freq, spike_train.shape[1])) + # for i in range(0, len(windowed_spikes)): # Iterate through windows + # if i * window_size + window_size > len(spike_train): # Last window... + # window = spike_train[i * window_freq:] # ...use remaining spikes + # windowed_spikes[i] = window.sum(0) + # else: + # window = spike_train[i * window_size:i * window_size + window_size] + # windowed_spikes[i] = window.sum(0) # Sum spikes in window + # return windowed_spikes + + # new_samples = np.zeros((len(samples), len(samples[0]) // window_freq, samples[0].shape[1])) + new_samples = np.zeros((len(samples), samples[0].shape[1])) + new_samples_sorted = {} + for i, s in enumerate(samples): # Apply transformer to each sample + # s = windowed_spike_train(s) + s = s.sum(0) + new_samples[i] = s + label = tuple(labels[i].round()) + if label not in new_samples_sorted: + new_samples_sorted[label] = [s] + else: + new_samples_sorted[label].append(s) + + ## Save transformed samples ## + with open('Data/preprocessed_recalls.pkl', 'wb') as f: + pkl.dump((new_samples, labels), f) + + if plot: + # positions = np.array([key for key in new_samples_sorted.keys()]) + # fig = plt.figure(figsize=(10, 10)) + # gs = fig.add_gridspec(nrows=5, ncols=5) + # for i, pos in enumerate(positions): + # ax = fig.add_subplot(gs[int(pos[0]), int(pos[1])]) + # avg_mem = np.mean(new_samples_sorted[tuple(pos)], axis=0) + # ax.set_title(f"Conf-Mat: {pos[0] * 5 + pos[1]}") + # im = ax.imshow(np.expand_dims(avg_mem, axis=0)) + # ax.set_aspect('auto') + # plt.tight_layout() + # plt.show() + + fig = plt.figure(figsize=(10, 10)) + gs = fig.add_gridspec(nrows=5, ncols=5) + for i, pos in enumerate(positions): + ax = fig.add_subplot(gs[int(pos[0]), int(pos[1])]) + avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) + ax.set_title(f"Conf-Mat: {pos[0] * 5 + pos[1]}") + im = ax.imshow(np.expand_dims(avg_mem, axis=0).squeeze()) + ax.set_aspect('auto') + plt.tight_layout() + plt.show() \ No newline at end of file diff --git a/scripts/Chris/DQN/sample_generator.py b/scripts/Chris/DQN/sample_generator.py new file mode 100644 index 00000000..e6241d75 --- /dev/null +++ b/scripts/Chris/DQN/sample_generator.py @@ -0,0 +1,85 @@ +from matplotlib import pyplot as plt +import numpy as np +import pickle as pkl + +from scripts.Chris.DQN.Grid_Cells import GC_Module + +# Spread of activity between samples for each position +# We want to minimize this (i.e. we want the activity to be consistent across samples) +def intra_positional_spread(env_to_gc): + spread = {} + for pos, activities in env_to_gc.items(): + avg_activity = np.mean(activities, axis=0) + spread[pos] = np.std(avg_activity) + return spread + +# Spread of activity between positions +# We want to maximize this (i.e. we want the activity to be different across positions) +def inter_positional_spread(env_to_gc): + spread = {} + for pos1, activities1 in env_to_gc.items(): + for pos2, activities2 in env_to_gc.items(): + if pos1 != pos2: + avg_activity1 = np.mean(activities1, axis=0) + avg_activity2 = np.mean(activities2, axis=0) + spread[(pos1, pos2)] = np.linalg.norm(avg_activity1 - avg_activity2) + return spread + +# Generate grid cell activity for all integer coordinate positions in environment +def sample_generator(scales, offsets, vars, x_range, y_range, samples_per_pos, noise=0.1, padding=2, plot=False): + print('Generating samples...') + sorted_samples = {} + samples = np.zeros((x_range[1] * y_range[1] * samples_per_pos, len(scales))) + labels = np.zeros((x_range[1] * y_range[1] * samples_per_pos, 2)) + padded_x_range = (x_range[0] - padding, x_range[1] + padding) + padded_y_range = (y_range[0] - padding, y_range[1] + padding) + module = GC_Module(padded_x_range, padded_y_range, scales, offsets, vars) + for i in range(x_range[1]): + for j in range(y_range[1]): + for k in range(samples_per_pos): # Generate multiple samples for each position + x_sign = 1 if np.random.rand() > 0.5 else -1 # (slight variations in position) + y_sign = 1 if np.random.rand() > 0.5 else -1 + pos = (i + np.random.rand() * noise * x_sign, j + np.random.rand() * noise * y_sign) + a, c = module.generate(pos) + if (i, j) not in sorted_samples: + sorted_samples[(i, j)] = [a] + else: + sorted_samples[(i, j)].append(a) + ind = i * y_range[1] * samples_per_pos + j * samples_per_pos + k + samples[ind] = a + labels[ind] = np.array(pos) + with open('Data/grid_cell_intensities.pkl', 'wb') as f: + pkl.dump((samples, labels), f) + with open('Data/grid_cell_intensities_sorted.pkl', 'wb') as f: + pkl.dump((sorted_samples), f) + + if plot: + module.plot_centers() + plt.title('Grid Cell Centers') + for i in range(x_range[1]): + for j in range(y_range[1]): + plt.plot(i, j, 'r+', markersize=10) + plt.show() + + return samples, labels, sorted_samples + +if __name__ == '__main__': + ## Constants ## + WIDTH = 5 + HEIGHT = 5 + SAMPLES_PER_POS = 1000 + WINDOW_FREQ = 10 + WINDOW_SIZE = 10 + # Grid Cells + num_cells_ = 20 + x_range_ = (0, 5) + y_range_ = (0, 5) + x_offsets_ = np.random.uniform(-1, 1, num_cells_) + y_offsets_ = np.random.uniform(-1, 1, num_cells_) + offsets_ = list(zip(x_offsets_, y_offsets_)) + scales_ = [1 + 0.01 * i for i in range(num_cells_)] + vars_ = [0.85]*num_cells_ + + # Test spread for set of parameters + # Shape = (num_samples, num_cells) + samples_, labels_, sorted_samples_ = sample_generator(scales_, offsets_, vars_, x_range_, y_range_, SAMPLES_PER_POS) diff --git a/scripts/Chris/DQN/spike_train_generator.py b/scripts/Chris/DQN/spike_train_generator.py new file mode 100644 index 00000000..15475073 --- /dev/null +++ b/scripts/Chris/DQN/spike_train_generator.py @@ -0,0 +1,48 @@ +import pickle as pkl +import numpy as np + +# Take in grid cell activity vector and turn into spike train +# max_freq: Maximum frequency of spikes +def intensity_to_spike(intensity, time, max_freq, labels=None): + # Normalize [0, 1] + intensity = (intensity - min(intensity)) / (max(intensity) - min(intensity)) + + # Convert to spike rate + spike_rate = intensity * max_freq + spike_train = np.zeros((time, len(intensity))) + for i, rate in enumerate(spike_rate): + if rate != 0: + spike_train[:, i] = np.zeros(time) + spike_train[:, i][np.random.rand(time) < rate] = 1 + else: + spike_train[:, i] = np.zeros(time) + + return spike_train + +def spike_train_generator(intensities, labels, sim_time, gc_multiples, max_freq): + print("Generating Spike Trains...") + + ## Transform intensities to spike trains ## + with open('Data/grid_cell_intensities.pkl', 'rb') as f: + intensities, labels = pkl.load(f) + # with open('Data/grid_cell_intensities_sorted.pkl', 'rb') as f: + # intensities_sorted = pkl.load(f) + spike_trains = np.zeros( + (len(intensities), sim_time, len(intensities[0]), gc_multiples)) # (num_samples, time, gc, num_gc) + sorted_spike_trains = {} + for i, intensity in enumerate(intensities): + for j in range(gc_multiples): + spike_trains[i, :, :, j] = intensity_to_spike(intensity, sim_time, max_freq) + adjusted_label = (round(labels[i][0]), round(labels[i][1])) + if adjusted_label not in sorted_spike_trains: + sorted_spike_trains[adjusted_label] = [spike_trains[i]] + else: + sorted_spike_trains[adjusted_label].append(spike_trains[i]) + + ## Save to file ## + with open('Data/grid_cell_spk_trains.pkl', 'wb') as f: + pkl.dump((spike_trains, labels), f) + with open('Data/grid_cell_spk_trains_sorted.pkl', 'wb') as f: + pkl.dump((sorted_spike_trains), f) + + return spike_trains, labels, sorted_spike_trains diff --git a/scripts/Chris/DQN/store_memories.py b/scripts/Chris/DQN/store_memories.py new file mode 100644 index 00000000..68694ed3 --- /dev/null +++ b/scripts/Chris/DQN/store_memories.py @@ -0,0 +1,82 @@ +import pickle as pkl +import torch +import numpy as np +from matplotlib import pyplot as plt + +from Memory import Memory_SNN, sparsify + +if __name__ == '__main__': + ## Constants ## + KEY_SIZE = 150 + VAL_SIZE = 150 + NUM_GRID_CELLS = 20 + IN_KEY_SHAPE = (NUM_GRID_CELLS, KEY_SIZE) + IN_VAL_SHAPE = (NUM_GRID_CELLS, VAL_SIZE) + ASSOC_SHAPE = (KEY_SIZE, VAL_SIZE) + SIM_TIME = 50 + WINDOW_FREQ = 10 + WINDOW_SIZE = 10 + NUM_SAMPLES = 2_500 # Number of samples to store + PLOT = True + + ## Initialize Memory SNN ## + w_in_key = torch.rand(IN_KEY_SHAPE) + w_in_val = torch.rand(IN_VAL_SHAPE) + w_assoc = torch.rand(ASSOC_SHAPE) + # w_in_key = assign_inhibition(w_in_key, 0.2, 1) # (weights, %-inhib, scale) + # w_in_val = assign_inhibition(w_in_val, 0.2, 1) + w_in_key = sparsify(w_in_key, 0.5) # (weights, %-zero) + w_in_val = sparsify(w_in_val, 0.5) + # w_assoc = sparsify(w_assoc, 0.25) + hyper_params = { + 'thresh': -40, + 'theta_plus': 5, + 'refrac': 5, + 'reset': -65, + 'tc_theta_decay': 500, + 'tc_decay': 30, # time constant for neuron decay; smaller = faster decay + 'nu': [0.005, 0.005], + 'decay': 0.00001 + } + memory_module = Memory_SNN( + KEY_SIZE, VAL_SIZE, NUM_GRID_CELLS, + w_in_key, w_in_val, w_assoc, + hyper_params + ) + + ## Load grid cell spike-train samples ## + with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: + grid_cell_data, labels = pkl.load(f) # (samples, time, num_cells) + + ## Store memories ## + # -> STDP active + if PLOT: + fig, ax = plt.subplots(1, 2, figsize=(10, 5)) + im = ax[0].imshow(w_assoc) + ax[0].set_title("Initial Association Weights") + plt.colorbar(im, ax=ax[0]) + ax[0].set_xlabel("Value Neuron") + ax[0].set_ylabel("Key Neuron") + + # Store samples + sample_inds = np.random.choice(len(grid_cell_data), NUM_SAMPLES, replace=False) + samples = grid_cell_data[sample_inds] # (#-samples, time, num-cells) + labels = labels[sample_inds] + for i, s in enumerate(samples): + if i % 10 == 0: + print(f"Storing sample {i} of {NUM_SAMPLES}") + memory_module.store(torch.tensor(s), sim_time=SIM_TIME) + memory_module.reset_state_variables() + + if PLOT: + im = ax[1].imshow(w_assoc) + ax[1].set_title("Final Association Weights") + plt.colorbar(im, ax=ax[1]) + ax[1].set_xlabel("Value Neuron") + ax[1].set_ylabel("Key Neuron") + plt.tight_layout() + plt.show() + + ## Save ## + with open('Data/memory_module.pkl', 'wb') as f: + pkl.dump(memory_module, f) diff --git a/scripts/Chris/DQN/store_reservoir.py b/scripts/Chris/DQN/store_reservoir.py new file mode 100644 index 00000000..f244aecb --- /dev/null +++ b/scripts/Chris/DQN/store_reservoir.py @@ -0,0 +1,65 @@ +import torch +from Reservoir import Reservoir +from Memory import sparsify, assign_inhibition +import pickle as pkl +import numpy as np +from matplotlib import pyplot as plt + +def store_reservoir(res_size, num_samples, num_grid_cells, gc_multiples, sim_time, + hyper_params, plot=False): + print("Storing memories...") + + ## Create synaptic weights ## + in_size = num_grid_cells * gc_multiples + w_in_res = torch.rand(in_size, res_size) + w_res_res = torch.rand(res_size, res_size) + w_in_res = sparsify(w_in_res, 0.85) + w_res_res = sparsify(w_res_res, 0.85) + w_res_res = assign_inhibition(w_res_res, 0.2, 1) + res = Reservoir(in_size, res_size, hyper_params, w_in_res, w_res_res) + + ## Load grid cell spike-train samples ## + with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: + grid_cell_data, labels = pkl.load(f) # (samples, time, num_cells) + + ## Store memories ## + # -> STDP active + if plot: + fig, ax = plt.subplots(2, 2, figsize=(10, 5)) + im = ax[0, 0].imshow(w_in_res) + ax[0, 0].set_title("Initial Input-to-Res") + plt.colorbar(im, ax=ax[0, 0]) + ax[0, 0].set_xlabel("Res Neuron") + ax[0, 0].set_ylabel("Input Neuron") + im = ax[0, 1].imshow(w_res_res) + ax[0, 1].set_title("Initial Res-to-Res") + plt.colorbar(im, ax=ax[0, 1]) + ax[0, 1].set_xlabel("Res Neuron") + ax[0, 1].set_ylabel("Res Neuron") + + # Store samples + sample_inds = np.random.choice(len(grid_cell_data), num_samples, replace=False) + samples = grid_cell_data[sample_inds] # (#-samples, time, num-cells) + labels = labels[sample_inds] + np.random.shuffle(samples) + for i, s in enumerate(samples): + res.store(torch.tensor(s.reshape(sim_time, -1)), sim_time=sim_time) + res.reset_state_variables() + + if plot: + im = ax[1, 0].imshow(w_in_res) + ax[1, 0].set_title("Final Input-to-Res") + plt.colorbar(im, ax=ax[1, 0]) + ax[1, 0].set_xlabel("Res Neuron") + ax[1, 0].set_ylabel("Input Neuron") + im = ax[1, 1].imshow(w_res_res) + ax[1, 1].set_title("Final Res-to-Res") + plt.colorbar(im, ax=ax[1, 1]) + ax[1, 1].set_xlabel("Res Neuron") + ax[1, 1].set_ylabel("Res Neuron") + plt.tight_layout() + plt.show() + + ## Save ## + with open('Data/reservoir_module.pkl', 'wb') as f: + pkl.dump(res, f) From e06080f3f925cc09a8815575e73f0dcc4a9ad79d Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Sun, 8 Sep 2024 22:22:13 -0400 Subject: [PATCH 17/27] Split inhib/exc populations --- scripts/Chris/DQN/Eval.ipynb | 76 +++++++++++++++--- scripts/Chris/DQN/Reservoir.py | 107 ++++++++++++++++++------- scripts/Chris/DQN/pipeline_executor.py | 59 ++++++++------ scripts/Chris/DQN/recall_reservoir.py | 14 ++-- scripts/Chris/DQN/store_reservoir.py | 72 +++++++++-------- 5 files changed, 226 insertions(+), 102 deletions(-) diff --git a/scripts/Chris/DQN/Eval.ipynb b/scripts/Chris/DQN/Eval.ipynb index 372dba60..eba7c458 100644 --- a/scripts/Chris/DQN/Eval.ipynb +++ b/scripts/Chris/DQN/Eval.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-09-07T22:31:51.993246Z", - "start_time": "2024-09-07T22:31:51.769117Z" + "end_time": "2024-09-09T01:41:49.738462Z", + "start_time": "2024-09-09T01:41:49.513476Z" } }, "source": [ @@ -17,10 +17,15 @@ "from matplotlib.gridspec import GridSpec " ], "outputs": [], - "execution_count": 3 + "execution_count": 1 }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-09T01:45:32.259311Z", + "start_time": "2024-09-09T01:45:31.554962Z" + } + }, "cell_type": "code", "source": [ "# Plot input spikes\n", @@ -55,14 +60,65 @@ " plt.show()" ], "id": "90ce759a18d4f156", - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-09-08T01:57:39.528962Z", - "start_time": "2024-09-08T01:57:38.519304Z" + "end_time": "2024-09-09T01:45:50.253281Z", + "start_time": "2024-09-09T01:45:49.359509Z" } }, "cell_type": "code", @@ -92,13 +148,13 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAPdCAYAAACXzguGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADd7ElEQVR4nOzdeXxU1f3/8fckIZOAJCEsWRTCpiwioCBpqAr9kh+JoEK/akVUkK8FN7QWVMAKsaLgShGhUvwKChWh1IKKiEUUNxAoiLggArIJJIBIwhqSzPn9wZfBY+ZOtrlJIK/n43EfMOfec+65k3nPzGeWOx5jjBEAAAAAAAi5sKqeAAAAAAAAZyuKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKK7rPApk2b1LNnT8XGxsrj8WjBggVVPSWgSpEJwEYmABuZAGxkwl0U3SGyZcsW3X777WrevLmioqIUExOjX//613ruued07NgxV/c9cOBAffnll3r88cc1a9Ysde7cOeB2L7/8sjwejzwejz755JNi640xaty4sTwej6666qpyzWXcuHEhCWl+fr5GjBih5ORkRUdHKzU1VUuWLKnwuKg8ZOKkUGTi8OHDysrKUmZmpuLj4+XxePTyyy9XaExUPjJxUigysXr1ag0dOlQXXnih6tSpoyZNmuh3v/udvvvuuwqNi8pFJk4KRSa+/vprXX/99WrevLlq166tBg0a6IorrtBbb71VoXFRucjESaGqJ37u8ccfl8fjUbt27UI6bqkZVNjChQtNdHS0iYuLM/fee6+ZNm2amTx5sunXr5+pVauWGTx4sGv7Pnr0qJFk/vSnP5W47YwZM4wkExUVZe68885i6z/44AMjyXi9XtO7d+9yzadOnTpm4MCB5er7c/369TMRERHm/vvvN3/7299MWlqaiYiIMB9//HGFx4b7yMRpocjE1q1bjSTTpEkT0717dyPJzJgxo0JjonKRidNCkYlrr73WJCYmmnvuuce8+OKLZuzYsSYhIcHUqVPHfPnllxUaG5WDTJwWiky8/fbbJiMjwzzyyCNm2rRpZuLEiebyyy83kszf/va3Co2NykEmTgtVPXHKzp07Te3atU2dOnXMhRdeGLJxyyKisov8s83WrVvVr18/paSk6P3331dSUpJ/3d13363Nmzfr7bffdm3/+/btkyTFxcWVuk+vXr00b948TZo0SRERp28Cs2fPVqdOnbR///5QT7NMVq1apTlz5ujpp5/W/fffL0kaMGCA2rVrpwcffFDLly+v0vkhODIReklJSdqzZ48SExP1n//8R5deemmVzgdlQyZCb9iwYZo9e7YiIyP9bTfccIMuuugiPfHEE/r73/9ehbNDSchE6PXq1Uu9evWy2oYOHapOnTppwoQJGjJkSBXNDKVBJtx1//3361e/+pWKioqqbl5VUuqfRe644w4jyXz66ael2r6goMA8+uijpnnz5iYyMtKkpKSYUaNGmePHj1vbpaSkmN69e5uPP/7YXHrppcbr9ZpmzZqZV155xb9NVlaWkWQtKSkpjvs+9crUvHnzjMfjMYsWLfKvy8/PN/Xq1TPPPvusf98/9/TTT5u0tDQTHx9voqKizCWXXGLmzZtnbfPLuUiyXqXasGGD2b59e4nX0QMPPGDCw8NNbm6u1T5u3DgjyezYsaPEMVB1yMRpocrEz61evZp3us8wZOI0NzLxc5dccom55JJLyt0flYNMnOZ2Jq666iqTkJBQ7v6oHGTitFBn4sMPPzTh4eFm/fr1plu3blX2TjdFdwWde+65pnnz5qXefuDAgUaSue6668yUKVPMgAEDjCTTt29fa7uUlBTTqlUrk5CQYB566CEzefJkc8kllxiPx2O++uorY4wxX3zxhfnLX/5iJJkbb7zRzJo1y8yfP99x36dCsnr1atO1a1dzyy23+NctWLDAhIWFmV27dgUMyXnnnWfuuusuM3nyZDNhwgTTpUsXI8ksXLjQv82sWbOM1+s1l19+uZk1a5aZNWuWWb58uX+9JNOtW7cSr6P09HTTpk2bYu3vvfeekWTefPPNEsdA1SEToc/Ez1F0n3nIhLuZOMXn85lzzz3X9OzZs1z9UXnIhHuZOHz4sNm3b5/ZvHmzmTBhggkPDzf9+/cvdX9UDTLhTiYKCwtN+/btze23326MMRTdZ6rc3FwjyfTp06dU269bt85IMr///e+t9vvvv99IMu+//76/LSUlxUgyH330kb9t7969xuv1muHDh/vbTn3X8+mnny5x/z8PyeTJk03dunXN0aNHjTHGXH/99eY3v/mNf9+/DMmp7U45ceKEadeunfmv//ovqz3YdzBKG5ILL7yw2LjGGPP1118bSWbq1KkljoGqQSbcycTPUXSfWciE+5k4ZdasWUaSeemll8rVH5WDTLibidtvv93/7mBYWJi57rrrzIEDB0rdH5WPTLiXicmTJ5vY2Fizd+9eY0zVFt2cvbwC8vLyJEl169Yt1faLFi2SdPK7aD83fPhwSSr2XY22bdvq8ssv919u2LChWrVqpe+//77ccz7ld7/7nY4dO6aFCxfq0KFDWrhwofr37++4fXR0tP//P/30k3Jzc3X55Zdr7dq1pd6nMUbLli0rcbtjx47J6/UWa4+KivKvR/VEJtzJBM5cZKJyMvHtt9/q7rvvVlpamgYOHFjm/qg8ZMLdTNx3331asmSJXnnlFV155ZUqKirSiRMnSt0flY9MuJOJH3/8UWPGjNHo0aPVsGHDUo/vFk6kVgExMTGSpEOHDpVq++3btyssLEwtW7a02hMTExUXF6ft27db7U2aNCk2Rr169fTTTz857qOoqMh/MoRT4uPjrZPNSCcDl56ertmzZ+vo0aMqKirSdddd5zjuwoUL9dhjj2ndunXKz8/3t3s8Hsc+5RUdHW3t45Tjx4/716N6IhPuZAJnLjLhfiays7PVu3dvxcbG6p///KfCw8Nd3R8qhky4m4nWrVurdevWkk6ehLZnz566+uqrtXLlSh6fqiky4U4mHn74YcXHx+uee+4J+djlQdFdATExMUpOTtZXX31Vpn6lvWE5PXEwxjj22blzp5o1a2a1ffDBB+revXuxbfv376/BgwcrOztbV155peMZCz/++GNdc801uuKKK/TXv/5VSUlJqlWrlmbMmKHZs2eX6ljKIikpSbt27SrWvmfPHklScnJyyPeJ0CAT7mQCZy4y4W4mcnNzdeWVV+rgwYP6+OOPeXw4A5CJyn2cuO6663T77bfru+++U6tWrSptvyg9MhH6TGzatEnTpk3TxIkTtXv3bn/78ePHVVBQoG3btikmJkbx8fEh3W8wFN0VdNVVV2natGlasWKF0tLSgm6bkpIin8+nTZs2qU2bNv72nJwcHTx4UCkpKRWeT2JiopYsWWK1dejQIeC2v/3tb3X77bfrs88+09y5cx3HfP311xUVFaV3333X+tj3jBkzim0bileqOnbsqA8++EB5eXn+V/8kaeXKlf71qL7IhI13FkAmbKHKxPHjx3X11Vfru+++03vvvae2bduGZFy4j0zY3HycOPWVvNzcXNf2gYojE7aKZmLXrl3y+Xy69957de+99xZb36xZM/3hD3/QxIkTK7SfsuA73RX04IMPqk6dOvr973+vnJycYuu3bNmi5557TpL8v5/4yz/whAkTJEm9e/eu8HyioqKUnp5uLfXq1Qu47TnnnKMXXnhBjzzyiK6++mrHMcPDw+XxeFRUVORv27ZtmxYsWFBs2zp16ujgwYMBx/n222+1Y8eOEo/huuuuU1FRkaZNm+Zvy8/P14wZM5SamqrGjRuXOAaqDpmwhSITOLORCVsoMlFUVKQbbrhBK1as0Lx580p8korqhUzYQpGJvXv3FmsrKCjQzJkzFR0dzYtS1RyZsFU0E+3atdP8+fOLLRdeeKGaNGmi+fPn67bbbgs6RqjxTncFtWjRQrNnz9YNN9ygNm3aaMCAAWrXrp1OnDih5cuXa968ebr11lslnXyFaODAgZo2bZoOHjyobt26adWqVXrllVfUt29f/eY3v6n0+ZfmhDO9e/fWhAkTlJmZqf79+2vv3r2aMmWKWrZsqfXr11vbdurUSe+9954mTJig5ORkNWvWTKmpqZKkNm3aqFu3biWe/CA1NVXXX3+9Ro0apb1796ply5Z65ZVXtG3bNr300kvlPlZUDjIR+kxI0uTJk3Xw4EH/x6Teeust/fDDD5Kke+65R7GxsWU8UlQWMhH6TAwfPlxvvvmmrr76ah04cEB///vfrfU333xz2Q4SlYpMhD4Tt99+u/Ly8nTFFVfo3HPPVXZ2tl599VV9++23evbZZ3XOOeeU+3jhPjIR2kw0aNBAffv2LdZ+6oWKQOtcVyXnTD8Lfffdd2bw4MGmadOmJjIy0tStW9f8+te/Ns8//7z1Q/UFBQXmz3/+s2nWrJmpVauWady4cdAfs/+lbt26WafJL+8p/oMJtO+XXnrJnH/++cbr9ZrWrVubGTNmmKysLPPLm9C3335rrrjiChMdHV3sx+xVhlP8Hzt2zNx///0mMTHReL1ec+mll5rFixeXqi+qBzJxUqgycepnPwItW7duLdUYqFpk4qRQZKJbt26OeeCpzZmDTJwUiky89tprJj093SQkJJiIiAhTr149k56ebt54440S+6L6IBMnheq50y9V5U+GeYwJ8i16AAAAAABQbnynGwAAAAAAl1B0AwAAAADgEopuAAAAAABc4lrRfeDAAd10002KiYlRXFycbrvtNh0+fDhon+7du8vj8VjLHXfcYW2zY8cO9e7dW7Vr11ajRo30wAMPqLCw0K3DAEKGTAA2MgHYyARgIxM4W7j2k2E33XST9uzZoyVLlqigoECDBg3SkCFDNHv27KD9Bg8erEcffdR/uXbt2v7/FxUVqXfv3kpMTNTy5cu1Z88eDRgwQLVq1dK4cePcOhQgJMgEYCMTgI1MADYygbOFK2cv37Bhg9q2bavVq1erc+fOkqTFixerV69e+uGHH5ScnBywX/fu3dWxY8diP/Z+yjvvvKOrrrpKu3fvVkJCgiRp6tSpGjFihPbt26fIyMiA/fLz85Wfn++/7PP5dODAAdWvX18ej6cCR4ozmTFGhw4dUnJyssLC3P2mBZnAmYBMkAnYyASZgI1MkAnYSp0JN36H7KWXXjJxcXFWW0FBgQkPDzf/+te/HPt169bNNGjQwNSvX99ceOGFZuTIkebIkSP+9aNHjzYdOnSw+nz//fdGklm7dq3juKd+/42FJdCyc+fO8t3Qy4BMsJxJC5lgYbEXMsHCYi9kgoXFXkrKhCsfL8/OzlajRo2stoiICMXHxys7O9uxX//+/ZWSkqLk5GStX79eI0aM0MaNG/Wvf/3LP+6pV6ROOXU52LijRo3SsGHD/Jdzc3PVpEkTXaZeilCtYtt7vN6A45ifvbr1S+H14wO2F/14wLFP7cUNArYfzdzv2Gf3H1MDtif/ZaVjn81/6RSwveUf1zj2iUho5LiuMGdvwPb5333p2Oe3F1zkuK6qFKpAn2iR6tat6/q+zvRMbP9zl4DjpGStctyH0+0h2G0hrHZ0wHbf0WOOfSISEwK2O91OJckTHh6w3fiMYx/5ihxX5f+/SwK2R+9y/t6Z75vvAraHx8U49ik6mOe4zlFY4GMNdDxkovSZkNO7GsE+PFaePiEUdlErx3W+LzcGbHd6PJScD0eSfCccvhsZJEdOyvPYUnRFB8c+W28I/E5Ey7s/L9ZGJkqfifLc5295qnPA9hYP/sexj5Oj1wQeS5Jqvxl4PKfHHEnyHTseeEWQvEacm+S4rnDXHsd1TgZ/vjlg+0sDr3Ls41v/bcD2HQ8Ffv4oSed+HPhYI1Z8Xayt0BTo46I3yYRKzsTxzMDPv6MWOz//9tQK/C67KTjh2MdJdX9enj008G0ycbJzTeNLCzzvsBXOxxpKx64q/jctLDiuNe+OKzETZSq6R44cqSeffDLoNhs2bCjLkJYhQ4b4/3/RRRcpKSlJPXr00JYtW9SiRYtyj+v1euUN8MQhQrUU4QlQdAdokyTj8TnuIzwscEicxpKkWnUC9wk0J/9+vFFl7hMWXfY+EQ7HI0ly6BdT1/kjFcH2VWX+73GzIh8JqimZCIsq+23I6fYQ9LbqCXy783mcT27ieFsNsh+Px6Ho9gQrmJxv30W1HK6f8ALHPj6H+YU7XAdS8PsT504ORXeg4yETxdqdMuFccZaj6A7WJ4TCwp0LaKfbY7DbXLDbic9pXZAcOSnPY4snInAmJSksugz3TWSiWLtTJsp1n1+O5ydOIhzuh4ON5/SYI0k+j9MLREGK7jDnjAV7THJSu27g+++IcmQ53OFxXJIiHKqBYH8HMnGaUyacbpPBr1enGqTsjxPV/Xl5eWoan8N9e1glHU+w+5mSMlGmonv48OG69dZbg27TvHlzJSYmau9e+12mwsJCHThwQImJiaXeX2rqyVdANm/erBYtWigxMVGrVtnvrOXk5EhSmcYFQoVMADYyAdjIBGAjE6iJylR0N2zYUA0bNixxu7S0NB08eFBr1qxRp04n34Z///335fP5/Df80li3bp0kKSkpyT/u448/rr179/o/brJkyRLFxMSobdu2ZTkUICTIBGAjE4CNTAA2MoGayJXTDrZp00aZmZkaPHiwVq1apU8//VRDhw5Vv379/Gca3LVrl1q3bu1/pWnLli0aO3as1qxZo23btunNN9/UgAEDdMUVV6h9+/aSpJ49e6pt27a65ZZb9MUXX+jdd9/Vww8/rLvvvjvgxz2A6oJMADYyAdjIBGAjEzibuHau/1dffVWtW7dWjx491KtXL1122WWaNm2af31BQYE2btyoo0ePSpIiIyP13nvvqWfPnmrdurWGDx+ua6+9Vm+99Za/T3h4uBYuXKjw8HClpaXp5ptv1oABA6zf4QOqKzIB2MgEYCMTgI1M4GzhytnLJSk+Pj7oD9c3bdpU5mdngGzcuLE+/PDDEsdNSUnRokWLQjJHoDKRCcBGJgAbmQBsZAJnC3d/1R4AAAAAgBqMohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuca3oPnDggG666SbFxMQoLi5Ot912mw4fPhx0+3vuuUetWrVSdHS0mjRponvvvVe5ubnWdh6Pp9gyZ84ctw4DCBkyAdjIBGAjE4CNTOBsEeHWwDfddJP27NmjJUuWqKCgQIMGDdKQIUM0e/bsgNvv3r1bu3fv1jPPPKO2bdtq+/btuuOOO7R7927985//tLadMWOGMjMz/Zfj4uLcOgwgZMgEYCMTgI1MADYygbOFK0X3hg0btHjxYq1evVqdO3eWJD3//PPq1auXnnnmGSUnJxfr065dO73++uv+yy1atNDjjz+um2++WYWFhYqIOD3VuLg4JSYmlno++fn5ys/P91/Oy8srz2EB5UYmABuZAGxkArCRCZxNXPl4+YoVKxQXF+cPiCSlp6crLCxMK1euLPU4ubm5iomJsQIiSXfffbcaNGigLl26aPr06TLGBB1n/Pjxio2N9S+NGzcu2wEBFUQmABuZAGxkArCRCZxNXCm6s7Oz1ahRI6stIiJC8fHxys7OLtUY+/fv19ixYzVkyBCr/dFHH9U//vEPLVmyRNdee63uuusuPf/880HHGjVqlHJzc/3Lzp07y3ZAQAWRCcBGJgAbmQBsZAJnkzJ9vHzkyJF68skng26zYcOGCk1IOvlxjd69e6tt27Z65JFHrHWjR4/2///iiy/WkSNH9PTTT+vee+91HM/r9crr9VZ4XsAvkQnARiYAG5kAbGQCNVGZiu7hw4fr1ltvDbpN8+bNlZiYqL1791rthYWFOnDgQInfnTh06JAyMzNVt25dzZ8/X7Vq1Qq6fWpqqsaOHav8/HyCgEpHJgAbmQBsZAKwkQnURGUquhs2bKiGDRuWuF1aWpoOHjyoNWvWqFOnTpKk999/Xz6fT6mpqY798vLylJGRIa/XqzfffFNRUVEl7mvdunWqV68eAUGVIBOAjUwANjIB2MgEaiJXzl7epk0bZWZmavDgwZo6daoKCgo0dOhQ9evXz3+mwV27dqlHjx6aOXOmunTpory8PPXs2VNHjx7V3//+d+Xl5fnPCtiwYUOFh4frrbfeUk5Ojn71q18pKipKS5Ys0bhx43T//fe7cRhAyJAJwEYmABuZAGxkAmcT136n+9VXX9XQoUPVo0cPhYWF6dprr9WkSZP86wsKCrRx40YdPXpUkrR27Vr/mQhbtmxpjbV161Y1bdpUtWrV0pQpU/THP/5Rxhi1bNlSEyZM0ODBg906DCBkyARgIxOAjUwANjKBs4VrRXd8fLzjD9dLUtOmTa1T83fv3r3EU/VnZmZaP2IPnEnIBGAjE4CNTAA2MoGzhSs/GQYAAAAAACi6AQAAAABwDUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BLXi+4pU6aoadOmioqKUmpqqlatWhV0+3nz5ql169aKiorSRRddpEWLFlnrjTEaM2aMkpKSFB0drfT0dG3atMnNQwBCjlwANjIB2MgEYCMTOJO5WnTPnTtXw4YNU1ZWltauXasOHTooIyNDe/fuDbj98uXLdeONN+q2227T559/rr59+6pv37766quv/Ns89dRTmjRpkqZOnaqVK1eqTp06ysjI0PHjx908FCBkyAVgIxOAjUwANjKBM52rRfeECRM0ePBgDRo0SG3bttXUqVNVu3ZtTZ8+PeD2zz33nDIzM/XAAw+oTZs2Gjt2rC655BJNnjxZ0slXpCZOnKiHH35Yffr0Ufv27TVz5kzt3r1bCxYscJxHfn6+8vLyrAWoKtUhF2QC1QmZAGxkArCRCZzpXCu6T5w4oTVr1ig9Pf30zsLClJ6erhUrVgTss2LFCmt7ScrIyPBvv3XrVmVnZ1vbxMbGKjU11XFMSRo/frxiY2P9S+PGjStyaEC5VZdckAlUF2QCsJEJwEYmcDZwrejev3+/ioqKlJCQYLUnJCQoOzs7YJ/s7Oyg25/6tyxjStKoUaOUm5vrX3bu3Fnm4wFCobrkgkyguiATgI1MADYygbNBRFVPoDJ4vV55vd6qngZQbZAJwEYmABuZAGxkAhXh2jvdDRo0UHh4uHJycqz2nJwcJSYmBuyTmJgYdPtT/5ZlTKA6IReAjUwANjIB2MgEzgauFd2RkZHq1KmTli5d6m/z+XxaunSp0tLSAvZJS0uztpekJUuW+Ldv1qyZEhMTrW3y8vK0cuVKxzGB6oRcADYyAdjIBGAjEzgbuPrx8mHDhmngwIHq3LmzunTpookTJ+rIkSMaNGiQJGnAgAE699xzNX78eEnSH/7wB3Xr1k3PPvusevfurTlz5ug///mPpk2bJknyeDy677779Nhjj+n8889Xs2bNNHr0aCUnJ6tv375uHgoQMuQCsJEJwEYmABuZwJnO1aL7hhtu0L59+zRmzBhlZ2erY8eOWrx4sf+kBTt27FBY2Ok327t27arZs2fr4Ycf1kMPPaTzzz9fCxYsULt27fzbPPjggzpy5IiGDBmigwcP6rLLLtPixYsVFRXl5qEAIUMuABuZAGxkArCRCZzpPMYYU9WTqGx5eXmKjY1Vd/VRhKdWsfUeh5MkmPx8xzHDG9QP2F60/0fHPnU+ahiw/cgV+xz77BrRNWD7uU8ud+zz3QtdArZfcOcqxz4RiQmO6wqzcwK2v7t7nWOfjOSOjuuqSqEp0DK9odzcXMXExFT1dKpUSZnY+kTgj1o1G+n8U31Ot4dgt4Ww2rUDtvuOHnXsE5EU+LtXTrdTSfKEhwdsN74gd4e+IsdV+VdeGrA9euch5+G++jZge3hcrGOfooO5juschQU+1kDHQyZOKykT8ngCdwz2kFqePiEU1qGN4zrfFxsCtjs9Hkon3ylyHO9EgcMK5xw5Kc9jS9FvLnHss+XmwN+su+C2/xRrIxOnlZSJ8tznb5qUGrD9/HtXlnl+R/878FiSVPtfgcdzesyRJN+xY4FXBMlrxHnnOq4r/GGX4zond2/6LmD7C9f3dezjW/dNwPbtfw78/FGSzvvgeMD2iE/WF2srNAX6oPB1MqGSM3H8qsDPv6MWOj//9tSKDNhuCk6UeX7V/Xn5nmGBb5NJE5xrGt9lHQO2h32yLgQzKtmxvsX/poUFx7Vy4ZgSM+Had7oBAAAAAKjpKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEteL7ilTpqhp06aKiopSamqqVq1a5bjtiy++qMsvv1z16tVTvXr1lJ6eXmz7W2+9VR6Px1oyMzPdPgwgpMgFYCMTgI1MADYygTOZq0X33LlzNWzYMGVlZWnt2rXq0KGDMjIytHfv3oDbL1u2TDfeeKM++OADrVixQo0bN1bPnj21a9cua7vMzEzt2bPHv7z22mtuHgYQUuQCsJEJwEYmABuZwJnO1aJ7woQJGjx4sAYNGqS2bdtq6tSpql27tqZPnx5w+1dffVV33XWXOnbsqNatW+t///d/5fP5tHTpUms7r9erxMRE/1KvXr2g88jPz1deXp61AFWlOuSCTKA6IROAjUwANjKBM51rRfeJEye0Zs0apaenn95ZWJjS09O1YsWKUo1x9OhRFRQUKD4+3mpftmyZGjVqpFatWunOO+/Ujz/+GHSc8ePHKzY21r80bty47AcEhEB1yQWZQHVBJgAbmQBsZAJnA9eK7v3796uoqEgJCQlWe0JCgrKzs0s1xogRI5ScnGyFLDMzUzNnztTSpUv15JNP6sMPP9SVV16poqIix3FGjRql3Nxc/7Jz587yHRRQQdUlF2QC1QWZAGxkArCRCZwNIqp6Ak6eeOIJzZkzR8uWLVNUVJS/vV+/fv7/X3TRRWrfvr1atGihZcuWqUePHgHH8nq98nq9rs8ZcFuockEmcLYgE4CNTAA2MoHqwLV3uhs0aKDw8HDl5ORY7Tk5OUpMTAza95lnntETTzyhf//732rfvn3QbZs3b64GDRpo8+bNFZ4z4DZyAdjIBGAjE4CNTOBs4FrRHRkZqU6dOlknLDh1AoO0tDTHfk899ZTGjh2rxYsXq3PnziXu54cfftCPP/6opKSkkMwbcBO5AGxkArCRCcBGJnA2cPXs5cOGDdOLL76oV155RRs2bNCdd96pI0eOaNCgQZKkAQMGaNSoUf7tn3zySY0ePVrTp09X06ZNlZ2drezsbB0+fFiSdPjwYT3wwAP67LPPtG3bNi1dulR9+vRRy5YtlZGR4eahACFDLgAbmQBsZAKwkQmc6Vz9TvcNN9ygffv2acyYMcrOzlbHjh21ePFi/4kQduzYobCw03X/Cy+8oBMnTui6666zxsnKytIjjzyi8PBwrV+/Xq+88ooOHjyo5ORk9ezZU2PHjuU7FjhjkAvARiYAG5kAbGQCZzrXT6Q2dOhQDR06NOC6ZcuWWZe3bdsWdKzo6Gi9++67IZoZUHXIBWAjE4CNTAA2MoEzmasfLwcAAAAAoCaj6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLXC+6p0yZoqZNmyoqKkqpqalatWqV47Yvv/yyPB6PtURFRVnbGGM0ZswYJSUlKTo6Wunp6dq0aZPbhwGEFLkAbGQCsJEJwEYmcCZzteieO3euhg0bpqysLK1du1YdOnRQRkaG9u7d69gnJiZGe/bs8S/bt2+31j/11FOaNGmSpk6dqpUrV6pOnTrKyMjQ8ePH3TwUIGTIBWAjE4CNTAA2MoEzXYSbg0+YMEGDBw/WoEGDJElTp07V22+/renTp2vkyJEB+3g8HiUmJgZcZ4zRxIkT9fDDD6tPnz6SpJkzZyohIUELFixQv379AvbLz89Xfn6+/3Jubq4kqVAFkgkwBxP4tQhjCgIfqCTjOxGwvShIn4IjgfsUBulTlB/4jiBYH9+xsveRw/EE65d3yFfmPlWpUCfnZEyAG4GLqkMuypoJn8MDULC/q9PtIVifMBP4ducrx2012H48JvDcgt4WTJHjqsICh+unKD9gu+R8TMbhOpCC3584cjjWQMdDJkqfCckT+GCCXnfl6RM6YeW4PTo9HkqOR/N/4xUGXhEkR07K89hSVOj8pNl3LPAxBRqLTJQ+E+W5zy/X8xMHTvfDwcZzesyRgjzuBLst+JwzVp5jOnoocF7K89hSFKSQLHTKS6BMGDJxSkmZcHxuEPT5SeB71mA1iJPq/ry8XDWNw201rJKOJ9Df9FRbiZkwLsnPzzfh4eFm/vz5VvuAAQPMNddcE7DPjBkzTHh4uGnSpIk577zzzDXXXGO++uor//otW7YYSebzzz+3+l1xxRXm3nvvdZxLVlaW0ck4sLAUW3bu3Fnu23lZVZdckAmWYAuZYGGxFzLBwmIvZIKFxV5KyoRr73Tv379fRUVFSkhIsNoTEhL07bffBuzTqlUrTZ8+Xe3bt1dubq6eeeYZde3aVV9//bXOO+88ZWdn+8f45Zin1gUyatQoDRs2zH/Z5/PpwIEDql+/vg4dOqTGjRtr586diomJKe/hntHy8vJq5HVgjNGhQ4eUnJxcafusLrkgE8GRCTJBJmxkgkyQCRuZIBNkwkYmgmfC1Y+Xl1VaWprS0tL8l7t27ao2bdrob3/7m8aOHVvucb1er7xer9UWFxcn6eRHT6ST3/uoSTeQQGridRAbG1vVUyiRG7kgE6VTE68DMnEamSiuJl4HZOI0MlFcTbwOyMRpZKK4mngdlCYTrp1IrUGDBgoPD1dOTo7VnpOT4/j9il+qVauWLr74Ym3evFmS/P0qMiZQlcgFYCMTgI1MADYygbOBa0V3ZGSkOnXqpKVLl/rbfD6fli5dar3yFExRUZG+/PJLJSUlSZKaNWumxMREa8y8vDytXLmy1GMCVYlcADYyAdjIBGAjEzgrBP3GdwXNmTPHeL1e8/LLL5tvvvnGDBkyxMTFxZns7GxjjDG33HKLGTlypH/7P//5z+bdd981W7ZsMWvWrDH9+vUzUVFR5uuvv/Zv88QTT5i4uDjzxhtvmPXr15s+ffqYZs2amWPHjpVrjsePHzdZWVnm+PHjFTvYMxjXQeWq7rng9sB1UNnIRPXHdVC5yET1x3VQuchE9cd1EJyrRbcxxjz//POmSZMmJjIy0nTp0sV89tln/nXdunUzAwcO9F++7777/NsmJCSYXr16mbVr11rj+Xw+M3r0aJOQkGC8Xq/p0aOH2bhxo9uHAYQUuQBsZAKwkQnARiZwJvMYU8k/tAcAAAAAQA3h2ne6AQAAAACo6Si6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlNb7onjJlipo2baqoqCilpqZq1apVVT0l13z00Ue6+uqrlZycLI/HowULFljrjTEaM2aMkpKSFB0drfT0dG3atKlqJosqQyZOIxOQyMTPkQlIZOLnyAQkMvFzZCKwGl10z507V8OGDVNWVpbWrl2rDh06KCMjQ3v37q3qqbniyJEj6tChg6ZMmRJw/VNPPaVJkyZp6tSpWrlyperUqaOMjAwdP368kmeKqkImbGQCZMJGJkAmbGQCZMJGJhxU4c+VVbkuXbqYu+++23+5qKjIJCcnm/Hjx1fhrCqHJDN//nz/ZZ/PZxITE83TTz/tbzt48KDxer3mtddeq4IZoiqQifn+y2QCxpAJMoFfIhPz/ZfJBIwhE2SidGrsO90nTpzQmjVrlJ6e7m8LCwtTenq6VqxYUYUzqxpbt25Vdna2dX3ExsYqNTW1Rl4fNRGZsJEJkAkbmQCZsJEJkAkbmXBWY4vu/fv3q6ioSAkJCVZ7QkKCsrOzq2hWVefUMXN91FxkwkYmQCZsZAJkwkYmQCZsZMJZjS26AQAAAABwW40tuhs0aKDw8HDl5ORY7Tk5OUpMTKyiWVWdU8fM9VFzkQkbmQCZsJEJkAkbmQCZsJEJZzW26I6MjFSnTp20dOlSf5vP59PSpUuVlpZWhTOrGs2aNVNiYqJ1feTl5WnlypU18vqoiciEjUyATNjIBMiEjUyATNjIhLOIqp5AVRo2bJgGDhyozp07q0uXLpo4caKOHDmiQYMGVfXUXHH48GFt3rzZf3nr1q1at26d4uPj1aRJE91333167LHHdP7556tZs2YaPXq0kpOT1bdv36qbNCoVmSATsJEJMgEbmSATsJEJMlEqVX369Kr2/PPPmyZNmpjIyEjTpUsX89lnn1X1lFzzwQcfGEnFloEDBxpjTp7mf/To0SYhIcF4vV7To0cPs3HjxqqdNCodmSATsJEJMgEbmSATsJEJMlESjzHGVFqFDwAAAABADVJjv9MNAAAAAIDbKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLrPAps2bVLPnj0VGxsrj8ejBQsWVPWUgCpFJgAbmQBsZAKwkQl3UXSHyJYtW3T77berefPmioqKUkxMjH7961/rueee07Fjx1zd98CBA/Xll1/q8ccf16xZs9S5c+eA27388svyeDzyeDz65JNPiq03xqhx48byeDy66qqryjWXcePGVTiky5Yt88/zl8tnn31WobFRecjESaHIxClr167VNddco/j4eNWuXVvt2rXTpEmTQjI23EcmTgpFJm699VbHxwmPx6Ndu3ZVaHxUDjJxUqgeJzZt2qR+/frpvPPOU+3atdW6dWs9+uijOnr0aIXHRuUgEyeFKhNr1qxRZmamYmJiVLduXfXs2VPr1q2r8LjlEVElez3LvP3227r++uvl9Xo1YMAAtWvXTidOnNAnn3yiBx54QF9//bWmTZvmyr6PHTumFStW6E9/+pOGDh1aqj5RUVGaPXu2LrvsMqv9ww8/1A8//CCv11vu+YwbN07XXXed+vbtW+4xTrn33nt16aWXWm0tW7as8LhwH5k4LVSZ+Pe//62rr75aF198sUaPHq1zzjlHW7Zs0Q8//FChcVE5yMRpocjE7bffrvT0dKvNGKM77rhDTZs21bnnnlvusVE5yMRpocjEzp071aVLF8XGxmro0KGKj4/XihUrlJWVpTVr1uiNN94o99ioHGTitFBkYu3atbrsssvUuHFjZWVlyefz6a9//au6deumVatWqVWrVuUeuzwouito69at6tevn1JSUvT+++8rKSnJv+7uu+/W5s2b9fbbb7u2/3379kmS4uLiSt2nV69emjdvniZNmqSIiNM3gdmzZ6tTp07av39/qKdZLpdffrmuu+66qp4GyohMhF5eXp4GDBig3r1765///KfCwviQ0pmETIReWlqa0tLSrLZPPvlER48e1U033VRFs0JpkYnQmzVrlg4ePKhPPvlEF154oSRpyJAh8vl8mjlzpn766SfVq1evSucIZ2Qi9EaPHq3o6GitWLFC9evXlyTdfPPNuuCCC/TQQw/p9ddfr9wJGVTIHXfcYSSZTz/9tFTbFxQUmEcffdQ0b97cREZGmpSUFDNq1Chz/Phxa7uUlBTTu3dv8/HHH5tLL73UeL1e06xZM/PKK6/4t8nKyjKSrCUlJcVx3zNmzDCSzLx584zH4zGLFi3yr8vPzzf16tUzzz77rH/fP/f000+btLQ0Ex8fb6Kioswll1xi5s2bZ23zy7lIMgMHDvSv37Bhg9m+fXuJ19EHH3zgn2deXp4pKCgosQ+qDzJxWqgy8cILLxhJ5ptvvjHGGHP48GFTVFRUYj9UD2TitFBlIpA777zTeDwes3Xr1nL1R+UhE6eFKhMjRowwksy+ffuKtYeFhZnDhw+XOAaqDpk4LVSZqFu3rrn++uuLtffu3dtERkaaQ4cOlThGKFF0V9C5555rmjdvXurtBw4caCSZ6667zkyZMsUMGDDASDJ9+/a1tktJSTGtWrUyCQkJ5qGHHjKTJ082l1xyifF4POarr74yxhjzxRdfmL/85S9GkrnxxhvNrFmzzPz58x33fSokq1evNl27djW33HKLf92CBQtMWFiY2bVrV8CQnHfeeeauu+4ykydPNhMmTDBdunQxkszChQv928yaNct4vV5z+eWXm1mzZplZs2aZ5cuX+9dLMt26dSvxOjpVdJ9zzjlGkgkPDzfdu3c3q1evLrEvqh6ZCH0mrr32WhMTE2OWLFliLrjgAiPJ1KlTx9xxxx3m2LFjJfZH1SIToc/EL504ccLUr1/f/PrXvy5zX1Q+MhH6TLzzzjtGkrnmmmvM559/bnbs2GHmzJljYmJizH333Vdif1QtMhH6TERGRpoBAwYUa7/++uuNJLNixYoSxwgliu4KyM3NNZJMnz59SrX9unXrjCTz+9//3mq///77jSTz/vvv+9tSUlKMJPPRRx/52/bu3Wu8Xq8ZPny4v23r1q1Gknn66adL3P/PQzJ58mRTt25dc/ToUWPMyRvgb37zG/++fxmSU9udcuLECdOuXTvzX//1X1Z7nTp1rFejfq60Ifn000/Ntddea1566SXzxhtvmPHjx5v69eubqKgos3bt2hL7o+qQCXcy0b59e1O7dm1Tu3Ztc88995jXX3/d3HPPPUaS6devX4n9UXXIhDuZ+KW33nrLSDJ//etfy9wXlYtMuJeJsWPHmujoaOsdwj/96U+l6ouqQybcycRFF11kLrjgAlNYWOhvy8/PN02aNDGSzD//+c8SxwglvhhYAXl5eZKkunXrlmr7RYsWSZKGDRtmtQ8fPlySin1Xo23btrr88sv9lxs2bKhWrVrp+++/L/ecT/nd736nY8eOaeHChTp06JAWLlyo/v37O24fHR3t//9PP/2k3NxcXX755Vq7dm2p92mM0bJly0rcrmvXrvrnP/+p//mf/9E111yjkSNH6rPPPpPH49GoUaNKvT9UPjLhTiYOHz6so0ePasCAAZo0aZL++7//W5MmTdLtt9+uOXPmaNOmTaXeJyoXmXAnE780e/Zs1apVS7/73e/K3BeVi0y4l4mmTZvqiiuu0LRp0/T666/rf/7nfzRu3DhNnjy51PtD5SMT7mTirrvu0nfffafbbrtN33zzjb766isNGDBAe/bskSTXzwb/S5xIrQJiYmIkSYcOHSrV9tu3b1dYWFixM3AnJiYqLi5O27dvt9qbNGlSbIx69erpp59+ctxHUVGR/2QIp8THxysyMtJqa9iwodLT0zV79mwdPXpURUVFQU9atnDhQj322GNat26d8vPz/e0ej8exTyi1bNlSffr00b/+9S8VFRUpPDy8UvaLsiET7mTi1IPUjTfeaLX3799ff/vb37RixQqdf/75Id8vKo5MuP84cfjwYb3xxhvKyMjwnywH1ReZcCcTc+bM0ZAhQ/Tdd9/pvPPOkyT993//t3w+n0aMGKEbb7yRfFRTZMKdTNxxxx3auXOnnn76ab3yyiuSpM6dO+vBBx/U448/rnPOOSfk+wyGd7orICYmRsnJyfrqq6/K1K+0NyynwtIY49hn586dSkpKspbly5cH3LZ///565513NHXqVF155ZWOZyz8+OOPdc011ygqKkp//etftWjRIi1ZskT9+/cPOpdQa9y4sU6cOKEjR45U2j5RNmTCnUwkJydLkhISEqz2Ro0aSVLQB05ULTLh/uPEggULOGv5GYRMuJOJv/71r7r44ov9Bfcp11xzjY4eParPP/885PtEaJAJ9x4nHn/8ceXk5Ojjjz/W+vXrtXr1avl8PknSBRdc4Mo+nfBOdwVdddVVmjZtmlasWFHs50t+KSUlRT6fT5s2bVKbNm387Tk5OTp48KBSUlIqPJ/ExEQtWbLEauvQoUPAbX/729/q9ttv12effaa5c+c6jvn6668rKipK7777rvWbezNmzCi2rZvvaHz//feKioqq9FemUDZkwhaKTHTq1ElLlizRrl27rN+V3L17t6STrzSj+iITtlA/Trz66qs655xzdM0114R0XLiHTNhCkYmcnJyAPwlWUFAgSSosLKzwPuAeMmEL5eNEvXr1rN8Sf++993TeeeepdevWIdtHafBOdwU9+OCDqlOnjn7/+98rJyen2PotW7boueeek3Ty9+wkaeLEidY2EyZMkCT17t27wvOJiopSenq6tTj9LuM555yjF154QY888oiuvvpqxzHDw8Pl8XhUVFTkb9u2bZsWLFhQbNs6dero4MGDAcf59ttvtWPHjhKP4ZcfZ5GkL774Qm+++aZ69uzJbxRXc2TCFopMnPqe6ksvvWS1/+///q8iIiLUvXv3EsdA1SETtlBk4pR9+/bpvffe029/+1vVrl271P1QtciELRSZuOCCC/T555/ru+++s9pfe+01hYWFqX379iWOgapDJmyhfJz4ublz52r16tW67777Kr2e4J3uCmrRooVmz56tG264QW3atNGAAQPUrl07nThxQsuXL9e8efN06623Sjr5CtHAgQM1bdo0HTx4UN26ddOqVav0yiuvqG/fvvrNb35T6fMfOHBgidv07t1bEyZMUGZmpvr376+9e/dqypQpatmypdavX29t26lTJ7333nuaMGGCkpOT1axZM6WmpkqS2rRpo27dupV48oMbbrhB0dHR6tq1qxo1aqRvvvlG06ZNU+3atfXEE0+U+1hROchE6DNx8cUX63/+5380ffp0FRYW+vvMmzdPo0aN8n/8HNUTmQh9Jk6ZO3euCgsL+Wj5GYZMhD4TDzzwgN555x1dfvnlGjp0qOrXr6+FCxfqnXfe0e9//3seJ6o5MhH6THz00Ud69NFH1bNnT9WvX1+fffaZZsyYoczMTP3hD38o97GWW6WeK/0s9t1335nBgwebpk2bmsjISFO3bl3z61//2jz//PPWD9UXFBSYP//5z6ZZs2amVq1apnHjxkF/zP6XunXrZp0mv7yn+A8m0L5feuklc/755xuv12tat25tZsyYYbKysswvb0LffvutueKKK/w/WfHz0/2rlKf4f+6550yXLl1MfHy8iYiIMElJSebmm282mzZtKrEvqg8ycVIoMmHMyZ/VeOSRR0xKSoqpVauWadmypfnLX/5Sqr6oHsjESaHKhDHG/OpXvzKNGjWyfhIGZw4ycVKoMrFy5Upz5ZVXmsTERFOrVi1zwQUXmMcff9wUFBSUqj+qHpk4KRSZ2Lx5s+nZs6dp0KCBf3/jx483+fn5JfZ1g8eYSjwTFgAAAAAANQhfjgUAAAAAwCUU3QAAAAAAuISiGwAAAAAAl7hWdB84cEA33XSTYmJiFBcXp9tuu02HDx8O2qd79+7yeDzWcscdd1jb7NixQ71791bt2rXVqFEjPfDAA/z2IM4IZAKwkQnARiYAG5nA2cK1nwy76aabtGfPHi1ZskQFBQUaNGiQhgwZotmzZwftN3jwYD366KP+yz//3c2ioiL17t1biYmJWr58ufbs2aMBAwaoVq1aGjdunFuHAoQEmQBsZAKwkQnARiZwtnDl7OUbNmxQ27ZttXr1anXu3FmStHjxYvXq1Us//PCD428Fdu/eXR07diz2Y++nvPPOO7rqqqu0e/duJSQkSJKmTp2qESNGaN++fYqMjAzYLz8/X/n5+f7LPp9PBw4cUP369eXxeCpwpDiTGWN06NAhJScnKyzM3W9akAmcCcgEmYCNTJAJ2MgEmYCt1Jlw43fIXnrpJRMXF2e1FRQUmPDwcPOvf/3LsV+3bt1MgwYNTP369c2FF15oRo4caY4cOeJfP3r0aNOhQwerz/fff28kmbVr1zqOe+r331hYAi07d+4s3w29DMgEy5m0kAkWFnshEyws9kImWFjspaRMuPLx8uzsbDVq1Mhqi4iIUHx8vLKzsx379e/fXykpKUpOTtb69es1YsQIbdy4Uf/617/84556ReqUU5eDjTtq1CgNGzbMfzk3N1dNmjTRZeqlCNUqtr2nVuBXuEzBCcd9hNeLC9he9NNBxz4n0i8J2B753lrHPvO/+zJg+28vuMixT3lEvdPIcd3xXvsCtofH1nXsU3QwL2D7nntTHfskTVoZsN0T4XyzNU7fxwnwCmShKdAnelt16zrPO1TO9EyU53YXkRD4NlSYs9exT3k43R4cbwsuSFtxPGD7irSoSptDKBSqQJ9oEZlQyZnY/cfA913Jfwl8vyVJ4fH1ArYXHfjJsU9l+X78pQHbm49a7dwpyDs78zeuD9j+29YdncfzFQVsDqtTO2C7JHkSGgZsL/p+u/N+nOYd4IN/ZKL0mXD6O/mOHHXcR5uPAr8rtOEKn2MfR8HeaSzHhzor6/nWTzd3cVxX7++rQrqvUCATpc/E8cxOAceJWrzGcR93r9sYsH1Kx1aOfTxeb8D2zc+3duzTYsgXjuuchLW7IPCK73c69vEdPea4zmne//ryP459/rvtxQHbd0x3mJukxgO+cVwXCqXNRJmK7pEjR+rJJ58Mus2GDRvKMqRlyJAh/v9fdNFFSkpKUo8ePbRlyxa1aNGi3ON6vV55A/xhI1RLEZ4ARXeANkkyHuc77XBP4ELdaSxJ8tUK/IQ80JxOiakb+AEqWJ/yqFUn8PFIUqHDvpyuA8n5egj3OhclTsfk8QQpup0edB2fZKlCHwmqKZkoz+0uIszh9hDi26rT7cHxtuCCqHMCFwuhzqXr/u8ujkyc5pQJp/uuYH/zcIdMBHucqCxhUWU/nmBFTrkeqzyB+4QFe2wJD/ykLeh16jjvAI/xZKJYu1MmnP5OPk+B8z7OcbqdhLjoDvS3LUFlPd8Kjyz786AqRSaKtTtlIqIcz/Nr1w0vcx+n+7uw6NDetsIc7m8V5D7a53F+A8Rp3k7Zk5znHV67CnNUykyUqegePny4br311qDbNG/eXImJidq71343q7CwUAcOHFBiYmKp95eaevKdhM2bN6tFixZKTEzUqlX2q345OTmSVKZxgVAhE4CNTAA2MgHYyARqojIV3Q0bNlTDhoE/yvVzaWlpOnjwoNasWaNOnU5+tOL999+Xz+fz3/BLY926dZKkpKQk/7iPP/649u7d6/+4yZIlSxQTE6O2bduW5VCAkCATgI1MADYyAdjIBGoiV0472KZNG2VmZmrw4MFatWqVPv30Uw0dOlT9+vXzn2lw165dat26tf+Vpi1btmjs2LFas2aNtm3bpjfffFMDBgzQFVdcofbt20uSevbsqbZt2+qWW27RF198oXfffVcPP/yw7r777oAf9wCqCzIB2MgEYCMTgI1M4Gzi2rn+X331VbVu3Vo9evRQr169dNlll2natGn+9QUFBdq4caOOHj15go3IyEi999576tmzp1q3bq3hw4fr2muv1VtvveXvEx4eroULFyo8PFxpaWm6+eabNWDAAOt3+IDqikwANjIB2MgEYCMTOFu4cvZySYqPjw/6w/VNmzaV+dnZJBs3bqwPP/ywxHFTUlK0aNGikMwRqExkArCRCcBGJgAbmcDZwt1ftQcAAAAAoAaj6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLXCu6Dxw4oJtuukkxMTGKi4vTbbfdpsOHDwfd/p577lGrVq0UHR2tJk2a6N5771Vubq61ncfjKbbMmTPHrcMAQoZMADYyAdjIBGAjEzhbRLg18E033aQ9e/ZoyZIlKigo0KBBgzRkyBDNnj074Pa7d+/W7t279cwzz6ht27bavn277rjjDu3evVv//Oc/rW1nzJihzMxM/+W4uDi3DgMIGTIB2MgEYCMTgI1M4GzhStG9YcMGLV68WKtXr1bnzp0lSc8//7x69eqlZ555RsnJycX6tGvXTq+//rr/cosWLfT444/r5ptvVmFhoSIiTk81Li5OiYmJpZ5Pfn6+8vPz/Zfz8vLKc1hAuZEJwEYmABuZAGxkAmcTVz5evmLFCsXFxfkDIknp6ekKCwvTypUrSz1Obm6uYmJirIBI0t13360GDRqoS5cumj59uowxQccZP368YmNj/Uvjxo3LdkBABZEJwEYmABuZAGxkAmcTV4ru7OxsNWrUyGqLiIhQfHy8srOzSzXG/v37NXbsWA0ZMsRqf/TRR/WPf/xDS5Ys0bXXXqu77rpLzz//fNCxRo0apdzcXP+yc+fOsh0QUEFkArCRCcBGJgAbmcDZpEwfLx85cqSefPLJoNts2LChQhOSTn5co3fv3mrbtq0eeeQRa93o0aP9/7/44ot15MgRPf3007r33nsdx/N6vfJ6vRWeF/BLZAKwkQnARiYAG5lATVSmonv48OG69dZbg27TvHlzJSYmau/evVZ7YWGhDhw4UOJ3Jw4dOqTMzEzVrVtX8+fPV61atYJun5qaqrFjxyo/P58goNKRCcBGJgAbmQBsZAI1UZmK7oYNG6phw4YlbpeWlqaDBw9qzZo16tSpkyTp/fffl8/nU2pqqmO/vLw8ZWRkyOv16s0331RUVFSJ+1q3bp3q1atHQFAlyARgIxOAjUwANjKBmsiVs5e3adNGmZmZGjx4sKZOnaqCggINHTpU/fr1859pcNeuXerRo4dmzpypLl26KC8vTz179tTRo0f197//XXl5ef6zAjZs2FDh4eF66623lJOTo1/96leKiorSkiVLNG7cON1///1uHAYQMmQCsJEJwEYmABuZwNnEtd/pfvXVVzV06FD16NFDYWFhuvbaazVp0iT/+oKCAm3cuFFHjx6VJK1du9Z/JsKWLVtaY23dulVNmzZVrVq1NGXKFP3xj3+UMUYtW7bUhAkTNHjwYLcOAwgZMgHYyARgIxOAjUzgbOFa0R0fH+/4w/WS1LRpU+vU/N27dy/xVP2ZmZnWj9gDZxIyAdjIBGAjE4CNTOBs4cpPhgEAAAAAAIpuAAAAAABcQ9ENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuMT1onvKlClq2rSpoqKilJqaqlWrVgXdft68eWrdurWioqJ00UUXadGiRdZ6Y4zGjBmjpKQkRUdHKz09XZs2bXLzEICQIxeAjUwANjIB2MgEzmSuFt1z587VsGHDlJWVpbVr16pDhw7KyMjQ3r17A26/fPly3Xjjjbrtttv0+eefq2/fvurbt6+++uor/zZPPfWUJk2apKlTp2rlypWqU6eOMjIydPz4cTcPBQgZcgHYyARgIxOAjUzgTOdq0T1hwgQNHjxYgwYNUtu2bTV16lTVrl1b06dPD7j9c889p8zMTD3wwANq06aNxo4dq0suuUSTJ0+WdPIVqYkTJ+rhhx9Wnz591L59e82cOVO7d+/WggULHOeRn5+vvLw8awGqSnXIBZlAdUImABuZAGxkAmc614ruEydOaM2aNUpPTz+9s7Awpaena8WKFQH7rFixwtpekjIyMvzbb926VdnZ2dY2sbGxSk1NdRxTksaPH6/Y2Fj/0rhx44ocGlBu1SUXZALVBZkAbGQCsJEJnA1cK7r379+voqIiJSQkWO0JCQnKzs4O2Cc7Ozvo9qf+LcuYkjRq1Cjl5ub6l507d5b5eIBQqC65IBOoLsgEYCMTgI1M4GwQUdUTqAxer1der7eqpwFUG2QCsJEJwEYmABuZQEW49k53gwYNFB4erpycHKs9JydHiYmJAfskJiYG3f7Uv2UZE6hOyAVgIxOAjUwANjKBs4FrRXdkZKQ6deqkpUuX+tt8Pp+WLl2qtLS0gH3S0tKs7SVpyZIl/u2bNWumxMREa5u8vDytXLnScUygOiEXgI1MADYyAdjIBM4Grn68fNiwYRo4cKA6d+6sLl26aOLEiTpy5IgGDRokSRowYIDOPfdcjR8/XpL0hz/8Qd26ddOzzz6r3r17a86cOfrPf/6jadOmSZI8Ho/uu+8+PfbYYzr//PPVrFkzjR49WsnJyerbt6+bhwKEDLkAbGQCsJEJwEYmcKZztei+4YYbtG/fPo0ZM0bZ2dnq2LGjFi9e7D9pwY4dOxQWdvrN9q5du2r27Nl6+OGH9dBDD+n888/XggUL1K5dO/82Dz74oI4cOaIhQ4bo4MGDuuyyy7R48WJFRUW5eShAyJALwEYmABuZAGxkAmc6jzHGVPUkKlteXp5iY2PVXX0U4alVbL2nVmTAfqbghOOY4fXqBWwv+uknxz4nMi8N2B65eLVjn3d3rwvYnpHc0bFPeUR/mOC47lj3vQHbw2NjHPsUHcwN2L77/q6OfZKfWR6w3RPh/FqRKSwMvMLjKdZUaAq0zCxQbm6uYmKc514TlJSJ8tzuIhID34YKs3MCtpeX0+3B8bbggsvXHw/Y/nH7M+uBu9AUaJneIBMqORO7RgS+7zr3ycD3W5IUXj8+YHvRjwfKN8kQ2jzhVwHbWw77zLlTgPvVU97d9XnA9ozzOjmP5ysK2BxWp47zFJIaBWwv2rzVeT9O8w7wdIhMnFZSJpz+Tr4jRxzHbLcm8Lccv+rkK/sEg9weA/1tS1JZz7cODHL+KHP8DOefw60qZOK0kjJx/KouAftFLVzlOOYfN28I2P6Xlm0c+3gcTu723YsXOvY5f8Bax3VOwtq3Drxi8w7HPr6jRx3XOc178daVjn0ym3QO2L79Nefrp8n1XzquC4XSZsK173QDAAAAAFDTUXQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJa4X3VOmTFHTpk0VFRWl1NRUrVq1ynHbF198UZdffrnq1aunevXqKT09vdj2t956qzwej7VkZma6fRhASJELwEYmABuZAGxkAmcyV4vuuXPnatiwYcrKytLatWvVoUMHZWRkaO/evQG3X7ZsmW688UZ98MEHWrFihRo3bqyePXtq165d1naZmZnas2ePf3nttdfcPAwgpMgFYCMTgI1MADYygTOdq0X3hAkTNHjwYA0aNEht27bV1KlTVbt2bU2fPj3g9q+++qruuusudezYUa1bt9b//u//yufzaenSpdZ2Xq9XiYmJ/qVevXpB55Gfn6+8vDxrAapKdcgFmUB1QiYAG5kAbGQCZzrXiu4TJ05ozZo1Sk9PP72zsDClp6drxYoVpRrj6NGjKigoUHx8vNW+bNkyNWrUSK1atdKdd96pH3/8Meg448ePV2xsrH9p3Lhx2Q8ICIHqkgsygeqCTAA2MgHYyATOBq4V3fv371dRUZESEhKs9oSEBGVnZ5dqjBEjRig5OdkKWWZmpmbOnKmlS5fqySef1Icffqgrr7xSRUVFjuOMGjVKubm5/mXnzp3lOyiggqpLLsgEqgsyAdjIBGAjEzgbRFT1BJw88cQTmjNnjpYtW6aoqCh/e79+/fz/v+iii9S+fXu1aNFCy5YtU48ePQKO5fV65fV6XZ8z4LZQ5YJM4GxBJgAbmQBsZALVgWvvdDdo0EDh4eHKycmx2nNycpSYmBi07zPPPKMnnnhC//73v9W+ffug2zZv3lwNGjTQ5s2bKzxnwG3kArCRCcBGJgAbmcDZwLWiOzIyUp06dbJOWHDqBAZpaWmO/Z566imNHTtWixcvVufOnUvczw8//KAff/xRSUlJIZk34CZyAdjIBGAjE4CNTOBs4OrZy4cNG6YXX3xRr7zyijZs2KA777xTR44c0aBBgyRJAwYM0KhRo/zbP/nkkxo9erSmT5+upk2bKjs7W9nZ2Tp8+LAk6fDhw3rggQf02Wefadu2bVq6dKn69Omjli1bKiMjw81DAUKGXAA2MgHYyARgIxM407n6ne4bbrhB+/bt05gxY5Sdna2OHTtq8eLF/hMh7NixQ2Fhp+v+F154QSdOnNB1111njZOVlaVHHnlE4eHhWr9+vV555RUdPHhQycnJ6tmzp8aOHct3LHDGIBeAjUwANjIB2MgEznSun0ht6NChGjp0aMB1y5Ytsy5v27Yt6FjR0dF69913QzQzoOqQC8BGJgAbmQBsZAJnMlc/Xg4AAAAAQE1G0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXuF50T5kyRU2bNlVUVJRSU1O1atUqx21ffvlleTwea4mKirK2McZozJgxSkpKUnR0tNLT07Vp0ya3DwMIKXIB2MgEYCMTgI1M4EzmatE9d+5cDRs2TFlZWVq7dq06dOigjIwM7d2717FPTEyM9uzZ41+2b99urX/qqac0adIkTZ06VStXrlSdOnWUkZGh48ePu3koQMiQC8BGJgAbmQBsZAJnugg3B58wYYIGDx6sQYMGSZKmTp2qt99+W9OnT9fIkSMD9vF4PEpMTAy4zhijiRMn6uGHH1afPn0kSTNnzlRCQoIWLFigfv36BeyXn5+v/Px8/+Xc3FxJUqEKJBNgDsbjsP+CwAcqyZgTAduLgvQpLAgc6rAgffIO+QKPFaRPeRQcCXw8wfbldB1IztdDUb7zHZvTfjwmwB/NP4dChzXF/6anxjdBxnNDdchFWTNRrtudL/DtIdS3Vafbg/NtIfSOHw58TIUmvNLmEAqFIhOnlJQJp/uuYLdv45CJYI8TlcXn8CQzeF4DP1ZK5bzPMEUBm8OCPLZ4ivIDtge/Th3mHeB2TyZKnwmnv5MvyN8i/3Dg934KTeDbT3DOt8dAf9uSVNbzraITZX8eVJXIROkz4fQ8P9jf9eihwPeDwfp4TOAc+Y6F9rYV5nB/qyD30cHy7zRvp+xJzvMuOlp1OSp1JoxL8vPzTXh4uJk/f77VPmDAAHPNNdcE7DNjxgwTHh5umjRpYs477zxzzTXXmK+++sq/fsuWLUaS+fzzz61+V1xxhbn33nsd55KVlWV0Mg4sLMWWnTt3lvt2XlbVJRdkgiXYQiZYWOyFTLCw2AuZYGGxl5Iy4do73fv371dRUZESEhKs9oSEBH377bcB+7Rq1UrTp09X+/btlZubq2eeeUZdu3bV119/rfPOO0/Z2dn+MX455ql1gYwaNUrDhg3zX/b5fDpw4IDq16+vQ4cOqXHjxtq5c6diYmLKe7hntLy8vBp5HRhjdOjQISUnJ1faPqtLLshEcGSCTJAJG5kgE2TCRibIBJmwkYngmXD14+VllZaWprS0NP/lrl27qk2bNvrb3/6msWPHlntcr9crr9drtcXFxUk6+dET6eT3PmrSDSSQmngdxMbGVvUUSuRGLshE6dTE64BMnEYmiquJ1wGZOI1MFFcTrwMycRqZKK4mXgelyYRrJ1Jr0KCBwsPDlZOTY7Xn5OQ4fr/il2rVqqWLL75YmzdvliR/v4qMCVQlcgHYyARgIxOAjUzgbOBa0R0ZGalOnTpp6dKl/jafz6elS5darzwFU1RUpC+//FJJSUmSpGbNmikxMdEaMy8vTytXriz1mEBVIheAjUwANjIB2MgEzgpBv/FdQXPmzDFer9e8/PLL5ptvvjFDhgwxcXFxJjs72xhjzC233GJGjhzp3/7Pf/6zeffdd82WLVvMmjVrTL9+/UxUVJT5+uuv/ds88cQTJi4uzrzxxhtm/fr1pk+fPqZZs2bm2LFj5Zrj8ePHTVZWljl+/HjFDvYMxnVQuap7Lrg9cB1UNjJR/XEdVC4yUf1xHVQuMlH9cR0E52rRbYwxzz//vGnSpImJjIw0Xbp0MZ999pl/Xbdu3czAgQP9l++77z7/tgkJCaZXr15m7dq11ng+n8+MHj3aJCQkGK/Xa3r06GE2btzo9mEAIUUuABuZAGxkArCRCZzJPMZU8g/tAQAAAABQQ7j2nW4AAAAAAGo6im4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcEmNL7qnTJmipk2bKioqSqmpqVq1alVVT8k1H330ka6++molJyfL4/FowYIF1npjjMaMGaOkpCRFR0crPT1dmzZtqprJosqQidPIBCQy8XNkAhKZ+DkyAYlM/ByZCKxGF91z587VsGHDlJWVpbVr16pDhw7KyMjQ3r17q3pqrjhy5Ig6dOigKVOmBFz/1FNPadKkSZo6dapWrlypOnXqKCMjQ8ePH6/kmaKqkAkbmQCZsJEJkAkbmQCZsJEJB1X4c2VVrkuXLubuu+/2Xy4qKjLJyclm/PjxVTiryiHJzJ8/33/Z5/OZxMRE8/TTT/vbDh48aLxer3nttdeqYIaoCmRivv8ymYAxZIJM4JfIxHz/ZTIBY8gEmSidGvtO94kTJ7RmzRqlp6f728LCwpSenq4VK1ZU4cyqxtatW5WdnW1dH7GxsUpNTa2R10dNRCZsZAJkwkYmQCZsZAJkwkYmnNXYonv//v0qKipSQkKC1Z6QkKDs7OwqmlXVOXXMXB81F5mwkQmQCRuZAJmwkQmQCRuZcFZji24AAAAAANxWY4vuBg0aKDw8XDk5OVZ7Tk6OEhMTq2hWVefUMXN91FxkwkYmQCZsZAJkwkYmQCZsZMJZjS26IyMj1alTJy1dutTf5vP5tHTpUqWlpVXhzKpGs2bNlJiYaF0feXl5WrlyZY28PmoiMmEjEyATNjIBMmEjEyATNjLhLKKqJ1CVhg0bpoEDB6pz587q0qWLJk6cqCNHjmjQoEFVPTVXHD58WJs3b/Zf3rp1q9atW6f4+Hg1adJE9913nx577DGdf/75atasmUaPHq3k5GT17du36iaNSkUmyARsZIJMwEYmyARsZIJMlEpVnz69qj3//POmSZMmJjIy0nTp0sV89tlnVT0l13zwwQdGUrFl4MCBxpiTp/kfPXq0SUhIMF6v1/To0cNs3LixaieNSkcmyARsZIJMwEYmyARsZIJMlMRjjDGVVuEDAAAAAFCD1NjvdAMAAAAA4DaKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKK7jPMpk2b1LNnT8XGxsrj8WjBggVVPSWgSpEJwEYmABuZAGxkovJRdJfDli1bdPvtt6t58+aKiopSTEyMfv3rX+u5557TsWPHXN33wIED9eWXX+rxxx/XrFmz1Llz54Dbvfzyy/J4PPJ4PPrkk0+KrTfGqHHjxvJ4PLrqqqvKNZdx48ZVOKSHDx9WVlaWMjMzFR8fL4/Ho5dfftlx+w0bNigzM1PnnHOO4uPjdcstt2jfvn0VmgMqjkycVNmZWLVqle666y516tRJtWrVksfjqdC+ETpk4qTKzITP59PLL7+sa665Ro0bN1adOnXUrl07PfbYYzp+/HiF5oCKIxMnVfbjxIsvvqhu3bopISFBXq9XzZo106BBg7Rt27YKzQEVRyZOqop64pSCggK1bdtWHo9HzzzzTIXmUCKDMlm4cKGJjo42cXFx5t577zXTpk0zkydPNv369TO1atUygwcPdm3fR48eNZLMn/70pxK3nTFjhpFkoqKizJ133lls/QcffGAkGa/Xa3r37l2u+dSpU8cMHDiwXH1P2bp1q5FkmjRpYrp3724kmRkzZgTcdufOnaZBgwamRYsW5rnnnjOPP/64qVevnunQoYPJz8+v0DxQfmTitMrORFZWlqlVq5bp1KmTueCCCwx36dUDmTitMjNx6NAhI8n86le/Mo899piZNm2aGTRokAkLCzPdu3c3Pp+vQvNA+ZGJ0yr7ceLOO+80AwcONM8884x56aWXzMMPP2wSEhJMgwYNzK5duyo0D5QfmTitsjPxc88++6ypU6eOkWSefvrpCs2hJBHulvRnl61bt6pfv35KSUnR+++/r6SkJP+6u+++W5s3b9bbb7/t2v5PvaMbFxdX6j69evXSvHnzNGnSJEVEnP5zz549W506ddL+/ftDPc0ySUpK0p49e5SYmKj//Oc/uvTSSx23HTdunI4cOaI1a9aoSZMmkqQuXbro//2//6eXX35ZQ4YMqaxp4/+QidArSybuvPNOjRgxQtHR0Ro6dKi+++67SpwpAiEToVfaTERGRurTTz9V165d/W2DBw9W06ZNlZWVpaVLlyo9Pb2ypo3/QyZCryyPE3/961+LtfXt21edO3fWzJkzNXLkSDenigDIROiVJROn7N27V48++qhGjBihMWPGuD9JV0v6s8wdd9xhJJlPP/20VNsXFBSYRx991DRv3txERkaalJQUM2rUKHP8+HFru5SUFNO7d2/z8ccfm0svvdR4vV7TrFkz88orr/i3ycrKMpKsJSUlxXHfp16ZmjdvnvF4PGbRokX+dfn5+aZevXrm2Wef9e/7555++mmTlpZm4uPjTVRUlLnkkkvMvHnzrG1+ORdJ1qtUGzZsMNu3by/V9XTK6tWrg74y1ahRI3P99dcXa7/gggtMjx49yrQvhAaZOK0qMvFzd999N+90VwNk4rSqzsQp69evN5LMpEmTyrQvhAaZOK26ZGL//v1GkhkxYkSZ9oXQIBOnVWUmBg0aZLp06WK+//77Snmnm2doZXDuueea5s2bl3r7gQMHGknmuuuuM1OmTDEDBgwwkkzfvn2t7VJSUkyrVq1MQkKCeeihh8zkyZPNJZdcYjwej/nqq6+MMcZ88cUX5i9/+YuRZG688UYza9YsM3/+fMd9nwrJ6tWrTdeuXc0tt9ziX7dgwQITFhZmdu3aFTAk5513nrnrrrvM5MmTzYQJE0yXLl2MJLNw4UL/NrNmzTJer9dcfvnlZtasWWbWrFlm+fLl/vWSTLdu3Up9XRkTPCQ//PCDkWSefPLJYutuvvlmEx8fX6Z9ITTIRNVl4pcouqsHMlF9MnHKv//9byPJzJ49u0z7QmiQieqRif3795ucnByzevVqc/XVVxtJ5t///neZ9oXQIBNVn4mVK1easLAws3z5cv9H0ym6q4nc3FwjyfTp06dU269bt85IMr///e+t9vvvv99IMu+//76/LSUlxUgyH330kb9t7969xuv1muHDh/vbynKj+HlIJk+ebOrWrWuOHj1qjDHm+uuvN7/5zW/8+/5lSE5td8qJEydMu3btzH/9139Z7cG+gxHqkJxaN3PmzGLrHnjgASOp2Ct+cBeZqNpM/BJFd9UjE9UrE6ekp6ebmJgY89NPP5VpX6g4MlF9MuH1ev3vJNavX59PflQRMlH1mfD5fKZLly7mxhtvNMaU7fqoCM5eXkp5eXmSpLp165Zq+0WLFkmShg0bZrUPHz5ckop9V6Nt27a6/PLL/ZcbNmyoVq1a6fvvvy/3nE/53e9+p2PHjmnhwoU6dOiQFi5cqP79+ztuHx0d7f//Tz/9pNzcXF1++eVau3ZtqfdpjNGyZcsqMm3LqbM4er3eYuuioqKsbVA5yETVZgLVD5mofpkYN26c3nvvPT3xxBNl+v4iQoNMVJ9MvPPOO1q0aJGeffZZNWnSREeOHHFlPwiOTFR9Jl5++WV9+eWXevLJJ0M6bkk4kVopxcTESJIOHTpUqu23b9+usLAwtWzZ0mpPTExUXFyctm/fbrWfOjHYz9WrV08//fST4z6KioqK/VxWfHy8IiMjrbaGDRsqPT1ds2fP1tGjR1VUVKTrrrvOcdyFCxfqscce07p165Sfn+9vr8qfIzoV3J/P55RTPwXz83DDfWSiajOB6odMVK9MzJ07Vw8//LBuu+023XnnnVU9nRqJTFSfTPzmN7+RJF155ZXq06eP2rVrp3POOUdDhw6t4pnVLGSiajORl5enUaNG6YEHHlDjxo0rdd+8011KMTExSk5O1ldffVWmfqW9YYWHhwdsN8Y49tm5c6eSkpKsZfny5QG37d+/v9555x1NnTpVV155peMr/h9//LGuueYaRUVF6a9//asWLVqkJUuWqH///kHn4rZTZ3bcs2dPsXV79uxRfHx8wHfB4R4yUbWZQPVDJqpPJpYsWaIBAwaod+/emjp1alVPp8YiE9UnEz/XokULXXzxxXr11Vereio1Dpmo2kw888wzOnHihG644QZt27ZN27Zt0w8//CDp5Lvx27Zt04kTJ1zZN+90l8FVV12ladOmacWKFUpLSwu6bUpKinw+nzZt2qQ2bdr423NycnTw4EGlpKRUeD6JiYlasmSJ1dahQ4eA2/72t7/V7bffrs8++0xz5851HPP1119XVFSU3n33XauInTFjRrFtK/OVqnPPPVcNGzbUf/7zn2LrVq1apY4dO1baXHAambBVl3c0UHXIhK0qMrFy5Ur99re/VefOnfWPf/zD+nkbVD4yYasujxPHjh0L+OlBuI9M2CozEzt27NBPP/2kCy+8sNi6cePGady4cfr8889dqSt4p7sMHnzwQdWpU0e///3vlZOTU2z9li1b9Nxzz0k6+Xt2kjRx4kRrmwkTJkiSevfuXeH5REVFKT093Vrq1asXcNtzzjlHL7zwgh555BFdffXVjmOGh4fL4/GoqKjI37Zt2zYtWLCg2LZ16tTRwYMHA47z7bffaseOHWU6npJce+21WrhwoXbu3OlvW7p0qb777jtdf/31Id0XSodM2Co7E6h+yIStsjOxYcMG9e7dW02bNtXChQv52lE1QCZslZmJwsLCgB8rXrVqlb788kt17tw5ZPtC6ZEJW2Vm4t5779X8+fOt5W9/+5sk6dZbb9X8+fPVrFmzkO3v53j5twxatGih2bNn64YbblCbNm00YMAAtWvXTidOnNDy5cs1b9483XrrrZJOvkI0cOBATZs2TQcPHlS3bt20atUqvfLKK+rbt6//uzWVaeDAgSVu07t3b02YMEGZmZnq37+/9u7dqylTpqhly5Zav369tW2nTp303nvvacKECUpOTlazZs2UmpoqSWrTpo26detWqpMfTJ48WQcPHtTu3bslSW+99Zb/ox733HOPYmNjJUkPPfSQ5s2bp9/85jf6wx/+oMOHD+vpp5/WRRddpEGDBpXlqkCIkImqzcT27ds1a9YsSfJ/CuSxxx6TdPLV8VtuuaUU1wJCiUxUXSYOHTqkjIwM/fTTT3rggQeKnWCoRYsWJb6rhNAjE1WXicOHD6tx48a64YYbdOGFF6pOnTr68ssvNWPGDMXGxmr06NFlvDYQCmSi6jJxySWX6JJLLrH6bdu2TZJ04YUXqm/fviXup9xcPTf6Weq7774zgwcPNk2bNjWRkZGmbt265te//rV5/vnnrZ+tKigoMH/+859Ns2bNTK1atUzjxo2D/pj9L3Xr1s06TX55T/EfTKB9v/TSS+b88883Xq/XtG7d2syYMcNkZWUV+zmib7/91lxxxRUmOjra6Bc/Zq8ynOL/1E8cBFq2bt1qbfvVV1+Znj17mtq1a5u4uDhz0003mezs7FLtB+4hEydVdiY++OADx+3K+hMbCC0ycVJlZuLUsTstTj9Jg8pBJk6qzEzk5+ebP/zhD6Z9+/YmJibG1KpVy6SkpJjbbrut2PMrVD4ycVJV1BM/V1k/GeYxphqe4QEAAAAAgLMA3+kGAAAAAMAlFN0AAAAAALiEohsAAAAAAJe4VnQfOHBAN910k2JiYhQXF6fbbrtNhw8fDtqne/fu8ng81nLHHXdY2+zYsUO9e/dW7dq11ahRIz3wwAMqLCx06zCAkCETgI1MADYyAdjIBM4Wrv1k2E033aQ9e/ZoyZIlKigo0KBBgzRkyBDNnj07aL/Bgwfr0Ucf9V+uXbu2//9FRUXq3bu3EhMTtXz5cu3Zs0cDBgxQrVq1NG7cOLcOBQgJMgHYyARgIxOAjUzgbOHK2cs3bNigtm3bavXq1ercubMkafHixerVq5d++OEHJScnB+zXvXt3dezYsdgPwJ/yzjvv6KqrrtLu3buVkJAgSZo6dapGjBihffv2KTIyMmC//Px85efn+y/7fD4dOHBA9evXl8fjqcCR4kxmjNGhQ4eUnJyssDB3v2lBJnAmIBNkAjYyQSZgIxNkArZSZ8KN3yF76aWXTFxcnNVWUFBgwsPDzb/+9S/Hft26dTMNGjQw9evXNxdeeKEZOXKkOXLkiH/96NGjTYcOHaw+33//vZFk1q5d6zjuqd+EY2EJtOzcubN8N/QyIBMsZ9JCJlhY7IVMsLDYC5lgYbGXkjLhysfLs7Oz1ahRI6stIiJC8fHxys7OduzXv39/paSkKDk5WevXr9eIESO0ceNG/etf//KPe+oVqVNOXQ427qhRozRs2DD/5dzcXDVp0kSXqZciVKvY9mHtWwccx7f+W8d9zP/uy4Dtv73gIsc+Tjb/9WLHdS3v+rzM4/3wQGrA9vOeXuncKdgrdg4fjvB4vc5dCgJ/TyasdQvHPr5vvgu8nwjnm61x+D5O2EWtirUVFuXro2+eU926dR3HC5UzPhN1ahdrkyTfkaOO+whlJipLeIMGjuuK9u93XOd02zc/e0U8FMJjAt9Wi/IOhWT8QhXoEy0iEzqdiW7N71JEePG/b9Gm70s+yNIKC3de5ysK3X6C3K97wgPPYevoSxz7nLvshOO6Wh+sK/W0SuJLc77PeOOVwB8xDdX9DJkonol2vxut8MioYtsvG/NSwHGC/S3CakcHbP+pj3Of2DmrA68I8Qc3za8Cz8Gz8ivHPvH/jnVcd+D/HQzYXnux8+PO0czAjztO15skeaKK/20kqejAT459yoJMlP650w8jHJ5/Pxnk+beTIPff8zeuD9henZ9vSdKvVxwL2L78DufHHfPFhsArylG3hEppM1GmonvkyJF68skng26zYYPDlVEKQ4YM8f//oosuUlJSknr06KEtW7aoRQvn4qwkXq9X3gBPiiNUSxGeAAVGgCdYkuQLsO0pMXUDf5wg0PglCYsOfIdZ3vHCvYHHCzpW0I/JOBTdQcYzDuM5XdeS8/Xt8QQpusuxn4p8JKjGZMIT+KNWPk+B4z5CmYnKEh4W+Dil4Ldvp3XG46vwnH4u3OHvEGxuZWJOjUcmTokI9wYsukN2nUuSJ0jR7QnhxzeDFd0OcwhzeAIvSRERznMLZc59Ec5zcP1+hkwUaw+PjApYdJfnb+H02BJo/JLHC3HR7XC7C5b9WnWcH0Oc5l2ePk7XmyR5HB7HeJyo/OdO5Xr+7STI9X0mPt+SpKhzAr9RFugx9xTjdEzlqFtCppSZKFPRPXz4cN16661Bt2nevLkSExO1d+9eq72wsFAHDhxQYmJiqfeXmnryFaLNmzerRYsWSkxM1KpVq6xtcnJyJKlM4wKhQiYAG5kAbGQCsJEJ1ERlKrobNmyohg0blrhdWlqaDh48qDVr1qhTp06SpPfff18+n89/wy+NdevWSZKSkpL84z7++OPau3ev/+MmS5YsUUxMjNq2bVuWQwFCgkwANjIB2MgEYCMTqIlcOe1gmzZtlJmZqcGDB2vVqlX69NNPNXToUPXr189/psFdu3apdevW/leatmzZorFjx2rNmjXatm2b3nzzTQ0YMEBXXHGF2rdvL0nq2bOn2rZtq1tuuUVffPGF3n33XT388MO6++67A37cA6guyARgIxOAjUwANjKBs4lr5/p/9dVX1bp1a/Xo0UO9evXSZZddpmnTpvnXFxQUaOPGjTp69OSJmCIjI/Xee++pZ8+eat26tYYPH65rr71Wb731lr9PeHi4Fi5cqPDwcKWlpenmm2/WgAEDrN/hA6orMgHYyARgIxOAjUzgbOHK2cslKT4+PugP1zdt2lTmZ2eTa9y4sT788MMSx01JSdGiRYtCMkegMpEJwEYmABuZAGxkAmcLd3/VHgAAAACAGoyiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC5xreg+cOCAbrrpJsXExCguLk633XabDh8+HHT7e+65R61atVJ0dLSaNGmie++9V7m5udZ2Ho+n2DJnzhy3DgMIGTIB2MgEYCMTgI1M4GwR4dbAN910k/bs2aMlS5aooKBAgwYN0pAhQzR79uyA2+/evVu7d+/WM888o7Zt22r79u264447tHv3bv3zn/+0tp0xY4YyMzP9l+Pi4tw6DCBkyARgIxOAjUwANjKBs4UrRfeGDRu0ePFirV69Wp07d5YkPf/88+rVq5eeeeYZJScnF+vTrl07vf766/7LLVq00OOPP66bb75ZhYWFiog4PdW4uDglJiaWej75+fnKz8/3X87LyyvPYQHlRiYAG5kAbGQCsJEJnE1c+Xj5ihUrFBcX5w+IJKWnpyssLEwrV64s9Ti5ubmKiYmxAiJJd999txo0aKAuXbpo+vTpMsYEHWf8+PGKjY31L40bNy7bAQEVRCYAG5kAbGQCsJEJnE1cKbqzs7PVqFEjqy0iIkLx8fHKzs4u1Rj79+/X2LFjNWTIEKv90Ucf1T/+8Q8tWbJE1157re666y49//zzQccaNWqUcnNz/cvOnTvLdkBABZEJwEYmABuZAGxkAmeTMn28fOTIkXryySeDbrNhw4YKTUg6+XGN3r17q23btnrkkUesdaNHj/b//+KLL9aRI0f09NNP695773Ucz+v1yuv1VnhewC+RCcBGJgAbmQBsZAI1UZmK7uHDh+vWW28Nuk3z5s2VmJiovXv3Wu2FhYU6cOBAid+dOHTokDIzM1W3bl3Nnz9ftWrVCrp9amqqxo4dq/z8fIKASkcmABuZAGxkArCRCdREZSq6GzZsqIYNG5a4XVpamg4ePKg1a9aoU6dOkqT3339fPp9Pqampjv3y8vKUkZEhr9erN998U1FRUSXua926dapXrx4BQZUgE4CNTAA2MgHYyARqIlfOXt6mTRtlZmZq8ODBmjp1qgoKCjR06FD169fPf6bBXbt2qUePHpo5c6a6dOmivLw89ezZU0ePHtXf//535eXl+c8K2LBhQ4WHh+utt95STk6OfvWrXykqKkpLlizRuHHjdP/997txGEDIkAnARiYAG5kAbGQCZxPXfqf71Vdf1dChQ9WjRw+FhYXp2muv1aRJk/zrCwoKtHHjRh09elSStHbtWv+ZCFu2bGmNtXXrVjVt2lS1atXSlClT9Mc//lHGGLVs2VITJkzQ4MGD3ToMIGTIBGAjE4CNTAA2MoGzhWtFd3x8vOMP10tS06ZNrVPzd+/evcRT9WdmZlo/Yg+cScgEYCMTgI1MADYygbOFKz8ZBgAAAAAAKLoBAAAAAHANRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEteL7ilTpqhp06aKiopSamqqVq1aFXT7efPmqXXr1oqKitJFF12kRYsWWeuNMRozZoySkpIUHR2t9PR0bdq0yc1DAEKOXAA2MgHYyARgIxM4k7ladM+dO1fDhg1TVlaW1q5dqw4dOigjI0N79+4NuP3y5ct144036rbbbtPnn3+uvn37qm/fvvrqq6/82zz11FOaNGmSpk6dqpUrV6pOnTrKyMjQ8ePH3TwUIGTIBWAjE4CNTAA2MoEznatF94QJEzR48GANGjRIbdu21dSpU1W7dm1Nnz494PbPPfecMjMz9cADD6hNmzYaO3asLrnkEk2ePFnSyVekJk6cqIcfflh9+vRR+/btNXPmTO3evVsLFixwnEd+fr7y8vKsBagq1SEXZALVCZkAbGQCsJEJnOlcK7pPnDihNWvWKD09/fTOwsKUnp6uFStWBOyzYsUKa3tJysjI8G+/detWZWdnW9vExsYqNTXVcUxJGj9+vGJjY/1L48aNK3JoQLlVl1yQCVQXZAKwkQnARiZwNnCt6N6/f7+KioqUkJBgtSckJCg7Oztgn+zs7KDbn/q3LGNK0qhRo5Sbm+tfdu7cWebjAUKhuuSCTKC6IBOAjUwANjKBs0FEVU+gMni9Xnm93qqeBlBtkAnARiYAG5kAbGQCFeHaO90NGjRQeHi4cnJyrPacnBwlJiYG7JOYmBh0+1P/lmVMoDohF4CNTAA2MgHYyATOBq4V3ZGRkerUqZOWLl3qb/P5fFq6dKnS0tIC9klLS7O2l6QlS5b4t2/WrJkSExOtbfLy8rRy5UrHMYHqhFwANjIB2MgEYCMTOBu4+vHyYcOGaeDAgercubO6dOmiiRMn6siRIxo0aJAkacCAATr33HM1fvx4SdIf/vAHdevWTc8++6x69+6tOXPm6D//+Y+mTZsmSfJ4PLrvvvv02GOP6fzzz1ezZs00evRoJScnq2/fvm4eChAy5AKwkQnARiYAG5nAmc7VovuGG27Qvn37NGbMGGVnZ6tjx45avHix/6QFO3bsUFjY6Tfbu3btqtmzZ+vhhx/WQw89pPPPP18LFixQu3bt/Ns8+OCDOnLkiIYMGaKDBw/qsssu0+LFixUVFeXmoQAhQy4AG5kAbGQCsJEJnOk8xhhT1ZOobHl5eYqNjVV39VGEp1ax9WEd2wbs51v3jeOY7+5eF7A9I7ljmef33fTOjusu+J//lHm8nX/qGrC98ePLnTt5PM7rHG4yniAnlzAFhQHbw9qe79jH99W3gfcT4fxakSl02E+HNsXaCovy9f6XTyk3N1cxMTGOY9YEJWaiTp2A/XxHjjiOGcpMVJbwhg0d1xXt2+e4zum2b/LzKzynnwt3uJ0Whei3QgtNgZbpDTKh05nocf4fFRFe/O9btHFz6HYWFu68zlcUuv0EuV/3hAeew5bHLnXs0/i9E47rar23pvTzKoHvso6O65b84+WA7aG6nyETp53KRIebH1d4ZPGiZPXjLwTsF+xvEVa7dsD2A9d1cOwTN+uzwCtC/HTW/LpjwHbP8i8c+9T/JM5x3Y+//ilge52PnB93jlwR+HHH6XqTJE904IKx6McDjn3KgkycVtJzp52jHZ5/jw3y/NtJkPvvd3d9HrC9Oj/fkqRu648FbP9ooHMdZD7/OvCKctQtoVLaTLj2nW4AAAAAAGo6im4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4xPWie8qUKWratKmioqKUmpqqVatWOW774osv6vLLL1e9evVUr149paenF9v+1ltvlcfjsZbMzEy3DwMIKXIB2MgEYCMTgI1M4EzmatE9d+5cDRs2TFlZWVq7dq06dOigjIwM7d27N+D2y5Yt04033qgPPvhAK1asUOPGjdWzZ0/t2rXL2i4zM1N79uzxL6+99pqbhwGEFLkAbGQCsJEJwEYmcKZzteieMGGCBg8erEGDBqlt27aaOnWqateurenTpwfc/tVXX9Vdd92ljh07qnXr1vrf//1f+Xw+LV261NrO6/UqMTHRv9SrVy/oPPLz85WXl2ctQFWpDrkgE6hOyARgIxOAjUzgTOda0X3ixAmtWbNG6enpp3cWFqb09HStWLGiVGMcPXpUBQUFio+Pt9qXLVumRo0aqVWrVrrzzjv1448/Bh1n/Pjxio2N9S+NGzcu+wEBIVBdckEmUF2QCcBGJgAbmcDZwLWie//+/SoqKlJCQoLVnpCQoOzs7FKNMWLECCUnJ1shy8zM1MyZM7V06VI9+eST+vDDD3XllVeqqKjIcZxRo0YpNzfXv+zcubN8BwVUUHXJBZlAdUEmABuZAGxkAmeDiKqegJMnnnhCc+bM0bJlyxQVFeVv79evn///F110kdq3b68WLVpo2bJl6tGjR8CxvF6vvF6v63MG3BaqXJAJnC3IBGAjE4CNTKA6cO2d7gYNGig8PFw5OTlWe05OjhITE4P2feaZZ/TEE0/o3//+t9q3bx902+bNm6tBgwbavHlzhecMuI1cADYyAdjIBGAjEzgbuFZ0R0ZGqlOnTtYJC06dwCAtLc2x31NPPaWxY8dq8eLF6ty5c4n7+eGHH/Tjjz8qKSkpJPMG3EQuABuZAGxkArCRCZwNXD17+bBhw/Tiiy/qlVde0YYNG3TnnXfqyJEjGjRokCRpwIABGjVqlH/7J598UqNHj9b06dPVtGlTZWdnKzs7W4cPH5YkHT58WA888IA+++wzbdu2TUuXLlWfPn3UsmVLZWRkuHkoQMiQC8BGJgAbmQBsZAJnOle/033DDTdo3759GjNmjLKzs9WxY0ctXrzYfyKEHTt2KCzsdN3/wgsv6MSJE7ruuuuscbKysvTII48oPDxc69ev1yuvvKKDBw8qOTlZPXv21NixY/mOBc4Y5AKwkQnARiYAG5nAmc71E6kNHTpUQ4cODbhu2bJl1uVt27YFHSs6OlrvvvtuiGYGVB1yAdjIBGAjE4CNTOBM5urHywEAAAAAqMkougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOAS14vuKVOmqGnTpoqKilJqaqpWrVrluO3LL78sj8djLVFRUdY2xhiNGTNGSUlJio6OVnp6ujZt2uT2YQAhRS4AG5kAbGQCsJEJnMlcLbrnzp2rYcOGKSsrS2vXrlWHDh2UkZGhvXv3OvaJiYnRnj17/Mv27dut9U899ZQmTZqkqVOnauXKlapTp44yMjJ0/PhxNw8FCBlyAdjIBGAjE4CNTOBMF+Hm4BMmTNDgwYM1aNAgSdLUqVP19ttva/r06Ro5cmTAPh6PR4mJiQHXGWM0ceJEPfzww+rTp48kaebMmUpISNCCBQvUr1+/gP3y8/OVn5/vv5ybmytJKlSBZIpvH1aUX7xRks8UBD5QSXmHfAHbC4P0ceI75hz28oxXlB94vOBjeZxXmQBXmiSPcX4Nx5jCgO1O17XkfH17HPZf1v0U/l+bCTKeG6pDLsqcCXMi4L4rKxOVxfgCH6ckFQWZt9Nt34T4WI3D3yHY3MqiUAX/tx8y4c+Ew31UqK7zkxMOnJWT64pCt58g9+sehzn4gjz5LCx0zosnhNePr9B5Dm7fz5CJ4pkoOhH471Gev4XTY4vTPoKOF+K/kXG43QW7bRcccc6E07zL08fpepMkjy/w4xGPE7bKeO5UvuffTpzvv8/E51uSdPxw4Pk5Pe5KwZ5Xlb1uCZVSZ8K4JD8/34SHh5v58+db7QMGDDDXXHNNwD4zZsww4eHhpkmTJua8884z11xzjfnqq6/867ds2WIkmc8//9zqd8UVV5h7773XcS5ZWVlGJ+PAwlJs2blzZ7lv52VVXXJBJliCLWSChcVeyAQLi72QCRYWeykpE669071//34VFRUpISHBak9ISNC3334bsE+rVq00ffp0tW/fXrm5uXrmmWfUtWtXff311zrvvPOUnZ3tH+OXY55aF8ioUaM0bNgw/2Wfz6cDBw6ofv36OnTokBo3bqydO3cqJiamvId7RsvLy6uR14ExRocOHVJycnKl7bO65IJMBEcmyASZsJEJMkEmbGSCTJAJG5kInglXP15eVmlpaUpLS/Nf7tq1q9q0aaO//e1vGjt2bLnH9Xq98nq9VltcXJykkx89kU5+76Mm3UACqYnXQWxsbFVPoURu5IJMlE5NvA7IxGlkoriaeB2QidPIRHE18TogE6eRieJq4nVQmky4diK1Bg0aKDw8XDk5OVZ7Tk6O4/crfqlWrVq6+OKLtXnzZkny96vImEBVIheAjUwANjIB2MgEzgauFd2RkZHq1KmTli5d6m/z+XxaunSp9cpTMEVFRfryyy+VlJQkSWrWrJkSExOtMfPy8rRy5cpSjwlUJXIB2MgEYCMTgI1M4KwQ9BvfFTRnzhzj9XrNyy+/bL755hszZMgQExcXZ7Kzs40xxtxyyy1m5MiR/u3//Oc/m3fffdds2bLFrFmzxvTr189ERUWZr7/+2r/NE088YeLi4swbb7xh1q9fb/r06WOaNWtmjh07Vq45Hj9+3GRlZZnjx49X7GDPYFwHlau654LbA9dBZSMT1R/XQeUiE9Uf10HlIhPVH9dBcK4W3cYY8/zzz5smTZqYyMhI06VLF/PZZ5/513Xr1s0MHDjQf/m+++7zb5uQkGB69epl1q5da43n8/nM6NGjTUJCgvF6vaZHjx5m48aNbh8GEFLkArCRCcBGJgAbmcCZzGNMJf/QHgAAAAAANYRr3+kGAAAAAKCmo+gGAAAAAMAlFN0AAAAAALiEohsAAAAAAJfU+KJ7ypQpatq0qaKiopSamqpVq1ZV9ZRc89FHH+nqq69WcnKyPB6PFixYYK03xmjMmDFKSkpSdHS00tPTtWnTpqqZLKoMmTiNTEAiEz9HJiCRiZ8jE5DIxM+RicBqdNE9d+5cDRs2TFlZWVq7dq06dOigjIwM7d27t6qn5oojR46oQ4cOmjJlSsD1Tz31lCZNmqSpU6dq5cqVqlOnjjIyMnT8+PFKnimqCpmwkQmQCRuZAJmwkQmQCRuZcFCFP1dW5bp06WLuvvtu/+WioiKTnJxsxo8fX4WzqhySzPz58/2XfT6fSUxMNE8//bS/7eDBg8br9ZrXXnutCmaIqkAm5vsvkwkYQybIBH6JTMz3XyYTMIZMkInSqbHvdJ84cUJr1qxRenq6vy0sLEzp6elasWJFFc6samzdulXZ2dnW9REbG6vU1NQaeX3URGTCRiZAJmxkAmTCRiZAJmxkwlmNLbr379+voqIiJSQkWO0JCQnKzs6uollVnVPHzPVRc5EJG5kAmbCRCZAJG5kAmbCRCWc1tugGAAAAAMBtNbbobtCggcLDw5WTk2O15+TkKDExsYpmVXVOHTPXR81FJmxkAmTCRiZAJmxkAmTCRiac1diiOzIyUp06ddLSpUv9bT6fT0uXLlVaWloVzqxqNGvWTImJidb1kZeXp5UrV9bI66MmIhM2MgEyYSMTIBM2MgEyYSMTziKqegJVadiwYRo4cKA6d+6sLl26aOLEiTpy5IgGDRpU1VNzxeHDh7V582b/5a1bt2rdunWKj49XkyZNdN999+mxxx7T+eefr2bNmmn06NFKTk5W3759q27SqFRkgkzARibIBGxkgkzARibIRKlU9enTq9rzzz9vmjRpYiIjI02XLl3MZ599VtVTcs0HH3xgJBVbBg4caIw5eZr/0aNHm4SEBOP1ek2PHj3Mxo0bq3bSqHRkgkzARibIBGxkgkzARibIREk8xhhTaRU+AAAAAAA1SI39TjcAAAAAAG6j6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAP+/vTuPj6q6/z/+nmyTsCQhgAlRCGGRRQUEmjRuYMmPRFDBqgVFCdQGN1waqoIVsaIgihRZKsUKIhVFqlBFimIEaxWBgrh9EQEBUUgQkYRFQpbz+4Nm8Ji5IdvNBPJ6Ph73AXPuOfeeezPvmXwmM3cAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtF9itmyZYv69u2rqKgoeTweLVmyJNBTAgKKTAA2MgHYyARgIxO1j6K7CrZt26abb75Zbdq0UXh4uCIjI3XhhRfqqaee0o8//ujqvjMyMvTpp5/q0Ucf1fz589WzZ0+//Z577jl5PB55PB795z//KbPeGKOWLVvK4/Ho8ssvr9JcJkyYUO2QHjp0SOPGjVN6erpiYmLk8Xj03HPP+e07bNgw3zH9dOnYsWO15oDqIxPH1XYmJKmkpERPP/20unXrpoiICDVt2lS/+tWv9PHHH1drHqgeMnFcbWfC33NE6fL//t//q9Y8UD1k4rhAPE+8/PLL+uUvf6no6Gg1bdpUvXr10htvvFGtOaD6yMRxgcjEjBkz1KlTJ3m9Xp155pnKysrS4cOHqzWHkzKolKVLl5qIiAgTHR1t7rzzTjN79mwzY8YMM3jwYBMaGmoyMzNd2/eRI0eMJPPHP/7xpH3nzp1rJJnw8HBz6623llm/cuVKI8l4vV7Tv3//Ks2nYcOGJiMjo0pjS23fvt1IMq1atTK9e/c2kszcuXP99s3IyDBer9fMnz/fWl577bVqzQHVQyZOqO1MGHM8FyEhIea3v/2teeaZZ8zUqVNNRkaGeeutt6o1D1QdmTihtjPx8+eH+fPnm7vuustIMo8//ni15oGqIxMn1HYmpk2bZiSZ/v37m6efftr8+c9/Nl27djWSzCuvvFKteaDqyMQJtZ2Je++910gy11xzjXn66afNHXfcYUJCQkzfvn2rNYeTCXG3pD+9bN++XYMHD1ZCQoLeeecdtWjRwrfu9ttv19atW1195fC7776TJEVHR1d4TL9+/bRo0SJNmzZNISEnftwLFixQjx49tG/fvpqeZqW0aNFCe/bsUVxcnP773//qF7/4Rbn9Q0JCdMMNN9TS7HAyZKLmVSYTL7/8subNm6dXX31VV111VS3OEk7IRM2rTCb8PT+sWrVKHo9H1113nZvThAMyUfMqk4np06frF7/4hV5//XV5PB5J0m9/+1udeeaZmjdvnn7961/X1rTxP2Si5lU0E3v27NGUKVN044036vnnn/e1n3322brjjjv0+uuv64orrnBnkq6W9KeZW265xUgy77//foX6FxYWmocffti0adPGhIWFmYSEBDNmzBhz9OhRq19CQoLp37+/ee+998wvfvEL4/V6TWJiopk3b56vz7hx44wka0lISHDcd+krU4sWLTIej8csW7bMt66goMA0adLEPPnkk759/9QTTzxhUlJSTExMjAkPDzfdu3c3ixYtsvr8fC6SrFepNm3aZHbu3Fmh81Rq3bp1J/1Ld8OGDU1RUZHJy8ur1LbhDjJxQiAykZycbJKSkowxxhQXF5tDhw5VavuoeWTihEBk4ueOHj1qoqOjTe/evSu1H9QcMnFCIDIRGxvr9y+QcXFxZtCgQZXaF2oGmTihtjPxyiuvGEnmjTfesNq/++47I8lcf/31ldpXZVB0V8KZZ55p2rRpU+H+GRkZvrcvzJw50wwdOtRIMgMHDrT6JSQkmA4dOpjY2Fhz//33mxkzZpju3bsbj8djPvvsM2OMMR9//LH585//bCSZ6667zsyfP98sXrzYcd+lIVm3bp254IILzI033uhbt2TJEhMUFGS+/fZbvyE566yzzG233WZmzJhhpkyZYpKSkowks3TpUl+f+fPnG6/Xay6++GLfW/g++OAD33pJplevXhU+V8ZUrOj2eDymQYMGRpJp0qSJue2228zBgwcrtR/UHDIRuEzk5eUZj8djbr/9djNmzBjTqFEjI8kkJiaahQsXVmo/qDlkIrDPEz/36quvGknmmWeeqdR+UHPIRGAzMWjQIBMcHGymTZtmtm/fbjZt2mRuu+02ExERYe0btYdMBC4TCxYsMJLMO++8Y7UfPnzYSDIdOnSo1L4qg6K7gvLy8owkM2DAgAr137hxo5Fkfve731ntf/jDH8r8sBMSEowk8+9//9vXtnfvXuP1es2oUaN8baWfV3jiiSdOuv+fhmTGjBmmcePG5siRI8YYY6699lpz6aWX+vb985CU9it17Ngxc+6555pf/epXVnt5n8Fw44lj9OjR5r777jMLFy40L774ou9B6MILLzSFhYWV2heqj0wENhMbNmwwkkzTpk1NbGys+ctf/mJeeOEFk5SUZDwej/nXv/5VqX2h+shE4J8nfu7qq682Xq/X/PDDD5XaD2oGmQh8JnJzc02fPn2svyQ2a9aMgjtAyERgM7F+/XojyYwfP95qX758uZFkGjVqVKl9VQZXL6+g/Px8SVLjxo0r1H/ZsmWSpKysLKt91KhRklTmsxqdO3fWxRdf7LvdvHlzdejQQV999VWV51zqN7/5jX788UctXbpUBw8e1NKlS3X99dc79o+IiPD9/4cfflBeXp4uvvhibdiwocL7NMZo1apV1Zl2GRMnTtRjjz2m3/zmNxo8eLCee+45Pfroo3r//ff1j3/8o0b3hZMjE4HNxKFDhyRJ33//vf75z3/q1ltv1fXXX6/s7Gw1bdpUjzzySI3tCxVDJgL/PPFT+fn5euONN9SvX79KfXYRNYdMBD4TDRo0UIcOHZSRkaFFixZpzpw5atGihX79619r69atNbovnByZCGwmunfvruTkZE2aNElz587Vjh079K9//Us333yzQkNDXb1qPBdSq6DIyEhJ0sGDByvUf+fOnQoKClK7du2s9ri4OEVHR2vnzp1We6tWrcpso0mTJvrhhx8c91FcXOy7GEKpmJgYhYWFWW3NmzdXamqqFixYoCNHjqi4uFjXXHON43aXLl2qRx55RBs3blRBQYGvvfQCHHXJ73//e40dO1Zvv/22Bg8eHOjp1CtkIrCZKH0yS0xMVHJysq+9UaNGuuKKK/T3v/9dRUVF1gVP4C4yUbeeJ1555RUdPXpUQ4YMCfRU6i0yEfhMXHvttQoJCdHrr7/uaxswYIDat2+vP/7xj1q4cGEAZ1f/kInAZ+KVV17RoEGD9Nvf/laSFBwcrKysLL377rvavHmza/vlt7EKioyMVHx8vD777LNKjavoHSs4ONhvuzHGccyuXbuUmJhota1cuVK9e/cu0/f6669XZmamcnJydNlllzm+6v/ee+/pyiuv1CWXXKK//OUvatGihUJDQzV37lwtWLCgQsdSm0q/l3j//v2Bnkq9QyYCm4n4+HhJUmxsbJl1Z5xxhgoLC3X48GFFRUXV9tTqLTJRt54nXnjhBUVFRVX5u2NRfWQisJn46quvtHz5cs2ePdtqj4mJ0UUXXaT3338/QDOrv8hE4J8nzjzzTP3nP//Rli1blJOTo/bt2ysuLk7x8fE6++yzXdsvRXclXH755Zo9e7ZWr16tlJSUcvsmJCSopKREW7ZsUadOnXztubm5OnDggBISEqo9n7i4OK1YscJq69q1q9++V111lW6++WZ9+OGH5b6q+corryg8PFxvvvmmvF6vr33u3Lll+gb6lSrp+CuF+/btU/PmzQM9lXqJTNhqMxPx8fGKi4vTt99+W2bd7t27FR4eXuG3r6HmkAlboJ4n9uzZo5UrV2rYsGHWHFH7yIStNjORm5sr6fhfMn+usLBQRUVFtTYXnEAmbIF6nmjfvr3at28vSfq///s/7dmzR8OGDXNtf3ymuxLuvfdeNWzYUL/73e98D2Q/tW3bNj311FOSjn+fnSRNnTrV6jNlyhRJUv/+/as9n/DwcKWmplpLkyZN/PZt1KiRnn76aT300EPlfv9ccHCwPB6P9QC9Y8cOLVmypEzfhg0b6sCBA36388UXX+jrr7+u1PGU5+jRo37fijN+/HgZY5Senl5j+0LFkQlbbWZCkgYNGqRdu3ZZT5b79u3TP//5T/3qV79SUBAP8bWNTNhqOxOlXnrpJZWUlPDW8jqATNhqMxPt2rVTUFCQFi5caP2l85tvvtF7772n888/v8b2hYojE7ZAPU+UKikp0b333qsGDRrolltucW0//KW7Etq2basFCxZo0KBB6tSpk4YOHapzzz1Xx44d0wcffKBFixb5XiHp2rWrMjIyNHv2bB04cEC9evXS2rVrNW/ePA0cOFCXXnpprc8/IyPjpH369++vKVOmKD09Xddff7327t2rmTNnql27dvrkk0+svj169NDbb7+tKVOmKD4+3vpsaadOndSrV68KXfxgxowZOnDggHbv3i1Jev311/XNN99Iku644w5FRUUpJydH559/vq677jp17NhRkvTmm29q2bJlSk9P14ABAypzKlBDyETgMiFJY8aM0csvv6yrr75aWVlZioqK0qxZs1RYWKgJEyZU5lSghpCJwGai1AsvvKD4+Hi/b49E7SITgctE8+bN9dvf/lZ/+9vf1KdPH/3617/WwYMH9Ze//EU//vijxowZU8mzgZpAJgL7PHHXXXfp6NGj6tatmwoLC7VgwQLfOfX3mfga49p10U9jX375pcnMzDStW7c2YWFhpnHjxubCCy8006dPt76ovrCw0PzpT38yiYmJJjQ01LRs2bLcL7P/uV69elmXya/qJf7L42/fzz77rGnfvr3xer2mY8eOZu7cuWbcuHHm53eXL774wlxyySUmIiLC6GdfZq9KXOK/9CsO/C3bt283xhjzww8/mBtuuMG0a9fONGjQwHi9XnPOOeeYCRMmmGPHjlVoP3APmTiuNjNRatu2beaqq64ykZGRJiIiwvzqV78ya9eurdB+4B4ycVwgMvHFF18YSSYrK6tC20btIBPH1XYmCgsLzfTp0023bt1Mo0aNTKNGjcyll15a5nuKUfvIxHG1nYm5c+earl27moYNG5rGjRubPn361EoePMaU88l6AAAAAABQZXzgDwAAAAAAl1B0AwAAAADgEopuAAAAAABc4lrRvX//fg0ZMkSRkZGKjo7WTTfdpEOHDpU7pnfv3vJ4PNby80u3f/311+rfv78aNGigM844Q/fccw/fM4hTApkAbGQCsJEJwEYmcLpw7SvDhgwZoj179mjFihUqLCzU8OHDNWLECC1YsKDccZmZmXr44Yd9txs0aOD7f3Fxsfr376+4uDh98MEH2rNnj4YOHarQ0FC+Hgd1HpkAbGQCsJEJwEYmcLpw5erlmzZtUufOnbVu3Tr17NlTkrR8+XL169dP33zzjeLj4/2O6927t7p161bmC+BL/etf/9Lll1+u3bt3KzY2VpI0a9Ys3Xffffruu+8UFhbmd1xBQYEKCgp8t0tKSrR//341bdpUHo+nGkeKU5kxRgcPHlR8fLyCgtz9pAWZwKmATJAJ2MgEmYCNTJAJ2CqcCTe+h+zZZ5810dHRVlthYaEJDg42r776quO4Xr16mWbNmpmmTZuac845x4wePdocPnzYt37s2LGma9eu1pivvvrKSDIbNmxw3G7pd8KxsPhbdu3aVbU7eiWQCZZTaSETLCz2QiZYWOyFTLCw2MvJMuHK28tzcnJ0xhlnWG0hISGKiYlRTk6O47jrr79eCQkJio+P1yeffKL77rtPmzdv1quvvurbbukrUqVKb5e33TFjxigrK8t3Oy8vT61atdJF6qcQhZYdEBTsf0MlxY77qEmeUP+vsEmSKTxW6e394oNCv+3rLvBz7P8THB3puK74QL7f9sVffuo45qqzz3NcFyhFKtR/tEyNGzd2fV+neiacfrbl/lydXvWt+TfX1JigcK/jupKjBY7rnPJScvio4xjHLJf3arnL545MlM3EhT3+oJCQsveLkP1H/G6neMtXjvtwemz3hDk/FZcc9r+fqqjKY/Su0cmOY1r/dbPjupKD/j9zaarwmclu/ylxXPfpgGZ+23Ovauc4Jm7pTr/tRTm5ZdvIhO92aSZ69L1fIaHhZfo3ePNjv9v55q4ejvtYe/Pf/LZfu/X/OY4p6uc858oKbpfouK546/ZKby/kLP9/eZWkom92V3p7ToKb+b/fS1Lxvn1+28vLcqvJ6/22+8srmaj4705Oj/nbZ3Vw3Ef8i/6fDyLWO98f/7HmPb/t5f2OVtS7m9/2kFUbHcfUtLs+/txv+1Ndz6m1OVSWJ6Tsz6fIFOq94tdOmolKFd2jR4/WpEmTyu2zadOmymzSMmLECN//zzvvPLVo0UJ9+vTRtm3b1LZt2ypv1+v1yuv180uTQhXi8VN4ehyKbk/tXOzd429O/2M8lf+l29vIf7vfY/+fYI9z4e80v8jGzuenvH0FzP9OZXXeElRfMuH0sy335+p4Xutw0V3O/b7E4/yLv1NeSjzOL9Q5Zrnc+6PL545MlGkPCfEqJKRsgRES7P9nW97jt9O68saUePy/aFoVVXmMDvaWPfYTY8rLi//tmSrct7yNnLMXEuR/DsFh5czbYYz8zZlMlGkPCQ33W3RX5T7kdJ8Mbeh83/L7c6qi4GDnF1rLy6WTkCDn7dXovJ3uw3Ked/lZrkReyUSZdqffnZx+FkENyvlZ+CnqpPIfb6v0O5qf57WTjqlhDRv7r7fqZM3wPx6Pc+l8skxUqugeNWqUhg0bVm6fNm3aKC4uTnv37rXai4qKtH//fsXFxVV4f8nJx1+V27p1q9q2bau4uDitXbvW6pObe/yV6cpsF6gpZAKwkQnARiYAG5lAfVSport58+Zq3rz5SfulpKTowIEDWr9+vXr0OP62onfeeUclJSW+O35FbNy4UZLUokUL33YfffRR7d271/d2kxUrVigyMlKdO3euzKEANYJMADYyAdjIBGAjE6iPXHm/dKdOnZSenq7MzEytXbtW77//vkaOHKnBgwf7rjT47bffqmPHjr5XmrZt26bx48dr/fr12rFjh1577TUNHTpUl1xyibp06SJJ6tu3rzp37qwbb7xRH3/8sd5880098MADuv322/2+3QOoK8gEYCMTgI1MADYygdOJax9SfuGFF9SxY0f16dNH/fr100UXXaTZs2f71hcWFmrz5s06cuT4RWLCwsL09ttvq2/fvurYsaNGjRqlq6++Wq+//rpvTHBwsJYuXarg4GClpKTohhtu0NChQ63v4QPqKjIB2MgEYCMTgI1M4HThytXLJSkmJqbcL65v3bq1zE+uxNuyZUu9++67J91uQkKCli1bViNzBGoTmQBsZAKwkQnARiZwuqidy3EDAAAAAFAPUXQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJa4V3fv379eQIUMUGRmp6Oho3XTTTTp06FC5/e+44w516NBBERERatWqle68807l5eVZ/TweT5nlpZdecuswgBpDJgAbmQBsZAKwkQmcLkLc2vCQIUO0Z88erVixQoWFhRo+fLhGjBihBQsW+O2/e/du7d69W5MnT1bnzp21c+dO3XLLLdq9e7f+8Y9/WH3nzp2r9PR03+3o6Gi3DgOoMWQCsJEJwEYmABuZwOnClaJ706ZNWr58udatW6eePXtKkqZPn65+/fpp8uTJio+PLzPm3HPP1SuvvOK73bZtWz366KO64YYbVFRUpJCQE1ONjo5WXFxchedTUFCggoIC3+38/PyqHBZQZWQCsJEJwEYmABuZwOnElbeXr169WtHR0b6ASFJqaqqCgoK0Zs2aCm8nLy9PkZGRVkAk6fbbb1ezZs2UlJSkOXPmyBhT7nYmTpyoqKgo39KyZcvKHRBQTWQCsJEJwEYmABuZwOnElaI7JydHZ5xxhtUWEhKimJgY5eTkVGgb+/bt0/jx4zVixAir/eGHH9bLL7+sFStW6Oqrr9Ztt92m6dOnl7utMWPGKC8vz7fs2rWrcgcEVBOZAGxkArCRCcBGJnA6qdTby0ePHq1JkyaV22fTpk3VmpB0/O0a/fv3V+fOnfXQQw9Z68aOHev7//nnn6/Dhw/riSee0J133um4Pa/XK6/XW+15AT9HJgAbmQBsZAKwkQnUR5UqukeNGqVhw4aV26dNmzaKi4vT3r17rfaioiLt37//pJ+dOHjwoNLT09W4cWMtXrxYoaGh5fZPTk7W+PHjVVBQQBBQ68gEYCMTgI1MADYygfqoUkV38+bN1bx585P2S0lJ0YEDB7R+/Xr16NFDkvTOO++opKREycnJjuPy8/OVlpYmr9er1157TeHh4Sfd18aNG9WkSRMCgoAgE4CNTAA2MgHYyATqI1euXt6pUyelp6crMzNTs2bNUmFhoUaOHKnBgwf7rjT47bffqk+fPnr++eeVlJSk/Px89e3bV0eOHNHf//535efn+64K2Lx5cwUHB+v1119Xbm6ufvnLXyo8PFwrVqzQhAkT9Ic//MGNwwBqDJkAbGQCsJEJwEYmcDpx7Xu6X3jhBY0cOVJ9+vRRUFCQrr76ak2bNs23vrCwUJs3b9aRI0ckSRs2bPBdibBdu3bWtrZv367WrVsrNDRUM2fO1O9//3sZY9SuXTtNmTJFmZmZbh0GUGPIBGAjE4CNTAA2MoHThWtFd0xMjOMX10tS69atrUvz9+7d+6SX6k9PT7e+xB44lZAJwEYmABuZAGxkAqcLV74yDAAAAAAAUHQDAAAAAOAaim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4hKIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxC0Q0AAAAAgEsougEAAAAAcAlFNwAAAAAALqHoBgAAAADAJa4X3TNnzlTr1q0VHh6u5ORkrV27ttz+ixYtUseOHRUeHq7zzjtPy5Yts9YbY/Tggw+qRYsWioiIUGpqqrZs2eLmIQA1jlwANjIB2MgEYCMTOJW5WnQvXLhQWVlZGjdunDZs2KCuXbsqLS1Ne/fu9dv/gw8+0HXXXaebbrpJH330kQYOHKiBAwfqs88+8/V5/PHHNW3aNM2aNUtr1qxRw4YNlZaWpqNHj7p5KECNIReAjUwANjIB2MgETnWuFt1TpkxRZmamhg8frs6dO2vWrFlq0KCB5syZ47f/U089pfT0dN1zzz3q1KmTxo8fr+7du2vGjBmSjr8iNXXqVD3wwAMaMGCAunTpoueff167d+/WkiVLHOdRUFCg/Px8awECpS7kgkygLiETgI1MADYygVOda0X3sWPHtH79eqWmpp7YWVCQUlNTtXr1ar9jVq9ebfWXpLS0NF//7du3Kycnx+oTFRWl5ORkx21K0sSJExUVFeVbWrZsWZ1DA6qsruSCTKCuIBOAjUwANjKB04FrRfe+fftUXFys2NhYqz02NlY5OTl+x+Tk5JTbv/TfymxTksaMGaO8vDzfsmvXrkofD1AT6kouyATqCjIB2MgEYCMTOB2EBHoCtcHr9crr9QZ6GkCdQSYAG5kAbGQCsJEJVIdrf+lu1qyZgoODlZuba7Xn5uYqLi7O75i4uLhy+5f+W5ltAnUJuQBsZAKwkQnARiZwOnCt6A4LC1OPHj2UnZ3tayspKVF2drZSUlL8jklJSbH6S9KKFSt8/RMTExUXF2f1yc/P15o1axy3CdQl5AKwkQnARiYAG5nA6cDVt5dnZWUpIyNDPXv2VFJSkqZOnarDhw9r+PDhkqShQ4fqzDPP1MSJEyVJd911l3r16qUnn3xS/fv310svvaT//ve/mj17tiTJ4/Ho7rvv1iOPPKL27dsrMTFRY8eOVXx8vAYOHOjmoQA1hlwANjIB2MgEYCMTONW5WnQPGjRI3333nR588EHl5OSoW7duWr58ue+iBV9//bWCgk78sf2CCy7QggUL9MADD+j+++9X+/bttWTJEp177rm+Pvfee68OHz6sESNG6MCBA7rooou0fPlyhYeHu3koQI0hF4CNTAA2MgHYyAROdR5jjAn0JGpbfn6+oqKi1FsDFOIJLdshKNj/wJJidyf2P57QMMd1pvBYpbf3y48L/bZ/2NXPsf9PcHSU47riA3l+29/cvdFxTFp8N8d1gVJkCrVK/1ReXp4iIyMDPZ2AOlkmnH625f5cPR7/7XX4ISeonCfakqNHHdc55aXk8I+OYxyz7HTeJNfPHZk4oTQTvZL/qJCQsveLkO8P+x1XvHmr4zadHts9Yc6PxSWH/e+nKqryGP31gxc4jkmcvslxXcnBg37bTVGR4xgnPT4qcVy38f8199uec+3ZjmNaLNnut71oT9krFpOJE0ozkdz/YYWEls1Egzc2+B23654kx21+fsdf/LZf/uVljmMKe+85yUwrLvjsto7rir/cVunthbQ8y3Fd0a5vKr09J8HN/d/vJan4u+/8tpeX5YQJa/22+8srmTjhZL87OT3mb5vX2XGbZ83z//fQiLXO98dln6/0217e72hFfXr4bQ/JXu84pqbdu+1Tv+2Ptz2v1uZQWZ6Qsj+fIlOolUWvnDQTrn2mGwAAAACA+o6iGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC5xveieOXOmWrdurfDwcCUnJ2vt2rWOfZ955hldfPHFatKkiZo0aaLU1NQy/YcNGyaPx2Mt6enpbh8GUKPIBWAjE4CNTAA2MoFTmatF98KFC5WVlaVx48Zpw4YN6tq1q9LS0rR3716//VetWqXrrrtOK1eu1OrVq9WyZUv17dtX3377rdUvPT1de/bs8S0vvviim4cB1ChyAdjIBGAjE4CNTOBU52rRPWXKFGVmZmr48OHq3LmzZs2apQYNGmjOnDl++7/wwgu67bbb1K1bN3Xs2FF/+9vfVFJSouzsbKuf1+tVXFycb2nSpEm58ygoKFB+fr61AIFSF3JBJlCXkAnARiYAG5nAqc61ovvYsWNav369UlNTT+wsKEipqalavXp1hbZx5MgRFRYWKiYmxmpftWqVzjjjDHXo0EG33nqrvv/++3K3M3HiREVFRfmWli1bVv6AgBpQV3JBJlBXkAnARiYAG5nA6cC1onvfvn0qLi5WbGys1R4bG6ucnJwKbeO+++5TfHy8FbL09HQ9//zzys7O1qRJk/Tuu+/qsssuU3FxseN2xowZo7y8PN+ya9euqh0UUE11JRdkAnUFmQBsZAKwkQmcDkICPQEnjz32mF566SWtWrVK4eHhvvbBgwf7/n/eeeepS5cuatu2rVatWqU+ffr43ZbX65XX63V9zoDbaioXZAKnCzIB2MgEYCMTqAtc+0t3s2bNFBwcrNzcXKs9NzdXcXFx5Y6dPHmyHnvsMb311lvq0qVLuX3btGmjZs2aaevWrdWeM+A2cgHYyARgIxOAjUzgdOBa0R0WFqYePXpYFywovYBBSkqK47jHH39c48eP1/Lly9WzZ8+T7uebb77R999/rxYtWtTIvAE3kQvARiYAG5kAbGQCpwNXr16elZWlZ555RvPmzdOmTZt066236vDhwxo+fLgkaejQoRozZoyv/6RJkzR27FjNmTNHrVu3Vk5OjnJycnTo0CFJ0qFDh3TPPffoww8/1I4dO5Sdna0BAwaoXbt2SktLc/NQgBpDLgAbmQBsZAKwkQmc6lz9TPegQYP03Xff6cEHH1ROTo66deum5cuX+y6E8PXXXyso6ETd//TTT+vYsWO65pprrO2MGzdODz30kIKDg/XJJ59o3rx5OnDggOLj49W3b1+NHz+ez1jglEEuABuZAGxkArCRCZzqXL+Q2siRIzVy5Ei/61atWmXd3rFjR7nbioiI0JtvvllDMwMCh1wANjIB2MgEYCMTOJW5+vZyAAAAAADqM4puAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuMT1onvmzJlq3bq1wsPDlZycrLVr1zr2fe655+TxeKwlPDzc6mOM0YMPPqgWLVooIiJCqamp2rJli9uHAdQocgHYyARgIxOAjUzgVOZq0b1w4UJlZWVp3Lhx2rBhg7p27aq0tDTt3bvXcUxkZKT27NnjW3bu3Gmtf/zxxzVt2jTNmjVLa9asUcOGDZWWlqajR4+6eShAjSEXgI1MADYyAdjIBE51IW5ufMqUKcrMzNTw4cMlSbNmzdIbb7yhOXPmaPTo0X7HeDwexcXF+V1njNHUqVP1wAMPaMCAAZKk559/XrGxsVqyZIkGDx7sd1xBQYEKCgp8t/Py8iRJRSqUjL8dlfg/IFPsv72GeYzHcZ0xhZXeXsEh/2OK/B27bz/HHNcVO8wh/6DDeZNUVIV5u61Ix+dkTDknwgV1IReVzYTTz7b8n6vD/biWz3dlBBnn1yFLyjlWp7yUP8ZpnXP+3T53ZMJPJooKyvSVJBX7b3d6fJScH9s95Zzv8u5DlVWVx+jiAudfPovKeZ5wmrcxRY5jnBQcKmfeJf7nUHysnHk7jPF3DsiEn0wU+j+3VbkPOd0nCw8737dq8vcJ45BjqfwsOypx3l6NztvhPiw5z7v8LFc8r2Si4r87OT3mlxwp52dR5L80K+/xtiq/oxUVOcyhFn9fP3zQf11VF2uGUv6er0vne9JMGJcUFBSY4OBgs3jxYqt96NCh5sorr/Q7Zu7cuSY4ONi0atXKnHXWWebKK680n332mW/9tm3bjCTz0UcfWeMuueQSc+eddzrOZdy4cUbH48DCUmbZtWtXle/nlVVXckEmWMpbyAQLi72QCRYWeyETLCz2crJMuPaX7n379qm4uFixsbFWe2xsrL744gu/Yzp06KA5c+aoS5cuysvL0+TJk3XBBRfo888/11lnnaWcnBzfNn6+zdJ1/owZM0ZZWVm+2yUlJdq/f7+aNm2qgwcPqmXLltq1a5ciIyOrerintPz8/Hp5DowxOnjwoOLj42ttn3UlF2SifGSCTJAJG5kgE2TCRibIBJmwkYnyM+Hq28srKyUlRSkpKb7bF1xwgTp16qS//vWvGj9+fJW36/V65fV6rbbo6GhJx996Ih3/3Ed9uoP4Ux/PQVRUVKCncFJu5IJMVEx9PAdk4gQyUVZ9PAdk4gQyUVZ9PAdk4gQyUVZ9PAcVyYRrF1Jr1qyZgoODlZuba7Xn5uY6fr7i50JDQ3X++edr69atkuQbV51tAoFELgAbmQBsZAKwkQmcDlwrusPCwtSjRw9lZ2f72kpKSpSdnW298lSe4uJiffrpp2rRooUkKTExUXFxcdY28/PztWbNmgpvEwgkcgHYyARgIxOAjUzgtFDuJ76r6aWXXjJer9c899xz5v/+7//MiBEjTHR0tMnJyTHGGHPjjTea0aNH+/r/6U9/Mm+++abZtm2bWb9+vRk8eLAJDw83n3/+ua/PY489ZqKjo80///lP88knn5gBAwaYxMRE8+OPP1ZpjkePHjXjxo0zR48erd7BnsI4B7WrrueC+wPnoLaRibqPc1C7yETdxzmoXWSi7uMclM/VotsYY6ZPn25atWplwsLCTFJSkvnwww9963r16mUyMjJ8t++++25f39jYWNOvXz+zYcMGa3slJSVm7NixJjY21ni9XtOnTx+zefNmtw8DqFHkArCRCcBGJgAbmcCpzGNMHf7SXAAAAAAATmGufaYbAAAAAID6jqIbAAAAAACXUHQDAAAAAOASim4AAAAAAFxS74vumTNnqnXr1goPD1dycrLWrl0b6Cm55t///reuuOIKxcfHy+PxaMmSJdZ6Y4wefPBBtWjRQhEREUpNTdWWLVsCM1kEDJk4gUxAIhM/RSYgkYmfIhOQyMRPkQn/6nXRvXDhQmVlZWncuHHasGGDunbtqrS0NO3duzfQU3PF4cOH1bVrV82cOdPv+scff1zTpk3TrFmztGbNGjVs2FBpaWk6evRoLc8UgUImbGQCZMJGJkAmbGQCZMJGJhwE8OvKAi4pKcncfvvtvtvFxcUmPj7eTJw4MYCzqh2SzOLFi323S0pKTFxcnHniiSd8bQcOHDBer9e8+OKLAZghAoFMLPbdJhMwhkyQCfwcmVjsu00mYAyZIBMVU2//0n3s2DGtX79eqampvragoCClpqZq9erVAZxZYGzfvl05OTnW+YiKilJycnK9PB/1EZmwkQmQCRuZAJmwkQmQCRuZcFZvi+59+/apuLhYsbGxVntsbKxycnICNKvAKT1mzkf9RSZsZAJkwkYmQCZsZAJkwkYmnNXbohsAAAAAALfV26K7WbNmCg4OVm5urtWem5uruLi4AM0qcEqPmfNRf5EJG5kAmbCRCZAJG5kAmbCRCWf1tugOCwtTjx49lJ2d7WsrKSlRdna2UlJSAjizwEhMTFRcXJx1PvLz87VmzZp6eT7qIzJhIxMgEzYyATJhIxMgEzYy4Swk0BMIpKysLGVkZKhnz55KSkrS1KlTdfjwYQ0fPjzQU3PFoUOHtHXrVt/t7du3a+PGjYqJiVGrVq10991365FHHlH79u2VmJiosWPHKj4+XgMHDgzcpFGryASZgI1MkAnYyASZgI1MkIkKCfTl0wNt+vTpplWrViYsLMwkJSWZDz/8MNBTcs3KlSuNpDJLRkaGMeb4Zf7Hjh1rYmNjjdfrNX369DGbN28O7KRR68gEmYCNTJAJ2MgEmYCNTJCJk/EYY0ytVfgAAAAAANQj9fYz3QAAAAAAuI2iGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISi+xSzZcsW9e3bV1FRUfJ4PFqyZEmgpwQEFJkAbGQCsJEJwEYmah9FdxVs27ZNN998s9q0aaPw8HBFRkbqwgsv1FNPPaUff/zR1X1nZGTo008/1aOPPqr58+erZ8+efvs999xz8ng88ng8+s9//lNmvTFGLVu2lMfj0eWXX16luUyYMKHaIV23bp1Gjhypc845Rw0bNlSrVq30m9/8Rl9++aXf/ps2bVJ6eroaNWqkmJgY3Xjjjfruu++qNQdUH5k4rrYzsXbtWt12223q0aOHQkND5fF4qrVv1BwycVxtZqKkpETPPfecrrzySrVs2VINGzbUueeeq0ceeURHjx6t1hxQfWTiuNp+nnjmmWfUq1cvxcbGyuv1KjExUcOHD9eOHTuqNQdUH5k4LhD1RKnCwkJ17txZHo9HkydPrtYcTsqgUpYuXWoiIiJMdHS0ufPOO83s2bPNjBkzzODBg01oaKjJzMx0bd9Hjhwxkswf//jHk/adO3eukWTCw8PNrbfeWmb9ypUrjSTj9XpN//79qzSfhg0bmoyMjCqNLXX11VebuLg4c8cdd5hnnnnGjB8/3sTGxpqGDRuaTz/91Oq7a9cu06xZM9O2bVvz1FNPmUcffdQ0adLEdO3a1RQUFFRrHqg6MnFCbWdi3LhxJjQ01PTo0cOcffbZhof0uoFMnFCbmTh48KCRZH75y1+aRx55xMyePdsMHz7cBAUFmd69e5uSkpJqzQNVRyZOqO3niVtvvdVkZGSYyZMnm2effdY88MADJjY21jRr1sx8++231ZoHqo5MnFDbmfipJ5980jRs2NBIMk888US15nAy/IZWCV999ZVp1KiR6dixo9m9e3eZ9Vu2bDFTp051bf87d+6s8J2iNCS//vWvTbNmzUxhYaG1PjMz0/To0cMkJCQENCTvv/9+mYL5yy+/NF6v1wwZMsRqv/XWW01ERITZuXOnr23FihVGkvnrX/9arXmgasiErbYzkZOTY44cOWKMMeb222+n6K4DyIStNjNRUFBg3n///TLj//SnPxlJZsWKFdWaB6qGTNhq+3nCn//+979Gkpk4cWK15oGqIRO2QGUiNzfXREVFmYcffpiiu6655ZZbjCS/T+r+FBYWmocffti0adPGhIWFmYSEBDNmzBhz9OhRq1/pHfW9994zv/jFL4zX6zWJiYlm3rx5vj7jxo0zkqwlISHBcd+lIVm0aJHxeDxm2bJlvnUFBQWmSZMm5sknn/QbkieeeMKkpKSYmJgYEx4ebrp3724WLVpk9fn5XCRZgdm0aZNVHFdW9+7dTffu3a22M844w1x77bVl+p599tmmT58+Vd4Xqo5MnBCITPwURXfdQCZOCHQmSn3yySdGkpk2bVqV94WqIxMn1JVM7Nu3z0gy9913X5X3haojEycEMhPDhw83SUlJ5quvvqLormvOPPNM06ZNmwr3z8jIMJLMNddcY2bOnGmGDh1qJJmBAwda/RISEkyHDh1MbGysuf/++82MGTNM9+7djcfjMZ999pkxxpiPP/7Y/PnPfzaSzHXXXWfmz59vFi9e7Ljv0pCsW7fOXHDBBebGG2/0rVuyZIkJCgoy3377rd+QnHXWWea2224zM2bMMFOmTDFJSUlGklm6dKmvz/z5843X6zUXX3yxmT9/vpk/f7754IMPfOslmV69elX4XP1USUmJOfPMM03fvn19bd98842RZCZNmlSm/w033GBiYmKqtC9UD5kIXCZ+jqK7biATdScTpd566y0jySxYsKBK+0L1kIm6kYl9+/aZ3Nxcs27dOnPFFVcYSeatt96q0r5QPWQi8JlYs2aNCQoKMh988IHZvn07RXddkpeXZySZAQMGVKj/xo0bjSTzu9/9zmr/wx/+YCSZd955x9eWkJBgJJl///vfvra9e/car9drRo0a5WurzJ3ipyGZMWOGady4se9tqNdee6259NJLffv+eUhK+5U6duyYOffcc82vfvUrq728t4NUJyTz5883ksyzzz7ra1u3bp2RZJ5//vky/e+55x4jqcwrfnAXmQhsJn6OojvwyETdykSp1NRUExkZaX744Ycq7QtVRybqTia8Xq/vL4lNmzblnR8BQiYCn4mSkhKTlJRkrrvuOmNM5c5HdXD18grKz8+XJDVu3LhC/ZctWyZJysrKstpHjRolSXrjjTes9s6dO+viiy/23W7evLk6dOigr776qspzLvWb3/xGP/74o5YuXaqDBw9q6dKluv766x37R0RE+P7/ww8/KC8vTxdffLE2bNhQ4X0aY7Rq1apKz/WLL77Q7bffrpSUFGVkZPjaS6/i6PV6y4wJDw+3+qB2kInAZgJ1D5moe5mYMGGC3n77bT322GOKjo6u9L5QPWSi7mTiX//6l5YtW6Ynn3xSrVq10uHDhyu9H1QfmQh8Jp577jl9+umnmjRpUqW3Wx0htbq3U1hkZKQk6eDBgxXqv3PnTgUFBaldu3ZWe1xcnKKjo7Vz506rvVWrVmW20aRJE/3www+O+yguLi7zdVkxMTEKCwuz2po3b67U1FQtWLBAR44cUXFxsa655hrH7S5dulSPPPKINm7cqIKCAl+7219HlJOTo/79+ysqKkr/+Mc/FBwc7FtXGtyfzqdU6VfB/DTccB+ZCGwmUPeQibqViYULF+qBBx7QTTfdpFtvvdXVecE/MlF3MnHppZdKki677DINGDBA5557rho1aqSRI0e6Oj/YyERgM5Gfn68xY8bonnvuUcuWLV2dx89RdFdQZGSk4uPj9dlnn1VqXEXvWE4PksYYxzG7du1SYmKi1bZy5Ur17t27TN/rr79emZmZysnJ0WWXXeb4iv97772nK6+8Updccon+8pe/qEWLFgoNDdXcuXO1YMGCCh1LVeTl5emyyy7TgQMH9N577yk+Pt5a36JFC0nSnj17yozds2ePYmJi/P4VHO4hE4HNBOoeMlF3MrFixQoNHTpU/fv316xZs1ybE8pHJupOJn6qbdu2Ov/88/XCCy9QdNcyMhHYTEyePFnHjh3ToEGDfN9V/80330g6/tf4HTt2KD4+vswLDjWBorsSLr/8cs2ePVurV69WSkpKuX0TEhJUUlKiLVu2qFOnTr723NxcHThwQAkJCdWeT1xcnFasWGG1de3a1W/fq666SjfffLM+/PBDLVy40HGbr7zyisLDw/Xmm29aRezcuXPL9K2pV6qOHj2qK664Ql9++aXefvttde7cuUyfM888U82bN9d///vfMuvWrl2rbt261chcUDlkwlabmUDdRCZsgcjEmjVrdNVVV6lnz556+eWXFRLCrzqBRCZsdeV54scff/T77kG4j0zYajMTX3/9tX744Qedc845ZdZNmDBBEyZM0EcffeRKXcFnuivh3nvvVcOGDfW73/1Oubm5ZdZv27ZNTz31lCSpX79+kqSpU6dafaZMmSJJ6t+/f7XnEx4ertTUVGtp0qSJ376NGjXS008/rYceekhXXHGF4zaDg4Pl8XhUXFzsa9uxY4eWLFlSpm/Dhg114MABv9v54osv9PXXX5/0GIqLizVo0CCtXr1aixYtKvfB5+qrr9bSpUu1a9cuX1t2dra+/PJLXXvttSfdF2oembDVdiZQ95AJW21nYtOmTerfv79at26tpUuX8rGjOoBM2GozE0VFRX7fVrx27Vp9+umn6tmz50n3hZpHJmy1mYk777xTixcvtpa//vWvkqRhw4Zp8eLFZf7qX1N4+bcS2rZtqwULFmjQoEHq1KmThg4dqnPPPVfHjh3TBx98oEWLFmnYsGGSjr9ClJGRodmzZ+vAgQPq1auX1q5dq3nz5mngwIG+z9bUpopchKl///6aMmWK0tPTdf3112vv3r2aOXOm2rVrp08++cTq26NHD7399tuaMmWK4uPjlZiYqOTkZElSp06d1KtXr5Ne/GDUqFF67bXXdMUVV2j//v36+9//bq2/4YYbfP+///77tWjRIl166aW66667dOjQIT3xxBM677zzNHz48AqeBdQkMhHYTOzcuVPz58+XJN+7QB555BFJx18dv/HGG096fKhZZCJwmTh48KDS0tL0ww8/6J577ilzgaG2bdvyIlYAkInAZeLQoUNq2bKlBg0apHPOOUcNGzbUp59+qrlz5yoqKkpjx46txJlATSETgctE9+7d1b17d2td6dvMzznnHA0cOPCkx1Zlrl4b/TT15ZdfmszMTNO6dWsTFhZmGjdubC688EIzffp062urCgsLzZ/+9CeTmJhoQkNDTcuWLcv9Mvuf69Wrl3WZ/Kpe4r88/vb97LPPmvbt2xuv12s6duxo5s6da8aNG1fm64i++OILc8kll5iIiIgyX2avCl7iv1evXr6vsPC3/Nxnn31m+vbtaxo0aGCio6PNkCFDTE5Ozkn3A3eRieNqOxMrV6507FfVr9hAzSATx9VmJkqP3Wlx+koa1A4ycVxtZqKgoMDcddddpkuXLiYyMtKEhoaahIQEc9NNN5nt27efdD9wF5k4LhD1xE/V1leGeYwp55P1AAAAAACgyvhMNwAAAAAALqHoBgAAAADAJRTdAAAAAAC4xLWie//+/RoyZIgiIyMVHR2tm266SYcOHSp3TO/eveXxeKzllltusfp8/fXX6t+/vxo0aKAzzjhD99xzj4qKitw6DKDGkAnARiYAG5kAbGQCpwvXvjJsyJAh2rNnj1asWKHCwkINHz5cI0aM0IIFC8odl5mZqYcffth3u0GDBr7/FxcXq3///oqLi9MHH3ygPXv2aOjQoQoNDdWECRPcOhSgRpAJwEYmABuZAGxkAqcLV65evmnTJnXu3Fnr1q1Tz549JUnLly9Xv3799M033yg+Pt7vuN69e6tbt25lvgC+1L/+9S9dfvnl2r17t2JjYyVJs2bN0n333afvvvtOYWFhfscVFBSooKDAd7ukpET79+9X06ZN5fF4qnGkOJUZY3Tw4EHFx8crKMjdT1qQCZwKyASZgI1MkAnYyASZgK3CmXDje8ieffZZEx0dbbUVFhaa4OBg8+qrrzqO69Wrl2nWrJlp2rSpOeecc8zo0aPN4cOHfevHjh1runbtao356quvjCSzYcMGx+2WficcC4u/ZdeuXVW7o1cCmWA5lRYywcJiL2SChcVeyAQLi72cLBOuvL08JydHZ5xxhtUWEhKimJgY5eTkOI67/vrrlZCQoPj4eH3yySe67777tHnzZr366qu+7Za+IlWq9HZ52x0zZoyysrJ8t/Py8tSqVStdpH4KUWiZ/sHNmvndTvG+fY772Dqlh9/2dlnrHcc0erOp3/ZDad87jqmSoGD/7SXFjkMWf/mp47qrOnTx2557W5LjmNiZa/y2f/XYLxzHtBm9znFdTShSof6jZWrcuLGr+5FOg0zENPG7neL9PzjuIy67kd/2nD7lfxbrVOSUF6esSJJq/k1G1UYmKp4JOf1Vow7+XEuFtG7pvLKkxG9z0dffVmlfB6/2/9je+BV3H9dLBTeNcVz3j9Xv+m2/6uzzyrSRiYpnwulxsO89wx33EfXh137bi3L3Oo5xEty2teO64m07/LZ7Qv3/RVOS/v7par/tQzr6/32vqkLi4xzXNXjumN/2/L77K72f4DYJjuvyup3htz3qnc1l2orMMb2bt5BM6OSZOHJlT7/biVzj/34vVe2+72TXmGTHdS0n+v+9vFy19bznVLdIUo+O/od8/pXjkJIjP1Z3Rj7+HufyD5UoofuOk2aiUkX36NGjNWnSpHL7bNq0qTKbtIwYMcL3//POO08tWrRQnz59tG3bNrVt27bK2/V6vfJ6vWXaQxSqEI+fAiPI/4Owx0/fUkER4X7b/W2/VGhD//spb0yVeBzuvB7nt0BENnZe5zS/YK//c1DemKDwyo+pMf97jKjOW4LIhPPPKKxRLd2/6wCnvJR/rHWwOCMTZdqdMuH4y0dd/Ln+T0hQ2eM7wX/RrSrmNSS08s+JNcnpMUuqZF7JRJl2p0w4nleH+4IkhTj9nKpwPwkOdr5/Oz1XlfccVrXH9corL5ehDR3G1PD5cc6rc47IxAlOmXA8r+U8PlX1Mdef4Jr+Hbu2nvec6hZJCvF/TEHl3FdLPDV3gbzy6qOTZaJSRfeoUaM0bNiwcvu0adNGcXFx2rvXfqWmqKhI+/fvV1yc8yt6P5ecfPwVmq1bt6pt27aKi4vT2rVrrT65ubmSVKntAjWFTAA2MgHYyARgIxOojypVdDdv3lzNmzc/ab+UlBQdOHBA69evV48ex9+G884776ikpMR3x6+IjRs3SpJatGjh2+6jjz6qvXv3+t5usmLFCkVGRqpz586VORSgRpAJwEYmABuZAGxkAvWRK5cd7NSpk9LT05WZmam1a9fq/fff18iRIzV48GDflQa//fZbdezY0fdK07Zt2zR+/HitX79eO3bs0GuvvaahQ4fqkksuUZcuxz8X2bdvX3Xu3Fk33nijPv74Y7355pt64IEHdPvtt/t9uwdQV5AJwEYmABuZAGxkAqcT1671/8ILL6hjx47q06eP+vXrp4suukizZ8/2rS8sLNTmzZt15MgRSVJYWJjefvtt9e3bVx07dtSoUaN09dVX6/XXX/eNCQ4O1tKlSxUcHKyUlBTdcMMNGjp0qPU9fEBdRSYAG5kAbGQCsJEJnC5cuXq5JMXExJT7xfWtW7eW+cnV7lq2bKl33/V/RdGfSkhI0LJly2pkjkBtIhOAjUwANjIB2MgEThfufqs9AAAAAAD1GEU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXOJa0b1//34NGTJEkZGRio6O1k033aRDhw6V2/+OO+5Qhw4dFBERoVatWunOO+9UXl6e1c/j8ZRZXnrpJbcOA6gxZAKwkQnARiYAG5nA6SLErQ0PGTJEe/bs0YoVK1RYWKjhw4drxIgRWrBggd/+u3fv1u7duzV58mR17txZO3fu1C233KLdu3frH//4h9V37ty5Sk9P992Ojo526zCAGkMmABuZAGxkArCRCZwuXCm6N23apOXLl2vdunXq2bOnJGn69Onq16+fJk+erPj4+DJjzj33XL3yyiu+223bttWjjz6qG264QUVFRQoJOTHV6OhoxcXFVXg+BQUFKigo8N3Oz8+vymEBVUYmABuZAGxkArCRCZxOXHl7+erVqxUdHe0LiCSlpqYqKChIa9asqfB28vLyFBkZaQVEkm6//XY1a9ZMSUlJmjNnjowx5W5n4sSJioqK8i0tW7as3AEB1UQmABuZAGxkArCRCZxOXCm6c3JydMYZZ1htISEhiomJUU5OToW2sW/fPo0fP14jRoyw2h9++GG9/PLLWrFiha6++mrddtttmj59ernbGjNmjPLy8nzLrl27KndAQDWRCcBGJgAbmQBsZAKnk0q9vXz06NGaNGlSuX02bdpUrQlJx9+u0b9/f3Xu3FkPPfSQtW7s2LG+/59//vk6fPiwnnjiCd15552O2/N6vfJ6vdWeF/BzZAKwkQnARiYAG5lAfVSponvUqFEaNmxYuX3atGmjuLg47d2712ovKirS/v37T/rZiYMHDyo9PV2NGzfW4sWLFRoaWm7/5ORkjR8/XgUFBQQBtY5MADYyAdjIBGAjE6iPKlV0N2/eXM2bNz9pv5SUFB04cEDr169Xjx49JEnvvPOOSkpKlJyc7DguPz9faWlp8nq9eu211xQeHn7SfW3cuFFNmjQhIAgIMgHYyARgIxOAjUygPnLl6uWdOnVSenq6MjMzNWvWLBUWFmrkyJEaPHiw70qD3377rfr06aPnn39eSUlJys/PV9++fXXkyBH9/e9/V35+vu+qgM2bN1dwcLBef/115ebm6pe//KXCw8O1YsUKTZgwQX/4wx/cOAygxpAJwEYmABuZAGxkAqcT176n+4UXXtDIkSPVp08fBQUF6eqrr9a0adN86wsLC7V582YdOXJEkrRhwwbflQjbtWtnbWv79u1q3bq1QkNDNXPmTP3+97+XMUbt2rXTlClTlJmZ6dZhADWGTAA2MgHYyARgIxM4XbhWdMfExDh+cb0ktW7d2ro0f+/evU96qf709HTrS+yBUwmZAGxkArCRCcBGJnC6cOUrwwAAAAAAAEU3AAAAAACuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXOJ60T1z5ky1bt1a4eHhSk5O1tq1a8vtv2jRInXs2FHh4eE677zztGzZMmu9MUYPPvigWrRooYiICKWmpmrLli1uHgJQ48gFYCMTgI1MADYygVOZq0X3woULlZWVpXHjxmnDhg3q2rWr0tLStHfvXr/9P/jgA1133XW66aab9NFHH2ngwIEaOHCgPvvsM1+fxx9/XNOmTdOsWbO0Zs0aNWzYUGlpaTp69KibhwLUGHIB2MgEYCMTgI1M4FTnatE9ZcoUZWZmavjw4ercubNmzZqlBg0aaM6cOX77P/XUU0pPT9c999yjTp06afz48erevbtmzJgh6fgrUlOnTtUDDzygAQMGqEuXLnr++ee1e/duLVmyxHEeBQUFys/PtxYgUOpCLsgE6hIyAdjIBGAjEzjVuVZ0Hzt2TOvXr1dqauqJnQUFKTU1VatXr/Y7ZvXq1VZ/SUpLS/P13759u3Jycqw+UVFRSk5OdtymJE2cOFFRUVG+pWXLltU5NKDK6kouyATqCjIB2MgEYCMTOB24VnTv27dPxcXFio2NtdpjY2OVk5Pjd0xOTk65/Uv/rcw2JWnMmDHKy8vzLbt27ar08QA1oa7kgkygriATgI1MADYygdNBSKAnUBu8Xq+8Xm+gpwHUGWQCsJEJwEYmABuZQHW49pfuZs2aKTg4WLm5uVZ7bm6u4uLi/I6Ji4srt3/pv5XZJlCXkAvARiYAG5kAbGQCpwPXiu6wsDD16NFD2dnZvraSkhJlZ2crJSXF75iUlBSrvyStWLHC1z8xMVFxcXFWn/z8fK1Zs8Zxm0BdQi4AG5kAbGQCsJEJnA5cfXt5VlaWMjIy1LNnTyUlJWnq1Kk6fPiwhg8fLkkaOnSozjzzTE2cOFGSdNddd6lXr1568skn1b9/f7300kv673//q9mzZ0uSPB6P7r77bj3yyCNq3769EhMTNXbsWMXHx2vgwIFuHgpQY8gFYCMTgI1MADYygVOdq0X3oEGD9N133+nBBx9UTk6OunXrpuXLl/suWvD1118rKOjEH9svuOACLViwQA888IDuv/9+tW/fXkuWLNG5557r63Pvvffq8OHDGjFihA4cOKCLLrpIy5cvV3h4uJuHAtQYcgHYyARgIxOAjUzgVOcxxphAT6K25efnKyoqSr01QCGe0DLrg5s39zuu+LvvHLf55V+S/LaffdtaxzGN32vmt/3gxfscx1RJULD/9pJixyFv7t7ouC7tzPP9tufc7fx2nLg/f+C3feuff+k4pt3vP3RcVxOKTKFW6Z/Ky8tTZGSkq/uq606aiaYxfscVf7/fcZvxHzb22777lwerNsk6zCkvTlmRJNXBh14yccLJMiGPx//AOvhzLRWSmOC8sqTEb3PRzqpdnffgIP+P7Y0Xuvu4Xiq4WVPHdcs+yfbbnhbfrUwbmTjhZJlwehy86I6bHbcZ9f4Ov+1FObl+28sT3L6N47riLV/5bfeEhjmOeXX7f/y2X3WW/9/3qirkzHjHdQ0XFvhtz7vo+0rvJ7hdouO6vO6xftuj3tpUpq3IHFP2gflkQifPxJFfJ/sdF/nBDsdtVuW+7+Trhy5wXNfqIf+/l5ertp73nOoWSUo6x/+QT7Y6Dik5cqS6M/Lx9ziXf7BETc7+6qSZcO0z3QAAAAAA1HcU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHCJ60X3zJkz1bp1a4WHhys5OVlr16517PvMM8/o4osvVpMmTdSkSROlpqaW6T9s2DB5PB5rSU9Pd/swgBpFLgAbmQBsZAKwkQmcylwtuhcuXKisrCyNGzdOGzZsUNeuXZWWlqa9e/f67b9q1Spdd911WrlypVavXq2WLVuqb9+++vbbb61+6enp2rNnj2958cUX3TwMoEaRC8BGJgAbmQBsZAKnOleL7ilTpigzM1PDhw9X586dNWvWLDVo0EBz5szx2/+FF17Qbbfdpm7duqljx47629/+ppKSEmVnZ1v9vF6v4uLifEuTJk3KnUdBQYHy8/OtBQiUupALMoG6hEwANjIB2MgETnWuFd3Hjh3T+vXrlZqaemJnQUFKTU3V6tWrK7SNI0eOqLCwUDExMVb7qlWrdMYZZ6hDhw669dZb9f3335e7nYkTJyoqKsq3tGzZsvIHBNSAupILMoG6gkwANjIB2MgETgeuFd379u1TcXGxYmNjrfbY2Fjl5ORUaBv33Xef4uPjrZClp6fr+eefV3Z2tiZNmqR3331Xl112mYqLix23M2bMGOXl5fmWXbt2Ve2ggGqqK7kgE6gryARgIxOAjUzgdBAS6Ak4eeyxx/TSSy9p1apVCg8P97UPHjzY9//zzjtPXbp0Udu2bbVq1Sr16dPH77a8Xq+8Xq/rcwbcVlO5IBM4XZAJwEYmABuZQF3g2l+6mzVrpuDgYOXm5lrtubm5iouLK3fs5MmT9dhjj+mtt95Sly5dyu3bpk0bNWvWTFu3bq32nAG3kQvARiYAG5kAbGQCpwPXiu6wsDD16NHDumBB6QUMUlJSHMc9/vjjGj9+vJYvX66ePXuedD/ffPONvv/+e7Vo0aJG5g24iVwANjIB2MgEYCMTOB24evXyrKwsPfPMM5o3b542bdqkW2+9VYcPH9bw4cMlSUOHDtWYMWN8/SdNmqSxY8dqzpw5at26tXJycpSTk6NDhw5Jkg4dOqR77rlHH374oXbs2KHs7GwNGDBA7dq1U1pampuHAtQYcgHYyARgIxOAjUzgVOfqZ7oHDRqk7777Tg8++KBycnLUrVs3LV++3HchhK+//lpBQSfq/qefflrHjh3TNddcY21n3LhxeuihhxQcHKxPPvlE8+bN04EDBxQfH6++fftq/PjxfMYCpwxyAdjIBGAjE4CNTOBU5/qF1EaOHKmRI0f6Xbdq1Srr9o4dO8rdVkREhN58880amhkQOOQCsJEJwEYmABuZwKnM1beXAwAAAABQn1F0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl1B0AwAAAADgEopuAAAAAABcQtENAAAAAIBLKLoBAAAAAHAJRTcAAAAAAC6h6AYAAAAAwCWuF90zZ85U69atFR4eruTkZK1du9ax73PPPSePx2Mt4eHhVh9jjB588EG1aNFCERERSk1N1ZYtW9w+DKBGkQvARiYAG5kAbGQCpzJXi+6FCxcqKytL48aN04YNG9S1a1elpaVp7969jmMiIyO1Z88e37Jz505r/eOPP65p06Zp1qxZWrNmjRo2bKi0tDQdPXrUzUMBagy5AGxkArCRCcBGJnCqC3Fz41OmTFFmZqaGDx8uSZo1a5beeOMNzZkzR6NHj/Y7xuPxKC4uzu86Y4ymTp2qBx54QAMGDJAkPf/884qNjdWSJUs0ePBgv+MKCgpUUFDgu52XlydJKlKhZPzsp+SY3+0Um0L/Byqp5Ef/AS0qZ0zhYf/7KW9MlZgSh/ZixyH5Bx3GyHl+xQXOD1JOY0rKeWCr8fPw8+3r+PaN8XMncFFdyEVtZOLYoVq6f9cBTnkp91hr+X5XEWSi4pmQPP4Ppg7+XH1KCspZV4X7cDmKCiv/nFiTnB6zpMrllUxUPBOO59XhviBJRQ4/p6rcT0yx8/3b6bnKYxxyrCo+rldFObmsyd8Tyzs/znktu//SNjJx8kw4ntdyHp9q8v5VXOO/Y9fS855T3SJJRf6PKcjPfbVUSQ2eU3+PC/mHjredNBPGJQUFBSY4ONgsXrzYah86dKi58sor/Y6ZO3euCQ4ONq1atTJnnXWWufLKK81nn33mW79t2zYjyXz00UfWuEsuucTceeedjnMZN26c0fE4sLCUWXbt2lXl+3ll1ZVckAmW8hYywcJiL2SChcVeyAQLi72cLBOu/aV73759Ki4uVmxsrNUeGxurL774wu+YDh06aM6cOerSpYvy8vI0efJkXXDBBfr888911llnKScnx7eNn2+zdJ0/Y8aMUVZWlu92SUmJ9u/fr6ZNm+rgwYNq2bKldu3apcjIyKoe7iktPz+/Xp4DY4wOHjyo+Pj4WttnXckFmSgfmSATZMJGJsgEmbCRCTJBJmxkovxMuPr28spKSUlRSkqK7/YFF1ygTp066a9//avGjx9f5e16vV55vV6rLTo6WtLxt55Ixz/3UZ/uIP7Ux3MQFRUV6CmclBu5IBMVUx/PAZk4gUyUVR/PAZk4gUyUVR/PAZk4gUyUVR/PQUUy4dqF1Jo1a6bg4GDl5uZa7bm5uY6fr/i50NBQnX/++dq6dask+cZVZ5tAIJELwEYmABuZAGxkAqcD14rusLAw9ejRQ9nZ2b62kpISZWdnW688lae4uFiffvqpWrRoIUlKTExUXFyctc38/HytWbOmwtsEAolcADYyAdjIBGAjEzgtlPuJ72p66aWXjNfrNc8995z5v//7PzNixAgTHR1tcnJyjDHG3HjjjWb06NG+/n/605/Mm2++abZt22bWr19vBg8ebMLDw83nn3/u6/PYY4+Z6Oho889//tN88sknZsCAASYxMdH8+OOPVZrj0aNHzbhx48zRo0erd7CnMM5B7arrueD+wDmobWSi7uMc1C4yUfdxDmoXmaj7OAflc7XoNsaY6dOnm1atWpmwsDCTlJRkPvzwQ9+6Xr16mYyMDN/tu+++29c3NjbW9OvXz2zYsMHaXklJiRk7dqyJjY01Xq/X9OnTx2zevNntwwBqFLkAbGQCsJEJwEYmcCrzGFOXv1QUAAAAAIBTl2uf6QYAAAAAoL6j6AYAAAAAwCUU3QAAAAAAuISiGwAAAAAAl9T7onvmzJlq3bq1wsPDlZycrLVr1wZ6Sq7597//rSuuuELx8fHyeDxasmSJtd4YowcffFAtWrRQRESEUlNTtWXLlsBMFgFDJk4gE5DIxE+RCUhk4qfIBCQy8VNkwr96XXQvXLhQWVlZGjdunDZs2KCuXbsqLS1Ne/fuDfTUXHH48GF17dpVM2fO9Lv+8ccf17Rp0zRr1iytWbNGDRs2VFpamo4ePVrLM0WgkAkbmQCZsJEJkAkbmQCZsJEJBwH8urKAS0pKMrfffrvvdnFxsYmPjzcTJ04M4KxqhySzePFi3+2SkhITFxdnnnjiCV/bgQMHjNfrNS+++GIAZohAIBOLfbfJBIwhE2QCP0cmFvtukwkYQybIRMXU2790Hzt2TOvXr1dqaqqvLSgoSKmpqVq9enUAZxYY27dvV05OjnU+oqKilJycXC/PR31EJmxkAmTCRiZAJmxkAmTCRiac1duie9++fSouLlZsbKzVHhsbq5ycnADNKnBKj5nzUX+RCRuZAJmwkQmQCRuZAJmwkQln9bboBgAAAADAbfW26G7WrJmCg4OVm5trtefm5iouLi5Aswqc0mPmfNRfZMJGJkAmbGQCZMJGJkAmbGTCWb0tusPCwtSjRw9lZ2f72kpKSpSdna2UlJQAziwwEhMTFRcXZ52P/Px8rVmzpl6ej/qITNjIBMiEjUyATNjIBMiEjUw4Cwn0BAIpKytLGRkZ6tmzp5KSkjR16lQdPnxYw4cPD/TUXHHo0CFt3brVd3v79u3auHGjYmJi1KpVK91999165JFH1L59eyUmJmrs2LGKj4/XwIEDAzdp1CoyQSZgIxNkAjYyQSZgIxNkokICffn0QJs+fbpp1aqVCQsLM0lJSebDDz8M9JRcs3LlSiOpzJKRkWGMOX6Z/7Fjx5rY2Fjj9XpNnz59zObNmwM7adQ6MkEmYCMTZAI2MkEmYCMTZOJkPMYYU2sVPgAAAAAA9Ui9/Uw3AAAAAABuo+gGAAAAAMAlFN0AAAAAALiEohsAAAAAAJdQdAMAAAAA4BKKbgAAAAAAXELRDQAAAACASyi6AQAAAABwCUU3AAAAAAAuoegGAAAAAMAlFN0AAAAAALjk/wOurHg1SlY0cQAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 36 + "execution_count": 4 }, { "metadata": {}, diff --git a/scripts/Chris/DQN/Reservoir.py b/scripts/Chris/DQN/Reservoir.py index 91683228..4999d753 100644 --- a/scripts/Chris/DQN/Reservoir.py +++ b/scripts/Chris/DQN/Reservoir.py @@ -7,44 +7,89 @@ class Reservoir(Network): - def __init__(self, in_size, res_size, hyper_params, - w_in_res, w_res_res, device='cpu'): + def __init__(self, in_size, exc_size, inh_size, hyper_params, + w_in_exc, w_in_inh, w_exc_exc, w_exc_inh, w_inh_exc, w_inh_inh, + device='cpu'): super().__init__() ## Layers ## input = Input(n=in_size) - res = AdaptiveLIFNodes( - n=res_size, - thresh=hyper_params['thresh'], - theta_plus=hyper_params['theta_plus'], - refrac=hyper_params['refrac'], - reset=hyper_params['reset'], - tc_theta_decay=hyper_params['tc_theta_decay'], - tc_decay=hyper_params['tc_decay'], + res_exc = AdaptiveLIFNodes( + n=exc_size, + thresh=hyper_params['thresh_exc'], + theta_plus=hyper_params['theta_plus_exc'], + refrac=hyper_params['refrac_exc'], + reset=hyper_params['reset_exc'], + tc_theta_decay=hyper_params['tc_theta_decay_exc'], + tc_decay=hyper_params['tc_decay_exc'], traces=True, ) - res_monitor = Monitor(res, ["s"], device=device) - self.add_monitor(res_monitor, name='res_monitor') - self.res_monitor = res_monitor + exc_monitor = Monitor(res_exc, ["s"], device=device) + self.add_monitor(exc_monitor, name='res_monitor_exc') + self.exc_monitor = exc_monitor + res_inh = AdaptiveLIFNodes( + n=inh_size, + thresh=hyper_params['thresh_inh'], + theta_plus=hyper_params['theta_plus_inh'], + refrac=hyper_params['refrac_inh'], + reset=hyper_params['reset_inh'], + tc_theta_decay=hyper_params['tc_theta_decay_inh'], + tc_decay=hyper_params['tc_decay_inh'], + traces=True, + ) + inh_monitor = Monitor(res_inh, ["s"], device=device) + self.add_monitor(inh_monitor, name='res_monitor_inh') + self.inh_monitor = inh_monitor self.add_layer(input, name='input') - self.add_layer(res, name='res') + self.add_layer(res_exc, name='res_exc') + self.add_layer(res_inh, name='res_inh') ## Connections ## - in_res_wfeat = Weight(name='in_res_weight_feature', value=w_in_res,) - in_res_conn = MulticompartmentConnection( - source=input, target=res, - device=device, pipeline=[in_res_wfeat], + in_exc_wfeat = Weight(name='in_exc_weight_feature', value=w_in_exc,) + in_exc_conn = MulticompartmentConnection( + source=input, target=res_exc, + device=device, pipeline=[in_exc_wfeat], + ) + in_inh_wfeat = Weight(name='in_inh_weight_feature', value=w_in_inh,) + in_inh_conn = MulticompartmentConnection( + source=input, target=res_inh, + device=device, pipeline=[in_inh_wfeat], + ) + + exc_exc_wfeat = Weight(name='exc_exc_weight_feature', value=w_exc_exc,) + # learning_rule=MSTDP, + # nu=hyper_params['nu_exc_exc'], range=hyper_params['range_exc_exc'], decay=hyper_params['decay_exc_exc']) + exc_exc_conn = MulticompartmentConnection( + source=res_exc, target=res_exc, + device=device, pipeline=[exc_exc_wfeat], + ) + exc_inh_wfeat = Weight(name='exc_inh_weight_feature', value=w_exc_inh,) + # learning_rule=MSTDP, + # nu=hyper_params['nu_exc_inh'], range=hyper_params['range_exc_inh'], decay=hyper_params['decay_exc_inh']) + exc_inh_conn = MulticompartmentConnection( + source=res_exc, target=res_inh, + device=device, pipeline=[exc_inh_wfeat], + ) + inh_exc_wfeat = Weight(name='inh_exc_weight_feature', value=w_inh_exc,) + # learning_rule=MSTDP, + # nu=hyper_params['nu_inh_exc'], range=hyper_params['range_inh_exc'], decay=hyper_params['decay_inh_exc']) + inh_exc_conn = MulticompartmentConnection( + source=res_inh, target=res_exc, + device=device, pipeline=[inh_exc_wfeat], ) - res_res_wfeat = Weight(name='res_res_weight_feature', value=w_res_res, + inh_inh_wfeat = Weight(name='inh_inh_weight_feature', value=w_inh_inh,) # learning_rule=MSTDP, - nu=hyper_params['nu'], range=hyper_params['range'], decay=hyper_params['decay']) - res_res_conn = MulticompartmentConnection( - source=res, target=res, - device=device, pipeline=[res_res_wfeat], + # nu=hyper_params['nu_inh_inh'], range=hyper_params['range_inh_inh'], decay=hyper_params['decay_inh_inh']) + inh_inh_conn = MulticompartmentConnection( + source=res_inh, target=res_inh, + device=device, pipeline=[inh_inh_wfeat], ) - self.add_connection(in_res_conn, source='input', target='res') - self.add_connection(res_res_conn, source='res', target='res') - self.res_res_conn = res_res_conn + self.add_connection(in_exc_conn, source='input', target='res_exc') + self.add_connection(in_inh_conn, source='input', target='res_inh') + self.add_connection(exc_exc_conn, source='res_exc', target='res_exc') + self.add_connection(exc_inh_conn, source='res_exc', target='res_inh') + self.add_connection(inh_exc_conn, source='res_inh', target='res_exc') + self.add_connection(inh_inh_conn, source='res_inh', target='res_inh') ## Migrate ## self.to(device) @@ -52,12 +97,14 @@ def __init__(self, in_size, res_size, hyper_params, def store(self, spike_train, sim_time): self.learning = True self.run(inputs={'input': spike_train}, time=sim_time, reward=1) - res_spikes = self.res_monitor.get('s') + exc_spikes = self.exc_monitor.get('s') + inh_spikes = self.inh_monitor.get('s') self.learning = False - return res_spikes + return exc_spikes, inh_spikes def recall(self, spike_train, sim_time): self.learning = False self.run(inputs={'input': spike_train}, time=sim_time,) - res_spikes = self.res_monitor.get('s') - return res_spikes + exc_spikes = self.exc_monitor.get('s') + inh_spikes = self.inh_monitor.get('s') + return exc_spikes, inh_spikes diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index 2a7281e3..e12249a0 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -11,7 +11,7 @@ ## Constants ## WIDTH = 5 HEIGHT = 5 - SAMPLES_PER_POS = 1000 + SAMPLES_PER_POS = 10 NOISE = 0.1 # Noise in sampling WINDOW_FREQ = 10 WINDOW_SIZE = 10 @@ -19,45 +19,56 @@ X_RANGE = (0, 5) Y_RANGE = (0, 5) SIM_TIME = 50 - MAX_SPIKE_FREQ = 0.3 + MAX_SPIKE_FREQ = 0.8 GC_MULTIPLES = 1 - RES_SIZE = 250 + EXC_SIZE = 250 + INH_SIZE = 50 STORE_SAMPLES = 100 - hyper_params = { - 'thresh': -55, - 'theta_plus': 0, - 'refrac': 1, - 'reset': -65, - 'tc_theta_decay': 500, - 'tc_decay': 30, - 'nu': (0.01, -0.01), - 'range': [-1, 1], - 'decay': None, - } WINDOW_FREQ = 10 WINDOW_SIZE = 10 OUT_DIM = 2 TRAIN_RATIO = 0.8 BATCH_SIZE = 10 PLOT = True + exc_hyper_params = { + 'thresh_exc': -55, + 'theta_plus_exc': 0, + 'refrac_exc': 1, + 'reset_exc': -65, + 'tc_theta_decay_exc': 500, + 'tc_decay_exc': 30, + # 'nu': (0.01, -0.01), + # 'range': [-1, 1], + # 'decay': None, + } + inh_hyper_params = { + 'thresh_inh': -55, + 'theta_plus_inh': 0, + 'refrac_inh': 1, + 'reset_inh': -65, + 'tc_theta_decay_inh': 500, + 'tc_decay_inh': 30, + } + hyper_params = exc_hyper_params | inh_hyper_params ## Sample Generation ## - x_offsets = np.random.uniform(-1, 1, NUM_CELLS) - y_offsets = np.random.uniform(-1, 1, NUM_CELLS) - offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets - scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks - vars = [.85] * NUM_CELLS # Variance of Grid Cell activity + # x_offsets = np.random.uniform(-1, 1, NUM_CELLS) + # + # y_offsets = np.random.uniform(-1, 1, NUM_CELLS) + # offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets + # scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks + # vars = [.85] * NUM_CELLS # Variance of Grid Cell activity # samples, labels, sorted_samples = sample_generator(scales, offsets, vars, X_RANGE, Y_RANGE, SAMPLES_PER_POS, # noise=NOISE, padding=1, plot=PLOT) # - # ## Spike Train Generation ## + # # Spike Train Generation ## # spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) - ## Association (Store) ## - store_reservoir(RES_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) + # ## Association (Store) ## + store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) - ## Association (Recall) ## - # recall_reservoir(RES_SIZE, SIM_TIME, PLOT) + # ## Association (Recall) ## + recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) # # Preprocess Recalls ## # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) diff --git a/scripts/Chris/DQN/recall_reservoir.py b/scripts/Chris/DQN/recall_reservoir.py index 9fe87d49..937ec46c 100644 --- a/scripts/Chris/DQN/recall_reservoir.py +++ b/scripts/Chris/DQN/recall_reservoir.py @@ -3,7 +3,7 @@ import torch from matplotlib import pyplot as plt -def recall_reservoir(res_size, sim_time, plot=False): +def recall_reservoir(exc_size, inh_size, sim_time, plot=False): print("Recalling memories...") ## Load memory module and memory keys ## @@ -13,16 +13,18 @@ def recall_reservoir(res_size, sim_time, plot=False): memory_keys, labels = pkl.load(f) ## Recall memories ## - recalled_memories = np.zeros((len(memory_keys), sim_time, res_size)) + # TODO: Plot output spikes according to inh exc populations + recalled_memories = np.zeros((len(memory_keys), sim_time, exc_size + inh_size)) recalled_memories_sorted = {} for i, (key, label) in enumerate(zip(memory_keys, labels)): - res_spike_train = res_module.recall(torch.tensor(key.reshape(sim_time, -1)), sim_time=sim_time) # Recall the sample - recalled_memories[i] = res_spike_train.squeeze() # Store the recalled memory + exc_spikes, inh_spikes = res_module.recall(torch.tensor(key.reshape(sim_time, -1)), sim_time=sim_time) # Recall the sample + all_spikes = torch.cat((exc_spikes, inh_spikes), dim=2).squeeze() + recalled_memories[i] = all_spikes # Store the recalled memory label = tuple(label.round()) if label not in recalled_memories_sorted: - recalled_memories_sorted[label] = [res_spike_train.squeeze()] + recalled_memories_sorted[label] = [all_spikes] else: - recalled_memories_sorted[label].append(res_spike_train.squeeze()) + recalled_memories_sorted[label].append(all_spikes) ## Save recalled memories ## with open('Data/recalled_memories.pkl', 'wb') as f: diff --git a/scripts/Chris/DQN/store_reservoir.py b/scripts/Chris/DQN/store_reservoir.py index f244aecb..522773f0 100644 --- a/scripts/Chris/DQN/store_reservoir.py +++ b/scripts/Chris/DQN/store_reservoir.py @@ -5,18 +5,26 @@ import numpy as np from matplotlib import pyplot as plt -def store_reservoir(res_size, num_samples, num_grid_cells, gc_multiples, sim_time, +def store_reservoir(exc_size, inh_size, num_samples, num_grid_cells, gc_multiples, sim_time, hyper_params, plot=False): print("Storing memories...") ## Create synaptic weights ## in_size = num_grid_cells * gc_multiples - w_in_res = torch.rand(in_size, res_size) - w_res_res = torch.rand(res_size, res_size) - w_in_res = sparsify(w_in_res, 0.85) - w_res_res = sparsify(w_res_res, 0.85) - w_res_res = assign_inhibition(w_res_res, 0.2, 1) - res = Reservoir(in_size, res_size, hyper_params, w_in_res, w_res_res) + w_in_exc = torch.rand(in_size, exc_size) # Initialize weights + w_in_inh = torch.rand(in_size, inh_size) + w_exc_exc = torch.rand(exc_size, exc_size) + w_exc_inh = torch.rand(exc_size, inh_size) + w_inh_exc = -torch.rand(inh_size, exc_size) + w_inh_inh = torch.rand(inh_size, inh_size) + w_in_exc = sparsify(w_in_exc, 0.85) # 0 x% of weights + w_in_inh = sparsify(w_in_inh, 0.85) + w_exc_exc = sparsify(w_exc_exc, 0.85) + w_exc_inh = sparsify(w_exc_inh, 0.85) + w_inh_exc = sparsify(w_inh_exc, 0.85) + w_inh_inh = sparsify(w_inh_inh, 0.85) + res = Reservoir(in_size, exc_size, inh_size, hyper_params, + w_in_exc, w_in_inh, w_exc_exc, w_exc_inh, w_inh_exc, w_inh_inh) ## Load grid cell spike-train samples ## with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: @@ -24,18 +32,18 @@ def store_reservoir(res_size, num_samples, num_grid_cells, gc_multiples, sim_tim ## Store memories ## # -> STDP active - if plot: - fig, ax = plt.subplots(2, 2, figsize=(10, 5)) - im = ax[0, 0].imshow(w_in_res) - ax[0, 0].set_title("Initial Input-to-Res") - plt.colorbar(im, ax=ax[0, 0]) - ax[0, 0].set_xlabel("Res Neuron") - ax[0, 0].set_ylabel("Input Neuron") - im = ax[0, 1].imshow(w_res_res) - ax[0, 1].set_title("Initial Res-to-Res") - plt.colorbar(im, ax=ax[0, 1]) - ax[0, 1].set_xlabel("Res Neuron") - ax[0, 1].set_ylabel("Res Neuron") + # if plot: + # fig, ax = plt.subplots(2, 2, figsize=(10, 5)) + # im = ax[0, 0].imshow(w_in_res) + # ax[0, 0].set_title("Initial Input-to-Res") + # plt.colorbar(im, ax=ax[0, 0]) + # ax[0, 0].set_xlabel("Res Neuron") + # ax[0, 0].set_ylabel("Input Neuron") + # im = ax[0, 1].imshow(w_res_res) + # ax[0, 1].set_title("Initial Res-to-Res") + # plt.colorbar(im, ax=ax[0, 1]) + # ax[0, 1].set_xlabel("Res Neuron") + # ax[0, 1].set_ylabel("Res Neuron") # Store samples sample_inds = np.random.choice(len(grid_cell_data), num_samples, replace=False) @@ -46,19 +54,19 @@ def store_reservoir(res_size, num_samples, num_grid_cells, gc_multiples, sim_tim res.store(torch.tensor(s.reshape(sim_time, -1)), sim_time=sim_time) res.reset_state_variables() - if plot: - im = ax[1, 0].imshow(w_in_res) - ax[1, 0].set_title("Final Input-to-Res") - plt.colorbar(im, ax=ax[1, 0]) - ax[1, 0].set_xlabel("Res Neuron") - ax[1, 0].set_ylabel("Input Neuron") - im = ax[1, 1].imshow(w_res_res) - ax[1, 1].set_title("Final Res-to-Res") - plt.colorbar(im, ax=ax[1, 1]) - ax[1, 1].set_xlabel("Res Neuron") - ax[1, 1].set_ylabel("Res Neuron") - plt.tight_layout() - plt.show() + # if plot: + # im = ax[1, 0].imshow(w_in_res) + # ax[1, 0].set_title("Final Input-to-Res") + # plt.colorbar(im, ax=ax[1, 0]) + # ax[1, 0].set_xlabel("Res Neuron") + # ax[1, 0].set_ylabel("Input Neuron") + # im = ax[1, 1].imshow(w_res_res) + # ax[1, 1].set_title("Final Res-to-Res") + # plt.colorbar(im, ax=ax[1, 1]) + # ax[1, 1].set_xlabel("Res Neuron") + # ax[1, 1].set_ylabel("Res Neuron") + # plt.tight_layout() + # plt.show() ## Save ## with open('Data/reservoir_module.pkl', 'wb') as f: From 59c732bc130a0b453b1439b33ca98ea6c22d1b2d Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Mon, 9 Sep 2024 14:41:47 -0400 Subject: [PATCH 18/27] Working classification for grid cell memories --- scripts/Chris/DQN/Eval.ipynb | 148 +++++++++--------- scripts/Chris/DQN/classify_recalls.py | 20 ++- scripts/Chris/DQN/pipeline_executor.py | 21 +-- .../Chris/DQN/recalled_mem_preprocessing.py | 1 + scripts/Chris/DQN/store_reservoir.py | 8 +- 5 files changed, 108 insertions(+), 90 deletions(-) diff --git a/scripts/Chris/DQN/Eval.ipynb b/scripts/Chris/DQN/Eval.ipynb index eba7c458..137b98f9 100644 --- a/scripts/Chris/DQN/Eval.ipynb +++ b/scripts/Chris/DQN/Eval.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-09-09T01:41:49.738462Z", - "start_time": "2024-09-09T01:41:49.513476Z" + "end_time": "2024-09-09T18:29:20.945623Z", + "start_time": "2024-09-09T18:29:20.669402Z" } }, "source": [ @@ -17,18 +17,13 @@ "from matplotlib.gridspec import GridSpec " ], "outputs": [], - "execution_count": 1 + "execution_count": 2 }, { - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-09T01:45:32.259311Z", - "start_time": "2024-09-09T01:45:31.554962Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ - "# Plot input spikes\n", + "|# Plot input spikes\n", "with open('Data/grid_cell_spk_trains.pkl', 'rb') as f:\n", " spike_trains, labels = pkl.load(f)\n", "with open('Data/grid_cell_spk_trains_sorted.pkl', 'rb') as f:\n", @@ -60,59 +55,8 @@ " plt.show()" ], "id": "90ce759a18d4f156", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 3 + "outputs": [], + "execution_count": null }, { "metadata": { @@ -213,7 +157,12 @@ "execution_count": null }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-09T18:29:28.479029Z", + "start_time": "2024-09-09T18:29:24.512935Z" + } + }, "cell_type": "code", "source": [ "# Plot recalls\n", @@ -241,8 +190,67 @@ " ax.set(yticklabels=[])" ], "id": "f30e1a968c75d36", - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/christopher-earl/School/bindsnet/venv/lib/python3.11/site-packages/torch/storage.py:414: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " return torch.load(io.BytesIO(b))\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 }, { "metadata": { @@ -274,14 +282,6 @@ } ], "execution_count": 9 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": "", - "id": "a2fcc559fb17b11e" } ], "metadata": { diff --git a/scripts/Chris/DQN/classify_recalls.py b/scripts/Chris/DQN/classify_recalls.py index 79c8b243..dd3b40ca 100644 --- a/scripts/Chris/DQN/classify_recalls.py +++ b/scripts/Chris/DQN/classify_recalls.py @@ -16,7 +16,7 @@ def __getitem__(self, idx): # Compress spike train into windows for dimension reduction return self.samples[idx].flatten(), self.labels[idx] -def classify_recalls(out_dim, train_ratio, batch_size): +def classify_recalls(out_dim, train_ratio, batch_size, epochs): print("Classifying recalled memories...") ## Load recalled memory samples ## @@ -38,7 +38,7 @@ def classify_recalls(out_dim, train_ratio, batch_size): ## Training ## loss_log = [] accuracy_log = [] - for epoch in range(20): + for epoch in range(epochs): total_loss = 0 correct = 0 for memory_batch, positions in train_loader: @@ -68,6 +68,8 @@ def classify_recalls(out_dim, train_ratio, batch_size): ## Testing ## total = 0 correct = 0 + confusion_matrix = torch.zeros(25, 25) + out_of_bounds = 0 with torch.no_grad(): for memories, labels in test_loader: outputs = model(memories) @@ -75,6 +77,20 @@ def classify_recalls(out_dim, train_ratio, batch_size): total += len(labels) correct += torch.all(outputs.round() == labels.round(), dim=1).sum().item() # Check if prediction for both x and y are correct + for t, p in zip(labels, outputs): + label_ind = int(t[0].round() * 5 + t[1].round()) + pred_ind = int(p[0].round() * 5 + p[1].round()) + if label_ind < 0 or label_ind >= 25 or pred_ind < 0 or pred_ind >= 25: + out_of_bounds += 1 + else: + confusion_matrix[label_ind, pred_ind] += 1 + + plt.imshow(confusion_matrix) + plt.title('Confusion Matrix') + plt.xlabel('Predicted') + plt.ylabel('True Label') + plt.colorbar() + plt.show() print(f'Accuracy: {round(correct / total, 3)*100}%') diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index e12249a0..a5d1dfa2 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -11,7 +11,7 @@ ## Constants ## WIDTH = 5 HEIGHT = 5 - SAMPLES_PER_POS = 10 + SAMPLES_PER_POS = 1000 NOISE = 0.1 # Noise in sampling WINDOW_FREQ = 10 WINDOW_SIZE = 10 @@ -29,6 +29,7 @@ OUT_DIM = 2 TRAIN_RATIO = 0.8 BATCH_SIZE = 10 + TRAIN_EPOCHS = 15 PLOT = True exc_hyper_params = { 'thresh_exc': -55, @@ -63,15 +64,15 @@ # # # Spike Train Generation ## # spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) - - # ## Association (Store) ## - store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) - - # ## Association (Recall) ## - recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) - + # + # # ## Association (Store) ## + # store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) + # + # # ## Association (Recall) ## + # recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) + # # # Preprocess Recalls ## # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) - ## Train ANN ## - # classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE) + # Train ANN ## + classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) diff --git a/scripts/Chris/DQN/recalled_mem_preprocessing.py b/scripts/Chris/DQN/recalled_mem_preprocessing.py index 39de5913..3ec1fe4b 100644 --- a/scripts/Chris/DQN/recalled_mem_preprocessing.py +++ b/scripts/Chris/DQN/recalled_mem_preprocessing.py @@ -56,6 +56,7 @@ def recalled_mem_preprocessing(window_freq, window_size, plot): # plt.tight_layout() # plt.show() + positions = np.array([key for key in new_samples_sorted.keys()]) fig = plt.figure(figsize=(10, 10)) gs = fig.add_gridspec(nrows=5, ncols=5) for i, pos in enumerate(positions): diff --git a/scripts/Chris/DQN/store_reservoir.py b/scripts/Chris/DQN/store_reservoir.py index 522773f0..f622a6f4 100644 --- a/scripts/Chris/DQN/store_reservoir.py +++ b/scripts/Chris/DQN/store_reservoir.py @@ -16,12 +16,12 @@ def store_reservoir(exc_size, inh_size, num_samples, num_grid_cells, gc_multiple w_exc_exc = torch.rand(exc_size, exc_size) w_exc_inh = torch.rand(exc_size, inh_size) w_inh_exc = -torch.rand(inh_size, exc_size) - w_inh_inh = torch.rand(inh_size, inh_size) + w_inh_inh = -torch.rand(inh_size, inh_size) w_in_exc = sparsify(w_in_exc, 0.85) # 0 x% of weights w_in_inh = sparsify(w_in_inh, 0.85) - w_exc_exc = sparsify(w_exc_exc, 0.85) - w_exc_inh = sparsify(w_exc_inh, 0.85) - w_inh_exc = sparsify(w_inh_exc, 0.85) + w_exc_exc = sparsify(w_exc_exc, 0.8) + w_exc_inh = sparsify(w_exc_inh, 0.5) + w_inh_exc = sparsify(w_inh_exc, 0.7) w_inh_inh = sparsify(w_inh_inh, 0.85) res = Reservoir(in_size, exc_size, inh_size, hyper_params, w_in_exc, w_in_inh, w_exc_exc, w_exc_inh, w_inh_exc, w_inh_inh) From ce07cddc82521d0539a35fd78bcbcec785bc49e1 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 10 Sep 2024 17:58:27 -0400 Subject: [PATCH 19/27] Working DQN --- scripts/Chris/DQN/Environment.py | 60 +++++--- scripts/Chris/DQN/pipeline_executor.py | 4 +- scripts/Chris/DQN/recall_reservoir.py | 1 - scripts/Chris/DQN/train_DQN.py | 182 +++++++++++++++++++++++++ 4 files changed, 227 insertions(+), 20 deletions(-) create mode 100644 scripts/Chris/DQN/train_DQN.py diff --git a/scripts/Chris/DQN/Environment.py b/scripts/Chris/DQN/Environment.py index e7986cbb..9c720b61 100644 --- a/scripts/Chris/DQN/Environment.py +++ b/scripts/Chris/DQN/Environment.py @@ -5,14 +5,18 @@ import pickle as pkl import matplotlib.pyplot as plt -class Maze_Environment(Maze): +class Maze_Environment(): def __init__(self, width, height): # Generate basic maze & solve - super().__init__(width=width, height=height, generator=DepthFirstSearchGenerator()) - solver = MazeSolver() - self.path = solver.solve(self) - self.agent_cell = self.start_cell + self.width = width + self.height = height + self.maze = Maze(width=width, height=height, generator=DepthFirstSearchGenerator()) + self.solver = MazeSolver() + self.path = self.solver.solve(self.maze) + self.maze.path = self.path # No idea why this is necessary + self.agent_cell = self.maze.start_cell + self.num_actions = 4 def plot(self): # Box around maze @@ -40,18 +44,37 @@ def plot(self): plt.plot([row+0.5, row+0.5], [column-0.5, column+0.5], color='black') def reset(self): - pass + # self.maze = Maze(width=self.width, height=self.height, generator=DepthFirstSearchGenerator()) + # self.solver = MazeSolver() + # self.path = self.solver.solve(self.maze) + # self.maze.path = self.path # No idea why this is necessary + # self.agent_cell = self.maze.start_cell + # return self.agent_cell, {} + self.agent_cell = self.maze.start_cell + return self.agent_cell, {} - # Takes action, returns next state, reward, done, info + + # Takes action + # Returns next state, reward, done, info def step(self, action): + # Transform action into Direction + if action == 0: + action = Direction.N + elif action == 1: + action = Direction.E + elif action == 2: + action = Direction.S + elif action == 3: + action = Direction.W + # Check if action runs into wall if action not in self.agent_cell.open_walls: - return self.agent_cell, -1, False, {} + return self.agent_cell, -.5, False, {} # Move agent else: - self.agent_cell = self.agent_pos.neighbor(action) - if self.agent_cell == self.end_cell: + self.agent_cell = self.maze.neighbor(self.agent_cell, action) + if self.agent_cell == self.maze.end_cell: # Check if agent has reached the end return self.agent_cell, 1, True, {} else: return self.agent_cell, 0, False, {} @@ -61,11 +84,14 @@ def save(self, filename): pkl.dump(self, f) + + if __name__ == '__main__': - maze = Maze_Environment(width=25, height=25) - solver = MazeSolver() - path = solver.solve(maze) - maze.path = path - print(maze) - print(f'start: {maze.start_cell}') - print(f'end: {maze.end_cell}') \ No newline at end of file + maze_env = Maze_Environment(width=25, height=25) + print(maze_env.maze) + print(f'start: {maze_env.maze.start_cell}') + print(f'end: {maze_env.maze.end_cell}') + maze_env.reset() + print(maze_env.maze) + print(f'start: {maze_env.maze.start_cell}') + print(f'end: {maze_env.maze.end_cell}') diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index a5d1dfa2..07ec5fc4 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -11,7 +11,7 @@ ## Constants ## WIDTH = 5 HEIGHT = 5 - SAMPLES_PER_POS = 1000 + SAMPLES_PER_POS = 5000 NOISE = 0.1 # Noise in sampling WINDOW_FREQ = 10 WINDOW_SIZE = 10 @@ -74,5 +74,5 @@ # # Preprocess Recalls ## # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) - # Train ANN ## + ## Train ANN ## classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) diff --git a/scripts/Chris/DQN/recall_reservoir.py b/scripts/Chris/DQN/recall_reservoir.py index 937ec46c..873c751e 100644 --- a/scripts/Chris/DQN/recall_reservoir.py +++ b/scripts/Chris/DQN/recall_reservoir.py @@ -13,7 +13,6 @@ def recall_reservoir(exc_size, inh_size, sim_time, plot=False): memory_keys, labels = pkl.load(f) ## Recall memories ## - # TODO: Plot output spikes according to inh exc populations recalled_memories = np.zeros((len(memory_keys), sim_time, exc_size + inh_size)) recalled_memories_sorted = {} for i, (key, label) in enumerate(zip(memory_keys, labels)): diff --git a/scripts/Chris/DQN/train_DQN.py b/scripts/Chris/DQN/train_DQN.py new file mode 100644 index 00000000..a6840ddc --- /dev/null +++ b/scripts/Chris/DQN/train_DQN.py @@ -0,0 +1,182 @@ +import math +import random +import matplotlib +import matplotlib.pyplot as plt +from collections import namedtuple, deque +from itertools import count + +import numpy as np +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F + +from scripts.Chris.DQN.Environment import Maze_Environment + +Transition = namedtuple('Transition', + ('state', 'action', 'next_state', 'reward')) + +class ReplayMemory(object): + def __init__(self, capacity): + self.memory = deque([], maxlen=capacity) + + def push(self, *args): + """Save a transition""" + self.memory.append(Transition(*args)) + + def sample(self, batch_size): + return random.sample(self.memory, batch_size) + + def __len__(self): + return len(self.memory) + +class DQN(nn.Module): + + def __init__(self, n_observations, n_actions): + super(DQN, self).__init__() + self.layer1 = nn.Linear(n_observations, 128) + self.layer2 = nn.Linear(128, 128) + self.layer3 = nn.Linear(128, n_actions) + + # Called with either one element to determine next action, or a batch + # during optimization. Returns tensor([[left0exp,right0exp]...]). + def forward(self, x): + x = F.relu(self.layer1(x)) + x = F.relu(self.layer2(x)) + return self.layer3(x) + + +# Select action using epsilon-greedy policy +def select_action(state, step, eps, policy_net, env): + # eps_threshold = EPS_END + (EPS_START - EPS_END) * \ + # math.exp(-1. * step / EPS_DECAY) + + # Select action from policy net + if random.random() > eps: + with torch.no_grad(): + # t.max(1) will return the largest column value of each row. + # second column on max result is index of where max element was + # found, so we pick action with the larger expected reward. + return policy_net(state).max(1).indices.view(1, 1) + + # Select random action (exploration) + else: + return torch.tensor(np.random.choice(env.num_actions)).view(1, 1) + + +# Optimize DQN +def optimize_model(memory, batch_size, policy_net, target_net, optimizer, gamma, device): + if len(memory) < batch_size: + return + transitions = memory.sample(batch_size) + # Transpose the batch (see https://stackoverflow.com/a/19343/3343043 for + # detailed explanation). This converts batch-array of Transitions + # to Transition of batch-arrays. + batch = Transition(*zip(*transitions)) + + # Compute a mask of non-final states and concatenate the batch elements + # (a final state would've been the one after which simulation ended) + non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, + batch.next_state)), device=device, dtype=torch.bool) + non_final_next_states = torch.cat([s for s in batch.next_state + if s is not None]) + state_batch = torch.cat(batch.state) + action_batch = torch.cat(batch.action) + reward_batch = torch.cat(batch.reward) + + # Compute Q(s_t, a) - the model computes Q(s_t), then we select the + # columns of actions taken. These are the actions which would've been taken + # for each batch state according to policy_net + state_action_values = policy_net(state_batch).gather(1, action_batch) + + # Compute V(s_{t+1}) for all next states. + # Expected values of actions for non_final_next_states are computed based + # on the "older" target_net; selecting their best reward with max(1).values + # This is merged based on the mask, such that we'll have either the expected + # state value or 0 in case the state was final. + next_state_values = torch.zeros(batch_size, device=device) + with torch.no_grad(): + next_state_values[non_final_mask] = target_net(non_final_next_states).max(1).values + # Compute the expected Q values + expected_state_action_values = (next_state_values * gamma) + reward_batch + + # Compute Huber loss + criterion = nn.SmoothL1Loss() + loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1)) + + # Optimize the model + optimizer.zero_grad() + loss.backward() + # In-place gradient clipping + torch.nn.utils.clip_grad_value_(policy_net.parameters(), 100) + optimizer.step() + + +if __name__ == '__main__': + device = 'cpu' + n_actions = 4 + n_observations = 2 + LR = 0.01 + EPS_START = 0.9 + EPS_END = 0.05 + EPS_DECAY = 1000 + TAU = 0.005 + GAMMA = 0.99 + MAX_STEPS_PER_EP = 1000 + TOTAL_STEPS = 10000 + MAX_EPS = 300 + BATCH_SIZE = 128 + + policy_net_ = DQN(n_observations, n_actions).to(device) + target_net_ = DQN(n_observations, n_actions).to(device) + target_net_.load_state_dict(policy_net_.state_dict()) + optimizer_ = optim.AdamW(policy_net_.parameters(), lr=LR, amsgrad=True) + memory_ = ReplayMemory(10000) + env_ = Maze_Environment(width=5, height=5) + + episode_durations = [] + episodes = 0 + total_steps = 0 + print(env_.maze) + while total_steps < TOTAL_STEPS and episodes < MAX_EPS: + # Initialize the environment and get its state + state, info = env_.reset() + state = torch.tensor(state.coordinates, dtype=torch.float32, device=device).unsqueeze(0) + # print(f"Episode {i_episode}") + for t in count(): + eps = EPS_END + (EPS_START - EPS_END) * math.exp(-1. * total_steps / EPS_DECAY) + action = select_action(state, t, eps, policy_net_, env_) + observation, reward, terminated, _ = env_.step(action.item()) + reward = torch.tensor([reward], device=device) + + if terminated: + next_state = None + else: + next_state = torch.tensor(observation.coordinates, dtype=torch.float32, device=device).unsqueeze(0) + + # Store the transition in memory + memory_.push(state, action, next_state, reward) + + # Move to the next state + state = next_state + + # Perform one step of the optimization (on the policy network) + optimize_model(memory_, BATCH_SIZE, policy_net_, target_net_, optimizer_, gamma=GAMMA, device=device) + + # Soft update of the target network's weights + # θ′ ← τ θ + (1 −τ )θ′ + target_net_state_dict = target_net_.state_dict() + policy_net_state_dict = policy_net_.state_dict() + for key in policy_net_state_dict: + target_net_state_dict[key] = policy_net_state_dict[key] * TAU + target_net_state_dict[key] * (1 - TAU) + target_net_.load_state_dict(target_net_state_dict) + + total_steps += 1 + if terminated or t > MAX_STEPS_PER_EP: + episode_durations.append(t + 1) + break + print(f"Episode {episodes} lasted {t+1} steps, eps = {round(eps, 2)} total steps = {total_steps}") + episodes += 1 + + plt.plot(episode_durations) + plt.show() From 701a18e71e02b7d5eac3bf70f63edd94a19e1152 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Wed, 11 Sep 2024 15:47:09 -0400 Subject: [PATCH 20/27] Environment animation --- scripts/Chris/DQN/ANN.py | 64 -------------- scripts/Chris/DQN/Environment.py | 80 +++++++++++++---- scripts/Chris/DQN/pipeline_executor.py | 17 +++- .../Chris/DQN/recalled_mem_preprocessing.py | 2 + scripts/Chris/DQN/sample_generator.py | 24 +---- scripts/Chris/DQN/train_DQN.py | 88 +++++++++++-------- 6 files changed, 130 insertions(+), 145 deletions(-) diff --git a/scripts/Chris/DQN/ANN.py b/scripts/Chris/DQN/ANN.py index bd54ff2b..c280c772 100644 --- a/scripts/Chris/DQN/ANN.py +++ b/scripts/Chris/DQN/ANN.py @@ -43,70 +43,6 @@ def forward(self, x): x = x.to(torch.float32) return self.sequence(x) - -class DQN: - def __init__(self, input_dim, output_dim, gamma=0.99, batch_size=128, device='cpu'): - self.policy_net = ANN(input_dim, output_dim) - self.target_net = ANN(input_dim, output_dim) - self.optimizer = Adam(self.policy_net.parameters()) - self.memory = ReplayMemory(10000) - self.gamma = gamma - self.batch_size = batch_size - self.device = device - - def select_action(self, state, epsilon): - # Random action - if random.random() < epsilon: - return torch.tensor([[random.randrange(2)]], dtype=torch.float32) - - # ANN action - else: - with torch.no_grad(): - return self.policy_net(state).argmax() - - def optimize_model(self): - if len(self.memory) < self.batch_size: - return - transitions = self.memory.sample(self.batch_size) - batch = Transition(*zip(*transitions)) - - non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, - batch.next_state)), device=self.device, dtype=torch.bool) - non_final_next_states = torch.cat([s for s in batch.next_state - if s is not None]).reshape(-1, 2) - state_batch = torch.cat(batch.state).reshape(-1, 2) - action_batch = torch.tensor(batch.action).to(torch.int64) - reward_batch = torch.tensor(batch.reward) - - # Compute Q(s_t, a) - state_action_values = self.policy_net(state_batch)[action_batch] - - # Compute V(s_{t+1}) for all next states. - next_state_values = torch.zeros(self.batch_size, device=self.device) - with torch.no_grad(): - next_state_values[non_final_mask] = self.target_net(non_final_next_states).max(1).values - - # Compute the expected Q values - expected_state_action_values = (next_state_values * self.gamma) + reward_batch - - # Compute Loss - criterion = torch.nn.SmoothL1Loss() - loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1)) - - # Optimize the model - self.optimizer.zero_grad() - loss.backward() - # In-place gradient clipping - torch.nn.utils.clip_grad_value_(self.policy_net.parameters(), 100) - self.optimizer.step() - - def update_target(self, tau=0.005): - target_net_state_dict = self.target_net.state_dict() - policy_net_state_dict = self.policy_net.state_dict() - for key in policy_net_state_dict: - target_net_state_dict[key] = policy_net_state_dict[key]*tau + target_net_state_dict[key] * (1 - tau) - - class Mem_Dataset(torch.utils.data.Dataset): def __init__(self, samples, labels): self.samples = samples diff --git a/scripts/Chris/DQN/Environment.py b/scripts/Chris/DQN/Environment.py index 9c720b61..961ab4e6 100644 --- a/scripts/Chris/DQN/Environment.py +++ b/scripts/Chris/DQN/Environment.py @@ -1,9 +1,15 @@ +import random +import numpy as np from labyrinth.generate import DepthFirstSearchGenerator from labyrinth.grid import Cell, Direction from labyrinth.maze import Maze from labyrinth.solve import MazeSolver +from matplotlib.pyplot import plot as plt +from matplotlib.animation import FuncAnimation + import pickle as pkl import matplotlib.pyplot as plt +from torch import optim class Maze_Environment(): def __init__(self, width, height): @@ -17,6 +23,8 @@ def __init__(self, width, height): self.maze.path = self.path # No idea why this is necessary self.agent_cell = self.maze.start_cell self.num_actions = 4 + self.history = [(self.agent_cell.coordinates, 0, False, {})] # (state, reward, done, info) + self.pos_history = [] def plot(self): # Box around maze @@ -29,12 +37,12 @@ def plot(self): for row in range(self.height): for column in range(self.width): # Path - cell = self[column, row] # Tranpose maze coordinates (just how the maze is stored) - if cell == self.start_cell: + cell = self.maze[column, row] # Tranpose maze coordinates (just how the maze is stored) + if cell == self.maze.start_cell: plt.plot(row, column, 'go') - elif cell == self.end_cell: + elif cell == self.maze.end_cell: plt.plot(row, column,'bo') - elif cell in self.path: + elif cell in self.maze.path: plt.plot(row, column, 'ro') # Walls @@ -44,16 +52,11 @@ def plot(self): plt.plot([row+0.5, row+0.5], [column-0.5, column+0.5], color='black') def reset(self): - # self.maze = Maze(width=self.width, height=self.height, generator=DepthFirstSearchGenerator()) - # self.solver = MazeSolver() - # self.path = self.solver.solve(self.maze) - # self.maze.path = self.path # No idea why this is necessary - # self.agent_cell = self.maze.start_cell - # return self.agent_cell, {} self.agent_cell = self.maze.start_cell + self.step_history = [] + self.pos_history = [] return self.agent_cell, {} - # Takes action # Returns next state, reward, done, info def step(self, action): @@ -69,29 +72,68 @@ def step(self, action): # Check if action runs into wall if action not in self.agent_cell.open_walls: + self.history.append((self.agent_cell.coordinates, -0.5, False, {})) return self.agent_cell, -.5, False, {} # Move agent else: self.agent_cell = self.maze.neighbor(self.agent_cell, action) if self.agent_cell == self.maze.end_cell: # Check if agent has reached the end + self.history.append(self.agent_cell.coordinates, 1, True, {}) return self.agent_cell, 1, True, {} else: + self.history.append((self.agent_cell.coordinates, 0, False, {})) return self.agent_cell, 0, False, {} def save(self, filename): with open(filename, 'wb') as f: pkl.dump(self, f) + def animate_history(self): + def update(i): + plt.clf() + self.plot() + plt.plot(self.history[i][0][1], self.history[i][0][0], 'yo') + plt.title(f'Step {i}, Reward: {self.history[i][1]}') + ani = FuncAnimation(plt.gcf(), update, frames=len(self.history), repeat=False) + ani.save('maze.gif', writer='ffmpeg', fps=10) + +class Grid_Cell_Maze_Environment(Maze_Environment): + def __init__(self, width, height): + super().__init__(width, height) + # Load spike train samples + # {position: [spike_trains]} + with open('Data/preprocessed_recalls_sorted.pkl', 'rb') as f: + self.samples = pkl.load(f) + + def reset(self): + cell, info = super().reset() + return self.state_to_grid_cell_spikes(cell), info + + def step(self, action): + obs, reward, done, info = super().step(action) + obs = self.state_to_grid_cell_spikes(obs) + return obs, reward, done, info + + def state_to_grid_cell_spikes(self, cell): + return random.choice(self.samples[cell.coordinates]) if __name__ == '__main__': - maze_env = Maze_Environment(width=25, height=25) - print(maze_env.maze) - print(f'start: {maze_env.maze.start_cell}') - print(f'end: {maze_env.maze.end_cell}') - maze_env.reset() - print(maze_env.maze) - print(f'start: {maze_env.maze.start_cell}') - print(f'end: {maze_env.maze.end_cell}') + from train_DQN import DQN, ReplayMemory + from scripts.Chris.DQN.train_DQN import run_episode + + device = 'cpu' + n_actions = 4 + input_size = 300 + lr = 0.01 + policy_net = DQN(input_size, n_actions).to(device) + target_net = DQN(input_size, n_actions).to(device) + target_net.load_state_dict(policy_net.state_dict()) + optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) + memory = ReplayMemory(10000) + env = Grid_Cell_Maze_Environment(width=5, height=5) + + run_episode(env, policy_net, 'cpu', 100, eps=0.9) + env.animate_history() diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index 07ec5fc4..c0efb667 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -1,5 +1,6 @@ import numpy as np import pickle as pkl +from train_DQN import train_DQN from sample_generator import sample_generator from spike_train_generator import spike_train_generator from store_reservoir import store_reservoir @@ -74,5 +75,19 @@ # # Preprocess Recalls ## # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) + ## Train DQN ## + LR = 0.01 + EPS_START = 0.9 + EPS_END = 0.05 + EPS_DECAY = 1000 + TAU = 0.005 + GAMMA = 0.99 + MAX_STEPS_PER_EP = 10 + MAX_TOTAL_STEPS = 10 + MAX_EPS = 3000 + BATCH_SIZE = 128 + INPUT_SIZE = EXC_SIZE + INH_SIZE + train_DQN(INPUT_SIZE, LR, BATCH_SIZE, EPS_START, EPS_END, EPS_DECAY, TAU, GAMMA, MAX_STEPS_PER_EP, MAX_TOTAL_STEPS, MAX_EPS) + ## Train ANN ## - classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) + # classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) diff --git a/scripts/Chris/DQN/recalled_mem_preprocessing.py b/scripts/Chris/DQN/recalled_mem_preprocessing.py index 3ec1fe4b..b8c29d5f 100644 --- a/scripts/Chris/DQN/recalled_mem_preprocessing.py +++ b/scripts/Chris/DQN/recalled_mem_preprocessing.py @@ -42,6 +42,8 @@ def recalled_mem_preprocessing(window_freq, window_size, plot): ## Save transformed samples ## with open('Data/preprocessed_recalls.pkl', 'wb') as f: pkl.dump((new_samples, labels), f) + with open('Data/preprocessed_recalls_sorted.pkl', 'wb') as f: + pkl.dump(new_samples_sorted, f) if plot: # positions = np.array([key for key in new_samples_sorted.keys()]) diff --git a/scripts/Chris/DQN/sample_generator.py b/scripts/Chris/DQN/sample_generator.py index e6241d75..c8c84170 100644 --- a/scripts/Chris/DQN/sample_generator.py +++ b/scripts/Chris/DQN/sample_generator.py @@ -26,7 +26,8 @@ def inter_positional_spread(env_to_gc): return spread # Generate grid cell activity for all integer coordinate positions in environment -def sample_generator(scales, offsets, vars, x_range, y_range, samples_per_pos, noise=0.1, padding=2, plot=False): +def sample_generator(scales, offsets, vars, x_range, y_range, + samples_per_pos, noise=0.1, padding=2, plot=False): print('Generating samples...') sorted_samples = {} samples = np.zeros((x_range[1] * y_range[1] * samples_per_pos, len(scales))) @@ -62,24 +63,3 @@ def sample_generator(scales, offsets, vars, x_range, y_range, samples_per_pos, n plt.show() return samples, labels, sorted_samples - -if __name__ == '__main__': - ## Constants ## - WIDTH = 5 - HEIGHT = 5 - SAMPLES_PER_POS = 1000 - WINDOW_FREQ = 10 - WINDOW_SIZE = 10 - # Grid Cells - num_cells_ = 20 - x_range_ = (0, 5) - y_range_ = (0, 5) - x_offsets_ = np.random.uniform(-1, 1, num_cells_) - y_offsets_ = np.random.uniform(-1, 1, num_cells_) - offsets_ = list(zip(x_offsets_, y_offsets_)) - scales_ = [1 + 0.01 * i for i in range(num_cells_)] - vars_ = [0.85]*num_cells_ - - # Test spread for set of parameters - # Shape = (num_samples, num_cells) - samples_, labels_, sorted_samples_ = sample_generator(scales_, offsets_, vars_, x_range_, y_range_, SAMPLES_PER_POS) diff --git a/scripts/Chris/DQN/train_DQN.py b/scripts/Chris/DQN/train_DQN.py index a6840ddc..73d208e8 100644 --- a/scripts/Chris/DQN/train_DQN.py +++ b/scripts/Chris/DQN/train_DQN.py @@ -11,7 +11,7 @@ import torch.optim as optim import torch.nn.functional as F -from scripts.Chris.DQN.Environment import Maze_Environment +from scripts.Chris.DQN.Environment import Maze_Environment, Grid_Cell_Maze_Environment Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward')) @@ -48,8 +48,6 @@ def forward(self, x): # Select action using epsilon-greedy policy def select_action(state, step, eps, policy_net, env): - # eps_threshold = EPS_END + (EPS_START - EPS_END) * \ - # math.exp(-1. * step / EPS_DECAY) # Select action from policy net if random.random() > eps: @@ -112,70 +110,82 @@ def optimize_model(memory, batch_size, policy_net, target_net, optimizer, gamma, optimizer.step() -if __name__ == '__main__': +# Run single episode of Maze env for DQN training +def run_episode(env, policy_net, device, max_steps, eps=0): + # Initialize the environment and get its state + state, info = env.reset() + state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0) + t = 0 + while t < max_steps: + action = select_action(state, t, eps, policy_net, env) # eps = 0 -> no exploration + observation, reward, terminated, _ = env.step(action.item()) + + if terminated: + next_state = None + else: + next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0) + + # Move to the next state + state = next_state + + if terminated: + break + + t+=1 + + + +def train_DQN(input_size, lr, batch_size, eps_start, eps_end, eps_decay, tau, gamma, max_steps_per_ep, max_total_steps, max_eps): device = 'cpu' n_actions = 4 - n_observations = 2 - LR = 0.01 - EPS_START = 0.9 - EPS_END = 0.05 - EPS_DECAY = 1000 - TAU = 0.005 - GAMMA = 0.99 - MAX_STEPS_PER_EP = 1000 - TOTAL_STEPS = 10000 - MAX_EPS = 300 - BATCH_SIZE = 128 - - policy_net_ = DQN(n_observations, n_actions).to(device) - target_net_ = DQN(n_observations, n_actions).to(device) - target_net_.load_state_dict(policy_net_.state_dict()) - optimizer_ = optim.AdamW(policy_net_.parameters(), lr=LR, amsgrad=True) - memory_ = ReplayMemory(10000) - env_ = Maze_Environment(width=5, height=5) + policy_net = DQN(input_size, n_actions).to(device) + target_net = DQN(input_size, n_actions).to(device) + target_net.load_state_dict(policy_net.state_dict()) + optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) + memory = ReplayMemory(10000) + env = Grid_Cell_Maze_Environment(width=5, height=5) episode_durations = [] episodes = 0 total_steps = 0 - print(env_.maze) - while total_steps < TOTAL_STEPS and episodes < MAX_EPS: + print(env.maze) + while total_steps < max_total_steps and episodes < max_eps: # Initialize the environment and get its state - state, info = env_.reset() - state = torch.tensor(state.coordinates, dtype=torch.float32, device=device).unsqueeze(0) - # print(f"Episode {i_episode}") + state, info = env.reset() + state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0) for t in count(): - eps = EPS_END + (EPS_START - EPS_END) * math.exp(-1. * total_steps / EPS_DECAY) - action = select_action(state, t, eps, policy_net_, env_) - observation, reward, terminated, _ = env_.step(action.item()) + eps = eps_end + (eps_start - eps_end) * math.exp(-1. * total_steps / eps_decay) + action = select_action(state, t, eps, policy_net, env) + observation, reward, terminated, _ = env.step(action.item()) reward = torch.tensor([reward], device=device) if terminated: next_state = None else: - next_state = torch.tensor(observation.coordinates, dtype=torch.float32, device=device).unsqueeze(0) + next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0) # Store the transition in memory - memory_.push(state, action, next_state, reward) + memory.push(state, action, next_state, reward) # Move to the next state state = next_state # Perform one step of the optimization (on the policy network) - optimize_model(memory_, BATCH_SIZE, policy_net_, target_net_, optimizer_, gamma=GAMMA, device=device) + optimize_model(memory, batch_size, policy_net, target_net, optimizer, gamma=gamma, device=device) # Soft update of the target network's weights # θ′ ← τ θ + (1 −τ )θ′ - target_net_state_dict = target_net_.state_dict() - policy_net_state_dict = policy_net_.state_dict() + target_net_state_dict = target_net.state_dict() + policy_net_state_dict = policy_net.state_dict() for key in policy_net_state_dict: - target_net_state_dict[key] = policy_net_state_dict[key] * TAU + target_net_state_dict[key] * (1 - TAU) - target_net_.load_state_dict(target_net_state_dict) + target_net_state_dict[key] = policy_net_state_dict[key] * tau + target_net_state_dict[key] * (1 - tau) + target_net.load_state_dict(target_net_state_dict) total_steps += 1 - if terminated or t > MAX_STEPS_PER_EP: + if terminated or t > max_steps_per_ep: episode_durations.append(t + 1) break - print(f"Episode {episodes} lasted {t+1} steps, eps = {round(eps, 2)} total steps = {total_steps}") + print(f"Episode {episodes} lasted {t + 1} steps, eps = {round(eps, 2)} total steps = {total_steps}") episodes += 1 plt.plot(episode_durations) From 5b6f3d2b3f6b03864f61a9750d49d3549cf608ec Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Sun, 15 Sep 2024 14:15:34 -0400 Subject: [PATCH 21/27] Final version of RL model --- scripts/Chris/DQN/Environment.py | 16 +++--- scripts/Chris/DQN/Eval.ipynb | 57 +++---------------- scripts/Chris/DQN/pipeline_executor.py | 26 +++++---- scripts/Chris/DQN/recall_reservoir.py | 44 +++++++------- .../Chris/DQN/recalled_mem_preprocessing.py | 18 +----- scripts/Chris/DQN/train_DQN.py | 30 +++++++--- 6 files changed, 78 insertions(+), 113 deletions(-) diff --git a/scripts/Chris/DQN/Environment.py b/scripts/Chris/DQN/Environment.py index 961ab4e6..7b05e189 100644 --- a/scripts/Chris/DQN/Environment.py +++ b/scripts/Chris/DQN/Environment.py @@ -24,7 +24,6 @@ def __init__(self, width, height): self.agent_cell = self.maze.start_cell self.num_actions = 4 self.history = [(self.agent_cell.coordinates, 0, False, {})] # (state, reward, done, info) - self.pos_history = [] def plot(self): # Box around maze @@ -53,8 +52,7 @@ def plot(self): def reset(self): self.agent_cell = self.maze.start_cell - self.step_history = [] - self.pos_history = [] + self.history = [(self.agent_cell.coordinates, 0, False, {})] return self.agent_cell, {} # Takes action @@ -72,14 +70,14 @@ def step(self, action): # Check if action runs into wall if action not in self.agent_cell.open_walls: - self.history.append((self.agent_cell.coordinates, -0.5, False, {})) - return self.agent_cell, -.5, False, {} + self.history.append((self.agent_cell.coordinates, -0.1, False, {})) + return self.agent_cell, -0.01, False, {} # Move agent else: self.agent_cell = self.maze.neighbor(self.agent_cell, action) if self.agent_cell == self.maze.end_cell: # Check if agent has reached the end - self.history.append(self.agent_cell.coordinates, 1, True, {}) + self.history.append((self.agent_cell.coordinates, 1, True, {})) return self.agent_cell, 1, True, {} else: self.history.append((self.agent_cell.coordinates, 0, False, {})) @@ -89,14 +87,14 @@ def save(self, filename): with open(filename, 'wb') as f: pkl.dump(self, f) - def animate_history(self): + def animate_history(self, file_name='maze.gif'): def update(i): plt.clf() self.plot() plt.plot(self.history[i][0][1], self.history[i][0][0], 'yo') plt.title(f'Step {i}, Reward: {self.history[i][1]}') ani = FuncAnimation(plt.gcf(), update, frames=len(self.history), repeat=False) - ani.save('maze.gif', writer='ffmpeg', fps=10) + ani.save(file_name, writer='ffmpeg', fps=5) class Grid_Cell_Maze_Environment(Maze_Environment): def __init__(self, width, height): @@ -132,7 +130,7 @@ def state_to_grid_cell_spikes(self, cell): target_net = DQN(input_size, n_actions).to(device) target_net.load_state_dict(policy_net.state_dict()) optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) - memory = ReplayMemory(10000) + memory = ReplayMemory(1000) env = Grid_Cell_Maze_Environment(width=5, height=5) run_episode(env, policy_net, 'cpu', 100, eps=0.9) diff --git a/scripts/Chris/DQN/Eval.ipynb b/scripts/Chris/DQN/Eval.ipynb index 137b98f9..6cadec3c 100644 --- a/scripts/Chris/DQN/Eval.ipynb +++ b/scripts/Chris/DQN/Eval.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-09-09T18:29:20.945623Z", - "start_time": "2024-09-09T18:29:20.669402Z" + "end_time": "2024-09-11T20:14:33.251453Z", + "start_time": "2024-09-11T20:14:33.249449Z" } }, "source": [ @@ -19,50 +19,11 @@ "outputs": [], "execution_count": 2 }, - { - "metadata": {}, - "cell_type": "code", - "source": [ - "|# Plot input spikes\n", - "with open('Data/grid_cell_spk_trains.pkl', 'rb') as f:\n", - " spike_trains, labels = pkl.load(f)\n", - "with open('Data/grid_cell_spk_trains_sorted.pkl', 'rb') as f:\n", - " spike_trains_sorted = pkl.load(f)\n", - "positions = np.array([key for key in spike_trains_sorted.keys()])\n", - "rand_inds = np.random.choice(range(len(positions)), 5)\n", - "sim_time = spike_trains.shape[1]\n", - "for pos in positions[rand_inds]:\n", - " fig = plt.figure(figsize=(10, 5))\n", - " fig.suptitle(f\"Position: {pos}\")\n", - " gs = fig.add_gridspec(1, 6)\n", - " ax1 = fig.add_subplot(gs[0, 0])\n", - " avg_mem = np.mean(spike_trains_sorted[tuple(pos)], axis=0).reshape(sim_time, -1)\n", - " im = ax1.imshow(avg_mem.T)\n", - " fig.colorbar(im, ax=ax1)\n", - " # ax1.set_aspect('auto')\n", - " random_inds = np.random.choice(range(len(spike_trains_sorted[tuple(pos)])), 5)\n", - " random_samples = np.array(spike_trains_sorted[tuple(pos)])[random_inds]\n", - " vmin = np.min(random_samples)\n", - " vmax = np.max(random_samples)\n", - " for i in range(1, 5):\n", - " ax = fig.add_subplot(gs[0, i])\n", - " rand_sample = spike_trains_sorted[tuple(pos)][random_inds[i]].reshape(sim_time, -1)\n", - " im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax)\n", - " ax.set(xticklabels=[])\n", - " ax.set(yticklabels=[])\n", - " # ax.set_aspect('auto')\n", - " plt.tight_layout()\n", - " plt.show()" - ], - "id": "90ce759a18d4f156", - "outputs": [], - "execution_count": null - }, { "metadata": { "ExecuteTime": { - "end_time": "2024-09-09T01:45:50.253281Z", - "start_time": "2024-09-09T01:45:49.359509Z" + "end_time": "2024-09-11T20:16:15.910801Z", + "start_time": "2024-09-11T20:16:07.171382Z" } }, "cell_type": "code", @@ -74,8 +35,8 @@ " spike_trains_sorted = pkl.load(f)\n", "sim_time = spike_trains.shape[1]\n", "positions = np.array([key for key in spike_trains_sorted.keys()])\n", - "fig = plt.figure(figsize=(10, 10))\n", - "gs = fig.add_gridspec(nrows=5, ncols=5)\n", + "fig = plt.figure(figsize=(50, 50))\n", + "gs = fig.add_gridspec(nrows=15, ncols=15)\n", "for i, pos in enumerate(positions):\n", " ax = fig.add_subplot(gs[pos[0], pos[1]])\n", " avg_mem = np.mean(spike_trains_sorted[tuple(pos)], axis=0).reshape(sim_time, -1)\n", @@ -90,15 +51,15 @@ { "data": { "text/plain": [ - "
" + "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 4 + "execution_count": 7 }, { "metadata": {}, diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index c0efb667..3862dc8a 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -12,19 +12,19 @@ ## Constants ## WIDTH = 5 HEIGHT = 5 - SAMPLES_PER_POS = 5000 + SAMPLES_PER_POS = 10 NOISE = 0.1 # Noise in sampling WINDOW_FREQ = 10 WINDOW_SIZE = 10 NUM_CELLS = 20 - X_RANGE = (0, 5) - Y_RANGE = (0, 5) + X_RANGE = (0, WIDTH) + Y_RANGE = (0, HEIGHT) SIM_TIME = 50 MAX_SPIKE_FREQ = 0.8 GC_MULTIPLES = 1 EXC_SIZE = 250 INH_SIZE = 50 - STORE_SAMPLES = 100 + STORE_SAMPLES = 0 WINDOW_FREQ = 10 WINDOW_SIZE = 10 OUT_DIM = 2 @@ -66,28 +66,30 @@ # # Spike Train Generation ## # spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) # - # # ## Association (Store) ## + # ## Association (Store) ## # store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) # # # ## Association (Recall) ## # recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) # # # Preprocess Recalls ## - # recalled_mem_preprocessing(WINDOW_FREQ, WINDOW_SIZE, PLOT) + # recalled_mem_preprocessing(WIDTH, HEIGHT, PLOT) ## Train DQN ## LR = 0.01 EPS_START = 0.9 EPS_END = 0.05 - EPS_DECAY = 1000 + DECAY_INTENSITY = 3 # higher TAU = 0.005 GAMMA = 0.99 - MAX_STEPS_PER_EP = 10 - MAX_TOTAL_STEPS = 10 - MAX_EPS = 3000 - BATCH_SIZE = 128 + MAX_STEPS_PER_EP = 100 + MAX_TOTAL_STEPS = 15000 + MAX_EPS = 500 + BATCH_SIZE = 256 INPUT_SIZE = EXC_SIZE + INH_SIZE - train_DQN(INPUT_SIZE, LR, BATCH_SIZE, EPS_START, EPS_END, EPS_DECAY, TAU, GAMMA, MAX_STEPS_PER_EP, MAX_TOTAL_STEPS, MAX_EPS) + train_DQN(INPUT_SIZE, WIDTH, HEIGHT, LR, BATCH_SIZE, EPS_START, + EPS_END, DECAY_INTENSITY, TAU, GAMMA, MAX_STEPS_PER_EP, + MAX_TOTAL_STEPS, MAX_EPS, PLOT) ## Train ANN ## # classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) diff --git a/scripts/Chris/DQN/recall_reservoir.py b/scripts/Chris/DQN/recall_reservoir.py index 873c751e..367afb89 100644 --- a/scripts/Chris/DQN/recall_reservoir.py +++ b/scripts/Chris/DQN/recall_reservoir.py @@ -32,25 +32,25 @@ def recall_reservoir(exc_size, inh_size, sim_time, plot=False): pkl.dump(recalled_memories_sorted, f) # Plot recalls - if plot: - positions = np.array([key for key in recalled_memories_sorted.keys()]) - rand_inds = np.random.choice(range(len(positions)), 5) - for pos in positions[rand_inds]: - fig = plt.figure(figsize=(10, 3)) - gs = fig.add_gridspec(1, 6) - ax1 = fig.add_subplot(gs[0, 0]) - ax1.set_title(f"Position: {pos}") - avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) - ax1.imshow(avg_mem.T) - random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5) - random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds] - vmin = np.min(random_samples) - vmax = np.max(random_samples) - for i in range(1, 5): - ax = fig.add_subplot(gs[0, i]) - rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]] - im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax) - ax.set_title(f"S{i}") - ax.set(xticklabels=[]) - ax.set(yticklabels=[]) - plt.show() + # if plot: + # positions = np.array([key for key in recalled_memories_sorted.keys()]) + # rand_inds = np.random.choice(range(len(positions)), 5) + # for pos in positions[rand_inds]: + # fig = plt.figure(figsize=(10, 3)) + # gs = fig.add_gridspec(1, 6) + # ax1 = fig.add_subplot(gs[0, 0]) + # ax1.set_title(f"Position: {pos}") + # avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) + # ax1.imshow(avg_mem.T) + # random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5) + # random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds] + # vmin = np.min(random_samples) + # vmax = np.max(random_samples) + # for i in range(1, 5): + # ax = fig.add_subplot(gs[0, i]) + # rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]] + # im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax) + # ax.set_title(f"S{i}") + # ax.set(xticklabels=[]) + # ax.set(yticklabels=[]) + # plt.show() diff --git a/scripts/Chris/DQN/recalled_mem_preprocessing.py b/scripts/Chris/DQN/recalled_mem_preprocessing.py index b8c29d5f..acd2c9ff 100644 --- a/scripts/Chris/DQN/recalled_mem_preprocessing.py +++ b/scripts/Chris/DQN/recalled_mem_preprocessing.py @@ -3,7 +3,7 @@ import numpy as np -def recalled_mem_preprocessing(window_freq, window_size, plot): +def recalled_mem_preprocessing(width, height, plot): print('Preprocessing recalled memories...') ## Load recalled memory spike-trains ## @@ -46,21 +46,9 @@ def recalled_mem_preprocessing(window_freq, window_size, plot): pkl.dump(new_samples_sorted, f) if plot: - # positions = np.array([key for key in new_samples_sorted.keys()]) - # fig = plt.figure(figsize=(10, 10)) - # gs = fig.add_gridspec(nrows=5, ncols=5) - # for i, pos in enumerate(positions): - # ax = fig.add_subplot(gs[int(pos[0]), int(pos[1])]) - # avg_mem = np.mean(new_samples_sorted[tuple(pos)], axis=0) - # ax.set_title(f"Conf-Mat: {pos[0] * 5 + pos[1]}") - # im = ax.imshow(np.expand_dims(avg_mem, axis=0)) - # ax.set_aspect('auto') - # plt.tight_layout() - # plt.show() - positions = np.array([key for key in new_samples_sorted.keys()]) - fig = plt.figure(figsize=(10, 10)) - gs = fig.add_gridspec(nrows=5, ncols=5) + fig = plt.figure(figsize=(50, 50)) + gs = fig.add_gridspec(nrows=width, ncols=height) for i, pos in enumerate(positions): ax = fig.add_subplot(gs[int(pos[0]), int(pos[1])]) avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) diff --git a/scripts/Chris/DQN/train_DQN.py b/scripts/Chris/DQN/train_DQN.py index 73d208e8..7ccbd29e 100644 --- a/scripts/Chris/DQN/train_DQN.py +++ b/scripts/Chris/DQN/train_DQN.py @@ -135,26 +135,32 @@ def run_episode(env, policy_net, device, max_steps, eps=0): -def train_DQN(input_size, lr, batch_size, eps_start, eps_end, eps_decay, tau, gamma, max_steps_per_ep, max_total_steps, max_eps): +def train_DQN(input_size, env_width, env_height, lr, batch_size, eps_start, + eps_end, decay_intensity, tau, gamma, max_steps_per_ep, max_total_steps, max_eps, plot): device = 'cpu' n_actions = 4 policy_net = DQN(input_size, n_actions).to(device) target_net = DQN(input_size, n_actions).to(device) target_net.load_state_dict(policy_net.state_dict()) optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) - memory = ReplayMemory(10000) - env = Grid_Cell_Maze_Environment(width=5, height=5) + memory = ReplayMemory(1000) + env = Grid_Cell_Maze_Environment(width=env_width, height=env_height) + + ## Pre-training recording ## + if plot: + run_episode(env, policy_net, device, 100, eps=0.9) + env.animate_history("pre_training.gif") episode_durations = [] episodes = 0 total_steps = 0 print(env.maze) - while total_steps < max_total_steps and episodes < max_eps: + while total_steps < max_total_steps: # and episodes < max_eps: # Initialize the environment and get its state state, info = env.reset() state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0) for t in count(): - eps = eps_end + (eps_start - eps_end) * math.exp(-1. * total_steps / eps_decay) + eps = eps_end + (eps_start - eps_end) * math.exp(-decay_intensity * total_steps / (max_total_steps)) action = select_action(state, t, eps, policy_net, env) observation, reward, terminated, _ = env.step(action.item()) reward = torch.tensor([reward], device=device) @@ -188,5 +194,15 @@ def train_DQN(input_size, lr, batch_size, eps_start, eps_end, eps_decay, tau, ga print(f"Episode {episodes} lasted {t + 1} steps, eps = {round(eps, 2)} total steps = {total_steps}") episodes += 1 - plt.plot(episode_durations) - plt.show() + ## Post-training recording ## + if plot: + env.reset() + run_episode(env, policy_net, device, 100, eps=0) # eps = 0 -> no exploration + env.animate_history("post_training.gif") + plt.clf() + + plt.plot(episode_durations) + plt.title("Episode durations") + plt.ylabel("Duration") + plt.xlabel("Episode") + plt.show() From 4d45f3fc1799ca45ee79ad8f37e12b34449794b2 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Tue, 17 Sep 2024 13:12:38 -0400 Subject: [PATCH 22/27] Uncomment pipeline --- scripts/Chris/DQN/pipeline_executor.py | 40 +++++++++++++------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py index 3862dc8a..7f19d3c9 100644 --- a/scripts/Chris/DQN/pipeline_executor.py +++ b/scripts/Chris/DQN/pipeline_executor.py @@ -54,26 +54,26 @@ hyper_params = exc_hyper_params | inh_hyper_params ## Sample Generation ## - # x_offsets = np.random.uniform(-1, 1, NUM_CELLS) - # - # y_offsets = np.random.uniform(-1, 1, NUM_CELLS) - # offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets - # scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks - # vars = [.85] * NUM_CELLS # Variance of Grid Cell activity - # samples, labels, sorted_samples = sample_generator(scales, offsets, vars, X_RANGE, Y_RANGE, SAMPLES_PER_POS, - # noise=NOISE, padding=1, plot=PLOT) - # - # # Spike Train Generation ## - # spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) - # - # ## Association (Store) ## - # store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) - # - # # ## Association (Recall) ## - # recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) - # - # # Preprocess Recalls ## - # recalled_mem_preprocessing(WIDTH, HEIGHT, PLOT) + x_offsets = np.random.uniform(-1, 1, NUM_CELLS) + + y_offsets = np.random.uniform(-1, 1, NUM_CELLS) + offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets + scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks + vars = [.85] * NUM_CELLS # Variance of Grid Cell activity + samples, labels, sorted_samples = sample_generator(scales, offsets, vars, X_RANGE, Y_RANGE, SAMPLES_PER_POS, + noise=NOISE, padding=1, plot=PLOT) + + # Spike Train Generation ## + spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) + + ## Association (Store) ## + store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) + + # ## Association (Recall) ## + recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) + + # Preprocess Recalls ## + recalled_mem_preprocessing(WIDTH, HEIGHT, PLOT) ## Train DQN ## LR = 0.01 From 4f0673f74e8c9d2dc91e23aac56391869655db00 Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Sun, 22 Sep 2024 12:34:56 -0400 Subject: [PATCH 23/27] Removed unnecessary files --- scripts/Chris/DQN/ANN.py | 135 --------- scripts/Chris/DQN/Environment.py | 137 --------- scripts/Chris/DQN/Eval.ipynb | 269 ------------------ scripts/Chris/DQN/Grid_Cells.py | 133 --------- scripts/Chris/DQN/Memory.py | 118 -------- scripts/Chris/DQN/Reservoir.py | 110 ------- scripts/Chris/DQN/classify_recalls.py | 149 ---------- scripts/Chris/DQN/pipeline_executor.py | 95 ------- scripts/Chris/DQN/recall_memories.py | 38 --- scripts/Chris/DQN/recall_reservoir.py | 56 ---- .../Chris/DQN/recalled_mem_preprocessing.py | 59 ---- scripts/Chris/DQN/sample_generator.py | 65 ----- scripts/Chris/DQN/spike_train_generator.py | 48 ---- scripts/Chris/DQN/store_memories.py | 82 ------ scripts/Chris/DQN/store_reservoir.py | 73 ----- scripts/Chris/DQN/train_DQN.py | 208 -------------- 16 files changed, 1775 deletions(-) delete mode 100644 scripts/Chris/DQN/ANN.py delete mode 100644 scripts/Chris/DQN/Environment.py delete mode 100644 scripts/Chris/DQN/Eval.ipynb delete mode 100644 scripts/Chris/DQN/Grid_Cells.py delete mode 100644 scripts/Chris/DQN/Memory.py delete mode 100644 scripts/Chris/DQN/Reservoir.py delete mode 100644 scripts/Chris/DQN/classify_recalls.py delete mode 100644 scripts/Chris/DQN/pipeline_executor.py delete mode 100644 scripts/Chris/DQN/recall_memories.py delete mode 100644 scripts/Chris/DQN/recall_reservoir.py delete mode 100644 scripts/Chris/DQN/recalled_mem_preprocessing.py delete mode 100644 scripts/Chris/DQN/sample_generator.py delete mode 100644 scripts/Chris/DQN/spike_train_generator.py delete mode 100644 scripts/Chris/DQN/store_memories.py delete mode 100644 scripts/Chris/DQN/store_reservoir.py delete mode 100644 scripts/Chris/DQN/train_DQN.py diff --git a/scripts/Chris/DQN/ANN.py b/scripts/Chris/DQN/ANN.py deleted file mode 100644 index c280c772..00000000 --- a/scripts/Chris/DQN/ANN.py +++ /dev/null @@ -1,135 +0,0 @@ -import pickle as pkl -import random -from collections import namedtuple, deque - -from matplotlib import pyplot as plt -from sklearn.metrics import confusion_matrix -from torch.nn import Module, Linear, ReLU, Sequential -from torch.optim import Adam -import torch - -# https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html -Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward')) - -# https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html -class ReplayMemory(object): - - def __init__(self, capacity): - self.memory = deque([], maxlen=capacity) - - def push(self, *args): - """Save a transition""" - self.memory.append(Transition(*args)) - - def sample(self, batch_size): - return random.sample(self.memory, batch_size) - - def __len__(self): - return len(self.memory) - - -class ANN(Module): - def __init__(self, input_dim, output_dim): - super(ANN, self).__init__() - self.sequence = Sequential( - Linear(input_dim, 1000), - ReLU(), - Linear(1000, 100), - ReLU(), - Linear(100, output_dim) - ) - - def forward(self, x): - x = x.to(torch.float32) - return self.sequence(x) - -class Mem_Dataset(torch.utils.data.Dataset): - def __init__(self, samples, labels): - self.samples = samples - self.labels = labels - - def __len__(self): - return len(self.samples) - - def __getitem__(self, idx): - # Compress spike train into windows for dimension reduction - return self.samples[idx].sum(0).squeeze(), self.labels[idx] - - -if __name__ == '__main__': - ### ANN for input spike trains ### - # Load recalled memory samples ## - with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: - samples, labels = pkl.load(f) - - ## Initialize ANN ## - in_dim = samples[0].shape[1] - model = ANN(in_dim, 2) - optimizer = Adam(model.parameters()) - criterion = torch.nn.MSELoss() - dataset = Mem_Dataset(samples, labels) - train_size = int(0.8 * len(dataset)) - test_size = len(dataset) - train_size - train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) - train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True) - test_loader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=True) - - ## Training ## - loss_log = [] - accuracy_log = [] - for epoch in range(10): - total_loss = 0 - correct = 0 - for memory_batch, positions in train_loader: - # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) - optimizer.zero_grad() - outputs = model(memory_batch) - loss = criterion(outputs, positions.to(torch.float32)) - loss.backward() - optimizer.step() - total_loss += loss.item() - correct += torch.all(outputs.round() == positions.round(), - dim=1).sum().item() - accuracy_log.append(correct / len(train_set)) - loss_log.append(total_loss) - - plt.xlabel('Epoch') - plt.ylabel('Loss') - plt.title('Training Loss') - plt.plot(loss_log) - plt.show() - plt.xlabel('Epoch') - plt.ylabel('Accuracy') - plt.title('Training Accuracy') - plt.plot(accuracy_log) - plt.show() - - ## Testing ## - total = 0 - correct = 0 - confusion_matrix = torch.zeros(25, 25) - out_of_bounds = 0 - with torch.no_grad(): - for memories, labels in test_loader: - outputs = model(memories) - loss = criterion(outputs, labels) - total += len(labels) - correct += torch.all(outputs.round() == labels.round(), - dim=1).sum().item() # Check if prediction for both x and y are correct - for t, p in zip(labels, outputs): - label_ind = int(t[0].round() * 5 + t[1].round()) - pred_ind = int(p[0].round() * 5 + p[1].round()) - if label_ind < 0 or label_ind >= 25 or pred_ind < 0 or pred_ind >= 25: - out_of_bounds += 1 - else: - confusion_matrix[label_ind, pred_ind] += 1 - - plt.imshow(confusion_matrix) - plt.title('Confusion Matrix') - plt.xlabel('Predicted') - plt.ylabel('True Label') - plt.colorbar() - plt.show() - - print(f'Accuracy: {round(correct / total, 3)*100}%') - diff --git a/scripts/Chris/DQN/Environment.py b/scripts/Chris/DQN/Environment.py deleted file mode 100644 index 7b05e189..00000000 --- a/scripts/Chris/DQN/Environment.py +++ /dev/null @@ -1,137 +0,0 @@ -import random -import numpy as np -from labyrinth.generate import DepthFirstSearchGenerator -from labyrinth.grid import Cell, Direction -from labyrinth.maze import Maze -from labyrinth.solve import MazeSolver -from matplotlib.pyplot import plot as plt -from matplotlib.animation import FuncAnimation - -import pickle as pkl -import matplotlib.pyplot as plt -from torch import optim - -class Maze_Environment(): - def __init__(self, width, height): - - # Generate basic maze & solve - self.width = width - self.height = height - self.maze = Maze(width=width, height=height, generator=DepthFirstSearchGenerator()) - self.solver = MazeSolver() - self.path = self.solver.solve(self.maze) - self.maze.path = self.path # No idea why this is necessary - self.agent_cell = self.maze.start_cell - self.num_actions = 4 - self.history = [(self.agent_cell.coordinates, 0, False, {})] # (state, reward, done, info) - - def plot(self): - # Box around maze - plt.plot([-0.5, self.width-1+0.5], [-0.5, -0.5], color='black') - plt.plot([-0.5, self.width-1+0.5], [self.height-1+0.5, self.height-1+0.5], color='black') - plt.plot([-0.5, -0.5], [-0.5, self.height-1+0.5], color='black') - plt.plot([self.width-1+0.5, self.width-1+0.5], [-0.5, self.height-1+0.5], color='black') - - # Plot maze - for row in range(self.height): - for column in range(self.width): - # Path - cell = self.maze[column, row] # Tranpose maze coordinates (just how the maze is stored) - if cell == self.maze.start_cell: - plt.plot(row, column, 'go') - elif cell == self.maze.end_cell: - plt.plot(row, column,'bo') - elif cell in self.maze.path: - plt.plot(row, column, 'ro') - - # Walls - if Direction.S not in cell.open_walls: - plt.plot([row-0.5, row+0.5], [column+0.5, column+0.5], color='black') - if Direction.E not in cell.open_walls: - plt.plot([row+0.5, row+0.5], [column-0.5, column+0.5], color='black') - - def reset(self): - self.agent_cell = self.maze.start_cell - self.history = [(self.agent_cell.coordinates, 0, False, {})] - return self.agent_cell, {} - - # Takes action - # Returns next state, reward, done, info - def step(self, action): - # Transform action into Direction - if action == 0: - action = Direction.N - elif action == 1: - action = Direction.E - elif action == 2: - action = Direction.S - elif action == 3: - action = Direction.W - - # Check if action runs into wall - if action not in self.agent_cell.open_walls: - self.history.append((self.agent_cell.coordinates, -0.1, False, {})) - return self.agent_cell, -0.01, False, {} - - # Move agent - else: - self.agent_cell = self.maze.neighbor(self.agent_cell, action) - if self.agent_cell == self.maze.end_cell: # Check if agent has reached the end - self.history.append((self.agent_cell.coordinates, 1, True, {})) - return self.agent_cell, 1, True, {} - else: - self.history.append((self.agent_cell.coordinates, 0, False, {})) - return self.agent_cell, 0, False, {} - - def save(self, filename): - with open(filename, 'wb') as f: - pkl.dump(self, f) - - def animate_history(self, file_name='maze.gif'): - def update(i): - plt.clf() - self.plot() - plt.plot(self.history[i][0][1], self.history[i][0][0], 'yo') - plt.title(f'Step {i}, Reward: {self.history[i][1]}') - ani = FuncAnimation(plt.gcf(), update, frames=len(self.history), repeat=False) - ani.save(file_name, writer='ffmpeg', fps=5) - -class Grid_Cell_Maze_Environment(Maze_Environment): - def __init__(self, width, height): - super().__init__(width, height) - - # Load spike train samples - # {position: [spike_trains]} - with open('Data/preprocessed_recalls_sorted.pkl', 'rb') as f: - self.samples = pkl.load(f) - - def reset(self): - cell, info = super().reset() - return self.state_to_grid_cell_spikes(cell), info - - def step(self, action): - obs, reward, done, info = super().step(action) - obs = self.state_to_grid_cell_spikes(obs) - return obs, reward, done, info - - def state_to_grid_cell_spikes(self, cell): - return random.choice(self.samples[cell.coordinates]) - - -if __name__ == '__main__': - from train_DQN import DQN, ReplayMemory - from scripts.Chris.DQN.train_DQN import run_episode - - device = 'cpu' - n_actions = 4 - input_size = 300 - lr = 0.01 - policy_net = DQN(input_size, n_actions).to(device) - target_net = DQN(input_size, n_actions).to(device) - target_net.load_state_dict(policy_net.state_dict()) - optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) - memory = ReplayMemory(1000) - env = Grid_Cell_Maze_Environment(width=5, height=5) - - run_episode(env, policy_net, 'cpu', 100, eps=0.9) - env.animate_history() diff --git a/scripts/Chris/DQN/Eval.ipynb b/scripts/Chris/DQN/Eval.ipynb deleted file mode 100644 index 6cadec3c..00000000 --- a/scripts/Chris/DQN/Eval.ipynb +++ /dev/null @@ -1,269 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "id": "initial_id", - "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2024-09-11T20:14:33.251453Z", - "start_time": "2024-09-11T20:14:33.249449Z" - } - }, - "source": [ - "import pickle as pkl\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np # Plot input spikes\n", - "from matplotlib.gridspec import GridSpec " - ], - "outputs": [], - "execution_count": 2 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-11T20:16:15.910801Z", - "start_time": "2024-09-11T20:16:07.171382Z" - } - }, - "cell_type": "code", - "source": [ - "# Plot input spikes\n", - "with open('Data/grid_cell_spk_trains.pkl', 'rb') as f:\n", - " spike_trains, labels = pkl.load(f)\n", - "with open('Data/grid_cell_spk_trains_sorted.pkl', 'rb') as f:\n", - " spike_trains_sorted = pkl.load(f)\n", - "sim_time = spike_trains.shape[1]\n", - "positions = np.array([key for key in spike_trains_sorted.keys()])\n", - "fig = plt.figure(figsize=(50, 50))\n", - "gs = fig.add_gridspec(nrows=15, ncols=15)\n", - "for i, pos in enumerate(positions):\n", - " ax = fig.add_subplot(gs[pos[0], pos[1]])\n", - " avg_mem = np.mean(spike_trains_sorted[tuple(pos)], axis=0).reshape(sim_time, -1)\n", - " ax.set_title(f\"Conf-Mat: {pos[0]*5 + pos[1]}\")\n", - " im = ax.imshow(np.expand_dims(avg_mem.sum(0), axis=0))\n", - " ax.set_aspect('auto')\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "id": "5d8ba0301681f835", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 7 - }, - { - "metadata": {}, - "cell_type": "code", - "source": [ - "# Average of grid cell intensities per position\n", - "# With raw samples on side for comparison\n", - "with open('Data/grid_cell_intensities_sorted.pkl', 'rb') as f:\n", - " grid_cell_intensities, true_labels = pkl.load(f)\n", - "positions = [key for key in grid_cell_intensities.keys()]\n", - "for pos in positions[0:5]:\n", - " fig = plt.figure()\n", - " gs = fig.add_gridspec(1, 6)\n", - " ax1 = fig.add_subplot(gs[0, 0])\n", - " avg_intensities = np.mean(grid_cell_intensities[pos], axis=0)\n", - " ax1.imshow(np.expand_dims(avg_intensities, axis=1))\n", - " ax1.set(xticklabels=[])\n", - " ax1.set_title(\"Avg.\")\n", - " for j in range(len(avg_intensities)):\n", - " ax1.text(0, j, f'{avg_intensities[j]:.2f}', color='red')\n", - " random_inds = np.random.choice(range(len(grid_cell_intensities[pos])), 5)\n", - " random_samples = np.array(grid_cell_intensities[pos])[random_inds]\n", - " vmin = np.min(random_samples)\n", - " vmax = np.max(random_samples)\n", - " for i in range(1, 5):\n", - " ax = fig.add_subplot(gs[0, i])\n", - " ax.set_title(f\"S{i}\")\n", - " rand_sample = grid_cell_intensities[pos][random_inds[i]]\n", - " im = ax.imshow(np.expand_dims(rand_sample, axis=1), vmin=vmin, vmax=vmax)\n", - " ax.set(xticklabels=[])\n", - " ax.set(yticklabels=[])\n", - " for j in range(len(rand_sample)):\n", - " ax.text(0, j, f'{rand_sample[j]:.2f}', color='red')\n", - " fig.subplots_adjust(right=0.8)\n", - " cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])\n", - " fig.colorbar(im, cax=cbar_ax)\n", - " # plt.tight_layout()\n", - " plt.show()" - ], - "id": "2cdae84a47c79f73", - "outputs": [], - "execution_count": null - }, - { - "metadata": {}, - "cell_type": "code", - "source": [ - "# Plot memory module weights\n", - "with open('Data/memory_module.pkl', 'rb') as f:\n", - " memory_module = pkl.load(f)\n", - "plt.imshow(memory_module.connections['key', 'value'].feature_index['assoc_weight_feature'].value.numpy())\n", - "plt.colorbar()" - ], - "id": "9203f5bc892b669e", - "outputs": [], - "execution_count": null - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-09T18:29:28.479029Z", - "start_time": "2024-09-09T18:29:24.512935Z" - } - }, - "cell_type": "code", - "source": [ - "# Plot recalls\n", - "with open('Data/recalled_memories.pkl', 'rb') as f:\n", - " recalled_memories, r_labels = pkl.load(f)\n", - "with open('Data/recalled_memories_sorted.pkl', 'rb') as f:\n", - " recalled_memories_sorted = pkl.load(f)\n", - "positions = np.array([key for key in recalled_memories_sorted.keys()])\n", - "rand_inds = np.random.choice(range(len(positions)), 5)\n", - "for pos in positions[rand_inds]:\n", - " fig = plt.figure(figsize=(10, 3))\n", - " gs = fig.add_gridspec(1, 6)\n", - " ax1 = fig.add_subplot(gs[0, 0])\n", - " avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0)\n", - " ax1.imshow(avg_mem.T)\n", - " random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5)\n", - " random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds]\n", - " vmin = np.min(random_samples)\n", - " vmax = np.max(random_samples)\n", - " for i in range(1, 5):\n", - " ax = fig.add_subplot(gs[0, i])\n", - " rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]]\n", - " im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax)\n", - " ax.set(xticklabels=[])\n", - " ax.set(yticklabels=[])" - ], - "id": "f30e1a968c75d36", - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/christopher-earl/School/bindsnet/venv/lib/python3.11/site-packages/torch/storage.py:414: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " return torch.load(io.BytesIO(b))\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnIAAAEXCAYAAAAp/6nhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACVY0lEQVR4nOydd5gcR5m436runp6ZzUHaVVhlrZKDZFmRZLAPY8IZ8AEGjrP5AT7ANnc2R47GgDkwRzQGDrDhwOTgsw982OZsA5IDcrayrCyt8sZJ3V31+6Nn887uzOaR6n2efWamuqq6tvub6m+qviC01hqDwWAwGAwGQ9EhJ3oABoPBYDAYDIbhYRQ5g8FgMBgMhiLFKHIGg8FgMBgMRYpR5AwGg8FgMBiKFKPIGQwGg8FgMBQpRpEzGAwGg8FgKFKMImcwGAwGg8FQpBhFzmAwGAwGg6FIMYqcwWAwGAwGQ5FiFDmDwWAwGAyGImVCFblbbrmFOXPmEI1GWbNmDY8++uhEDsdgMBgMBoOhqJgwRe7nP/85119/PZ/61Kd4/PHHOffcc7n44os5evToRA3JYDAYDAaDoagQWms9ESdes2YNq1at4pvf/CYASikaGhq49tpr+fCHPzxoW6UUhw4doqysDCHEeAw3b7TWtLW1MX36dKQ0O9fjxWSVCSMPE4eRCUNfjEwY+nI6yIQ9TmPqRSaTYdOmTXzkIx/pKpNSctFFF7Fx48Z+9dPpNOl0uuvzwYMHWbp06biMdbjs37+fmTNnTvQwTluKTSaMPIw9RiYMfTEyYejL6SgTE6LIHT9+nCAIqKur61VeV1fH1q1b+9W/6aabuOGGG/qVv+is64j4ErRGR2zQGuErtGMhfAV+gEinwbIgCNAlcUQqjZYSpEQ7NkKpsDOtCUpdrI4MCIEWItx4ViC0Bs8HK6sVCwGBQnhe2JcQ6JIoIuPjSZ+HNn+NsrKy0b5shh7kkokX8kpsnJztjl21hvrf7CI4fnxE52+6dg3Tb38O1dY+aD0fj7/weyMP40BeMrFqGcmpUWL/s2lMxmBNnULTpfOY8p+P5KxjZGL8GO48MVLk0kZallRQ9uvH8qpvZGL8GIlMyLJSDl25jPpv5P5+54t64Tn4UZvIfY8PeLwQmZiQrdVDhw4xY8YMNmzYwLp167rKP/jBD/Lggw/yyCO9L1JfDbq1tZWGhgYu4FJsMXZfxuHga48HuJOWlhbKy8snejinLcUiE0Yexg8jE4a+GJkw9OV0lIkJWZGrra3FsiyOHDnSq/zIkSPU19f3q++6Lq7r9iuX5yxGagdVGgGlEUF2NS7QoBRBaQQr4YeVtUYmPYKSCEKFuqtfFsFuy4QreV5AprYE51QKLIG2JTLlg6/Q0fAyqYiFlgIRaKQXIJMeKmKjXQvlWIhAYZ1ohv6LioZRJpdMjCpCcPi3i5n22i1jex7DqDCUTNj1dWz+zCwar8pvlWQwWv5xLcoSVP2wvymIYfIwLvPEIOy4fSWL37+b4MTJCRuDoTcTIROyrIwd35nP/Lc8OSb9T4giF4lEWLlyJffffz+vfe1rgdDg8P777+eaa67Jux/19FZUDw1a93mVPd4DBH2OW33a2H3qqz7nE9m/zvpBj2Odpoi+9vIev2GSo7VR4k4j/KYjNF51ZOiKeVDx44dHpR/D6c3CKzf1ek4YzkxUW9uYKXEwQYocwPXXX88VV1zB+eefz+rVq/nqV79KR0cHb3/72/PuI3jRuUjhhitqQbgi55dFkL7Ci9tIT+G0ZlCx8N8UvkY5kiAa2tBpWxI5mUJbEm0JgqiFnfBRroUWAqctg3IkQmmCWPel8uMWwtdIPzyv05zCr3DxYzZBKgH/d+eoXy/D2HPog+uZ9dN9+PsP5FXfnjGdPf80h5k3bRjjkRnGixPvWkft463oTc+NuK+d/7GWBf/2GCjzKC9GdnxtLQv/ZWQK+54b1zH/y5sJmltGaVSGsWbH19ew8H0jt4GzZzew700NTP/i2D8fJkyRe9Ob3sSxY8f45Cc/SVNTE8uXL+eee+7p5wAxGCeXRHF9FzulSdZKIm0aZYG2QdkCp0MjVITAASsDyoEgAjIANGgL7CmlYZkPlqdJVboIpZEeuG0OyRqBlgIro7FS4JWAtgVWSuN0aNIVAivtorNXUp6aPHvsZyL7PraaeZ9/Iq+6+z+2nhl/SSIfDOvP+uk+gqb84xgGR48z5w6LHV9Yx/w7TqGeNnvqxU7d3bvRHQn2/3Yp01+3eUR9Lbr1KP66s9l/YZxZnzHK/mQleelqWmfZ1H2j9z1afMuxnKtpTb9bQn0eq/ULfnAIv7XbIUrG4+z6wQLmXv70SIZsGEMWf/N4133f8/NzmHfFdlQqVVAfO3+8gkXXHQgXBoYxho7L1tBWkYHv57coNGFx5EZCa2srFRUVk844EYzR6kQxWWXCyMPEYWTC0BcjE4a+nA4yYSIPGgwGg8FgMBQpE7a1Ohoc/pc1iNIoTjsELsgMBFFQEbA7wE5ovPLQPcFKhduqiO7tVRGAlQbhh+2CKDjt4fYphHUjLWG5lqBscE9pVETglYZ9Cp3tzwu3bmlJwa3GRm4ysfO/VrDwnZvRPVzOe2ItbWTnP9Yw96P9PRD3/Pwc5rxp4G0Qe84stl07nfnvN4bvxcrJt6/DbVWU/Hpom5jD71/P1MdTWP83cNynnuz9zDrm/uIU6lmz3T5Z2fGNNSz5wn78g4cGPG7VVLPl8/Np/Of8vJxb37wWbQ3uCLP7p+cy963PGrvJScjJK1dT1uwQuzN3zvdCZGKwZ8e+X57NrDc8M+yx9qWot1Zfal82qZZCIVwO/T//12aJfJwZbHlcuG5OJS6sIBC2g/Yy/Q8N0VY4kQHbdWK2TCaOvLZMpBW+5vFgFbaNDgLIY8oUTgTtewPWNTIxcfSUCSdSMuh3F4b+fvciD1nKNZ8YmZg4umRCvj6cJ4aYC/KVicGeHUM+kyiCOHKjhbAthLChTx4y7fkgs4FClEY4NqjewUS01gjLCsulDF87M0Bkj+kg6M691nkOpdBBti8pwuOd7QF880trspHrC5N69WpKth0n2PF8zi/mUF+2vCd5w6RAnruETG0c+/5sZocCVka0n7/ZspGLyU8+96ig+5iHLA01nxgmEBWAGNraLF+ZGOxej7YcFLUipwONFir81at0l/KmgwChu5Pfam+ACVgrdDYwcFf7rtfsMa3QnTc2UGH/Sof9SwEB4fFA9erXUBzEjiQR7YmJHoZhHJEtHUS07hcj0mAwGIqVolbkhBVuiQGhEiZEuJJm273KgHDVLAjCVTfovRLXWRfAFt3vhejdh9YQsZBChFssne17vAotoG3s/3fDyNGPPdPPNdxaMJdg5+682hdS1zBx2PV1cCSMrO/v2Zd3O6uqCrQyMcDOVKSFPWtGQTJTKGYOKQ6smmoIguHPBUJgz5mFv3vv6A4sS1ErcsybjaooA6WRaR8dsfFKHGQmQGYChBcQlETCukIg0z5BzAEJIqPQEYnwFNJT4IcKnYrayIyPCDQqaiPSAdoNlT/hBQSlEQJH4rR7aEsiMwF+iYNMByDA1xkwIaOKlq3X1rHwX/KbWLe+byoL32cm4cnO4UvnMO27hadIan/JQqSncf9n5Cm9DMWHVV7KznfMYM4nxk6RM3NIcdD60oU4bQGR//3bsNrLWIzt/zydeR82ilw/1ObtyKwRc+dWSXa9DZ39Ez3qa3rHW+mZbqtnme5R1vNYZ3vZp67Vo440KbqKmkIiuY9G9G/D2DPlO4/AMJyiYr/L7b1mOP0JmluY84mxzaVr5pDioORXI7tPKpFg3ofHTpaKWpGzKsuRykZEHHQqjYiGiXBVSyvCdXt5jAnXRWeyRopadzk29No2BURJCTqVQliyy7ZOWBa4LniZ0NFBKUQk0mWwKGwblU4jY1G0zkDz+Pz/homn7fK1ZEoFNd8zydOLhX2fWk/DHzsQG5+a6KEYJjnpS1ZxarFD/VfMNoth9Mg3M0i+FLUiR90UiMTREoTf7TUqp9aETgt26JWqLQvSGYQQqIo4siMNfoCORRBeNpyA56OjLmQ8hFMN6QyURCG7xSo70qENXqC67fEgfG9bCCnD1TsvaRS5SYQ4/yzk3iMEx47lVT99ySrcP+TeSrPr6wim1aKfCHNxlv2s/wpe8NLzsDc8ZzzUJhHqJSuwH9uGSiSYdcPQD2WrsgJ/yZyClb30K1fh/t5sxRYLQ90v9w+PUf+H3mX6Bcuxnt6FahvaGNp/2UqcPz9jvJiLlMzF5xO594n8whM5EbwXn93tEZ8D/2UrmfamZ3vt9o2UolbkMnWl4QqaACut0DJ87Ux0ryIS4YevTpuHloJkXQT3VASZUXjlNjKtkIFGpgO8Mgc7FRA4ErvDJ1MdQQTglUjcUy4IkL4CBdoKV/KE1ihbomwBQqCSFpgYoJOGjlkllJ8sgTwVuVOLnX4Td090eSmJWSXEBknn2jzfZcrfIkaRm0Q0z48y5SkH8nRSFiUltM2JUV7gQuvJxQ7Tfl/4+AwTw3DuV+vcKNU7Y5CHIte8MMLURwaOUWmY/JxqjFB/v8grGIWwJKcWRphy/+D1QpmwR/X5UPwBgWW4nap9D4TMxowLQ4SEB1RYnvVW1b7X5ekqHBuVSoNW3XHjIpHwfSbTFZ6ksy1adfcrZBiChGy4k2x7VRLhT20/MYEdx5nTIV+eYXQxMmHoi5EJQ19OB5ko6lyrIuIgY1GEYyNjMWTURdg2wpLIiBP+xWLIiBMG77Uk0nURjo1wwijtwrFD5S0SQcZiYYDfbHBgYVlddYUlw74jEaTrhn1aVldZZzmecXY43bHnzsaqrZnoYRgKRDgR5DmLJ3oYBgMQBqcWTmSih2EYJcSqsyfs3EW9tSprqyFWhkykup0WLAme3x0fzrbB88JsDV11LBACnUyGaVWkQEQioDXa8xBCoLWGdBqcCCKS1dKVQiuFsO3uDBBSov0gdLRQCuklITX+18IwfjSfX0/Z7g44fmKih2IoAFlawoG/q2bawOkPDYZx5cDfVdGwN0bQbLZdTwd2/30pcybIPLaoFbnDl8xEVUdx2sGPh4nrg+wPHOmFSe2VA1ZGk64SyAzYKdASpKdpb4D4YYGV1gRRQaYc3FOgImH75JTws53QdMyE2BERxpdzBEKDFhDEABWeRwbgZ1LwlQm9LAbAmjKFHf+2gHkf6m/kZFVVsf3jiwZNdn/0veuZ8lQC8dcn+x0r/eUjaGD798+n8R2DxxU6/C9r4Gt3Fjp8w1hg2ySn5mdJYjXOZ88b6mj43OCOEdv/cxWNV/0tr/yr+ciLYXw4/L41NHzj8QGPtb5lLZFWRfTu/MPPbP/e+TS+M/97e/Lt65j6RNoEm57kbP/WahZd91Re9myZabl34wabJ7Z/dxWN7368oHSBfSlqRW7aPQexrWj4ofMC9UyXJUW4+pbOgGOHq3Y9c6FaMizz/LC9Y/fuS2aPd2Zx6HkOrcP2EJ4jG6rEFx7bx+j/NeRPcPw4C7+k6LzbwnWxqqvwDzcRNDfTeNMOBvvaTPvxs1A/haAzu8cALPnovn59WLU16HSmy6Nt5g+3sG3E/41hVKgoZeGXtg963ztRz+9l7h0+urJi0Iftko/vJRhAPuxp9QQnT/V6ACz92P5+mUQME8PMH+UO/VB55zOI6XUo2847v+6Sj+WYC5IpVEdHv/q1v3oWPM+kiptk2DNnEDQd6brvS27YQ5CnU8LSTxyA2Q34e/f3O9ZznrBnN+DvP9SluC35xF6CEShxUOSK3KnzpxERLpG2AJRGuRI7EV6QICLRtsCLS2LHPQLXCrdOrXBVDSGwUgGZChuZ0TjtPl6ZjYoIRAAyoxAalC3QUiA9RRANvVMjLT5CgR+3kH64QueeDJfHPdIwNsGbDYWgNUGPrU85p4EDr5xK/Vea+h0biKC1lec/uowFNzYNOBEDBEeO9is7+YqFlB7IYD0Q/toPmluH/z8YRpWt101l4dX5RdHXvk/r8nqkVzfoysxAMgCw/83zmHn3EYLtu7rK/KYjhQ3YMGYEza05DdtVRwf731TP3NtS+AcP5dffAHJw/NWNVOxMIv/yZP9z5OHxahh/nn/nbObe6nXdz1zf74FQ7R3s/NhZzPtwf0WuZz87/nkmC77Y2vUDsZBz5KKoFbmyXz+W88vYmW3B7fO5L7Ee790cdXIx0MUzmR0mJ8G2ndRv21lQm3kf3ljwL+aKH+efGcIwviy8urDo7PHfDj+a+7T/2JDXyp9hctLw2Q0jXj2tut0ECS82Zn16+N9b1daWV/aGuR/dOOpzQ1F7rYaOCqHjQtf7wcp6luc6nquPXOcYqNwwuRECy7j4G/LEqqyY6CEYihQzz5y5jOe8UdQrcta8WVhuHJHKoG2r287NDxCJFLq8BABV4iIyoR2cSGd/Z2WzM4Qdye5MD74K7ei0RvgBqiyGlhLZlgj7lhJtyzAjhOcjPB/thh4WOuoggzQ8MxFXw5AvVnUVWz+9kIXXmjyHhqHZ9o15LHjbIBGgDYYcbP3cEhZ/cjvBqVMTPRTDODOe80ZRK3LB8/uQkezmaDYIcGdAYKSAI8fCGHCdDguWhYbQADkb5LczJIkOFMKSqECFbZUOAwW7bpi9IZMBkV3A1CoMa2JZKN8PQ5EojZACbTZUJj3BiZNGiTPkjVHiDMNl4bWPmCfCGcp4zhtFrcihgn5uwTrd+2uTMzVK1itF96rbv1our6WByrUCbWzkDAaDwWAwjBNFrcjJqIvAQbouOpMJQ4SoAczTO8OIaB0ez9bTWvcK7tuJyAYMBrpCTwg7zARBZ4ouKcMVwKyLemcaLxmkTEDg0wB7zix0S5vZEjkNsGdMw/IEQZ75dvPFapyPPnAYlcgzgauhqBC2jVi8APXs2CXPFk4EuXAO/nPPjdk5DJMLedZi9NadeYe2yYfiVuSm1mL5ElVXjTzVFipoftC9NdoZ503K0IZOKURnDDgAz0eXxBB+aO+Gn40nF4+hLQm2hUh7oBSqPI5I+4hECqRAuxFkMo2OR5HtCXQ8ClojE21wcOKuiWFwWt+ylqo/bBtSQTu5fjoVW9rAKHJFT9uK6ZS0SOQoK3JNF05l2u8zqL1GkTsdkfE4+15dzYxnx/AcFWUceEUtU4wed8aw7zXVzNobQ49iCJqiVuT8A02ABUeOoXR2Ja5TSROiK7G9DoIu+7Zen7XqrqN0d2TlztW4njZxPfsiXLXTqscqngzb+F5yTP9nw8iIHffz+iVUfsfDDBwG2FBsxO7ehByDZNhTbt1oAvyexgStrcz4wuCZPUZ8juMnmPYfIw91YigeZt60YdQDQRe1IofqVMgGMCfVGnRAp37XWafv5151erbtWadnvewWbV9loOuYYVLj/PFvJpq6wWAwGE4bilqRk0sbEaWlBHEbq8NDORYIkF64fdr1OROAECg7XGGTXoC2JVZLEq+mBOkrRDpAOxK/NIKd8NBSYCU8gpIIMhE6MGhHoiKh/ZxQGi1Dpc5uzxDEw1/82k/BIya35mTDmjKF9NmzsP+0aci69pxZeNOqEBufGrrfpY3oiI16cvNoDNMwDqiXrCCy88igUfvb3rSWsp8PHdy57fK1lP2ssCDQwYvPhYfMHDFZsBbOQ1WWoB8bOm6UPGcxItAEzxWeeM+/cCXu0/t62WrKsjKSL16MdffYrvwZhk8hz45e7aqqSK6eT+R/88vBK1adjTzVTrAzv+wzPSlqRU47FsqRKFsiXBvl9IhvrEFbAiyBglDpEgIk4eeIREZstCPDkHK2RjsWQUwiVHhZpKdQjkTasksJRAhURCJ9hbIkQmu0LdGORGQU2inuGMunK8K28ONWXgKvHZsgZudXN2KjokX9NTrj8GM2EXuQwN1CkCnNb3U933q9zh81QcMnFY5N4Fp5RcfXroMeyKEuD/y4RdTqfRYhBF6JlTPzkGHiKeTZ0QtL4pdYRPKsHkRtZGR4JiCj/gT69Kc/zQ033NCrbNGiRWzdGnr+pFIp3v/+9/Ozn/2MdDrNxRdfzLe+9S3q6uoKPpd+agtCOF3/RN8vg8jxvvOz6tFGZ8t6punS2eOdxzrbdX4VZY96XWUm/MikxD/cRPTuprzqBjuex96RX79mJa74iNzz2OA2SVpT8/380ivVfK/wNEzuHx8vuI1h7Ag2b887xVE+q3a5iN71aD+5C1pbKf3Fw8ZGbhJTyLOjJ8HxE8R/M3hO757IPz8x7JiDY7J8tGzZMg4fPtz195e//KXr2HXXXcddd93FL3/5Sx588EEOHTrE61//+rEYhsFgMBgMBsNpzZjsCdm2TX19fb/ylpYWvv/973PHHXfwspe9DIDbbruNJUuW8PDDD7N27doB+0un06R7BP5tbW0di2EbiggjE4a+GJkw9MXIhKEvp6NMjMmK3I4dO5g+fTrz5s3jrW99K/v27QNg06ZNeJ7HRRdd1FV38eLFzJo1i40bc29R3HTTTVRUVHT9NTQ0ZEefdTxwIuGrbfdPat9Jz+T2nXW7woyI7n6y/QrX7e6j83i2/56vwol09dX52TD25JSJfJHGKuV0Y8Qy0RcheP4L67DnzRmV8RnGn1GXiUIx88ykY8xkYgLvtdA9UxqMAn/4wx9ob29n0aJFHD58mBtuuIGDBw/y7LPPctddd/H2t7+9lzYMsHr1al760pfy7//+7wP2OZAG3dDQwIte9ElkNIbIOjb4MYn0NTKtsDyF8FTosQr4pRGULbA8hUwHKDv0QLXSAVpAELWw0qERq7YFMqPwSm3sRID0ApRjEbgSoSByMkkQd1CuhbIEVioIPZliNiqZ4KENN9LS0kJ5efloXlpDD3LJxAVcij1EzDD/ZSt5/q2Cxnfk5000ENayRahtu4aMSedrjwe408jDOJCvTNhzZ6OOn0QNEZDz1BXr0BKqb3+4OyRRFqtuKkII/KYjBY/TyMT4kY9MWDXViFgM/8DoRnK3G2ay8+Zq5r/3AMGJk4PWNTIxfuSSiYvmXgt7Dg+736bfLWH6JzXq6fwygVhTpoSOFIcHtr8rRCZGfWv1kksu6Xp/zjnnsGbNGmbPns0vfvELYrHYsPp0XRfXdfuVO80pqIwgAo22BNKT6GxoEBRoSxKUSKyEj93hoSIWWoBXHsFKBgilw0wPUmClFcJXqKiF1eGBFEhPI70AP+4gtMZKZZXCMhehNDKjsFOhc0NQGq7EadvEkhsPcslEPux/eYTGdxRupN6TvZfWMPubhwlOg2X504V8ZeLoS6cz5WEXNg+uyFX9MLeMpM6dhbIE7h8KV+QM40c+MuEvnkWi3qVklBW5Uy+YyZwvdwypxBnGl1wycfTF9UwdgSI3/a372HvduTQ8nV/99NmzQk/mYThS9GXM4yZUVlbS2NjIzp07+bu/+zsymQzNzc1UVlZ21Tly5MiANnVDobfvwdY2wpLoQKF9L8y7qjUo3VUuHBvt+ViWRGU8rGwWBiwLgiD0SBUyVN56tHMAtCJih5dJZ5U+Ibrba99Hez52xAHHwfdNZofJztwPj0yJA5j5+Q3D9jAyTCzVP9g44nvn/HH4q7mGyYX465OUjEG/hcYXNEws1T98FEaQAUZ1dNDw2d7xAJOvXY2yBCW/fqRffftPm0ZNARvzoGft7e3s2rWLadOmsXLlShzH4f777+86vm3bNvbt28e6desK7ltnMuggQGW8rtRZKuN1l6fTaN9DpdJd9dAKrXT45/noIOj+y37ubKeDAK00KuN1nUN7ftdnlUyhPR+0Co8nk6hUZtSuncFgmDis8nJkWdlED8NgMBQpJfdvoeyPYx+iatRX5P7t3/6N17zmNcyePZtDhw7xqU99CsuyePOb30xFRQXveMc7uP7666murqa8vJxrr72WdevW5fRYHQwRiSDdOCiFiETQ6TQi4qAzXtdqG5aFsGTXZx30COaoVFgHsvWscDXP80DK0Ikh4qCTqfCzECDDHK46k+la6escC1JgZRJgdtsMhqKn9e+WIH1N7M5HJ3ooBoOhCBnKDne0GPUVuQMHDvDmN7+ZRYsW8cY3vpGamhoefvhhpkyZAsBXvvIVXv3qV3PZZZfx4he/mPr6en7zm98M61zCziprWqMSiXCr0/NDpUyI8DUeC7dNO5W4bFRuYdvhtmrU7Vb6IFQKoy4IERqyZ7xQYcuEK206UNAZndsKvVS0H67K6R4rg4bTm/0fW49ljJJPS/Z9ej0yGqXk148YJc5gMEx6Rn1F7mc/+9mgx6PRKLfccgu33HLLiM8lp9QgRSRMYu/Y0NYRrowBWBIB6JJYqJwlUggpIeOhYy4ilUFUlKGTKWRpadjGtsI6no/wwlU9XV4CgcLyA7QlEREH0hlkeVnYb2nWuiJrWydkALtG/K8ZJjlzfns8/PFgKCpSr1lN6yybqbfkzm0551cnUX086w2GvvgXruToCpfpN5s8qQawKivY+rX5LLxi/DO3FHWSSH/P/hEZJ+ZFgY5MgUnRdUYQbN4+0UMwDIPoXY8SFYN7lqtn8wsfYDizse/fxPQ/mSgFhpCguYWFb39qQs5d1IqcPWMaVkk5IlBo1wlX0gIVrs5ZEh2x0bbEOtkOfoCORkJbt4wHSqGzCWpFxkNVlCCSmTBelBDdfQoBnh++KgWdSW09H5G1j0MIVEkMEQTQcqpg5c8wvhz88HpmfMH8ij5jGSR0Zsc/rKH8uZMEW/JMtmsoaqzycpreuowptw7Tk30QWUq9ZjXxfW2op7YMc3SGyYhcvpTEzFKidw9gdqFGblpl1VRz5LJFVH7nofzHNOKzTjRahwqXlKFjgm2hysN4dVpKtGMRVJaiS2MgJarURZXEQiXOtsI2URdtZdtFHHQsEip9QqAjNqo8hiqJhvXssE8di6BtCx1z0fEoSELFsWwsHNkNo8nUv5ltszOJg+9fk3fdsu0tcLw57/o7f7yidwYZQ1Gh0mlqnx44ZNSuO5aPqO+SXc3Io6dG1Idh8iGPnKTk+eYx6193JKh5tjCznaJekVOnmpEn27viuQnLQgdB6MEaBKHDg+8jhEBpHX7OOito6O3kkD3e+ftKA1prRKfjRLZezxh1XX12nl8ItDbhRyY7zn2bhqxjN8xEt7URNLeMw4gMY8ms/zmRd918o7J30vienajRTY5jGEd0Oo3465MDHpv3zZHdV2N+cXphNc5H7d4fZmLIkY1hNFCpFGJDYVu0Ra3IydpqpHbQ0Qgi6+igk0moqUKkM+GKWnMrIuqilUJIiU4mEdFoqHzFXERHMlzVCzq9Wa2u5XKtdejdalvgB92er74f9ukHYf1YFN2RQNg20k/B2N1jwzhx/IIGqja3wiajyBU7R9dVU7dt75j0PV7hBQzjz+5L48wzFhiGLPv/vo5ZP24fVlq+saaot1a1bYdKnB9AdUUY462yHJHx0E72WDa8iJASbBtRWgqOE/4Sa0+EW6mdGRssGW7RRl1wI6ES50ZCpS8eDcsiTtinzF46KUMlrvNzbHhpowxjT/sb15K+ZFVedSv/ayN603NjPCLDeFBzW2jLsv3bqyd4JIZiYuEXtrL7C4UHqjecnky/ecOoKXH2zBns/8T6UekLinxF7tiL65BuFD8mUC7EjmpSNQI7oQmigkwZlO+pJTlFIDPgtmgCF9DglQm8OJTt02gLvFKBHwdlgZbgngLLC3O2euUCK6mRPiDC45kyARKc1jDPaxANx6TbUvCdibwqhr4I2+bALxYx6/9tQQcKNUhdq7KCbd+cx4J/fGLQPnf88DwWv38vwfHBt+32fWI13HjnMEZtGG2W3nQYFY8jbLtXjtwdt6xhyZcO4+/ZV1B/u25eS+MPTua1hbb9++ez9GP7J+WveUN/dtyyhiVfPsLCb+zFH6qyEDT9djH1r83PqUG/YDn7L4oz6waz3DfZ2P6dVSy98RD+EHl3939sPTP+kkQ+mOM5MYRMBE1HmPPTCFu/tpZFP2gZsUOM0Lr4DDxaW1upqKjgwtp34DhRtOchotEwowMg3GwsuSDoWjnTGa/bo0RaXdujaB3atzlOmK0hEglX6VJpSKdByHAb1fMQTtZj1bLCVTg3dIhAZlfylMJLtnH/idtoaWmh3ASMHTc6ZeICLsUe65A0WWRZGek1jYPa3Pna4wHuNPIwAQwkE95FK2mfEaHqh4N7KVo11WTOmYP1f6MfE8rIxMQxEfNEPhiZmDjGQyaEbZO85Dyid3V7uqZevRqvVObMyVuITBT1ihyZNFrYodIFoLK2bb4fZl/IeBCLgu+Hx7TKptdKZTNCqLDcstAiCPtROrSHS6fDfrJpuXTGCzNEeBmws5kedHZtx7LCeoECik4vNgwTEXFI1ThMnseBYSic+zZRlUc94Tikqp0xSaZuMBjOMIQkMcUi2qMoevejvT6PhKJW5IK2dkSHh5AClUwhZBgGoEsBA2jv6Fa4oCtOHFpDUiA602xllUCy/Wilu1fwOjrCNm1t4WqeVr3jB0mrK42XkoNt3BlOB4QTekUHJ05S9vOBf00Zihu/6Qild54If7T5Q26uGQwGQ060l6H6B8OMVZgHRa3IydISpIigMxmsipJwRU1rEBJZko0l5/kIxwalw63TivLwfSoVptiyLHBsyOZeRchQUbMsVHML0s06L7guOpFAxKLhNqznge+jMx4iFg3bxuNolYLmibsmhrGn6d3nU70lnVcYE0Px0nz5+UgPo6wbDIZJTVErcqqtHZXd0w765EYMmnPEc0ulCjpH337p6OhfqUfOTZOi6/Sn7hvGSPlMoOLHRoEzGAyTn6IOP2IwDBsTjd/QFyMThonAyJ2hLwXKRFGvyFnzZmPZ0TB3qmWhbQvR1hHGgfODMHVXxEE7FrK5vcuzVDs2QmlIpsKUWrYFGQ/h+eioi2hth4iDqixFJLIrclojkumwvCyGbOkInSlsO9ya1RptSbT2YOfEXhfD4Fi1NWz54lwa/9/fJnoohkmCkQnDRGDPnMHmj85g3nv+OtFDMUwShiMTRa3IBc/vReTpLpzTBeHwII0GCQafqz+ztTr5CY6foPH/5Z+2yXD6Y2TCMBH4Bw7S+N6DQ8eqM5wxDEcmzpyt1XyWKoXorte3vrR6lwkRlnWWd76aZXKDwWAwGAzjRFGvyFnlZUgcRDwWbnMGATh2d2BgIcJtTyFCD1PPDwP+SgGe351LFdCZDLK8rOt9J50eqp19ypI4WuswWHBn/Ditw3PbNlplwPywP2OxysvDMDQFOtUYTi+smmpUS6sJXXKGYDXOZ9t7prDguvwcZMw8MXmxp9XjHx7bhOn23Nlsub6ehdc+MuBxGY8jZQB5pnIuakVOVFUgM4TKVHlpV0BgEdNgSXQqHSpuvh/mWY3SrXxFNSLihAogYTaIoL4G2ZFC+NGwvFMRbFOI+kpEoCCdCdtF3bB/IaAz44PWkDQT95nMscuWUb4vg32/CU1yJrPvXYuZdecxgi07JnoohnEg2L6LBdftyru+mScmL5s/O5PGd4ytIufv3svCa3PbbiVfsoyOMg9+nl9/Ra3I+XsPwGim1Gg6QpDr2LFjeXVhbOTObKpvG7ugj4biYcYXNuSeSwxnPGaemLw0vmPiHZ7cPzyGVYAuUdSKXGiXZuU83JWhYTzRahDPCsN4I5wI2vd6Z+IoABmPo3rECSzo3K4LKaPYT2aEbffO4jICZDRqtspOE4TrZtMwjuz5YWSi+Bn2PRQCEYmg+8aiHQOKWpFLvXw5EeESRAVBRCJ9jfQ0gSsIHIEfFThJjZXRaAl2ItSwvBKJndKkqixix3xkoNEC/BKLICIQCpyOAGULtBT4sbBMBBrliGx/gugJjyAiURFB4EqUBbojCXf+ZoKvjKGT/f92PjPvb4NHn+kqE04EvXIxPPz0kO13/WABcy8ful5f7BnT2XJTPQs/eRh2F9zcME6c/MdVuK2K+G8GtlUphK1fPYclH9tJcOLkKIzMMB4I14VzGtGPPdOrfOfnV7Do6wfx9+4fUf+DysTqsxFPbEN7OYLXGyYcYdss/EvAtvMLb2stmMuOd9Qx78P9V19lNIpeNh+96blRGGWRK3KlW45gayf81WRb4GXt04QAS4Y2c54X2rDZVhhbLpUGKRCOQ0nMRSRSYZotS4IbQSdSiNJ4GGMuUIioGzpQWFkH3+wvNJHKhGm6giCcDNwIBAF+aoDMD4YJY+ZN/bMwiKjL4bWl1OdhlzwcJQ7AP3iIBd+eQseCWqPITWKqbh+9La7Gdz9qtlOLDBmLcmhtGXWP9S6f//6HRyUkyGAycWRtGdO3x3JnITJMOFpp7v/1amZSeDafYMfzzPvw8wMeE2VlHFlVzpRRMpEsakVu1G3kOsnPHG5AfGMjN+lRbW3Uf3WM02wJgdjwFK6RhzOLTi92Q1EQNLfkTrk33HuZZ7u6rxs7ykmPCgZcDBgpwbFjTPn2CBSNPhS1Infw39YgSqIIDcIHLUH6gABlg9MGXjlkKhVoiB+WeCXgtIP0wnqZirBtulpjJwRWCrxyTfywAA3S03TMBOkLAlfjnhCkpmiix8PjygEZhOcGSIsUfP7OibwsBsCur2PzZ2bReNVj/Y5ZtTVs+dIcGt8+8M8h76KVHFvhMv1L/b/A6iUrOLQ+NuSX++jvFjH10q3DG7xhzEheupq2Bpup3xz8/lnLFrHjimrmfbCwFbum3y6m/rVbch7vuGwNbRUZ+L6ZIyaa7d9ezdLPHsQ/cHDA40Pdy1wc+s0Spr9+y4DKnIzHh22uYRhb9n1sNfM+/8SAx068cx1uq6b0F4Nv4wz27AA4fP16ajZ7RO7p/1zqN56Pr4bP5jdPCK2L7+dja2srFRUVXMCl2GOxIpcPnYF/+1w+X3s8wJ20tLRQXl4+AQM7M5kUMjEARh4mDiMThr4YmTD05XSQiaJekZtQik//NRgMBoPBcJpR1IqcNW82lhMLlSohEOkMujSOzr4Xnk9QW47cewRREgM/CJPex6MIz0e0tKErysLX0jiiM1SJUqHjhBsJM0CUxREdSXTURbSHoSh0SSws8310XTWypQNVVoLdchL2TeBFMQyJVVvD1pvnsPBKE4zzTGGobTSDYSQUmtnBcPoznjJRsCL30EMP8aUvfYlNmzZx+PBhfvvb3/La176267jWmk996lP853/+J83NzbzgBS/g1ltvZeHChV11Tp48ybXXXstdd92FlJLLLruMr33ta5SWlhY0luD5vYihlkL3EBqU5rIrbDpS0DkH5MjRrtBxxtlh8hMcP8HCK00etTOJxnc/ahKTG8aMQjM7GE5/xlMmZKENOjo6OPfcc7nlllsGPP7FL36Rr3/963z729/mkUceoaSkhIsvvphUj4B6b33rW3nuuee49957ufvuu3nooYe46qqrhv9fGAwGg8FgMJyBFLwid8kll3DJJZcMeExrzVe/+lU+/vGPc+mllwLwox/9iLq6On73u99x+eWXs2XLFu655x4ee+wxzj8/jLL3jW98g1e+8pXcfPPNTJ8+fQT/jsFgMBgMBsOZw6jayO3evZumpiYuuuiirrKKigrWrFnDxo0bufzyy9m4cSOVlZVdShzARRddhJSSRx55hNe97nX9+k2n06R7pLlobW0dzWEbihAjE4a+GJkw9MXIhKEvp6NMFLy1OhhNTU0A1NXV9Sqvq6vrOtbU1MTUqVN7Hbdtm+rq6q46fbnpppuoqKjo+mtoaBjNYRuKECMThr4YmTD0xciEoS+no0yMqiI3VnzkIx+hpaWl62///pHlvzMUP0YmDH0xMmHoi5EJQ19OR5kY1a3V+vp6AI4cOcK0adO6yo8cOcLy5cu76hw9erRXO9/3OXnyZFf7vriui+u6ozlUQ5FjZMLQFyMThr4YmTD05XSUiVFV5ObOnUt9fT33339/l+LW2trKI488wnve8x4A1q1bR3NzM5s2bWLlypUA/OlPf0IpxZo1awo6nywrRWobYVlorRFC0JmoQlgSlEal04hIBDwPpAxjxDnZkCXZhPc6nUbYdtiHbaMz2STGUnb3qVTYHsDzwrqWhYg46EAhhADLQiVaIDXAYA2nDeqFy3GOtBLsGDghsmFy4120ktjWJhNTzmAwnBYUrMi1t7ezc+fOrs+7d+/mySefpLq6mlmzZvGv//qvfPazn2XhwoXMnTuXT3ziE0yfPr0r1tySJUt4xStewbve9S6+/e1v43ke11xzDZdffvnoeqwq3aXUodQAxwcoA9BD1FVqwH611ohhDtVQXAiNyexRxAhz6wwGw2lEwYrc3/72N1760pd2fb7++usBuOKKK7j99tv54Ac/SEdHB1dddRXNzc288IUv5J577iEajXa1+clPfsI111zDhRde2BUQ+Otf/3rBg1dt7ag8cqPpHh4qAPSIaUciUfB5u/rt2xegTEDg0x7x1yfDINOGosS+f5MJDmwwGE4bClbkLrjggu4VqQEQQvCZz3yGz3zmMznrVFdXc8cddxR6aoPBYDAYDAZDD4rCa9VgMBgMBoPB0J9RdXYYb9S6s1FOjMCVCA0yo0BrrKRHpiaGlfBRroXMKKQXboYpO1s37aMiFjLp41eEHixeqY30FCLQOK0ZtGOhBSjXwm7L4JVH0JbATgQIpUFrtCMRGQVShHZ5Kg0P3zmRl8Uwiuz5+TnMedPTOY8L20b7ZqOuWEi/ahWts2ym3LpxyLq57u1QMmEocqQVvqrwmXHwQ+uZ9tcE8i9PTtyYDBPOzq+sZdG3jg7LyW3Pz89hzuXPDGlbLZwI2ssU3H9RK3JOcwrLFciYg/BDxwPZFtqsuekALAGtGhV1EEojExksP0DHIiAEdtJDW4LIkTb8yjix9gwEGhW1sTrCi6miNtJXaMfCafeQKR+R9tCOhQg0KmIj0x7KdZBtCfTQJnuGImLuP20j11fPnjOLre+bzoLrHx7XMRmGj/uHx5kqRc572om1tJGd/1jD3I/2V/gGkwlD8XPyytW4LYqSXz8CwMwvP4oOjFXsmc7CDz7Onp820vAPhbed+0/bBjVJ62TbN5az5FN7CI4cHbJuT4p6azWIO2gpkYkMwgsQKR8Vd9FRB+1aIAQi0OEKXCJDUBoeQ4hwNc2W2ZAkOlTQvAAkoeImBH5FFOErrNYUVksK4QWoqI12u/sQXoCO2Ait0XEX7KK+pKc16kUrEOefVVCbvo4y1sJ5pF+1CgB/zz6jxBUBwYvPRaxYFn5QQV4rqOJUK7VPDTzx9nOeyoOTb1+HLCsruJ1h7JHnLsG/cGXX5+ofbOxS4oBQXobhpZ65+HysZYtGZYyGiUW9aAWc20jDPzxbcNu2N63FqqrMq27jux8tWImDIl+Rs1qSSOEj/AAdcRCeD0KgpUAqjZYC4flIz0ekM1iBQng+WoaBQkTPOirclhUQKoAZDxEEiGQaAoWwLXTa6lLg0BrhBwgpw/6kzJaZIHKTFedEB2S8EXmcivYE0SNxsyJTRDjHk1gp1eWpevj69Ux/sAW96bmcbXQqTcnB0fsul+3PhLEsDZMO2dJBRGtyBKQaNu7RJKK1Y5R7NUwEI3l2lBxKo1NjqxcUtSIXPL8PIZww9puQXTHghGV11dFKI7KKW+d7rXo/hjvLhBThEnpnX0L2PqYGeHxr1XU+rTSBCT8yaQk2bx9xH/7hJjg8cE5gw+REbd6Onw1TZJWX0/C7QwT7Dw3aJjh1CvmXU6M2Bue+TaOuKBhGB3/PvjHpVz/xnAlzc5owkmeH/PMTYx6uqqgVOau6CkvY0LlVYlnojIcsL+vK4qDTaYTjQNRFJ5JhpoYgO6V2Kn7RKARBuN3q+12KnHAciDiQyWaFCIJwn7unsuf7iFgMpAy3XCwN5jlf9KgXrSBy4CT+7r0TPRTDKJI5bwEd0yOUP79noodimOTIaJS2V59Lya8eGbqy4fRECFresoaKn0xuE5qiVuRUSysKK1TgPB8ZcVAZD51KIywZKmydylo2BRdKd3mYAuFxqz3bYXhMiOwKHoQKWhB0twsCsKzu9gAdya6+Aml+d58OaEuE2+iG0wrrgccpn+hBGIoDKVGWmQPOdHQRyEBRK3LBqsUIO4q2BXZbhsC1EYEicMKtTivlIzvSpGaWd4UUUZ3OCFIgU935V5Vr45VHwrAjlkT4CpnyUXEHEYQhSYKoHdrViTDNj0x5CF+RnFmK0+4j0wFKpcH8gJswZFkptA9ujG7V1rDtq7NovGobKkdmD+uBx3tti1jl5QTtHaACDr9/PTXPeUTueSy/8bQV8A8YxoTt317N0s8eJDh2HGFZOe97T2Q2G43qY99iNc5n27un5OXoImwb4bqoDmMrVSzIaBStNSqRINIa0HTdeuq/sqGgPgq972aemKRoTeWPH0WWlaHaCrhBQuDf24B90fC37QuRiaJ2sfTKbLxym8TUCG1zS2hviJKsj+KX2LTNcklNidIxr5JMuUWy1sEri5Csj5Ka6tLeECU1NY5XFiE1NU5iWhSvRJKa4pKoj5CpjJCaHidZ55KYHqNtbgmp2ggdM8L2XplDpipK24JylCNI1kZIV7ukprgTfVnOaA68a9mQdYLjJ5hzm+To287Nu9/d15+FNX82ANO+vCEvJQ5g/1VDj8cw9jS++1H8AwdJv/Qcjr05v/ve8trltL26f91g+678vZVXLOHAe/KXM8PEc+oflpN4RXjP3D88VrASB6BWL+PQO/O/72aemLxYSxaw931nF9ZIa3Yfqh3ReQuRCaHzCW4yyWhtbaWiooILuBQ7j1yr44mvPR7gTlpaWigvN5s448VklQkjDxOHkQlDX4xMGPpyOshEUa/IGQwGg8FgMJzJGEXOYDAYDAaDoUgpamcHvfoshHYQKR+/MorQYLWnCeIRrEQG4Su0JQhKXBAgPYUWIBMeKu6gLYn0AmQig4o5ICWBG6besltTBGWhvZtMeuHxHsiUTxBzsDrSqHgkzCCR8RHag6dMrtWJRpaVceL1Z1H1w6FzagLo9eeGad4efWbQetbCeSQW1uD+Pj8bOcPkIW+ZEIKj713H1FsGt41qf+NaKh/ajd90JO8xiBXLUHEFfzFzxGTEnjmDljUze2V2KBThuhy74jxqv5vf3GMoHo5cu566b+RnM2lNmULzhfMp+1lue9qOy9ZQ8fB+/IODx7UciqJW5E4tjRPRUfwYyAwEUYi0RfHiAi3jWFnnRRUB4YOVrSMzIAONFoIgAk5CE0QE2oLkFIHTBtHmGGhIVwjcVk2mVIAAobLncsP+lB1HZa+i0wFpOwVPTdw1MYTI6kpK/vEQ/DC/+nZzEgJFAKgXLufEWTGmfLv/RCwSKaLHUl2ZHVKvWU2mVFL+08kdZ8gAeB6lh/MI2K01ZQdDn+V9n1rPvB8eGDBobPxIGp3OneBaRqNs/Y9zaHzvo91lbQnswnNiG8aI7d8/n8Z3/K3rs06liB0pPAXb9u+dT+M7s/0EQZf8FHp+w+TAe/n5tE93qLq99zOg7EDu0L69ZADAyxBvGvjLbjfMZNe7Gmj4Y3JUsj4UtbPDRXOvxQ6sMCBwNowIlgWWDIP4WhY4NiRT4EbAD8LYYLYVxofrSCAike7UOUKE9QLVHUw4Fgvf+z4iHgPPD2PJ2dlAxFqH720LUmm8IM39R79njFbHmX4Gq0Jg1VQTHD9RcF/CdZGuS9DaOmRdGY+DEDnDDBgj5oljNIyYrZpqglMtoIYXm92aMoXg2LFeZUYmJo6+MmHX1xW0opoLq27q8HJkZs9vZGLiGGiekNEoOE5BIUcKkgFpYVVVEJw4mbNKITJR1Cty/u59MIm8TACTomuyoPWwlDgIk6IHeSZGzycemaF4GWyizat9HyXOMLkYDSUOGJYSN5rnN4wuKpWCAlfKCpIBFYx4bumJcXYwGAwGg8FgKFKKW5ETAqTV/dr5vu9fz2ND1enbT9/++7YfqD/DaYcsKQnvtaF4EQJrFLatrMqKURiMYdIzSvJiMHQi43GEExn1fot6a9VqnIeMlSB8hYrayJQP6Uxo/xZxEEqBEARlLlZbGpFM408tx2oJDdvROrShCxRYMvQ+9UP7OJEObeF0aQzRkULH3VBJ8xUi1WPbzbHRjhV6yEqJ3dYMeybqihiGQr9gOdaTOwpOmbT7g+cy7ydHCLbvyqt+5hWr8s7+YBgfrNpatn1kfv5ZGXKw7RvzWPC2J0ZpVIbJSvsb1nD4RZqF15qci2ciYuUy5N6mYZvoDETTlcup3pom8shWguULEX99clT6Le4VOSkh0KiYg0xkQkeEiIMqi4IlUDGHoCQSKniAjrlhPaW7Vs90xEa7NmiN8AJEIlTStGODEIhEGhEoCLLHtc46VFjgRtCOhYo6KNcBCdoyqzaTmVOLYohYNK+6h69fHzozALM/tSFvJQ7g+NmTy3bTAHgZyp8f+ZRnlLgzg9bZclAlTp6zmMTr14zjiAzjSfvcUqgMV2S9l5+PfsHyEfc59VsbsP+0CTFrOsc/lBxxf50U9Yqc3ncQYccQUqAzXte2pgCQEtm5zSkFOlDhMSHQvt9d17LQWneFk9Be1tsV0EEQru4RJkEG0FqH3rHZtkIKLACl0UGA9kfv5hhGn+ofbCRf/8P6hzvQmeHFipj+pcLzMxrGFpVMMfVRk5nckB9DfYfF4ROUpf285xNDcVHyq0e67m1sxzHwfPILKjM0eu9Bpt4wl9EKGVLUipyIRkGH4UaE64bhQIQIFTHfD8OCACiNcLNKne8jOkOU+D5YVqikKQ1SgMqu1uhsKBOlw/dag7QQKhvCJBu1RThOqCRKgVAaoWwYeVgYwyhg1dYgYjH8/QcKa1dVhagow9/w1KBfNOG6yHmzCLbsGNlADeOCTqeHDPgMIM9dgnp6a9d3fLiIFcvQTzw3oj4ME4dYuQy9Kff9C44dgyG8kuVZi9Fbd4aLB4aixd+9d8g6Q8lLT1QiAYPUtaZMAUfDwfzGV9SKXHLFHBzLRVkCFRG4zR6BaxG4EuFrVESgpcBKKwJXYmUUMh1me1COxD2VIXAt/Hh2BS57NaxkuOKmLUHnk9zKZPtIK5Qd9qktgVdqIQLCZUANQToJfxz/a2Hoj984k2R9lHgfRe7o1esHjdqv5kyndVEZZQMEge2JVVXJgZdPod4ockWBLCvj5GvPovK/Bo+4v/fvq5i1NRIqfiNgz+vKmf2UNewYdIaJZffry5mzaWR97HtNNbP2xtA94pHZc2fTvqyO6N2PDtLSUGwUIi9WTTWnXt6YM5C8t3gmHWXBmaHIRTdswXFLemxr+thW6EUqIpEwiK8QaK3D1yCcUIWT3SbNeFhARIjQ3g4QlkSn0l2fw0LRHXA4+6p9H2HbRIKgaysWwNcmbPtkQWx4ivgA5SVNgz9Y9RPPUZaHGZTfdIT6r5k4UEVDEBA/NvTKSMONG0Zly2P2J02KpmJmzsdGfv9m3rQB1bcwlcY9ObIfCYbJRyHyojMesWO5Y87KPz9BrICYtEWtyKlEkiDZe2LumoAL9EocDgP9YlcmIPCkZyR5FA3Fi0okjCexYcLxDzchDjdN9DAME4hqa8O5b4TLvT0obq9Vg8FgMBgMhjOYghW5hx56iNe85jVMnz4dIQS/+93veh2/8sorEUL0+nvFK17Rq87Jkyd561vfSnl5OZWVlbzjHe+gvb19RP+IwWAwGAwGw5lGwYpcR0cH5557LrfcckvOOq94xSs4fPhw199Pf/rTXsff+ta38txzz3Hvvfdy991389BDD3HVVVcVPnqDwWAwGAyGM5iCbeQuueQSLrnkkkHruK5LfX39gMe2bNnCPffcw2OPPcb5558PwDe+8Q1e+cpXcvPNNzN9+vRCh2QwGAwGg8FwRjImzg4PPPAAU6dOpaqqipe97GV89rOfpaamBoCNGzdSWVnZpcQBXHTRRUgpeeSRR3jd617Xr790Ok26h2NBa2vrWAzbUEQYmTD0xciEoS9GJgx9OR1lYtSdHV7xilfwox/9iPvvv59///d/58EHH+SSSy4hyIb+aGpqYurUqb3a2LZNdXU1TU0De/LcdNNNVFRUdP01NDSEB/omq++btH6gJPadn/vWH+jzYK8DMdD5DGNCTpnIBznMNGrDbWcYF/KSiUK/oyO550ZeJpwhnx1jhbn3k5YRPTuGopD7PooyOOorcpdffnnX+7PPPptzzjmH+fPn88ADD3DhhRcOq8+PfOQjXH/99V2fW1tbaWhooPWN52M5UdwWhe68fgJkWiM0BNEwoK/MaITSSF+TqnFw2gL8eKjDSl9jJxVBRIYBhAU4HQqvRGInFckam9gJH+UIZEYTRMNytA4DBgtAgQw0flzi+Wm463fDvHqGfMklE/lw6NeLmP66zQWf88AvFzPzHzaPOOK/YWzIRyZSr15F6yx70IDQPdn1pVU03nqEYOfugsez7+dLmfWmzSYg8ASSSyaO/79VlJ+KEP/t6IcikmVlbL91AQv+0eTknYyM5NkxGFZlBVu/uoCFV+YXVqT9DWvIlAqqfzDyeIVjHkdu3rx51NbWsnPnTi688ELq6+s5evRorzq+73Py5MmcdnWu6+K6br/y8p8/hi0KS05e2tlnn/K+vURy1BsMB3BMHLlxIZdM5MNwlDiAmZeZdEuTmXxkInrXo0QL6HP++x8edi7NWW8YOh2YYWzJJRO133+04GdHvqi2NqPETWJG8uwYjKC5JW8lDqD0FwNndRgOY67IHThwgBMnTjBt2jQA1q1bR3NzM5s2bWLlypUA/OlPf0IpxZo1awrqu+PS87Gd7mnZaQ/QlkCo7tU4bQlEoJEZDQJENsx2pkziRyXxYz5a0LWCJ9Ph6l2q2kZoiLQESE+RqbTRAixPY6U0QVQgfLBS4Tk7z5OKePDfd47OxTOMPUKw/dZVNL57ZOlytt+6msarN5nVl0nKns+uY/43dhEcOTp05R7s//h65v7Xfvy9+4d1XrFiGU0vqqDu6/mtABrGF6u2hp3XNzL3o8NbFTn+z+uoeSaB2PDUsNpv/84qGv/ZBKkuFqyqKnZ8eDHzPlSYvMh4nO2fO4cF142e8tar/0IbtLe38+STT/Lkk08CsHv3bp588kn27dtHe3s7H/jAB3j44YfZs2cP999/P5deeikLFizg4osvBmDJkiW84hWv4F3vehePPvoof/3rX7nmmmu4/PLLC/ZY9UolyVpJ+3QL5Qg6pjkEUUmq2qJ9mkWq0iJTKmmZa9M+0yZZY5Mpt0jWhvW1hI46m1S1RdsMm/Z6i0SdTdtMh1SVJFUpaJ9pk6m0SVVI0uWSdLmFH5ekKsLXRL1DstamZY7DqUURRiW3j2H80Jq5vwrY9aV1I+pmyX8cZ+/Plo7SoAyjzYJvPk9w7ETe9a1li9j1pXXM+c+dBAcP59Vmxw/Pw6qt6V24eSfTf7K1kKEaxpHgZDMLv/48+z69Hr3+3ILb1/1iK/v+VWGVlw/r/KuWPT+sdobR59i71pB4/eCLSUFzM41fHdjM4uidi3O2U8kki2/uzt197L8XDW+QORBaF2bw88ADD/DSl760X/kVV1zBrbfeymtf+1qeeOIJmpubmT59Oi9/+cu58cYbqaur66p78uRJrrnmGu666y6klFx22WV8/etfp7S0tF+/A9Ha2kpFRQUXcCm2jPSvILL6qQpCY0KtezgryO7yzs9a9XsVloVWOizr2Wfn556XrUdfvkrzgP4dLS0tlA/zy20onF4yMUZbJsPB1x4PcKeRhwlgPGSi/Q1rKP1lYXZWRiYmDjNPGPpyOshEwVurF1xwAYPpfv/7v/87ZB/V1dXccccdhZ66P32Vsex7IUWohPWr33msz+egZxWBVrJXm+7yQXTebF9oaVblDIYzhFSVJL+fnwaDwTA2FHeuVSG7V8p6vu9EWmFZ5yuglUbYdm+Fr0cfncqaVjpUzHKdU1oI2+7fl6HokSUlI++jrGwURmKYNEgLMZDR/HdH7nFmmHzIeHxMw5MI1w2fHYbJj7SQ0UJcpPJAiFDGRomiliS9eilaumHIkUyAlgKkoH1GjNiR7oB/2pYIrRGeQjsS3bWSB8JTSF+hpcDqyBCURBC+QgSKVH0cp9VH+IpknYt7KvRI7exHWaECaCV9gqiFTAUoMrDhN+N+LQyjg1VezpYvLh6x88PO78xn3lueHJ1BGSac4MXncvycqHFaOEPYccO5LPr6fvz9B8ak/2NXnkf5Xp/IPcbRYbIjly5kz+urmfWZ0fvu27Nmsv29Mwt2msjZ36j0MkGIh59BZPe0e66FDbaekus3VjYcXNdxTe/QI7EB6vdc/+sMYydN+JGiJmhtHbESBxgl7jTDeuBx6h6Y6FEYxov5H9iIP4b9137HrOQWC+rZrcx6dnT79PfuZ96HhucJPxDFvbVqMBgMBoPBcAZT1CtyMupiuaXoIAi9SJVCRCJo3wfLAqW6KwcBOE74CohYFJ1MddXRgUI4NggReqwGAUjZ3Tbbn/Z9hGWFnyFsLyUEASLioHUGmsfxIhgKRp67BPXUlokehmGcMffdMJ7YM2egOxIEp05N9FAM44A8ZzHq6YkJNVTcilxlJZRVIP0AgmzarLI4MpXpDg8SZJU5zwM3AhkPIg5IiYhGQQh0KoUQEuFGwLZCZS6VhlgUPB9sC21JREeyu1/bDhW8aHYDVmu0bSEyCaPITXJ2vqWSecOL32koYna+1dx3w/hx8sUNlD+fgIeNIncmsPOtVcx7emLOXdSKnN90BI6cnOhh9MI3NnKTntEyMDUUF/M+aO67Yfwov2NsovgbJicT+VwxNnIGg8FgMBgMRYpR5AwGg8FgMBiKFKPIGQwGg8FgMBQpRW0jJ0viCE+EuVFtO/QetSx0MgmWhRAi9DK17W5PVkB7PjLrpKCDAO2FEYOEZYEU0JmhIftexqLoTKa7jyAIs0AEQdhGq/B8loXUGUhMyOUwjAVCIF0XlUpN9EgMo4CwbfZ8YjWz/9AOD4/MMlm4LjqT6Z132VD0CCcCOoxQMJbIaNTMK6cJMhpFpdMTNhcUtSKXWrcYVznY7R6BI0EIVEQiPIWV9NAKghIHKx2GHAlcC+2Ex0XSQ7k2VsJDR0Kv1MC1sFI+QdRG+AqZCRCBwndtlBtmbpApHxV3wkwO6QARaITuTusVkIHCcmgbxpnggvOwHng8r7rW/DnsfGc9cz+8EaSFXnc24q9Pjun4DGNH6uUrCFyNteMAwdDVB2X3J85j/n8dI9i2c9B61sJ5iPYE/uGmEZ7RMB6cfOtK3FZF/De5J/JC5pBcbLv5XBbf8DzBsWMj6scwOsizGuG53cNqu/fHC5j9aR/17OiFH5FnNUKegYiLWpGLHk1gWy4i42MlUmEoEdsKQ4j44TRtNbejHRvh+UgrVPZEewJi0TAbg9bIzhAjjo2Ou1gnO3pp1pYfhP1C2E/KxfbC1TmRzoTHhEAECvzkBFwJQyEcekGUhgfyqxvs3M3cD4dfbhlxOLg2zrS/jt3YDGOL+/vHqK1YCzVVcGJkHu9zPr4xL2WwY1EtsaYEGEWuKKi6fWjvw8Pro8x8YGTnWXjNIyP+MWEYPZqXVlD93PDaxu8pQx5/HjV01YLGc0Yocurprahsiq7Jggk/Mvlp+NzwcuapVIppXza5Noud8p8+PK4P0Ojdj2I2X08vZn7ezAOnG+W/eAyGqU/UfG/0U7qV/yL/PLxFrcgJJ4K03e4sC9msDTq7miaECN8rHdq7daI0wpLooIf+3OO4ECLM9NBZp9NuLltHCAEyayPX4xzCkkgtwZg9FA3WkoUEW3caOyfD8BACa/ECgi07JnokhnHCnjeH4OBhdDo90UMxFAtjPE8UtSJn1VQhY6XoWDa7gucjlO5S6BACAoXOZLqdIXT2eCwKyVSYkUFrRCQSHrNChwmSKYhF0W0diKgbZobodJaIuaERfDIdZokIAnQqjYhFEcKH5yfoghgKZtdbapn3uf3G6NgwLKTrsusttcz5hFHkzhT2v3Y6Db/w8A8cnOihGIqEsZ4nilqR85uOgJhcmR0Cs7VaVMz5xMZRtWswnFmoVIo5nzAZI84kpv3HhlHfRjOc3oz1PFHUceSEEwmdDGwbpIWMRsMyaXWVdx4Trhu+OpHwz87qsJ31XLf3n20jy8q6+hNuuOrXdTzbh4xGw36k1XVeg8Ewedn3qfXo9edO9DAMBoNhVCjqFTntZUA4XfF+VKq3CXPPOEA6G4JEqz5mzlqH9QaIGaTb2vq372MX0XWOzn6NrZXBMKmZdYMxVDcYDKcPRa3IIUS4WmZZaD/c0hSddmzZYL06ay/XVa50GEDYssL3YWFYx3a66neW9+yvU0nrCjDcY/VN2E44BqPHGQwGg8FgGCeKW5HTGlSA1qpLyepSxLTupXz1LO/63Gf1rFMZ7Fnet13OMt8zq3EGg8FgMBjGlaJW5MTKpcjAzmZ0sBCBQkUdZMpDWxKkQCYyqHgEEWi0AKFBC0AKhBeAlAgvQFsC4Sv8Mhcr5aMcC+krRMYHrQlKXKQXoBwLBFgJDxWxsDoy+OWhnZz0AlBp2HTnxF4YQy/0C5YjNjzVO8hz3VQoLyXY0d/F2JoyBaor+kXsVy9agfzzEwOeQ71wOfIvT47quA2jjz2tHl0SI9g5eAT3oe6n3TATpMDfuz93J9JCrz0rlD3DpEOcfxY8s2PAMCJi5TLEc7tyerML20atWobYOPC9tWprYEr1gOEmrKoqmDaFYPP2kf0DhlHFnjsLO637ZWCxysvRc6ajnh44a4M9ZxYECn//gV7lsqQEFs5GPbm5X5vBniUA9ozp4GjIM9FEUStyR88vw/Vd0JApFzjtmnS1INKq8aMCBMSOKdJVEhFkV+KkQFuhMmenNMoS2EmNckB6kJoisDsgcMFOauwECAWpaoH0w3ItIXpCE0TBbdEkpki0DVYSVDoJmyb4whh6ceiFcWY+6oQ2lVnU9CkkZpcQG0CR09NraVtQTkkfRe7gi2M0/EUMuPJ66MVxZv514GOGyYPfMIXU1BjRwRQ5ITj4kjgNf8ldJT1/KloK7EEUOWFZHHxRCTOMSd6k5MjacqbtLiEYQJE7urqc+n1lkEuRi0RoWl/CtFyOiHW1tCyronSguGFTazh1bjXl/Z/vhgmkY2EtJW2iXwYWUVPF8RVVVOVIzZyaPwURaKy+ilx5GUdWVVDzZP82B18So+HPucfizZ5CIq7yVuSE1sX35GltbaWiooILuBR7EmZ2eIA7aWlpoby8fKKHc8YwWWXCyMPEYWTC0BcjE4a+nA4yUdQrcsK2EcIGkc2y0DN7g5CgFVrp/uXQ5eCAZYUBfZUOHRt0n6hiA/UNXY4SffsWSmOCDBUx0sKaP3vALVeDwWDoi7VwXrhVX3xrIobThKJW5GR5GdJyEY6DTqXDrAyBAkuGZX6ATiTCzAwyVNKE64JSaJX1VI26Ydt0GlFSgk4ku/uxbYQbQXckutN09cz8IEWoGNp22Ldto7wUHJ/gC2MYNrIkzvNvq2P2J40iZzAYhmbXP9Ux7wtHUB0dEz0UwxlKUStywclTiHyWQvP9gjW3jGxAmMwOxY5qa2P2J02kfoPBkB8mO4xhoinqzA4Gg8FgMBgMZzIFKXI33XQTq1atoqysjKlTp/La176Wbdu29aqTSqW4+uqrqampobS0lMsuu4wjR470qrNv3z5e9apXEY/HmTp1Kh/4wAfwB8isYDAYDAaDwWDITUGK3IMPPsjVV1/Nww8/zL333ovnebz85S+no8fW5XXXXcddd93FL3/5Sx588EEOHTrE61//+q7jQRDwqle9ikwmw4YNG/jhD3/I7bffzic/+cnR+68MBoPBYDAYzgAKspG75557en2+/fbbmTp1Kps2beLFL34xLS0tfP/73+eOO+7gZS97GQC33XYbS5Ys4eGHH2bt2rX88Y9/ZPPmzdx3333U1dWxfPlybrzxRj70oQ/x6U9/mkgkkv+ApAWIbk/Uoej0SM16tPZ63/O1s+5g/fb1bu1EWBiDiSJAWggpeuXjHTFChKnaesSrMxQ3womYrC1nIMJ1BwwUPFJkNJozyLBhEjHM58NoyY1wXUjlb28/ImeHlpbQOaC6uhqATZs24XkeF110UVedxYsXM2vWLDZu3MjatWvZuHEjZ599NnV1dV11Lr74Yt7znvfw3HPPsWLFin7nSafTpHtcnNbWVgASr1qBG0RIV1lEWhVCa5LVNlqCk9RYGYUIwgC+gStxT3poWxK4AiulQAi0ACuj8EotZEbjl0iEgkiLT7LWIVMmcDo0dkqjrTA4sO8KYid8tABtCexEgIpIlC3wVBr+8JuRXFZDHuSSiXwQts3hq1cjFNR9YxSjta45m/0vLWXmTSYC7EQwEpnoi15/LmLDU+z63Eoav30Y//k9ozBCw3gzXJnY8YUVTPurpuRXj4zqeHbdtoi5b30WVHdOb3tafRjFf++onsqQg3xkIn3JebTOsplya7fjm1y+FLY+n1MRtyor2HLzQhrf+bcRjc+eMZ0tH5zF3PcNEjG4b5vhnkwpxb/+67/yghe8gLPOOguApqYmIpEIlZWVverW1dXR1NTUVaenEtd5vPPYQNx0003ccMMN/crLHz+ILV3iMRea2xARh3jGQ5TEwAuT2ut0JgwxEnMRfgAZD+1lNV2lwxAiQFQIiMcg44XtMhmikQjYVlg344XvpQx/nQeqOySJFOFnIfBssxw3HuSSiXwQsRjahvovj7LC9fDTzHx4dLs05M9IZKIXQnDgwhIaNsC8D240YSGLmOHKxILrHmbfp9ZT8qvRHc/cN/dP6eXNqydREhhFbpzIRybc/3mMKX3Kml5QybSDubN9BM0tI1biAPyDh1j4L4cKmneGrchdffXVPPvss/zlL4PksRklPvKRj3D99dd3fW5tbaWhoQH/4GEYKPzIsTEfUk5M+JHxIZdM5INqa2PaaCtxhglnJDLRC61puNHIx+nASGRi1g3jIwPir0/imufGuDFcmZh6ywaCIWtNDMNS5K655hruvvtuHnroIWbOnNlVXl9fTyaTobm5udeq3JEjR6ivr++q8+ijj/bqr9OrtbNOX1zXxXXdfuWJ15wP5THspMZt9ggiksRUByujEUoTuAItBJGO7CqZBq9EYKc00RMe6Uon3GbNaKyUom2mTbRZ4zb7dNQ5RJsD/JjEiwmizQGZUonlAVqHeRbTisAJc7D6UUHgCkRLEn5z53Auq6EAcslELuTypex6UwVzP1JYjDircT7b3j2FBdcPvtQm43F2/WABcy/PkZDPMObkIxPJS1fTOsvOa0v91JXrkJ6m4ieFL7Pu/sI65t9xKmeibcP4MNoykYt85wnDxFPIs2PPz89h3hXb87Zr9C5aybEVLtO/NLgsHb1zMVMvHb25oSBFTmvNtddey29/+1seeOAB5s6d2+v4ypUrcRyH+++/n8suuwyAbdu2sW/fPtatWwfAunXr+NznPsfRo0eZOnUqAPfeey/l5eUsXbq0oMHH7/pbr9xoFlCAqwTxPp973trKAerH8ujTN7+sJiXqyc3MfbLwdsH2XSy4ftfQ/ScSRokrAmJ3PprX9xig6vbhB4ae+2ETJLZYKEQmcpHvPGEoLua86emCvsfOfZuYft/Q9UZTiYMCFbmrr76aO+64gzvvvJOysrIum7aKigpisRgVFRW84x3v4Prrr6e6upry8nKuvfZa1q1bx9q1awF4+ctfztKlS3nb297GF7/4RZqamvj4xz/O1VdfXdAKSy+E6PYq63wveuRA7fzc8zVXe5m1idOqfz89vV17tZehh4vSoHwwDm4Gg8FgMBjGgYIUuVtvvRWACy64oFf5bbfdxpVXXgnAV77yFaSUXHbZZaTTaS6++GK+9a1vddW1LIu7776b97znPaxbt46SkhKuuOIKPvOZzxQ8+MxFK9BWNNz+LJG4zQGRFo+OGVGE0tgJReBKrEz31qqVUvhxC22B9DRoEEojfU2m3AYR1rHSoSdrEBEIDXZCdbUVWoMK22lbINOKIBbWlac64P7fFfy/GMaWEW2tvmcKC64Lt0yEE0FEXVRb21gM0zCG2PV1bP7MLBqveixnHVlWhk6lRxRCpu3ytWRKBTXfM6neJjNWVRUiHmPzp2YMKhN59VVbQ3D8RL/yHbevZPH7dxOcODmi/g3jg1VVRdDc3GuxZ6KeHfs+vho+m5+ZltC6+AIktba2UlFRwYUL/hWrtAwVcxDp0AxRxR2s9tC1WNsSbUm0Y4HWWB0Z0JqgxMVKZBAZHxWPhPG/Uj7atRC+Iih1sU92oKIRghIHuz0DSqHiEbQQCK0R6QCZ8QlKIghPoWI2VnsaP0jzp2e/REtLC+Xl5RN5mc4oOmXiAi7ttd0+2uh153J0VQl1X8/PnsbXHg9wp5GHCWA4MtH0L+upf6QdHh67bXIjExNHT5nY98UX0/iV5/GbjgzdcAi237aSxrdvGnZ7IxMTx1jJRF/G8tlR1LlWVUmUoNQFpQlKI/gV4XuvKoZ2LIQXhKFBtEb44VaptiyspId2LFQ8gvACtC3J1JXgl7n4lVG0LfCrS0CClQ7QQqAjNloIVNTCjzvItNelxMn2JDIToF0Hvzw60ZfFMAT7Pr1+eO0+uR7x8NN5fxENxYMsK+Pw+9dT/7UNQypx9ozpHP/ndcM6j37BctIXnzestobRpeSg6A5FNUKWfvzwsGUCoPktq0dlHIbhk3rFSubemRg1JW7fp3o/Z8TGp8bs2TGigMATjTx4DCfSjlYK27ZDezbfB9sOv6BBEJZn0b6PyNq5CcsKY8DpsK3tOOFyaucCpVJoP6sIBgEIiWVJyPanOxJYESfsw8sgW9sBiMjJ6qB8hiMEwrLQvk/DvYlhddFwX4eJ8H+aopNJpj/Ympd5qzrVzNSN5cNyZnCeb6LEMTI0Gaj/cwuqvWPoinkwEpkAqHncbL1ONKVbj2Kn9ajFjWy4t49s9XgGjTZFrcjpdAqV8hGOjUokwfPCgL2dF0zrMABwJgOWhXBsdDbgL0EQBgr2fFTGQ1gSEYtBEITtPA+scEu2s30nwrZDpTBtdZWLdBosC5UYfjR5w9ghz1nM7ssqmf3JjYi/PjmsPsSG/sE8DacH2vfhb8/mVVclEjDMsCL+4Sbj2T5J0E88N2p9jUQmAIKtO0dtLIbh4e/ZP3Bc2mHS93mhXricpnUxpn9x9FflilqRU23tqJFc+B6xYbRHzojNQLjS11k3m95joN/VykzSkxL11BZmGz3MYDAYDBOA/PMTTM8/61ZhfY9NtwaDwWAwGAyGsaaoFTlh2yAthG33e9/zr6vciYRx4vp87lXfdfu1Q1qh6/BAfQ7w2XBmY89u6I5HaCgaZFkZ1pS+GRYNhrHDWjB36EqGyYO0sOfMmuhR9KOotQ5ZXYWlZKhEWTK0W3PdLjs3IURo75ZOgxNBlMTQbe2hjZyQCDeC7kiAbSOsrE4bj0EiiQ4U+H5YJ5FElJeh0xmQAiElOpWGrLODsK3Qjs62sbQHo++5bCgidv2/BuZ9vcPEjioygnPm0zIvRuV/TWCyZsMZxdb3TWXh+3ZP9DAMeWKVl7LzHTOY84l9Ez2UXhS1IhccPYYoxEZuJPNza35ODMaQ2TD7U5M3ubIhN+KvT1L514keheFMYuH7HpnoIRgKIGhuYc4nJl+g76LeWjUYDAaDwWA4kzGKnMFgMBgMBkORUtRbq1ZVJZaIhLZqGa8rWC8q6AriK+IxdCoV2sEJEcZ9UwqdyaAzHrK0BK36hHHMBhXusoWzJFgWuq0dEXEQsRg6mcz2pUM7unQGtEJLBf1T7hkMhkmOWLmMjlmlxH9rtrsM44NVU83hNy+m+hsPTvRQDEVMUStyKpFEiTAwrw6CUFEDeqaPFZlMqNRJGcZ9E2HKLpRCBwqlVNfxTnQQhAGFO98LEbbPZMLPGQ/t+WHWB8JgwDoIQGm0HP2ozQaDYeyRB45R1po09o2GcUO1d1C3sQVjWW0YCUWtyAlBqGQJkVWisgdUqMh1ZnIQlkSl0gjH7vZkBdDZ/KuBgkCFHqnZrA86CLpW3LQOwqwPQiIsC5VMgpB0zfhB99SvMkaRMxiKkeDIUThydKKHYTiD0Ok0bBq9DBOGM5OiVuRUKo0SKlTkOumxGqe9TPjqZ1fq0ul+2Rh0EPRu09mX1uEWq7TCLdO2NhAirA+hEtjZxs+2F6JXucFgMBgMBsNYUtSKnD13FrYnwLbAD8C20IkUwo10b5faFjriILzsSlk6g1YKEYuiO5JhvtVEIrR7S2cQ8Wi4EpdMoTMZRCQCUReUClfnopFQYbMkoi0Bjp2NTSfDWHQRYO+EXhZDHgQXnEfzApea700+V3LD2NJ03XqmPdSCNishhkHY/v3zaXzH3yZ6GIbTkNGWraJW5Py9B/snudUq3PbsgZACrXT/Or1eW/q37Vxd61EmpOhxWPeuB/jGwqYosDc+x5RNEcz66ZnHjNueQ3UkJ3oYhknOko/uM7O5YUwYbdkqakUOFfRT2gDQvS/RgLudnXVyvebob8id04HaGyYdOp0O7VMMZxxBc8tED8FQBATGXtIwRoy2bJk4cgaDwWAwGAxFilHkDAaDwWAwGIoUo8gZDAaDwWAwFClFbSNnVZYjPYGwbbQfeqXqHjHdZCyK9nx0xuuKESciEVQ63ZXlQWc8RKdXqpTgeWHw3x4BhgFEJILOZHoHDvb80FPVsrInlMhMB6TG5/83TCz7P7aehs9tmOhhGAwGg+E0waqp5vCbFlN9S/7ZPopakVPJNFLJMMtC1guhp3eqIhWGDPE9EGFmBxGoUNmTAnw/rJ9K9/ZgzfbT2ZOQAp1t19drNSzzOyuilXF2OFOY8Rfj+WgwGAyG0UN3JKh7rK2gbB9FrcjpdBrdN/xIr+M9lKqsN2mnotXT+3Qo5at33SGOa5PZ4UxBPvjERA/BYDAYDKcRKpWCx54pqI2xkTMYDAaDwWAoUowiZzAYDAaDwVCkFPXW6r5PrCaYGkGmJVYKlAuBq0FqhCewMgLhg3IAAVpAUBaAAuELokcttAV+iUZ6kJnqh8c8idUu0bYm0iJJ1SqEAhEAWqBchUxLEJrocUliRrg1KzwRLot+5M4JvS6GbvZ9ej0Nf+xAbHiqV3n6klWcWuxQ/5WBnRUOfng9dY+lse/f1O/Y4fevp3qzh/uHx/odO/K+9VTs9one9ejo/AOGUcOur2PzjbNofFf/+9aT3T89l/nv3Inq6Biyz6bfLaH+dVt75WseiO3fP5+lH9uP33SkoDEbxg9h2xz4xSJmvL5/6rahZMJqnM+290xhwXUPD3oOGY/z/G0LmPOmp0dlzIbRZfu3V7P0swfxDxzsVX7iXetwWzSlv8h9f63KCrZ9cx4L/rG/yc1g88RoyITQeogZaBLS2tpKRUUFL3XfiC0chGWBUmG+VN8PvUuVBinQno/s9EqF0OtUKXSgQq/WIAjzsvbwPBVuBNXS1u2R2pm3FcJ+st6unYiIA0GAiETw0u38KfULWlpaKC8vH+crc+bSKRMXcCn2IHaT442vPR7gTiMPE4CRCUNfjEwY+nI6yERRr8iFzg6qy7uU1MBxP1QiMWB54GUG7rgt23+ebiO6s59UCpVvI4PBYDAYDIYRUpCN3E033cSqVasoKytj6tSpvPa1r2Xbtm296lxwwQVhvLYef+9+97t71dm3bx+vetWriMfjTJ06lQ984AP4vvH2NBgMBoPBYCiEglbkHnzwQa6++mpWrVqF7/t89KMf5eUvfzmbN2+mpKSkq9673vUuPvOZz3R9jsfjXe+DIOBVr3oV9fX1bNiwgcOHD/NP//RPOI7D5z//+VH4lwwGg8FgMBjODApS5O65555en2+//XamTp3Kpk2bePGLX9xVHo/Hqa+vH7CPP/7xj2zevJn77ruPuro6li9fzo033siHPvQhPv3pTxOJRPq1SafTpNPprs+tra0AZC5aQRCJ4ZdI7KRCehplC+xEgLYEWoBQEEQlWgqsVEAQs0CDnQxQjsRO+mghkJkAr8whU2ETafFBCJQtcNp9VETix8JzeKUWdkIRRAV2QqEF2B0+2pEEEYkXpOFe4+ww1uSSiZ6I888iNTWG+/vBjdvtmTM4duEsqn64ccDj6iUrQvn5v8dz9iGcCAf/5Xym32wyPUwUueeJ87DbgEcHjs10/Kp11P12J8GxYwWd79SV65hy7178g4fyb7T2HDIlCu4zc8R4kM880RfvopXYCb+fg9Rg2NPqOXrJXKp/MPAckosDH1nPzJvMnDGeDCUTQ90TuXwpiYbSIR3aCpEJq3E+zSumUPbzwZ1lco5pWK2ytLS0AFBdXd2r/Cc/+Qm1tbWcddZZfOQjHyHRw0Zt48aNnH322dTV1XWVXXzxxbS2tvLcc/29hSDc0q2oqOj6a2hoAKB9hkP7TJu2mRYnljmcaozQUW/TPN+ldVaEk0tcklMdWuY6NM+3ObXYpW2mRUe9RfOCCG0zbVpnRzm1yKVlfpyTSyIkawQnl0RonufQ1mBxapFL83yHtpk2HfUOHXWS5gUOLXNs2mY4tM10aFkQ49RCl+PnRGibVdRmh0VDLpmgR1o16/BJ9l0iEavOHriTbF3d2kb1s72/zE3/uh71khUARPafwt1zIncfQqCDgPrHTKaHiSSXTMR2n8Q+dBKkRfqVqzh+1bpe7WqfbEf39UaUofPT7i+sw543Z8DzVT/TimptG3gwPeSwk90/PRf7wAliu08V9o8Zhk3OeWIQontO4hw6hVVTzfZvrc7rPKq1jZqnB5CFrBz1YvXZHPzwegDqH0n3P24YU4aSibpNA9vO7/rSOuyGmcimE5RsP9m/Qp97PaBMZOeF3T89t3f5iVNUbGku6P/o1e1wvVaVUvz93/89zc3N/OUvf+kq/+53v8vs2bOZPn06Tz/9NB/60IdYvXo1v/nNbwC46qqr2Lt3L//7v//b1SaRSFBSUsLvf/97Lrnkkn7nGkiDbmho4Oy3fw5HRPHjAhUB6YGV1GQqBWhwOjQiACsNQQS0BcoRWCmNXyLwSkBLiB/RWNl7F0TCcCXSD8ONeKUCKx1eImWH/SJB+BoVETjtYegSbUGqWiBakjz7vY8Z76MxJpdMzP/I55n7he6VM+G6YQq3Ptk7Mq9YxclFDvVfG/iXV2c7a8Ectl81hfn/Fv5SssrLEdWV+Hv2AdD+xrVkSkXOX13GG238yCUTnd5oh367lBlv2B6m0svl6AQgBPt/uYyGf3gWGY2i0unc4UWkhVy6EPXs1l7Fuz+/jvk/O4V6urtclpSgOjqMTIwjQ8lELnZ8fQ1L/uMw6ujxnM5y+bD9++ez5IPPE5zo8eCXFsKx0T3GZWRi/Mhnnpj+us392sl4HJVM5pwLDv5m2YChazpRL1nB4XUxZnxhQ9dcYC2Yiz50ZEAZGxev1auvvppnn322lxIHoaLWydlnn820adO48MIL2bVrF/Pnzx/WuVzXxXXdfuVT/taCozrQjoWKOYhAI9tT4QpJxAY/DDkitEZFbIRSiJQHtoW2JcIL0BEbkQhvqiqLIgINWqMjNtaJNlRZDG1LZMpHW9lf2VIi2pPouItIpBF+gLYtcGw8jNPGeJBLJhpuegR6TNA9J8uexPY2U5vJ/eXobBds38X8f9vVXT53BifOqaQyq8gNFlfIML7kkolOpr9uMxpIv2oVJc8d6VLG+6E1Df/wLJBNlzMIVnkpdd87yKG1vcvnfnQjfbP55ROXzjC6DCUTuVj4vkcKnsnFqrPRgl5b+I3v+Bv9EkCqoHf6SMO4ks88MRBDKfQNb9nFiSvXUXX7wD/q5YNPMOPBbF/ZuaDponqm/VGjnt8z9MAHYViK3DXXXMPdd9/NQw89xMyZMwetu2bNGgB27tzJ/Pnzqa+v59FHe+8tHzkSBsnMZVeXiyNrKylti5Csye4QS5BeabgylwlX47y4wG3TpCoF2gI7GZZF2jWBC4EjiB9XeHERrr6lNNIHPwp2qjQMIhwFmYHAFTiJsJ3MVCA02EkNAjJlAhFA0k3DwHJgGGf8C1fSPiNC5Y/6f7FEMo3TlukKXdPxD2uQniZ25+B2D+qpLVQ+Bc9/cR0LP7+ZoLllDEZuGE2OXL2GGd/qXqV1Wjy23ljDwnceyanoQ34yodo72PWF84gxuNzs/sI6Fty8neB4ji16w4Ry5H3rqf9zC/qJ3CsqPZFlZez41LKulXoA2ZEGIforbjkwMnF6IUpLmPPO7bTcnn8br1ygnZGbYxVkI6e15pprruG3v/0tf/rTn5g7d+6QbZ588kkApk2bBsC6det45plnOHr0aFede++9l/LycpYuXVrIcGifrTn8EkXzeRlalgW0zVV0zIBTSzXHzoejq6B5MRxdKTh1tqL5LMWx1QHJOji5FE6eE7Y9ep6guRGaz/E4uUJxbG1AyyJN22xB2xzBqXMCTq5QtCwJOL5Cc3J5wKmzNMfPUxxfLmh6gebkWZoT52raFpoVuclCZOMWav57M3t/cTYyGu11TB09jtx5gN0/PRdZUkL5H7dQ8qct/fqwGuez8ytr+5U3fmU31Faz45trxmz8htGhfVb32piMx3Ge3c3iD3crcTtuWYM9Z1avNtayRRx6KQPKRE8O/2ohsTsHd6YBiDS2IoaxMmQYO7Z/ZxX2zBkATL9jG2ze2ev4sf9ehIzHsaqq+rVV7e0s+vIeDn54Pf6FKwEINm8neG5bv7rH/nvRgOdf+LXdHLu9ZqT/hmEU6SkTA5HrXgIEJ06y/5aFHPrg+kHPseOH52HVhve94bYdqOf77wx0/MMajr8zP/tMKNBG7r3vfS933HEHd955J4sWdf9DFRUVxGIxdu3axR133MErX/lKampqePrpp7nuuuuYOXMmDz4YrikGQcDy5cuZPn06X/ziF2lqauJtb3sb73znO/MOP9IZifmi2VdjiwjajYRGhFIg0h54PjoeRXg+BAGqrATh+WjHRiZSaEuG+9yWBVqH9TwfHXPBtiBQ4NiQ8cJt03gU0hlwbEQqE27dOnaYzcHzIeOhy0sB8IM09+/4irF1GGcKjc6tXrKC5nlRqm8rzMusJ+1vXDvk1qqxfZk4BpKJwVZpc5HPfS4EIxMTR655Qr1wOZFdTfiHm3rVH415Ih+MTEwcY53Zwb9wJe6Tu3vbSebTbqxs5G699VYgDPrbk9tuu40rr7ySSCTCfffdx1e/+lU6OjpoaGjgsssu4+Mf/3hXXcuyuPvuu3nPe97DunXrKCkp4YorrugVdy5fnv+n6aExsgNBTIEAKyERGvyYxmkVKAf8Gh/7hE0QC7dNI80Sr1TjV/nYJ8NLYCcFmQqFqvQRSQuZkMiA7hAmMY2VEihboyIa6QnsDkEQgehJQapaE8Q0QZCA6wr+VwzjQOo1q3Hafaz/exyZDnASA+S9Kylh7/Xn0nDjwE4Q8twlnDy3ksofbSRVJYheuBI/bpncqkWAVVXFwVUuM77Q/95a5eXsveYsZn6++1j6lauQviZVJSgdoL+j16xn+l378ffuz33OZYs4trp6zBUBw8jY+U8Oc349k0gPRc4qL+fAC2K9ZGIwMhefj5aiXw7m57+wjnkf7n//D3xkPbO/vYXglPFiniwc+uB6Gn6wLed2d6572Yk4/yxaGkspv6P7h9+BqzzmfnEaDKDIHXvPOqb972H8EdrIFby1OtDflVdeCUBDQwMPPvggJ06cIJVKsWPHDr74xS/20yZnz57N73//exKJBMeOHePmm2/GtgvfJ/bKFV5lqMA5LZLIKYlfHuCXKXQswKtSoYepG6CioRInPIFyQvs52W4RlCi0o0nXBKiYQnRYoCCo8kABGvxSBRq8Wg/hC2RaEsQUQQSCEkW6UqOd0HsVt6+Js2EiOPy7Jf3KSv+2j8iz4UO3fVacE2f1DxGhkinm/Cb8EsuyMg79tvd2v9h9kNoHDwBQ+52NuE/vo/Rv+9j/q7MGDjVgmHD2fTTc/lZtbcy681i4zd7jXu34+hqYWsPs3x3v1a7k8X3sfhPU3d97laaTaf/bhDqSO/acjMc5dbPP1P87mLOOYWI4/o7VJF7XbRax9KajRDf03hYVJXHmX/x83n02L4hwqrH/is6Cnzb3Kzt6zXoiraGNpewRMN8wsTTcdQzV0h0yRNg2x+9q7Po80L3sxKqsYO+HBNV/PtDd3okw/4YU4rldvep2Plfq721CNR1lpBR10LO6jQJV2b1yBsAuCy3B8gTpComywdnhYqVAKI22wldlC7QInR60FYYuSdZaWKls+BFPIn2NHxNYGUnggp20CSKAhiBqEWnVgCBwwekIHR4Cz+HAIGM2jA/TXr+9631wwXlYDz7Ra9uk9BcPU75tCWLKlN6BYFXQZeey9ebFLH3fYYJVZ6MfCz3RgtZW6BFAUsSjaMem4Y1b+oU4MUwOZt30KGCjfR/R2sHWL51L448SXfd04b88StDHwsR/2Ur40yYa33m037FOVEUc0eTkzPGMUhw5Ukn5nk1hnxeuxL5/06j9X4bhU/uDx7B7PP783Xv71WldN5sDWzSNDKzI92X67w+iLdnP2UE91dvO0qqtof4vzagnN2PNmM6262cx+/o/F/w/GEafYMuOfmUtrSXULZiLSHv4T+W2mQ2aW5j1ps342eeALCtjz3VnU7lTUb55e6+60y8LnzGqLI4cxiJWX0YUEHiiOb5C0NIIx1ZqTqzQHFsbcPw8zYkVimPnhc4LrUt8Tp6raF4Ex5cLjq1RHFsJx9b5nDxHc3SVpOmFmmPnSU6u9Dm23ufE+QEnz9GcOEfQvERzbJXi5LmKIy9UnFqmObUUWudrjq+AYyvh+HqPI2vgxDqP5iXDCstnGG16KFVHV0ax5s+h5a29nRbaFpZDbWWvss5AnQCN//wY+D4nzgo31oTr0vSvvQ1ZvRnVpGdX9z7fe9djGTuXyYPWHP/ndVhVVQTTqpn1B9WlxHUe73nfEYIjq0LHhJNXrsWur2MgTi4rQ5aX5TytSqVYeOUm0q9chVi5jKbVxtlh0pBVzq3yco69Z92AVU4uslj87XZSrx7a6Nyur2PrtdPIzOzvGNGP6kpaG8s5+t716LZ25r/fhDCarBx632oWXPEMqTnVeDNzO6acfPu6cJ7o8RyQpSVkqhQlhwaIWZmt17ysDFFVgdU4n/Y39neqy5eiVuTkrHa8qgCqMogpaZAaHQ+g0sOankDEAnAUoiKDXNQeHo8GRGe1Ea1OoVyFXxagowFBVFM2tZ3aGS3EahMoG/xqn6Ak3LrV8YBIVQp3ThtyZgJdlyYoD1BxRUl1ElXuI2yFto0iN5Ec+EB/L9JpX96AX1fB0Yt7f6FKfv1or19guz+/jvjh3vdPl8Ro6VxZDwKmPBmuvuy4ZQ1WVRViw1PdqyzZqN21TyfY/f3Zo/QfGUaDmmcS6GQSvek5jp/t9Mv2MfVvPcKQaM2s/z7GnhvXUf1cO6qtfcA+q364EdXcwvbvrup9oE9Wh/juZqymU6TPHn5gWcPYsPv7s6l9OjlgJo7Z393Kzg9GKNk9dIghVVeNO6sd64EB0vj16HvHj84j2LmH0l88TO3TiTDYtGHyIARW3VR2fjVUqqY+kUIrjXPfJna/Lo7dMHC4tern2sGy2P6d7rnAP9zE4q8fxt13EllSMuA8UfHjh/H37ic5t4pDLxu+WVZRb61GN5Rh2zZ+qQ0KIq0a5QhUxEHLcLvVPaXpmBEh0gKqVlO52cErjSAUuICd0GQqbKInNKmDVWQUOBpEHNxmgVcmsFKQKbOwvAjuSU1UQqZcYGUg0qJJ1VRQrgABiejgAUQNY0tQOrAiLTY+w6In3K4gre1vXMvxswVzPtFtuDr/s0+Fkbt7Yln4ZWEr7ft0TtSLPvgsQY8ArzIaZecPFjPvLU8i//Ikc54q6xcQ1jBxiA1PIevr2Prp2Sz52jE4fLTXFphzX+8tT+1Y+GUaHn1m0PuoOjpY/P6tXXXsObPYct10Fv5L9ypL54+Fhf/cZmRikjHn/+1BtbWx/xPrmXlfB2Jjd37V4MRJ6n+1kIN/F6d+iPBy6umtzP6nWL/7ay1tpOkLgil/H26lLbp6B6pz6+0vT2J+9k8utn9rFUs/d5DGj4Xf+575tRd8+in8vs+HTh59Bl1VRaSyt2Lec8t+sHkicu8TLH7QGfb8UNSKXO1zSRwVkK5xcTp8dPaXj9OaxqtwEYFGS0HVdoVfYmM9FSDTAUiBFiAzASpmQ6BBCMr3CZQjEYHGbssQlDjIjMIrc7A7/DBUiQ4VxCBuYyUDRKBge5g9QluSRCwgf/NYw2gz+1OPdmV2sJYtwquOI//8BKigV2Tu0n0JtOxhZLz6bHSgYFPvGTvYtpOF1/SOLwVw6nVnU/Wbp7v6VKkU897yZNdx1ZYjB6dhwvCbjtD47iMcfcc62mdNYc6Nj6L9geM+qqe3suCOsxErl6E3Df4U73mv/T37WPgvA2eMOPrms6j9rvFenUx03rtcXurx3zyCffH52HNnD2hH14XWveYXe94ckgtq2b86wpx/fLbrR4OZFyY3je95lKar1lH73f4OSkNldtDJJJV3l+Q83neeWHRbKWrtOfDw0+HzKTV8G+ui3lr1oxYqahG4AmWJMPxI0idVFyOISBDglVl45Xbo3CAFImsb4Zc6BCUOmTIH5Vr4JTbKkWgpyJTbeOUR/KhFEA1jzfnx8L2KSFTEQvhhP9oKz6NsiV9iI5X5jTVpSGewkt7Axx5+mrKf9YjKnvKQqfyDOUfaFSizvlKM1Hx/I7XPBOghvquFysRQuK1mbihG7I4wzmhBeD52h0/DZzeEDlI52P7t/IO+GsaH4X5PtdbhcyFPmtZXcuClAwU2KpyiXpFLV9uIjA0CklMcLE+jaxy8mMBOa9JVFpkygZ0Ay9MkayzcVhs/KpBB6JnqxQWZMonbEqAcSarKAg3astECUhEL6YOyQUuRfYXYKUUQEVhpTeCGK3zaApUo6kta9Oz7+Grmfe4JAIKduwesY8+Yjn/wUK+y4yursDxNRZ/FF2HbyKqq3p6tQOx3j6IIjVy9MkHd1/OLNWWYOI799yKm/P02rJpqSu96Ej2El3EumejEqq1BNbfkXNXrS88fDobJg4zHEbbdT+GyamvYevMcFl65qV/e1YHmkJ74+w8g9ofxCzrlbiAaf5Bjq84w7ljlZchADvo9Hexe6nSa0j88haisGDB1Y3DBeRxeF2XmTRuwZ0yn/r+eQQzg5TwcilrrOL4cdBWABksh0hIrJRA+qAgE5QFWq4X0w8C9SI3wJEFZgEhLIs0WmaogXJfUEh1RyIQm0iLxSgUqooEw+G9Q4WO12ChH47RJTlaCFgq73QpzulaFt0MlFfx6oq6IYeb9/SfG5GtXE/vvTV2eQls+N41Zv5yB+z/dgTs7A7YKJ0Ly4uVE7w4D/FoNM9j9jzNouPEYHZetoeTXj3S16bhsDfFjAV6y98J2+pJVxP7vmSETrhvGl/iPKgE4+LbFKAemf/mRAUPGJC9dTfx/Hs8pE53svWoRThvUfWNwJV6sWIbV3D741pxhwjjxhnNpWUAve1mA1pcsYOGVjwzYZvNnpzHrNzMHDQQuzj8L61hLvwe/Pa0eb24dYsNTbH9XlEYTS3xSsOe9Syk/7lLz/R5yIASJ160m/ptQDqa+YQ+pV67C/X3/tHwdl60h3pTmxFkxar8T9mEtWRjm3928HeuBx5n5QFh33R+e58/nRPv1MdxnR1ErciX7JPJ46Oigs/E9hQYrqfHKJEGzxG0GEWgCNxtTrl3jldvINFgZTbxJEkQFWkIQsbBToQOElgI/Hj6gAxc4HiF2VBNEQxu6dLuF9ED64LSFDhNCgaeL+pIWPZnKCJE+ZYlai7gU6Oyq96L3buHEG85loGAQwpIkplh0fsX83XtpuDF8ACemSHpaQCSmSqbcupG+X8dkrU3MGSS+mGFC6Lx/9V/dwIl3rkP0kIle9Wot4qJbOe8rE53M/PwGjr174NAVPfErXGTG5GCerNRsOkX53v5BeRNTe3/fe7L4Pc9x/M0r+slET7wKF9kxQA03QqYqggs0vmvoPL2G8WHGQ0miHYl+DgeJKZJO6RCWRWKKPeCzIzFVUvLrJ6n9a3eZKo2irf4e0T/92cuw/zWci3oy3GdHQblWJwududFWv+ZGXBVBZlRov+YI7ESA9DWZchsrFd6SdJWFldEIBU57gFdq4Z7y8GNWqOA5Arc5nGj9uEQEhNumGU2k2QvruDIbCFiSqJW4LZroCQ9tS6x0QLoy6ynbkeThP3zS5MwbZzpl4qXOG7CxBt3uOvibZcx4/RBuaIRbLgMZuDZdt57qzRki//u3IfswORQnjoFyKKZes5rWWTZTbxl6K1zYNjtuPp9F3zySc5t+OBiZmDgKyatp1daw5QtzaXzn0N9zhEC67oArKfnMN0YmJo5CZWLbV2ax4G1PFHwe9aIVHF4fY8a/b0C4LnLeLIItO3I+ZwqRiaJ2drDSChFoUjUOQVQQuAKv1CIx1UF6GuUKMuUWdkoTRASBI1C2AB1md/BjEqE1TluQdXKwUJYgUyrxYwKhNIn6COkqG6/EwiuRCKWx0hA94RHEQuWxoz7S7UQR7a99G8aPvR9ZTvKS8watM/ON/W0c7DmzsGc39Crb+tVlAwb2rf/qRiJ/HCRC/9pzEK4J/joZKX38ANPuyy8lTvPl5zP1kdy2lmLFMmRZ7oDAhuJGtbSx4Pb8VlKt+XPY9ekVAx6ru2WwdTtDUaE1diTAapxfWDsZOk3O+FK4RavT6a6wRDv+c9GI0zsWtSKnrdATVUsQQXeZ5Wm8Ekm6zEJklTY7pXE6wpyp0td4JTZ2UmElVdZGThNpDfDiEmUL7GQYk07LUEHUPa6UndKhh6sFkVaP6EkfmdFkSiWi6NY3Ty8y9d6QCewHWq1LzZtCZk5tr7LGqx4b2ONMa46+Zx2yZOCNlyOrSpFGkZuUBNNr2PbPtVgL5g5Zt+LHD1P+09yGzyeWlyMrCls9EavOxnvp8oLaGMYWsXIZmVes6l8edTm6Mr88qMHO3czNkUz9pV/564DlhuIjOHGSuV8IaF+SO8tDJ3Z9HaeuCE0vZMThyJr4gDa589/6xIjTOxa1IueVSvySbuVJehqhNOmy8N9yktndbh16mvoxgYqEXqqpagstBakam3SFhVcW7n1bGY30O1fXJE6Hwklooid9lC1Il1s4CUWizsZ3JckpEdqnO6iIQCjCMCiGCWPh97q3NtKXrOLEu4a2YQKw/7QJ+WC4XK5esoIj164fMNp7JzWbU+iMR+J1a2h+W+9z1H1j8JADholDP/YMC3/SBi0DZ2sA2P6dVXklMq++bSP+gYODyklfrKPNRA8Y2Zgs7PrJCqyjLcT2Nvc7ptrbqf/a4FvwR963HvWigVfiOrn/Ay8cyRANk4Tn/30ddsNM9BPPEbszx2JBj7lAdSSo2tbB3hvWI2bNYNqXC4tscPD9/bMU5aKoFTmnTSE9jZ1UOB0BQkGkNSB+LMDKaHxXEDuWQWY07imf2DEP6Wnc5oB4UxhfzEkooid8nHZFpF0hlEZLcDoUdlIhfY2dUChb4CQUkbbwfexEQPxohtixDBV70ggf3LYAO2Vii00kO97W/QCO3vcUU/6rcFsG66/PMP2eJvb/cuCtVQDrgcfRXoaSu5+g6hcDpOUBrJpq7LqpBZ/fMLbsfVUF/oLpOY8v+cA2UAp77tBp1mRZGbt+vDzvc/t79xPsMCHDJwuN/7IPHY0MmCy96beLh2w/7buPY20M8/ZatTVYU6b0qzOULa2ZJyYn9uyGXrsuCz77bPjDLQdWZQU7ftit1Ku2NqydB5l/+0GCnXsKPn/DrU/nXbeoFTmvXJKusAgigtbZDl6JIDHVxiuRZMokQUTQPj0SrrbVOWQqbBJTbFREoNzQDs6LyWyw39B+zo9J/Gi4aufFJR11Nslai466sF/lhFutqUqLVLVDutLBj1lkyiWpitBmzjCBuN2KtPYyOd24rUULUC8Z+Je09n1OrKtj1hfIubLW+pa1yHgc7WXQOfIlZs6ZQ8vaWQX+A4axpv5RD+fQyZzHg9ZW5LQ6Dr5mxqD9JC9djYhGw60RQ3GiNXvfUA/AqSvWIezuqAP1r90yZHOVSnWZahz8x0Xsv2JhQae3ysvZ+W+LzDwxSWh/49quH+9H/m4mzO22m1ZtbTCIb6hKppj6x94xE5Lnz6Nj6dR+W6cn3jn0TpFK5B9jsKhjZRxdCbYFKg7o0P5NBKEipSIBVlISxBUyJdGORltgtxB6miYFyoGgTGF1ZD1SSxSiIoVK2jjH7TCOnNBhsN/aNJyKIDOCoNzHbrYJSiBy0gItyFQqqMhg7ZDwuwm9LGc09gkH/8KV3Yns+7D/4+uZe9se8HxEpv/q6Y5vrmHhNY9Q+aONOfMgnrpyHW2zBZU5MjvsuXEd87+6Df7vcUp0jswShnHHqq3h+fc1MvNPafD726SoFy6nZX6Mqh9uxN+9l7qv7+XAR9Yz5479+Hv39+8vpfpN0DtuWcPCqweOPTbYMcP40vYPqyhrtuD+Tcz8fLjl5SR1r2wf+d6v57+wjgU3Ps30+06CJfqFrxisny1faWTWbwPsu/LwjDWMOXZSoYPwO13zvY3s+PJaFnzUzfljvZMDH1nP7F81YSd7PzUi94ThZXZ8Yw0L3/dolyLoJLrrCddl5+dXMP/9ww8YXtSK3IwHFJYbepxamVCRA7L5UW2EUkRafZQjUZbASisgQDmiyw4ucCV+HOyO8OsnPYlyQHqZMO+qCvOwpitDTdtOBQSORPrhNqyd9AgiEisVEEQtdHvK5FqdQOb/x3asQA6YfFiWlTHnZ4c59t0Sql61AzHAjVpy8+FeUdyFbSMrKwiOn+gqq717OzXJVK/VPhmP8/xtC5jzpqeZ9+sWVGtuGyzDxBCcbGb+d/fx/DtmM7VsJtE+kfntJ3ZQu8XtFWl9zu3PExw7PmB/kf/9G6K+rlfZki8d7pcF4Mj71lOx2x/wmGFiqLx/B1YgkdPq8Q83se9T62m4t6OXYp7v/Wq8ZT9BxkM2Hes1T+TqR79gOfsvijPrhg0svfEo/p59Ri4mCdG7Hu317Fj09YP46XTonR4EOfOtds4TkdlVHPrgeqZ/sbc93JL/aIK6qfhNRwAov6NbadOZTHieHvVlPI6UAeSZmreot1YDN6uQCboC+AZRSarWwWkLL4tyJO3THdJVFn6JRXKKE+ZfLbO6QpFoKdCWQLkCv9TCj0sylTZCaVQkDBgMhOm4IuH2qh8TSC8MNCy0zuZhDfO0GiaO4FRzzsTUza9eRmJRLdWv30f6kv5eahAmM+6J1TCD3e9d1Pscx0+gOjq6PqsXrUDEosx5U2jTsPPNFcgKE5Zi0qEC/AMHmXXDBpZ98ul+Dg2qo4PgRO8tV/9w06AxCTd/ZlZvA+cTp/AvXNmrTt3XNxC969F+smWYODrnic2fnQnArBs2IDY81auOv2cf9uwGxMplg/bl7z+ANXNav3miZz89EX99klk3bBjwmGFy0bkS3/zqZSRfmlsOOucJ575N/ZQ4AHX0ONu+PB1Wn92/sdb9VvyTL1lG8yuX5D3OotY6oic83IwiiDsIrfFjNnbSJ3AtnNYM2o7y/9u7++Ao6jSB499fd0/PTF4mkMQEQsI74gsgyjtalKuU3rpXp27V7XqWt+JdaVkLbimnp6xe4e7dnne6tXKI1r1ULXdXK8rulUqVu27pgsWWJ4iHx/EmCEQgLhCIkBdmMjP98rs/OpkYMhkCSUgan08VRdLT09Mz80vPM7+X57HaHEqOgR9RKFdT3JHg13T8jooQilhTGnwfNxFFKwUqqAahtIZkcBE3SyIYjo9nG8H/MZNIm4tbZBI52xE02gY6IosdhqvOVBKquJjkKIv0ffMZubMZf+e+Xu/jfn6EsT/uvbSS940bOPwtm6n1XbmiJj65ZUDq54nBceb+BWx8FyZk+59V/6of7OLIDxdQ95Pg4q3sCKmqCJLSNRyu/MvCQ5qnF46h6TrFxAJpI+H814neHP7JAsY/nT9tiRg+CqUh6o1VO4Zjd46j6uUP8ZNJrny2hdSUirxVIc4VfedjzAuYlhPqHjltKPy4hW8bOCUWaI1vBiW0nBFRlOvjFVl4HVUZOtOUWO3B8CgEgVymPIqbiOLGTLxYR69eRQTl+GjLwLfN3Ni2bwffvg1X51493zZwiy082wgeSww/SuWS9PrJJOVrt1Dx4QnU0eN5dz/2+ELcW2b12G7Euif3jH76B6auaihYQFsML6dudKn5vdPnYveF+FmH2k1dvbPel6cv6qIvhh+jqAjDA2MQv5VNeEumYITFgX+a3yNpfCH+mWZG/Xdz7nfvQH2uRqs1fiwHX5w/YOcW6qjD8HyU27EYQSkirU4wp+0rw6VmysVuDiJb5WmU6+OUWBheEJiZKRcr5WG1ZdFmMFTrFBlYKR8vHnRYmhmPSJsDGmJN2VxZLm0orKSLkQ7+0r24kRvSFcOLMX0qR1Z0BWZmdRXaNPCaW/LuX/Ozj7De755WxCguZt8r07ptc080FlySLoYXa/QolGNgt2QH5HhmooTyn/ZcCCHCr37tZEp+9RHj/6ZvVe2tutoL+qCHIK+hCIcr/+p/8i566qQsC73guq7fa6o5eE9Z3n3dw0eZ8sTALXAJdSAX9L75QW+Lp9FWMOxptruYaQ+lCXrK4ibKDxZBANgtWVTHYgdtBqW4VNbFbgkCvugZF8PTKE8HKUmKLXTEwMh6eFEzSC4cM/HsYDGE4XiYGQ+7xZXKDkPs7N2z8273d+5j7LNdcxf8mis4e21l3n0B0t+ahXl191QCfjLJlX8hq8vCzK27ApVRmE19nEV8HjqdYc9b+fONnXiscFJpMTyo668le3vP68b47+4MRmL6mHU/M6mK9KSe+eCOPb6w3+cohl5nD74x46q8c6yVbXNiYVfeOe9APRN7qfYBoGdfg3dz4XKSfRXqQE5binRlDKfYABUEbe1VUVJjYrjFJk6JSboiQqbMJDPCJFMeITvCJltmk6mIoC2FUxrBKY2QrSzGjwR56dKVETIjLNKVEbIjLPyIIlUd5WxdDLfIJJsw0ZbCLTLJlEdxyqK0V9pBPjoZWh1SpUfzryo6l/7fPcTf6v2bdlHDWQ48U3RRtTQPvjg/b2JQMQxs24Vf4tE+6fwldvrCT6epeSF/xvY/+t6HKLN/NRTF4DNPtxL/on+BvTVxPA23RrE29ZxMV7FXUhBdDj7/h6Cyg3G6jXhDz/bip1J9rt5g1dXy2UM29vGBqfIS6sUO8fovMa0kyvVAa3TEQmUcMA3w/CDJXHsaXV4Gno/KOsF+URuVChY4RCNW8K3Z9cAyie130CNKIeug0ll0PIrKOmjLDI5tmcHPjguGAe1piNrEMlkwTZyIdMkNJb19L6jIeffLfHMOZ66KMOrF/H94/o69TPl+GV4vK2ALmfqjT/FapAzT192uW0ai3TNDfRriPAoNl/X5GIcbmPj8l3nTHnXOixLhNvnv9+B2JgX+on/Hcr/4A1c/2jpgpRxDHci1Tq8i5ti4cYNI0sPI+qSqbcxsULbLiyrs1mBlKT6ggsUKRkajTYXd4pC+wsZKBl3nnXnjOvPMmemgHJdTamK3BnPivKgKqjdosNu8YAVrNPjWrRW4ThpJJDd0sotvwNpYeN7J6QcWUL52C6Pe6XmbikZp+fb1JF7b2mP+nIrYNH/nBspeLTyZ3WtuyT2GCKczSxYw8t8Lv3/pP55L8Uef4506lfd270xXEHf2O/NJ/HpXt7Q1YvixRlWTvGFsweCr/c65lHxwsHuqGt/Lm/ao7Z75lL21o9cKMwDmtVNx4xo+3tCvcxeDQCnOfG8+I/9jS69Bl5p1bTANa8febtvNinLO3jQ5f11WrfFaW8ncMYfiT47m8stdrFAHcm21JmkVwYuB1W5gZMFJdKwqzZh4MYg2m7gxheF1LIowgyDMi0HstElmhMrdNzNSBXPc/GCFa+RscB+nRGFUmShf48UVvgkYEDtl4NsQSWraKw2UBzolix2GkuGeP/2L6Wj8m2bSOjHOiP/s+WHdmSw6/327fj7w0jymPJI/Y7vpSM/scDXpNY/ogcaCSVjbr1C0P76Qmp/2PlRiuDqoKNMHwb7SJoY7rXXu77+3v2/D0eD37b00znMdMKur+PQHCSb9S/MFn6u4NDqv5Q1PL2TCz+txj5/odrvyNPRS5eer77+aPY2m60up+LeuzxzD1Wiv/ynLQh3I1bx7EsuMomOR4MXMOhCx0LaFas+i4zYqlUE5LjoeRRsGKpMNhkQNFfyvg8oN6mwKXdSRWsLX+Ik4RnOy63bHRUesYLjW89F2BCPZjrbMYGi2Y1Kzi8PuIXxNvu7sjz/DiMUKfgMu+8VWWv9sPqevgRHn3KYzGUp+lT84006Wkl929cZNebX3Wnhlv5AUFMNR+51zaR1rUf1+/pXGZiKB355mzOrtmJUVBYM9+7cf9ylfoFFaSslv/q9gmxTDg9d4ksi7JzEryrnqpaa872/0N3173wESmw/iFSjv5H95mmv+ziZ99POLOl8xyLQmsW4rRnEx4395Im+Vl3N74jp5Z1oo2nIw11bU3nqqGkpyv7fdM59siSLybs8efSMWwzAi0McO/FAHci0zKrEiMbTq6kXpHPb0bIU2IJLyUTqoyuDGg8BN+aA6h1qtYMUrjMilHjE8MLM+zuTiIBrXQRUJoCO1CVhpjTbKMLMdQ7C2gVNkoFPt0Ht+WTHIzvzJNEqbrVyNu8H02UM2V/YSr7XfNbfgYgoxNOIbthEvcPuxJdOo3naW9upY/iGRi9D0p9MoPZol8rvzZJUVw8ahx6Yy+Z/7X3Vh/w+nMPVv93cNsxsmmW/eQPTXwfVJuy5uQz8nXIlB13zndOxWn9iBwvOmrNoxeNUj0Nv3YI2vo/7Pa3JVPPxUCr5S4qv09d6/7LffMp2zpS683rfzC/USSzPjY6V87FYPq93HzGiiZ1wiKZ/4aZeiJhcrrTEzuqMcVxDERZtdlK+xm10iZ73gPkkfw9FEm4M0IgCx0y6GGxyz+HgWM6ux23xMh+DnVg/DDbrilaexMv55u9LF4Cp7bdslCeIArl5xlJPL8qcWaBkX6u9Il72GpxeiInaP7dWrP4SPdtE6duDev/KfbyHyu+0c+fGCATumGFzjn9mCbm3j2BP9Sx0yefnWbnMllWkOaNsSl0Zi3VZib3f/YvfFioW5JPOddGkR6aqg9J9bfzgXxJ3LrK7q9bMDgl7fstf7/kUylC1Kd8w1abzaIepYpKt8jKwi3qhwSsCP+PgxTeykIlsKfiyox6pcMLId9VVNF7sFnBIP3wIz6+HZHftqMNt9DAe8qB/00LWDthw8G7QVHA8FvgmxJkV2hIuZUniuC+90naO4NDpfb5cgcXMhTeunUP39PSQ+LMbtKINy5r65mI4msb73ILDxtalU3/tZV5WP5iYqNwbHMIriHH5lImOX7AGgctVm3M7zQdrDUOh8zQ8/MYPxL+zsdtvCxVs58jMDP5snNYSGitXB+1f/j3OY8q+n8A4dvqDHPvKjuUz4rxb8Xftz28a81YSrHWkTQ6i360TDinnUbkqiPuqaGOMlWxj128bcNaLThbaJpvVTqPzugeCXrMPIV37fY8j+8F/PgOc3SJsYAuf77DBmXMXn304w7tnugdXod07iZNtBdw20u3v3Yu4FVylOvTaFK+75LP9jlsXwbzqG+1LvqWku5DqhdAhbTn19PZMmTRrq0yiooaGB2traoT6Nr43h3iakPVx60ibEuaRNiHNdDm0ilD1y5eXlABw9epSysvwlMC5Ea2srdXV1NDQ0kEj0r9y11pq2tjZqamr6fV6i74Zrm5D2MHQGsk3INeLyIG1CnOtyaBOhDOQMI5jaV1ZW1u8X66sSicSAHG8gAglxYYZzm5D2MDQGo03INSLcpE2Ic10ObSLUix2EEEIIIb7OJJATQgghhAipUAZy0WiUlStXEj1n6e9wOZ649KRNiHMN5Hso7eHyIG1CnOtyaBOhXLUqhBBCCCFC2iMnhBBCCCEkkBNCCCGECC0J5IQQQgghQkoCOSGEEEKIkJJATgghhBAipEIZyL388suMHz+eWCzGvHnz2LZt23nv89xzzzFnzhxKS0upqqrirrvuYv/+/d32ufnmm1FKdfv38MMPD9bTEEIIIYTol9AFcuvXr2f58uWsXLmSTz75hOuuu47bb7+dkydPFrzf5s2bWbp0KVu3buW9997DcRxuu+02kslkt/0efPBBjh8/nvv3/PPPD+bTEUIIIYS4aKHLIzdv3jzmzJnDmjVrAPB9n7q6Oh555BGeeuqpPh/n1KlTVFVVsXnzZhYtWgQEPXIzZ85k1apVg3HqQgghhBADKlQ9ctlslu3bt7N48eLcNsMwWLx4MVu2bLmgY7W0tABQXl7ebfurr75KZWUl06ZNY8WKFaRSqf6fuBBCCCHEILCG+gQuRFNTE57nUV1d3W17dXU1+/bt6/NxfN/n0Ucf5cYbb2TatGm57ffeey/jxo2jpqaGnTt38uSTT7J//37eeOONAXsOQgghhBADJVSB3EBZunQpu3fv5oMPPui2/aGHHsr9PH36dEaPHs2tt97KoUOHmDRp0qU+TSGEEEKIgkI1tFpZWYlpmjQ2Nnbb3tjYyKhRo/p0jGXLlvH222/z/vvvU1tbW3DfefPmAXDw4MGLO2EhhBBCiEEUqkDOtm1mzZrFxo0bc9t832fjxo0sWLCg4H211ixbtow333yTTZs2MWHChPM+3o4dOwAYPXp0v85bCCGEEGIwhG5odfny5dx///3Mnj2buXPnsmrVKpLJJA888EDB+y1dupR169axYcMGSktLOXHiBABlZWXE43EOHTrEunXruOOOO6ioqGDnzp089thjLFq0iBkzZlyKpyaEEEIIcUFCl34EYM2aNbzwwgucOHGCmTNnsnr16twwaG+UUnm3r127liVLltDQ0MB9993H7t27SSaT1NXVcffdd/PMM8+QSCQG42kIIYQQQvRLKAM5IYQQQggRsjlyQgghhBCiiwRyQgghhBAhJYGcEEIIIURISSAnhBBCCBFSEsgJIYQQQoSUBHJCCCGEECElgZwQQgghREhJICeEEEIIEVISyAkhhBBChJQEckIIIYQQISWBnBBCCCFESP0/GcD8H9+y7bQAAAAASUVORK5CYII=" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnIAAAEXCAYAAAAp/6nhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB820lEQVR4nO3dd5gcR534/3dVhwkbtUqrnOWAI7Yky8fxNeDHAb7cAeZ7GAyYcPjgbO7ARHMkE87EwwcYOO7AcHf4MNk/DGfABgxGsmQL56Bk2YqrvGlid1f9/ujZ1e5qw8zubBjp83oePdrprq7unamd+UxX1aeUtdYihBBCCCFqjp7sCxBCCCGEEKMjgZwQQgghRI2SQE4IIYQQokZJICeEEEIIUaMkkBNCCCGEqFESyAkhhBBC1CgJ5IQQQgghapQEckIIIYQQNUoCOSGEEEKIGiWBnBBCCCFEjZrUQO6WW25h8eLFJJNJ1qxZw8aNGyfzcoQQQgghasqkBXK33347119/PR/72Mf485//zNlnn82ll17KgQMHJuuShBBCCCFqirLW2sk48Zo1a1i1ahVf/epXATDGsGDBAt75znfywQ9+cNhjjTHs3buXhoYGlFITcblls9bS1dXF3Llz0Vp6rifKVG0T0h4mj7QJMZC0CTHQidAm3Am6pn6KxSKbNm3ihhtu6N2mtebiiy9m/fr1x5UvFAoUCoXex3v27OH000+fkGsdrV27djF//vzJvowTVq21CWkP40/ahBhI2oQY6ERsE5MSyB06dIgoipg9e3a/7bNnz+bpp58+rvxNN93EjTfeeNz201//EVw3iYog8gEFXjcYN/650Kyo22ewGsK0wsmD3x2Rn+ZQbFSk98f7Il+hI9ChJfIUxgXjgVMA44OKwCmCDixWQ7FBoUOIkgoVWhJdFmx8ziAq8OiPP0lDQ8P4PHkCGLpNvICX4uINekzx4ufjZgL0+sfKPs+uD65hwWc2lFXWOWUZR89uofEHD/RuCwm4j19Ke5gAZbWJVc8jNytJ6hebyq5Xp1PsedtZzPnX8toBwNE3rGbmH/YSPrf7uH3SJiZOJe8Te96zhvlffggbFIet8/BbVjP7l88Rtu2v6FqkTUwN4/U+MZjohWdjHIX3u4fLPsaZ3sK+V6+g5d/uK7tNTErX6t69e5k3bx7r1q1j7dq1vdvf//73c++997JhQ/83zIERdGdnJwsWLOAi/hpXDf6hPVlCG/B77qCjo4PGxsbJvpwTVq20CWkPE0fahBhI2oQY6ERsE5NyR27GjBk4jsP+/f2/0ezfv5/W1tbjyicSCRKJxHHb3UXzcZUfP3AcrFaoMAJrQSms76HCCOu5EEXH9hUDSCZAKTAmPl5rrOuAoyEIUZHp3W89N34chNiEhzIWogib8HuPV0EY16FC2F7d50scb8g2MW8O7D00/MHawV28gPCZZ0c8j7NyGdGWMl5QpXCWLyHa+szIZcW4GKpNlMtpbIRUkmh/+ROuym4fYlIM1ybcJYuIdu3BhmFZdVXyWuu6OnRjA+G+trKvVUyMMb1PVPDZMRJn2jRwNNGhw2Oua1ICOd/3Oe+887jnnnt4xSteAcQDDu+55x6uu+66suvZ9Yp5eE6SyIcoBVHCkjgcD1a0LhSbLU5OYR2LMgpdAB1AosOSbVVYB9wMWKfUHWshrLd4XXH3qlMANweFFtBFSByx5GYpjGfxuhVBo8XJKsIGS/KgIvIhMHn4zDg8aaIs+166kDn/MXwg5zTWs/3quSz62LMj1rf5HTNZ/u6R37yV77P1rbNZ+kEJ5GpVeMYSOpemaPrv8gO5zW+fyfL3PBN/QRQ1Zcfr5rH4m1migwdHLqwUW/5uJsveU14gZ09dzP5zGpn+LQnkTiSVfHaMJLd6GWGdQ/onNRrIAVx//fVcffXVnH/++axevZqbb76ZTCbDm9/85rLrmP+LA3jGie+85QvxHbTIYFMJbNJDZeNtKgixCR9VKEIQgufGd9+Uit+AtUZlcuA6ccVhhC0G0NyAKgagNeTy2Po0dGXiMtObUV1Z8NzeO4AUioROJDfkJtHMf98AI9wej9o7WPSxdb2P3aWL2fWKucz5l3XHlV3+7vvLOq8tFFj6weMn6ojaodY9QlOpCQzXJvpafn157UNMPQs+vY6o3MLWsuw9x15r3dDA9hvOYMmHBv+bt5ueYPrYhleJKcrq6nxp83/1IH5VaprEQO41r3kNBw8e5KMf/ShtbW2cc8453HXXXcdNgBiRtXH3ZzqJTXhgLSoXD1Y10+pRQYRRCmVM3B3aVIfVGp0vDWjVGuO7OEGIaapDZQuoQjfMaMakfXRHHOiZ5hnobAGa4uDOAjadBK3iblyt0YViHNCJmhLt2ceCHwSU18Eysi3/cT6n/dPOirroxNRS7TYhTiymu5sV/7FP2sdJJursZvm39065133SAjmA6667rqKu1IGiZ3aicEBplFbYKEK5HhbAGlAaEwYAWBXnYVGeiw1CIkD7HjYy2CjCJBPYXXvictZAqd86MhZVGmMXGRvvK1GOE5/T98FYwjAgLP87npgibKFAuHtP1epb+bcPSiuocdVuE2JqcU5bgZs3hM/uHF0F1lZlnJSoLfmXnkfyzqm3AlVNZx5UWvUGcfQJ1JTnxtsdHW8vlVFaoVwX5Tjxz74fl9cK5XvgOPGxThwc4jhxWdft/bnnPD37gVKdpfOUtgkhhJiaCrPqiKZJqg9Rmfblk3rva0hT86rKZMMw7tY8dpMMk80e2x/0KWv6HFMSdXYe+7m9I94/8CRK9eYVUm7p6bIWbIQtxPddTCbTO97ORsHAGoQQQkwh7r0PY6dQqglRG1pvHn7M7GSp6UBuQvSZjTbsNHWZtSaEEEKICVbTXavoUrendo7bjlKD/+vZR6lL1CvNG1HqWF19y/bdVzqm7/mU6x5/DiGEEEKICVDbd+SswQ6YgNCz/djP9lhwZS1geu+eWWOhz7D0fnX1lC39HJfluPPFj/vcjZM7c0IIIYSYIDUeyFkwg8wPHBhMDRVo9T22NO5tyON6yg4832DnF0IIIYSYALXdtTqSUXRz9k5oGEqf7tZqnVMIIYQQYjRO7EBuFN2cI66713MHbqi6pWtVCCGEEBPkxA7khBBCCCFOYBLICSGEEELUqJqe7NBx5WqSoY8ygIJivSbREaGLFusqCo2ayFckOg2Rr/ByBqsUXiYiTGucvCXT6qIi0KHFKVoiX2Ed8LIWq6DYoFER+BmDkzcYT5Fvdkh0GowLfpeh2BCfxwkg5xXgv++Y7KdGDKJ42Src7gB938OjrsN53im0nzGNhttlsfQTllLs+qe1LPjU1Ez+Kcau48rVTL/9oTHVoc8+ja4VjdT9aEOVrkrUsp0fvZCFn6jee0bHa1fD/5QXS9R0INfyyFFc4xxLJ5LwUfkCKjJYR1Pne1hXo/IBOBrCeHybCkKs56KCkOTeNCqyYAxEJi6nNRSDeFUH30NZC0GICiOsVtQlE6hCMc4vF4SkfC8+LjKkXZnFOlWln94PQTi2BY/bDtIcRrKW6onMWub9PjtyOVGzWh45OuY61N5DNOaK8l4gAJj/2+q+Z7Q8XH4brelAzmx7DoOD8n1sEPaulxoVCvG2fAFdX4fN5UrLeWmU72EBW4yX0tLtKUwmB9agUimIIjAGG4Yo349/1hobRXFd+QK2UIBUCtPVha6rg1J9yvcwmY5JfEbEcEa9QHYf0eEjcPhIFa5GTGVjuWsrpr7oqa24Y1yiKzp4EA4erNIViVpX7feM6KmtZZet6UDOBkWs8npnmtqgeGzN00IBgOho8bhj+orajz22XV39yw6YwRqV6uxbtt86q0FRZq0KIYQQYsLUdCCX+evz8dwkTsHgZiOwYLUiaHQIkxqnYEGBmzUYV6EDg4osxtfoosHvKNK5rA6nYPE7QvIzPKyG5JEQjEWHlvwMD6dgCeo0yUMBTsGQn+mjSis9hElN3e48udYEXrchDHJwt4yRqzXdf3MBOrCkfzq28S5H3ryWxp1F3Hs2VenKxFh1XLmahg4X/64HqlKfu2QRz7xxHgtvrGw8jDunla3vXMKCG/5QlesQo7fvH9aw4Ct/HtdzHLpmLdO2FHB+P77nETXigrM4cH49s75a/bG3NR3INfz2abxkPSgNhQLWWpTrkgDwPZRSmMyxfmulVFxGKdAKWwxo3pYAHSfxTURRXBeUulY9fNeNx8s5Ot4XFPGUjvcnfHAcbDZH49M+hCFBmJ+EZ0KMVeMvHgNrMSMXHdaMHz0OQTDmekT1TPvFk7ihqtprEj63myVf7ap4bFS4/yDL/yWgMHJRMc7m/+dT436O2d9/AlMoUE4fzc6PrIZPyg2AqWzrLWs47fP7Rj1ERz20mTlPJsZlTGVNB3KmO4PJR8e6QLWD0qo0Hk4N2s2pEglMny5SsqVAT6l4TFwUHVtPtc86rcpxsNGAJb0yDtqPu3ZNVxcohTH9u25FbTCZTHXqGdA9Lyaf6erGjHE8VP8Ko3is5GiOO3S4etchRi1q7xzzGLkRz9HZWXbZhZ/cyDPjeC1i7FZcu2FME+VsodBveFY11XQg5y6ch25oRnVnsekk1nNQuSIqXwTPxTSmwVpUJo9NJrAJB7TGyRRQnRnCuS24Bzsxdal4ZmqhiJlWjzIG68VLcbkHOrEJD5P2MSkP72B3fHJHx+fL5CGZQFtL2JzCOXQUnp7EJ0VUzF2yiD0vn8fsL0u6CRGTNiGqxZ3Tys7XL2Xu56Ut1TqnuYkd//C8qqYZqYaaDuTM/oPow93xnTLHie+ahSHWGNAadcjFWtu7X/d0qQYhNopwursxxSDuHgWIIvShI2Bsb3erKaUh0Y6Ddhxssc8dt9JsVpTCAq7vExS6J+OpEGNg9u1n3v9nx5aWRJxQpE2I42gHnUpWfPc+OnSEhT9OSluqUU5zE1F7nI0i6uxmyff3T7mUMzW9soMpFDG5fJw2BCCRiAO6hgaU64LjgDGoRCLuMu0J+DwXlSyVTcfHKqVK5S34HjYyYCwqkYhTmYRhPC7OK8W+Pd22jhOnLNG6/35RM0w+X5XUJOLEIW1CDOSsWMKz7zu74uNsUCR85tnqX5AYf9rh6ZuXH3tsIqIt2yfveoZQ21GHtfET295eGrNW+qY0cJxS329Q1RgLNdj4u3w8ySGS711CCHHCiTZvY+HHt032ZYiJZCJWvGnqZyCo6TtyKAXaOfZz33/aGfzn4f5p51jZ4Y6BocuJyVXF10G5o/ieI+2gZozq9S1Xz/uSmLrG+BqNa/sRtWWS/95ruiUevWoV4ewUTgG8bkuYAr/boiLIzdB43RYvZ8m0alIHDYVpGjdrSR41ZGZrvCxEPlgNThGysxVOAZJHLN3zFHV7Lcn2iDCpsZo4F11osRpyM+O6ooTCzcV355wi2GwOfvizyX1iTmKH37yKxqMeqZ9tHHNdW/7jbE79h60VzT478PdraXo2IPGL6uQsE+NDuS7P3nYai/7msXGp/9lPrmbp7Ucxj8rMp6lqy1fP4/RP7ybcs7fiY53mJp6+eXlN3K0R42/751ex8uv7ibbtmJTz13QgN+2/Nw45hbyxz88Ng+xPD1Zfn5+bRzh30xDbQxuMcKQYT9O/PXSbqNSKN22qeFDrrFum1mwmMTgbhuMWxAEs/qf1kktwilv59xtHPRAmau+QIE70Wvae+yd1AkRtd60KIYQQQpzEavqOnG6ox3GT8cxRKC14b+PH1oDScboQrY+t6uC6vfuwQ3xnLi2/hVb9UpHYyBw73vSZtWoNlFaAMKYAkhO2ZrmLFhA+t2uyL0NMEKe5CRuZqidydmbPwhxpP25tZ3FiUq6LM2M6Ydv+yb4UMUYT8RmgXBdn5gzCfW1Vqa+mA7nsC06BhhSFRg0KvIzF7zbkWhycIB7Llj4QEqbiG486tBQaHVAQeQqnGK+nGvkKJwDjAhacwKJMPCbOKkAd255v0ni5+DgdWvLNDn6XId+iSR02mGwO/ncynxUxFk9+YA4r/14CuZNFxyWn4XVFJP63umMad79+OfN/vn9KpioQ1efMn8uzr53P/JuOD+Scxkayf3FK1duYGB9PfnAOK98x+GeATibJXHbWmMdgO7NnsePNi1nwKQnkSP7qYVzl0diT900rbKFAcsByW75WvctuJQDlevFdNMfBBiGqdMdNJRLYQqG3rPL9+E5eGILSKM+l3hhMMYiXAjOWtONgw4B6x0G5LkGQm9wnRYzJyr8f+yQJUTvqf3D/uNQ754vrplzSUDF+wmd3Mv+mIfIOOg5hnY7XABdT3sp3DPMZoDXFOk1qjOcI9+xlwacqn2QzlKqPkfv4xz+OUqrfv1NPPbV3fz6f59prr2X69OnU19dzxRVXsH//6G5HK6fP2qrWQBShXDcO1ErroirH6Q3CVGn1h94u1SjqDeIAbDGIy/aUi6I4QCx1w9piMX7c5/xY03uOvvvE1KTr6sYvPYh20OnBptGIE4nT2DhyIXHSGtg+oqNHqfvRhkm6GlEunR45PDPZLE3fG58vf30pz48XMijTuNyRe97znsfdd9997CR98u28+93v5he/+AU//OEPaWpq4rrrruNVr3oVf/rTnyo+T/aSM6nrcohSDiq06GKEDg2FaQn89iIm6VBo9nDyhsI0h/T+eEapMhZdNEQJJ049EhgwEDS6YME6Cr8zwLiaKBnHum4mwmpF0OCQ3pkhbEoQNLg4BYPbHRAlXaKURrV3w30/HuMzKMbLto+excqv7iLctbv6lZ9/OrsvamDu52Tm6ols89eWsfz1D032ZYgpavMty1j+xoePTxovprRd7ziLRf/y58m+DAByl51DV2MA//2DssqPSyDnui6tra3Hbe/o6OBb3/oWt912Gy9+8YsBuPXWWznttNO4//77ueCCCwatr1AoUCgUeh93lvJ6pX6xCa28424r9sSxDsfSjAwW2w785QeW0YOUKQ2jwyn967vdRdKPTJSh2sRIln5g/fitvbHxMeZKz+ykGW2bqJQEcbVjotpEX8vfIO1jKhuqTcz74gaoUuqqsUr+fCNuBbHEuARyW7duZe7cuSSTSdauXctNN93EwoUL2bRpE0EQcPHFF/eWPfXUU1m4cCHr168fMpC76aabuPHGG4/bfuSNq3ESSdy8JUwo0JDosHQu1LhZQIFTsBgX3DwYD1QIUQK8LNTtLZKb6RHUx0l9OxdpnCIUGy3TNscTJ4p1cZgYJlW8r0mROmQIE3Fy4GJj3E2nA0h0GDL1Rfj2HdV/UkU/w7WJxqMeyTtHH1FFFz2fg2cnaf3Xyu+sHfq7tTQ+F+LfJQObJ9pQbaIcO/7nbJa89pExX0O16hHVMZY20WPvey9kzroMat3Qr+v2285h2eseHtN5xMSYCu8T7qIFbLl2Pkvfv37MdQEoa6t7//d///d/6e7u5pRTTmHfvn3ceOON7Nmzh8cff5yf//znvPnNb+4XDQOsXr2aF73oRXz2s58dtM7BIugFCxbwIu//HZ/8tTSJoVdP+hDT59fsedyThqREOTpOUaJUPN5twP5+x/Z93HMeawiJ+F3wQzo6OmiUsTTjZtg2gROPmxwt7aA8FzugnZZDeX48nrJ0/tAG/J47pD1MgKHaxEX89YhJonVdHaYK6zCXU4+0iYkzljbRQyUS2CAEM/T0lbG2H2kTE2cqvE+gFDqVwmSzQxappE1U/Y7c5Zdf3vvzWWedxZo1a1i0aBE/+MEPSKVGN9cjkUiQGGTgnw2KWDVIHDrKD/GeO5ljiWytdK1OiOHbxBhvj5sIWxjdnEPJGzZ5hmoT5ajKm3MV6xHVMZY20aOcL3TyuteOqfA+gbXDBnGVGveVHZqbm1m5ciXbtm2jtbWVYrFIe3t7vzL79+8fdEydEEIIIYQY2rgHct3d3Wzfvp05c+Zw3nnn4Xke99xzT+/+zZs3s3PnTtauXVtx3SqRiKfpen4p7Yh77OdEAp1OH9vfU7anTN9j+m4brM6+9fbs6/tvQB1i8jjNjXGKESGmIF1Xh9MsXWcnM3fe3Mm+BDHB3Pnzxrf+alf43ve+l5e//OUsWrSIvXv38rGPfQzHcXjta19LU1MTb33rW7n++utpaWmhsbGRd77znaxdu3bIiQ7DUcsWoXEhMqgwgmKAbapH5QqY+iRhYxLvYDdYi/U9VDFAFYrYdBKUQuWPdYNZR4PnYj0HFRooBqhsHjw3Pr4+jcrmsf6xHHVoDY5G5QqgNdbR6KgAksx90hy95BQaOly8Xz842ZcixHHyf3k6mYYAyssqIE4wKpHgqfcvZMU/Vi8ZrJj6nvyneaz8+73jlpKm6oHc7t27ee1rX8vhw4eZOXMmL3jBC7j//vuZOXMmAF/60pfQWnPFFVdQKBS49NJL+drXvja6kz23G9wUpJLx4HLtwKGjcZDW0Yl/0MeGEWiFdl1sVzfWc6GzO56k4HnxcWEYT5BQCrI5KCUGtNaiotJ4q6MdcRDnONAzZsJYSMVBoY0MBEUYv+QWogyNP3ig7EHM46H7/62hbk9+2Blu4uTl3/UAWsbRnpQOvmMtc361jxX/OP4JZcX4Onr1WqY/3I555Kmyyg+7WkQVVD2Q+/73vz/s/mQyyS233MItt9wy5nOZXAHjWMjl+88w1Sq+a+Y4x2aYahUvx9WzsoPSg85etVGECkrBWN8ZsFEEOX1se49cvl89Rt6kT2rN63djczlZnkkI0U/rb9owbQcm+zJEFcy8dw/2SPtkX0avml5rFRNh7TB3wAaZvWqHmUI+aJkKZ8AOez3ihBfu3jPZlyCEmIKibTsm+xJElYTPDrGu7iQZ98kOQgghhBBifNT0HTln1kycmbPiyQaA7c6ikglwHWzShyBE5QrYYgDNDajIQBD23mWzLU3xmDqAxnpUZLCZLIQhyvfjbtUogmQiPk4pbC6HqkuDsdh0EpUvxOWyOWwQYIng0GQ9IwKlRndMuYNQhyu7+kz2XtTA3M+vl3UWa10lbWI05cXUU85rWCqz/XvnsuyqMpfikrZRG0b47Hjmc2tZ+ZU+63SP03tE7yohSpWd1LamA7ktn5yLk2tEF+NfOGow0BDgtCVIr2ync+803OYiFjBFB7TF2ZfA+BaTjkjt9ihMm4b1LGhwp+cIumbSOLObzrYGVFHhzChgIoXemwQFYUOEf9jBySty80N0fYCfCFGqnjDUFNos/ONkPzMnr0NvWUXjUZ/0TzeUd4BS7P7R6Sz6+4NgLNHBg0MW1Q0NbPn68qHX2nzwSeY/6vH0v53PaR95jmi/jIepRfqsU9l9o2buK58s+5i2d62l5cki/q9ktnSt2nHbWSx782ZMPj/ofud5p7D1jS0s/cB6Vrx9G2bQUsc78vMVzLw+Itoi6Qymsp7Pjrqfb0IvW0y0eVu//cs//ghhLtf7ePt/n8OKa7aUlSR4xM+OPlb83XYMsPNDq+DTPyvr2ms6kFv5oV24TjKefGAtyvexQWmyQRgyP5UC18UWiyitsfVpOHgYHOdYWaVR6SQUS8dpjc3mmEdbPIkhCOOZqcUAG4aoUtSu6tKY7gyqNMOVML5jF9qQ3ZPwXIjYjG9trGzWqrXMv+IJsi9bhQot/q+GDuRMV9fwf4gmwuQjVl7zgEx2qGE7rmhhyWv/XPYHNUDrlypfl1dMLUte+8iwr3n0xGaWfiD+2XR1lV3vrLd1sut1S5nzRQnkprKezw49vYXnXjWL+Tf1D+QGrsSw7KqHyn6PGPGzY0BZgIWf3sgzZdZf04FcdPgIargP7faO6pyos3PobQP+oCOZtVqTEr+QRe5FbNHH1lUUxAkxnHBfG3O+2DbZlyHKFB0+wvybauuLWU0HcmgH5cS/gjUWpQf0cSt9LIVIKQ2JjaJj5VSfuR49KUV6jhmqzt7itlRcHSunNMpYSSVXo5yZMzFHj/YueC9OIkrhzp5F2LZ/3E/ltEyDI+N+GjFVaAdnesuwwzbE1ONMb8F0Z8paa3ey1XQg5y6ah6pvQmfzWK2wyQSqGMQDCn0P62pUaCi01uN1FlFBhO7OxeWCEJtwsX68coMasEi66ulqdR2s1qjSIEWrFKpQ7J04YRNePAki4WM9B93ZAdsGXqmY6pznncJT/9jI6f+cmnJTy8X4c5qb2fyepSx73+gDucLLVpG8+9ER3/j3XLUSvjLq04ga485t5Zm/XcTCj0sgV0v2vOFU5tzbAQ89MdmXMqKaDuTMgUM47VmiTA5dl0IBJpePZ5r23G3zXBIH6qBQwFqLLS2vZYrF3rFy8QYTj48rFlGOgzUGPK83sbA1BuXFy4HZKMKWZqDYIEQlE/HYuSjChrnBL1ZMaVFDglP+PS9B3EkqOnqUZe9bP6Y6sjNcUo4z4kSz1q9s4OkxnUnUknD3HhZ+XPJL1prWm9eVO2l00tV0IBc8fwXKeOhcSHZOGhVZrKPQocU4CjSk9mToXlyPmzVYBU7RYByFjiy6EOFkikRpHydbJN9ah9cZoCKD8R2itIvXXsB6DvmZPrpgcYpxPTqy6KKh2OzhZiMiX+N3FMk1WPj1ZD8zomL3PzriH61uaGDL15az/A1lph0QU9b2285hxVueHnKG4mhM++56dv3kecx71dT/Bi9AJ5Ojfv2d5iaevnk5K960aWzXkE4fN4heTB3KdXn2ttNY9DePjame8X6dazqQczc+jTYalCb5OMcvzWUNxlhSjwLWxHff+i7JZQ3WcdBRhAlDkptLa7Y6Dl4qidMdTytWSpMu1W1LxyvfRylFyvNQSsUvktKkvFqJ4UWlTFcXy69+dLIvQ1TB8jc+jhmHsZDz/2ZzzXyLP9lt+cw5nPrZZwn3VT4RIWrvYMVbHh7zNWz/9nKWXCnvKVOVDUMWv+6pMf9Nb/uPlSy96pFxyydY04GcLRSwg81aHeINetCxK33K9n47C0OiEca52EIhfnEHfKMzRZm1ekIrY4k3MfWN14QWmShTO5a/6/6xzUurwnuBBHFTXzX+ppe+7uGxX8gwZIkuIYQQYjCjWSlmKp5DjE6NvDY1fUfOmdaMLlp0YwM2n+9dUssWgzhRr7XxzNJSdylBAJ6H8kszTQtFgPixdrD5PMqNnxJT6lbVjfUA8dJdjoNKJeOTRwZbKKBct3cCBVrjuFZSCwghRI1zZkznqc8tYeVbxm+1Dnf+PJ780DyWvuNP43YOMXo7/udMlr1pS1XH0o6Hmg7kmNaE8lLxqgz1aUj4qEwOFYREs6ahu7KgFMraOF2ItdhUIl5/NZdHNzeBMdh0ErRGuS3xSg7GoGe2xClKHI0KI+y8WahsIa4vV4iDvrmzIeGDq9Fd8WxVU8hIIDfFHf7btUz/j7HNUByKecE5eIczRE9tHZf6Re048pa1tNx6v6yzWaOiQ4dZ+ZbDvY+d2bPovmAxqTs2Vu0c4e49rPz7PZJ6dIpacuWjk5IcXJ9xKjZtYcMdZZWv6UBORRFKRRAZFGB1CGEEUYQKIlQYHVuothTIxftNPCkiDOMccmGEdWzvz3EqkrisKh3Tr76+x+kQZeM7gUBcv5jSvOz4fbDqYiRtQADg5iSAO6FEEU5e1vwQ408FIbqC4fY1HciFz+2GoZboats//pH04eNvvYWyRNeU13jb/eNX+cbHZJ1VAUDj/4xjOxMTLjp0GP9Xh0cuKMQYRZu3YSuIJWSygxBCCCFEjZJATgghhBCiRtV2IKfU+P0bbf2i5uhkcrIvQQgxgZTrgnYm5Fw6nZ6Q84jxNxGv5WjOUdNj5JzlS3BwwXMJm9O4Hbl4ZqrjxJMUCsV4VinEs1E9F5PycA53xelHtEJF8axVW5p5Gk2rwznSDcUAM60RHIXuymGTPlZrdDaPaUihOzKY+jRosJ6DzhZRuQJku2D0626LiaYU27596rgnbBRCTB2Hr3o+jUc9kj+v3gzUoTxz63IWv0YS/54IJuK1HM05ajqQi7Y+gypNdlBQ9iDzoaZ6m4H79+ztt73vzwMnUvScWyY71BhrJYgT4iTT8t2NuENNlKsyCeJOHBPxWo7mHLXdtSqEEEIIcRKr6TtyTnMjjvKxUen+WBT1rrSgHAcbhvFja+PVG6IIG5l4W8+qDNaCMaj6Osjl42MSCdAK09kNWqFTSXAcbC4f55hznHj1CM+Nx1okEmANhCEmzEPX5D4vYnLoujr0tGbC3Xsm+1LEGDnPO4WtV7ew9P3jkzha1DbntBWS9PsE586fhznajslkxv1cY/3sqO07ckpDIoFqnYlubkLPngm+h25sQE1rQs+agUqn4sf1deA46Lo0qr4O3TINlU6hEj66oR6MjctOawZHo5JJnFkz4n2ui0omUQ318bEN9ehUEj1zOrTORPkeyvNQqZQMbD2ZLVtA20sXTvZViCqIntgsQZwY0pa/nT7ZlyDGWdtLF8KSBRNzsjF+dtT0HTlmTSdqbkLnA1QxIGqpRzWksAZwNdZz4skPOp5NqpvqILLxdmN6J0VYgNBgXY3qzkFzA8bVqFwRGutAa0ypLqyFXJFo8Wycznw8aaKxDuu7mIQL+w9O5jMiJolKJNj6hmkse598+NeyQ9esZeamTuymJyb7UsQUtuw9kuz5RGdcBc7EZKIwjz7NjDEMv6vpQM4+txtnz2GIIqLIoA4ejrs+IV47tVRO9aQFiaI4aNM67k7VfW5IGhMHbFHUW96U1khUSvUe07Nd7427cIG461YptNYExdw4/9ZiKrLFIqd8ba+smVjjZt+xHdvVjSyuJcTJbe5PtmPaOyb7MspScdfqH/7wB17+8pczd+5clFL87Gc/67ffWstHP/pR5syZQyqV4uKLL2br1v5jCY4cOcJVV11FY2Mjzc3NvPWtb6W7u7viizf5AiaTweTz2KCIyWYx+TymUIh/zuXi/zOZ3nImnz9Wrm+Z0mNbKPSWs4XCscc9ZUrb+9bXt4wNZdbqSclawh3PTfZViDGK9h/AZLOTfRlCiEkWtu3H5POTfRllqTiQy2QynH322dxyyy2D7v/c5z7Hl7/8Zb7xjW+wYcMG6urquPTSS8n3eUKuuuoqnnjiCX7zm99w55138oc//IFrrrlm9L/FQKU7ab3/l1O22ucWQgghhBhnFXetXn755Vx++eWD7rPWcvPNN/PhD3+Yv/7rvwbgP//zP5k9ezY/+9nPuPLKK3nqqae46667eOCBBzj//PMB+MpXvsJLX/pSvvCFLzB37twx/DpCCCGEECePqo6R27FjB21tbVx88cW925qamlizZg3r16/nyiuvZP369TQ3N/cGcQAXX3wxWms2bNjAK1/5yuPqLRQKFAqF3sednZ3VvGxRg6RNiIGkTYiBpE2IgU7ENlHV9CNtbW0AzJ49u9/22bNn9+5ra2tj1qxZ/fa7rktLS0tvmYFuuukmmpqaev8tWDBBU4LFlCVtQgwkbUIMJG1CDHQitomayCN3ww030NHR0ftv165dk31JYpJJmxADSZsQA0mbEAOdiG2iql2rra2tAOzfv585c+b0bt+/fz/nnHNOb5kDBw70Oy4MQ44cOdJ7/ECJRIJEIlHNSxU1TtqEGEjahBhI2oQY6ERsE1W9I7dkyRJaW1u55557erd1dnayYcMG1q5dC8DatWtpb29n06ZNvWV++9vfYoxhzZo11bycwakyEvyVU0YIIYQQYpJVfEeuu7ubbdu29T7esWMHDz/8MC0tLSxcuJB3vetdfOpTn2LFihUsWbKEj3zkI8ydO5dXvOIVAJx22mlcdtllvO1tb+Mb3/gGQRBw3XXXceWVV07MjFVJDyKEEEKIE0TFgdyDDz7Ii170ot7H119/PQBXX3013/nOd3j/+99PJpPhmmuuob29nRe84AXcddddJJPJ3mO+973vcd111/GSl7wErTVXXHEFX/7yl6vw61SJBHtCCCGEqAEVB3IXXXQRdphARynFJz7xCT7xiU8MWaalpYXbbrut0lMfx645g7C+HmUsylp0LozXUQWsq4g8jZsNUaEBrTCeQ5h2cIoGJxMQ1Xk4uTBeV9VYdGAIGn2cXLzQkvU0RBZl4/qMo3FyITo8Vs46GqxFRRa0IlJF+OMdY/7dRPU5p61AFQLCZ56t7LgVS0Fros3bRiyrzzoV3ZEhfK72B9CeTFQiQfEvz8C7e9PIhQehzzkdfaiDcPeeKl+ZmEjO9BbClQtQ6x8ZtpzyfIovOgvv1w+O6Xz5/7ua5J0bx1SHqJ7oRc/H2/D0qFZ3qcZrGb7kPPw/PVHxihI1vdZqZl4KM81HRaAM+N2GKKHAgvEgTCkSHR46tFgFYVIR1Ct0EZIdHoUGjd/tESUUKgKnaMm1aBJdHlZB5Ct0ZFEGjBs/9rtcdAi56ZpEp0fkxefWocU6iiIyvm6qCmbV42RDeKay48IZDaAVavPIZQuz6kgoBbJaV01RrkvnEp/pozw+31pHKohgd1UvS0wwlU6TmZ+kfqRyjqZjiceMMZ6vfbnL4FP8xGToXJRgxkMejGKVvmq8lh2LfWZu9OBkCuQafv4ILg7K9zH5OMGf8lxsEKK0whqLchxsFKF0KcBSGqwBoN73sUEY73fiO3l1WqEcB5MvHF9Hn7rTpe29rEG5LkGQm9DnQPSnXBeiwffpex8acjF05brYcPAl70f8du662CgCa/Hu3oSp4HrFxOv7evUwmQzT/319v3Ltb1iLE1gavn//iHX6v/4zkZVXvtYoz8cGxd7H4a7d1O8aORo3+Twzv71pyPeTcrXevG6MNYhqmvad9UN9fIxosNdyuM+VwUz/1vrezw/lulDmoTUdyB2+6hyoS5HoMCgD+Wma5FGDdaBYr3BzECVBl9axD+oUxgM3Z/G7LMV6RZRSJA9bCs2lQM+C8aFhZ0Tkx9vy0zXJI4bIU+ieJ1ZBbqZCGXAzFi9rCeoUuWQBbv7xhD8XIrbzveex5LN/rugY5/SVbHv9dJZ8aP3IhQex42OrWHr7UczjT4/qeDGxdn5gNQvu6Yb7Hx22XPP3yu8maXvnGqY/VRxzV5uYWDv/ZyULXv14xcc5zU089cUVrHyrvN5icM6KpWx922yWvn90nys733sefKa8WKKmA7mW72zEVV7v48ZxOk/TENubB9kW2oAyeuDEOFnwmQ3Qp02UI3pyC0s+NPpzLv7IerkLV0MWfLrMuyCm/O/mrf8qd1Zq0WiCOICovUOCODGsaOszLH1/heN4+ljwmQ1sL7NsTQdyztJFuNYlmt6A7syB72Fdje7MErXUYz0HpyNH1JDE6S6gMjlsMoHKF8BxIJfHtjRhPQfd3o2pT6OCEByNyuaxnotN+ejuPKYxjW7vjnPMWRv/0xqb9DFpH+doJt5mCvDsZD8zYrIcectaGnYWRz1oXggxMZ75zFpW3vwMYdv+CT2vOv8M9v1lI61fkuC/1jjTprH5I6ew/PqRh1tMpJoO5GzbAWyiDvbtx/o+qhRkGUB3dsWFghAdhpgoAhOPaFCeC46DUgrbnUEpRZTLx2PgVGmMXLGISiZQSkNdGrbvimeoKh33eQcBKpUCQDsa050Bx8FWdjNInGBm3P4oNgzHPHZGCDG+Vnx+M+GRo+N+ngN3nMqsv+4z7OKRLczbkhz1WCwxeaL2dk759JaqvXY7PrOWZbcdxTw6tmE5NR3ImWyOqCdVSLEY3xHruWPWY+BjwIbBoLni+g56RTvHZo60tw9edzGIJ0IExd7VICIbVOV3E7XJZDKTfQlCiDJEh49MyHn6BXHEnzNR388aUTusrWq7WfLB6gzLqelArp+eAGtggDZYzrtyEv72HR8zVN0mwvaUG6qMEEIIIcQ4qelArutvVpHK+QR1mtx0jZe1qAgad+bpmh8vihvUKXQAXtbi5g06tBhPYRyFshAmFDqC3HRF8micb65v3rhkuyFIK1CQPBxhHYWbjcjN9Ep56uJZspGvcIqWgi7A7ZIQuJY4zzuFrVe3jHp2UQ974dnsuriOhZ9YB0rhNDUSHj1UpasU48mZMZ2nPr+YlW+ubGyjbmhg678tY9nrHh683mnTiI6Of/edGD+7P3Qhc/+UQ9/7UMXHbv3OeZz6nh0TdvdPVJ8+53S2v6aJJTeM7fNhPNV0INd05+M4oSalFU1KYcMQ5bqYYkCz56Ib6jEd8Vg5G0Vo34vHtzkOGNubFw6taHRdTDYb54ZznGM54pTCFkvdpVpBFIHS+I7GFAN0Khmv7OC62GKRlJaRD7UmemIzS98/9nrUukdYWBq/7LbOZsu7lrDw/X8Ye8Vi3EWHDrPyzYcrPs50dQ0ZxOlkkqc+u5yV1zwwxqsTk2n+P49+UsKKN22SsXA1zjz8JEsenuyrGF5NB3Imm0MrLw62SmPYepLv2UJEVCj0L58v/Un1lOkzTsGWytowhKEGq2unt8u1ZyjcwDFRRsbICSDc18bSD7SVm89RnIBMPi9BnBBi3OnJvoCqmKjxaRXklRJCCCGEGG8nRiAnhBBCCHESqumu1dz/PQ/fxpMasFBsdHDzBqdgUaEhrHewWuHkDVFCE/kKt2BIHA0I6l3ClEYHFhT4HSFRwilNXNAoY3EzEVEqHisXpDXKgtcdESU0ylpUqd9MBwaUotDsoI9k4Fcy2aFmKMWBv1/LrFvKHwcTXHI+yd2dRE9uGbKM09zE4ZefTv1/yhi5WnPomrXMvHVT/3REQ1CJBAevfj4zvjl1B0KLypgXnIOTC7CbnqjswAvOivOQjrA2s5iaor88G787HhM3Ggeuu5BZX618POWBay9k1tfWj6lHsaYDueTBAn6fX97LuqiiQQcRRBY364JS6GKE8R2Mp9HFCKezgM55eL6DiuJAzskUcb048LNePBlC50NsIg7k/NL/TjbE+E48wSE0oBUqiOJZinkf25mflOdCjJK1NOypbCSbfziHyuSGrzYIqdsnuaJqUcOeEGyZ2Z2iqOL2I6Y272gOikHFkxSco1nQSiY31CjvaA6ds6PO61a/Z3SvfMPusb9/1HQgpzY8ju2zrmZPP3FPaKf6PFZAaR5q7wvluG7v5Ii+L17f4warW9FfTzmHeK1VUVtSPyt/cXQAu+mJEScxmEwG7+5NMtmhBiV+8UDZK3PYMCTxC5nQcCKJnhjdatnR5m1VvhIxkczjWwgrXKe7r/RPN4zquNQdlX3+DOakHiPXE8QJIYQQQtSikzqQE0IIIYSoZRLICSGEEEJMEqe5aUzH13Ygpx2U56MSifjnRALl+b3be7f1+YdS6HQ63t9Th+ui6+pQno+uq0Mnk3EZ1+0t23MOlDpWl3bQ6XRcPpmM61MDR9AJIYQQQhxPJ5M89fmVY6qjpic7YKIBqzMcmzXSs5h93229h2Wz/eswx8bLDUw5MNg4OttnxYh+dcH4JyUWQgghxAnB5POsfNvYJkzV9h05IYQQQoiTWE3fkdN1aTQeNopQSoHjxIvaax13fZZyQdkg7N3eW2Ygx4Eg6P84irDWxnV7HhiDLQZxvY4TbweU72OjCKxFE0Dm+OrF1ObOaQVrCdv2T/aliHHkzJiOSqUId+0e3/OsWIrdu/+4tZhF7dLpNGr+HKIt2yf7UsQkcqa3oOrrCJ/bNdmX0qumAzk1ZzY60thcHpVKYj0Xlc2D7xG11McJe5VCd2SgGIDnYtNJVK7UNdpnjVabTqI6M71j3GwqgSoGUCiC62Ib0hBGqM5uKBTA81G+B0phWhpQ+QAVhCgCeGaSnhAxatmzF6BCgyeB3AktXDmfXGuS9DgHcvtfNJvW30SYHRLInSj0rBnse/EsZlYpkGt/41pafvo4pqurKvWJiWGWzqNrcZp6CeSqI3pmJ4p4lQWU6j8+bcexRL1DZmoeeMxQ+/v+D8cfs6e0XWmiSFZ2qEX+XZLU9WSg1j1CegLOM+Ob6yUZ9AkmfHYnM7+xs2r1pQ6G/XuBRE2wDzxG/RT7uKjpQA4TgSoN8xvNJIORjulzx27Y8r37ZXEWIYQQI0v87wOjXg5KiL5ksoMQQgghRI2qOJD7wx/+wMtf/nLmzp2LUoqf/exn/fa/6U1vQinV799ll13Wr8yRI0e46qqraGxspLm5mbe+9a10d3eP6RcRQgghhDjZVNy1mslkOPvss3nLW97Cq171qkHLXHbZZdx66629jxOJRL/9V111Ffv27eM3v/kNQRDw5je/mWuuuYbbbrutomtRZ59G1NKI21UApbBaoQshYXMS92gOVQgJp9fhdBewnoMqRNiki+7KYxqS6GyRsDmFezjT+9j6LlHKwz3cjU35qCAiaizt8xxUaLBao6II6zgA6K4saI31PbQtwOMVPqlCiElXuHwVR0/xaL153bieZ+c/rYZP3zGu5xDjL3zJeRw4N8HcL4xvexFTw9avrOG0L+4jfLZ64ySrpeJA7vLLL+fyyy8ftkwikaC1tXXQfU899RR33XUXDzzwAOeffz4AX/nKV3jpS1/KF77wBebOnVv2tdhHnsJVHn1Hrhni24w9Yw9Un597ykV9/lcDHjNgW996+9bR95x9yxorg1eFqEWJ/32A1rvGf2WWhf/8gExsPwG492xi7m9lJZ+TxYp/2Eg4RRP+j8tkh9///vfMmjWLadOm8eIXv5hPfepTTJ8+HYD169fT3NzcG8QBXHzxxWit2bBhA6985SuPq69QKFDos5pCZ2fn2C9yuBmrfZfZ6ltm4CzWgdugf4Qnxs24tAlR06rSJibijXqKfhiciMb9fUJey5oz6jYxhV/rqgdyl112Ga961atYsmQJ27dv50Mf+hCXX34569evx3Ec2tramDVrVv+LcF1aWlpoa2sbtM6bbrqJG2+88bjtwYvOwc07qMgS1nm43UXCBh+rFW5XEbRCFSKCaUmUtajAoEzPDFMwibirVIcGFUTkZ6WxjiJxNF6my/gaZWxcX3sBk/binHNagaNwOouYtIfTXaA4I42TDXGOdsBT1X1OxfGGahMA2750Aad+7lnCfYO3p0ENlVpG1Izh2kTFtBPPih8Hu9+3Bj4vXasToaptYpTcRQvYfN18lr3/fnl/mQJGahPO7Fk8/ZElrLhuwwRe1fEqeZ+o+qzVK6+8kr/6q7/izDPP5BWveAV33nknDzzwAL///e9HXecNN9xAR0dH779du44l4jMJB+M7BPUu+VkpIl+jCxFhvU+xyacwK0WU0uiiwboak3AIGn1M0kEXI8J6j/zMJEFzEh1Z3FyEdeO7bLpo0LkQ4yiK05NYrSg2+xjfQQWG7KI6Ci0+UZ2PLkRYVxM2JavwLIqRDNcmVv7To0St08uuS59zOkffeAGdr10zQkEHfcapFV2nu2RhReXF6A3XJsrlLl6IM20au35wWtnHOI2NuIvLf50XfuXhiq9LjE65bcJdsgjd0FB+xRW8F4Q7dzP9MTjy5gv6bXdOX4lyazsDWC0aqU0orbF1lWWBdFYuQyfH9tnvzp+HM72l93El7xPj3oqWLl3KjBkz2LZtGy95yUtobW3lwIED/cqEYciRI0eGHFeXSCSOmzABsPciH51IEjRFuF0OxreoCJy8h3UhmF1EZVycbo2b9wjqDW5WgVUY38VqUBbCtMHr8ImSYB2LqY9I7/AImixehyK7IETVh7i7k6gIitMjvE6foCWESOF2polSBievcfYruH9cnkrRx1BtAsBks+x4TSNLHjp+X9eVF9D8q81ER4/GG5Ri+980seRD60c8p/Y9nr2ihYWDTGY5dM1aZvz78d+4D/yfVtgxYtWiCoZrE+U69MJ5tDzSzoJXH3uRD759LTO/MXT7sEvmcfisZprLHARt8oWRC4mqGKpNmLVnorNgHn0agAMvmsvM+xPwZHmrLOhUkude0cKCQd4LlOdz+A3n0fLtUpuxlub/PL797PyrGSz8t4PH3ovEhBjpfSLc18bKNw/em6PTaY68+uzjXs+9l81m3o9zmD17R31dHRfMJ703j1p3BH32aRRTFkb+WAImIJDbvXs3hw8fZs6cOQCsXbuW9vZ2Nm3axHnnnQfAb3/7W4wxrFkzwh2RAZZ+dz+uH+dpV0GIdTQqLHWHFANsfRqiCJUvYpM+tj6FyhVR+cKxrjSlsK4TH19acgutUN25eL+jsekkJuHhdByBIMS0NMTLflmLTSbAWlShiPU9omKWrWN/2sQYLfng4H8BiaMhNuzzbcvasoI4AJPPs/DGwWeopY4Mntqz5Tsby6pbTA3N/7n+uCStqcPDp201jzxF8yPjd02i+txMgMof+9LV8u31x01wG47JZFjwqSFmq1pD6sjItc37zLqKzimmAGNIDvLazv7yujGv5FL3o2NduSpbwDXlT6SpOJDr7u5m27ZtvY937NjBww8/TEtLCy0tLdx4441cccUVtLa2sn37dt7//vezfPlyLr30UgBOO+00LrvsMt72trfxjW98gyAIuO6667jyyisrmrEKED3zHEp5lf4K5RlkMkTvC7Vr6GW/Qpm1OqX5v3pwXLKp9/0jFCeW+h/Ka3uiMY8+TTROnx02DEn9TL7AnYhMPk/yzvF/baOtz1SUAaPiMXIPPvgg5557Lueeey4A119/Peeeey4f/ehHcRyHRx99lL/6q79i5cqVvPWtb+W8887jj3/8Y79bmd/73vc49dRTeclLXsJLX/pSXvCCF/DNb36z0ksZXzIoVQghhBBTXMV35C666CLsMEHOr371qxHraGlpqTj5rxBCCCGE6K+mp8zs/sAaHC+JSVi8bkWYBBWBdaCwLA8dHroQz2io36kpNkKUtFgH3KwiSto475sCr1NRmG6xCtAWr1P35oSL0harwT+qcIqQn24JGw3+YYfijAgM+EeceOJElINPSGqBqeSZ285h+VuexuTzFR239bvP59R3biMqM8+QvfBsdr+4buixM6J2KMWht12A321pvG10s5d2/egMFvzNU+OWxkSM3qG3rqbxqE/6p5V1mx+9ei1OYGn++ROYrvImRvSlk0m2fftUlr7u4YqPFeNr54fWsPSmP1d8XE+bGO37BIz9s6OmA7lFdxzGK1jQOu4KDUJsXQqi+I3T1qdQQYR1FCof9zebpjRWgS6ERHU+TnehdzkI3Z3HNKZRhQDCCNOYQhUidDYPxQAcHS/F5TqorgykU/E5Ex4qV8CmkwRJJVnbp5ilr38MM4oP0xVvfoSoguPUukdYsF4yvZ8InFOX070AFn909OPjJIibumZ8+wHcUXz8TfvP+MN66/fOZtkogjGTz7P09Y9VfJwYfwtv2shoQqKeNjEWY/3sqOlALnp626gnOxj6L98Fg09gsENsH7Jemeww9Yz2w3Q0x8nYyhNC9NRWFn9kjPPPJYibuqyNPwBGcxyMKojrJe1iahpjm6jK+Uep6gmBhRBCCCHExDhxAjlVRiitnYk9nxDi5KVUxSuBCCFEpWo7kNNO7xInynH6Pe6nFHTpVLL/tr7BWM/PPXUo1e9n5brHAkGl4vP1PUWfY4QQQvk+z7xm2mRfhhDiBFfTY+QwEdbGaXp7svXbQQe6xX3PJpM5bttxj010rA577OeBqwH0e9x3v5XxD0IIsIUCiz9S5ho7QggxSrV9R26iSDeqEEIIIaYgCeTKITMRhRBCCDEFSSAnhBBCCFGjanqMnPJ8tJ8CwEb9x6YppbCRAa3ADLijpktdpcaiSkl+Maa3vFIKHKd33Jvq6Vrtu81xsMGxcXLK0VhrUVZDYRx+WTFqOp3GZLMVHaM8P25TFeR8Gs15xPhTiQQUK8kGOYbXUil0IlHxKiJiYinPR+EcN9Z59BXK634yUYlE/Pk/hpyAPRMzq9EGazqQa7vmXMLWBF6nwvhgfFBhvEyXMuBmIT/TkjgcB2LWATdnyc1UWAeSh6HYCMaPl+1KHlIUG8HNQGGGpW6nwilaoqQiMzcOBhueg9xMRZSyJA8pdACRH5/HzSrozMPNP5jMp0UMsPlrp7Hy7x7HFsqPsPdddz4zH8rj/L68JVt0Msnmr53GijdtGuVVivGy6x/OYfEXKlh6Rym2/sfKUSV9dRfOZ/N181n2PpnkMJUdft05NB71SP58Y1Xqc5YtZtvftrLkg/K6nwz2/MN5zFmXRf3p4VHX0f3X51Gs10z77tjbTE0HcrNv2YA7ypUdxktoAzZP9kWIfla8aROVjnJs/VJla96ZfF6CuClq/uc3QCXvE9aOOnN/+Nwulr1v16iOFROn5bsbq/rZEW3bwZIP7qhafWJqm/v5sa+nXffjDdRV4VrgRBsjN9js0sFyxY21/sHqkfxxQgghhChXlTJi1PQdOXfhPJxkPSpfBGPifxCPeXMdiAw2COIxbkpBwocwwnZ3o+rqsMUA5TrgutjuDKqpIT4mlUB1dmObGlDZeMyDTfrgOqjODDYMUZ6HLRRR6WTvGDzb1YXVBg5P1jMipgJn5TLMM89Vb/yNEGLKcRobUQ31hHv2AtBx1QUYV1Wlq0xMDmfFUsyOnRP23r3jny9g2f8cxTz69JjqqelAzhw4hDLtACjP7Z3woHwfogiVSPQOWFZOvEpD1NWFTiSw+QLK94k6C/HEhSiC7gwqmYDDESaKUJksKBVPYkgmsfk81hjQGlPswAYhustD+fHAeJPNYn3JOXeye/b/zWbx144QHT062ZcihBgn5pRFHD21nub/igO5pu/dP8lXJMbquVe3sug/uogOHpyQ8y25YT2VTcMaXG0HcvkCWsVPgw2Kvdt7B7X3mXVm+x1XmllU+r/vvkHrAejqGuIaot564sfFQcuJk8eCT69D1vcQ4sRmH3iM5gcm+ypENc2/qTbfu2s6kEM7KOf4X8Ea27sWqo2i+Gdr4u1agdL91/Lqeax0XF4rbJ+UJUqrfmV7ygysxxqLUhakR23KcVtnE7btn5BzOTNnEh06JImka5hyXXRTI9HhI5N9KWKKcWZMJzrSPqbUE2Jq08lkqceuc7IvpSw1Hci5C+ag/XT8wHHiHHD5IgQhprkBNDhHuzFN9ehsHqIIW5fCao0qFFFBiE344Oh4/dSEh3OoA1uXisfGlXLQ2XQy/lBWCuu5OF2ZuB7fRWXyqMhgHY3qzoJn4bnJfV7EANrhyY8vYuXbJyaQ2/re5az4vCE6JIMla5VeuojnXj2b+f889tlp4sSy49pTWPrd3YTP7pzsSxHjpPDCM+ie6zHtO7Ux3rGmA7nwud1DpxXYHf9nAHZRdj90OeWGKxPaoMwziQljIla+vTr5osqx9APra/L2vDgm2rKd+f+8fbIvQ0xBC29cJ50uJzjv1w8ybbIvogInVvqRcg2VRqRndutgZUeqS4gSnUxO9iUIIcaZ/J2fWJTrTngaMZVIVCWGqOk7ck7LNBw/DYUCuC4oHS+55bpxN2ouB55/rIs0m0U31EMqCbk8pJLY9s54hmtDfdyFqjUc6QBr4hc24WPzBcjlj423cxxUwsfm86hpzdhsrjcdCT69dwPFyWnzF8/m1E/sINp/YLIvRQgxDpzmJp76/EpWvk1mO5woDl/1/Kqu9lGOZz90Hkt+eATz+EmcfiQ6chSluis6xmQyg+8Y7aDG9o5+D6VrVay4doN0rQpxAovaOySIO8FUe7WPciz62LqqpB85ObtWhRBCCCFOABLICSGEEELUKAnkhBBCCCFqlARyQgghhBA1qqYnO+izTsXJGUj4qGyeaEYjqhCgj3Rhmhsw9T5OZx6rNbgaQoMyBus56I4MRAYcjamPkwpHTUncQ91Yz8WkPXQ+wJZWiIjqfby2DnAdTF0C51AnWEswtwX3SAabcFFBRJSw8NAdk/m0iFHQ6bgNmD7LugkhTkw7P7yapZ9+aLIvQ9SoXf90IfPuy6HvnRptqKJA7qabbuInP/kJTz/9NKlUigsvvJDPfvaznHLKKb1l8vk873nPe/j+979PoVDg0ksv5Wtf+xqzZ8/uLbNz507e8Y538Lvf/Y76+nquvvpqbrrpJly3wrhy23OQqAPXJWrvQO0/iKqrw3R1QUcnju/FqUO0jlOM+B4kEijA5korNzgOHDwMWuMYg2pugkwGR8U3K5XrQqGA09iA6eiMl+4pLfeFVrhHO8D3UGEIxqKVzFqtRZ3/9yx0aEn/ZMNkX4oQYpwt/NTGoZPJCzGCBZ+eWiu+VNS1eu+993Lttddy//3385vf/IYgCLjkkkvI9Enp8e53v5uf//zn/PCHP+Tee+9l7969vOpVr+rdH0URL3vZyygWi6xbt47vfve7fOc73+GjH/3oqH4BWwwgDFGJBDaKICiifB+MOZbcLwiwxSJRRye2qxvb1Y0pFLCRwXR2QxTF5aMo3l8MsLkcNgyx+Th/nDl0GKUUWIPpzsTH5wtYa+M7e8ZiwxCTyY/q9xCTq/4H90sQJ4QQYtLse8+FOM1NFR9X0S2wu+66q9/j73znO8yaNYtNmzbxwhe+kI6ODr71rW9x22238eIXvxiAW2+9ldNOO43777+fCy64gF//+tc8+eST3H333cyePZtzzjmHT37yk3zgAx/g4x//OL7vl309Jl/EKIsKQrAmDriM7V3I3oZhHJz1bLMWky8cqyCKsFGEjTRKh/Gi92H8PxDfZSvp2YfSccBoLLZUxiodn99YrJE7ckIIIYSozLy7j2IyuYqPG9Nkh46OOBluS0sLAJs2bSIIAi6++OLeMqeeeioLFy5k/fp48dn169dz5pln9utqvfTSS+ns7OSJJ54Y9DyFQoHOzs5+//opBXGUAiog7jI1Ng7AtEK5XtxNak38uDT2TScSKK16y/X831NHb1DnHYt5e45VWh0L7ErX0bNPjK8R28QkcZcuxpk9a7Iv46Q0VduEmDzj2SacGdNxViytWn1iYkzU+4S98OyKjzGPPIUNihUfN+rJDsYY3vWud/EXf/EXnHHGGQC0tbXh+z7Nzc39ys6ePZu2trbeMn2DuJ79PfsGc9NNN3HjjTcetz1/yTk4qSQqAq87JKh3UcYSJTTGVThFgwohqNMoCzq0qMiiDBhXUWzQ6NCS6IjQBUOUdAjqNIn2EJSi0OTgd0dgwTqKKKGIfIXfZcBCUK8xLugAooQidSgkKuTh7h+P9mkVZRqqTYT/5xy8DNhNg38pKFfhZatIP9NO9NTWio7b9pY5NG+G5v+S5bkm2lBtYjAHrruQ2d/YGN+1HyNn5TIyp0yf0KV9RHkqaRPDOfD3FzL73x/s9yFr582ic2Uj9Vuf6VdWJRLsf+t5zPra1BpHJWLltonsq9bQ+PB+wmeeHdV5dl1cx8IhmkDbuy+k9UvVax+jDuSuvfZaHn/8ce67776qXcxQbrjhBq6//vrex52dnSxYsID0zi7cRIgKIggjPM9FWYt1Ndg4aLOOwnoOKizdqVMKFURYpTD1PjoXxPuCsHdGqu7MgVYkfTfeZy1Yi014WEehCvEdOJtw4okUxIGe7i4S5YdYAkxU1VBtInEgg5M3jPXjObk3i+qs/LVc+v2j6K7MmM8vKjdUmxhM87ag9277WKnOblJ7k1SnNlFNlbSJ4TRvLx7r7SkxjzxF/SODFI6iuLyYksptE3W7stiu0X+eL/zE0IHatC3VHYI1qkDuuuuu48477+QPf/gD8+fP793e2tpKsVikvb293125/fv309ra2ltm48b+31z379/fu28wiUSCRCJx3Hbz5BZMmTOPhnqTHWyds5HWyRyurkjWWp0QQ7WJ6KmtqCrMRrMPPTGqYMw8/nRV1s4TlRuqTQzGv6t662SGbfuhbX/V6hPVU0mbGI7/qwfLDtRtGOL/6sExn1OMj3LbhH3gsXFbMzvxi+qu01vRGDlrLddddx0//elP+e1vf8uSJUv67T/vvPPwPI977rmnd9vmzZvZuXMna9euBWDt2rU89thjHDhwrOvpN7/5DY2NjZx++ulj+V2EEEIIIU4qFd2Ru/baa7ntttu44447aGho6B3T1tTURCqVoqmpibe+9a1cf/31tLS00NjYyDvf+U7Wrl3LBRdcAMAll1zC6aefzhve8AY+97nP0dbWxoc//GGuvfbaqnxzEkIIIYQ4WVQUyH39618H4KKLLuq3/dZbb+VNb3oTAF/60pfQWnPFFVf0Swjcw3Ec7rzzTt7xjnewdu1a6urquPrqq/nEJz4xtt9ECCGEEOIkU1EgZ+3IowSSySS33HILt9xyy5BlFi1axC9/+ctKTi2EEEIIIQao6bVWleuitI/yPWwxQCUT8SoOkYmX49Iamy+gPBcbhPH/URQv19WzHJjWYAymGJTyzbngeccdh+PEKzlEEcpz43xxjgPGxOf2vXh2a7Zz6NkQQogT1t73Xsj8f3ssXiJQCCEmSE0HcjaK4pUUehIC50yfVRzMsTJRdKwM9K7C0L8yg42OreDQ75g+dWEtNiAO8BznuDKUcddSCHHimff7Tmyu8qzsQggxFjUdyMVBk+1N6tk3uWe/RJ826v//wJ/71Rkdi8kGqRcAU8ojZ47VUY3EokKI2mUffHyyL0EIcRIa0xJdQgghhBBi8kggJ4QQQghRo07MQE6p+F/fn3seD9w2cF/P/qGOHexc2hm+jBBCCCFqnm5owJk5c7Ivo5/aHiOnFMrzj002UBrlOPEsU0oTEkozWQFsFE9MUI4DpRmqNownLdgg7J2woFw3nvnqlOJcx8EWCqB0v4kPyvXiGay+h8nlIYogMoOv+yWEEEKImhadtYyOpSma/+vgZF9Kr9oO5KzFBn0WJ7YR1kT9tvXb37OtZ7JCoRD/P3B/zySHEZZNtUExrj/bd+N4rc4mhBBCiMmk/vQwzX+a7Kvo78TsWhVCCCGEOAlIICeEEEIIUaNqumtV16Vx/DSqrq63O1R5HkQRNgjilRca6lCZXJyoU2lUMoENIwiKqGQyLhdFpVUaLCqdwrR3oJIJlOdhrUWlktiOrtI4OYVubMB0Z1C+F5eJDKqhDrI5bK4T2if3eRGTwzllOUfPm0HjbfdP9qUIIcZo50cvZOEn1tX8OcTo7b7hQhZ84cFBh2hV01g/O2o6kLOFIiZQqCCMgzGtsUrFiYJNaeJCoYApBvFkBq1QhUK8rFZkUMXg2GoPJapYxBYKvZMgAGw2hy0W43MApsNigxBbLMZljIHSMaaYn9gnQUwdBw4z7WGNjJIUovbN/2125EI1cA4xevPuzWDDEQbLV8MYPztqO5ALQ6xSw0fL+f6BVd+JDYNOhChNgCAMh1wytd8KEgPOY0eaISFOWNHRo3D06GRfhhCiCvR9D58Q5xCjp9Y9MiHnGetnh4yRE0IIIYSoUSdOICcJeYUQQghxkjlxAjk7VEeoEEIIIcSJ6cQJ5IQQQgghTjISyAkhhBBC1CgJ5IQQQgghapQEckIIIYQQNaqm88h1vXoVOpVEGVCGOKmbAuOAW7DkmzTKgpuzoMBqiDxFst0QJRROwZKbrkm2G6yCIK0xfqm8hUSHIUoqivWaMAWJDttbV5hUBHUKv9MS1CkSnXEdRQrwgzsm+6kRQzj49rW0/ngb0cGDZR8TXfR8rFa4v91U8fk6X7MKbpf2cCLIvHoNDVs6MI8+PdmXIsbBng9cyPx/KS+Lv06n2fP2c5jzL5WtyrD7hguZ/5n1MjlvCup8zSpafvDwiOXUuc8ju7CO1B0bq3LearSJmg7kmp9ox3GTqJ4nwFpQCqsUKoqoT/ooa1FBFK/4AOBqVLYAngtBSF1dEp2P/3Ct72JdjQoiMKAKRXCdeLvnoPIhqhjEqU5cB5N00bkA67uoQpwIOCAc7FLFFDHrwS5sV1dFxyR2HASlRvXKNj/RMYqjxFTU+MQRONQ+2Zchxsnc+7JlZ/G3xSKt6zOjOEdOgrgpqvmx8t6r9d6D1GfyVVvBpxptoqYDueiprSjlgY6X0sJEKDf+lazS2CjCmigOvEpBnnIczIBluYzjxEtyuW68WkRPfdYcW6bLWKw1vfVgLcp1iaIo3lY6xkSyRNdUZh98fMgVO4YSPrdr1Oczj28Z9bFiaome2jrZlyDGkfrTw2WXtWGIWl951n/9x4cqPkZMDPPkFrTyRiwX7T8A+w9U7bzVaBM1Hcj1MscCs77LZx3beOyO3WD7e7b17iuzvn77jKywKYQQQoiJVdOBnPJ8MBrlONigiE4m4+BKaWwYxNvD8Lg7cjgOSilMPh/fhSvdoVO+j/J9iCJssYg1Nr7L5/nYKEJ5LvTczXMcbKGATiYxxQCl465bZS3SuyqEEEKIiVDTgZwNiqC8uPsUMKWF63sCt947ZgPvyIVhb/da37tqtlDAFov9j+k5D2CL5tj2UkBnCoW4XhOf11q5MyeEEEKI0XNmzYQye3BPzPQjqs+vpVR567D2jouzx44bsn51/GOlUL6PTiUru1YhhBBCiD72vnpp2WVPzECu73g1a8ubEVLOMX1nxw782VpsoYDJ5kZ/3UIIIYQ46c3+2oayy1YUyN10002sWrWKhoYGZs2axSte8Qo2b97cr8xFF12EUqrfv7e//e39yuzcuZOXvexlpNNpZs2axfve9z7CwSYVCCGEEEKIIVU0Ru7ee+/l2muvZdWqVYRhyIc+9CEuueQSnnzySerq6nrLve1tb+MTn/hE7+N0Ot37cxRFvOxlL6O1tZV169axb98+3vjGN+J5Hv/8z/9chV9JCCGEEOLkUFEgd9ddd/V7/J3vfIdZs2axadMmXvjCF/ZuT6fTtLa2DlrHr3/9a5588knuvvtuZs+ezTnnnMMnP/lJPvCBD/Dxj38c3/ePO6ZQKFAoFHofd3Z2AqDPWIlpaQYNOhdinfgGo5MpYJIeKjIY3yVKu3hH8nEC33yIMgarSzcjXY3xNFiwvsbtKGCSLlHKxe0qxhMYHEWUcnEyATobYBMOxekp/KMFoqRLlND4HUWMq3GOdsBTlTyrYjSGahPl0uecTnZBPcmfVyc7t/J89vzj+cz9QmWZ3kX1jLVN9OXOn8fBlyxk2nfXV+PSxCSpqE1ohz3vW8O8z5b/N5x91Rrqt3RgHh/dah+7b7iQ+TfJe8ZEKrdNdL3mApr/fIBo6zPD1he96Pmo0FY9R2DX36wqe5WoMY2R6+iIMyG3tLT02/69732PGTNmcMYZZ3DDDTeQzWZ7961fv54zzzyT2bNn92679NJL6ezs5Iknnhj0PDfddBNNTU29/xYsWACAKoS4XQVU0RClPXQQoUNDVJdAF+LALjs3iS5EmJSL25FDRVEcxLkaXQji4Ku7gNsRj22L0h5RqhTflsbBRUkXFVpUZOKgMR/iZOOuYCdbxMlHRGkXHcaBoxh/Q7WJcum2w9RtOTJgozPq67FRROsDOQ793VqKl60adT1i9MbaJvqynV20PNFV3kQpMWUN2yYG/r2biNYNxxK6O9Nb2PK11cPW3/D0UdTBI8OW6bHz4xfiPO+UfttaNxSGKC3GS7nvE01PtcOR9n7bdvzP2ceVSzx7GH/X4apdX885mp4q/4uosnZ0a0MYY/irv/or2tvbue+++3q3f/Ob32TRokXMnTuXRx99lA984AOsXr2an/zkJwBcc801PPfcc/zqV7/qPSabzVJXV8cvf/lLLr/88uPONVgEvWDBAl6y/F24yTpUR3e8o+dX0RocjalPg1NahSE0cTnfwzoam06gckXQGlUMsKkEFANUEGKa6tAdGWzCB89FdceBqM1kUfV18cQGz0VlcuC62PoUBCF4LmExxz3bbqajo4PGxsbRPLWiDEO1iYv4a9wysnMPZvsXL2Dl1/cTbdsx6utSng/W9Ka1CW3A77lD2sMEqHabOHr1WpzA0njb/dW8TGkTE2i4NnH052cw5x/zhDueG/J4nU5j+tyIGAudTPamqxpI2sTEGcv7hK6rw2QqX5qtEj3nqKRNjPr20bXXXsvjjz/eL4iDOFDrceaZZzJnzhxe8pKXsH37dpYtWzaqcyUSCRKJxPE7jnZgC0ehvg7CMP6GFRTBdePgLZOLl9nqWXorDCGrQSvU0bgK5Xnx9qPtoDSmUEB1Z7CuC53dcaBmTZzSxHGwpTqJTJyLzjfQlgFHx8uD5btH9TuKygzZJsZg2XvuH/P6eTYo0vH6C5j208fG/Q9e9FftNiHdqrVvuDYR/HE6tmvzoPt6VCuIg2N5Tt3FC8mcPpvELx+oWt2ifGN5n5iI93TluXS+9gLSt/2x7GNGFchdd9113HnnnfzhD39g/vz5w5Zds2YNANu2bWPZsmW0traycWP/cUn79+8HGHJc3VDCFfOwfgplLFHCIUw7OPkItCLyNdYFXbAE9RovYzCeInG4iHU1YZ2DDiwqskS+JnE4j0m5qMBQaEmgA4ObiVeFiFIOmNKyXI7C6wwwCQc3ExDWebhd8Zg8rCWXiuDuin4NcQLY8vXVrLx2E5iI5NFIFsY+CT3zubWs+OcnidrLW3xbTK65n19X0Rc3Z8VSnnt166jGtOX/72qCOk3D7fdDoYjfEVRch5h8W/5tFSv/rnoB+N73X8iCOw4Qbd7Wu80GYfwZUoGKAjlrLe985zv56U9/yu9//3uWLFky4jEPP/wwAHPmzAFg7dq1fPrTn+bAgQPMmjULgN/85jc0NjZy+umnV3TxzhM78HQCay0OkFAKHCe+Y+aUgi9roNTdBUAx/gPytYr3l5bWspHBcTQo3fuk2DBEORoPjiUZtgYbGVylsNbil/53AIwh5ZqKfgdRfW7rbMIDhyZ0/dvTP72HsHS+uk07CfMy9qUWOdNbsJnssVViKrDySzsIO0Y/wUJMbebZ3Sz6j67e4E8nk6hUiujo0RGPTf/uCZTjEAHhvjbUvrZxvVZRPe78eYS79wBw+if3VnUFzgW3bsUM+OJnMhn8ux6o6DwVBXLXXnstt912G3fccQcNDQ20tcWNsampiVQqxfbt27ntttt46UtfyvTp03n00Ud597vfzQtf+ELOOussAC655BJOP/103vCGN/C5z32OtrY2PvzhD3PttddWfLvz6MtOxzYlURZUCDqCYoMCC27eYlxw85CZo9BhXCZ51BLUgd9pCVOKKKlwMxZlwPgQ1CmUARXFZaIkYCHyFcpadBGUgSgBxlM4RYtxFE7BggbbnYfbKvo1RJVtu3Ypy75qoaEO05TGbhp8Es1guv/mAup/UN6YKKexkdzalfi/erD3Dx1g6z8uZfkXQ6JD1RsAKybGvtecyuwHunCe2UPh7CW4v91U9rFhnw/n6EXPx3/sOWkDNcK84Bz87W39XsOBbFAkOniQ4JLzSW7cSnj6Yo48L830fx+5C76nSy7z6jXU/Xij3LGvEcrzOePne3j43Phx3/f5gSr57OgRHTwIgDunleKyVvR9D4/qOiuatfr1r3+djo4OLrroIubMmdP77/bbbwfA933uvvtuLrnkEk499VTe8573cMUVV/Dzn/+8tw7HcbjzzjtxHIe1a9fy+te/nje+8Y398s6Vq2uBIjtXkZuhyLYq8i2KoB6y8yzFJkWxUdG5RBGlIExBlIqPybco8tM12VZFoQny0xWZuYrsbIXxodgExUboWqQI6hX5GYrCNCg2KopN8ePsXChMh3yLIqyH7BxF9wIoTJNZbpPN71LxWrgJn6j++HQ2w8mX8fp1XXkBrD4THIdi0/HfhZbcsF4+wGvUrK+twz7wGMrz2HmZT3DJ+aOqp9jkorzRTboRE+eZz6wFIGj0IFHee0Wx0QHXRa17ZNggrvd9oo/8tBNzMaUTQfbl52P+8tx+22wYcM/X1g5+gFLsuOnYvnI+O4aU8OM2OEoVd60OZ8GCBdx7770j1rNo0SJ++ctfVnLqQc1dn8OPQoznoCKDLkaEDT5uV5Eo5YEGVTSEDfET5OQirKtQxvbmnXM7chTmNBA0OKT25giaE1itsBqcgkEZG6ceMZagwcM/kkfnA0zaRwVRnG5EK4pNHn57kTDMSxq5Sbbg5wcxHV3YQ4cr+qYSz1ptG3HczLQ/7cZ2Z4iOHq34G5ioDWHbflb+S/yeN5oO+tTPNmKSSZ657RyWvu7hal+eqIItX1/N4p/FQ20Svyy/K6vuRxvKahO97xN9tg0M/Pb97DTmvEI+MaaCxk27cQL6v7bWHveaFS9bxZFTPFr/dR3Lvt9Oz2CqGf82+slR4bM7STy7c9TH13TSM+9wDhpd3K7SeCRr8Q9k4tvWkUVZi1WKZHsWU5cAa9G5AJPwUEEUJwNOeHjteRJ7i9iER3JPF9ZRYMAmHFQhLocxOF35eLvnoHMBKIWTi98IUt2FOHlwUJzEZ0QARE9tHbGMO6cV29zQr+yy924gGuLLijr/DNTm5zBdXYS7dg9Zr3PKclR3lnDP3sovXEwcpYguOhfnd38eskjYtr/s6pzTVqCOdvY7xuTzLH39Y2O6TDF+eiYn9Yguej7OvQ+V1e0Zvvi8Ebvdw127MS84B2dDZsjPhRlfqxt0u5h44d427IXn43Rnhhwjqzwftzug9csPAmAeGT4IdxcvBKWGTXED4MyYjp07E/Po6BJL13Qgd3DVNExLCqdoUREoCzoA44B1wLgK68Tj5YK6eBxb8oglP03hFCCoj7dZDW4uHvfmZUtl88cehwmFUwSr43MU6xVuPj5OmXg7FowHqiMBj0/2MyNGYma3kJ1fT7Lv3+Ewb+BHntfAzH0NmK6uYevd/oaZNG+G5v+SQG5KU5r9q5LM/V11quteOY26Z10YGPxN4IQbUZlDb1vN7B883TtZ4cB5Sebe5/TmgBzO/tUJ5v125HMcPDfNnIe8IQO5/ef5zP91RZctxknXq1cRzkzR+nQKhgrkkgkOnZNm1n3ljXEsLpiOdRTOCIEcLc10ntpM/aOVXnWspgO5hj0B+oiLkzM4+ZAw7eJmQ3KtSVJt+fgOmVYYXxMlNF5XiNuRo74hidOVpzizDicXoosRhRkpooQi0R6gcyGFGUlSe7oJG5PoICKo93ACg3E0OijdTLWWoMnDbw8IGjx00WBylc92E9W17V8u4NTPPxvfHRkiODMPP0ny4QEblTqu/Pbvncuyqx5i2nfXD9/1Ujp22fcOoTozhIPUJSbRwNfDRMz93CBpJPqU63zdBejAUv/DDSNWn7pjI6bcVSBUPCFLTK7kK/fDb6dBKZCb88V1Zb8s8z4zfAoS+xfnsH91mtYvrWO4PAbzPyO5CqeKxu3dOD9+eNhuc9PVxaxb1rPvPRfSuj6DWvfIsHUOuWzXgPejaMt26rdsH6RMedde04Hcc68EP+cSzSpiiz5Ol0PUpHAPa6ybIqqL/4RUUaGMwpldJOhoJP7L8vGPOFjtE6UsJl26pedpMAn8NpfizHq8Q/FTFCUtzCqgd/uETRHJfS7Gt5ilOcKMB65BORZ2JkCWzptUKz/yGDQ2sOXrq1j59vLWUnVmz+KpTy/ktM8c7reyw4q3bxv2jbjHrh8+jwV/81RvV62MfZlatnxtFad/aveIXd67P7iWuffl0H98iKYfxt2u5X64b/nWeZz2vmeIDg+/ZNPOD62CT/+szFrFeGm8Yj97vreQ1leUf0zf1T6c5iZUQ0PvUIuOqy7AOorm/1yPWv8Yczd5I7537PvpqfI+MUUcfH4DjUvWkP7psS9u+oxTMU9s7g26nBnTeeqzSzj12j9jiqPPBVjO617J+0RNB3KpHT5OUpHa4hP5CuOB8X38Dtt7Fy7y4+5WpwD+Q2kKzXF3qy7dXrEq3hclPVQUpyCxGrwuS3qfBwZ0ZMnO0Xi7U3jdFqsdnKIlTCqKmTQN7XF3rI4gGkX+KVFdHS8/k+ZfPllRELf1+mUs/mFw3PJcfbtSD79t7ZCz1BZe+TSHr15Ny63xfnlznlpWvmMjIeA87xSClvSQ35Tn37QOlOLw365l+n+Uf7cketHzOe2z7SMGcQALP72R4ZfhFhOh4+VnMu+NTw55B+bQNWuZ8c3+baBntQ+dTLL9vacz7SlL0/fiQK7pe30mPpkIk4/iVV5+8uiQK0R4v2we668hqmTGtzYet0TXklufZcf/SfW+ftGhw6x86+H+AfrqM1GRGTHNlbt0MbnlM/B+/eCQnw+dr7uA5jviVYEqeZ+o7UDukMXxLanDhkKjRkeWyI9zu5GxGC+efWrcOFhzAouXJQ7Owjhg0xFEHngZCwqCurisDsApGoK6OPBLtVmc0jAHq8ApWtycxSkq/O5StJ4HU5A+k8nmd0XYqIKxSVHEgt8U8e4efvCy3zn8a5voiv+8n/30WpZ9aYukIJmKCkWcnDf8XTZr8bssmSvW4BQtyZ+P/IXAyYWoMXxDFxNvpPeJxDB/79ZanLwiTI1wjm4DZuj7csOdQ0yu/e+8kD0/hnn54YdW6HwQrxA1UoVBGK8WNQy/y4xqSE5NB3Izbn8E168DY2hwSoNUHSfOIWYMyvePT5li+jxRprQCBKVVHJRC+X7vY5QCrVEJP17L1VjwXIgibOlN20YRynVp0hqiiCCUO3KTLfGLB8rqDu0RHTqMd/fIQVfD7UOnGrFhSN2PNuA0NrLs1jaiI+0VXIGYKAPvuA6l4fb7cUoLVZf1leD+R6ua8V2Mv5HeJxq+P8zfe6HA4q8/jWpqHPZ1T/1s46jPISbX3F/thwOHiEaYsFTuTNNw127UMBkPAJI/P9ZenJZpMPINfqDGAzl7ylIKrc3oYpxDThmL1XGeOOdoFtOQJGhKoCKLLkQoa8FYrKPRocE6iqDRx+ssoruLRA0JrK/jHHOuJkq6OIX4RSw2eYSpeM3W5N4urOPE6U18hyjhEiU0OrSoQ+0gGQdqjvO8U8CYslKXDOfQq55Hw64ibpkBg5i6ok5ZbutEVrz0fJL3PTXqhdDDUxdy+IwUM/7t2epemJgS9rx0NnPuTcJDY187WbkuucufX9bd/d7zX7USvlJe2ZoO5Nr+opHiIo/kwbj70+u0RAlFmIbk4Tq6lsZLbSUPKNAQlca/uVlIHzBkWzUqhKDex81DbqbF71ToID4OC9aFMB2fz8mBDhzMGS0YD7xMnHIkaABdjMt7+5okkJvidty0liU39B/7EjXEAf9wdDLJs+9/Pgs/MfRslmnf6V/vkatXw3fvGP3FignhNDby3LVnlLUgujt/HnteuYjZX6lsVpMzcya737iCmV8YOWm6GH/Bu4+Q3joT80zlgZyuq+O5i9Is+HQZ7aV1NruvXEbrzTILbqrb+94LWfCdzUSHDtN68xCzmFefSffiusqSwStNdqZDss+m8MXnEaYdkncOHty1fmUD5WaVq+n1QrpWhES+pTDN0r0sIDdL0bU8Ijc/onM5BLOL2KVZus/P0XlmkdwZObKLQoIGOHymomtpRPciQ7HZ0nl6QDA7ILOiSNfKgO7FhvwMS/dCQ25uSH5mRGZRRH6GJTvPkF1WpHN5RNfpRQpL8uTmRGRXFOn8C+lanUyH37KartdcMGyZpT8a5E7L/Y+y7co6nOVLBj1GJRLYMGTxHcMvkH3g2gspvGxV7+OZfyw/qayYOMp1ee4Hx5ZPMrk8C+4eOkdg+JLz2PeeC+Oyhw4z99cHyjpP+OLz2PXh0nHtHcz/30NjuGpRLSqRoPE9HtGu4WcxFy9bRds/XnjcdpPLs/CXHSjPB6XY/ePnDVlHdLSdeb86OOi+vT89vbILF+Nqwf8exnQM/j6w9ctrcBcvxHluP01/rux93QZFWr7d/0t++wqfI6dV515aTd+Rm3cP6JQFazGeg98REKU0fkeIcRVd832M55fyw1lSh3VpxmqAcRU6tOjAEqY0hUYXLxv3TuvQUmyA9IGAoM7BOqV8dG48GcLvBOO58Z07Gz+FbtZQbHRx97uMkPpPjKPptz7Aji//BdP+0DrkAthDzS5a9r4HhhwPseMjz2fZfx0kGiGT96yvrcdecFYc+BUKRM9Ia5iKbBiy+HVP9X7j1o31PPWWFCsfGLy8+9s/M6eUANbk87B524jn0MkkO662rHhzPFjaBkWiJ7dU4erFWO36h3NY/IWhV/Xo4f/qQVp/NcgOExE2Jzj49+fT+q/rWPCazUNOoFGOE68sNIh5/2+LpBScQqInNg+5b8W7HiQ0EcEl53N0hc+sMQ6fmfHN4e/o6TNWlr24QE0HcvXbO3FVDrTGeg4qW8A0xf2gqhDgd/jo7iI24aC7C0RNKZyuPLZngkPKQx/txtYlqbM2ntiQKxI1pUgcdnAyAf4Rhe7KY+oTRCkPtz0f38dUChUaojofZQFjSBxx4UD7pD0fArCWFf+wYdgByLqujv1vPIuZXx+QXmKYQa2LP7y+vEHv1qI+dRjnTTOHXcpLTL6+Gfyjw0dY+Y7+XRzm/5wbr7P8p4dHNZPM5POsuHrkYEFMvPmf3wCqjEXKh3nd/QMZmp+JP0KHWw1C1dVx4PkNzHhwkOrLWEVCTJ62d13InK9ujF+n0ueD9+sHmVWN1ThGeE9pP73p5Ajk1JGO3j9GBRCGONm4a9MWirgJHxsEaK2xxSJudxJbKKDd0q/tONh8Ht2d7c20bCODm8nFj0t/ZDaMcLo9HNeBQikHiVJYY3A7Sm8GUYTjugTd7RP3BIhRscWA6U8O0gVepdUYzMdnEh14csz1iMnl7WlHGTv62aiyusfUNsbXRx1uJ63UiDPko4MHmfHNwbtWxdQ247EC1gzRRsb577vxB0N0DwyipsfIAXG6kJYmVF0apjUBYJvqUckENpWIt7suzJqOTSXi4M1abGN9XK6+DjwvDuLq0yhHx+XCEJIJbENdXFd9GrSOyzpO/C8MwfcwM5ri/Y5GeWV8yxOTygZF9L3HJ4Td9sU1Q46Rq4T+40PYQmHM9YjJFW3bQfjMs6M+fvePTgftVO+CRFVt+foq3HlzR3182LYf8/joFjkXtcG9Z9OQPTXe71rRDQ0TfEWDq+1ALuljkz6qEGC1iu+SJX1UNo9NeKggxDSmsekkGIsKQmish4a6uAusM4P1PWzSP5ZPrqkBFUbYuhSEESqTA8+N60wlsI1x3jpbl4qDQ9dBFUNswo/Pkxp8LISY2tSqM1nxX11l5xkTJ672N66NB7GP0fwrnhi2u15MrpVv3zjikm3DcZYvIXrR86t4RWIqOPy3a8sqt/WPiyGYGknAazqQs+lUHLwlvHicXLp0x81zsckE1vcwvgNaYT03Dta0xiYT8d01pbApH3wPW5fC1qcw6UQc2PUEZr6HaUhhG9LY0lg8XDc+h+OA62B9l3B6CpPysHJHriapYogKqvOh++wn1+JMb6lKXWLiuTkDtpKU0uJkpMIIXZR2cqJxc+V1l0bJkctMlJoeI3dw9TQ8lcTLGty8JTPLIX0owmpFmIxzyxUbFLpYT5RU+F0WN2coNmiiBHjd0LC7QKbVx3iK9IGQYoMmSMfxrXUg0REnDgYo1iuw4GcaMQ4EdYooqUgeMYQJBSRxjrgwtpyyYoy2fGM1p39qD+HuPWUfYwaZjbrtv8/llL/fXnFi2OX/tpPw6NiTSIrJUf/DDYPOJNzzwQuZ/UAh7m4RNW807xN9hc/uRD27s/dxx+svwLjquFySonbEbWJXWeNiT/nyLsIyh9Dohga2/dsylr7u4TFd35D1j0utE8TvsiQ6DU7Roowl2WGwWhHUKZwgXgvVy4CXs9TvjfC7DTqE+r0hyaOWRFdE58IEyoCXMYSlAM7LWZSF9MEIHVmMC35nRKLD4GcsVsdr6KUPRiSOGnRgcQvxtRhXTfKzIla+fWP/N2elyL1i9bDHOKevxDlleb9ty1//0HFBnDtvLqw+k+Fkz5iL9uXObE264CzcOa2D7pr3mXW492zCaW4qr0tNO+RfPny7E5NDn7GS0z93YNggTiUSFC5fNfg+z6fw0v77mv77/hGDuNwrVseD5MWUU06bAHAXLUCd97w4K8Ewkx36vk+Yrq5hgzi3dTZ27dmjum6o8TtyXa/uItflQyJCKUg3Zsm0p6iflqW7PUW6Mc/MhgyHuuvI5z0U4LgRhfYkDbM6iCJNQ6rAoY46wiNJErOy+F5ILueTSAYczvlEOZdUU5Zux5DpiFdI9tNFwtBBK0trSye797WgPYPWBt92wY8m93kR/SnXY+3HNvLwz4YuEzanUOHx3STPfnItiz9y7M3ZppMUZiQZbiRkZrZL0vMgL8mhp6KjV69lxgOHB83pVpiewDk0/ErodvE89l1XYP7vhj+P0oruOf2zuYupIWxO4o7w6adcl0yr2+9vvXjZKnRg8P/0BN1z3GHfBwbTNdel7nmncPi8aUz7rty5m0r6tgl74dnkWpOkf7LhuHK2LkVxWpIRv6p7PtlZPg3EOSWfe8/zh14JJJWkMD0x6veKmg7k5n3K4EWHsb6HiiKs7wKZ+APZdsXj2VSaBdag8t3gOpiUh8p3oYwBIrCKFrKorkPYpnqsUqggE4+dC/PxBAkgbKnD7egqpSWJ4nF3jgNuilPIoTuzmPokoVUMnzJWTBjtoLTCBkUe+dvnAYMnAgZQ6x6Jk/gOmFK+5I6uft1s0dZnSGx9ZtjTTr/9IXb/z1LmvlJSkExFM/7UhurODrov8YsHevMFKneIHGFPP8OiDy8YMa+gcl1mfFM+rKcifd+jmGHyyKlEApPN0nJr/9cv/dgeMIYwn2f6rRtRno8NisOfTCmU72MLBWZ9bR2qsZEZ+UJ5eSnFhNH3PYpN1gPgbt1L457koF2s0ZNb8Hre2vu8tseVO3iQhtvjtDOmGLDoF+2DpqrRySThjudI7hh98viaDuSefXUzKp0kdUBRaIaw3mCSloatDtk5FjejSByFoD4emOh3Qm5W3G2aOBKPdwsaLFiFDsF4Nl47tTnCa3cwvsXr0nhdoAzkZqZxM/FtcTcPTh4y8yzKgJttJkxZoiAPj07u8yLA/OW5BI0unQtcZn5j/ZCrOfS1/cbns/Kb+/qlnIhSXsXjD3L/XysL/y4z+vxjYlxF23aw9bvPZ+U17UOmidENDTx7/ZlMe9rQcHv/DOwmn4enRh4Iu/Xbp7Ls9Y/1m7nqzpsLngWZHD2lbfvncznly3sIn9vVb3vfWa7ZV5zPvrWaZe8bPlh3F85n8zvnsey9cTuKOjuhwnG3YmJs+dy5nPa5nf1eZ/OCc9D3PTxoeefU5Wx//QwW/9MIX9hMhHl48C/2/d4nVp+JemjzyF8OBqjpQG7WAxGeClEWdGDAgvEUbr4ID0Fupo/XFWEdFQdb3fFUYWVB5wOs55BrTeLk4zF2UUKjQovxFYkjeQrTPZxcXL+bCVGRIUq56MKxN+bm7T5eRxGTdLBKYQp5eY+eAvZclGLBJ9cxs4Jjln5w/XHB157/k2LBHys7d/udc0kfHTlwFJNnxdV/HnZpJN3cRP0ue1wQV4llg4yJCRbNJJs2EshNEXvfeyFzv3B8d9ey99w/4hex+u2dtKrGEc8RPreLZe/dNWI5MflW/OOA11077P3LNPPvO77sgesuZPa/b2LxP41tdmPf94n9FzQwd0uKqP0kCuTS923GS9RhM1lsGKISpbQiQYDyfTzHQaVT2EwGGxmUo1F1dZj2DpQTpyWpf9JiowiiCBsZdCrupbZhiJdIQBSB54Kx2DDErUtjMlkwBqIIt74uTgzsumAtoansBRDVt/3zaznlX56pyh2xBZ8aYkzDMGZ/eZ10m9S4cNduWr5d/SXW1LpHSNipkXtKwPQnR/9ahI1JMq0OdVW8HjG1bPnG8znlnZsG/dI37ekCNqhuv8toPztqetYqURQn+k2l0Ol03FddjAMpG0XYMMRmc9hiEAdqQYg5fASiCNPTpeJ7vWNglO9hrQWtUKlkfIy1mO5M3AVjDKarO04CWNpnszlMJhevDJEvyJI8U8DKTz5B2LZ/0s6/5d9X4cyeNWnnF0KMzF26mOSvj1/hpVzO/U/QeuvD1bsgMeWc9oFtQw6/8O4eetWHiVbTgZxKJMDRcfLO0p00nUqiGhpQ6TTK91DJBKquDtUQL8fV80+nkqhUChwH3diIbm5CpZLxAGfXjYNErVAJH52I5ybphnp0YwN4XlxHQz0qnUI3NfQOepREopMv6uyc1IB65dse4OBLl03a+cXUoFyX9jeUlyVeTLxnr5yLnjZt1MfboIjJDj5pZjjugvkEF5836vOKiRMdPTpp5y5eXP6qITXdtdr2/07BUwmsA8ZVuHlLbqYicTT+ELdKoaxFlYLmKKmI/Dj/nIp6JjAojAeJI2C8ePwcQKI9rsvNWHQIYUrh5uKJDcYDFYHV8f/FZoUKIWgEfTAPX5+kJ0RUTim23ryGFf9Y2VioZz+9lmWff5KoffDEv69892+599bh01iIybP9Cxew/J+qsyauOv8MDp3bwPR/P37AsxPIHfqpyriAHl1ON93QwPYPncGSG0YxK9ladBS3C2f2LJ69ZjlzPnHvqK5DjDPtsO2Lq1j+7tGNlc3/39VYF1I/21j5qQdJhzWUmg7kWn93ELdnCrlbWpw6jFDZfLy0VmMaAH2kCzwXqxXK2HgJLmshCCER/6xyBaxTukGpdXynr5SKomctV2VsvLZqGMXHl+76WM+Nu2hdTZTLSPqRWmItp/1rW8Xj6ZZ/czdhZ/eQ+7dmZwFdY7o0MX5OuWVf2VnZR6KefIZZu+qPG9tiw5CG749+soQYX0tv3Ul0+MiojrW5HEt/1DnshJmhhLv34JSSzprDR1jynZ1Ixsmp4+D/dwoz/2pz/MBEnPqVyj8fetTdtxmUHtW4N/f3D5dfdhT1TxnRth0oPUhKRhOhXBdrLFiDdZx4HNwgGbWVEweAvbmidCkgtAblevFEiJ7HjnPsMYDScR+5dnrPGQW5av6KYgL0TTdS9jHPDT8LbftnTiNF5d/CxMQIx5CzaSCTzcIoutjE5Ap3jX4yi06nefqNDawY42ptNgzHdB2i+nqDuJLRfD70GKrHptpqOpBzVi7F8eLuK5XJgdbxYvZJD32ki2h2c3wbOx9CEKLCCOvoOMlvEMZ38YpBfDfNc+O7c0GITfnortIEBt9D5QtEs5pRhQCdLUDCR3VmsI11YAxRUwqdD1HFEG0DkDywk6rtXRcy77+eHvW37bHa954LiXyY/7NJOb0oh3bY+eE1LPxE5bOSxYnDmTaN3W8+jTn/Ulk7iDo7Kx6OIcRI9r3nQuZ/64mKA8CaDORsqUvz0OlpinPS+J0W48fdqF63pdCkcXNJCs0KL2uJvASoeNybmzfkZmi8DEQJ8LoshWaFDsAtWCI/HkfnFJMYF6wDQboRHYKbd4EUTh6UScf7XYh8hdUufpcl5xfgyWPXKCZGz/MdEjDrN/sodrVjK0zz8MxnV7HimweJtj876us48PY1mHyeOf/6EKENCAn6XZ+YOH3bRN8+sF03rGH+77LMu/MgYZVTgRy6fQUzXjN8XilpE5NnYJuIutqZ/eu2stvB0devxgksjbc/MKrz63SKZ7+2lIVv6p9nUtrE5BnqfQLiCUt7vruCuVdVf8BU16tXEdQpWr57rOdm9q/aKHZ3Yiv87FC2BlvOM888w7JlU3tW4K5du5g/f/5kX8ZJY6q3CWkPE0/ahBhI2oQY6ERoEzV5R66lpQWAnTt30tTUNOb6Ojs7WbBgAbt27aKxceRM3cOx1tLV1cXcuXPHfF2ifFO1TUh7mDzVbBPyHnFikDYhBjoR2kRNBnJax7NLm5qaxvxk9dXY2FiV+qoRSIjKTOU2Ie1hcoxHm5D3iNombUIMdCK0iZpOCCyEEEIIcTKTQE4IIYQQokbVZCCXSCT42Mc+RiIxSA65KVCfmHjSJsRA1XwNpT2cGKRNiIFOhDZRk7NWhRBCCCFEjd6RE0IIIYQQEsgJIYQQQtQsCeSEEEIIIWqUBHJCCCGEEDVKAjkhhBBCiBpVk4HcLbfcwuLFi0kmk6xZs4aNGzeOeMxNN93EqlWraGhoYNasWbziFa9g8+bN/cpcdNFFKKX6/Xv7298+Xr+GEEIIIcSY1Fwgd/vtt3P99dfzsY99jD//+c+cffbZXHrppRw4cGDY4+69916uvfZa7r//fn7zm98QBAGXXHIJmUymX7m3ve1t7Nu3r/ff5z73ufH8dYQQQgghRq3m8sitWbOGVatW8dWvfhUAYwwLFizgne98Jx/84AfLrufgwYPMmjWLe++9lxe+8IVAfEfunHPO4eabbx6PSxdCCCGEqKqauiNXLBbZtGkTF198ce82rTUXX3wx69evr6iujo4OAFpaWvpt/973vseMGTM444wzuOGGG8hms2O/cCGEEEKIceBO9gVU4tChQ0RRxOzZs/ttnz17Nk8//XTZ9RhjeNe73sVf/MVfcMYZZ/Ruf93rXseiRYuYO3cujz76KB/4wAfYvHkzP/nJT6r2OwghhBBCVEtNBXLVcu211/L4449z33339dt+zTXX9P585plnMmfOHF7ykpewfft2li1bNtGXKYQQQggxrJrqWp0xYwaO47B///5+2/fv309ra2tZdVx33XXceeed/O53v2P+/PnDll2zZg0A27ZtG90FCyGEEEKMo5oK5Hzf57zzzuOee+7p3WaM4Z577mHt2rXDHmut5brrruOnP/0pv/3tb1myZMmI53v44YcBmDNnzpiuWwghhBBiPNRc1+r111/P1Vdfzfnnn8/q1au5+eabyWQyvPnNbx72uGuvvZbbbruNO+64g4aGBtra2gBoamoilUqxfft2brvtNl760pcyffp0Hn30Ud797nfzwhe+kLPOOmsifjUhhBBCiIrUXPoRgK9+9at8/vOfp62tjXPOOYcvf/nLvd2gQ1FKDbr91ltv5U1vehO7du3i9a9/PY8//jiZTIYFCxbwyle+kg9/+MM0NjaOx68hhBBCCDEmNRnICSGEEEKIGhsjJ4QQQgghjpFATgghhBCiRkkgJ4QQQghRoySQE0IIIYSoURLICSGEEELUKAnkhBBCCCFqlARyQgghhBA1SgI5IYQQQogaJYGcEEIIIUSNkkBOCCGEEKJGSSAnhBBCCFGj/n/kjYSts/Ug3wAAAABJRU5ErkJggg==" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 3 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-02T19:16:47.907983Z", - "start_time": "2024-09-02T19:16:46.090175Z" - } - }, - "cell_type": "code", - "source": [ - "# Plot reservoir module weights\n", - "with open('Data/reservoir_module.pkl', 'rb') as f:\n", - " memory_module = pkl.load(f)\n", - "plt.imshow(memory_module.connections['key', 'value'].feature_index['assoc_weight_feature'].value.numpy())\n", - "plt.colorbar()" - ], - "id": "c3c66743119f2d75", - "outputs": [ - { - "ename": "KeyError", - "evalue": "('key', 'value')", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mKeyError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[9], line 4\u001B[0m\n\u001B[1;32m 2\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mopen\u001B[39m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mData/reservoir_module.pkl\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mrb\u001B[39m\u001B[38;5;124m'\u001B[39m) \u001B[38;5;28;01mas\u001B[39;00m f:\n\u001B[1;32m 3\u001B[0m memory_module \u001B[38;5;241m=\u001B[39m pkl\u001B[38;5;241m.\u001B[39mload(f)\n\u001B[0;32m----> 4\u001B[0m plt\u001B[38;5;241m.\u001B[39mimshow(\u001B[43mmemory_module\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnections\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mkey\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mvalue\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241m.\u001B[39mfeature_index[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124massoc_weight_feature\u001B[39m\u001B[38;5;124m'\u001B[39m]\u001B[38;5;241m.\u001B[39mvalue\u001B[38;5;241m.\u001B[39mnumpy())\n\u001B[1;32m 5\u001B[0m plt\u001B[38;5;241m.\u001B[39mcolorbar()\n", - "\u001B[0;31mKeyError\u001B[0m: ('key', 'value')" - ] - } - ], - "execution_count": 9 - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/scripts/Chris/DQN/Grid_Cells.py b/scripts/Chris/DQN/Grid_Cells.py deleted file mode 100644 index 308891c4..00000000 --- a/scripts/Chris/DQN/Grid_Cells.py +++ /dev/null @@ -1,133 +0,0 @@ -from scipy.stats import multivariate_normal -import numpy as np -from matplotlib import pyplot as plt - -class Grid_Cell: - def __init__(self, x_range, y_range, x_offset, y_offset, scale=1, var=1, color='b'): - self.centers = np.mgrid[x_range[0]:x_range[1]:scale, y_range[0]:y_range[1]:scale].transpose(1, 2, 0).astype(float) - self.centers[:, :, 0] += x_offset - self.centers[:, :, 1] += y_offset - self.centers[:, ::2, 0] += 0.5 * scale - # self.centers[::2, :, 1] += 0.5 * scale - self.x_range = x_range - self.y_range = y_range - self.color = color - self.var = var - - # Produce Grid Cell spike behavior relative to position - # scale: Distance between grid cells - def generate(self, pos): - # Find closest center - distances = np.linalg.norm(self.centers - pos, axis=2) - closest_center = self.centers[np.unravel_index(np.argmin(distances), distances.shape)] - mvn = multivariate_normal(mean=closest_center, cov=np.eye(2) * (self.var / (2 * np.pi))) - activity = mvn.pdf(pos) - return activity, closest_center - - def plot_activity(self, activity, center, color): - for i in range(self.centers.shape[0]): - for j in range(self.centers.shape[1]): - x, y = self.centers[i, j] - if np.all(center == (x, y)): - c = plt.Circle((x, y), activity + 0.01, fill=True, alpha=0.5) - plt.plot(x, y, '.', alpha=0.5, color=color) - plt.gca().add_artist(c) - else: - plt.plot(x, y, '.', alpha=0.5, color=color) - # c = plt.Circle((x, y), activity[i, j] + 0.01, color=color, fill=True, alpha=0.5) - plt.xlim(self.x_range[0]-1, self.x_range[1]+1) - plt.ylim(self.y_range[0]-1, self.y_range[1]+1) - - def plot_centers(self, color): - for i in range(self.centers.shape[0]): - for j in range(self.centers.shape[1]): - x, y = self.centers[i, j] - plt.plot(x, y, '.', alpha=0.5, color=color) - # c = plt.Circle((x, y), activity[i, j] + 0.01, color=color, fill=True, alpha=0.5) - plt.xlim(self.x_range[0]-1, self.x_range[1]+1) - plt.ylim(self.y_range[0]-1, self.y_range[1]+1) - - -# Module of Grid Cell populations, each with a different scale -class GC_Module: - def __init__(self, x_range, y_range, scales, offsets, vars): - # self.colors = - self.grid_cells = [Grid_Cell(x_range, y_range, x_ofst, y_ofst, s, v) for - (x_ofst, y_ofst), s, v in zip(offsets, scales, vars)] - self.scales = scales - self.x_range = x_range - self.y_range = y_range - self.offsets = offsets - self.colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w', 'orange', 'purple', 'brown', - 'pink', 'gray', 'olive', 'cyan', 'lime', 'teal', 'lavender', 'tan', 'salmon', - 'gold', 'indigo', 'maroon', 'navy', 'peru', 'sienna', 'tomato', 'violet', 'wheat',] - - # Generate Grid Cell activity - def generate(self, pos): - activities = [] - centers = [] - for gc in self.grid_cells: - a, c = gc.generate(pos) - activities.append(a) - centers.append(c) - return np.array(activities), np.array(centers) - - # Plot Grid Cell activity - def plot_activity(self, activities, centers): - for i, gc in enumerate(self.grid_cells): - gc.plot_activity(activities[i], centers[i], self.colors[i]) - - # Plot Grid Cell Centers - def plot_centers(self): - for i, gc in enumerate(self.grid_cells): - gc.plot_centers(self.colors[i]) - - -# Take in grid cell activity vector and turn into spike train -# Activity converted to spike rate -# max_freq: Maximum frequency of spikes -def activity_to_spike(activity, time, max_freq): - # Normalize [0, 1] - activity = (activity - min(activity)) / (max(activity) - min(activity)) - - # Convert to spike rate - spike_rate = activity * max_freq - spike_train = np.zeros((time, len(activity))) - for i, rate in enumerate(spike_rate): - if rate != 0: - spike_train[:, i] = np.zeros(time) - spike_train[:, i][np.random.rand(time) < rate] = 1 - else: - spike_train[:, i] = np.zeros(time) - - return spike_train - -if __name__ == '__main__': - np.random.seed(5) - num_cells = 5 - - # Grid Cell activity range - x_range_ = (0, +5) - y_range_ = (0, +5) - - # Agent position - pos_ = (0, 0) - - # Grid Cell offsets - x_offsets_ = np.random.uniform(-1, 1, num_cells) - y_offsets_ = np.random.uniform(-1, 1, num_cells) - offsets = list(zip(x_offsets_, y_offsets_)) - - # How far apart Grid Cells are - scales = [1 + 0.1*i for i in range(num_cells)] - - # Variance for activity sampling around Grid Cell centers - vars_ = [1]*num_cells - - # Initialize Grid Cell Module - module = GC_Module(x_range_, y_range_, scales, offsets, vars_) - a_, c_ = module.generate(pos_) - # test = activity_to_spike(a_, 50, 0.5) - print(f"Activity vector: {a_}") - module.plot_activity(a_, c_) - plt.show() diff --git a/scripts/Chris/DQN/Memory.py b/scripts/Chris/DQN/Memory.py deleted file mode 100644 index 4bd9ac0a..00000000 --- a/scripts/Chris/DQN/Memory.py +++ /dev/null @@ -1,118 +0,0 @@ -import pickle as pkl -import torch -import numpy as np -import matplotlib.pyplot as plt -from Grid_Cells import activity_to_spike - -from bindsnet.learning.MCC_learning import PostPre, MSTDP -from bindsnet.network import Network -from bindsnet.network.monitors import Monitor -from bindsnet.network.nodes import Input, AdaptiveLIFNodes -from bindsnet.network.topology import MulticompartmentConnection -from bindsnet.network.topology_features import Weight - - -class Memory_SNN(Network): - def __init__(self, - key_size, val_size, in_size, - w_in_key, w_in_val, w_assoc, - hyper_params, device='cpu'): - super().__init__() - - ## Layers ## - key_input = Input(n=in_size) - val_input = Input(n=in_size) - key = AdaptiveLIFNodes( - n=key_size, - thresh=hyper_params['thresh'], - theta_plus=hyper_params['theta_plus'], - refrac=hyper_params['refrac'], - reset=hyper_params['reset'], - tc_theta_decay=hyper_params['tc_theta_decay'], - tc_decay=hyper_params['tc_decay'], - traces=True, - ) - value = AdaptiveLIFNodes( - n=val_size, - thresh=hyper_params['thresh'], - theta_plus=hyper_params['theta_plus'], - refrac=hyper_params['refrac'], - reset=hyper_params['reset'], - tc_theta_decay=hyper_params['tc_theta_decay'], - tc_decay=hyper_params['tc_decay'], - traces = True, - ) - val_monitor = Monitor(value, ["s"], device=device) - self.add_monitor(val_monitor, name='val_monitor') - self.val_monitor = val_monitor - self.add_layer(key_input, name='key_input') - self.add_layer(val_input, name='val_input') - self.add_layer(key, name='key') - self.add_layer(value, name='value') - - ## Connections ## - # Key - in_key_wfeat = Weight(name='in_key_weight_feature', value=w_in_key) - in_key_conn = MulticompartmentConnection( - source=key_input, target=key, - device=device, pipeline=[in_key_wfeat], - ) - # Value - in_val_wfeat = Weight(name='in_val_weight_feature', value=w_in_val) - in_val_conn = MulticompartmentConnection( - source=val_input, target=value, - device=device, pipeline=[in_val_wfeat], - ) - # Association - assoc_wfeat = Weight(name='assoc_weight_feature', value=w_assoc, - learning_rule=MSTDP, nu=hyper_params['nu'], range=[0, 1], decay=hyper_params['decay']) - assoc_conn = MulticompartmentConnection( - source=key, target=value, - device=device, pipeline=[assoc_wfeat], traces=True, - ) - assoc_monitor = Monitor(assoc_wfeat, ["value"], device=device) - self.add_connection(in_key_conn, source='key_input', target='key') - self.add_connection(in_val_conn, source='val_input', target='value') - self.add_connection(assoc_conn, source='key', target='value') - self.add_monitor(assoc_monitor, name='assoc_monitor') - self.assoc_monitor = assoc_monitor - - ## Migrate device ## - self.to(device) - - # Store memory - # input: torch.Tensor of shape (time, in_size) - # output: Association output (time, key_size, val_size), Value output (time, val_size) - def store(self, key_train, sim_time=100, lr_params={}): - self.learning = True - self.run(inputs={'key_input':key_train, 'val_input':key_train}, time=sim_time, reward=1, **lr_params) - assoc_out = self.assoc_monitor.get('value') - val_spikes = self.val_monitor.get('s') - return assoc_out, val_spikes - - # Recall memory given a key - # input: torch.Tensor of shape (in_size) (key) - # output: torch.Tensor of shape (val_size) (value) - def recall(self, key_train, sim_time=100): - self.learning = False - self.run(inputs={'val_input':key_train}, time=sim_time) - val_spikes = self.val_monitor.get('s') - return val_spikes - - -def assign_inhibition(weights, percent, inhib_scale): - layer_shape = weights.shape - layer_size = np.prod(layer_shape) - indices_to_flip = np.random.choice(layer_size, int(layer_size * percent), replace=False) - indices_to_flip = np.unravel_index(indices_to_flip, layer_shape) - weights[indices_to_flip] = -weights[indices_to_flip]*inhib_scale - return weights - -# Note: percent = number of weights to zero out -def sparsify(weights, percent): - layer_shape = weights.shape - layer_size = np.prod(layer_shape) - indices_to_zero = np.random.choice(layer_size, int(layer_size * percent), replace=False) - indices_to_zero = np.unravel_index(indices_to_zero, layer_shape) - weights[indices_to_zero] = 0 - return weights diff --git a/scripts/Chris/DQN/Reservoir.py b/scripts/Chris/DQN/Reservoir.py deleted file mode 100644 index 4999d753..00000000 --- a/scripts/Chris/DQN/Reservoir.py +++ /dev/null @@ -1,110 +0,0 @@ -from bindsnet.network import Network -from bindsnet.network.monitors import Monitor -from bindsnet.network.nodes import Input, AdaptiveLIFNodes -from bindsnet.network.topology import MulticompartmentConnection -from bindsnet.network.topology_features import Weight -from bindsnet.learning.MCC_learning import MSTDP - - -class Reservoir(Network): - def __init__(self, in_size, exc_size, inh_size, hyper_params, - w_in_exc, w_in_inh, w_exc_exc, w_exc_inh, w_inh_exc, w_inh_inh, - device='cpu'): - super().__init__() - - ## Layers ## - input = Input(n=in_size) - res_exc = AdaptiveLIFNodes( - n=exc_size, - thresh=hyper_params['thresh_exc'], - theta_plus=hyper_params['theta_plus_exc'], - refrac=hyper_params['refrac_exc'], - reset=hyper_params['reset_exc'], - tc_theta_decay=hyper_params['tc_theta_decay_exc'], - tc_decay=hyper_params['tc_decay_exc'], - traces=True, - ) - exc_monitor = Monitor(res_exc, ["s"], device=device) - self.add_monitor(exc_monitor, name='res_monitor_exc') - self.exc_monitor = exc_monitor - res_inh = AdaptiveLIFNodes( - n=inh_size, - thresh=hyper_params['thresh_inh'], - theta_plus=hyper_params['theta_plus_inh'], - refrac=hyper_params['refrac_inh'], - reset=hyper_params['reset_inh'], - tc_theta_decay=hyper_params['tc_theta_decay_inh'], - tc_decay=hyper_params['tc_decay_inh'], - traces=True, - ) - inh_monitor = Monitor(res_inh, ["s"], device=device) - self.add_monitor(inh_monitor, name='res_monitor_inh') - self.inh_monitor = inh_monitor - self.add_layer(input, name='input') - self.add_layer(res_exc, name='res_exc') - self.add_layer(res_inh, name='res_inh') - - ## Connections ## - in_exc_wfeat = Weight(name='in_exc_weight_feature', value=w_in_exc,) - in_exc_conn = MulticompartmentConnection( - source=input, target=res_exc, - device=device, pipeline=[in_exc_wfeat], - ) - in_inh_wfeat = Weight(name='in_inh_weight_feature', value=w_in_inh,) - in_inh_conn = MulticompartmentConnection( - source=input, target=res_inh, - device=device, pipeline=[in_inh_wfeat], - ) - - exc_exc_wfeat = Weight(name='exc_exc_weight_feature', value=w_exc_exc,) - # learning_rule=MSTDP, - # nu=hyper_params['nu_exc_exc'], range=hyper_params['range_exc_exc'], decay=hyper_params['decay_exc_exc']) - exc_exc_conn = MulticompartmentConnection( - source=res_exc, target=res_exc, - device=device, pipeline=[exc_exc_wfeat], - ) - exc_inh_wfeat = Weight(name='exc_inh_weight_feature', value=w_exc_inh,) - # learning_rule=MSTDP, - # nu=hyper_params['nu_exc_inh'], range=hyper_params['range_exc_inh'], decay=hyper_params['decay_exc_inh']) - exc_inh_conn = MulticompartmentConnection( - source=res_exc, target=res_inh, - device=device, pipeline=[exc_inh_wfeat], - ) - inh_exc_wfeat = Weight(name='inh_exc_weight_feature', value=w_inh_exc,) - # learning_rule=MSTDP, - # nu=hyper_params['nu_inh_exc'], range=hyper_params['range_inh_exc'], decay=hyper_params['decay_inh_exc']) - inh_exc_conn = MulticompartmentConnection( - source=res_inh, target=res_exc, - device=device, pipeline=[inh_exc_wfeat], - ) - inh_inh_wfeat = Weight(name='inh_inh_weight_feature', value=w_inh_inh,) - # learning_rule=MSTDP, - # nu=hyper_params['nu_inh_inh'], range=hyper_params['range_inh_inh'], decay=hyper_params['decay_inh_inh']) - inh_inh_conn = MulticompartmentConnection( - source=res_inh, target=res_inh, - device=device, pipeline=[inh_inh_wfeat], - ) - self.add_connection(in_exc_conn, source='input', target='res_exc') - self.add_connection(in_inh_conn, source='input', target='res_inh') - self.add_connection(exc_exc_conn, source='res_exc', target='res_exc') - self.add_connection(exc_inh_conn, source='res_exc', target='res_inh') - self.add_connection(inh_exc_conn, source='res_inh', target='res_exc') - self.add_connection(inh_inh_conn, source='res_inh', target='res_inh') - - ## Migrate ## - self.to(device) - - def store(self, spike_train, sim_time): - self.learning = True - self.run(inputs={'input': spike_train}, time=sim_time, reward=1) - exc_spikes = self.exc_monitor.get('s') - inh_spikes = self.inh_monitor.get('s') - self.learning = False - return exc_spikes, inh_spikes - - def recall(self, spike_train, sim_time): - self.learning = False - self.run(inputs={'input': spike_train}, time=sim_time,) - exc_spikes = self.exc_monitor.get('s') - inh_spikes = self.inh_monitor.get('s') - return exc_spikes, inh_spikes diff --git a/scripts/Chris/DQN/classify_recalls.py b/scripts/Chris/DQN/classify_recalls.py deleted file mode 100644 index dd3b40ca..00000000 --- a/scripts/Chris/DQN/classify_recalls.py +++ /dev/null @@ -1,149 +0,0 @@ -from torch.optim import Adam -from matplotlib import pyplot as plt -from ANN import ANN -import pickle as pkl -import torch - -class Recalled_Mem_Dataset(torch.utils.data.Dataset): - def __init__(self, samples, labels): - self.samples = samples - self.labels = labels - - def __len__(self): - return len(self.samples) - - def __getitem__(self, idx): - # Compress spike train into windows for dimension reduction - return self.samples[idx].flatten(), self.labels[idx] - -def classify_recalls(out_dim, train_ratio, batch_size, epochs): - print("Classifying recalled memories...") - - ## Load recalled memory samples ## - with open('Data/preprocessed_recalls.pkl', 'rb') as f: - samples, labels = pkl.load(f) - - ## Initialize ANN ## - in_dim = samples[0].shape[0] - model = ANN(in_dim, out_dim) - optimizer = Adam(model.parameters()) - criterion = torch.nn.MSELoss() - dataset = Recalled_Mem_Dataset(samples, labels) - train_size = int(train_ratio * len(dataset)) - test_size = len(dataset) - train_size - train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) - train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) - test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=True) - - ## Training ## - loss_log = [] - accuracy_log = [] - for epoch in range(epochs): - total_loss = 0 - correct = 0 - for memory_batch, positions in train_loader: - # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) - optimizer.zero_grad() - outputs = model(memory_batch) - loss = criterion(outputs, positions.to(torch.float32)) - loss.backward() - optimizer.step() - total_loss += loss.item() - correct += torch.all(outputs.round() == positions.round(), - dim=1).sum().item() - accuracy_log.append(correct / len(train_set)) - loss_log.append(total_loss) - - plt.xlabel('Epoch') - plt.ylabel('Loss') - plt.title('Training Loss') - plt.plot(loss_log) - plt.show() - plt.xlabel('Epoch') - plt.ylabel('Accuracy') - plt.title('Training Accuracy') - plt.plot(accuracy_log) - plt.show() - - ## Testing ## - total = 0 - correct = 0 - confusion_matrix = torch.zeros(25, 25) - out_of_bounds = 0 - with torch.no_grad(): - for memories, labels in test_loader: - outputs = model(memories) - loss = criterion(outputs, labels) - total += len(labels) - correct += torch.all(outputs.round() == labels.round(), - dim=1).sum().item() # Check if prediction for both x and y are correct - for t, p in zip(labels, outputs): - label_ind = int(t[0].round() * 5 + t[1].round()) - pred_ind = int(p[0].round() * 5 + p[1].round()) - if label_ind < 0 or label_ind >= 25 or pred_ind < 0 or pred_ind >= 25: - out_of_bounds += 1 - else: - confusion_matrix[label_ind, pred_ind] += 1 - - plt.imshow(confusion_matrix) - plt.title('Confusion Matrix') - plt.xlabel('Predicted') - plt.ylabel('True Label') - plt.colorbar() - plt.show() - - print(f'Accuracy: {round(correct / total, 3)*100}%') - - -# if __name__ == '__main__': - # ## Constants ## - # OUT_DIM = 2 - # TRAIN_RATIO = 0.8 - # BATCH_SIZE = 10 - # - # ## Load recalled memory samples ## - # with open('Data/preprocessed_recalls.pkl', 'rb') as f: - # samples, labels = pkl.load(f) - # - # ## Initialize ANN ## - # in_dim = samples[0].shape[0] * samples[0].shape[1] - # model = ANN(in_dim, OUT_DIM) - # optimizer = Adam(model.parameters()) - # criterion = torch.nn.MSELoss() - # dataset = Recalled_Mem_Dataset(samples, labels) - # train_size = int(TRAIN_RATIO * len(dataset)) - # test_size = len(dataset) - train_size - # train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size]) - # train_loader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True) - # test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=True) - # - # ## Training ## - # loss_log = [] - # for epoch in range(20): - # total_loss = 0 - # for memory_batch, positions in train_loader: - # # positions_ = torch.tensor([[positions_[0][i], positions_[1][i]] for i, _ in enumerate(positions_[0])], dtype=torch.float32) - # optimizer.zero_grad() - # outputs = model(memory_batch) - # loss = criterion(outputs, positions.to(torch.float32)) - # loss.backward() - # optimizer.step() - # total_loss += loss.item() - # loss_log.append(total_loss) - # print(f'Epoch: {epoch}, Total Loss: {total_loss}') - # plt.xlabel('Epoch') - # plt.ylabel('Loss') - # plt.plot(loss_log) - # plt.show() - # - # ## Testing ## - # total = 0 - # correct = 0 - # with torch.no_grad(): - # for memories, labels in test_loader: - # outputs = model(memories) - # loss = criterion(outputs, labels) - # total += len(labels) - # correct += torch.all(outputs.round() == labels.round(), dim=1).sum().item() # Check if prediction for both x and y are correct - # - # print(f'Accuracy: {round(correct/total, 3)}%') diff --git a/scripts/Chris/DQN/pipeline_executor.py b/scripts/Chris/DQN/pipeline_executor.py deleted file mode 100644 index 7f19d3c9..00000000 --- a/scripts/Chris/DQN/pipeline_executor.py +++ /dev/null @@ -1,95 +0,0 @@ -import numpy as np -import pickle as pkl -from train_DQN import train_DQN -from sample_generator import sample_generator -from spike_train_generator import spike_train_generator -from store_reservoir import store_reservoir -from recall_reservoir import recall_reservoir -from recalled_mem_preprocessing import recalled_mem_preprocessing -from classify_recalls import classify_recalls - -if __name__ == '__main__': - ## Constants ## - WIDTH = 5 - HEIGHT = 5 - SAMPLES_PER_POS = 10 - NOISE = 0.1 # Noise in sampling - WINDOW_FREQ = 10 - WINDOW_SIZE = 10 - NUM_CELLS = 20 - X_RANGE = (0, WIDTH) - Y_RANGE = (0, HEIGHT) - SIM_TIME = 50 - MAX_SPIKE_FREQ = 0.8 - GC_MULTIPLES = 1 - EXC_SIZE = 250 - INH_SIZE = 50 - STORE_SAMPLES = 0 - WINDOW_FREQ = 10 - WINDOW_SIZE = 10 - OUT_DIM = 2 - TRAIN_RATIO = 0.8 - BATCH_SIZE = 10 - TRAIN_EPOCHS = 15 - PLOT = True - exc_hyper_params = { - 'thresh_exc': -55, - 'theta_plus_exc': 0, - 'refrac_exc': 1, - 'reset_exc': -65, - 'tc_theta_decay_exc': 500, - 'tc_decay_exc': 30, - # 'nu': (0.01, -0.01), - # 'range': [-1, 1], - # 'decay': None, - } - inh_hyper_params = { - 'thresh_inh': -55, - 'theta_plus_inh': 0, - 'refrac_inh': 1, - 'reset_inh': -65, - 'tc_theta_decay_inh': 500, - 'tc_decay_inh': 30, - } - hyper_params = exc_hyper_params | inh_hyper_params - - ## Sample Generation ## - x_offsets = np.random.uniform(-1, 1, NUM_CELLS) - - y_offsets = np.random.uniform(-1, 1, NUM_CELLS) - offsets = list(zip(x_offsets, y_offsets)) # Grid Cell x & y offsets - scales = [np.random.uniform(1.7, 5) for i in range(NUM_CELLS)] # Dist. between Grid Cell peaks - vars = [.85] * NUM_CELLS # Variance of Grid Cell activity - samples, labels, sorted_samples = sample_generator(scales, offsets, vars, X_RANGE, Y_RANGE, SAMPLES_PER_POS, - noise=NOISE, padding=1, plot=PLOT) - - # Spike Train Generation ## - spike_trains, labels, sorted_spike_trains = spike_train_generator(samples, labels, SIM_TIME, GC_MULTIPLES, MAX_SPIKE_FREQ) - - ## Association (Store) ## - store_reservoir(EXC_SIZE, INH_SIZE, STORE_SAMPLES, NUM_CELLS, GC_MULTIPLES, SIM_TIME, hyper_params, PLOT) - - # ## Association (Recall) ## - recall_reservoir(EXC_SIZE, INH_SIZE, SIM_TIME, PLOT) - - # Preprocess Recalls ## - recalled_mem_preprocessing(WIDTH, HEIGHT, PLOT) - - ## Train DQN ## - LR = 0.01 - EPS_START = 0.9 - EPS_END = 0.05 - DECAY_INTENSITY = 3 # higher - TAU = 0.005 - GAMMA = 0.99 - MAX_STEPS_PER_EP = 100 - MAX_TOTAL_STEPS = 15000 - MAX_EPS = 500 - BATCH_SIZE = 256 - INPUT_SIZE = EXC_SIZE + INH_SIZE - train_DQN(INPUT_SIZE, WIDTH, HEIGHT, LR, BATCH_SIZE, EPS_START, - EPS_END, DECAY_INTENSITY, TAU, GAMMA, MAX_STEPS_PER_EP, - MAX_TOTAL_STEPS, MAX_EPS, PLOT) - - ## Train ANN ## - # classify_recalls(OUT_DIM, TRAIN_RATIO, BATCH_SIZE, TRAIN_EPOCHS) diff --git a/scripts/Chris/DQN/recall_memories.py b/scripts/Chris/DQN/recall_memories.py deleted file mode 100644 index 58a6f7a0..00000000 --- a/scripts/Chris/DQN/recall_memories.py +++ /dev/null @@ -1,38 +0,0 @@ -import pickle as pkl -import numpy as np -import torch - -from Memory import Memory_SNN - -if __name__ == '__main__': - ## Constants ## - KEY_SIZE = 150 - VAL_SIZE = 150 - NUM_GRID_CELLS = 20 - SIM_TIME = 50 - - ## Load memory module and memory keys ## - with open('Data/memory_module.pkl', 'rb') as f: - memory_module = pkl.load(f) - with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: - memory_keys, labels = pkl.load(f) - - ## Recall memories ## - recalled_memories = np.zeros((len(memory_keys), SIM_TIME, VAL_SIZE)) - recalled_memories_sorted = {} - for i, (key, label) in enumerate(zip(memory_keys, labels)): - if i % 100 == 0: - print(f'Recalling memory {i}...') - value_spike_train = memory_module.recall(torch.tensor(key), sim_time=SIM_TIME) # Recall the sample - recalled_memories[i] = value_spike_train.squeeze() # Store the recalled memory - label = tuple(label.round()) - if label not in recalled_memories_sorted: - recalled_memories_sorted[label] = [value_spike_train.squeeze()] - else: - recalled_memories_sorted[label].append(value_spike_train.squeeze()) - - ## Save recalled memories ## - with open('Data/recalled_memories.pkl', 'wb') as f: - pkl.dump((recalled_memories, labels), f) - with open('Data/recalled_memories_sorted.pkl', 'wb') as f: - pkl.dump(recalled_memories_sorted, f) diff --git a/scripts/Chris/DQN/recall_reservoir.py b/scripts/Chris/DQN/recall_reservoir.py deleted file mode 100644 index 367afb89..00000000 --- a/scripts/Chris/DQN/recall_reservoir.py +++ /dev/null @@ -1,56 +0,0 @@ -import pickle as pkl -import numpy as np -import torch -from matplotlib import pyplot as plt - -def recall_reservoir(exc_size, inh_size, sim_time, plot=False): - print("Recalling memories...") - - ## Load memory module and memory keys ## - with open('Data/reservoir_module.pkl', 'rb') as f: - res_module = pkl.load(f) - with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: - memory_keys, labels = pkl.load(f) - - ## Recall memories ## - recalled_memories = np.zeros((len(memory_keys), sim_time, exc_size + inh_size)) - recalled_memories_sorted = {} - for i, (key, label) in enumerate(zip(memory_keys, labels)): - exc_spikes, inh_spikes = res_module.recall(torch.tensor(key.reshape(sim_time, -1)), sim_time=sim_time) # Recall the sample - all_spikes = torch.cat((exc_spikes, inh_spikes), dim=2).squeeze() - recalled_memories[i] = all_spikes # Store the recalled memory - label = tuple(label.round()) - if label not in recalled_memories_sorted: - recalled_memories_sorted[label] = [all_spikes] - else: - recalled_memories_sorted[label].append(all_spikes) - - ## Save recalled memories ## - with open('Data/recalled_memories.pkl', 'wb') as f: - pkl.dump((recalled_memories, labels), f) - with open('Data/recalled_memories_sorted.pkl', 'wb') as f: - pkl.dump(recalled_memories_sorted, f) - - # Plot recalls - # if plot: - # positions = np.array([key for key in recalled_memories_sorted.keys()]) - # rand_inds = np.random.choice(range(len(positions)), 5) - # for pos in positions[rand_inds]: - # fig = plt.figure(figsize=(10, 3)) - # gs = fig.add_gridspec(1, 6) - # ax1 = fig.add_subplot(gs[0, 0]) - # ax1.set_title(f"Position: {pos}") - # avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) - # ax1.imshow(avg_mem.T) - # random_inds = np.random.choice(range(len(recalled_memories_sorted[tuple(pos)])), 5) - # random_samples = np.array(recalled_memories_sorted[tuple(pos)])[random_inds] - # vmin = np.min(random_samples) - # vmax = np.max(random_samples) - # for i in range(1, 5): - # ax = fig.add_subplot(gs[0, i]) - # rand_sample = recalled_memories_sorted[tuple(pos)][random_inds[i]] - # im = ax.imshow(np.expand_dims(rand_sample.T, axis=1).squeeze(), vmin=vmin, vmax=vmax) - # ax.set_title(f"S{i}") - # ax.set(xticklabels=[]) - # ax.set(yticklabels=[]) - # plt.show() diff --git a/scripts/Chris/DQN/recalled_mem_preprocessing.py b/scripts/Chris/DQN/recalled_mem_preprocessing.py deleted file mode 100644 index acd2c9ff..00000000 --- a/scripts/Chris/DQN/recalled_mem_preprocessing.py +++ /dev/null @@ -1,59 +0,0 @@ -import matplotlib.pyplot as plt -import pickle as pkl -import numpy as np - - -def recalled_mem_preprocessing(width, height, plot): - print('Preprocessing recalled memories...') - - ## Load recalled memory spike-trains ## - with open('Data/recalled_memories.pkl', 'rb') as f: - samples, labels = pkl.load(f) # Used as training data, hence samples & labels - - ## Load recalled memory spike-trains ## - with open('Data/recalled_memories_sorted.pkl', 'rb') as f: - recalled_memories_sorted = pkl.load(f) # Used as training data, hence samples & labels - - ## Transformer (reduces sample dimensions) ## - # def windowed_spike_train(spike_train): - # windowed_spikes = np.zeros((len(spike_train) // window_freq, spike_train.shape[1])) - # for i in range(0, len(windowed_spikes)): # Iterate through windows - # if i * window_size + window_size > len(spike_train): # Last window... - # window = spike_train[i * window_freq:] # ...use remaining spikes - # windowed_spikes[i] = window.sum(0) - # else: - # window = spike_train[i * window_size:i * window_size + window_size] - # windowed_spikes[i] = window.sum(0) # Sum spikes in window - # return windowed_spikes - - # new_samples = np.zeros((len(samples), len(samples[0]) // window_freq, samples[0].shape[1])) - new_samples = np.zeros((len(samples), samples[0].shape[1])) - new_samples_sorted = {} - for i, s in enumerate(samples): # Apply transformer to each sample - # s = windowed_spike_train(s) - s = s.sum(0) - new_samples[i] = s - label = tuple(labels[i].round()) - if label not in new_samples_sorted: - new_samples_sorted[label] = [s] - else: - new_samples_sorted[label].append(s) - - ## Save transformed samples ## - with open('Data/preprocessed_recalls.pkl', 'wb') as f: - pkl.dump((new_samples, labels), f) - with open('Data/preprocessed_recalls_sorted.pkl', 'wb') as f: - pkl.dump(new_samples_sorted, f) - - if plot: - positions = np.array([key for key in new_samples_sorted.keys()]) - fig = plt.figure(figsize=(50, 50)) - gs = fig.add_gridspec(nrows=width, ncols=height) - for i, pos in enumerate(positions): - ax = fig.add_subplot(gs[int(pos[0]), int(pos[1])]) - avg_mem = np.mean(recalled_memories_sorted[tuple(pos)], axis=0) - ax.set_title(f"Conf-Mat: {pos[0] * 5 + pos[1]}") - im = ax.imshow(np.expand_dims(avg_mem, axis=0).squeeze()) - ax.set_aspect('auto') - plt.tight_layout() - plt.show() \ No newline at end of file diff --git a/scripts/Chris/DQN/sample_generator.py b/scripts/Chris/DQN/sample_generator.py deleted file mode 100644 index c8c84170..00000000 --- a/scripts/Chris/DQN/sample_generator.py +++ /dev/null @@ -1,65 +0,0 @@ -from matplotlib import pyplot as plt -import numpy as np -import pickle as pkl - -from scripts.Chris.DQN.Grid_Cells import GC_Module - -# Spread of activity between samples for each position -# We want to minimize this (i.e. we want the activity to be consistent across samples) -def intra_positional_spread(env_to_gc): - spread = {} - for pos, activities in env_to_gc.items(): - avg_activity = np.mean(activities, axis=0) - spread[pos] = np.std(avg_activity) - return spread - -# Spread of activity between positions -# We want to maximize this (i.e. we want the activity to be different across positions) -def inter_positional_spread(env_to_gc): - spread = {} - for pos1, activities1 in env_to_gc.items(): - for pos2, activities2 in env_to_gc.items(): - if pos1 != pos2: - avg_activity1 = np.mean(activities1, axis=0) - avg_activity2 = np.mean(activities2, axis=0) - spread[(pos1, pos2)] = np.linalg.norm(avg_activity1 - avg_activity2) - return spread - -# Generate grid cell activity for all integer coordinate positions in environment -def sample_generator(scales, offsets, vars, x_range, y_range, - samples_per_pos, noise=0.1, padding=2, plot=False): - print('Generating samples...') - sorted_samples = {} - samples = np.zeros((x_range[1] * y_range[1] * samples_per_pos, len(scales))) - labels = np.zeros((x_range[1] * y_range[1] * samples_per_pos, 2)) - padded_x_range = (x_range[0] - padding, x_range[1] + padding) - padded_y_range = (y_range[0] - padding, y_range[1] + padding) - module = GC_Module(padded_x_range, padded_y_range, scales, offsets, vars) - for i in range(x_range[1]): - for j in range(y_range[1]): - for k in range(samples_per_pos): # Generate multiple samples for each position - x_sign = 1 if np.random.rand() > 0.5 else -1 # (slight variations in position) - y_sign = 1 if np.random.rand() > 0.5 else -1 - pos = (i + np.random.rand() * noise * x_sign, j + np.random.rand() * noise * y_sign) - a, c = module.generate(pos) - if (i, j) not in sorted_samples: - sorted_samples[(i, j)] = [a] - else: - sorted_samples[(i, j)].append(a) - ind = i * y_range[1] * samples_per_pos + j * samples_per_pos + k - samples[ind] = a - labels[ind] = np.array(pos) - with open('Data/grid_cell_intensities.pkl', 'wb') as f: - pkl.dump((samples, labels), f) - with open('Data/grid_cell_intensities_sorted.pkl', 'wb') as f: - pkl.dump((sorted_samples), f) - - if plot: - module.plot_centers() - plt.title('Grid Cell Centers') - for i in range(x_range[1]): - for j in range(y_range[1]): - plt.plot(i, j, 'r+', markersize=10) - plt.show() - - return samples, labels, sorted_samples diff --git a/scripts/Chris/DQN/spike_train_generator.py b/scripts/Chris/DQN/spike_train_generator.py deleted file mode 100644 index 15475073..00000000 --- a/scripts/Chris/DQN/spike_train_generator.py +++ /dev/null @@ -1,48 +0,0 @@ -import pickle as pkl -import numpy as np - -# Take in grid cell activity vector and turn into spike train -# max_freq: Maximum frequency of spikes -def intensity_to_spike(intensity, time, max_freq, labels=None): - # Normalize [0, 1] - intensity = (intensity - min(intensity)) / (max(intensity) - min(intensity)) - - # Convert to spike rate - spike_rate = intensity * max_freq - spike_train = np.zeros((time, len(intensity))) - for i, rate in enumerate(spike_rate): - if rate != 0: - spike_train[:, i] = np.zeros(time) - spike_train[:, i][np.random.rand(time) < rate] = 1 - else: - spike_train[:, i] = np.zeros(time) - - return spike_train - -def spike_train_generator(intensities, labels, sim_time, gc_multiples, max_freq): - print("Generating Spike Trains...") - - ## Transform intensities to spike trains ## - with open('Data/grid_cell_intensities.pkl', 'rb') as f: - intensities, labels = pkl.load(f) - # with open('Data/grid_cell_intensities_sorted.pkl', 'rb') as f: - # intensities_sorted = pkl.load(f) - spike_trains = np.zeros( - (len(intensities), sim_time, len(intensities[0]), gc_multiples)) # (num_samples, time, gc, num_gc) - sorted_spike_trains = {} - for i, intensity in enumerate(intensities): - for j in range(gc_multiples): - spike_trains[i, :, :, j] = intensity_to_spike(intensity, sim_time, max_freq) - adjusted_label = (round(labels[i][0]), round(labels[i][1])) - if adjusted_label not in sorted_spike_trains: - sorted_spike_trains[adjusted_label] = [spike_trains[i]] - else: - sorted_spike_trains[adjusted_label].append(spike_trains[i]) - - ## Save to file ## - with open('Data/grid_cell_spk_trains.pkl', 'wb') as f: - pkl.dump((spike_trains, labels), f) - with open('Data/grid_cell_spk_trains_sorted.pkl', 'wb') as f: - pkl.dump((sorted_spike_trains), f) - - return spike_trains, labels, sorted_spike_trains diff --git a/scripts/Chris/DQN/store_memories.py b/scripts/Chris/DQN/store_memories.py deleted file mode 100644 index 68694ed3..00000000 --- a/scripts/Chris/DQN/store_memories.py +++ /dev/null @@ -1,82 +0,0 @@ -import pickle as pkl -import torch -import numpy as np -from matplotlib import pyplot as plt - -from Memory import Memory_SNN, sparsify - -if __name__ == '__main__': - ## Constants ## - KEY_SIZE = 150 - VAL_SIZE = 150 - NUM_GRID_CELLS = 20 - IN_KEY_SHAPE = (NUM_GRID_CELLS, KEY_SIZE) - IN_VAL_SHAPE = (NUM_GRID_CELLS, VAL_SIZE) - ASSOC_SHAPE = (KEY_SIZE, VAL_SIZE) - SIM_TIME = 50 - WINDOW_FREQ = 10 - WINDOW_SIZE = 10 - NUM_SAMPLES = 2_500 # Number of samples to store - PLOT = True - - ## Initialize Memory SNN ## - w_in_key = torch.rand(IN_KEY_SHAPE) - w_in_val = torch.rand(IN_VAL_SHAPE) - w_assoc = torch.rand(ASSOC_SHAPE) - # w_in_key = assign_inhibition(w_in_key, 0.2, 1) # (weights, %-inhib, scale) - # w_in_val = assign_inhibition(w_in_val, 0.2, 1) - w_in_key = sparsify(w_in_key, 0.5) # (weights, %-zero) - w_in_val = sparsify(w_in_val, 0.5) - # w_assoc = sparsify(w_assoc, 0.25) - hyper_params = { - 'thresh': -40, - 'theta_plus': 5, - 'refrac': 5, - 'reset': -65, - 'tc_theta_decay': 500, - 'tc_decay': 30, # time constant for neuron decay; smaller = faster decay - 'nu': [0.005, 0.005], - 'decay': 0.00001 - } - memory_module = Memory_SNN( - KEY_SIZE, VAL_SIZE, NUM_GRID_CELLS, - w_in_key, w_in_val, w_assoc, - hyper_params - ) - - ## Load grid cell spike-train samples ## - with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: - grid_cell_data, labels = pkl.load(f) # (samples, time, num_cells) - - ## Store memories ## - # -> STDP active - if PLOT: - fig, ax = plt.subplots(1, 2, figsize=(10, 5)) - im = ax[0].imshow(w_assoc) - ax[0].set_title("Initial Association Weights") - plt.colorbar(im, ax=ax[0]) - ax[0].set_xlabel("Value Neuron") - ax[0].set_ylabel("Key Neuron") - - # Store samples - sample_inds = np.random.choice(len(grid_cell_data), NUM_SAMPLES, replace=False) - samples = grid_cell_data[sample_inds] # (#-samples, time, num-cells) - labels = labels[sample_inds] - for i, s in enumerate(samples): - if i % 10 == 0: - print(f"Storing sample {i} of {NUM_SAMPLES}") - memory_module.store(torch.tensor(s), sim_time=SIM_TIME) - memory_module.reset_state_variables() - - if PLOT: - im = ax[1].imshow(w_assoc) - ax[1].set_title("Final Association Weights") - plt.colorbar(im, ax=ax[1]) - ax[1].set_xlabel("Value Neuron") - ax[1].set_ylabel("Key Neuron") - plt.tight_layout() - plt.show() - - ## Save ## - with open('Data/memory_module.pkl', 'wb') as f: - pkl.dump(memory_module, f) diff --git a/scripts/Chris/DQN/store_reservoir.py b/scripts/Chris/DQN/store_reservoir.py deleted file mode 100644 index f622a6f4..00000000 --- a/scripts/Chris/DQN/store_reservoir.py +++ /dev/null @@ -1,73 +0,0 @@ -import torch -from Reservoir import Reservoir -from Memory import sparsify, assign_inhibition -import pickle as pkl -import numpy as np -from matplotlib import pyplot as plt - -def store_reservoir(exc_size, inh_size, num_samples, num_grid_cells, gc_multiples, sim_time, - hyper_params, plot=False): - print("Storing memories...") - - ## Create synaptic weights ## - in_size = num_grid_cells * gc_multiples - w_in_exc = torch.rand(in_size, exc_size) # Initialize weights - w_in_inh = torch.rand(in_size, inh_size) - w_exc_exc = torch.rand(exc_size, exc_size) - w_exc_inh = torch.rand(exc_size, inh_size) - w_inh_exc = -torch.rand(inh_size, exc_size) - w_inh_inh = -torch.rand(inh_size, inh_size) - w_in_exc = sparsify(w_in_exc, 0.85) # 0 x% of weights - w_in_inh = sparsify(w_in_inh, 0.85) - w_exc_exc = sparsify(w_exc_exc, 0.8) - w_exc_inh = sparsify(w_exc_inh, 0.5) - w_inh_exc = sparsify(w_inh_exc, 0.7) - w_inh_inh = sparsify(w_inh_inh, 0.85) - res = Reservoir(in_size, exc_size, inh_size, hyper_params, - w_in_exc, w_in_inh, w_exc_exc, w_exc_inh, w_inh_exc, w_inh_inh) - - ## Load grid cell spike-train samples ## - with open('Data/grid_cell_spk_trains.pkl', 'rb') as f: - grid_cell_data, labels = pkl.load(f) # (samples, time, num_cells) - - ## Store memories ## - # -> STDP active - # if plot: - # fig, ax = plt.subplots(2, 2, figsize=(10, 5)) - # im = ax[0, 0].imshow(w_in_res) - # ax[0, 0].set_title("Initial Input-to-Res") - # plt.colorbar(im, ax=ax[0, 0]) - # ax[0, 0].set_xlabel("Res Neuron") - # ax[0, 0].set_ylabel("Input Neuron") - # im = ax[0, 1].imshow(w_res_res) - # ax[0, 1].set_title("Initial Res-to-Res") - # plt.colorbar(im, ax=ax[0, 1]) - # ax[0, 1].set_xlabel("Res Neuron") - # ax[0, 1].set_ylabel("Res Neuron") - - # Store samples - sample_inds = np.random.choice(len(grid_cell_data), num_samples, replace=False) - samples = grid_cell_data[sample_inds] # (#-samples, time, num-cells) - labels = labels[sample_inds] - np.random.shuffle(samples) - for i, s in enumerate(samples): - res.store(torch.tensor(s.reshape(sim_time, -1)), sim_time=sim_time) - res.reset_state_variables() - - # if plot: - # im = ax[1, 0].imshow(w_in_res) - # ax[1, 0].set_title("Final Input-to-Res") - # plt.colorbar(im, ax=ax[1, 0]) - # ax[1, 0].set_xlabel("Res Neuron") - # ax[1, 0].set_ylabel("Input Neuron") - # im = ax[1, 1].imshow(w_res_res) - # ax[1, 1].set_title("Final Res-to-Res") - # plt.colorbar(im, ax=ax[1, 1]) - # ax[1, 1].set_xlabel("Res Neuron") - # ax[1, 1].set_ylabel("Res Neuron") - # plt.tight_layout() - # plt.show() - - ## Save ## - with open('Data/reservoir_module.pkl', 'wb') as f: - pkl.dump(res, f) diff --git a/scripts/Chris/DQN/train_DQN.py b/scripts/Chris/DQN/train_DQN.py deleted file mode 100644 index 7ccbd29e..00000000 --- a/scripts/Chris/DQN/train_DQN.py +++ /dev/null @@ -1,208 +0,0 @@ -import math -import random -import matplotlib -import matplotlib.pyplot as plt -from collections import namedtuple, deque -from itertools import count - -import numpy as np -import torch -import torch.nn as nn -import torch.optim as optim -import torch.nn.functional as F - -from scripts.Chris.DQN.Environment import Maze_Environment, Grid_Cell_Maze_Environment - -Transition = namedtuple('Transition', - ('state', 'action', 'next_state', 'reward')) - -class ReplayMemory(object): - def __init__(self, capacity): - self.memory = deque([], maxlen=capacity) - - def push(self, *args): - """Save a transition""" - self.memory.append(Transition(*args)) - - def sample(self, batch_size): - return random.sample(self.memory, batch_size) - - def __len__(self): - return len(self.memory) - -class DQN(nn.Module): - - def __init__(self, n_observations, n_actions): - super(DQN, self).__init__() - self.layer1 = nn.Linear(n_observations, 128) - self.layer2 = nn.Linear(128, 128) - self.layer3 = nn.Linear(128, n_actions) - - # Called with either one element to determine next action, or a batch - # during optimization. Returns tensor([[left0exp,right0exp]...]). - def forward(self, x): - x = F.relu(self.layer1(x)) - x = F.relu(self.layer2(x)) - return self.layer3(x) - - -# Select action using epsilon-greedy policy -def select_action(state, step, eps, policy_net, env): - - # Select action from policy net - if random.random() > eps: - with torch.no_grad(): - # t.max(1) will return the largest column value of each row. - # second column on max result is index of where max element was - # found, so we pick action with the larger expected reward. - return policy_net(state).max(1).indices.view(1, 1) - - # Select random action (exploration) - else: - return torch.tensor(np.random.choice(env.num_actions)).view(1, 1) - - -# Optimize DQN -def optimize_model(memory, batch_size, policy_net, target_net, optimizer, gamma, device): - if len(memory) < batch_size: - return - transitions = memory.sample(batch_size) - # Transpose the batch (see https://stackoverflow.com/a/19343/3343043 for - # detailed explanation). This converts batch-array of Transitions - # to Transition of batch-arrays. - batch = Transition(*zip(*transitions)) - - # Compute a mask of non-final states and concatenate the batch elements - # (a final state would've been the one after which simulation ended) - non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, - batch.next_state)), device=device, dtype=torch.bool) - non_final_next_states = torch.cat([s for s in batch.next_state - if s is not None]) - state_batch = torch.cat(batch.state) - action_batch = torch.cat(batch.action) - reward_batch = torch.cat(batch.reward) - - # Compute Q(s_t, a) - the model computes Q(s_t), then we select the - # columns of actions taken. These are the actions which would've been taken - # for each batch state according to policy_net - state_action_values = policy_net(state_batch).gather(1, action_batch) - - # Compute V(s_{t+1}) for all next states. - # Expected values of actions for non_final_next_states are computed based - # on the "older" target_net; selecting their best reward with max(1).values - # This is merged based on the mask, such that we'll have either the expected - # state value or 0 in case the state was final. - next_state_values = torch.zeros(batch_size, device=device) - with torch.no_grad(): - next_state_values[non_final_mask] = target_net(non_final_next_states).max(1).values - # Compute the expected Q values - expected_state_action_values = (next_state_values * gamma) + reward_batch - - # Compute Huber loss - criterion = nn.SmoothL1Loss() - loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1)) - - # Optimize the model - optimizer.zero_grad() - loss.backward() - # In-place gradient clipping - torch.nn.utils.clip_grad_value_(policy_net.parameters(), 100) - optimizer.step() - - -# Run single episode of Maze env for DQN training -def run_episode(env, policy_net, device, max_steps, eps=0): - # Initialize the environment and get its state - state, info = env.reset() - state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0) - t = 0 - while t < max_steps: - action = select_action(state, t, eps, policy_net, env) # eps = 0 -> no exploration - observation, reward, terminated, _ = env.step(action.item()) - - if terminated: - next_state = None - else: - next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0) - - # Move to the next state - state = next_state - - if terminated: - break - - t+=1 - - - -def train_DQN(input_size, env_width, env_height, lr, batch_size, eps_start, - eps_end, decay_intensity, tau, gamma, max_steps_per_ep, max_total_steps, max_eps, plot): - device = 'cpu' - n_actions = 4 - policy_net = DQN(input_size, n_actions).to(device) - target_net = DQN(input_size, n_actions).to(device) - target_net.load_state_dict(policy_net.state_dict()) - optimizer = optim.AdamW(policy_net.parameters(), lr=lr, amsgrad=True) - memory = ReplayMemory(1000) - env = Grid_Cell_Maze_Environment(width=env_width, height=env_height) - - ## Pre-training recording ## - if plot: - run_episode(env, policy_net, device, 100, eps=0.9) - env.animate_history("pre_training.gif") - - episode_durations = [] - episodes = 0 - total_steps = 0 - print(env.maze) - while total_steps < max_total_steps: # and episodes < max_eps: - # Initialize the environment and get its state - state, info = env.reset() - state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0) - for t in count(): - eps = eps_end + (eps_start - eps_end) * math.exp(-decay_intensity * total_steps / (max_total_steps)) - action = select_action(state, t, eps, policy_net, env) - observation, reward, terminated, _ = env.step(action.item()) - reward = torch.tensor([reward], device=device) - - if terminated: - next_state = None - else: - next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0) - - # Store the transition in memory - memory.push(state, action, next_state, reward) - - # Move to the next state - state = next_state - - # Perform one step of the optimization (on the policy network) - optimize_model(memory, batch_size, policy_net, target_net, optimizer, gamma=gamma, device=device) - - # Soft update of the target network's weights - # θ′ ← τ θ + (1 −τ )θ′ - target_net_state_dict = target_net.state_dict() - policy_net_state_dict = policy_net.state_dict() - for key in policy_net_state_dict: - target_net_state_dict[key] = policy_net_state_dict[key] * tau + target_net_state_dict[key] * (1 - tau) - target_net.load_state_dict(target_net_state_dict) - - total_steps += 1 - if terminated or t > max_steps_per_ep: - episode_durations.append(t + 1) - break - print(f"Episode {episodes} lasted {t + 1} steps, eps = {round(eps, 2)} total steps = {total_steps}") - episodes += 1 - - ## Post-training recording ## - if plot: - env.reset() - run_episode(env, policy_net, device, 100, eps=0) # eps = 0 -> no exploration - env.animate_history("post_training.gif") - plt.clf() - - plt.plot(episode_durations) - plt.title("Episode durations") - plt.ylabel("Duration") - plt.xlabel("Episode") - plt.show() From 52be1345f6016eb3d7fc03697b83be9dd8ee8b5e Mon Sep 17 00:00:00 2001 From: christopher-earl Date: Sun, 22 Sep 2024 18:34:23 -0400 Subject: [PATCH 24/27] Update guides --- docs/source/guide/guide_part_i.rst | 31 ++++++++++++++++++++++++++++- docs/source/guide/guide_part_ii.rst | 31 ++++++++++++++++++++++++++++- 2 files changed, 60 insertions(+), 2 deletions(-) diff --git a/docs/source/guide/guide_part_i.rst b/docs/source/guide/guide_part_i.rst index ff425e8b..d8bc35d7 100644 --- a/docs/source/guide/guide_part_i.rst +++ b/docs/source/guide/guide_part_i.rst @@ -145,6 +145,33 @@ weights based on pre-, post-synaptic activity and possibly other signals; e.g., :code:`normalize` (for ensuring weights incident to post-synaptic neurons sum to a pre-specified value), and :code:`reset_state_variables` (for re-initializing stateful variables for the start of a new simulation). +For more complex connections, the MulticompartmentConnection class can be used. The MulticompartmentConnection will pass spikes through different "features" +such as weights, bias's, and boolean masks in a specified order. Features are passed to the MulticompartmentConnection constructor in a list, and executed in order. +For example, the code below uses a pipeline containing a weight and bias feature. During runtime, spikes from the source will be multiplied by the weights first, +then a bias added second. Additional features can be added before/after/between these two. +To create a simple all-to-all connection with a weight and bias: + +.. code-block:: python + + from bindsnet.network.nodes import Input, LIFNodes + from bindsnet.network.topology import MulticompartmentConnection + from bindsnet.network.topology_features import Weight, Bias + + # Create two populations of neurons, one to act as the "source" + # population, and the other, the "target population". + source_layer = Input(n=100) + target_layer = LIFNodes(n=1000) + + # Create 'pipeline' of features that spikes will pass through + weights = Weight(name='weight_feature', value=torch.rand(100, 1000)) + bias = Bias(name='bias_feature', value=torch.rand(100, 1000)) + + # Connect the two layers. + connection = MulticompartmentConnection( + source=source_layer, target=target_layer, + pipeline=[weight, bias] + ) + Specifying monitors ******************* @@ -176,7 +203,9 @@ course of simulation in certain network components. To create a monitor to monit The user must specify a :code:`Nodes` or :code:`AbstractConnection` object from which to record, attributes of that object to record (:code:`state_vars`), and, optionally, how many time steps the simulation(s) will last, in order to -save time by pre-allocating memory. +save time by pre-allocating memory. + +Monitors are not officially supported for MulticompartmentConnection To add a monitor to the network (thereby enabling monitoring), use the :code:`add_monitor` function of the :py:class:`bindsnet.network.Network` class: diff --git a/docs/source/guide/guide_part_ii.rst b/docs/source/guide/guide_part_ii.rst index 13ef5b31..786753a3 100644 --- a/docs/source/guide/guide_part_ii.rst +++ b/docs/source/guide/guide_part_ii.rst @@ -74,4 +74,33 @@ Custom learning rules can be implemented by subclassing :code:`bindsnet.learning and providing implementations for the types of :code:`AbstractConnection` objects intended to be used. For example, the :code:`Connection` and :code:`LocalConnection` objects rely on the implementation of a private method, :code:`_connection_update`, whereas the :code:`Conv2dConnection` object -uses the :code:`_conv2d_connection_update` version. \ No newline at end of file +uses the :code:`_conv2d_connection_update` version. + +If using a MulticompartmentConneciton, you can add a learning rule to a specific feature. Note that only +:code:`NoOp`, :code:`PostPre`, :code:`MSTDP`, :code:`MSTDPET` are supported, and located at +bindsnet.learning.MCC_learning. Below is an example of how to apply a PostPre learning rule to a weight function. +Note that the bias does not have a learning rule, so it will remain static. + +.. code-block:: python + + from bindsnet.network.nodes import Input, LIFNodes + from bindsnet.network.topology import MulticompartmentConnection + from bindsnet.learning.MCC_learning import PostPre + + # Create two populations of neurons, one to act as the "source" + # population, and the other, the "target population". + # Neurons involved in certain learning rules must record synaptic + # traces, a vector of short-term memories of the last emitted spikes. + source_layer = Input(n=100, traces=True) + target_layer = LIFNodes(n=1000, traces=True) + + # Create 'pipeline' of features that spikes will pass through + weights = Weight(name='weight_feature', value=torch.rand(100, 1000), + learning_rule=PostPre, nu=(1e-4, 1e-2)) + bias = Bias(name='bias_feature', value=torch.rand(100, 1000)) + + # Connect the two layers. + connection = MulticompartmentConnection( + source=source_layer, target=target_layer, + pipeline=[weights, bias]) + ) \ No newline at end of file From 7b586ac79e4ffb37b219b10ef07833cef6500f47 Mon Sep 17 00:00:00 2001 From: Hananel Hazan Date: Tue, 15 Oct 2024 12:42:15 -0400 Subject: [PATCH 25/27] black reformating --- bindsnet/learning/MCC_learning.py | 1028 +++++++++++++------------ bindsnet/network/monitors.py | 28 +- bindsnet/network/topology_features.py | 134 ++-- 3 files changed, 631 insertions(+), 559 deletions(-) diff --git a/bindsnet/learning/MCC_learning.py b/bindsnet/learning/MCC_learning.py index 33c3936e..14565a80 100644 --- a/bindsnet/learning/MCC_learning.py +++ b/bindsnet/learning/MCC_learning.py @@ -142,142 +142,160 @@ def reset_state_variables(self) -> None: class PostPre(MCC_LearningRule): - # language=rst - """ - Simple STDP rule involving both pre- and post-synaptic spiking activity. By default, - pre-synaptic update is negative and the post-synaptic update is positive. - """ - - def __init__( - self, - connection: AbstractMulticompartmentConnection, - feature_value: Union[torch.Tensor, float, int], - range: Optional[Sequence[float]] = None, - nu: Optional[Union[float, Sequence[float]]] = None, - reduction: Optional[callable] = None, - decay: float = 0.0, - enforce_polarity: bool = False, - **kwargs, - ) -> None: # language=rst """ - Constructor for ``PostPre`` learning rule. - - :param connection: An ``AbstractConnection`` object whose weights the - ``PostPre`` learning rule will modify. - :param feature_value: The object which will be altered - :param range: The domain for the feature - :param nu: Single or pair of learning rates for pre- and post-synaptic events. - :param reduction: Method for reducing parameter updates along the batch - dimension. - :param decay: Coefficient controlling rate of decay of the weights each iteration. - :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` - - Keyword arguments: - :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates - :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + Simple STDP rule involving both pre- and post-synaptic spiking activity. By default, + pre-synaptic update is negative and the post-synaptic update is positive. """ - super().__init__( - connection=connection, - feature_value=feature_value, - range=[-1, +1] if range is None else range, - nu=nu, - reduction=reduction, - decay=decay, - enforce_polarity=enforce_polarity, - **kwargs, - ) - - assert self.source.traces and self.target.traces, ( - "Both pre- and post-synaptic nodes must record spike traces " - "(use traces='True' on source/target layers)" - ) - - if isinstance( - connection, (MulticompartmentConnection) - ): - self.update = self._connection_update - # elif isinstance(connection, Conv2dConnection): - # self.update = self._conv2d_connection_update - else: - raise NotImplementedError( - "This learning rule is not supported for this Connection type." - ) - - # Initialize variables for average update and continues update - self.average_update = kwargs.get("average_update", 0) - self.continues_update = kwargs.get("continues_update", False) - - if self.average_update > 0: - self.average_buffer_pre = torch.zeros( - self.average_update, *self.feature_value.shape, device=self.feature_value.device - ) - self.average_buffer_post = torch.zeros_like(self.average_buffer_pre) - self.average_buffer_index_pre = 0 - self.average_buffer_index_post = 0 - - def _connection_update(self, **kwargs) -> None: - # language=rst - """ - Post-pre learning rule for ``Connection`` subclass of ``AbstractConnection`` - class. - """ - batch_size = self.source.batch_size - # Pre-synaptic update. - if self.nu[0]: - source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() - target_x = self.target.x.view(batch_size, -1).unsqueeze(1) * self.nu[0] + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``PostPre`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``PostPre`` learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the batch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` - if self.average_update > 0: - self.average_buffer_pre[self.average_buffer_index_pre] = ( - self.reduction(torch.bmm(source_s, target_x), dim=0) + Keyword arguments: + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, ) - self.average_buffer_index_pre = (self.average_buffer_index_pre + 1) % self.average_update - - if self.continues_update: - self.feature_value -= torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt - elif self.average_buffer_index_pre == 0: - self.feature_value -= torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt - else: - self.feature_value -= self.reduction(torch.bmm(source_s, target_x), dim=0) * self.connection.dt - del source_s, target_x - - # Post-synaptic update. - if self.nu[1]: - target_s = ( - self.target.s.view(batch_size, -1).unsqueeze(1).float() * self.nu[1] - ) - source_x = self.source.x.view(batch_size, -1).unsqueeze(2) - - if self.average_update > 0: - self.average_buffer_post[self.average_buffer_index_post] = ( - self.reduction(torch.bmm(source_x, target_s), dim=0) + assert self.source.traces and self.target.traces, ( + "Both pre- and post-synaptic nodes must record spike traces " + "(use traces='True' on source/target layers)" ) - self.average_buffer_index_post = (self.average_buffer_index_post + 1) % self.average_update + if isinstance(connection, (MulticompartmentConnection)): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) - if self.continues_update: - self.feature_value += torch.mean(self.average_buffer_post, dim=0) * self.connection.dt - elif self.average_buffer_index_post == 0: - self.feature_value += torch.mean(self.average_buffer_post, dim=0) * self.connection.dt - else: - self.feature_value += self.reduction(torch.bmm(source_x, target_s), dim=0) * self.connection.dt - del source_x, target_s + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) - super().update() + if self.average_update > 0: + self.average_buffer_pre = torch.zeros( + self.average_update, + *self.feature_value.shape, + device=self.feature_value.device, + ) + self.average_buffer_post = torch.zeros_like(self.average_buffer_pre) + self.average_buffer_index_pre = 0 + self.average_buffer_index_post = 0 - def reset_state_variables(self): - return + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + Post-pre learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + """ + batch_size = self.source.batch_size + + # Pre-synaptic update. + if self.nu[0]: + source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() + target_x = self.target.x.view(batch_size, -1).unsqueeze(1) * self.nu[0] + + if self.average_update > 0: + self.average_buffer_pre[self.average_buffer_index_pre] = self.reduction( + torch.bmm(source_s, target_x), dim=0 + ) + + self.average_buffer_index_pre = ( + self.average_buffer_index_pre + 1 + ) % self.average_update + + if self.continues_update: + self.feature_value -= ( + torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt + ) + elif self.average_buffer_index_pre == 0: + self.feature_value -= ( + torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt + ) + else: + self.feature_value -= ( + self.reduction(torch.bmm(source_s, target_x), dim=0) + * self.connection.dt + ) + del source_s, target_x + + # Post-synaptic update. + if self.nu[1]: + target_s = ( + self.target.s.view(batch_size, -1).unsqueeze(1).float() * self.nu[1] + ) + source_x = self.source.x.view(batch_size, -1).unsqueeze(2) + + if self.average_update > 0: + self.average_buffer_post[self.average_buffer_index_post] = ( + self.reduction(torch.bmm(source_x, target_s), dim=0) + ) + + self.average_buffer_index_post = ( + self.average_buffer_index_post + 1 + ) % self.average_update + + if self.continues_update: + self.feature_value += ( + torch.mean(self.average_buffer_post, dim=0) * self.connection.dt + ) + elif self.average_buffer_index_post == 0: + self.feature_value += ( + torch.mean(self.average_buffer_post, dim=0) * self.connection.dt + ) + else: + self.feature_value += ( + self.reduction(torch.bmm(source_x, target_s), dim=0) + * self.connection.dt + ) + del source_x, target_s - class Hebbian(MCC_LearningRule): - # language=rst - """ - Simple Hebbian learning rule. Pre- and post-synaptic updates are both positive. - """ + super().update() - def __init__( + def reset_state_variables(self): + return + + class Hebbian(MCC_LearningRule): + # language=rst + """ + Simple Hebbian learning rule. Pre- and post-synaptic updates are both positive. + """ + + def __init__( self, connection: AbstractMulticompartmentConnection, feature_value: Union[torch.Tensor, float, int], @@ -285,407 +303,419 @@ def __init__( reduction: Optional[callable] = None, decay: float = 0.0, **kwargs, - ) -> None: - # language=rst - """ - Constructor for ``Hebbian`` learning rule. - - :param connection: An ``AbstractConnection`` object whose weights the - ``Hebbian`` learning rule will modify. - :param nu: Single or pair of learning rates for pre- and post-synaptic events. - :param reduction: Method for reducing parameter updates along the batch - dimension. - :param decay: Coefficient controlling rate of decay of the weights each iteration. - """ - super().__init__( - connection=connection, - feature_value=feature_value, - nu=nu, - reduction=reduction, - decay=decay, - **kwargs, - ) + ) -> None: + # language=rst + """ + Constructor for ``Hebbian`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``Hebbian`` learning rule will modify. + :param nu: Single or pair of learning rates for pre- and post-synaptic events. + :param reduction: Method for reducing parameter updates along the batch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + """ + super().__init__( + connection=connection, + feature_value=feature_value, + nu=nu, + reduction=reduction, + decay=decay, + **kwargs, + ) - assert ( - self.source.traces and self.target.traces - ), "Both pre- and post-synaptic nodes must record spike traces." + assert ( + self.source.traces and self.target.traces + ), "Both pre- and post-synaptic nodes must record spike traces." - if isinstance(MulticompartmentConnection): - self.update = self._connection_update - self.feature_value = feature_value - # elif isinstance(connection, Conv2dConnection): - # self.update = self._conv2d_connection_update - else: - raise NotImplementedError( - "This learning rule is not supported for this Connection type." - ) + if isinstance(MulticompartmentConnection): + self.update = self._connection_update + self.feature_value = feature_value + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) - def _connection_update(self, **kwargs) -> None: - # language=rst - """ - Hebbian learning rule for ``Connection`` subclass of ``AbstractConnection`` - class. - """ + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + Hebbian learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + """ - # Add polarities back to feature after updates - if self.enforce_polarity: - self.feature_value = torch.abs(self.feature_value) + # Add polarities back to feature after updates + if self.enforce_polarity: + self.feature_value = torch.abs(self.feature_value) - batch_size = self.source.batch_size + batch_size = self.source.batch_size - source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() - source_x = self.source.x.view(batch_size, -1).unsqueeze(2) - target_s = self.target.s.view(batch_size, -1).unsqueeze(1).float() - target_x = self.target.x.view(batch_size, -1).unsqueeze(1) + source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float() + source_x = self.source.x.view(batch_size, -1).unsqueeze(2) + target_s = self.target.s.view(batch_size, -1).unsqueeze(1).float() + target_x = self.target.x.view(batch_size, -1).unsqueeze(1) - # Pre-synaptic update. - update = self.reduction(torch.bmm(source_s, target_x), dim=0) - self.feature_value += self.nu[0] * update + # Pre-synaptic update. + update = self.reduction(torch.bmm(source_s, target_x), dim=0) + self.feature_value += self.nu[0] * update - # Post-synaptic update. - update = self.reduction(torch.bmm(source_x, target_s), dim=0) - self.feature_value += self.nu[1] * update + # Post-synaptic update. + update = self.reduction(torch.bmm(source_x, target_s), dim=0) + self.feature_value += self.nu[1] * update - # Add polarities back to feature after updates - if self.enforce_polarity: - self.feature_value = self.feature_value * self.polarities + # Add polarities back to feature after updates + if self.enforce_polarity: + self.feature_value = self.feature_value * self.polarities - super().update() + super().update() - def reset_state_variables(self): - return + def reset_state_variables(self): + return class MSTDP(MCC_LearningRule): - # language=rst - """ - Reward-modulated STDP. Adapted from `(Florian 2007) - `_. - """ - - def __init__( - self, - connection: AbstractMulticompartmentConnection, - feature_value: Union[torch.Tensor, float, int], - range: Optional[Sequence[float]] = None, - nu: Optional[Union[float, Sequence[float]]] = None, - reduction: Optional[callable] = None, - decay: float = 0.0, - enforce_polarity: bool = False, - **kwargs, - ) -> None: # language=rst """ - Constructor for ``MSTDP`` learning rule. - - :param connection: An ``AbstractConnection`` object whose weights the ``MSTDP`` - learning rule will modify. - :param feature_value: The object which will be altered - :param range: The domain for the feature - :param nu: Single or pair of learning rates for pre- and post-synaptic events, - respectively. - :param reduction: Method for reducing parameter updates along the minibatch - dimension. - :param decay: Coefficient controlling rate of decay of the weights each iteration. - :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` - - Keyword arguments: - - :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates - :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full - - :param tc_plus: Time constant for pre-synaptic firing trace. - :param tc_minus: Time constant for post-synaptic firing trace. + Reward-modulated STDP. Adapted from `(Florian 2007) + `_. """ - super().__init__( - connection=connection, - feature_value=feature_value, - range=[-1, +1] if range is None else range, - nu=nu, - reduction=reduction, - decay=decay, - enforce_polarity=enforce_polarity, - **kwargs, - ) - - if isinstance( - connection, (MulticompartmentConnection) - ): - self.update = self._connection_update - # elif isinstance(connection, Conv2dConnection): - # self.update = self._conv2d_connection_update - else: - raise NotImplementedError( - "This learning rule is not supported for this Connection type." - ) - - self.tc_plus = torch.tensor(kwargs.get("tc_plus", 20.0)) - self.tc_minus = torch.tensor(kwargs.get("tc_minus", 20.0)) - - # Initialize variables for average update and continues update - self.average_update = kwargs.get("average_update", 0) - self.continues_update = kwargs.get("continues_update", False) - - if self.average_update > 0: - self.average_buffer = torch.zeros( - self.average_update, *self.feature_value.shape, device=self.feature_value.device - ) - self.average_buffer_index = 0 - - def _connection_update(self, **kwargs) -> None: - # language=rst - """ - MSTDP learning rule for ``Connection`` subclass of ``AbstractConnection`` class. - Keyword arguments: + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``MSTDP`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the ``MSTDP`` + learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events, + respectively. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + + Keyword arguments: - :param Union[float, torch.Tensor] reward: Reward signal from reinforcement - learning task. - :param float a_plus: Learning rate (post-synaptic). - :param float a_minus: Learning rate (pre-synaptic). - """ - batch_size = self.source.batch_size - - # Initialize eligibility, P^+, and P^-. - if not hasattr(self, "p_plus"): - self.p_plus = torch.zeros( - # batch_size, *self.source.shape, device=self.source.s.device - batch_size, - self.source.n, - device=self.source.s.device, - ) - if not hasattr(self, "p_minus"): - self.p_minus = torch.zeros( - # batch_size, *self.target.shape, device=self.target.s.device - batch_size, - self.target.n, - device=self.target.s.device, - ) - if not hasattr(self, "eligibility"): - self.eligibility = torch.zeros( - batch_size, *self.feature_value.shape, device=self.feature_value.device - ) - - # Reshape pre- and post-synaptic spikes. - source_s = self.source.s.view(batch_size, -1).float() - target_s = self.target.s.view(batch_size, -1).float() - - # Parse keyword arguments. - reward = kwargs["reward"] - a_plus = torch.tensor( - kwargs.get("a_plus", 1.0), device=self.feature_value.device - ) - a_minus = torch.tensor( - kwargs.get("a_minus", -1.0), device=self.feature_value.device - ) - - # Compute weight update based on the eligibility value of the past timestep. - update = reward * self.eligibility - - if self.average_update > 0: - self.average_buffer[self.average_buffer_index] = self.reduction(update, dim=0) - self.average_buffer_index = (self.average_buffer_index + 1) % self.average_update - - if self.continues_update: - self.feature_value += self.nu[0] * torch.mean(self.average_buffer, dim=0) - elif self.average_buffer_index == 0: - self.feature_value += self.nu[0] * torch.mean(self.average_buffer, dim=0) - else: - self.feature_value += self.nu[0] * self.reduction(update, dim=0) - - # Update P^+ and P^- values. - self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) - self.p_plus += a_plus * source_s - self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) - self.p_minus += a_minus * target_s - - # Calculate point eligibility value. - self.eligibility = torch.bmm( - self.p_plus.unsqueeze(2), target_s.unsqueeze(1) - ) + torch.bmm(source_s.unsqueeze(2), self.p_minus.unsqueeze(1)) - - super().update() - - def reset_state_variables(self): - return + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + + :param tc_plus: Time constant for pre-synaptic firing trace. + :param tc_minus: Time constant for post-synaptic firing trace. + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, + ) + + if isinstance(connection, (MulticompartmentConnection)): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + self.tc_plus = torch.tensor(kwargs.get("tc_plus", 20.0)) + self.tc_minus = torch.tensor(kwargs.get("tc_minus", 20.0)) + + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) + + if self.average_update > 0: + self.average_buffer = torch.zeros( + self.average_update, + *self.feature_value.shape, + device=self.feature_value.device, + ) + self.average_buffer_index = 0 + + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + MSTDP learning rule for ``Connection`` subclass of ``AbstractConnection`` class. + + Keyword arguments: + + :param Union[float, torch.Tensor] reward: Reward signal from reinforcement + learning task. + :param float a_plus: Learning rate (post-synaptic). + :param float a_minus: Learning rate (pre-synaptic). + """ + batch_size = self.source.batch_size + + # Initialize eligibility, P^+, and P^-. + if not hasattr(self, "p_plus"): + self.p_plus = torch.zeros( + # batch_size, *self.source.shape, device=self.source.s.device + batch_size, + self.source.n, + device=self.source.s.device, + ) + if not hasattr(self, "p_minus"): + self.p_minus = torch.zeros( + # batch_size, *self.target.shape, device=self.target.s.device + batch_size, + self.target.n, + device=self.target.s.device, + ) + if not hasattr(self, "eligibility"): + self.eligibility = torch.zeros( + batch_size, *self.feature_value.shape, device=self.feature_value.device + ) + + # Reshape pre- and post-synaptic spikes. + source_s = self.source.s.view(batch_size, -1).float() + target_s = self.target.s.view(batch_size, -1).float() + + # Parse keyword arguments. + reward = kwargs["reward"] + a_plus = torch.tensor( + kwargs.get("a_plus", 1.0), device=self.feature_value.device + ) + a_minus = torch.tensor( + kwargs.get("a_minus", -1.0), device=self.feature_value.device + ) + + # Compute weight update based on the eligibility value of the past timestep. + update = reward * self.eligibility + + if self.average_update > 0: + self.average_buffer[self.average_buffer_index] = self.reduction( + update, dim=0 + ) + self.average_buffer_index = ( + self.average_buffer_index + 1 + ) % self.average_update + + if self.continues_update: + self.feature_value += self.nu[0] * torch.mean( + self.average_buffer, dim=0 + ) + elif self.average_buffer_index == 0: + self.feature_value += self.nu[0] * torch.mean( + self.average_buffer, dim=0 + ) + else: + self.feature_value += self.nu[0] * self.reduction(update, dim=0) + + # Update P^+ and P^- values. + self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) + self.p_plus += a_plus * source_s + self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) + self.p_minus += a_minus * target_s + + # Calculate point eligibility value. + self.eligibility = torch.bmm( + self.p_plus.unsqueeze(2), target_s.unsqueeze(1) + ) + torch.bmm(source_s.unsqueeze(2), self.p_minus.unsqueeze(1)) + + super().update() + + def reset_state_variables(self): + return class MSTDPET(MCC_LearningRule): - # language=rst - """ - Reward-modulated STDP with eligibility trace. Adapted from - `(Florian 2007) `_. - """ - - def __init__( - self, - connection: AbstractMulticompartmentConnection, - feature_value: Union[torch.Tensor, float, int], - range: Optional[Sequence[float]] = None, - nu: Optional[Union[float, Sequence[float]]] = None, - reduction: Optional[callable] = None, - decay: float = 0.0, - enforce_polarity: bool = False, - **kwargs, - ) -> None: # language=rst """ - Constructor for ``MSTDPET`` learning rule. - - :param connection: An ``AbstractConnection`` object whose weights the - ``MSTDPET`` learning rule will modify. - :param feature_value: The object which will be altered - :param range: The domain for the feature - :param nu: Single or pair of learning rates for pre- and post-synaptic events, - respectively. - :param reduction: Method for reducing parameter updates along the minibatch - dimension. - :param decay: Coefficient controlling rate of decay of the weights each iteration. - :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` - - Keyword arguments: - - :param float tc_plus: Time constant for pre-synaptic firing trace. - :param float tc_minus: Time constant for post-synaptic firing trace. - :param float tc_e_trace: Time constant for the eligibility trace. - :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates - :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full - + Reward-modulated STDP with eligibility trace. Adapted from + `(Florian 2007) `_. """ - super().__init__( - connection=connection, - feature_value=feature_value, - range=[-1, +1] if range is None else range, - nu=nu, - reduction=reduction, - decay=decay, - enforce_polarity=enforce_polarity, - **kwargs, - ) - - if isinstance( - connection, (MulticompartmentConnection) - ): - self.update = self._connection_update - # elif isinstance(connection, Conv2dConnection): - # self.update = self._conv2d_connection_update - else: - raise NotImplementedError( - "This learning rule is not supported for this Connection type." - ) - - self.tc_plus = torch.tensor( - kwargs.get("tc_plus", 20.0) - ) # How long pos reinforcement effects weights - self.tc_minus = torch.tensor( - kwargs.get("tc_minus", 20.0) - ) # How long neg reinforcement effects weights - self.tc_e_trace = torch.tensor( - kwargs.get("tc_e_trace", 25.0) - ) # How long trace effects weights - self.eligibility = torch.zeros( - *self.feature_value.shape, device=self.feature_value.device - ) - self.eligibility_trace = torch.zeros( - *self.feature_value.shape, device=self.feature_value.device - ) - - # Initialize eligibility, eligibility trace, P^+, and P^-. - if not hasattr(self, "p_plus"): - self.p_plus = torch.zeros((self.source.n), device=self.feature_value.device) - if not hasattr(self, "p_minus"): - self.p_minus = torch.zeros((self.target.n), device=self.feature_value.device) - - # Initialize variables for average update and continues update - self.average_update = kwargs.get("average_update", 0) - self.continues_update = kwargs.get("continues_update", False) - if self.average_update > 0: - self.average_buffer = torch.zeros( - self.average_update, *self.feature_value.shape, device=self.feature_value.device - ) - self.average_buffer_index = 0 - - # @profile - def _connection_update(self, **kwargs) -> None: - # language=rst - """ - MSTDPET learning rule for ``Connection`` subclass of ``AbstractConnection`` - class. - Keyword arguments: + def __init__( + self, + connection: AbstractMulticompartmentConnection, + feature_value: Union[torch.Tensor, float, int], + range: Optional[Sequence[float]] = None, + nu: Optional[Union[float, Sequence[float]]] = None, + reduction: Optional[callable] = None, + decay: float = 0.0, + enforce_polarity: bool = False, + **kwargs, + ) -> None: + # language=rst + """ + Constructor for ``MSTDPET`` learning rule. + + :param connection: An ``AbstractConnection`` object whose weights the + ``MSTDPET`` learning rule will modify. + :param feature_value: The object which will be altered + :param range: The domain for the feature + :param nu: Single or pair of learning rates for pre- and post-synaptic events, + respectively. + :param reduction: Method for reducing parameter updates along the minibatch + dimension. + :param decay: Coefficient controlling rate of decay of the weights each iteration. + :param enforce_polarity: Will prevent synapses from changing signs if :code:`True` + + Keyword arguments: - :param Union[float, torch.Tensor] reward: Reward signal from reinforcement - learning task. - :param float a_plus: Learning rate (post-synaptic). - :param float a_minus: Learning rate (pre-synaptic). - """ - # Reshape pre- and post-synaptic spikes. - source_s = self.source.s.view(-1).float() - target_s = self.target.s.view(-1).float() - - # Parse keyword arguments. - reward = kwargs["reward"] - a_plus = kwargs.get("a_plus", 1.0) - # if isinstance(a_plus, dict): - # for k, v in a_plus.items(): - # a_plus[k] = torch.tensor(v, device=self.feature_value.device) - # else: - a_plus = torch.tensor(a_plus, device=self.feature_value.device) - a_minus = kwargs.get("a_minus", -1.0) - # if isinstance(a_minus, dict): - # for k, v in a_minus.items(): - # a_minus[k] = torch.tensor(v, device=self.feature_value.device) - # else: - a_minus = torch.tensor(a_minus, device=self.feature_value.device) - - # Calculate value of eligibility trace based on the value - # of the point eligibility value of the past timestep. - # Note: eligibility = [source.n, target.n] > 0 where source and target spiked - # Note: high negs. -> - self.eligibility_trace *= torch.exp( - -self.connection.dt / self.tc_e_trace - ) # Decay - self.eligibility_trace += self.eligibility / self.tc_e_trace # Additive changes - # ^ Also effected by delay in last step - - # Compute weight update. - - if self.average_update > 0: - self.average_buffer[self.average_buffer_index] = ( - self.nu[0] * self.connection.dt * reward * self.eligibility_trace - ) - self.average_buffer_index = (self.average_buffer_index + 1) % self.average_update - - if self.continues_update: - self.feature_value += torch.mean(self.average_buffer, dim=0) - elif self.average_buffer_index == 0: - self.feature_value += torch.mean(self.average_buffer, dim=0) - else: - self.feature_value += ( - self.nu[0] * self.connection.dt * reward * self.eligibility_trace - ) - - # Update P^+ and P^- values. - self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) # Decay - self.p_plus += a_plus * source_s # Scaled source spikes - self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) # Decay - self.p_minus += a_minus * target_s # Scaled target spikes - - # Notes: - # - # a_plus -> How much a spike in src contributes to the eligibility - # a_minus -> How much a spike in trg contributes to the eligibility (neg) - # p_plus -> +a_plus every spike, with decay - # p_minus -> +a_minus every spike, with decay - - # Calculate point eligibility value. - self.eligibility = torch.outer(self.p_plus, target_s) + torch.outer( - source_s, self.p_minus - ) - - super().update() - - def reset_state_variables(self) -> None: - self.eligibility.zero_() - self.eligibility_trace.zero_() - return + :param float tc_plus: Time constant for pre-synaptic firing trace. + :param float tc_minus: Time constant for post-synaptic firing trace. + :param float tc_e_trace: Time constant for the eligibility trace. + :param average_update: Number of updates to average over, 0=No averaging, x=average over last x updates + :param continues_update: If True, the update will be applied after every update, if False, only after the average_update buffer is full + + """ + super().__init__( + connection=connection, + feature_value=feature_value, + range=[-1, +1] if range is None else range, + nu=nu, + reduction=reduction, + decay=decay, + enforce_polarity=enforce_polarity, + **kwargs, + ) + + if isinstance(connection, (MulticompartmentConnection)): + self.update = self._connection_update + # elif isinstance(connection, Conv2dConnection): + # self.update = self._conv2d_connection_update + else: + raise NotImplementedError( + "This learning rule is not supported for this Connection type." + ) + + self.tc_plus = torch.tensor( + kwargs.get("tc_plus", 20.0) + ) # How long pos reinforcement effects weights + self.tc_minus = torch.tensor( + kwargs.get("tc_minus", 20.0) + ) # How long neg reinforcement effects weights + self.tc_e_trace = torch.tensor( + kwargs.get("tc_e_trace", 25.0) + ) # How long trace effects weights + self.eligibility = torch.zeros( + *self.feature_value.shape, device=self.feature_value.device + ) + self.eligibility_trace = torch.zeros( + *self.feature_value.shape, device=self.feature_value.device + ) + + # Initialize eligibility, eligibility trace, P^+, and P^-. + if not hasattr(self, "p_plus"): + self.p_plus = torch.zeros((self.source.n), device=self.feature_value.device) + if not hasattr(self, "p_minus"): + self.p_minus = torch.zeros( + (self.target.n), device=self.feature_value.device + ) + + # Initialize variables for average update and continues update + self.average_update = kwargs.get("average_update", 0) + self.continues_update = kwargs.get("continues_update", False) + if self.average_update > 0: + self.average_buffer = torch.zeros( + self.average_update, + *self.feature_value.shape, + device=self.feature_value.device, + ) + self.average_buffer_index = 0 + + # @profile + def _connection_update(self, **kwargs) -> None: + # language=rst + """ + MSTDPET learning rule for ``Connection`` subclass of ``AbstractConnection`` + class. + + Keyword arguments: + + :param Union[float, torch.Tensor] reward: Reward signal from reinforcement + learning task. + :param float a_plus: Learning rate (post-synaptic). + :param float a_minus: Learning rate (pre-synaptic). + """ + # Reshape pre- and post-synaptic spikes. + source_s = self.source.s.view(-1).float() + target_s = self.target.s.view(-1).float() + + # Parse keyword arguments. + reward = kwargs["reward"] + a_plus = kwargs.get("a_plus", 1.0) + # if isinstance(a_plus, dict): + # for k, v in a_plus.items(): + # a_plus[k] = torch.tensor(v, device=self.feature_value.device) + # else: + a_plus = torch.tensor(a_plus, device=self.feature_value.device) + a_minus = kwargs.get("a_minus", -1.0) + # if isinstance(a_minus, dict): + # for k, v in a_minus.items(): + # a_minus[k] = torch.tensor(v, device=self.feature_value.device) + # else: + a_minus = torch.tensor(a_minus, device=self.feature_value.device) + + # Calculate value of eligibility trace based on the value + # of the point eligibility value of the past timestep. + # Note: eligibility = [source.n, target.n] > 0 where source and target spiked + # Note: high negs. -> + self.eligibility_trace *= torch.exp( + -self.connection.dt / self.tc_e_trace + ) # Decay + self.eligibility_trace += self.eligibility / self.tc_e_trace # Additive changes + # ^ Also effected by delay in last step + + # Compute weight update. + + if self.average_update > 0: + self.average_buffer[self.average_buffer_index] = ( + self.nu[0] * self.connection.dt * reward * self.eligibility_trace + ) + self.average_buffer_index = ( + self.average_buffer_index + 1 + ) % self.average_update + + if self.continues_update: + self.feature_value += torch.mean(self.average_buffer, dim=0) + elif self.average_buffer_index == 0: + self.feature_value += torch.mean(self.average_buffer, dim=0) + else: + self.feature_value += ( + self.nu[0] * self.connection.dt * reward * self.eligibility_trace + ) + + # Update P^+ and P^- values. + self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus) # Decay + self.p_plus += a_plus * source_s # Scaled source spikes + self.p_minus *= torch.exp(-self.connection.dt / self.tc_minus) # Decay + self.p_minus += a_minus * target_s # Scaled target spikes + + # Notes: + # + # a_plus -> How much a spike in src contributes to the eligibility + # a_minus -> How much a spike in trg contributes to the eligibility (neg) + # p_plus -> +a_plus every spike, with decay + # p_minus -> +a_minus every spike, with decay + + # Calculate point eligibility value. + self.eligibility = torch.outer(self.p_plus, target_s) + torch.outer( + source_s, self.p_minus + ) + + super().update() + + def reset_state_variables(self) -> None: + self.eligibility.zero_() + self.eligibility_trace.zero_() + return diff --git a/bindsnet/network/monitors.py b/bindsnet/network/monitors.py index 5367ec0f..f11a2339 100644 --- a/bindsnet/network/monitors.py +++ b/bindsnet/network/monitors.py @@ -10,12 +10,16 @@ from typing import Union, Optional, Iterable, Dict from bindsnet.network.nodes import Nodes -from bindsnet.network.topology import AbstractConnection, AbstractMulticompartmentConnection +from bindsnet.network.topology import ( + AbstractConnection, + AbstractMulticompartmentConnection, +) from bindsnet.network.topology_features import AbstractFeature if TYPE_CHECKING: from .network import Network + class AbstractMonitor(ABC): # language=rst """ @@ -31,7 +35,12 @@ class Monitor(AbstractMonitor): def __init__( self, - obj: Union[Nodes, AbstractConnection, AbstractMulticompartmentConnection, AbstractFeature], + obj: Union[ + Nodes, + AbstractConnection, + AbstractMulticompartmentConnection, + AbstractFeature, + ], state_vars: Iterable[str], time: Optional[int] = None, batch_size: int = 1, @@ -181,7 +190,20 @@ def __init__( self.time, *getattr(self.network.connections[c], v).size() ) - def get(self) -> Dict[str, Dict[str, Union[Nodes, AbstractConnection, AbstractMulticompartmentConnection, AbstractFeature]]]: + def get( + self, + ) -> Dict[ + str, + Dict[ + str, + Union[ + Nodes, + AbstractConnection, + AbstractMulticompartmentConnection, + AbstractFeature, + ], + ], + ]: # language=rst """ Return entire recording to user. diff --git a/bindsnet/network/topology_features.py b/bindsnet/network/topology_features.py index 2ad7f537..f99cf39f 100644 --- a/bindsnet/network/topology_features.py +++ b/bindsnet/network/topology_features.py @@ -545,13 +545,13 @@ def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: if self.enforce_polarity: pos_mask = ~torch.logical_xor(self.value > 0, self.positive_mask) neg_mask = ~torch.logical_xor(self.value < 0, ~self.positive_mask) - self.value = self.value * torch.logical_or(pos_mask , neg_mask) + self.value = self.value * torch.logical_or(pos_mask, neg_mask) self.value[~pos_mask] = 0.0001 self.value[~neg_mask] = -0.0001 - + return_val = self.value * conn_spikes if self.norm_frequency == "time step": - self.normalize(time_step_norm=True) + self.normalize(time_step_norm=True) return return_val @@ -566,13 +566,11 @@ def prime_feature(self, connection, device, **kwargs) -> None: connection, device, enforce_polarity=self.enforce_polarity, **kwargs ) if self.enforce_polarity: - self.positive_mask = ((self.value > 0).sum(1) / self.value.shape[1]) >0.5 + self.positive_mask = ((self.value > 0).sum(1) / self.value.shape[1]) > 0.5 tmp = torch.zeros_like(self.value) - tmp[self.positive_mask,:] = 1 + tmp[self.positive_mask, :] = 1 self.positive_mask = tmp.bool() - - def normalize(self, time_step_norm=False) -> None: # 'time_step_norm' will indicate if normalize is being called from compute() # or from network.py (after a sample is completed) @@ -694,12 +692,12 @@ def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: class AdaptationBaseSynapsHistory(AbstractFeature): def __init__( - self, - name: str, - value: Union[torch.Tensor, float, int] = None, - ann_values: Union[list, tuple] = None, - const_update_rate: float = 0.1, - const_decay: float = 0.001, + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + ann_values: Union[list, tuple] = None, + const_update_rate: float = 0.1, + const_decay: float = 0.001, ) -> None: # language=rst """ @@ -711,8 +709,8 @@ def __init__( :param const_update_rate: The mask upatate rate of the ANN decision. :param const_decay: The spontaneous activation of the synapses. """ - - #Define the ANN + + # Define the ANN class ANN(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(ANN, self).__init__() @@ -721,21 +719,25 @@ def __init__(self, input_size, hidden_size, output_size): def forward(self, x): x = torch.relu(self.fc1(x)) - x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 + x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 return x - - self.init_value = value.clone().detach() # initial mask - self.mask = value # final decision of the ANN - value = torch.zeros_like(value) # initial mask + + self.init_value = value.clone().detach() # initial mask + self.mask = value # final decision of the ANN + value = torch.zeros_like(value) # initial mask self.ann = ANN(ann_values[0].shape[0], ann_values[0].shape[1], 1) - + # load weights from ann_values with torch.no_grad(): self.ann.fc1.weight.data = ann_values[0] self.ann.fc2.weight.data = ann_values[1] self.ann.to(ann_values[0].device) - self.spike_buffer = torch.zeros((value.numel(), ann_values[0].shape[1]), device=ann_values[0].device, dtype=torch.bool) + self.spike_buffer = torch.zeros( + (value.numel(), ann_values[0].shape[1]), + device=ann_values[0].device, + dtype=torch.bool, + ) self.counter = 0 self.start_counter = False self.const_update_rate = const_update_rate @@ -744,41 +746,48 @@ def forward(self, x): super().__init__(name=name, value=value) def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: - + # Update the spike buffer if self.start_counter == False or conn_spikes.sum() > 0: self.start_counter = True - self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = conn_spikes.flatten() + self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = ( + conn_spikes.flatten() + ) self.counter += 1 # Update the masks - if self.counter % self.spike_buffer.shape[1] == 0 : + if self.counter % self.spike_buffer.shape[1] == 0: with torch.no_grad(): ann_decision = self.ann(self.spike_buffer.to(torch.float32)) - self.mask += ann_decision.view(self.mask.shape) * self.const_update_rate # update mask with learning rate fraction - self.mask += self.const_decay # spontaneous activate synapses - self.mask = torch.clamp(self.mask, -1, 1) # cap the mask + self.mask += ( + ann_decision.view(self.mask.shape) * self.const_update_rate + ) # update mask with learning rate fraction + self.mask += self.const_decay # spontaneous activate synapses + self.mask = torch.clamp(self.mask, -1, 1) # cap the mask # self.mask = torch.clamp(self.mask, -1, 1) self.value = (self.mask > 0).float() - + return conn_spikes * self.value - def reset_state_variables(self, ): + def reset_state_variables( + self, + ): self.spike_buffer = torch.zeros_like(self.spike_buffer) self.counter = 0 self.start_counter = False - self.value = self.init_value.clone().detach() # initial mask - pass + self.value = self.init_value.clone().detach() # initial mask + pass + class AdaptationBaseOtherSynaps(AbstractFeature): def __init__( - self, - name: str, - value: Union[torch.Tensor, float, int] = None, - ann_values: Union[list, tuple] = None, - const_update_rate: float = 0.1, - const_decay: float = 0.01, + self, + name: str, + value: Union[torch.Tensor, float, int] = None, + ann_values: Union[list, tuple] = None, + const_update_rate: float = 0.1, + const_decay: float = 0.01, ) -> None: # language=rst """ @@ -790,8 +799,8 @@ def __init__( :param const_update_rate: The mask upatate rate of the ANN decision. :param const_decay: The spontaneous activation of the synapses. """ - - #Define the ANN + + # Define the ANN class ANN(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(ANN, self).__init__() @@ -800,21 +809,25 @@ def __init__(self, input_size, hidden_size, output_size): def forward(self, x): x = torch.relu(self.fc1(x)) - x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 + x = torch.tanh(self.fc2(x)) # MUST HAVE output between -1 and 1 return x - - self.init_value = value.clone().detach() # initial mask - self.mask = value # final decision of the ANN - value = torch.zeros_like(value) # initial mask + + self.init_value = value.clone().detach() # initial mask + self.mask = value # final decision of the ANN + value = torch.zeros_like(value) # initial mask self.ann = ANN(ann_values[0].shape[0], ann_values[0].shape[1], 1) - + # load weights from ann_values with torch.no_grad(): self.ann.fc1.weight.data = ann_values[0] self.ann.fc2.weight.data = ann_values[1] self.ann.to(ann_values[0].device) - self.spike_buffer = torch.zeros((value.numel(), ann_values[0].shape[1]), device=ann_values[0].device, dtype=torch.bool) + self.spike_buffer = torch.zeros( + (value.numel(), ann_values[0].shape[1]), + device=ann_values[0].device, + dtype=torch.bool, + ) self.counter = 0 self.start_counter = False self.const_update_rate = const_update_rate @@ -823,32 +836,39 @@ def forward(self, x): super().__init__(name=name, value=value) def compute(self, conn_spikes) -> Union[torch.Tensor, float, int]: - + # Update the spike buffer if self.start_counter == False or conn_spikes.sum() > 0: self.start_counter = True - self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = conn_spikes.flatten() + self.spike_buffer[:, self.counter % self.spike_buffer.shape[1]] = ( + conn_spikes.flatten() + ) self.counter += 1 # Update the masks - if self.counter % self.spike_buffer.shape[1] == 0 : + if self.counter % self.spike_buffer.shape[1] == 0: with torch.no_grad(): ann_decision = self.ann(self.spike_buffer.to(torch.float32)) - self.mask += ann_decision.view(self.mask.shape) * self.const_update_rate # update mask with learning rate fraction - self.mask += self.const_decay # spontaneous activate synapses - self.mask = torch.clamp(self.mask, -1, 1) # cap the mask + self.mask += ( + ann_decision.view(self.mask.shape) * self.const_update_rate + ) # update mask with learning rate fraction + self.mask += self.const_decay # spontaneous activate synapses + self.mask = torch.clamp(self.mask, -1, 1) # cap the mask # self.mask = torch.clamp(self.mask, -1, 1) self.value = (self.mask > 0).float() - + return conn_spikes * self.value - def reset_state_variables(self, ): + def reset_state_variables( + self, + ): self.spike_buffer = torch.zeros_like(self.spike_buffer) self.counter = 0 self.start_counter = False - self.value = self.init_value.clone().detach() # initial mask - pass + self.value = self.init_value.clone().detach() # initial mask + pass + ### Sub Features ### From af26b5eee6ff3ea31f3a18a4d25a71f92e994333 Mon Sep 17 00:00:00 2001 From: Hananel Hazan Date: Tue, 15 Oct 2024 13:34:26 -0400 Subject: [PATCH 26/27] update contributors --- README.md | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index f160b3ce..b6ce35f4 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,8 @@ A Python package used for simulating spiking neural networks (SNNs) on CPUs or G BindsNET is a spiking neural network simulation library geared towards the development of biologically inspired algorithms for machine learning. -This package is used as part of ongoing research on applying SNNs to machine learning (ML) and reinforcement learning (RL) problems in the [Biologically Inspired Neural & Dynamical Systems (BINDS) lab](http://binds.cs.umass.edu/). +This package is used as part of ongoing research on applying SNNs, machine learning (ML) and reinforcement learning (RL) problems in the [Biologically Inspired Neural & Dynamical Systems (BINDS) lab](http://binds.cs.umass.edu/) and the Allen Discovery Center at Tufts University. + Check out the [BindsNET examples](https://github.com/BindsNET/bindsnet/tree/master/examples) for a collection of experiments, functions for the analysis of results, plots of experiment outcomes, and more. Documentation for the package can be found [here](https://bindsnet-docs.readthedocs.io). @@ -129,11 +130,22 @@ If you use BindsNET in your research, please cite the following [article](https: ## Contributors -- Daniel Saunders ([email](mailto:djsaunde@cs.umass.edu)) -- Hananel Hazan ([email](mailto:hananel@hazan.org.il)) -- Darpan Sanghavi ([email](mailto:dsanghavi@cs.umass.edu)) -- Hassaan Khan ([email](mailto:hqkhan@umass.edu)) -- Devdhar Patel ([email](mailto:devdharpatel@cs.umass.edu)) +- Hava Siegelmann - Director of BINDS lab at UMass +- Robert Kozma - Co-Director of BINDS lab (2018-2019) +- Hananel Hazan ([email](mailto:hananel@hazan.org.il)) - Spearheaded BindsNET and its main maintainer. +- Daniel Saunders ([email](mailto:djsaunde@cs.umass.edu)) - MSc student, BindsNET core functions coder (2018-2019). +- Darpan Sanghavi ([email](mailto:dsanghavi@cs.umass.edu)) - MSc student BINDS Lab (2018) +- Hassaan Khan ([email](mailto:hqkhan@umass.edu)) - MSc student BINDS Lab (2018) +- Devdhar Patel ([email](mailto:devdharpatel@cs.umass.edu)) - MSc student BINDS Lab (2018) +- Simon Caby [github](https://github.com/SimonInParis) +- Christopher Earl ([email](mailto:cearl@umass.edu)) - MSc student (2021 - present) + + + + + + +Made with [contrib.rocks](https://contrib.rocks). ## License GNU Affero General Public License v3.0 From 1b9786152db6fc67a38d2ddb3090ac434bca239f Mon Sep 17 00:00:00 2001 From: Hananel Hazan Date: Fri, 18 Oct 2024 13:17:10 -0400 Subject: [PATCH 27/27] bump version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index c361c10e..4665c1ed 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "bindsnet" -version = "0.3.2" +version = "0.3.3" description = "Spiking neural networks for ML in Python" authors = [ "Hananel Hazan ", "Daniel Saunders", "Darpan Sanghavi", "Hassaan Khan" ] license = "AGPL-3.0-only"