From 8f584226d2ad5fd1a790707830c82f981ba3339e Mon Sep 17 00:00:00 2001 From: Pablo Carmona Gonzalez Date: Mon, 12 Aug 2024 13:08:45 +0200 Subject: [PATCH 01/14] feat(docs): add half-precision training section in using_simulator docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Pablo Carmona Gonzalez Signed-off-by: Pablo Carmona González --- docs/source/using_simulator.rst | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/docs/source/using_simulator.rst b/docs/source/using_simulator.rst index 25688ba3..6b257470 100644 --- a/docs/source/using_simulator.rst +++ b/docs/source/using_simulator.rst @@ -399,6 +399,21 @@ instead of manually specifying a ``RPU Configuration``:: tile = AnalogTile(10, 20, rpu_config=TikiTakaEcRamPreset()) +Working with half-precision training +------------------------------------ + +The simulator supports half-precision training. This can be enabled by setting the +``RPUDataType`` to ``HALF`` when creating the configuration:: + + from aihwkit.simulator.configs import InferenceRPUConfig + from aihwkit.simulator.parameters.enums import RPUDataType + + rpu_config = InferenceRPUConfig() # or TorchInferenceRPUConfig(). + rpu_config.runtime.data_type = RPUDataType.HALF + +For more info look into :py:mod:`aihwkit.simulator.parameters.enums.RPUDataType`. + + .. _Gokmen & Haensch 2020: https://www.frontiersin.org/articles/10.3389/fnins.2020.00103/full .. _Example 7: https://github.com/IBM/aihwkit/blob/master/examples/07_simple_layer_with_other_devices.py .. _Example 8: https://github.com/IBM/aihwkit/blob/master/examples/08_simple_layer_with_tiki_taka.py From 0e8cdde8017a540bd44e66bcbe2a2f5f0feabbfa Mon Sep 17 00:00:00 2001 From: Pablo Carmona Gonzalez Date: Mon, 12 Aug 2024 17:53:53 +0200 Subject: [PATCH 02/14] feat(examples): add example 31 for half precision training MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Pablo Carmona Gonzalez Signed-off-by: Pablo Carmona González --- examples/31_half_precision_training.py | 83 ++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 examples/31_half_precision_training.py diff --git a/examples/31_half_precision_training.py b/examples/31_half_precision_training.py new file mode 100644 index 00000000..ad4a57e4 --- /dev/null +++ b/examples/31_half_precision_training.py @@ -0,0 +1,83 @@ +# type: ignore +# pylint: disable-all +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""aihwkit example 31: Using half precision training. + +This example demonstrates how to use half precision training with aihwkit. + +""" +# pylint: disable=invalid-name + +import tqdm +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import datasets, transforms +from aihwkit.simulator.configs import InferenceRPUConfig, TorchInferenceRPUConfig +from aihwkit.nn.conversion import convert_to_analog +from aihwkit.optim import AnalogSGD +from aihwkit.simulator.parameters.enums import RPUDataType + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + +class Net(nn.Module): + def __init__(self): + super(Net, self).__init__() + self.conv1 = nn.Conv2d(1, 32, 3, 1) + self.conv2 = nn.Conv2d(32, 64, 3, 1) + self.dropout1 = nn.Dropout(0.25) + self.dropout2 = nn.Dropout(0.5) + self.fc1 = nn.Linear(9216, 128) + self.fc2 = nn.Linear(128, 10) + + def forward(self, x): + x = self.conv1(x) + x = F.relu(x) + x = self.conv2(x) + x = F.relu(x) + x = F.max_pool2d(x, 2) + x = self.dropout1(x) + x = torch.flatten(x, 1) + x = self.fc1(x) + x = F.relu(x) + x = self.dropout2(x) + x = self.fc2(x) + output = F.log_softmax(x, dim=1) + return output + +if __name__ == "__main__": + model = Net() + rpu_config = TorchInferenceRPUConfig() + model = convert_to_analog(model, rpu_config) + nll_loss = torch.nn.NLLLoss() + transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,)) + ]) + dataset = datasets.MNIST('data', train=True, download=True, transform=transform) + train_loader = torch.utils.data.DataLoader(dataset, batch_size=32) + + model = model.to(device=device, dtype=torch.bfloat16) + optimizer = AnalogSGD(model.parameters(), lr=0.1) + model = model.train() + + pbar = tqdm.tqdm(enumerate(train_loader)) + for batch_idx, (data, target) in pbar: + data, target = data.to(device=device, dtype=torch.bfloat16), target.to(device=device) + optimizer.zero_grad() + output = model(data) + loss = F.nll_loss(output.float(), target) + loss.backward() + optimizer.step() + pbar.set_description(f"Loss {loss:.4f}") \ No newline at end of file From 77bcc0b922e2bb584cb1c0a035f51c16610dc8da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julian=20B=C3=BCchel?= Date: Fri, 16 Aug 2024 13:49:21 +0200 Subject: [PATCH 03/14] Fix dtype context (#681) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Draft fix * Remove DS Store * Ran mypy and pylint and passing * add ignore on unused ctx params temporarly for linting pass --------- Co-authored-by: Pablo Carmona Gonzalez Signed-off-by: Pablo Carmona González --- src/aihwkit/extension/functions.py | 6 +++--- src/aihwkit/inference/calibration/calibration.py | 2 +- src/aihwkit/simulator/tiles/module.py | 1 + 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/aihwkit/extension/functions.py b/src/aihwkit/extension/functions.py index 554600ca..9f32825a 100644 --- a/src/aihwkit/extension/functions.py +++ b/src/aihwkit/extension/functions.py @@ -27,14 +27,14 @@ class FloatPrecisionCastFunction(Function): @staticmethod def forward( - ctx: Any, input_: Tensor, exponent: int = 8, mantissa: int = 7, saturate_to_inf: bool = True + _: Any, input_: Tensor, exponent: int = 8, mantissa: int = 7, saturate_to_inf: bool = True ) -> Tensor: - # pylint: disable=arguments-differ + # pylint: disable=unused-argument, arguments-differ return ops.float_precision_cast(input_, exponent, mantissa, saturate_to_inf) @staticmethod def backward(ctx: Any, grad_in: Tensor) -> Tensor: - # pylint: disable=arguments-differ + # pylint: disable=unused-argument, arguments-differ return grad_in diff --git a/src/aihwkit/inference/calibration/calibration.py b/src/aihwkit/inference/calibration/calibration.py index 27352cf9..a3a3fcc9 100644 --- a/src/aihwkit/inference/calibration/calibration.py +++ b/src/aihwkit/inference/calibration/calibration.py @@ -240,7 +240,7 @@ def calibrate_input_ranges( # Pass through the samples progress_bar = tqdm if verbose else lambda x: x - for args, kwargs in progress_bar(dataloader): + for args, kwargs in progress_bar(dataloader): # type: ignore model(*args, **kwargs) # Remove hooks diff --git a/src/aihwkit/simulator/tiles/module.py b/src/aihwkit/simulator/tiles/module.py index ed8fb17d..1d4dc0e0 100644 --- a/src/aihwkit/simulator/tiles/module.py +++ b/src/aihwkit/simulator/tiles/module.py @@ -244,6 +244,7 @@ def to(self, *args: Any, **kwargs: Any) -> "TileModule": self._apply_without_context(lambda t: t.to(*new_args, **kwargs)) if dtype is not None: + self.analog_ctx.to(dtype=dtype) scales = self.get_scales() if scales is not None: self.set_scales(scales) From d0f5f28cd1f50780d2dcf9c8868d065fe3c517c1 Mon Sep 17 00:00:00 2001 From: Pablo Carmona Gonzalez Date: Mon, 19 Aug 2024 12:24:26 +0200 Subject: [PATCH 04/14] format example with black MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Pablo Carmona González --- examples/31_half_precision_training.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/examples/31_half_precision_training.py b/examples/31_half_precision_training.py index ad4a57e4..69ae9eb6 100644 --- a/examples/31_half_precision_training.py +++ b/examples/31_half_precision_training.py @@ -31,6 +31,7 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + class Net(nn.Module): def __init__(self): super(Net, self).__init__() @@ -55,29 +56,31 @@ def forward(self, x): x = self.fc2(x) output = F.log_softmax(x, dim=1) return output - + + if __name__ == "__main__": model = Net() rpu_config = TorchInferenceRPUConfig() - model = convert_to_analog(model, rpu_config) + model = convert_to_analog(model, rpu_config) nll_loss = torch.nn.NLLLoss() - transform=transforms.Compose([ - transforms.ToTensor(), - transforms.Normalize((0.1307,), (0.3081,)) - ]) - dataset = datasets.MNIST('data', train=True, download=True, transform=transform) + transform = transforms.Compose( + [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))] + ) + dataset = datasets.MNIST("data", train=True, download=True, transform=transform) train_loader = torch.utils.data.DataLoader(dataset, batch_size=32) - + model = model.to(device=device, dtype=torch.bfloat16) optimizer = AnalogSGD(model.parameters(), lr=0.1) model = model.train() - + pbar = tqdm.tqdm(enumerate(train_loader)) for batch_idx, (data, target) in pbar: - data, target = data.to(device=device, dtype=torch.bfloat16), target.to(device=device) + data, target = data.to(device=device, dtype=torch.bfloat16), target.to( + device=device + ) optimizer.zero_grad() output = model(data) loss = F.nll_loss(output.float(), target) loss.backward() optimizer.step() - pbar.set_description(f"Loss {loss:.4f}") \ No newline at end of file + pbar.set_description(f"Loss {loss:.4f}") From 00424786ccbfb1d5807b580b4a7290e3318053fb Mon Sep 17 00:00:00 2001 From: pablocarmona Date: Wed, 18 Sep 2024 19:10:41 +0200 Subject: [PATCH 05/14] add release content for 0.9.2 (#685) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add release content for 0.9.2 Signed-off-by: Pablo Carmona * remove added patch text Signed-off-by: Pablo Carmona * modify changelog.md and version Signed-off-by: Pablo Carmona * ufix(examples/31_custom_drift_models.py): change way rpu config is setup to a cleaner way Signed-off-by: Pablo Carmona * fix(examples/31_custom_drift_models.py): fix errors with pycodestyle Signed-off-by: Pablo Carmona * feat(notebooks): clean up and enhacenments on notebook contents for clarification and typos fixings * feat(converter/conductance): new conductance converters development * updates to custom drift model suggested by Malte (#690) Co-authored-by: Charles Mackin * Update hermes.py (#691) * fix(hermes.py): fix linting errors related to whitespacing * fix(requirements.txt): solve problem with numpy versions in some cases * feat(CHANGELOG.md): add PR number for new related developments and modify the date of release to a proper one * feat(CHANGELOG.md): add PR number for new related developments and modify the date of release to a proper one * feat(travis): update travis build with latest pytorch version --------- Signed-off-by: Pablo Carmona Co-authored-by: charlesmackin <45808803+charlesmackin@users.noreply.github.com> Co-authored-by: Charles Mackin Co-authored-by: Athanasios Vasilopoulos <152185220+atvasilopoulos@users.noreply.github.com> Signed-off-by: Pablo Carmona González --- .travis.yml | 16 +- CHANGELOG.md | 14 + docs/source/pcm_inference.rst | 10 +- examples/31_custom_drift_models.py | 156 ++++++ examples/32_weight_programming_options.py | 200 ++++++++ notebooks/hermes/hermes_noise_model.ipynb | 453 ++++++++++++++++++ notebooks/hermes/hermes_noise_model_mvm.ipynb | 176 +++++++ .../iscas_tutorial/mobilebert_squad.ipynb | 20 +- requirements-examples.txt | 1 + requirements.txt | 2 +- src/aihwkit/VERSION.txt | 2 +- src/aihwkit/inference/__init__.py | 9 +- src/aihwkit/inference/compensation/drift.py | 21 + .../inference/converter/conductance.py | 275 ++++++++++- src/aihwkit/inference/noise/hermes.py | 283 +++++++++++ src/aihwkit/inference/noise/pcm.py | 147 +++++- src/aihwkit/nn/modules/conv.py | 8 +- .../simulator/tiles/analog_mvm_irdrop_t.py | 214 +++++---- tests/test_inference.py | 134 ++++++ 19 files changed, 2027 insertions(+), 114 deletions(-) create mode 100644 examples/31_custom_drift_models.py create mode 100644 examples/32_weight_programming_options.py create mode 100644 notebooks/hermes/hermes_noise_model.ipynb create mode 100644 notebooks/hermes/hermes_noise_model_mvm.ipynb create mode 100644 src/aihwkit/inference/noise/hermes.py diff --git a/.travis.yml b/.travis.yml index 94889ae1..7adc97a2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -94,11 +94,11 @@ jobs: if: branch =~ /^release\/.*$/ env: # Use a specific torch version. - - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.0.1'" - - CIBW_BEFORE_BUILD="pip install torch==2.0.1 torchvision && pip install -r requirements.txt" + - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.4.1'" + - CIBW_BEFORE_BUILD="pip install torch==2.4.1 torchvision && pip install -r requirements.txt" - CIBW_MANYLINUX_X86_64_IMAGE="aihwkit/manylinux2014_x86_64_aihwkit" - CIBW_REPAIR_WHEEL_COMMAND="auditwheel repair -w {dest_dir} {wheel} --exclude libtorch_python.so" - - CIBW_BUILD="cp38-manylinux_x86_64 cp39-manylinux_x86_64 cp310-manylinux_x86_64" + - CIBW_BUILD="cp38-manylinux_x86_64 cp39-manylinux_x86_64 cp310-manylinux_x86_64 cp311-manylinux_x86_64" before_install: - docker pull aihwkit/manylinux2014_x86_64_aihwkit install: @@ -120,8 +120,8 @@ jobs: update: true env: # Use a specific torch version. - - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.0.1'" - - CIBW_BEFORE_BUILD="pip install torch==2.0.1 torchvision && pip install ./delocate && pip install -r requirements.txt" + - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.4.1'" + - CIBW_BEFORE_BUILD="pip install torch==2.4.1 torchvision && pip install ./delocate && pip install -r requirements.txt" - CIBW_BUILD="cp38-macosx_x86_64 cp39-macosx_x86_64" before_install: - git clone -b aihwkit https://github.com/aihwkit-bot/delocate.git @@ -139,9 +139,9 @@ jobs: if: branch =~ /^release\/win.*$/ env: # Use a specific torch version. - - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.0.1'" - - CIBW_BEFORE_BUILD="pip install torch==2.0.1 && pip install -r requirements.txt" - - CIBW_BUILD="cp37-win_amd64 cp38-win_amd64 cp39-win_amd64 cp310-win_amd64" + - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.4.1'" + - CIBW_BEFORE_BUILD="pip install torch==2.4.1 && pip install -r requirements.txt" + - CIBW_BUILD="cp38-win_amd64 cp39-win_amd64 cp310-win_amd64" # Use unzipped OpenBLAS. - OPENBLAS_ROOT=C:\\BLAS - OPENBLAS_ROOT_DIR=C:\\BLAS diff --git a/CHANGELOG.md b/CHANGELOG.md index 571710a7..6a9b8330 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,20 @@ The format is based on [Keep a Changelog], and this project adheres to * `Fixed` for any bug fixes. * `Security` in case of vulnerabilities. +## [0.9.2] - 2024/09/18 + +### Added + +* Added new Hermes noise model and related notebooks (\#685) +* Added new conductance converters (\#685) +* Make Conv layers also compatible with non-batched inputs (\#685) +* Added per column drift compensation (\#685) +* Added custom drifts (\#685) + +### Changed + +* Update requirements-examples.txt (\#685) + ## [0.9.1] - 2024/05/16 ### Added diff --git a/docs/source/pcm_inference.rst b/docs/source/pcm_inference.rst index 138a7089..e92bccf7 100644 --- a/docs/source/pcm_inference.rst +++ b/docs/source/pcm_inference.rst @@ -121,6 +121,12 @@ The fits between these equations and the hardware measurements are shown below: .. image:: ../img/pcm_drift_plot.png :alt: +Users can also provide custom drift characteristics to override the default drift model, +which can be used to evaluate the performance and trade-offs of different devices +:ref:`[6] `. See +`example 31 `_ +for an example on how to customize drift models. + Read noise ---------- @@ -225,4 +231,6 @@ References * [5] Le Gallo, M., Krebs, D., Zipoli, F., Salinga, M., & Sebastian, A. `Collective Structural Relaxation in Phase‐Change Memory Devices `_. Advanced Electronic Materials, 4(9), 1700627. 2018 -* [6] Le Gallo, M., Sebastian, A., Cherubini, G., Giefers, H., & Eleftheriou, E. `Compressed sensing with approximate message passing using in-memory computing `_. IEEE Transactions on Electron Devices, 65(10), 4304-4312. 2018 +* [6] N. Li, C. Mackin, A. Chen, K. Brew, T. Philip, A. Simon, I. Saraf, J.-P. Han, S. G. Sarwat, G. W. Burr, M. Rasch, A. Sebastian, V. Narayanan, N. Saulnier. `Optimization of Projected Phase Change Memory for Analog In-Memory Computing Inference `_. Advanced Electronic Materials, 9, 2201190. 2023 + +* [7] Le Gallo, M., Sebastian, A., Cherubini, G., Giefers, H., & Eleftheriou, E. `Compressed sensing with approximate message passing using in-memory computing `_. IEEE Transactions on Electron Devices, 65(10), 4304-4312. 2018 diff --git a/examples/31_custom_drift_models.py b/examples/31_custom_drift_models.py new file mode 100644 index 00000000..516080c1 --- /dev/null +++ b/examples/31_custom_drift_models.py @@ -0,0 +1,156 @@ +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""aihwkit example 31: customized conductance drift models + +Simple 1-layer network that demonstrates user-defined drift model +capability and impact on output over time due to drift. + +Reference paper evaluating a number of different conductance-dependent +drift models exhibiting complex characteristics: +https://onlinelibrary.wiley.com/doi/full/10.1002/aelm.202201190 +""" +# pylint: disable=invalid-name +from numpy import asarray + +# Imports from PyTorch. +from torch import ( + zeros, + ones, + mean, + std, + linspace, +) +import matplotlib.pyplot as plt + +# Imports from aihwkit. +from aihwkit.nn import AnalogLinear +from aihwkit.simulator.rpu_base import cuda +from aihwkit.inference.converter.conductance import SinglePairConductanceConverter +from aihwkit.inference.noise.pcm import CustomDriftPCMLikeNoiseModel +from aihwkit.simulator.parameters.enums import BoundManagementType +from aihwkit.simulator.parameters.io import IOParameters +from aihwkit.simulator.configs import TorchInferenceRPUConfig + +g_min, g_max = 0.0, 25. +# define custom drift model +custom_drift_model = dict(g_lst=[g_min, 10., g_max], + nu_mean_lst=[0.08, 0.05, 0.03], + nu_std_lst=[0.03, 0.02, 0.01]) + +t_inference_times = [1, # 1 sec + 60, # 1 min + 60 * 60, # 1 hour + 24 * 60 * 60, # 1 day + 30 * 24 * 60 * 60, # 1 month + 12 * 30 * 24 * 60 * 60, # 1 year + ] + +IN_FEATURES = 512 +OUT_FEATURES = 512 +BATCH_SIZE = 1 + +# define rpu_config +io_params = IOParameters( + bound_management=BoundManagementType.NONE, + nm_thres=1.0, + inp_res=2 ** 8 - 2, + out_bound=-1, + out_res=-1, + out_noise=0.0) + +noise_model = CustomDriftPCMLikeNoiseModel(custom_drift_model, + prog_noise_scale=0.0, # turn off to show drift only + read_noise_scale=0.0, # turn off to show drift only + drift_scale=1.0, + g_converter=SinglePairConductanceConverter(g_min=g_min, + g_max=g_max), + ) + +rpu_config = TorchInferenceRPUConfig(noise_model=noise_model, forward=io_params) + +# define simple model, weights, and activations +model = AnalogLinear(IN_FEATURES, OUT_FEATURES, bias=False, rpu_config=rpu_config) +weights = linspace(custom_drift_model['g_lst'][0], + custom_drift_model['g_lst'][-1], + OUT_FEATURES).repeat(IN_FEATURES, 1) +x = ones(BATCH_SIZE, IN_FEATURES) + +# set weights +for name, layer in model.named_analog_layers(): + layer.set_weights(weights.T, zeros(OUT_FEATURES)) + +# Move the model and tensors to cuda if it is available +if cuda.is_compiled(): + x = x.cuda() + model = model.cuda() + +model.eval() +model.drift_analog_weights(t_inference_times[0]) # generate drift (nu) coefficients + +# Extract drift coefficients nu as a function of conductance +g_lst, _ = rpu_config.noise_model.g_converter.convert_to_conductances(weights) +nu_lst = model.analog_module.drift_noise_parameters + +# Get mean and std drift coefficient (nu) as function of conductance +gs = mean(g_lst[0], dim=0).numpy() +nu_mean = mean(nu_lst[0].T, dim=0).numpy() +nu_std = std(nu_lst[0].T, dim=0).numpy() + +# Plot device drift model +plt.figure() +plt.plot(gs, nu_mean) +plt.fill_between(gs, nu_mean - nu_std, nu_mean + nu_std, alpha=0.2) +plt.xlabel(r"$Conductance \ [\mu S]$") +plt.ylabel(r"$\nu \ [1]$") +plt.tight_layout() +plt.savefig('custom_drift_model.png') +plt.close() + +# create simple linear layer model +model = AnalogLinear(IN_FEATURES, OUT_FEATURES, bias=False, rpu_config=rpu_config) + +# define weights, activations +weights = (1. / 512.) * ones(IN_FEATURES, OUT_FEATURES) +x = ones(BATCH_SIZE, IN_FEATURES) + +# set weights +for _, layer in model.named_analog_layers(): + layer.set_weights(weights.T, zeros(OUT_FEATURES)) + +# Move the model and tensors to cuda if it is available +if cuda.is_compiled(): + x = x.cuda() + model = model.cuda() + +# Eval model at different time steps +model.eval() +out_lst = [] +for t_inference in t_inference_times: + model.drift_analog_weights(t_inference) # generate new nu coefficients at each time step + out = model(x) + out_lst.append(out) + +# Plot drift compensated outputs as a function of time +t = asarray(t_inference_times) +out_mean = asarray([mean(out).detach().cpu().numpy() for out in out_lst]) +out_std = asarray([std(out).detach().cpu().numpy() for out in out_lst]) +plt.figure() +plt.plot(t, out_mean) +plt.fill_between(t, out_mean - out_std, out_mean + out_std, alpha=0.2) +plt.xscale("log") +plt.xticks(t, ['1 sec', '1 min', '1 hour', '1 day', '1 month', '1 year'], rotation='vertical') +plt.xlabel(r"$Time$") +plt.ylabel(r"$Drift \ Compensated \ Outputs \ [1]$") +plt.tight_layout() +plt.savefig('custom_drift_model_output.png') +plt.close() diff --git a/examples/32_weight_programming_options.py b/examples/32_weight_programming_options.py new file mode 100644 index 00000000..b8f93d2e --- /dev/null +++ b/examples/32_weight_programming_options.py @@ -0,0 +1,200 @@ +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""aihwkit example 32: weight programming options + +Showcases four different weight programming options: + + 1. SinglePairConductanceConverter - conventional mode uses 1 pair of analog + memory devices per unit cell. + + 2. DualPairConductanceConverter - mode uses 2 pair of analog memory devices + per unit cell, with significance between the two pair determined by f_lst. + Only programs in more signifance pair once the range of the lower significant + pair has been exhausted. This helps to prevent unnecessary amplification of + programming errors and read noise. + + 3. NPairConductanceConverter - allows for N pairs of analog memory devices + per unit cell, with significance between the pairs determined by f_lst. + Only programs in more signifance pair once the range of the lower significant + pair has been exhausted. This helps to prevent unnecessary amplification of + programming errors and read noise. This is a generalized form of the + DualPairConductanceConverter. + + 4. CustomPairConductanceConverter - enables more complex and custom weight + programming strategies across N pairs of analog memory devices. Similary, + f_lst specifies the relative significance between pairs. Enables weight + programming strategies such as those detailed in + + C. Mackin, et al., "Optimised weight programming for analogue memory-based + deep neural networks" 2022. https://www.nature.com/articles/s41467-022-31405-1 + +""" +# pylint: disable=invalid-name +from typing import Type + +# Imports for distrubtion generation +from random import uniform + +# Imports for plotting +import matplotlib.pyplot as plt + +# Imports from PyTorch +from torch import zeros, randn, clamp, linspace, allclose, Tensor + +# Imports from aihwkit +from aihwkit.nn import AnalogLinear +from aihwkit.inference.converter.conductance import ( + BaseConductanceConverter, + SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter +) +from aihwkit.inference import PCMLikeNoiseModel +from aihwkit.simulator.configs import InferenceRPUConfig + +# specifications +IN_FEATURES = 512 +OUT_FEATURES = 512 +BATCH_SIZE = 10 +SEGMENTS = 32 +USE_CUDA = True + +time_dict = {'1 second': 1, + '1 month' : 1 * 60 * 60 * 24 * 30} + +g_min, g_max = 0.1, 15. +single_pair_g_converter = SinglePairConductanceConverter(g_min=g_min, g_max=g_max) +dual_pair_g_converter = DualPairConductanceConverter(f_lst=[1.0, 3.0], g_min=g_min, g_max=g_max) +npair_g_converter = NPairConductanceConverter(f_lst=[1.0, 2.0, 3.0], g_min=g_min, g_max=g_max) + +# custom programming model A (curved) +k_lst = [0.5, 0.8] +g_plus_ = [g_min] + [k * (g_max - g_min) + g_min for k in k_lst] + [g_max] +g_minus_ = [g_min] + [(k - (i / (len(k_lst) + 1))) * (g_max - g_min) + g_min + for i, k in enumerate(k_lst, 1)] + [g_min] +g_plus = g_minus_[::-1][:-1] + g_plus_ +g_minus = g_plus_[::-1][:-1] + g_minus_ +prog_model = {'A': [g_plus, g_minus]} + +# custom programming model B (random) +n_pts = 5 +w_pts = linspace(0, 1, n_pts).detach().cpu().numpy().tolist() +lower_bounds = [(g_max - g_min) * w + g_min for w in w_pts] +g_plus_ = [uniform(lb, g_max) for lb in lower_bounds] +g_minus_ = [g - lb + g_min for g, lb in zip(g_plus_, lower_bounds)] +g_plus = g_minus_[::-1][:-1] + g_plus_ +g_minus = g_plus_[::-1][:-1] + g_minus_ +prog_model.update({'B': [g_plus, g_minus]}) + +custom_g_converter = CustomPairConductanceConverter(f_lst=[1.0], + g_lst=prog_model['A'], + g_min=g_min, + g_max=g_max, + invertibility_test=True) + + +def plot_weights(g_converter: Type[BaseConductanceConverter], + ideal_weights: Tensor, + drifted_weights: Tensor, + suffix: str = '') -> None: + """Plots weight programming strategy + """ + + g_lst, params = g_converter.convert_to_conductances(drifted_weights) + return_weights = g_converter.convert_back_to_weights(g_lst, params) + + assert allclose(drifted_weights, return_weights, atol=0.0001), \ + "conversion error: weights don't match for %s" % str(g_converter) + + g_converter_name = str(g_converter).split('(', maxsplit=1)[0] + rows = int(len(g_lst) / 2) + 1 + width, height = 7, 4 + plt.subplots(rows, 1, figsize=(width, rows * height)) + plt.subplot(rows, 1, 1) + if suffix != 'ideal': + title_str = "%s @ %s" % (g_converter_name, suffix) + else: + title_str = "Ideal %s" % g_converter_name + plt.title(title_str) + plt.plot(ideal_weights.detach().cpu().numpy().flatten(), + return_weights.detach().cpu().numpy().flatten(), + '.', + ms=1) + plt.xlabel(r"$Ideal \ Weights \ [1]$") + plt.ylabel(r"$Actual \ Weights \ [1]$") + + for i, (gp, gm) in enumerate(zip(g_lst[::2], g_lst[1::2])): + plt.subplot(rows, 1, i + 2) + plt.plot(ideal_weights.detach().cpu().numpy().flatten(), + gp.detach().cpu().numpy().flatten(), + '.', + ms=1, + label=r"$G^+_%d$" % i) + plt.plot(ideal_weights.detach().cpu().numpy().flatten(), + gm.detach().cpu().numpy().flatten(), + '.', + ms=1, + label=r"$G^-_%d$" % i) + plt.legend() + plt.xlabel(r"$Ideal \ Weights \ [1]$") + plt.ylabel(r"$Conductance \ [\mu S]$") + + plt.savefig("%s_%s.png" % (g_converter_name, suffix)) + plt.close() + + +def main(): + """Compare weight programming strategies (i.e. g_converters) + """ + + # create dataset + x = clamp((1.0 / 3.0) * randn(BATCH_SIZE, IN_FEATURES), min=-1, max=1) + ideal_weights = clamp((1.0 / 3.0) * randn(IN_FEATURES, OUT_FEATURES), min=-1, max=1) + + # compare each g_converter + for g_converter in [single_pair_g_converter, + dual_pair_g_converter, + npair_g_converter, + custom_g_converter]: + + # g_converter applied to ideal weights + plot_weights(g_converter, ideal_weights, ideal_weights, 'ideal') + + # create simple model using g_converter + rpu_config = InferenceRPUConfig() + rpu_config.noise_model = PCMLikeNoiseModel(prog_noise_scale=1.0, + read_noise_scale=1.0, + drift_scale=1.0, + g_converter=g_converter) + model = AnalogLinear(IN_FEATURES, OUT_FEATURES, bias=False, rpu_config=rpu_config) + + # set weights + for _, layer in model.named_analog_layers(): + layer.set_weights(ideal_weights.T, zeros(OUT_FEATURES)) + + # compare programming strategies at different time steps + model.eval() + for t_name, t_inference in time_dict.items(): + + model.drift_analog_weights(t_inference) + _ = model(x) # dummy inference applies programming errors and read noise + drifted_weights, _ = model.get_weights() + + # g_converter applied to non-ideal weights + plot_weights(g_converter, ideal_weights, drifted_weights.T, suffix="%s" % t_name) + + +if __name__ == "__main__": + + main() diff --git a/notebooks/hermes/hermes_noise_model.ipynb b/notebooks/hermes/hermes_noise_model.ipynb new file mode 100644 index 00000000..9e2b7e5a --- /dev/null +++ b/notebooks/hermes/hermes_noise_model.ipynb @@ -0,0 +1,453 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "3S0YWetZ-a2m" + }, + "source": [ + "# IBM Analog Hardware Acceleration Kit (AIHWKIT): Inference using noise models characterized on the IBM HERMES Project Chip\n", + "\n", + "Le Gallo, M., Khaddam-Aljameh, R., Stanisavljevic, M. et al. A 64-core mixed-signal in-memory compute chip based on phase-change memory for deep neural network inference. Nat Electron 6, 680–693 (2023). https://doi.org/10.1038/s41928-023-01010-1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "form", + "id": "8dRBAFI2xcEK", + "jupyter": { + "source_hidden": true + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# various utility functions\n", + "import torch\n", + "import torch.nn.functional as F\n", + "import torch.nn.init as init\n", + "import torchvision\n", + "import numpy as np\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "\n", + "def _weights_init(m):\n", + " if isinstance(m, torch.nn.Linear) or isinstance(m, torch.nn.Conv2d):\n", + " init.kaiming_normal_(m.weight)\n", + "\n", + "\n", + "class LambdaLayer(torch.nn.Module):\n", + " def __init__(self, lambd):\n", + " super(LambdaLayer, self).__init__()\n", + " self.lambd = lambd\n", + "\n", + " def forward(self, x):\n", + " return self.lambd(x)\n", + "\n", + "\n", + "class BasicBlock(torch.nn.Module):\n", + " expansion = 1\n", + "\n", + " def __init__(self, in_planes, planes, stride=1, option=\"A\"):\n", + " super(BasicBlock, self).__init__()\n", + " self.conv1 = torch.nn.Conv2d(\n", + " in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False\n", + " )\n", + " self.bn1 = torch.nn.BatchNorm2d(planes)\n", + " self.conv2 = torch.nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)\n", + " self.bn2 = torch.nn.BatchNorm2d(planes)\n", + "\n", + " self.shortcut = torch.nn.Sequential()\n", + " if stride != 1 or in_planes != planes:\n", + " if option == \"A\":\n", + " \"\"\"\n", + " For CIFAR10 ResNet paper uses option A.\n", + " \"\"\"\n", + " self.shortcut = LambdaLayer(\n", + " lambda x: F.pad(\n", + " x[:, :, ::2, ::2],\n", + " (0, 0, 0, 0, planes // 4, planes // 4),\n", + " \"constant\",\n", + " 0,\n", + " )\n", + " )\n", + " elif option == \"B\":\n", + " self.shortcut = torch.nn.Sequential(\n", + " torch.nn.Conv2d(\n", + " in_planes,\n", + " self.expansion * planes,\n", + " kernel_size=1,\n", + " stride=stride,\n", + " bias=False,\n", + " ),\n", + " torch.nn.BatchNorm2d(self.expansion * planes),\n", + " )\n", + "\n", + " def forward(self, x):\n", + " out = F.relu(self.bn1(self.conv1(x)))\n", + " out = self.bn2(self.conv2(out))\n", + " out += self.shortcut(x)\n", + " out = F.relu(out)\n", + " return out\n", + "\n", + "\n", + "class ResNet(torch.nn.Module):\n", + " def __init__(self, block, num_blocks, n_classes=10):\n", + " super(ResNet, self).__init__()\n", + " self.in_planes = 16\n", + "\n", + " self.conv1 = torch.nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1, bias=False)\n", + " self.bn1 = torch.nn.BatchNorm2d(16)\n", + " self.layer1 = self._make_layer(block, 16, num_blocks[0], stride=1)\n", + " self.layer2 = self._make_layer(block, 32, num_blocks[1], stride=2)\n", + " self.layer3 = self._make_layer(block, 64, num_blocks[2], stride=2)\n", + " self.linear = torch.nn.Linear(64, n_classes)\n", + "\n", + " self.apply(_weights_init)\n", + "\n", + " def _make_layer(self, block, planes, num_blocks, stride):\n", + " strides = [stride] + [1] * (num_blocks - 1)\n", + " layers = []\n", + " for stride in strides:\n", + " layers.append(block(self.in_planes, planes, stride))\n", + " self.in_planes = planes * block.expansion\n", + "\n", + " return torch.nn.Sequential(*layers)\n", + "\n", + " def forward(self, x):\n", + " out = F.relu(self.bn1(self.conv1(x)))\n", + " out = self.layer1(out)\n", + " out = self.layer2(out)\n", + " out = self.layer3(out)\n", + " out = F.avg_pool2d(out, out.size()[3])\n", + " out = out.view(out.size(0), -1)\n", + " out = self.linear(out)\n", + " return out\n", + "\n", + "\n", + "def resnet32(n_classes=10):\n", + " return ResNet(BasicBlock, [5, 5, 5], n_classes=n_classes)\n", + "\n", + "\n", + "class TorchCutout(object):\n", + " def __init__(self, length, fill=(0.0, 0.0, 0.0)):\n", + " self.length = length\n", + " self.fill = torch.tensor(fill).reshape(shape=(3, 1, 1))\n", + "\n", + " def __call__(self, img):\n", + " h = img.size(1)\n", + " w = img.size(2)\n", + " y = np.random.randint(h)\n", + " x = np.random.randint(w)\n", + " y1 = np.clip(y - self.length // 2, 0, h)\n", + " y2 = np.clip(y + self.length // 2, 0, h)\n", + " x1 = np.clip(x - self.length // 2, 0, w)\n", + " x2 = np.clip(x + self.length // 2, 0, w)\n", + " img[:, y1:y2, x1:x2] = self.fill\n", + " return img\n", + "\n", + "\n", + "# Load dataset\n", + "def load_cifar10(batch_size, path):\n", + " transform_train = torchvision.transforms.Compose(\n", + " [\n", + " torchvision.transforms.RandomCrop(32, padding=4),\n", + " torchvision.transforms.RandomHorizontalFlip(),\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + " TorchCutout(length=8),\n", + " ]\n", + " )\n", + "\n", + " transform_test = torchvision.transforms.Compose(\n", + " [\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n", + " ]\n", + " )\n", + "\n", + " trainset = torchvision.datasets.CIFAR10(\n", + " root=path, train=True, download=True, transform=transform_train\n", + " )\n", + " testset = torchvision.datasets.CIFAR10(\n", + " root=path, train=False, download=True, transform=transform_test\n", + " )\n", + " trainloader = torch.utils.data.DataLoader(\n", + " trainset, batch_size=batch_size, shuffle=True, num_workers=1\n", + " )\n", + " testloader = torch.utils.data.DataLoader(\n", + " testset, batch_size=batch_size, shuffle=False, num_workers=1\n", + " )\n", + "\n", + " return trainloader, testloader" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "9m1qDEsd-C4H" + }, + "outputs": [], + "source": [ + "# - Generic imports\n", + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from aihwkit.inference.compensation.drift import GlobalDriftCompensation\n", + "from aihwkit.inference.noise.hermes import HermesNoiseModel\n", + "from aihwkit.inference.noise.pcm import PCMLikeNoiseModel\n", + "\n", + "# - AIHWKIT related imports\n", + "from aihwkit.nn.conversion import convert_to_analog\n", + "from aihwkit.simulator.configs import InferenceRPUConfig\n", + "from aihwkit.simulator.configs.utils import (\n", + " BoundManagementType,\n", + " NoiseManagementType,\n", + " WeightClipType,\n", + " WeightModifierType,\n", + " WeightRemapType,\n", + ")\n", + "from aihwkit.simulator.presets import StandardHWATrainingPreset\n", + "from aihwkit.simulator.presets.utils import IOParameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## RPUConfig\n", + "To use the Hermes noise model, adjust the `rpu_config.noise_model` field of the `RPUConfig`. The noise model can be instatiated by the class `HermesNoiseModel`. See the following cells for available options." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "DHmjiuKn-C4O" + }, + "outputs": [], + "source": [ + "def gen_rpu_config(noise_model):\n", + " rpu_config = InferenceRPUConfig()\n", + "\n", + " # To select the Hermes noise model, change the `rpu_config.noise_model` field\n", + " # with an instance of the noise class (see next cells for details)\n", + " rpu_config.noise_model = noise_model\n", + "\n", + " # RPU config options to match the training config\n", + " rpu_config.modifier.std_dev = 0.06\n", + " rpu_config.modifier.type = WeightModifierType.ADD_NORMAL\n", + "\n", + " rpu_config.mapping.digital_bias = True\n", + " rpu_config.mapping.weight_scaling_omega = 1.0\n", + " rpu_config.mapping.weight_scaling_columnwise = False\n", + " rpu_config.mapping.out_scaling_columnwise = False\n", + " rpu_config.remap.type = WeightRemapType.LAYERWISE_SYMMETRIC\n", + "\n", + " rpu_config.clip.type = WeightClipType.LAYER_GAUSSIAN\n", + " rpu_config.clip.sigma = 2.0\n", + "\n", + " rpu_config.forward = IOParameters()\n", + " rpu_config.forward.is_perfect = False\n", + " rpu_config.forward.out_noise = 0.0\n", + " rpu_config.forward.inp_bound = 1.0\n", + " rpu_config.forward.inp_res = 1 / (2**8 - 2)\n", + " rpu_config.forward.out_bound = 12\n", + " rpu_config.forward.out_res = 1 / (2**8 - 2)\n", + " rpu_config.forward.bound_management = BoundManagementType.NONE\n", + " rpu_config.forward.noise_management = NoiseManagementType.NONE\n", + "\n", + " rpu_config.pre_post.input_range.enable = True\n", + " rpu_config.pre_post.input_range.decay = 0.01\n", + " rpu_config.pre_post.input_range.init_from_data = 50\n", + " rpu_config.pre_post.input_range.init_std_alpha = 3.0\n", + " rpu_config.pre_post.input_range.input_min_percentage = 0.995\n", + " rpu_config.pre_post.input_range.manage_output_clipping = False\n", + " \n", + " rpu_config.drift_compensation = GlobalDriftCompensation()\n", + " return rpu_config\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "6_She6Vv-C4P" + }, + "outputs": [], + "source": [ + "# Function to perform inference on the test set and calculate the test accuracy\n", + "def test_step(model, criterion, testloader):\n", + " model.eval()\n", + " test_loss = 0\n", + " correct = 0\n", + " total = 0\n", + " with torch.no_grad():\n", + " for inputs, targets in testloader:\n", + " inputs, targets = inputs.to(device), targets.to(device)\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs, targets)\n", + " test_loss += loss.item()\n", + " _, predicted = outputs.max(1)\n", + " total += targets.size(0)\n", + " correct += predicted.eq(targets).sum().item()\n", + " return 100.0 * correct / total" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "P0-82vyr-C4Q", + "outputId": "05431c47-efa4-4ea6-e759-5e3b5b93f66b" + }, + "outputs": [], + "source": [ + "# - Set seeds\n", + "torch.manual_seed(42)\n", + "np.random.seed(42)\n", + "\n", + "# - Get the dataloader\n", + "batch_size = 128\n", + "_, testloader = load_cifar10(\n", + " batch_size=batch_size, path=os.path.expanduser(\"~/Data/\")\n", + ")\n", + "\n", + "# - Define model and the criterion\n", + "model = resnet32()\n", + "model = model.to(device)\n", + "criterion = torch.nn.CrossEntropyLoss()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hermes Noise Model\n", + "Hermes' unit cell offers the capability to map a weight on either 1 device or 2 devices per polarity. Both modes have been characterized and can be called using the `num_devices` parameter during instatiation. The user has the capability to further tweek the model by changing other parameters, see the class prototype for more details." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CF6ddwgw-C4S", + "outputId": "17dbd555-d243-4cac-eed6-c8652d8e79bb" + }, + "outputs": [], + "source": [ + "# - Noise model instatiation for comparison (Previous PCMLikeNoiseModel with the new HermesNoiseModel for 1 and 2 num_devices)\n", + "noise_models_to_compare = {\n", + " \"Standard\": PCMLikeNoiseModel(g_max=25.0),\n", + " \"Hermes 1D\": HermesNoiseModel(num_devices=1),\n", + " \"Hermes 2D\": HermesNoiseModel(num_devices=2),\n", + "}\n", + "rpu_configs = {\n", + " model_name: gen_rpu_config(noise_model)\n", + " for model_name, noise_model in noise_models_to_compare.items()\n", + "}\n", + "# - Instatiate models, each with an RPU config with the corresponding noise model\n", + "analog_models = {\n", + " model_name: convert_to_analog(model, config) for model_name, config in rpu_configs.items()\n", + "}\n", + "\n", + "# Download the HW-Aware trained checkpoint and load it in the models\n", + "!wget -P Models/ https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/finetuned_model_0.9.1.th\n", + "for model in analog_models.values():\n", + " model.load_state_dict(\n", + " torch.load(\"Models/finetuned_model_0.9.1.th\", map_location=device), load_rpu_config=False,\n", + " )\n", + "print(f\"Finetuned test acc. w/o noise: {test_step(analog_models['Standard'], criterion, testloader):.2f} %\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "uAF1fy68-C4V", + "outputId": "c5e5762b-cb7b-4dba-8ff9-a33bdd885468" + }, + "outputs": [], + "source": [ + "# - For programming the model, we need to put it into eval() mode\n", + "for model in analog_models.values():\n", + " model.eval()\n", + "# - We repeat each measurement 5 times\n", + "n_rep = 5\n", + "t_inferences = [0.0, 60.0, 3600.0, 86400.0, 2592000.0, 31104000.0]\n", + "_, ax = plt.subplots()\n", + "ax: plt.Axes\n", + "for noise_name, model in analog_models.items():\n", + " drifted_test_accs = torch.zeros(size=(len(t_inferences), n_rep))\n", + " for i, t in enumerate(t_inferences):\n", + " for j in range(n_rep):\n", + " model.drift_analog_weights(t)\n", + " drifted_test_accs[i, j] = test_step(model, criterion, testloader)\n", + "\n", + " ax.errorbar(\n", + " t_inferences,\n", + " drifted_test_accs.mean(1),\n", + " drifted_test_accs.std(1),\n", + " capsize=3,\n", + " label=noise_name,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_xscale(\"log\")\n", + "ax.set_ylabel(\"Test acc. (%)\")\n", + "ax.legend();" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "V100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "8552d10987f98ef8320154686d1598142476aa8dfb1019e7b5164f51d5b1d29f" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/hermes/hermes_noise_model_mvm.ipynb b/notebooks/hermes/hermes_noise_model_mvm.ipynb new file mode 100644 index 00000000..2397df66 --- /dev/null +++ b/notebooks/hermes/hermes_noise_model_mvm.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "3S0YWetZ-a2m" + }, + "source": [ + "# IBM Analog Hardware Acceleration Kit (AIHWKIT): MVM using noise models characterized on the IBM HERMES Project Chip\n", + "\n", + "Le Gallo, M., Khaddam-Aljameh, R., Stanisavljevic, M. et al. A 64-core mixed-signal in-memory compute chip based on phase-change memory for deep neural network inference. Nat Electron 6, 680–693 (2023). https://doi.org/10.1038/s41928-023-01010-1" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "form", + "id": "8dRBAFI2xcEK", + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# %%\n", + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from aihwkit.inference.noise.hermes import HermesNoiseModel\n", + "from aihwkit.inference.noise.pcm import PCMLikeNoiseModel\n", + "from aihwkit.simulator.configs import BoundManagementType, NoiseManagementType, WeightNoiseType\n", + "from aihwkit.inference.compensation.drift import PerColumnDriftCompensation\n", + "from aihwkit.simulator.presets import StandardHWATrainingPreset\n", + "from aihwkit.simulator.tiles import InferenceTile\n", + "\n", + "\n", + "# Generate a sparse uniform tensor\n", + "def generate_random_tensor_with_zeros(shape, sparsity=0.3):\n", + " total_elements = torch.prod(torch.tensor(shape))\n", + " num_zeros = int(total_elements * sparsity)\n", + "\n", + " # Generate a tensor from a uniform distribution\n", + " tensor = torch.rand(shape) * 2 - 1.0\n", + "\n", + " # Randomly choose indices to set to zero\n", + " zero_indices = torch.randperm(total_elements)[:num_zeros]\n", + "\n", + " # Set the chosen indices to zero\n", + " tensor.view(-1)[zero_indices] = 0\n", + "\n", + " return tensor\n", + "\n", + "\n", + "# Perform an MVM with an ideal RPUConfig except for I/O quant and noise model\n", + "def perform_noisy_mvm(inputs, weights, noise_model, t_inf):\n", + " rows, cols = weights.shape\n", + "\n", + " # Initialize an rpu config without ANY noise\n", + " rpu_config = StandardHWATrainingPreset()\n", + " rpu_config.forward.bound_management = BoundManagementType.NONE\n", + " rpu_config.forward.out_bound = 0\n", + " rpu_config.forward.w_noise = 0.00\n", + " rpu_config.forward.w_noise_type = WeightNoiseType.NONE\n", + " rpu_config.forward.ir_drop = 0.00\n", + " rpu_config.forward.out_noise = 0.0\n", + " rpu_config.forward.noise_management = NoiseManagementType.ABS_MAX\n", + "\n", + " # Now add on the RPU config the 8-bit I/O\n", + " # and the selected noise model noise model\n", + " rpu_config.forward.inp_res = 254.0\n", + " rpu_config.forward.out_res = 254.0\n", + " rpu_config.noise_model = noise_model\n", + "\n", + " analog_tile = InferenceTile(cols, rows, rpu_config)\n", + " analog_tile.eval()\n", + " analog_tile.set_weights(weights.T)\n", + "\n", + " # Apply all noises\n", + " analog_tile.drift_weights(t_inference=t_inf)\n", + "\n", + " # Perform MVM\n", + " output = analog_tile.forward(inputs)\n", + " return output\n", + "\n", + "\n", + "def calculate_l2_error(y_target, y_measured):\n", + " l2_errors = torch.norm(y_measured - y_target, dim=1) / torch.norm(y_target, dim=1)\n", + " return l2_errors.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9m1qDEsd-C4H" + }, + "outputs": [], + "source": [ + "# Set seed and MVM/tile parameters\n", + "torch.manual_seed(42)\n", + "rows = 512\n", + "cols = 512\n", + "batch_size = 10_000\n", + "t_inf = [0.0, 60.0, 3600.0, 86400, 2592000.0, 31104000.0]\n", + "n_reps = 10\n", + "\n", + "# Define the noise models to compare\n", + "noise_models = {\n", + " \"Standard\": PCMLikeNoiseModel(g_max=25.0),\n", + " \"Hermes SD\": HermesNoiseModel(num_devices=1),\n", + " \"Hermes TD\": HermesNoiseModel(num_devices=2),\n", + "}\n", + "\n", + "# Generate the data and perform the ideal MVM\n", + "inputs = generate_random_tensor_with_zeros((batch_size, rows), sparsity=0.5)\n", + "weights = generate_random_tensor_with_zeros((rows, cols), sparsity=0.3)\n", + "ideal_result = inputs @ weights\n", + "\n", + "# Iterate over the models and perform 10 MVMs\n", + "mvm_precisions = {}\n", + "fig, ax = plt.subplots()\n", + "for model_n, model in noise_models.items():\n", + " mean_l2_errs_per_t = []\n", + " for t in t_inf:\n", + " l2_errs = torch.zeros(n_reps)\n", + " for i in range(n_reps):\n", + " result_noisy = perform_noisy_mvm(inputs, weights, model, t_inf=t)\n", + " l2_errs[i] = calculate_l2_error(ideal_result, result_noisy)\n", + " mean_l2_errs_per_t.append(l2_errs.mean().detach() * 100)\n", + "\n", + " ax.plot(t_inf, mean_l2_errs_per_t, \"-d\", label=model_n)\n", + "\n", + " ax.legend()\n", + " ax.set_xscale(\"log\")\n", + " ax.set_xlabel(\"Time of MVM\")\n", + " ax.set_ylabel(\"MVM error (%)\")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "V100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "8552d10987f98ef8320154686d1598142476aa8dfb1019e7b5164f51d5b1d29f" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/iscas_tutorial/mobilebert_squad.ipynb b/notebooks/iscas_tutorial/mobilebert_squad.ipynb index e65612e9..1bc60e00 100644 --- a/notebooks/iscas_tutorial/mobilebert_squad.ipynb +++ b/notebooks/iscas_tutorial/mobilebert_squad.ipynb @@ -71,7 +71,7 @@ }, "outputs": [], "source": [ - "!pip install wandb accelerate transformers tqdm" + "!pip install wandb accelerate transformers tqdm tensorflow tensorflow_datasets gcsfs" ] }, { @@ -81,7 +81,9 @@ }, "source": [ "## Authenticate W&B\n", - "If you do not already have a W&B account, please create one [here](https://wandb.ai/site)" + "If you do not already have a W&B account, please create one [here](https://wandb.ai/site).\n", + "\n", + "Run the command `wandb login` in your CLI and paste the API Key, when prompted, provided on your wandb dashboard." ] }, { @@ -110,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": { "id": "DHmjiuKn-C4O" }, @@ -129,8 +131,8 @@ "id": "X43dbg-9xSiP" }, "source": [ - "## Define a Configururation File Describing the Training Configurations and Parameters to Optimize\n", - "The following attributes decribe how the optimization is performed:\n", + "## Define a Configuration File Describing the Training Configurations and Parameters to Optimize\n", + "The following attributes describe how the optimization is performed:\n", "* **method**: The optimization method to use (Bayesian Optimization/Grid search/etc.).\n", "* **metirc**: The optimization goal and item.\n", "\n", @@ -146,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": { "id": "6_She6Vv-C4P" }, @@ -193,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "metadata": { "id": "P0-82vyr-C4Q" }, @@ -452,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": { "id": "aG-rrTt5-C4R" }, @@ -581,7 +583,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.14" }, "vscode": { "interpreter": { diff --git a/requirements-examples.txt b/requirements-examples.txt index 9f31372a..2fa5e822 100644 --- a/requirements-examples.txt +++ b/requirements-examples.txt @@ -1,3 +1,4 @@ torchvision>=0.7.0 matplotlib>=3.0 pyamg +jupyter diff --git a/requirements.txt b/requirements.txt index 40c4f672..4ee6881c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,7 @@ torch>=1.9 torchvision scipy requests>=2.25,<3 -numpy>=1.22 +numpy>=1.22,<2 protobuf>=4.21.6 tqdm mypy==0.991 diff --git a/src/aihwkit/VERSION.txt b/src/aihwkit/VERSION.txt index f374f666..2003b639 100644 --- a/src/aihwkit/VERSION.txt +++ b/src/aihwkit/VERSION.txt @@ -1 +1 @@ -0.9.1 +0.9.2 diff --git a/src/aihwkit/inference/__init__.py b/src/aihwkit/inference/__init__.py index fa6b7a24..581add28 100644 --- a/src/aihwkit/inference/__init__.py +++ b/src/aihwkit/inference/__init__.py @@ -14,9 +14,14 @@ # Convenience imports for easier access to the classes. from aihwkit.inference.converter.base import BaseConductanceConverter -from aihwkit.inference.converter.conductance import SinglePairConductanceConverter +from aihwkit.inference.converter.conductance import ( + SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter +) from aihwkit.inference.noise.base import BaseNoiseModel -from aihwkit.inference.noise.pcm import PCMLikeNoiseModel +from aihwkit.inference.noise.pcm import PCMLikeNoiseModel, CustomDriftPCMLikeNoiseModel from aihwkit.inference.noise.reram import ReRamWan2022NoiseModel from aihwkit.inference.noise.custom import StateIndependentNoiseModel from aihwkit.inference.compensation.base import BaseDriftCompensation diff --git a/src/aihwkit/inference/compensation/drift.py b/src/aihwkit/inference/compensation/drift.py index 905b831a..78140533 100644 --- a/src/aihwkit/inference/compensation/drift.py +++ b/src/aihwkit/inference/compensation/drift.py @@ -40,3 +40,24 @@ def get_readout_tensor(self, in_size: int) -> Tensor: def __str__(self) -> str: return "{}()".format(self.__class__.__name__) + + +class PerColumnDriftCompensation(BaseDriftCompensation): + """Per column drift compensation. + Uses a vector for compensating the drift. + """ + + @no_grad() + def readout(self, out_tensor: Tensor) -> Tensor: + """Read outs the per-column mean abs.""" + return clamp(torch_abs(out_tensor).mean(dim=0), min=0.0001) + + @no_grad() + def get_readout_tensor(self, in_size: int) -> Tensor: + """Return the read-out tensor. + Uses the set of one-hot vectors (eye). + """ + return eye(in_size) + + def __str__(self) -> str: + return "{}()".format(self.__class__.__name__) diff --git a/src/aihwkit/inference/converter/conductance.py b/src/aihwkit/inference/converter/conductance.py index d3456b3a..50778796 100644 --- a/src/aihwkit/inference/converter/conductance.py +++ b/src/aihwkit/inference/converter/conductance.py @@ -14,10 +14,12 @@ from typing import Dict, List, Optional, Tuple -from torch import abs as torch_abs # pylint: disable=unused-import -from torch import Tensor +from torch import abs as torch_abs +from torch import Tensor, zeros_like, from_numpy, linspace, allclose from torch.autograd import no_grad +from numpy import interp + from aihwkit.inference.converter.base import BaseConductanceConverter _ZERO_CLIP = 1e-7 @@ -80,3 +82,272 @@ def convert_back_to_weights(self, conductances: List[Tensor], params: Dict) -> T ] return weights + + +class NPairConductanceConverter(BaseConductanceConverter): + r"""N pairs of conductance devices per unit cell (generalized). + + Assuming a N pairs of devices per cross-point, each having a relative + weighting (i.e. F factor) as defined by the values in the f_lst parameter. + For positive and negative weights, one device within in the pair is always + set to g_min. The higher significant pair will only be used once the + range of the lower significant pairs is exhausted. In this way, we minimize + amplification of programming errors and read noise by the scale factors F. + Note that the scale factors can also be values less than 1.0, however. The + F factor can be implemented using an amplifying current mirror or by applying + a longer pulse durations to one pair of conductance pair relative to another, + such that their is a greater current contribution even though all devices are + sized equally. + + Args: + f_lst: In: list of weighting (i.e. scale) factors from lowest + to hightest, used to determinethe significance of each + conductance pair. + g_max: In :math:`\mu S`, the maximal conductance, ie the value + the absolute max of the weights will be mapped to. + g_min: In :math:`\mu S`, the minimal conductance, ie the value + the logical zero of the weights will be mapped to. + """ + + def __init__(self, + f_lst: List[float], + g_max: Optional[float] = None, + g_min: Optional[float] = None, + ): + + if not isinstance(f_lst, list): + raise ValueError("f_lst parameter must be a list of F factors") + + if max(f_lst) < 0.: + raise ValueError("f_lst parameter contains negative value") + + self.g_max = 25.0 if g_max is None else g_max + self.g_min = 0.0 if g_min is None else g_min + self.f_lst = f_lst + self.scale_ratio = None + + if self.g_max < 0.0: + raise ValueError("g_max should be a positive value") + if self.g_min < 0.0: + raise ValueError("g_min should be a positive value") + if self.g_min >= self.g_max: + raise ValueError("g_min should be smaller than g_max") + + def __str__(self) -> str: + return "{}(g_max={:1.2f}, g_min={:1.2f})".format( + self.__class__.__name__, self.g_max, self.g_min + ) + + @no_grad() + def convert_to_conductances(self, weights: Tensor) -> Tuple[List[Tensor], Dict]: + max_weight_us = sum(f * (self.g_max - self.g_min) for f in self.f_lst) + max_weight_unitless = torch_abs(weights).max().clamp(min=_ZERO_CLIP) + scale_ratio = max_weight_us / max_weight_unitless + weights_us = scale_ratio * weights + + lower_bound_us = 0. # lower bound in uS + conductances = [] + for f_factor in self.f_lst: + conductances.append(((weights_us.clamp(min=0.0) - lower_bound_us) / f_factor + + self.g_min).clamp(min=self.g_min, max=self.g_max)) # g_plus + conductances.append((((-weights_us).clamp(min=0.0) - lower_bound_us) / f_factor + + self.g_min).clamp(min=self.g_min, max=self.g_max)) # g_minus + lower_bound_us += f_factor * (self.g_max - self.g_min) + + params = {'scale_ratio': scale_ratio, + 'f_lst': self.f_lst} + + return conductances, params + + @no_grad() + def convert_back_to_weights(self, conductances: List[Tensor], params: Dict) -> Tensor: + if 'f_lst' not in params: + raise ValueError("params does not contain f_lst") + if len(conductances) % 2 != 0: + raise ValueError("unit cell must have an even number of conductances") + if 'scale_ratio' not in params: + raise ValueError("params does not contain scale_ratio") + + weights = zeros_like(conductances[0]) + for f_factor, (g_plus, g_minus) in zip(self.f_lst, + zip(conductances[::2], conductances[1::2])): + weights += f_factor * (g_plus - g_minus) + + return weights / params['scale_ratio'] + + +class DualPairConductanceConverter(NPairConductanceConverter): + r"""Two pairs of conductance devices per unit cell (4 devices total). + + Assuming a two pairs of devices per cross-point, each having a relative + weighting (i.e. F factor) as defined by the values in the f_lst parameter. + For positive and negative weights, one device within in the pair is always + set to g_min. The higher significant pair will only be used once the + range of the lower significant pairs is exhausted. In this way, we minimize + amplification of programming errors and read noise by the scale factors F. + Note that the scale factors can also be values less than 1.0, however. The + F factor can be implemented using an amplifying current mirror or by applying + a longer pulse durations to one pair of conductance pair relative to another, + such that their is a greater current contribution even though all devices are + sized equally. + + Args: + f_lst: In: list of weighting (i.e. scale) factors from lowest + to hightest, used to determinethe significance of each + conductance pair. + g_max: In :math:`\mu S`, the maximal conductance, ie the value + the absolute max of the weights will be mapped to. + g_min: In :math:`\mu S`, the minimal conductance, ie the value + the logical zero of the weights will be mapped to. + """ + + def __init__(self, + f_lst: List[float], + g_max: Optional[float] = None, + g_min: Optional[float] = None, + ): + + if len(f_lst) != 2: + raise ValueError("f_lst parameter does not contain two values") + + super().__init__(f_lst=f_lst, + g_max=g_max, + g_min=g_min) + + +class CustomPairConductanceConverter(BaseConductanceConverter): + r"""Arbitrary even number of devices. + + Assuming an arbitrary pair of devices per cross-point, each pair having a + relative weight defined by the values in the f_lst parameter. The parameter + g_lst is a list of lists that map the unitless weights to a series of + conductance values. These lists allow us to interpolate and implement a + function g(w) so that we can map unitless weight to their corresponding + conductance values. In this way, we can implement very complex conductance + programming schemes. The various F factors can be implemented using amplifying + current mirrors or by applying longer pulse durations to the one conductance + pair relative to others such that their is a greater current contribution even + though all devices are sized equally. + + Args: + f_lst: In: list of weighting (i.e. scale) factors used for the + more significant conductance pairs and the less significant + conductance pairs. + g_lst: In: list of lists that map unitless weights to + conductance values. + g_max: In :math:`\mu S`, the maximal conductance, ie the value + the absolute max of the weights will be mapped to. + g_min: In :math:`\mu S`, the minimal conductance, ie the value + the logical zero of the weights will be mapped to. + """ + + def __init__(self, + f_lst: List[float], + g_lst: List[List[float]], + g_max: Optional[float] = None, + g_min: Optional[float] = None, + invertibility_test: Optional[bool] = True, + ): + self.g_max = 25.0 if g_max is None else g_max + self.g_min = 0.0 if g_min is None else g_min + + if not isinstance(g_lst, list): + raise ValueError("g_lst parameter must be a list") + + if not all(isinstance(g, list) for g in g_lst): + raise ValueError("g_lst must be list of lists") + + if len(g_lst) % 2 != 0: + raise ValueError("g_lst must have and even number of elements") + + if not isinstance(f_lst, list): + raise ValueError("f_lst parameter must be a list") + + if 2 * len(f_lst) != len(g_lst): + raise ValueError("must have one value in f_lst for every pair of values in g_lst") + + self.f_lst = f_lst + self.g_lst = g_lst + self.scale_ratio = None + + if self.g_max < 0.0: + raise ValueError("g_max should be a positive value") + if self.g_min < 0.0: + raise ValueError("g_min should be a positive value") + if self.g_min >= self.g_max: + raise ValueError("g_min should be smaller than g_max") + + if invertibility_test: + self.invertibility_test() + + def invertibility_test(self) -> None: + r"""Test to make sure custom conductance converter specification is invertible + + This method tests to make sure the custom converter specification represents + and invertible function, meaning the g = f(w) <--> w = f^{-1}(x) is true. + Otherwise, converting unitless weights to conductances and then subsequently + converting those conductances back to unitless weights will introduce changes + into the weights, which should not be there. The default is to run this test + upon instantiation and return an error if it passes. This prevents ill-defined + custom conductance converter models from corrupting simulation results. + """ + test_weights = linspace(-1, 1, 5) + conductances, params = self.convert_to_conductances(test_weights) + return_weights = self.convert_back_to_weights(conductances, params) + if not allclose(test_weights, return_weights, atol=0.0001): + raise ArithmeticError("CustomPairConductanceConverter is not an invertible function") + + def __str__(self) -> str: + return "{}(g_max={:1.2f}, g_min={:1.2f})".format( + self.__class__.__name__, self.g_max, self.g_min + ) + + @no_grad() + def convert_to_conductances(self, weights: Tensor) -> Tuple[List[Tensor], Dict]: + + weights_us = zeros_like(Tensor(self.g_lst[0])).type_as(weights) + for f_factor, (gp_lst, gm_lst) in zip(self.f_lst, + zip(self.g_lst[::2], self.g_lst[1::2])): + weights_us += f_factor * (Tensor(gp_lst) - Tensor(gm_lst)).type_as(weights) + + max_weight = torch_abs(weights).max() + max_weight_us = torch_abs(weights_us).max() + scale_ratio = max_weight_us / max_weight.clamp(min=_ZERO_CLIP) + + w_lst = (linspace(-max_weight_us, + max_weight_us, + len(self.g_lst[0])) / scale_ratio).tolist() + + conductances = [] + for f_factor, (gp_lst, gm_lst) in zip(self.f_lst, + zip(self.g_lst[::2], self.g_lst[1::2])): + conductances.append(from_numpy(interp(weights.cpu().numpy(), + w_lst, + gp_lst)).type_as(weights)) + conductances.append(from_numpy(interp(weights.cpu().numpy(), + w_lst, + gm_lst)).type_as(weights)) + + params = {'scale_ratio': scale_ratio, + 'f_lst': self.f_lst} + + return conductances, params + + @no_grad() + def convert_back_to_weights(self, conductances: List[Tensor], params: Dict) -> Tensor: + + if 'f_lst' not in params: + raise ValueError("params does not contain f_lst") + + if not isinstance(params['f_lst'], list): + raise TypeError("f_lst parameter must be a list of f factors") + + if 2 * len(params['f_lst']) != len(conductances): + raise ValueError("must have one value in f_lst for every pair of conductances") + + weights_us = zeros_like(conductances[0]) + for f_factor, (g_plus, g_minus) in zip(params['f_lst'], + zip(conductances[::2], conductances[1::2])): + weights_us += f_factor * (g_plus - g_minus) + + return weights_us / params['scale_ratio'] # back to unitless diff --git a/src/aihwkit/inference/noise/hermes.py b/src/aihwkit/inference/noise/hermes.py new file mode 100644 index 00000000..e9601c70 --- /dev/null +++ b/src/aihwkit/inference/noise/hermes.py @@ -0,0 +1,283 @@ +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# pylint: disable=too-many-instance-attributes, too-many-arguments, too-many-branches + +"""Phenomenological noise models for PCM devices for inference.""" + +from copy import deepcopy +from typing import List, Optional + +from numpy import log as numpy_log +from numpy import sqrt +from torch import Tensor +from torch import abs as torch_abs +from torch import clamp, log, randn_like, zeros_like +from torch.autograd import no_grad + +from aihwkit.inference.converter.base import BaseConductanceConverter +from aihwkit.inference.converter.conductance import SinglePairConductanceConverter +from aihwkit.inference.noise.base import BaseNoiseModel + +_ZERO_CLIP = 1e-7 + + +class HermesNoiseModel(BaseNoiseModel): + r"""A Noise model that was fitted and characterized on the PCM devices of the + platform IBM HERMES Project Chip, see `Le Gallo et al. Nat. Electronics (2023)`_ + and `Khaddam-Aljameh et al. JSSC (2022)`_ + + Expected weight noise at assumed time of inference with expected + programming noise at 0. + + See also `Nandakumar et al. ICECS (2019)`_ for details about the + statistical modelling methodology that was used. + + NOTE: The argument `num_devices` changes the programming method and the drift behavior of + the model. When `num_devices` is 1, a conventional single device programming method is + used. When `num_devices` is 2, the method from the work `Vasilopoulos et al. TED (2023)`_ + is employed (MSF), which is optimal and yields higher programming accuracy. + For the drift characterization, though, when `num_devices` is 2 the model is applied as + if the two devices host the same conductance and not as described in the aforementioned + reference, due to it using a dynamic conductance mapping step which requires feedback from + the chip in question. This simplification yields worse drift behavior in the current model + than the one measured on-chip in the aforementioned work. + + Args: + prog_coeff: Programming polynomial coeffs in + :math:`\sum_i c_i \left(\frac{g_t}{g_\max}\right)^i` + g_converter: instantiated class of the conductance converter + (defaults to single pair) + num_devices: The number of devices that are used to map a weight. + Hermes supports either 1 or 2 devices per weight. When `num_devices` + is 2, higher programming accuracy and less drift variability is measured. + Defaults to 2. + g_max: In :math:`\mu S`, the maximal conductance, ie the value + the absolute max of the weights will be mapped to. + When `num_devices = 2`, the maximum characterized conductance + is 20.7 :math:`\mu S`. When `num_devices = 1` the maximum + characterized value is 10.35 :math:`\mu S`. When `None` is passed (by default) + the maximum conductance for the corresponding `num_devices` is selected. + t_read: Parameter of the 1/f fit (in seconds). + t_0: Parameter of the drift fit (first reading time). When `num_devices = 2` + that time corresponds to 300s, while in the case that `num_devices = 1` + it is 200s. If `None` is passed (by default) the time is selected according + to the `num_devices` selection. + + Note: + The ``t_inference`` is relative to this time `t0` + e.g. t_inference counts from the completion of the programming + of a device. + prog_noise_scale: Scale for the programming noise. + read_noise_scale: Scale for the read and accumulated noise. + drift_scale: Scale for the drift coefficient. + prog_coeff_g_max_reference: reference :math:`g_\max` value + when fitting the coefficients, since the result of the + polynomial fit is given in uS. If + ``prog_coeff_g_max_reference`` is not given and + `prog_coeffs` are given explicitly, it will be set to + ``g_max`` of the conductance converter. + + .. _`Nandakumar et al. ICECS (2019)`: https://ieeexplore.ieee.org/document/8964852 + .. _`Le Gallo et al. Nat. Electron. (2023)`: https://www.nature.com/articles/s41928-023-01010-1 + .. _`Khaddam-Aljameh et al. JSSC (2022)`: https://ieeexplore.ieee.org/document/9696185 + .. _`Vasilopoulos et al. TED (2023)`: https://ieeexplore.ieee.org/document/10281389 + + """ + + def __init__( + self, + prog_coeff: Optional[List[float]] = None, + g_converter: Optional[BaseConductanceConverter] = None, + num_devices: int = 2, + g_max: Optional[float] = None, + t_read: float = 512.0e-9, + t_0: Optional[float] = None, + prog_noise_scale: float = 1.0, + read_noise_scale: float = 1.0, + drift_scale: float = 1.0, + prog_coeff_g_max_reference: Optional[float] = None, + ): + # The only valid options are 1 or 2 devices + assert num_devices in [1, 2], "Hermes supports either 1 or 2 devices per weight" + self.num_devices = num_devices + + # Figure out t0 depending on the num devices + if t_0 is None: + t_0 = 300.0 if self.num_devices == 2 else 200.0 + + # Fix Gmax now + if self.num_devices == 1: + if g_max is not None: + assert ( + g_max <= 10.35 + ), "The maximum conductance characterized for single device unit cell is 10.35 uS" + else: + g_max = 10.35 + elif self.num_devices == 2: + if g_max is not None: + assert ( + g_max <= 20.7 + ), "The maximum conductance characterized for single device unit cell is 10.35 uS" + else: + g_max = 20.7 + + g_converter = deepcopy(g_converter) or SinglePairConductanceConverter(g_max=g_max) + super().__init__(g_converter) + + self.g_max = getattr(self.g_converter, "g_max", g_max) + if self.g_max is None: + raise ValueError("g_max cannot be established from g_converter") + + if prog_coeff_g_max_reference is None: + self.prog_coeff_g_max_reference = self.g_max + + if prog_coeff is None: + # standard g_max are defined in respect to 20.7 or 10.35 uS. Need to + # adjust for that in case g_max is not equal to the characterized maximum value + if self.num_devices == 2: + self.prog_coeff = [0.16603222, 4.71806468, -8.48101252, 4.68961419] + self.prog_coeff_g_max_reference = 20.7 + elif self.num_devices == 1: + self.prog_coeff = [0.15781817, 2.32443916, -2.16310839, 0.68841818] + self.prog_coeff_g_max_reference = 10.35 + else: + self.prog_coeff = prog_coeff + + self.t_0 = t_0 + self.t_read = t_read + self.prog_noise_scale = prog_noise_scale + self.read_noise_scale = read_noise_scale + self.drift_scale = drift_scale + + @no_grad() + def apply_programming_noise_to_conductance(self, g_target: Tensor) -> Tensor: + """Apply programming noise to a target conductance Tensor. + + Programming noise with additive Gaussian noise with + conductance dependency of the variance given by a 3-degree + polynomial. + """ + mat = 1 + sig_prog = self.prog_coeff[0] + for coeff in self.prog_coeff[1:]: + mat *= g_target / self.g_max + sig_prog += mat * coeff + + sig_prog *= self.g_max / self.prog_coeff_g_max_reference # type: ignore + g_prog = g_target + self.prog_noise_scale * sig_prog * randn_like(g_target) + g_prog.clamp_(min=0.0) # no negative conductances allowed + + return g_prog + + @no_grad() + def generate_drift_coefficients(self, g_target: Tensor) -> Tensor: + """Return drift coefficients ``nu`` based on PCM measurements.""" + g_relative = clamp(torch_abs(g_target / self.g_max), min=_ZERO_CLIP) + + # gt should be normalized wrt g_max + mu_drift, sig_drift = zeros_like(g_relative), zeros_like(g_relative) + # Depending on the number of devices, different behavior is expected + # for the standard deviation of the drift coefficient. The mean + # behavior remains the same as it is considered that both devices + # in the unit cell are programmed in the same state for simplicity. + # The function for the mean and the standard deviation of + # the ``nu`` factor are fitted with a branch function to match the + # experimental data + g_rel_low_mean, g_rel_high_mean = ( + g_relative[g_relative < 0.0945], + g_relative[[g_relative >= 0.0945]], + ) + mu_drift[g_relative < 0.0945] = (-0.0387 * log(g_rel_low_mean) - 0.0182).clamp( + min=0.0720, max=0.13 + ) + mu_drift[g_relative >= 0.0945] = ( + -0.0436 * g_rel_high_mean**2 - 0.0126 * g_rel_high_mean + 0.0736 + ) + if self.num_devices == 1: + g_rel_low_std, g_rel_high_std = ( + g_relative[g_relative < 0.3039], + g_relative[[g_relative >= 0.3039]], + ) + sig_drift[g_relative < 0.3039] = (-0.0120 * log(g_rel_low_std) - 0.0023).clamp( + min=0.0124, max=0.04 + ) + sig_drift[g_relative >= 0.3039] = ( + -0.0165 * g_rel_high_std**2 + 0.0116 * g_rel_high_std + 0.0104 + ) + elif self.num_devices == 2: + g_rel_low_std, g_rel_high_std = ( + g_relative[g_relative < 0.3055], + g_relative[[g_relative >= 0.3055]], + ) + sig_drift[g_relative < 0.3055] = (-0.0117 * log(g_rel_low_std) - 0.0057).clamp( + min=0.0091, max=0.04 + ) + sig_drift[g_relative >= 0.3055] = ( + -0.0118 * g_rel_high_std**2 + 0.0093 * g_rel_high_std + 0.0073 + ) + + nu_drift = torch_abs(mu_drift + sig_drift * randn_like(g_relative)).clamp(min=0.0) + + return nu_drift * self.drift_scale + + @no_grad() + def apply_drift_noise_to_conductance( + self, + g_prog: Tensor, + drift_noise_param: Tensor, + t_inference: float, + ) -> Tensor: + """Apply the noise and drift up to the assumed inference time + point based on PCM measurements.""" + t = t_inference + self.t_0 + + # drift + if t > self.t_0: + g_drift = g_prog * ((t / self.t_0) ** (-drift_noise_param)) + else: + g_drift = g_prog + + # expected accumulated 1/f noise since start of programming at t=0 + if t > 0: + g_relative = torch_abs(g_prog) / self.g_max + q_s = zeros_like(g_prog) + if self.num_devices == 1: + g_rel_low, g_rel_high = ( + g_relative[g_relative < 0.1591], + g_relative[[g_relative >= 0.1591]], + ) + q_s[g_relative < 0.1591] = (-0.0078 * log(g_rel_low) + 0.0038).clamp( + min=0.0179, max=0.04 + ) + q_s[g_relative >= 0.1591] = ( + 0.0664 * g_rel_high**3 - 0.1352 * g_rel_high**2 + 0.0768 * g_rel_high + 0.0088 + ) + elif self.num_devices == 2: + g_rel_low, g_rel_high = ( + g_relative[g_relative < 0.16], + g_relative[[g_relative >= 0.16]], + ) + q_s[g_relative < 0.16] = (-0.0117 * log(g_rel_low) - 0.0069).clamp( + min=0.015, max=0.04 + ) + q_s[g_relative >= 0.16] = ( + 0.0069 * g_rel_high**3 - 0.0280 * g_rel_high**2 + 0.0211 * g_rel_high + 0.0123 + ) + sig_noise = q_s * sqrt(numpy_log((t + self.t_read) / (2 * self.t_read))) + g_final = g_drift + torch_abs(g_drift) * self.read_noise_scale * sig_noise * randn_like( + g_prog + ) + else: + g_final = g_prog + + return g_final.clamp(min=0.0) diff --git a/src/aihwkit/inference/noise/pcm.py b/src/aihwkit/inference/noise/pcm.py index 738f9c7e..bbe7176e 100644 --- a/src/aihwkit/inference/noise/pcm.py +++ b/src/aihwkit/inference/noise/pcm.py @@ -18,9 +18,14 @@ from typing import List, Optional from numpy import log as numpy_log -from numpy import sqrt -from torch import abs as torch_abs -from torch import clamp, log, randn_like, Tensor +from numpy import sqrt, interp +from torch import ( + abs as torch_abs, + min as torch_min, + max as torch_max, + sort as torch_sort, +) +from torch import clamp, log, randn_like, Tensor, from_numpy, equal from torch.autograd import no_grad from aihwkit.inference.noise.base import BaseNoiseModel @@ -162,3 +167,139 @@ def apply_drift_noise_to_conductance( g_final = g_prog return g_final.clamp(min=0.0) + + +class CustomDriftPCMLikeNoiseModel(PCMLikeNoiseModel): + r"""Enables user-defined (custom) drift models. + + Args: + custom_drift_model: drift model specified as a dictionary containing three lists: + g_lst, a list of conductances in ascending order; + nu_mean_lst, a list of mean drift coefficients corresponding to the g_lst values; and + nu_std_lst, a list of nu standard deviation values corresponding to the g_lst values. + prog_coeff: Programming polynomial coeffs in + :math:`\sum_i c_i \left(\frac{g_t}{g_\max}\right)^i` + g_converter: instantiated class of the conductance converter + (defaults to single pair) + g_max: In :math:`\mu S`, the maximal conductance, ie the value + the absolute max of the weights will be mapped to. + t_read: Parameter of the 1/f fit (in seconds). + t_0: Parameter of the drift fit (first reading time). + + Note: + The ``t_inference`` is relative to this time `t0` + e.g. t_inference counts from the completion of the programming + of a device. + prog_noise_scale: Scale for the programming noise. + read_noise_scale: Scale for the read and accumulated noise. + drift_scale: Scale for the drift coefficient. + prog_coeff_g_max_reference: reference :math:`g_\max` value + when fitting the coefficients, since the result of the + polynomial fit is given in uS. If + ``prog_coeff_g_max_reference`` is not given and + `prog_coeffs` are given explicitly, it will be set to + ``g_max`` of the conductance converter. + + .. _`N. Li et al. AEM (2023)`: https://onlinelibrary.wiley.com/doi/pdf/10.1002/aelm.202201190 + + """ + # pylint: disable=too-many-arguments + def __init__(self, + custom_drift_model: dict, + prog_coeff: Optional[List[float]] = None, + g_converter: Optional[BaseConductanceConverter] = None, + g_max: Optional[float] = None, + t_read: float = 250.0e-9, + t_0: float = 20.0, + prog_noise_scale: float = 1.0, + read_noise_scale: float = 1.0, + drift_scale: float = 1.0, + prog_coeff_g_max_reference: Optional[float] = None, + ): + + g_converter = deepcopy(g_converter) or SinglePairConductanceConverter(g_max=g_max) + + super().__init__(prog_coeff=prog_coeff, + g_converter=g_converter, + g_max=g_max, + t_read=t_read, + t_0=t_0, + prog_noise_scale=prog_noise_scale, + read_noise_scale=read_noise_scale, + drift_scale=drift_scale, + prog_coeff_g_max_reference=prog_coeff_g_max_reference, + ) + + self.custom_drift_model = custom_drift_model + + assert isinstance(self.custom_drift_model, + dict), "custom_drift_model must be specified as dictionary" + + assert all(key in ['g_lst', 'nu_mean_lst', 'nu_std_lst'] for key in + self.custom_drift_model), ("Missing required key in custom_drift_model: " + "g_lst, nu_mean_lst, nu_std_lst") + assert all(isinstance(val, List) for _, val in + self.custom_drift_model.items()), ("Value corresponding to each key in " + "custom_drift_model must be a list") + assert all(len(val) >= 2 for _, val in + self.custom_drift_model.items()), ("Each key in custom_drift_model must" + "have at least 2 elements") + + assert sorted(self.custom_drift_model['g_lst']) == self.custom_drift_model['g_lst'], \ + ("Elements in custom_drift_model[g_lst] must be in ascending order") + + drift_model_g_min = min(self.custom_drift_model['g_lst']) + drift_model_g_max = max(self.custom_drift_model['g_lst']) + + # using Single/Dual/NPairConductanceConverter + if hasattr(g_converter, 'g_min') and hasattr(g_converter, 'g_max'): + g_converter_g_min = g_converter.g_min + g_converter_g_max = g_converter.g_max + # using CustomPairConductanceConverter + elif hasattr(g_converter, 'g_lst'): + g_converter_g_min = min(min(gs)for gs in g_converter.g_lst) + g_converter_g_max = max(max(gs)for gs in g_converter.g_lst) + else: + raise ValueError("Unsupported g_converter and drift model combination.") + + if g_converter_g_min < drift_model_g_min or g_converter_g_max > drift_model_g_max: + raise ValueError("g_converter producing conductances " + "(g_min = %0.3f, g_max = %0.3f) " + "outside the range of the custom drift model " + "(g_min = %0.3f, g_max = %0.3f)" + % (g_converter_g_min, g_converter_g_max, + drift_model_g_min, drift_model_g_max)) + + @no_grad() + def generate_drift_coefficients(self, g_target: Tensor) -> Tensor: + """Returns drift coefficients ``nu`` based on custom drift model. + Nu coeffiecients will be interpolated using this model information.""" + + g_lst = Tensor(self.custom_drift_model.get('g_lst')) + nu_mean_lst = Tensor(self.custom_drift_model.get('nu_mean_lst')) + nu_std_lst = Tensor(self.custom_drift_model.get('nu_std_lst')) + + g_min = torch_min(g_lst) + g_max = torch_max(g_lst) + + g_target[g_target > g_max] = g_max # clip G values to g_max + g_target[g_target < g_min] = g_min # clip G values to g_min + + assert (g_target >= g_min).all(), "All G values must be >= g_min" + assert (g_target <= g_max).all(), "All G values must be <= g_max" + assert (g_lst >= 0).all(), "All values specified in g_lst must be > 0" + assert (nu_std_lst >= 0).all(), "All values specified in nu_std_lst must be > 0" + assert equal(torch_sort(g_lst)[0], g_lst), "Values in g_lst must be in ascending order" + + nu_mean = from_numpy(interp(g_target.numpy(), + g_lst.numpy(), + nu_mean_lst.numpy())).float() + nu_std = from_numpy(interp(g_target.numpy(), + g_lst.numpy(), + nu_std_lst.numpy())).float() + + nu_drift = torch_abs(nu_mean + nu_std * randn_like(g_target)) + + nu_drift[nu_drift < 0] = 0. + + return nu_drift * self.drift_scale diff --git a/src/aihwkit/nn/modules/conv.py b/src/aihwkit/nn/modules/conv.py index e0b7c8b6..1644cb71 100644 --- a/src/aihwkit/nn/modules/conv.py +++ b/src/aihwkit/nn/modules/conv.py @@ -180,12 +180,14 @@ def forward(self, x_input: Tensor) -> Tensor: dilation=self.dilation, padding=self.padding, stride=self.stride, - ).transpose(1, 2) + ).transpose(-1, -2) - out = self.analog_module(x_input_).transpose(1, 2) + out = self.analog_module(x_input_).transpose(-1, -2) out_size = ( - im_shape[2] + 2 * self.padding[0] - self.dilation[0] * (self.kernel_size[0] - 1) - 1 + im_shape[-2] + 2 * self.padding[0] - self.dilation[0] * (self.kernel_size[0] - 1) - 1 ) // self.stride[0] + 1 + if len(im_shape) == 3: + return out.view(self.out_channels, out_size, -1) return out.view(im_shape[0], self.out_channels, out_size, -1) diff --git a/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py b/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py index ed65644d..a40159ff 100644 --- a/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py +++ b/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py @@ -19,6 +19,7 @@ from torch import ( Tensor, + empty, zeros, sum as torch_sum, flip, @@ -28,6 +29,7 @@ fmod, allclose, linspace, + Size, ) from torch.autograd import no_grad from torch.nn.functional import pad @@ -69,21 +71,23 @@ def _get_res(cls, res: float) -> float: return res @classmethod - def _interleave_cols_2d(cls, mvm1: Tensor, mvm2: Tensor) -> Tensor: - """Returns 2D matrix with columns interleaved, starting with mvm1 + def _interleave_cols_nd(cls, mvm1: Tensor, mvm2: Tensor) -> Tensor: + """Interleaves two matrices along final dimension to mimic North-South ADcs, + starting with mvm1. Can now handle n-dimensional matrices, not just 2D. Args: - mvm1: ``[batch_size, out_size/2]`` output activations (to south ADCs) - mvm2: ``[batch_size, out_size/2]`` output activations (to north ADCs) + mvm1: ``[*, batch_size, out_size/2]`` output activations (to south ADCs) + mvm2: ``[*, batch_size, out_size/2]`` output activations (to north ADCs) Returns: - Column-wise interleaved 2D matrix of output activations that captures + Column-wise interleaved matrix of output activations that captures IR drop in both directions (to north and south ADCs) in a symmetric tile design. """ - mvm = zeros((mvm1.shape[0], mvm1.shape[1] + mvm2.shape[1])).to(mvm1.device) - mvm[:, 0::2] = mvm1 - mvm[:, 1::2] = mvm2 + shape = Size(mvm1.shape[0:-1]) + Size([mvm1.shape[-1] + mvm2.shape[-1]]) + mvm = empty(*shape).to(mvm1.device) + mvm[..., 0::2] = mvm1 + mvm[..., 1::2] = mvm2 return mvm @classmethod @@ -92,9 +96,10 @@ def _pad_symmetric( ) -> Tuple[Tensor, Tensor]: """Return input_ (activations) and weights symmetrically padded with zeros to mimic symmetric ADCs (north and south). + Can now handle n-dimensional input_, not just 2D. Args: - input_: ``[batch_size, in_size]`` input_ (activations). + input_: ``[*, batch_size, in_size]`` input_ (activations). weight: ``[in_size, out_size]`` weight matrix. phys_input_size: number of hardware tile rows @@ -105,7 +110,8 @@ def _pad_symmetric( if pad1 == 0: return input_, weight pad2 = phys_input_size - weight.shape[0] - pad1 - input_ = pad(input_, (pad1, pad2, 0, 0), "constant", 0) + input_pad_tuple = (pad1, pad2) + (0, 0) * (input_.dim() - 1) + input_ = pad(input_, input_pad_tuple, "constant", 0) weight = pad(weight, (0, 0, pad1, pad2), "constant", 0) return input_, weight @@ -129,10 +135,11 @@ def _prepare_inputs( will return a list of activations for each bit, which depends on the inp_res. SPLIT_MODE and BIT_WISE will appropriately bit-shift the output results to perform - the MVM operation correctly. + the MVM operation correctly. Can handle n-dimensional + input activations, not just 2D. Args: - input_: ``[N, in_size]`` input activations. + input_: ``[*, batch_size, in_size]`` input activations. scale: scale for rescaling input activations. scaling: whether to rescale input activations. with_asymmetry: @@ -155,16 +162,17 @@ def _prepare_inputs( if io_pars.mv_type == AnalogMVType.ONE_PASS: prepared_input = [prepared_input] elif io_pars.mv_type == AnalogMVType.SPLIT_MODE: - n_bits = int(log2(1.0 / res)) - if not log2(1.0 / res) % 1 == 0: + n_bits = int(log2(1.0 / res + 2)) + if not log2(1.0 / res + 2) % 1 == 0: raise ConfigError( - f"inp_res={1. / res} must be power of 2 (or 1/2**n_bits) " + f"inp_res={1. / res} must be of form (2**n_bits - 2) " "for AnalogMVType.SPLIT_MODE" ) if not io_pars.split_mode_bit_shift % 1 == 0: raise ConfigError( - f"split_mode_bit_shift={io_pars.split_mode_bit_shift}" " must be integer" + f"split_mode_bit_shift={io_pars.split_mode_bit_shift}" + " must be integer" ) if not io_pars.split_mode_bit_shift < n_bits: @@ -185,7 +193,8 @@ def _prepare_inputs( prepared_input_lsb = lower_bits * (2 * res) if not allclose( - (2**io_pars.split_mode_bit_shift) * prepared_input_msb + prepared_input_lsb, + (2**io_pars.split_mode_bit_shift) * prepared_input_msb + + prepared_input_lsb, prepared_input, ): raise ConfigError("Split mode pwm conversion error") @@ -193,8 +202,8 @@ def _prepare_inputs( prepared_input = [prepared_input_lsb, prepared_input_msb] elif io_pars.mv_type == AnalogMVType.BIT_WISE: - int_input = prepared_input / (2 * res) - n_bits = int(log2(1.0 / res)) + int_input = prepared_input / (2.0 * res) + n_bits = int(log2(1.0 / res + 2)) - 1 prepared_input = [] for _ in range(n_bits): # fmod for +/- remainders @@ -216,8 +225,7 @@ def _prepare_inputs( def _thev_equiv( cls, input_: Tensor, - weight: Tensor, - g_converter: Optional[SinglePairConductanceConverter] = None, + g_lst: List[Tensor], time_steps: int = 128, t_max: float = 1.0, segments: int = 8, @@ -234,19 +242,12 @@ def _thev_equiv( equivalents into one time-varying Thevenin equivalent circuit per MVM tile column (i.e. each element of out_size). This part is represented by the for loop at the end of the method. Largest indices are closest to - the ADC. + the ADC. Can now handle n-dimensional input activations, not just 2D. Args: - input_: ``[N, in_size]`` MVM tile input activations - - weight: ``[in_size, out_size]`` MVM tile weights - time_steps: discrete time steps for time-varying Thevenin equivalent - (approximation). High value is more accurate whereas lower value - results in faster computation with more IR drop inaccuracy. SPLIT_MODE - and BIT_WISE will automatically set this parameter to an appropriate value. + input_: ``[*, batch_size, in_size]`` MVM tile input activations - g_converter: specifies weight programming scheme which determines conductances - for Thevenin equivlanet circuit. + g_lst: list of conductances in MVM tile t_max: max sim time, beyond which activations all zero. Can cease computation @@ -268,29 +269,38 @@ def _thev_equiv( Returns: Tuple[Tensor] containing thevenin voltages vth_3d and rth_3d where both - have dimensions ``[batch_size, out_size/2, time_steps]``. Tensor vth_3d - is given volts and rth_3d is in units of MOhms. - + have dimensions ``[*, batch_size, out_size/2, time_steps]``. + Tensor vth_nd is given volts and rth_nd is in units of MOhms. """ - seg_rows = int(phys_input_size / segments) - assert seg_rows * segments == phys_input_size, ( + syn_rows_per_seg = int(phys_input_size / segments) + assert syn_rows_per_seg * segments == phys_input_size, ( "Error: phys_input_size " "(%s) must be evenly divisible by number " "of segments (%s)" % (str(phys_input_size), str(segments)) ) - input_, weight = cls._pad_symmetric(input_, weight, phys_input_size=phys_input_size) - if g_converter is None: - g_converter = SinglePairConductanceConverter() - [gp_2d, gm_2d], _ = g_converter.convert_to_conductances(weight) + gp_2d, gm_2d = g_lst + + out_sh = Size(input_.shape[0:-1]) + Size([gp_2d.shape[1]]) + Size([time_steps]) + + input_ = input_.view(-1, input_.shape[-1]) # make 2d if use_extension and extension_ops is not None: # use C++ code for speedup if available output = extension_ops.thevenin_equiv( - input_, gp_2d.T.contiguous(), gm_2d.T.contiguous(), r_s, t_max, time_steps + input_, + gp_2d.T.contiguous(), + gm_2d.T.contiguous(), + r_s, + t_max, + time_steps, ) vth_3d = output[0, :, :, :] rth_3d = output[1, :, :, :] + + vth_nd = vth_3d.view(*out_sh) # reshape back to appropriate dimensions + rth_nd = rth_3d.view(*out_sh) + return vth_3d, rth_3d gp_4d = gp_2d[None, :, :, None] @@ -299,11 +309,17 @@ def _thev_equiv( x_4d = input_[:, :, None, None] def sum_segs(g_values: Tensor) -> Tensor: - if seg_rows == 1: + if syn_rows_per_seg == 1: return g_values shape = g_values.shape return g_values.view( - (shape[0], shape[1] // seg_rows, seg_rows, shape[2], shape[3]) + ( + shape[0], + shape[1] // syn_rows_per_seg, + syn_rows_per_seg, + shape[2], + shape[3], + ) ).sum(dim=2) # pp @@ -331,7 +347,7 @@ def sum_segs(g_values: Tensor) -> Tensor: g_4d = None # wire resistance depends on segmentation - rw_segs = 1e-6 * r_s * seg_rows + rw_segs = 1e-6 * r_s * syn_rows_per_seg vth_3d = vth_4d_segs[:, 0, :, :] rth_3d = 1.0 / gth_4d_segs[:, 0, :, :] @@ -342,7 +358,10 @@ def sum_segs(g_values: Tensor) -> Tensor: vth_3d = (vth_3d / r_1 + vth_4d_segs[:, seg, :, :] / r_2) * rth_3d rth_3d += 0.5 * rw_segs - return vth_3d, rth_3d # rth_3d in MOhm + vth_nd = vth_3d.view(*out_sh) # reshape back to appropriate dimensions + rth_nd = rth_3d.view(*out_sh) + + return vth_nd, rth_nd # rth_nd in MOhm @classmethod def _matmul_irdrop( @@ -362,7 +381,7 @@ def _matmul_irdrop( Args: weight: ``[in_size, out_size]`` MVM tile weights - input_: ``[N, in_size]`` MVM tile input activations + input_: ``[*, batch_size, in_size]`` MVM tile input activations trans: whether to transpose the weight io_pars: Parameter defining the mat-mul nonlinearities and time-dependent IR drop ir_drop: scale of the IR-drop wire resistance @@ -373,9 +392,11 @@ def _matmul_irdrop( info: info string. Returns: - Tensor with 2D matmul result + Tensor with n-dimensional matmul result """ ir_drop_rs = ir_drop * io_pars.ir_drop_rs + res = cls._get_res(io_pars.inp_res) + bit_res = io_pars.inp_bound / res if ir_drop == 0.0: return super(AnalogMVMIRDropT, cls)._matmul(weight, input_, trans) @@ -388,35 +409,55 @@ def _matmul_irdrop( else: new_weight = weight - vth_3d, rth_3d = cls._thev_equiv( - input_, - new_weight[:, 0::2], # even cols - g_converter, - time_steps=time_steps, - t_max=t_max, - segments=io_pars.ir_drop_segments, - r_s=ir_drop_rs, - phys_input_size=phys_input_size, + syn_rows_per_seg = int(phys_input_size / io_pars.ir_drop_segments) + assert syn_rows_per_seg * io_pars.ir_drop_segments == phys_input_size, ( + "Error: phys_input_size " + "(%s) must be evenly divisible by number " + "of segments (%s)" % (str(phys_input_size), str(io_pars.ir_drop_segments)) ) - i_out_3d = (vth_3d - io_pars.ir_drop_v_read) / rth_3d # uA - mvm_even_col_down_adc = torch_sum(i_out_3d, dim=2) # batch_size x n_cols/2 - - vth_3d, rth_3d = cls._thev_equiv( - flip(input_, (1,)), # flip input - flip(new_weight[:, 1::2], (0,)), # odd cols - g_converter, - time_steps=time_steps, - t_max=t_max, - segments=io_pars.ir_drop_segments, - r_s=ir_drop_rs, - phys_input_size=phys_input_size, + + input_, new_weight = cls._pad_symmetric( + input_, new_weight, phys_input_size=phys_input_size ) - i_out_3d = (vth_3d - io_pars.ir_drop_v_read) / rth_3d # uA - mvm_odd_col_up_adc = torch_sum(i_out_3d, dim=2) # batch_size x n_cols/2 + if g_converter is None: + g_converter = SinglePairConductanceConverter() # type: ignore + g_lst, params = g_converter.convert_to_conductances(new_weight) + + mvm = zeros((input_.shape[0], g_lst[0].shape[1])).to(input_.device) + # (f1, (gp1, gm1)), (f2, (gp2, gm2), ... , (fn, (gpn, gmn)) # low to highest significance + for f_factor, g_lst_pair in zip(params.get('f_lst', [1.]), + zip(g_lst[::2], g_lst[1::2])): + vth_nd, rth_nd = cls._thev_equiv( + input_, + [g[:, 0::2] for g in g_lst_pair], # even cols + time_steps=time_steps, + t_max=t_max, + segments=io_pars.ir_drop_segments, + r_s=ir_drop_rs, + phys_input_size=phys_input_size, + ) + i_out_nd = (vth_nd - io_pars.ir_drop_v_read) / rth_nd # uA + mvm_even_col_down_adc = torch_sum(i_out_nd, dim=-1) # * x batch_size x n_cols/2 - mvm = cls._interleave_cols_2d(mvm_even_col_down_adc, mvm_odd_col_up_adc) # symmetric ADCs - mvm /= g_converter.g_max - g_converter.g_min # conductance normalization + vth_nd, rth_nd = cls._thev_equiv( + flip(input_, (-1,)), # flip input + [flip(g[:, 1::2], (0,)) for g in g_lst_pair], # odd cols + time_steps=time_steps, + t_max=t_max, + segments=io_pars.ir_drop_segments, + r_s=ir_drop_rs, + phys_input_size=phys_input_size, + ) + i_out_nd = (vth_nd - io_pars.ir_drop_v_read) / rth_nd # uA + mvm_odd_col_up_adc = torch_sum(i_out_nd, dim=-1) # * x batch_size x n_cols/2 + + mvm += f_factor * cls._interleave_cols_nd( + mvm_even_col_down_adc, mvm_odd_col_up_adc + ) # symmetric ADCs + + mvm /= params['scale_ratio'] # conductance normalization mvm /= 0.2 # hardware normalization + mvm /= bit_res / 2.0 # normalize return mvm @classmethod @@ -439,7 +480,7 @@ def _compute_analog_mv( # type: ignore Args: weight: Weight tensor. - input_: Input tensor in format [N, in_size]. + input_: Input tensor in format [*, batch_size, in_size]. trans: whether to transpose the weight scale: Scale for scaling the input. scaling: Whether to scale. @@ -467,7 +508,7 @@ def _compute_analog_mv( # type: ignore io_pars=io_pars, ) res = cls._get_res(io_pars.inp_res) - bit_res = io_pars.inp_bound / res + bit_res = io_pars.inp_bound / res + 2 if io_pars.mv_type == AnalogMVType.ONE_PASS: # - Perform the noisy MVM @@ -478,11 +519,12 @@ def _compute_analog_mv( # type: ignore io_pars, ir_drop=ir_drop, t_max=1.0, - time_steps=int((bit_res / 2) * io_pars.ir_drop_time_step_resolution_scale), + time_steps=int( + (bit_res / 2) * io_pars.ir_drop_time_step_resolution_scale + ), phys_input_size=phys_input_size, g_converter=g_converter, ) - out_values /= bit_res / 2.0 bound_test_passed, finalized_outputs = cls._finalize_output( out_values=out_values, io_pars=io_pars, **fwd_pars ) @@ -504,15 +546,14 @@ def _compute_analog_mv( # type: ignore g_converter=g_converter, info="LSB", ) - out_values_lsb /= bit_res / 2.0 # normalize bound_test_passed_lsb, finalized_outputs_lsb = cls._finalize_output( out_values=out_values_lsb, io_pars=io_pars, **fwd_pars ) time_steps = 2 ** int( - log2(bit_res + 1) - io_pars.split_mode_bit_shift - 1 + log2(bit_res) - io_pars.split_mode_bit_shift - 1 ) # minus 1 for sign bit - t_max = io_pars.inp_bound / (2**io_pars.split_mode_bit_shift) + t_max = (2 * res) * (time_steps - 1) out_values_msb = cls._matmul_irdrop( weight, prepared_input_msb, @@ -525,13 +566,13 @@ def _compute_analog_mv( # type: ignore g_converter=g_converter, info="MSB", ) - out_values_msb /= bit_res / 2.0 # normalize bound_test_passed_msb, finalized_outputs_msb = cls._finalize_output( out_values=out_values_msb, io_pars=io_pars, **fwd_pars ) finalized_outputs = ( - finalized_outputs_lsb + (2**io_pars.split_mode_bit_shift) * finalized_outputs_msb + finalized_outputs_lsb + + (2**io_pars.split_mode_bit_shift) * finalized_outputs_msb ) bound_test_passed = bound_test_passed_lsb * bound_test_passed_msb @@ -550,7 +591,6 @@ def _compute_analog_mv( # type: ignore g_converter=g_converter, info=str(bit_pos), ) - out_values_1b /= bit_res / 2.0 # normalize bound_test_passed_1b, finalized_outputs_1b = cls._finalize_output( out_values=out_values_1b, io_pars=io_pars, **fwd_pars ) @@ -610,8 +650,14 @@ def check_support(cls, io_pars: IOParameters) -> None: if io_pars.slope_calibration > 0.0: raise ConfigError("Slope calibration not supported in torch tile") - if io_pars.v_offset_std > 0.0 or io_pars.v_offset_w_min > 0.0 or io_pars.r_series > 0.0: + if ( + io_pars.v_offset_std > 0.0 + or io_pars.v_offset_w_min > 0.0 + or io_pars.r_series > 0.0 + ): raise ConfigError("Voltage offset or R-series not supported in torch tile") if io_pars.w_read_asymmetry_dtod > 0.0: - raise ConfigError("Device polarity read dependence is not supported in torch tile") + raise ConfigError( + "Device polarity read dependence is not supported in torch tile" + ) diff --git a/tests/test_inference.py b/tests/test_inference.py index 81cc2251..bca33361 100644 --- a/tests/test_inference.py +++ b/tests/test_inference.py @@ -16,8 +16,12 @@ from aihwkit.inference import ( PCMLikeNoiseModel, + CustomDriftPCMLikeNoiseModel, StateIndependentNoiseModel, SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter, ) from .helpers.testcases import AihwkitTestCase @@ -46,6 +50,24 @@ def test_apply_noise_custom(self): self.assertNotAlmostEqualTensor(noisy_weights, weights) + def test_apply_custom_drift(self): + """Test custom drift model with g_converter""" + weights = randn(10, 35) + + g_min, g_max = 0., 25. + custom_drift_model = dict(g_lst=[g_min, 10., g_max], + nu_mean_lst=[0.08, 0.05, 0.03], + nu_std_lst=[0.03, 0.02, 0.01]) + + noise_model = CustomDriftPCMLikeNoiseModel( + custom_drift_model, + g_converter=SinglePairConductanceConverter(g_min=g_min, g_max=g_max), + ) + t_inference = 100.0 + noisy_weights = noise_model.apply_noise(weights, t_inference) + + self.assertNotAlmostEqualTensor(noisy_weights, weights) + class ConductanceConverterTest(AihwkitTestCase): """Conductance converter test.""" @@ -79,3 +101,115 @@ def test_single_pair_converter(self): converted_weights = g_converter.convert_back_to_weights(g_lst, params) self.assertTensorAlmostEqual(weights, converted_weights) + + def test_dual_pair_converter(self): + """Tests the dual pair converter.""" + g_max = 3.123 + g_min = 0.789 + + weights = randn(10, 35) + + g_converter = DualPairConductanceConverter(f_lst=[1.0, 3.0], + g_max=g_max, + g_min=g_min) + + g_lst, params = g_converter.convert_to_conductances(weights) + + tolerance = 1e-6 + for g_plus, g_minus in zip(g_lst[::2], g_lst[1::2]): + + g_plus = g_lst[0].detach().cpu().numpy() + g_minus = g_lst[1].detach().cpu().numpy() + + self.assertTrue( + (g_plus > g_max - tolerance).sum() + (g_minus > g_max - tolerance).sum() > 0 + ) + self.assertTrue( + (g_plus < g_min - tolerance).sum() + (g_minus < g_min - tolerance).sum() == 0 + ) + self.assertTrue( + (g_plus > g_max + tolerance).sum() + (g_minus > g_max + tolerance).sum() == 0 + ) + + converted_weights = g_converter.convert_back_to_weights(g_lst, params) + + self.assertTensorAlmostEqual(weights, converted_weights) + + def test_n_pair_converter(self): + """Tests the dual pair converter.""" + g_max = 3.123 + g_min = 0.789 + + weights = randn(10, 35) + + g_converter = NPairConductanceConverter(f_lst=[1.0, 2.0, 3.0], + g_max=g_max, + g_min=g_min) + + g_lst, params = g_converter.convert_to_conductances(weights) + + tolerance = 1e-6 + for g_plus, g_minus in zip(g_lst[::2], g_lst[1::2]): + + g_plus = g_lst[0].detach().cpu().numpy() + g_minus = g_lst[1].detach().cpu().numpy() + + self.assertTrue( + (g_plus > g_max - tolerance).sum() + (g_minus > g_max - tolerance).sum() > 0 + ) + self.assertTrue( + (g_plus < g_min - tolerance).sum() + (g_minus < g_min - tolerance).sum() == 0 + ) + self.assertTrue( + (g_plus > g_max + tolerance).sum() + (g_minus > g_max + tolerance).sum() == 0 + ) + + converted_weights = g_converter.convert_back_to_weights(g_lst, params) + + self.assertTensorAlmostEqual(weights, converted_weights) + + def test_custom_pair_converter(self): + """Tests the dual pair converter.""" + g_max = 3.123 + g_min = 0.789 + + weights = randn(10, 35) + + g_converter = CustomPairConductanceConverter(f_lst=[1.0], + g_lst=[[g_min, + g_min, + g_min, + (g_max - g_min) / 2 + g_min, + g_max], + [g_max, + (g_max - g_min) / 2 + g_min, + g_min, + g_min, + g_min], + ], + g_min=g_min, + g_max=g_max, + invertibility_test=False, + ) + + g_lst, params = g_converter.convert_to_conductances(weights) + + tolerance = 1e-6 + for g_plus, g_minus in zip(g_lst[::2], g_lst[1::2]): + + g_plus = g_lst[0].detach().cpu().numpy() + g_minus = g_lst[1].detach().cpu().numpy() + + self.assertTrue( + (g_plus > g_max - tolerance).sum() + (g_minus > g_max - tolerance).sum() > 0 + ) + self.assertTrue( + (g_plus < g_min - tolerance).sum() + (g_minus < g_min - tolerance).sum() == 0 + ) + self.assertTrue( + (g_plus > g_max + tolerance).sum() + (g_minus > g_max + tolerance).sum() == 0 + ) + + converted_weights = g_converter.convert_back_to_weights(g_lst, params) + + self.assertTensorAlmostEqual(weights, converted_weights) # invertibility test From 096fd4ee8249e1aa747b493418430dd03bc845a0 Mon Sep 17 00:00:00 2001 From: pablocarmona Date: Thu, 19 Sep 2024 13:50:20 +0200 Subject: [PATCH 06/14] Release/0.9.2 (#693) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add release content for 0.9.2 * feat(notebooks/tutorial): add notebook outputs for reference * fix(pcm.py): add a check to not get custom_drift_model as None * fix(travis/build): fix proper version for pytorch on mac osx wheel build * fix(travis/build): fix torch version to match compatibility with osx version Signed-off-by: Pablo Carmona González --- .travis.yml | 4 +- notebooks/hermes/hermes_noise_model.ipynb | 8 +- notebooks/hermes/hermes_noise_model_mvm.ipynb | 2 +- notebooks/tutorial/analog_training.ipynb | 1431 ++++++++++++++++- notebooks/tutorial/hw_aware_training.ipynb | 185 ++- src/aihwkit/inference/noise/pcm.py | 97 +- 6 files changed, 1654 insertions(+), 73 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7adc97a2..53170b1d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -120,8 +120,8 @@ jobs: update: true env: # Use a specific torch version. - - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.4.1'" - - CIBW_BEFORE_BUILD="pip install torch==2.4.1 torchvision && pip install ./delocate && pip install -r requirements.txt" + - CIBW_ENVIRONMENT="TORCH_VERSION_SPECIFIER='==2.0.1'" + - CIBW_BEFORE_BUILD="pip install torch==2.0.1 torchvision && pip install ./delocate && pip install -r requirements.txt" - CIBW_BUILD="cp38-macosx_x86_64 cp39-macosx_x86_64" before_install: - git clone -b aihwkit https://github.com/aihwkit-bot/delocate.git diff --git a/notebooks/hermes/hermes_noise_model.ipynb b/notebooks/hermes/hermes_noise_model.ipynb index 9e2b7e5a..c83f833c 100644 --- a/notebooks/hermes/hermes_noise_model.ipynb +++ b/notebooks/hermes/hermes_noise_model.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "cellView": "form", "id": "8dRBAFI2xcEK", @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "9m1qDEsd-C4H" }, @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "id": "DHmjiuKn-C4O" }, @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "id": "6_She6Vv-C4P" }, diff --git a/notebooks/hermes/hermes_noise_model_mvm.ipynb b/notebooks/hermes/hermes_noise_model_mvm.ipynb index 2397df66..f4d8f5ca 100644 --- a/notebooks/hermes/hermes_noise_model_mvm.ipynb +++ b/notebooks/hermes/hermes_noise_model_mvm.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "cellView": "form", "id": "8dRBAFI2xcEK", diff --git a/notebooks/tutorial/analog_training.ipynb b/notebooks/tutorial/analog_training.ipynb index 1e0f54a4..6176443e 100644 --- a/notebooks/tutorial/analog_training.ipynb +++ b/notebooks/tutorial/analog_training.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -67,7 +67,106 @@ "outputId": "425c75fd-6e3c-4ec3-bc86-2f3bdb5afc29", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting pandas\n", + " Downloading pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (19 kB)\n", + "Requirement already satisfied: numpy>=1.22.4 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pandas) (1.26.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pandas) (2.9.0)\n", + "Collecting pytz>=2020.1 (from pandas)\n", + " Downloading pytz-2024.2-py2.py3-none-any.whl.metadata (22 kB)\n", + "Collecting tzdata>=2022.7 (from pandas)\n", + " Downloading tzdata-2024.1-py2.py3-none-any.whl.metadata (1.4 kB)\n", + "Requirement already satisfied: six>=1.5 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n", + "Downloading pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.0/13.0 MB\u001b[0m \u001b[31m80.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pytz-2024.2-py2.py3-none-any.whl (508 kB)\n", + "Downloading tzdata-2024.1-py2.py3-none-any.whl (345 kB)\n", + "Installing collected packages: pytz, tzdata, pandas\n", + "Successfully installed pandas-2.2.2 pytz-2024.2 tzdata-2024.1\n", + "Collecting lmfit\n", + " Downloading lmfit-1.3.2-py3-none-any.whl.metadata (13 kB)\n", + "Collecting asteval>=1.0 (from lmfit)\n", + " Downloading asteval-1.0.4-py3-none-any.whl.metadata (6.2 kB)\n", + "Requirement already satisfied: numpy>=1.19 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from lmfit) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.6 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from lmfit) (1.14.1)\n", + "Collecting uncertainties>=3.2.2 (from lmfit)\n", + " Downloading uncertainties-3.2.2-py3-none-any.whl.metadata (6.9 kB)\n", + "Requirement already satisfied: dill>=0.3.4 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from lmfit) (0.3.8)\n", + "Downloading lmfit-1.3.2-py3-none-any.whl (98 kB)\n", + "Downloading asteval-1.0.4-py3-none-any.whl (21 kB)\n", + "Downloading uncertainties-3.2.2-py3-none-any.whl (58 kB)\n", + "Installing collected packages: uncertainties, asteval, lmfit\n", + "Successfully installed asteval-1.0.4 lmfit-1.3.2 uncertainties-3.2.2\n", + "Collecting pytorch-lightning\n", + " Downloading pytorch_lightning-2.4.0-py3-none-any.whl.metadata (21 kB)\n", + "Requirement already satisfied: torch>=2.1.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pytorch-lightning) (2.3.1)\n", + "Requirement already satisfied: tqdm>=4.57.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pytorch-lightning) (4.66.5)\n", + "Requirement already satisfied: PyYAML>=5.4 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pytorch-lightning) (6.0.2)\n", + "Requirement already satisfied: fsspec>=2022.5.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from fsspec[http]>=2022.5.0->pytorch-lightning) (2024.9.0)\n", + "Collecting torchmetrics>=0.7.0 (from pytorch-lightning)\n", + " Downloading torchmetrics-1.4.2-py3-none-any.whl.metadata (19 kB)\n", + "Requirement already satisfied: packaging>=20.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pytorch-lightning) (24.1)\n", + "Requirement already satisfied: typing-extensions>=4.4.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from pytorch-lightning) (4.12.2)\n", + "Collecting lightning-utilities>=0.10.0 (from pytorch-lightning)\n", + " Downloading lightning_utilities-0.11.7-py3-none-any.whl.metadata (5.2 kB)\n", + "Collecting aiohttp!=4.0.0a0,!=4.0.0a1 (from fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Using cached aiohttp-3.10.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (7.5 kB)\n", + "Requirement already satisfied: setuptools in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from lightning-utilities>=0.10.0->pytorch-lightning) (72.1.0)\n", + "Requirement already satisfied: filelock in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (3.15.4)\n", + "Requirement already satisfied: sympy in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (1.13.2)\n", + "Requirement already satisfied: networkx in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (3.3)\n", + "Requirement already satisfied: jinja2 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (3.1.4)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.105)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (8.9.2.26)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.3.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (11.0.2.54)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (10.3.2.106)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (11.4.5.107)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.0.106)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.20.5 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (2.20.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (12.1.105)\n", + "Requirement already satisfied: triton==2.3.1 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torch>=2.1.0->pytorch-lightning) (2.3.1)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch>=2.1.0->pytorch-lightning) (12.6.68)\n", + "Requirement already satisfied: numpy>1.20.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from torchmetrics>=0.7.0->pytorch-lightning) (1.26.4)\n", + "Collecting aiohappyeyeballs>=2.3.0 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Using cached aiohappyeyeballs-2.4.0-py3-none-any.whl.metadata (5.9 kB)\n", + "Collecting aiosignal>=1.1.2 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Using cached aiosignal-1.3.1-py3-none-any.whl.metadata (4.0 kB)\n", + "Requirement already satisfied: attrs>=17.3.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (24.2.0)\n", + "Collecting frozenlist>=1.1.1 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Using cached frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n", + "Collecting multidict<7.0,>=4.5 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Downloading multidict-6.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.0 kB)\n", + "Collecting yarl<2.0,>=1.0 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Downloading yarl-1.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (48 kB)\n", + "Collecting async-timeout<5.0,>=4.0 (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning)\n", + " Using cached async_timeout-4.0.3-py3-none-any.whl.metadata (4.2 kB)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from jinja2->torch>=2.1.0->pytorch-lightning) (2.1.5)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from sympy->torch>=2.1.0->pytorch-lightning) (1.3.0)\n", + "Requirement already satisfied: idna>=2.0 in /home/pablocarmona/miniconda3/envs/aihwkit/lib/python3.10/site-packages (from yarl<2.0,>=1.0->aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (3.8)\n", + "Downloading pytorch_lightning-2.4.0-py3-none-any.whl (815 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m815.2/815.2 kB\u001b[0m \u001b[31m21.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading lightning_utilities-0.11.7-py3-none-any.whl (26 kB)\n", + "Downloading torchmetrics-1.4.2-py3-none-any.whl (869 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m869.2/869.2 kB\u001b[0m \u001b[31m25.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hUsing cached aiohttp-3.10.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.2 MB)\n", + "Using cached aiohappyeyeballs-2.4.0-py3-none-any.whl (12 kB)\n", + "Using cached aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n", + "Using cached async_timeout-4.0.3-py3-none-any.whl (5.7 kB)\n", + "Using cached frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (239 kB)\n", + "Downloading multidict-6.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (124 kB)\n", + "Downloading yarl-1.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (446 kB)\n", + "Installing collected packages: multidict, lightning-utilities, frozenlist, async-timeout, aiohappyeyeballs, yarl, aiosignal, aiohttp, torchmetrics, pytorch-lightning\n", + "Successfully installed aiohappyeyeballs-2.4.0 aiohttp-3.10.5 aiosignal-1.3.1 async-timeout-4.0.3 frozenlist-1.4.1 lightning-utilities-0.11.7 multidict-6.1.0 pytorch-lightning-2.4.0 torchmetrics-1.4.2 yarl-1.11.1\n" + ] + } + ], "source": [ "# Install some prerequisites\n", "!pip install pandas\n", @@ -86,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -95,7 +194,19 @@ "outputId": "83f8dbf9-c6c5-4b1e-83a4-094cb9a65d75", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-0.6879, -0.4810],\n", + " [-0.6502, -0.6504]], grad_fn=)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from torch import Tensor\n", "from aihwkit.nn import AnalogLinear\n", @@ -122,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -131,7 +242,23 @@ "outputId": "dad251b9-ee12-487d-809e-dd20752bba18", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SingleRPUConfig(\n", + " runtime=RuntimeParameter(),\n", + " pre_post=PrePostProcessingParameter(input_range=InputRangeParameter(enable=False)),\n", + " mapping=MappingParameter(),\n", + " forward=IOParameters(),\n", + " backward=IOParameters(),\n", + " update=UpdateParameters(),\n", + " device=SoftBoundsReferenceDevice()\n", + ")\n" + ] + } + ], "source": [ "from aihwkit.simulator.configs import SoftBoundsReferenceDevice, SingleRPUConfig\n", "\n", @@ -150,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -159,7 +286,23 @@ "outputId": "685dbce9-5979-42f9-c422-2af8a813c669", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SingleRPUConfig(\n", + " runtime=RuntimeParameter(),\n", + " pre_post=PrePostProcessingParameter(input_range=InputRangeParameter(enable=False)),\n", + " mapping=MappingParameter(max_input_size=256, max_output_size=256),\n", + " forward=IOParameters(out_noise=0.1),\n", + " backward=IOParameters(is_perfect=True),\n", + " update=UpdateParameters(),\n", + " device=SoftBoundsReferenceDevice()\n", + ")\n" + ] + } + ], "source": [ "rpu_config.mapping.max_input_size = 256\n", "rpu_config.mapping.max_output_size = 256\n", @@ -180,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -190,7 +333,295 @@ "scrolled": true, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnalogWrapperResNet(\n", + " (conv1): AnalogConv2dMapped(\n", + " 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,147))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): AnalogSequential(\n", + " (0): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,198))\n", + " )\n", + " (1-2): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,189))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,198))\n", + " )\n", + " (1-2): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,189))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,198))\n", + " )\n", + " (1-2): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,189))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,198))\n", + " )\n", + " (1-2): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](64,189))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (layer2): AnalogSequential(\n", + " (0): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,198))\n", + " )\n", + " (1-2): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,189))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-2): 3 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,234))\n", + " )\n", + " (3-4): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,225))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): AnalogSequential(\n", + " (0): AnalogConv2dMapped(\n", + " 64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,64))\n", + " )\n", + " )\n", + " )\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-2): 3 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,234))\n", + " )\n", + " (3-4): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,225))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-2): 3 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,234))\n", + " )\n", + " (3-4): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](128,225))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (layer3): AnalogSequential(\n", + " (0): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-2): 3 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " (3-4): 2 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,225))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-5): 6 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " (6-9): 4 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,225))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): AnalogSequential(\n", + " (0): AnalogConv2dMapped(\n", + " 128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,128))\n", + " )\n", + " )\n", + " )\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-5): 6 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " (6-9): 4 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,225))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-5): 6 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " (6-9): 4 x ModuleList(\n", + " (0): AnalogTile(RPUPulsed[SoftBoundsReference](256,225))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (layer4): AnalogSequential(\n", + " (0): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-5): 6 x ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " (6-9): 4 x ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,225))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-17): 18 x ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,243))\n", + " )\n", + " (18): ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): AnalogSequential(\n", + " (0): AnalogConv2dMapped(\n", + " 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0): ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,256))\n", + " )\n", + " )\n", + " )\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): AnalogConv2dMapped(\n", + " 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-17): 18 x ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,243))\n", + " )\n", + " (18): ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " )\n", + " )\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): AnalogConv2dMapped(\n", + " 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, SingleRPUConfig\n", + " (array): ModuleList(\n", + " (0-17): 18 x ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,243))\n", + " )\n", + " (18): ModuleList(\n", + " (0-1): 2 x AnalogTile(RPUPulsed[SoftBoundsReference](256,234))\n", + " )\n", + " )\n", + " )\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): AnalogLinearMapped(\n", + " in_features=512, out_features=1000, bias=True, SingleRPUConfig\n", + " (analog_module): TileModuleArray(\n", + " (array): ModuleList(\n", + " (0-1): 2 x ModuleList(\n", + " (0-3): 4 x AnalogTile(RPUPulsed[SoftBoundsReference](250,256))\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")\n" + ] + } + ], "source": [ "from torchvision.models import resnet18\n", "from aihwkit.nn.conversion import convert_to_analog_mapped\n", @@ -211,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -221,7 +652,302 @@ "scrolled": true, "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "========================================================================================================================================================================================================\n", + "Model Name: AnalogWrapperResNet\n", + "========================================================================================================================================================================================================\n", + "Per-layer Information\n", + "========================================================================================================================================================================================================\n", + "Layer Information | Tile Information \n", + "========================================================================================================================================================================================================\n", + "Layer Name Is Analog In Shape Out Shape Kernel Shape # of Tiles Reuse Factor Log. tile shape Phys. tile shape utilization (%) \n", + "AnalogConv2dMapped analog [1, 3, 224, 224] [1, 64, 112, 112] (7, 7) 1 12544 - - - \n", + " (64, 147) (256, 256) 14.36 \n", + "BatchNorm2d digital [1, 64, 112, 112] [1, 64, 112, 112] - 0 0 - - - \n", + "ReLU digital [1, 64, 112, 112] [1, 64, 112, 112] - 0 0 - - - \n", + "MaxPool2d digital [1, 64, 112, 112] [1, 64, 56, 56] 3 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 64, 56, 56] (3, 3) 3 3136 - - - \n", + " (64, 198) (256, 256) 19.34 \n", + " (64, 189) (256, 256) 18.46 \n", + " (64, 189) (256, 256) 18.46 \n", + "BatchNorm2d digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "ReLU digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 64, 56, 56] (3, 3) 3 3136 - - - \n", + " (64, 198) (256, 256) 19.34 \n", + " (64, 189) (256, 256) 18.46 \n", + " (64, 189) (256, 256) 18.46 \n", + "BatchNorm2d digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "ReLU digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 64, 56, 56] (3, 3) 3 3136 - - - \n", + " (64, 198) (256, 256) 19.34 \n", + " (64, 189) (256, 256) 18.46 \n", + " (64, 189) (256, 256) 18.46 \n", + "BatchNorm2d digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "ReLU digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 64, 56, 56] (3, 3) 3 3136 - - - \n", + " (64, 198) (256, 256) 19.34 \n", + " (64, 189) (256, 256) 18.46 \n", + " (64, 189) (256, 256) 18.46 \n", + "BatchNorm2d digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "ReLU digital [1, 64, 56, 56] [1, 64, 56, 56] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 128, 28, 28] (3, 3) 3 784 - - - \n", + " (128, 198) (256, 256) 38.67 \n", + " (128, 189) (256, 256) 36.91 \n", + " (128, 189) (256, 256) 36.91 \n", + "BatchNorm2d digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "ReLU digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 128, 28, 28] [1, 128, 28, 28] (3, 3) 5 784 - - - \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 225) (256, 256) 43.95 \n", + " (128, 225) (256, 256) 43.95 \n", + "BatchNorm2d digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 64, 56, 56] [1, 128, 28, 28] (1, 1) 1 784 - - - \n", + " (128, 64) (256, 256) 12.50 \n", + "BatchNorm2d digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "ReLU digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 128, 28, 28] [1, 128, 28, 28] (3, 3) 5 784 - - - \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 225) (256, 256) 43.95 \n", + " (128, 225) (256, 256) 43.95 \n", + "BatchNorm2d digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "ReLU digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 128, 28, 28] [1, 128, 28, 28] (3, 3) 5 784 - - - \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 234) (256, 256) 45.70 \n", + " (128, 225) (256, 256) 43.95 \n", + " (128, 225) (256, 256) 43.95 \n", + "BatchNorm2d digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "ReLU digital [1, 128, 28, 28] [1, 128, 28, 28] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 128, 28, 28] [1, 256, 14, 14] (3, 3) 5 196 - - - \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + "BatchNorm2d digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "ReLU digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 256, 14, 14] [1, 256, 14, 14] (3, 3) 10 196 - - - \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + "BatchNorm2d digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 128, 28, 28] [1, 256, 14, 14] (1, 1) 1 196 - - - \n", + " (256, 128) (256, 256) 50.00 \n", + "BatchNorm2d digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "ReLU digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 256, 14, 14] [1, 256, 14, 14] (3, 3) 10 196 - - - \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + "BatchNorm2d digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "ReLU digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 256, 14, 14] [1, 256, 14, 14] (3, 3) 10 196 - - - \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + "BatchNorm2d digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "ReLU digital [1, 256, 14, 14] [1, 256, 14, 14] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 256, 14, 14] [1, 512, 7, 7] (3, 3) 20 49 - - - \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + " (256, 225) (256, 256) 87.89 \n", + "BatchNorm2d digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "ReLU digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 512, 7, 7] [1, 512, 7, 7] (3, 3) 38 49 - - - \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + "BatchNorm2d digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 256, 14, 14] [1, 512, 7, 7] (1, 1) 2 49 - - - \n", + " (256, 256) (256, 256) 100.00 \n", + " (256, 256) (256, 256) 100.00 \n", + "BatchNorm2d digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "ReLU digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 512, 7, 7] [1, 512, 7, 7] (3, 3) 38 49 - - - \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + "BatchNorm2d digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "ReLU digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "AnalogConv2dMapped analog [1, 512, 7, 7] [1, 512, 7, 7] (3, 3) 38 49 - - - \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 243) (256, 256) 94.92 \n", + " (256, 234) (256, 256) 91.41 \n", + " (256, 234) (256, 256) 91.41 \n", + "BatchNorm2d digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "ReLU digital [1, 512, 7, 7] [1, 512, 7, 7] - 0 0 - - - \n", + "AdaptiveAvgPool2d digital [1, 512, 7, 7] [1, 512, 1, 1] - 0 0 - - - \n", + "AnalogLinearMapped analog [1, 512] [1, 1000] - 8 1 - - - \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + " (250, 256) (256, 256) 97.66 \n", + "========================================================================================================================================================================================================\n", + "General Information\n", + "========================================================================================================================================================================================================\n", + "Total number of tiles: 212\n", + "Total number of analog layers: 21" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from aihwkit.utils.analog_info import analog_summary\n", "\n", @@ -242,7 +968,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -252,7 +978,18 @@ "outputId": "81bd3063-e880-476f-d311-2b46f2cd2fdf", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from aihwkit.utils.visualization import plot_device_compact\n", "from aihwkit.simulator.configs import SoftBoundsReferenceDevice\n", @@ -272,7 +1009,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -282,7 +1019,18 @@ "outputId": "09b9a1b6-1240-4f60-c990-924252c0ea15", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "device_config_plain = SoftBoundsReferenceDevice(w_min_dtod=0.0, w_max_dtod=0.0, dw_min_dtod=0.0, up_down_dtod=0.0, dw_min_std=1.0)\n", "plot_device_compact(device_config_plain, n_traces=5);" @@ -299,7 +1047,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -309,7 +1057,35 @@ "outputId": "6c481dd4-f710-4b62-a483-c5a0cf5cffa9", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-18 19:21:45-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/IEDM_2022.csv\n", + "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", + "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 7723 (7.5K) [text/csv]\n", + "Saving to: ‘IEDM_2022.csv’\n", + "\n", + "IEDM_2022.csv 100%[===================>] 7.54K --.-KB/s in 0s \n", + "\n", + "2024-09-18 19:21:46 (1.20 GB/s) - ‘IEDM_2022.csv’ saved [7723/7723]\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from numpy import ones, absolute, concatenate, tile, average\n", "import matplotlib.pyplot as plt\n", @@ -342,7 +1118,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "id": "pJLk2j5vMXr3", "tags": [] @@ -367,7 +1143,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -376,7 +1152,26 @@ "outputId": "94e053bc-9aa0-4bef-af27-b9cdf73f5bc6", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SoftBoundsReferenceDevice(\n", + " dw_min=0.020470346964324024,\n", + " dw_min_dtod=0.0,\n", + " dw_min_std=0.0,\n", + " reset_std=0.0,\n", + " up_down=0.33704489385280056,\n", + " up_down_dtod=0.0,\n", + " w_max=0.8486431288966343,\n", + " w_max_dtod=0.0,\n", + " w_min=-1.02220239921561,\n", + " w_min_dtod=0.0\n", + ")\n" + ] + } + ], "source": [ "from aihwkit.utils.fitting import fit_measurements\n", "up_down = [1, -1]\n", @@ -403,7 +1198,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -413,7 +1208,18 @@ "outputId": "98dca2f0-1f11-4ed7-ad85-cb1f7e92f27c", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "figure = plt.figure(figsize=[6, 4])\n", "plt.plot(response, label='response pulses (measurement)')\n", @@ -437,7 +1243,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -447,7 +1253,18 @@ "outputId": "8777dba7-bebb-432a-9ec6-9d5909b878b4", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from numpy import sqrt\n", "\n", @@ -491,7 +1308,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "id": "dzJdgAIdMXr5", "tags": [] @@ -519,7 +1336,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "id": "Qd659ZgSMXr6", "tags": [] @@ -560,7 +1377,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "id": "MowjqQWRMXr7", "tags": [] @@ -632,7 +1449,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "id": "jQUrQckeMXr7", "tags": [] @@ -670,7 +1487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "id": "iTZZhj-ZMXr8", "tags": [] @@ -716,7 +1533,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -794,7 +1611,215 @@ "outputId": "87e6e4ec-96da-4b91-9274-4d8fb27543b6", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to data/DATASET/MNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 9912422/9912422 [00:02<00:00, 4021546.73it/s] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting data/DATASET/MNIST/raw/train-images-idx3-ubyte.gz to data/DATASET/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to data/DATASET/MNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 28881/28881 [00:00<00:00, 251030.86it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting data/DATASET/MNIST/raw/train-labels-idx1-ubyte.gz to data/DATASET/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to data/DATASET/MNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1648877/1648877 [00:00<00:00, 2481306.10it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting data/DATASET/MNIST/raw/t10k-images-idx3-ubyte.gz to data/DATASET/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to data/DATASET/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4542/4542 [00:00<00:00, 6850244.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting data/DATASET/MNIST/raw/t10k-labels-idx1-ubyte.gz to data/DATASET/MNIST/raw\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a826ec2e0a424f7d9f38535c47588353", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃ Test metric ┃ DataLoader 0 ┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ test_acc │ 0.5511999726295471 │\n", + "│ test_loss │ 1.3861665725708008 │\n", + "└───────────────────────────┴───────────────────────────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.5511999726295471 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 1.3861665725708008 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "trainer, model = build_trainer(get_sgd_rpu_config(), log=\"sgd\")\n", "fit_model(trainer, model)\n", @@ -836,7 +1861,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -845,7 +1870,64 @@ "outputId": "a40150fb-363d-4a3b-a9f8-9edb454f35d0", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UnitCellRPUConfig(\n", + " runtime=RuntimeParameter(),\n", + " pre_post=PrePostProcessingParameter(input_range=InputRangeParameter(enable=False)),\n", + " mapping=MappingParameter(weight_scaling_omega=0.6, weight_scaling_columnwise=True, learn_out_scaling=True),\n", + " forward=IOParameters(),\n", + " backward=IOParameters(),\n", + " update=UpdateParameters(desired_bl=5),\n", + " device=ChoppedTransferCompound(\n", + " unit_cell_devices=[\n", + " SoftBoundsReferenceDevice(\n", + " construction_seed=123,\n", + " dw_min=0.020470346964324024,\n", + " dw_min_dtod_log_normal=True,\n", + " dw_min_std=5.0,\n", + " reset_std=0.0,\n", + " up_down=0.33704489385280056,\n", + " up_down_dtod=0.05,\n", + " w_max=0.8486431288966343,\n", + " w_max_dtod=0.1,\n", + " w_min=-1.02220239921561,\n", + " w_min_dtod=0.1,\n", + " write_noise_std=4.0254904007736805,\n", + " reference_std=0.05,\n", + " subtract_symmetry_point=True\n", + " ),\n", + " SoftBoundsReferenceDevice(\n", + " construction_seed=123,\n", + " dw_min=0.020470346964324024,\n", + " dw_min_dtod_log_normal=True,\n", + " dw_min_std=5.0,\n", + " reset_std=0.0,\n", + " up_down=0.33704489385280056,\n", + " up_down_dtod=0.05,\n", + " w_max=0.8486431288966343,\n", + " w_max_dtod=0.1,\n", + " w_min=-1.02220239921561,\n", + " w_min_dtod=0.1,\n", + " write_noise_std=4.0254904007736805,\n", + " reference_std=0.05,\n", + " subtract_symmetry_point=True\n", + " )\n", + " ],\n", + " construction_seed=123,\n", + " fast_lr=0.01,\n", + " transfer_forward=IOParameters(bound_management=BoundManagementType.NONE, noise_management=NoiseManagementType.NONE),\n", + " transfer_update=UpdateParameters(desired_bl=1, update_bl_management=False, update_management=False),\n", + " in_chop_prob=0.0,\n", + " auto_granularity=15000\n", + " )\n", + ")\n" + ] + } + ], "source": [ "from aihwkit.simulator.configs import build_config\n", "\n", @@ -864,7 +1946,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -942,7 +2024,125 @@ "outputId": "a3990eec-3966-409d-d666-007168822a97", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9388824c5fe94ffc9d5b4e62462b5855", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃ Test metric ┃ DataLoader 0 ┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ test_acc │ 0.7615000009536743 │\n", + "│ test_loss │ 0.7763383984565735 │\n", + "└───────────────────────────┴───────────────────────────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7615000009536743 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.7763383984565735 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "trainer, model = build_trainer(rpu_config, log=\"ttv2\")\n", "fit_model(trainer, model)\n", @@ -961,7 +2161,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -970,7 +2170,40 @@ "outputId": "357469f9-e21b-4797-88c8-96e57ae38ae2", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DigitalRankUpdateRPUConfig(\n", + " runtime=RuntimeParameter(),\n", + " pre_post=PrePostProcessingParameter(input_range=InputRangeParameter(enable=False)),\n", + " mapping=MappingParameter(),\n", + " forward=IOParameters(),\n", + " backward=IOParameters(),\n", + " update=UpdateParameters(),\n", + " device=MixedPrecisionCompound(\n", + " device=SoftBoundsReferenceDevice(\n", + " construction_seed=123,\n", + " dw_min=0.020470346964324024,\n", + " dw_min_dtod_log_normal=True,\n", + " dw_min_std=5.0,\n", + " reset_std=0.0,\n", + " up_down=0.33704489385280056,\n", + " up_down_dtod=0.05,\n", + " w_max=0.8486431288966343,\n", + " w_max_dtod=0.1,\n", + " w_min=-1.02220239921561,\n", + " w_min_dtod=0.1,\n", + " write_noise_std=4.0254904007736805,\n", + " reference_std=0.05,\n", + " subtract_symmetry_point=True\n", + " )\n", + " )\n", + ")\n" + ] + } + ], "source": [ "algorithm = 'mp' # or tiki-taka, ttv2, c-ttv2, mp, sgd\n", "\n", @@ -989,7 +2222,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1067,7 +2300,125 @@ "outputId": "20b4bcde-eeca-4217-fdef-35589a12ced3", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d913b8c17694e23ab737f4a17d373ec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃ Test metric ┃ DataLoader 0 ┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ test_acc │ 0.9258999824523926 │\n", + "│ test_loss │ 0.2496766299009323 │\n", + "└───────────────────────────┴───────────────────────────┘\n", + "\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[36m \u001b[0m\u001b[36m test_acc \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.9258999824523926 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[36m \u001b[0m\u001b[36m test_loss \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 0.2496766299009323 \u001b[0m\u001b[35m \u001b[0m│\n", + "└───────────────────────────┴───────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHFCAYAAAAOmtghAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADCpElEQVR4nOydd5wURdrHf7M5suQclZwRRAkiQckYMGJEvTtRMRzHeWIE9MRXUTEcYkQ903mHOQOSlJwzgpLZJbPLLmyaqfeP3Z7pUN1dHWZ6Zvb5fj4LMz3dVdXdFZ56nqee8jHGGAiCIAiCIOKEBK8LQBAEQRAE4SYk3BAEQRAEEVeQcEMQBEEQRFxBwg1BEARBEHEFCTcEQRAEQcQVJNwQBEEQBBFXkHBDEARBEERcQcINQRAEQRBxBQk3BEEQBEHEFSTcxBjvvvsufD5f8C8pKQmNGzfGbbfdhoMHD7qa19NPP40vvvhCc3zhwoXw+XxYuHCh5TRFr3WSBxF7+Hw+TJ482fJ1hw4dwuTJk7F+/XrXy+Qm/fv3R//+/b0uhi0mT54Mn88X8XxjuQ9o3rw5xo4da+kaqW/fs2dPWMpU1UjyugCEPWbPno22bdvi7NmzWLx4MaZNm4ZFixZh06ZNyMzMdCWPp59+GldffTWuuOIKxfHzzjsPy5YtQ/v27V3Jh0ck8iBin0OHDmHKlClo3rw5unbt6nVxdJk5c6bXRbDNn/70JwwdOtTrYsQUn3/+OapVq2bpmhEjRmDZsmVo0KBBmEpVtSDhJkbp2LEjevToAQAYMGAA/H4/nnzySXzxxRe48cYbHaV99uxZpKen6/5erVo1XHjhhY7yMCMSecQrfr8f5eXlSE1N9booRCWxLKQ3btwYjRs39roYYcOsv7NDt27dLF9Tp04d1KlTx9VyVGXILBUnSILA3r17AQBTpkzBBRdcgJo1a6JatWo477zz8Pbbb0O9T2rz5s0xcuRIfPbZZ+jWrRvS0tIwZcoU+Hw+FBUV4b333guawCS1Ok9dvHr1alx//fVo3rw50tPT0bx5c4wZMyZYHqvw8hg7diyysrKwa9cuDB8+HFlZWWjSpAn+9re/oaSkRChdn8+H8ePHY/bs2WjTpg3S09PRo0cPLF++HIwxPPfcc2jRogWysrIwcOBA7Nq1S5PGvHnzMGjQIFSrVg0ZGRno06cP5s+frzhHUuVv3LgR11xzDXJyclCzZk1MmDAB5eXl2LFjB4YOHYrs7Gw0b94czz77rCafffv24aabbkLdunWRmpqKdu3a4fnnn0cgEAies2fPHvh8Pjz77LN46qmn0KJFC6SmpmLu3LmoXr067rzzTk26e/bsQWJiIp577jnd56RnEpDye/fdd4PHpPeyZcsWDBo0CJmZmahTpw7Gjx+PM2fOKK4vKCjAn//8Z9SqVQtZWVkYOnQofvvtN03+u3btwm233YZWrVohIyMDjRo1wqhRo7Bp0yZFGc8//3wAwG233Rasp3Lz1urVq3HZZZehZs2aSEtLQ7du3fDpp5/q3red+//jjz9w/fXXo2HDhkhNTUW9evUwaNAghalMbZaS0pk+fTpeeOGFYJ3r1asXli9frinPm2++idatWyM1NRXt27fHRx99hLFjx6J58+am9yK18W+++QbdunVDeno62rVrh2+++QZAhTmkXbt2yMzMRM+ePbF69WrF9Wqz1C+//ILk5GRMnDhRcZ5kVnn77beDx3bu3IkbbrhBUYf/9a9/acq4fft2DB06FBkZGahduzbGjRuH06dPm96bvHzr1q3D6NGjUa1aNeTk5OCmm27C0aNHuc9C3d8BQF5eHu688040btwYKSkpaNGiBaZMmYLy8nJFGiUlJZg6dSratWuHtLQ01KpVCwMGDMDSpUsV+cjNUoFAAE899VSwz6levTo6d+6Ml156SfP81Gapd955B126dEFaWhpq1qyJK6+8Etu2bVOc40bfGG+Q5iZOkAZhSfLfs2cP7rzzTjRt2hQAsHz5ctx77704ePAgHn/8ccW1a9euxbZt2/Doo4+iRYsWyMzMxBVXXIGBAwdiwIABeOyxxwDAUM26Z88etGnTBtdffz1q1qyJ3NxcvPbaazj//POxdetW1K5d25X7LCsrw2WXXYY77rgDf/vb37B48WI8+eSTyMnJ0dyXHt988w3WrVuHZ555Bj6fD//4xz8wYsQI3Hrrrfjjjz/w6quvIj8/HxMmTMBVV12F9evXBzv3Dz74ALfccgsuv/xyvPfee0hOTsbrr7+OIUOG4Mcff8SgQYMUeV177bW46aabcOedd2Lu3Ll49tlnUVZWhnnz5uHuu+/GxIkT8dFHH+Ef//gHWrZsidGjRwMAjh49it69e6O0tBRPPvkkmjdvjm+++QYTJ07E77//rjFzvPzyy2jdujWmT5+OatWqoVWrVrj99tvxxhtv4Nlnn0VOTk7w3JkzZyIlJQW33367k1ehoKysDMOHD8edd96Jhx56CEuXLsVTTz2FvXv34uuvvwYAMMZwxRVXYOnSpXj88cdx/vnn49dff8WwYcM06R06dAi1atXCM888gzp16uDEiRN47733cMEFF2DdunVo06YNzjvvPMyePRu33XYbHn30UYwYMQIAglqGBQsWYOjQobjgggswa9Ys5OTk4JNPPsF1112HM2fOWPaJ0GP48OHw+/149tln0bRpUxw7dgxLly7FqVOnTK/917/+hbZt22LGjBkAgMceewzDhw/H7t27g+/sjTfewJ133omrrroKL774IvLz8zFlyhRLg9aGDRswadIkPPLII8jJycGUKVMwevRoTJo0CfPnz8fTTz8dbAsjR47E7t27dbUZffv2xVNPPYWHHnoI/fr1w2WXXYYtW7bgnnvuwU033YQ77rgDALB161b07t0bTZs2xfPPP4/69evjxx9/xH333Ydjx47hiSeeAAAcPnwYF198MZKTkzFz5kzUq1cPH374IcaPHy98fwBw5ZVX4tprr8W4ceOwZcsWPPbYY9i6dStWrFiB5OTk4Hm8/i4vLw89e/ZEQkICHn/8cZx77rlYtmwZnnrqKezZswezZ88GAJSXl2PYsGFYsmQJHnjgAQwcOBDl5eVYvnw59u3bh969e3PL9uyzz2Ly5Ml49NFH0a9fP5SVlWH79u2mdWTatGl4+OGHMWbMGEybNg3Hjx/H5MmT0atXL6xatQqtWrUKnutG3xhXMCKmmD17NgPAli9fzsrKytjp06fZN998w+rUqcOys7NZXl6e5hq/38/KysrY1KlTWa1atVggEAj+1qxZM5aYmMh27NihuS4zM5PdeuutmuMLFixgANiCBQt0y1leXs4KCwtZZmYme+mllyxdq3ferbfeygCwTz/9VHHu8OHDWZs2bQzTkwDA6tevzwoLC4PHvvjiCwaAde3aVfFsZsyYwQCwjRs3MsYYKyoqYjVr1mSjRo1SpOn3+1mXLl1Yz549g8eeeOIJBoA9//zzinO7du3KALDPPvsseKysrIzVqVOHjR49OnjsoYceYgDYihUrFNffddddzOfzBd/X7t27GQB27rnnstLSUsW5v//+O0tISGAvvvhi8NjZs2dZrVq12G233Wb4nPTek5Tf7Nmzg8ek9yJ/z4wx9s9//pMBYL/88gtjjLHvv//e8LwnnnhCtzzl5eWstLSUtWrViv31r38NHl+1apWmPBJt27Zl3bp1Y2VlZYrjI0eOZA0aNGB+v9/x/R87dowBYDNmzNBNizHGLr74YnbxxRdr0unUqRMrLy8PHl+5ciUDwD7++GPGWEXdql+/PrvgggsU6e3du5clJyezZs2aGebLWEUbT09PZwcOHAgeW79+PQPAGjRowIqKioLHpbbw1VdfBY9JdVlOIBBgw4cPZ9WrV2ebN29m7du3Z23btlW0qyFDhrDGjRuz/Px8xbXjx49naWlp7MSJE4wxxv7xj38wn8/H1q9frzjv0ksvFeorpPLJ6wVjjH344YcMAPvggw8Uz4LX3915550sKyuL7d27V3F8+vTpDADbsmULY4yx999/nwFgb775pmGZmjVrpug7R44cybp27Wp4jdS37969mzHG2MmTJ1l6ejobPny44rx9+/ax1NRUdsMNNwSPudE3xhtklopRLrzwQiQnJyM7OxsjR45E/fr18f3336NevXoAgJ9//hmXXHIJcnJykJiYiOTkZDz++OM4fvw4jhw5okirc+fOaN26taPyFBYWBrUPSUlJSEpKQlZWFoqKijQqVCf4fD6MGjVKcaxz584K85fkcyL9yc04QIWPktzpul27dgCAYcOGKdTv0nEp7aVLl+LEiRO49dZbNekPHToUq1atQlFRkSKvkSNHKr63a9cOPp9Poa1ISkpCy5YtFffw888/o3379ujZs6fi+rFjx4Ixhp9//llx/LLLLlPMTgHgnHPOwciRIzFz5sygOfKjjz7C8ePHLc+KRVD7et1www0AKjQo8v/1zpNTXl6Op59+Gu3bt0dKSgqSkpKQkpKCnTt3CtWnXbt2Yfv27cG85O9r+PDhyM3NxY4dO6zfpIqaNWvi3HPPxXPPPYcXXngB69at09Q3I0aMGIHExMTg986dOwMI1bkdO3YgLy8P1157reK6pk2bok+fPsL5dO3aFY0aNQp+l+p2//79kZGRoTluZk72+Xx4//33kZ2djR49emD37t349NNPg+2quLgY8+fPx5VXXomMjAzN8y8uLg6a3xYsWIAOHTqgS5cuijx49cIIdb269tprkZSUFKx3Erz+7ptvvsGAAQPQsGFDRVmldrpo0SIAwPfff4+0tDTLWs+ePXtiw4YNuPvuu/Hjjz+ioKDA9Jply5bh7NmzGg1jkyZNMHDgQI0pXKRvrEqQcBOjvP/++1i1ahXWrVuHQ4cOYePGjcHObuXKlRg8eDCAClv9r7/+ilWrVuGRRx4BUOFAJ8cN7/wbbrgBr776Kv70pz/hxx9/xMqVK7Fq1SrUqVNHk58TMjIykJaWpjiWmpqK4uLi4PdBgwYhOTk5+KfuiGrWrKn4npKSYnhcSvvw4cMAgKuvvlqRfnJyMv7v//4PjDGcOHHCNC/ePaSkpCju4fjx49z30rBhw+DvcvTe4f3334+dO3di7ty5ACrMIL169cJ5553HPd8uSUlJqFWrluJY/fr1FWU9fvy44XlyJkyYgMceewxXXHEFvv76a6xYsQKrVq1Cly5dhOqT9K4mTpyoeVd33303AODYsWPWb1SFz+fD/PnzMWTIEDz77LM477zzUKdOHdx3331CPiPqZyE5gUv3KD07adIih3dMD7t13ohatWrhsssuQ3FxMYYOHYpOnToFfzt+/DjKy8vxyiuvaJ7/8OHDAYSe//Hjx7l1gHfMCPX5Ul0TaSuHDx/G119/rSlrhw4dFGU9evQoGjZsiIQEa0PnpEmTMH36dCxfvhzDhg1DrVq1MGjQII1/kxyp3Hr9gPq+RPrGqgT53MQo7dq1C66WUvPJJ58gOTkZ33zzjaKy82LWAHAcwyI/Px/ffPMNnnjiCTz00EPB4yUlJZrBPhK8/vrrioHFLX8fKZ1XXnlFdyWXlQHHiFq1aiE3N1dz/NChQ4qySOi9w4EDB6Jjx4549dVXkZWVhbVr1+KDDz4wzV+qN2q/Dj2BoLy8HMePH1cM1nl5ecF7kf43Ok+O5Nv09NNPa/KvXr26afml5zNp0qSgH5OaNm3a6F5v5f6bNWsWdKL97bff8Omnn2Ly5MkoLS3FrFmzTMtqhPScJGFNDu+5RZK5c+fitddeQ8+ePfH5559jzpw5uOqqqwAANWrUQGJiIm6++Wbcc8893OtbtGgBoOIeefdi9f7y8vIU2ileXQP4baV27dro3Lkz/vnPf3LTliYVderUwS+//IJAIGBJwElKSsKECRMwYcIEnDp1CvPmzcPDDz+MIUOGYP/+/QrtmYRUbr1+wK1+LV4hzU0cIgX3k6u7z549i3//+9+W0klNTRWaJft8PjDGNEuP33rrLfj9fkt5ukGbNm3Qo0eP4J/IihIR+vTpg+rVq2Pr1q2K9OV/0szXKYMGDcLWrVuxdu1axfH3338fPp8PAwYMEE7rvvvuw7fffotJkyahXr16uOaaa0yvkZ7Zxo0bFce/+uor3Ws+/PBDxfePPvoIAIKrhKQy650nx+fzaerTt99+qwlUqdZ0SLRp0watWrXChg0bdN9Vdna27r3YuX8AaN26NR599FF06tRJ8+7s0KZNG9SvX1+zwmvfvn2K1TmRJjc3FzfddBMuvvhiLF26NOjIunv3bgAVWoQBAwZg3bp16Ny5M/f5S4P3gAEDsGXLFmzYsEGRB69eGKGuV59++inKy8uFgieOHDkSmzdvxrnnnsstqyTcDBs2DMXFxYrVclapXr06rr76atxzzz04ceKEbtC+Xr16IT09XTMZOXDgAH7++WfN4gVCCWlu4pARI0bghRdewA033IC//OUvOH78OKZPn2457kmnTp2wcOFCfP3112jQoAGys7O5s91q1aqhX79+eO6551C7dm00b94cixYtwttvvy00y44VsrKy8Morr+DWW2/FiRMncPXVV6Nu3bo4evQoNmzYgKNHj+K1115zJa+//vWveP/99zFixAhMnToVzZo1w7fffouZM2firrvusuQjddNNN2HSpElYvHgxHn30USEBrH79+rjkkkswbdo01KhRA82aNcP8+fPx2Wefcc9PSUnB888/j8LCQpx//vnB1VLDhg1D3759AQCDBw9Gv3798OCDD6KoqAg9evTAr7/+yhW6R44ciXfffRdt27ZF586dsWbNGjz33HOaeCvnnnsu0tPT8eGHH6Jdu3bIyspCw4YN0bBhQ7z++usYNmwYhgwZgrFjx6JRo0Y4ceIEtm3bhrVr1+K///2v4/vfuHEjxo8fj2uuuQatWrVCSkoKfv75Z2zcuFGhxbRLQkICpkyZgjvvvBNXX301br/9dpw6dQpTpkxBgwYNLJtH3MDv92PMmDHw+Xz46KOPkJiYiHfffRddu3bFddddh19++QUpKSl46aWX0LdvX1x00UW466670Lx5c5w+fRq7du3C119/HfQbe+CBB/DOO+9gxIgReOqpp4KrpbZv326pXJ999hmSkpJw6aWXBldLdenSReOvxGPq1KmYO3cuevfujfvuuw9t2rRBcXEx9uzZg++++w6zZs1C48aNMWbMGMyePRvjxo3Djh07MGDAAAQCAaxYsQLt2rXD9ddfz01/1KhRwdhkderUwd69ezFjxgw0a9ZMseJJTvXq1fHYY4/h4Ycfxi233IIxY8bg+PHjmDJlCtLS0oKrzazSsmVLAOCGuYgrvPVnJqwiedSvWrXK8Lx33nmHtWnThqWmprJzzjmHTZs2jb399tsKb3zGKrz6R4wYwU1j/fr1rE+fPiwjI4MBCK724K0kOXDgALvqqqtYjRo1WHZ2Nhs6dCjbvHmzZtWA09VSmZmZmnN5qzn0AMDuuecexTFp5cpzzz3HLcN///tfxfFFixaxESNGsJo1a7Lk5GTWqFEjNmLECMV5UpmOHj2quFbvHi6++GLWoUMHxbG9e/eyG264gdWqVYslJyezNm3asOeee06xykev7GrGjh3LkpKSFCtmzMjNzWVXX301q1mzJsvJyWE33XQTW716NXe1VGZmJtu4cSPr378/S09PZzVr1mR33XWXYvUMY4ydOnWK3X777ax69eosIyODXXrppWz79u2a1VInT55kd9xxB6tbty7LyMhgffv2ZUuWLNGsOmKMsY8//pi1bduWJScna9LZsGEDu/baa1ndunVZcnIyq1+/Phs4cCCbNWuWK/d/+PBhNnbsWNa2bVuWmZnJsrKyWOfOndmLL76oWAWlt1qK997U98AYY2+88QZr2bIlS0lJYa1bt2bvvPMOu/zyy1m3bt1M70OvjYu2BXX7euSRR1hCQgKbP3++4tqlS5eypKQkdv/99yvSu/3221mjRo1YcnIyq1OnDuvduzd76qmnFNdu3bqVXXrppSwtLY3VrFmT3XHHHezLL7+0tFpqzZo1bNSoUSwrK4tlZ2ezMWPGsMOHDws9C8YYO3r0KLvvvvtYixYtWHJyMqtZsybr3r07e+SRRxT1+OzZs+zxxx9nrVq1YikpKaxWrVps4MCBbOnSpYp85P3e888/z3r37s1q167NUlJSWNOmTdkdd9zB9uzZEzxHvVpK4q233mKdO3dmKSkpLCcnh11++eXB1VsSVvrGZs2aCa2yi3V8jKmiuhEEEVeUlpaiefPm6Nu3r1AAO6uMHTsW//vf/1BYWOh62gSfU6dOoXXr1rjiiivwxhtveF0cT5k8eTKmTJmCo0ePkh8KEYTMUgQRpxw9ehQ7duzA7NmzcfjwYVfMJETkycvLwz//+U8MGDAAtWrVwt69e/Hiiy/i9OnTuP/++70uHkFEJSTcEESc8u233+K2225DgwYNMHPmTNeXfxORITU1FXv27MHdd9+NEydOICMjAxdeeCFmzZoVXKpMEIQSMksRBEEQBBFX0FJwgiAIgiDiChJuCIIgCIKIK0i4IQiCIAgirqhyDsWBQACHDh1Cdna2420HCIIgCIKIDIwxnD59Wmh/ryon3Bw6dAhNmjTxuhgEQRAEQdhg//79mmjlaqqccCPtJ7N//35Uq1bN49IQBEEQBCFCQUEBmjRpYrgvnESVE24kU1S1atVIuCEIgiCIGEPEpYQcigmCIAiCiCtIuCEIgiAIIq4g4YYgCIIgiLiiyvncEARBEPGJ3+9HWVmZ18UgHJCSkmK6zFsEEm4IgiCImIYxhry8PJw6dcrrohAOSUhIQIsWLZCSkuIoHRJuCIIgiJhGEmzq1q2LjIwMCtAao0hBdnNzc9G0aVNH75GEG4IgCCJm8fv9QcGmVq1aXheHcEidOnVw6NAhlJeXIzk52XY65FBMEARBxCySj01GRobHJSHcQDJH+f1+R+mQcEMQBEHEPGSKig/ceo8k3BAEQRAEEVeQcEMQBEEQMU7z5s0xY8YMV9JauHAhfD5fTK8+I4digiAIgvCA/v37o2vXrq4IJatWrUJmZqbzQsUJJNwQBFGlKC7zIyUxAQkJ5KNBRDeMMfj9fiQlmQ/VderUiUCJYgcySxEEUWXIP1uG9o//gGteX+Z1UYgqztixY7Fo0SK89NJL8Pl88Pl8ePfdd+Hz+fDjjz+iR48eSE1NxZIlS/D777/j8ssvR7169ZCVlYXzzz8f8+bNU6SnNkv5fD689dZbuPLKK5GRkYFWrVrhq6++sl3eOXPmoEOHDkhNTUXz5s3x/PPPK36fOXMmWrVqhbS0NNSrVw9XX3118Lf//e9/6NSpE9LT01GrVi1ccsklKCoqsl0WEUhzQxBElWHhjiMIMGDN3pNeF4UII4wxnC1ztpTYLunJiUIrfl566SX89ttv6NixI6ZOnQoA2LJlCwDgwQcfxPTp03HOOeegevXqOHDgAIYPH46nnnoKaWlpeO+99zBq1Cjs2LEDTZs21c1jypQpePbZZ/Hcc8/hlVdewY033oi9e/eiZs2alu5pzZo1uPbaazF58mRcd911WLp0Ke6++27UqlULY8eOxerVq3Hffffh3//+N3r37o0TJ05gyZIlAIDc3FyMGTMGzz77LK688kqcPn0aS5YsAWPMUhmsQsINQRAEEVecLfOj/eM/epL31qlDkJFiPrTm5OQgJSUFGRkZqF+/PgBg+/btAICpU6fi0ksvDZ5bq1YtdOnSJfj9qaeewueff46vvvoK48eP181j7NixGDNmDADg6aefxiuvvIKVK1di6NChlu7phRdewKBBg/DYY48BAFq3bo2tW7fiueeew9ixY7Fv3z5kZmZi5MiRyM7ORrNmzdCtWzcAFcJNeXk5Ro8ejWbNmgEAOnXqZCl/O5BZiiAIgiCiiB49eii+FxUV4cEHH0T79u1RvXp1ZGVlYfv27di3b59hOp07dw5+zszMRHZ2No4cOWK5PNu2bUOfPn0Ux/r06YOdO3fC7/fj0ksvRbNmzXDOOefg5ptvxocffogzZ84AALp06YJBgwahU6dOuOaaa/Dmm2/i5Mnwa05Jc0MQBEHEFenJidg6dYhneTtFverp73//O3788UdMnz4dLVu2RHp6Oq6++mqUlpYapqPevsDn8yEQCFguD2NMY2qTm5Wys7Oxdu1aLFy4ED/99BMef/xxTJ48GatWrUL16tUxd+5cLF26FD/99BNeeeUVPPLII1ixYgVatGhhuSyikHBDEARBxBU+n0/INOQ1KSkpQtsMLFmyBGPHjsWVV14JACgsLMSePXvCXLoQ7du3xy+//KI4tnTpUrRu3RqJiRXCXFJSEi655BJccskleOKJJ1C9enX8/PPPGD16NHw+H/r06YM+ffrg8ccfR7NmzfD5559jwoQJYStz9L99giAIgohDmjdvjhUrVmDPnj3IysrS1aq0bNkSn332GUaNGgWfz4fHHnvMlgbGLn/7299w/vnn48knn8R1112HZcuW4dVXX8XMmTMBAN988w3++OMP9OvXDzVq1MB3332HQCCANm3aYMWKFZg/fz4GDx6MunXrYsWKFTh69CjatWsX1jKTzw1BEARBeMDEiRORmJiI9u3bo06dOro+NC+++CJq1KiB3r17Y9SoURgyZAjOO++8iJXzvPPOw6effopPPvkEHTt2xOOPP46pU6di7NixAIDq1avjs88+w8CBA9GuXTvMmjULH3/8MTp06IBq1aph8eLFGD58OFq3bo1HH30Uzz//PIYNGxbWMvtYuNdjRRkFBQXIyclBfn4+qlWr5nVxCIKIIF+uP4j7P1kPANjzzAhvC0O4QnFxMXbv3o0WLVogLS3N6+IQDjF6n1bGb9LcEARBEAQRV5BwQxAEQRBViHHjxiErK4v7N27cOK+L5wrkUEwQBEEQVYipU6di4sSJ3N/ixV2DhBuCIAiCqELUrVsXdevW9boYYcVTs9S0adNw/vnnIzs7G3Xr1sUVV1yBHTt2GF6zcOHC4CZj8j8pbDVBEARBEFUbT4WbRYsW4Z577sHy5csxd+5clJeXY/DgwUK7he7YsQO5ubnBv1atWkWgxARBEEQ0Esm4L0T4cGsBt6dmqR9++EHxffbs2ahbty7WrFmDfv36GV5bt25dVK9ePYylIwiCIKKdlJQUJCQk4NChQ6hTpw5SUlKEduUmog/GGI4ePQqfz6fZOsIqUeVzk5+fDwBC27F369YNxcXFaN++PR599FEMGDAg3MUjCIIgooyEhAS0aNECubm5OHTokNfFIRzi8/nQuHHj4LYOdoka4YYxhgkTJqBv377o2LGj7nkNGjTAG2+8ge7du6OkpAT//ve/MWjQICxcuJCr7SkpKUFJSUnwe0FBQVjKf7KoFPd9sg4+nw/v394zLHkQBEEQWlJSUtC0aVOUl5cL7dVERC/JycmOBRsgioSb8ePHY+PGjZrNudS0adMGbdq0CX7v1asX9u/fj+nTp3OFm2nTpmHKlCmul1dNmT+AJTuPgbShBEEQkUcyZTg1ZxDxQVQE8bv33nvx1VdfYcGCBWjcuLHl6y+88ELs3LmT+9ukSZOQn58f/Nu/f7/T4nJJSKiQahhzzyGKIAiCIAjreKq5YYzh3nvvxeeff46FCxeiRYsWttJZt24dGjRowP0tNTUVqampToopRKJMZRNgQCJpcAiCIAjCEzwVbu655x589NFH+PLLL5GdnY28vDwAQE5ODtLT0wFUaF4OHjyI999/HwAwY8YMNG/eHB06dEBpaSk++OADzJkzB3PmzPHsPgAgQSbc+AMMiQkk3RAEQRCEF3gq3Lz22msAgP79+yuOz549O7iVem5urmIb+NLSUkycOBEHDx5Eeno6OnTogG+//RbDhw+PVLG5JMgMfAEySxEEQRCEZ3huljLj3XffVXx/8MEH8eCDD4apRPZJUJilSLghCIIgCK+ICofieEBuhgqQbEMQBEEQnkHCjUvIl4D7SbohCIIgCM8g4cYlFKulSLghCIIgCM8g4cYllGYpEm4IgiAIwitIuHEJ+UZtfhJuCIIgCMIzSLhxkURZlGKCIKIPapsEUTUg4cZFJMsUORQTBEEQhHeQcOMiUqwb8rkhCIIgCO8g4cZFJLNUIOBxQQiCIAiiCkPCjYuQ5oYgCIIgvIeEGxcJ+tyQcEMQBEEQnkHCjYskBM1SJNwQBEEQhFeQcOMiiUGzlMcFIQiCIIgqDAk3LiIF8qOl4ARBEAThHSTcuEhi5dMkh+LoobjMT8ImQRBEFYOEGxdJpNVSUcWZ0nJ0nvwThs5Y7HVRCIIgiAhCwo2L+MjnJqpYv/8USv0B7DxS6HVRCIIgiAhCwo2LSEH8yAxCEARBEN5Bwo2LSHFuyCxFEARBEN5Bwo2LUJwbgiAIgvAeEm5cRHIopgjFBEEQBOEdJNy4iLS3FMk2BEEQBOEdJNy4SAI5FBMEQRCE55Bw4yLkUEwQBEEQ3kPCjYtIS8FJuCEIgiAI7yDhxkVCe0t5XBCCIAiCqMKQcOMiiWSWIoiYgVE7JYi4hYQbF0mkODcEQRAE4Tkk3LiIZJb641gRnvxmK/Lyiz0uEUEQepDihiDilySvCxBPSEH8nvtxBwBg04F8fDqul5dFIgiCIIgqB2luXCRB9TTX7z/lSTkIgjCHFDcEEb+QcOMiUoRiieREn86ZBEEQBEGECxJuXERyKJZITqLHSxDRCq2WIoj4hUZfF1FrbpLUdiqCIAiCIMIOjb4uohZuUsgsRRBRC+ltCCJ+IeHGRVRWKSQl0uMlCIIgiEhDo6+LaHxuSHMTNZB/BUEQRNWBhBsX0a6WosdLENEKybvh48W5v+GTlfu8LgZRhaEgfi6SoNHckHATLTAG+EiRVuVh5GkTdrYeKsBL83cCAK7v2dTj0hBVFRp9XURthUoisxRBRC0k6ISHguIyr4tAECTcuAmZpaIXGsYIIjKQuY+IBmj0dRGtWYo0N9ECORQTaqhKEET8QsKNi6iXgpPmhiCIqgaZ+4hogEZfF9EuBafHGy1Qd0sQBFF1oNHXRWjjTIIgqjo+UL9HeA8JNy4SIPVA1EL+FYQaqhPhgcxSRDRAwo2LlJT7Fd8DAY8KQhAEQRBVGBJuXKSkXCnN+GlqGDXQbJJQQ3WCIOIXEm5cpFQl3ATIThU1kJxJEBGC2hoRBZBw4yJqzU0gRkbUHzbn4arXlmL/iTNeF4UgIkaMNE+CIGxAwo2LlJQpfW78MdJ5jvtgDdbsPYmHP9/kdVEIgiAIwjEk3LhIqT+2zVIFZ2lPGKLqEFutkyAIK5Bw4yIlZbFplqoK0KsgCIKoOngq3EybNg3nn38+srOzUbduXVxxxRXYsWOH6XWLFi1C9+7dkZaWhnPOOQezZs2KQGnNUS8F98eY5ga++A2+RStjCDW031j4oWdMeIWnws2iRYtwzz33YPny5Zg7dy7Ky8sxePBgFBUV6V6ze/duDB8+HBdddBHWrVuHhx9+GPfddx/mzJkTwZLziVWHYon4FW0IgogUsdXrEfFKkpeZ//DDD4rvs2fPRt26dbFmzRr069ePe82sWbPQtGlTzJgxAwDQrl07rF69GtOnT8dVV10V7iIbolkKTq08aogxOZOIAFQlwg9jca0QJqKYqPK5yc/PBwDUrFlT95xly5Zh8ODBimNDhgzB6tWrUVbmrUNs05oZiu+xZpaiToggCKfQRIKIBqJGuGGMYcKECejbty86duyoe15eXh7q1aunOFavXj2Ul5fj2LFjmvNLSkpQUFCg+AsXL17XFcM71cd9A1sCiD17czzLNrH1JohIEGPNMyahR0x4RdQIN+PHj8fGjRvx8ccfm57rU6kYJCFCfRyocFrOyckJ/jVp0sSdAnNoUjMDM2/sjm7NagCg7RcIgqh6yLvhWJvgEfFDVAg39957L7766issWLAAjRs3Njy3fv36yMvLUxw7cuQIkpKSUKtWLc35kyZNQn5+fvBv//79rpadR2Jl6/bH2MaZPOEwXqBOltBAVSIsUFMjogFPHYoZY7j33nvx+eefY+HChWjRooXpNb169cLXX3+tOPbTTz+hR48eSE5O1pyfmpqK1NRU18osQkKlkBBrA2r8ijY0jhGEF1C7I7zCU83NPffcgw8++AAfffQRsrOzkZeXh7y8PJw9ezZ4zqRJk3DLLbcEv48bNw579+7FhAkTsG3bNrzzzjt4++23MXHiRC9ugUtC5VMlh2KCiF4o9lH4ibH5HRFHeCrcvPbaa8jPz0f//v3RoEGD4N9//vOf4Dm5ubnYt29f8HuLFi3w3XffYeHChejatSuefPJJvPzyy54vA5cTNEtRy44a6FUQRGQgoZGIBjw3S5nx7rvvao5dfPHFWLt2bRhK5A4JCZJZyuOCWMQX14YpglASa+0zFiFBh/CKqHAojjcSgg7FMdaw41m2ibFXQRDxAAmQhFeQcBMGEhNiU7iJZ9mGIAiCqDqQcBMGKmWb2FstFcfSDanHCTVUIwgifiHhJgwkkENx1EGvQp8DJ8/EnJaRIAjCCBJuwkDILOVxQQjChJ+25KHv/y3Anf9e7XVRIk6saVZjBfljpUdMeAUJN2EgdoP4xa9dKrbeROR4Y/EfAIB52454XJLIEGNNMuYhczDhFSTchIFEKYhfjPWk8exzQxBqYqt1xg70XIlogISbMBCrS8HjWbiJNS0aER6oGkQWet6EV5BwEwZCZimPC0IEoVdBqKH2GR7kcyR6xIRXkHATBmI3zk2cqW5i6/F7QlV7RFXtfr2AnjERDZBwEwak7Rf8jKHcH4gZISe+zVJelyA6qcrmOnJ2DT9VuX4R3kLCTRiQgviVlgfQ5/9+xtAZi6mRewA9cUINtcPIQk+b8ApPN86MVxJlKpDDBSU4XFCCAAMS41gzEu3QLJ3QQFUiLJAASUQDpLkJA5JZSk4sNHhfnNmlYuCRExGGqkRkoTZIeAUJN2EggSMkUBuPPAptDb0ALlX5sVTleyeIeIeEmzCQyBFuAjEwhYkvvY2S6H/63hAD1dJdqtr9eg09b8IjSLgJAwmcpxoLg0icWaVi4pm7zfI/juN/aw54XYyYoCrWj0hDvm6EV5BDcRjgmaUIb6kqA9n1bywHALSpl41OjXM8Lk30QYMtQVQNSHMTBhI5DsVkloo80f/Ew8eBk2e8LkLUQ4JOeJA/1Rjo9og4hYSbMMB1KI6BRh5vq6Xk0EDGp6o9lVhoh/EEPW7CK0i4CQMcxU1MNPJ4E21iYfm951ThZ1SFbz280HMlogASbsJArJql4g1SjxNqqBpEFppgEF5Bwk0Y8Pl8mpVHsdDG49gqRYMaoYHqRPihZ0x4BQk3YULtdxMbM5g4k25i4ZGHiXgWVJ0QE82QIAjHkHATJtSB/GKhU43nATE2hEv3EL3dqvVUlFS1OhEp5M779IgJryDhJkyoA/nFQhuPN9mGVkiZU9UGH6oT4aeq1SkiOiHhJkykJycqvkfSofjI6WK8t3QPCorLIpZntEMdLqGG6kR4kD9XEiYJr6AIxWEiIyUJJ8+EhItIdqQ3vLkCu44UYtWeE3j1hvMil3GUUZUHr3g2MTqhKteJSMF0vxBE5CDNTZjISFFqbiI5g9l1pBAAMH/bEUvXxduA6MZAFggwnHZJA7b1UAHW7z/lSloEEa2QLxMRDZBwEyYyUpVKMS/au1WByhd3Xjch7D7/W2evRKfJP2H3sSKH+TMMf3kJrvjXr8g/Ez3mwqpmNqhad+s99LwJryDhJkxkqjU3MdDK405z40IaS3YeAwB8unq/o3QCssIcLSxxlJabxEK9JGILCp5JRAMk3IQJL81SEvGsibGK0+fv7pOkHt8zZKMtDbzhgZ4rEQ2QcBMmMlKUZqlADDT4uNPcuNjLOn02jAZVosogq+skyBMeQcJNmMhMVZuljBt5cZkfH63Yh9z8s+EsliHxrOnxWqCgLj46UJhM6K2EBcVScHrEhEfQUvAwkZ5szaH4+Z924M0lu1ErMwVrHrvUlTJY7rzjTLZhOp/t4FTwU8b+iB5o8CHchqoUEQ2QcBMmtJob4/MX7DgKADheVBquIpkSZ7KNqwO3Y7NUlHb50Vmq8EFahfATrYI8ERkKisuw4o8TSEtOwEWt6nhWDjJLhQm1z43Z4BaO2BDxbGayitPn6/RJ0qAaHVAMlshCz7vqceDEWfz5/dX426cbPC0HaW7ChFpzY+ZQ7EUXsPyP42iYkx787os3j+IonTdGRosTb+/SfaKzdsQ+0aqlJCJDtLx/Em7ChHpvqWibwWw+mI/r31iuOBbPw6Hjpx9zgp/YHUdbvQw38X63Z0v9mLXodwzuUA8dGuZ4UoZIaynX7juJWpkpaFYrM/yZEaZI79zrLpPMUmEiXRPnxoQwdAJGEvSmg/nuZxhluOpz4/B6MktFH/Eo2L00fydemr8TI17+xbMyRPKp7j1ehNEzl+Li5xZGMFdCBK/dIki4CROJKrHVrCONdDcbh/26IV7fb7Soaqs6XteDcLPlkPeTlkgKjTvyTkcsL0IM0tzEOQkJauEm8mWwKjl7XRndhhl8s4rzIH78z+Ejzl5mGIhzOScqiHdhktDH6x6IhJswkaDW3JicHw0qcq8ro9u4a5Zy7+mQFsc76MmHn0h2ZfG3CCL2iZb+jYSbMJGoerIBD8xSlncFj+OOwmmH6zzOjexzmNq+HQE5CmRqz6jK9x4pomWgIyJHyCxFPjdxifrFmnWk1NG6TzR1rJHQzFEdMicaNKTxjrzd0eOuekTLKyfhJkxoHYo9KogF4ldv48b2C97mH648okkAjDxV+d7DR0TNUpHLirCI14YAEm7ChNrnxtwsFdmOlptfnPUUUbX9QgReL2kliGggktsveD2AElqipR8i4SZMJFh8suGoD0ZOsLz8vI5L4DZu+rk4th9TnJuog95DeFC2O3rIVQ3pjXsteJJwEyasmqXC0QdYdyh2vwzRQjSZX8JVFltmqeh5LBGhqt2vF5BAU7UJOhRTEL/4RB3nxswsRbhPNHWykXCyjKLbjQnocYUHpvOZqFp4PVkm4SZMWI1zEw3EseLG84E/Ij43NmpZLNRLN4kmDR5BxCfR0cZIuAkTKsVNTGhuvJa0oxm1sGqVSM9m6V2aEwNNMjaJoH8Z1fPoI2SW8hYSbsJEYhRsv1BcFsBjX2xGQXGZ5req1q97HsQvwnFuRLOLJtNdJKhit+sJjAxTVZqQQ3EV9rlZvHgxRo0ahYYNG8Ln8+GLL74wPH/hwoXw+Xyav+3bt0emwBbQzvRNloKHqdf99/K9eP7HHULneu0A5jbKJanR08lWNYEiWommOhFPyKv3vR+vR5k/4F1hCM/wejTxVLgpKipCly5d8Oqrr1q6bseOHcjNzQ3+tWrVKkwltI82zo3x+eHsZv84VhTG1KMXNwcvN4P4mdUF23nQWG0KPaLwI3/G23IL8MW6g2HLK94mZPFAtPRDSV5mPmzYMAwbNszydXXr1kX16tXdL5CLqOPcxML2C/Fsv/b6+SrzD9dS8FC68fwu3cLrOhGvqJ/r6eLy8GVG9TzqYFHidBOTPjfdunVDgwYNMGjQICxYsMDw3JKSEhQUFCj+IoE2zk3096TxNiBGVYRimeARLs2NHaKoKBEhBpphzOOVuS8W+tiqQNDnxtNSxJhw06BBA7zxxhuYM2cOPvvsM7Rp0waDBg3C4sWLda+ZNm0acnJygn9NmjSJSFm1cW6Mz494h8DtCLyujtGLY/V3BFaQ2ErXg/HgWGEJXlv4O46cLo585kTcQrJNdBAtu4J7apaySps2bdCmTZvg9169emH//v2YPn06+vXrx71m0qRJmDBhQvB7QUFBRAQcbZwbM4ficJaGkx/nGGlu9HFx94WwhQWIlb797g/WYuWeE/huUy6+vrdvRPOmHavDj1fPlV4nISemNDc8LrzwQuzcuVP399TUVFSrVk3xFwnUZimzlhcNDTOeO3s79xYuNXf4NDex8QJX7jkBANh0MN/jksQf0VAFIlkEeS8bK/U/3pEmEF7PlWNeuFm3bh0aNGjgdTE0qGWbaPKzqCooo23YiN7r4jtTxqChyuAV0RoeIK5Q1e9IaYTpbUYJQbOUt8Xw1CxVWFiIXbt2Bb/v3r0b69evR82aNdG0aVNMmjQJBw8exPvvvw8AmDFjBpo3b44OHTqgtLQUH3zwAebMmYM5c+Z4dQu6aIL4RZlZik9UFMI1nAoRbj4NhTnExXSVeUTmGq/YfDAfP209jLv7n4u05ESvi0Po4FWdio4+lAg5FFdhn5vVq1djwIABwe+Sb8ytt96Kd999F7m5udi3b1/w99LSUkycOBEHDx5Eeno6OnTogG+//RbDhw+PeNnN0Pjc6DS80vIAisv9iIZhJp47Bzv3JveNcbz9giz/sPncRJHpLRyMfOUXAEAgwDBxSBuTs82JoVuPKbzzuaEX6hVbDxXgRFEp+raq7XVRgngq3PTv39+wc3333XcV3x988EE8+OCDYS6VO6jj3OgNaAOmL8TBU2c1e1GFm6rQsTu9RfkzctOhOGzPvgq8UwDYmhuZcA6EPSIpMMtX5FSFPi1aGf7yEgDAor/3l62W8rBAiAOfm2hFdFfwg6fOAogOn5xo6hyW7jqGuz9c49pyYTu3Fi4NS/hWS0XRC4xSYklTFat451AcwYwJLvtOnImafiimloLHElZXS0UD0VIpAeCGt1YAAAIBYNbN3e0l4uZScIfXywfVSDxlr1cqhBMSUAge0dR/VVV88AUnb17HuSHNTZjQBvGL/oYXjUU8lH/WlXTsDIhuvrNIrJZSrgQSvCYsJYle7OycTljDM58bep+e47UpSg4JN2FC7UNDDS/yOF2hJDcVujkLCVucGzvXxGC9dFLkGLzdmMOz1VIe5UuE8IG2X4h71EvBY0Jz43UBXMbpI5drWBw7FCtWSzlLSz+PeHuDfNy6TTJjhIfIOhR7ky/Bx+fzBd+D11ocW8LN/v37ceDAgeD3lStX4oEHHsAbb7zhWsFiHVGH4kjA0zrwOgI3+4Yjp4tx89sr8MPmPPcSdYC9peChz459bhRh/8O//YLXs6Zw4khzQ+Nf3EKv1nt8PpnmJhaFmxtuuCG4G3deXh4uvfRSrFy5Eg8//DCmTp3qagFjFdE4N14R7uI89c02LNl5DOM+WBPmnPRxfI9hekiRWBkXZdUtKom2NhkvkM8NAXgfxM+WcLN582b07NkTAPDpp5+iY8eOWLp0KT766CNNbJqqitbnJvpbnptq+hNFpa6l5Q4OHYpdDOIXLtHDVhC/GBSDnLSlWLxfK0TD/XlVhljoY+MRhfkeiJqZlS3hpqysDKmpqQCAefPm4bLLLgMAtG3bFrm5ue6VLobRbr/gHcLDcpRUSrdwujLGTTOPPK2w+dzY2PG6Ko8HVfjW4wa5dqAq12UvUS+8CG6cGYtmqQ4dOmDWrFlYsmQJ5s6di6FDhwIADh06hFq1arlawFhF7edCDS/2CLjqUGxd8LCeie4XohKv2+HcrYfxyOebUFoe8LYgYSSSz1jhUBy5bAkZ6n4yGKHYo/JI2BJu/u///g+vv/46+vfvjzFjxqBLly4AgK+++iporiKURNtqKV5xoquEznG6FNzNmChKzU34n3SUVbeoxAszxp/fX40PV+zDRyv2RjzvSKF+qpEa5Mgs5Q0BlVkq+NVj1Y2tCMX9+/fHsWPHUFBQgBo1agSP/+Uvf0FGRoZrhYsnYqHZxVvn4OZScDefTEQUN3GMk/caLc/o8OmSsKTrtRMnEFnB2k7gSsJd3NyDz01saW7Onj2LkpKSoGCzd+9ezJgxAzt27EDdunVdLWC8wF96HV3NMbpK4y5OfW6c9thRG6E4nl+6CfF461XbodiTbKs8ak10TAfxu/zyy/H+++8DAE6dOoULLrgAzz//PK644gq89tprrhYwXuCagagxhhWnj9dd81H4fW7sOBTHIo4Gz3h+MFFCRDU3CtMzvVsvUL7vGA/it3btWlx00UUAgP/973+oV68e9u7di/fffx8vv/yyqwWMF3gNL9qaYjz3+3a0JW6qvJURiqNnKXhVxsvnRe/KHRTPMYzPdOOBU9h6qCB8GcQwGodi6bM3xQliS7g5c+YMsrOzAQA//fQTRo8ejYSEBFx44YXYuzd+HeWcUFhcjlmLfsd/V+8PHos6J2OvC+A2Dn1m5O/HTYfiSLz2eJ7FxoPPDeEOkQixUFBchste/RXDX14CfyQicMYY8keiDl7rJbaEm5YtW+KLL77A/v378eOPP2Lw4MEAgCNHjqBatWquFjBemLXoDzzz/Xb8/X8bkZdfDMDjmaN3WccMbvrJRERzo5NfvOHevcXxQ/KQSPoSyvM6cPIMisv8rudxUhaQtMwfv0v47aIO4hdcCu6xoGNLuHn88ccxceJENG/eHD179kSvXr0AVGhxunXr5moB44VTZ0INpKi0HIC3mptYcHB2itPBPlwrMcK2WsqGpioW37kTrVQM3m7MoX7GkRrkrp61DMNfXuJ6utGwAi2aUQbxA6Tex+unZmsp+NVXX42+ffsiNzc3GOMGAAYNGoQrr7zStcLFE/5IBHFzSJQWyzZOn7O7Zil5WtHjcxNv79wK0doOnRAN9xTJIqjz+uNoket5KHcedz35mEezWiqoufGgMDJsCTcAUL9+fdSvXx8HDhyAz+dDo0aNKICfAQGZNlMa3KLN5yaesTPbd1Vbw/ifw0UsamREceZzEx3PJVrKEQ4iWvUi/Bjj+b3Zxc1JoJvYMksFAgFMnToVOTk5aNasGZo2bYrq1avjySefRCBANkkecs2NpMaLpooAwNWOwmupHXA+wAdsmHn0yyJP12FiBKFDVLS7CAoAkRY2qO1yUJnvQ6ulYjBC8SOPPIK3334bzzzzDPr06QPGGH799VdMnjwZxcXF+Oc//+l2OWMeuZd9IEo1N3E9K3Hqc+PUoTgC8Tic+hXFCk6KTBFtw4+6TsW6FlEuMEZbnx0NBFT9ZGj7BU+KE8SWcPPee+/hrbfeCu4GDgBdunRBo0aNcPfdd5NwY4LUQKiZhBenITDC1SlH067gBBHLRLqeMzJMaFBruIO7gntUHglbZqkTJ06gbdu2muNt27bFiRMnHBcq3pHqQrQ1FBoQlbi5tJq5mZhAHqLaoZjU1rkU54bqe3iIqMsN+dx4Tlz53HTp0gWvvvqq5virr76Kzp07Oy5UvBPS3ERRTUB0VUw3cOrEGy4VdCTs9vH2LgkxouK9qwoRzqXgkbhdefnJ50aL8nWHzFJe+3/ZMks9++yzGDFiBObNm4devXrB5/Nh6dKl2L9/P7777ju3yxh3SC8/2hpKtAlbTnHTCdjps4nIxplhSTW+iMR7qOpEVnMTaYdiqjNq1JqbaHEotqW5ufjii/Hbb7/hyiuvxKlTp3DixAmMHj0aW7ZswezZs90uY9wR1NxQQ4kYdoSTcMW5CZvPjY3yxmIV9EII33WkEFsO5buXYAw+d1FisU4ZIW9XJNxo0XMgj0nNDQA0bNhQ4zi8YcMGvPfee3jnnXccFyyekQY3LzU3vDYab+3WzS0T3NUChQenDtSxgltxbkSTYYzhkhcWAQA2PD4YORnJ9gtQBYjsUvAI5OHQvB3vuBkyw01saW4IZ7Ao1dxEV2ncxfH2Cy4+nGh679FTEnEiXWb5JORoYXGEc1eSf6YM7/66G8cKSzwthxHhqt7b8wrwwfK9CMheSGQCYoY+k+ZGS0Cnn4xZzQ1hn2AQvwjlx6tk8eZfY4atpeAuPqNIrNIhfxIBbAis0fQsH/jPOizYcRRz1h7E1/f29bo4EWXojIp9o9KSE3F198aVR7XvJhBgSEhwb2SNhEk5llGaw2UOxbHoc0M4w0kQvxV/HMfi3466XSQApHJVo5iROHYojoTdPjrVw24TaWEjmp7lgh0VbX/TQRf9f1wm3M9rs8m9lwtIIOX+AL7ecAh5+eaaOIXmhqQbDcp+UhbnJpY0N6NHjzb8/dSpU07KUmUIORRbu84fYLjujeUAgHWPXYoamSkulyy+Gq5TTYa7DsX8z27CbGRS1QRa5SMSu/mq9oycEsnnxcvLLyCAvL9sL6Z+sxWZKYnYMnWocR4m+VV1NKulouQZWRJucnJyTH+/5ZZbHBWoShB0KLZWC+TnnzxTGgbhJr5wc/m2UyJht4+SPiXsRPo+q5oJ1ynq5xXOGTzvzZQFAkhHouF1iyq130WlftM8AhHRusYuSofi6Hk+loQbWubtDnY2zjxZVIojp91zIqwKq6Xk2PK5UdmSXStLJJwgo6iTiSYU79FD7VZcvx2vNTd++wVgjOFMqR+ZqUmyY7Lfbaccv6g1xqEgfjG4cSbhDDtmqW5Pzg1TaUJ43XAPnTqLBjlprjUKO2YaxfWulCI8qXFzsLW6y+u3bh1HS8Fj73ZjDq8fsYjPjR6Tv9qC95btxX/H9cL5zWtWHiXNjRFq4U/6GpN7SxHOiNbtF7zk01X70fuZn/Hw55u9LkoQN5ec6jkluqoRovpkCdGnFUvjWTSUNZIO37w6Xx4w37RPr4TvLdsLAHj+px2hc2kVoiFan5vocCgm4cYD3Nh+wWkT413vZcN9rrIz+XjlPtfStOM8qn+9m2Wp4PN1B9DtyblYtcedzWbtqM9jsa92UmRb5kkSGqMKs0jc5Q7MUhLyvlnvM1FBtPrckHDjAdGw/QLX58bF9K2alqJxkLW7WuqztQdw4dPzFUtWeQ7Ff/3PBpw6U4Y/vbfacVnV2AtaGIUvIYzY2aKiij0iW0R0tRTnmMhqKTMU2lUySxmiDuJHZqkqQE2d1UxubL/g5l5HbqUZbTgelBSaEPEEJny6AXkFxbjvk3Wy/PUFJbeECmazvDGHg+dlS+iznZtBmvHW2GSE+87kEyfecxTxuTEbeP067VXA4lXl0LyDKHEoJuEmjPxw/0XISdfuQxOqDNGluXGDcn8Ak7/aErZAg1ZwOsDrhRUXpczP7wnVnYFrDtROTW8xMt66VUzxODcx8mCiBK8fl4jPjRl6bZ80N1p0g/h5U5wgJNyEkbrV0jCycwPN8WjYOJOHG8WZs/YA3l26x7Xc3Wog9mbsbjr78j+7iR1NlUKj5HJ5woWj1VIOBcBox2snTiD8WkMzYdMVnxtZ5+xmMM94JFwhM5xCwk2YSeD0NqGNMyNdmhC8MOJuVMwjBdGzoZ/T+BTqGYlbZVHP/pwMSIEA44aQt2WFi6KOKRLc/PZKvPrzTtPzYumxRENZYyFCsRl6GhrS3GjRaG6CZilPihOEhJsww3vBIc1NpNd9uHW1Pm5uWOc1zI4qRC8t6M/+nDyxv366HhdOm48fNuc6SKWCaO629584E/zsRDOgfvbTf/pN4KLQR687bEKJ20vBJfTMUtHcRrxCHRgz9I18buIa3uu1u7eUm4Qr70Sbwo1eeVzzr7Bxw047Nb0ggm6aI79cfwgA8OqCXar84qsbvujZBZ7lTbP12MJtsxStljJGvcEwaW6qCDxnUSe7gktE62qpRK9rtIuEy9au3XvHfYdi0eLGojwkUs7dx4pw/RvLsGSnc8d2rx/LqTOl+GFzHkrLY2OpTkSD+IXJLKW3WqqqmW5FiFafJNp+IcwYjVukuQkvTp1l3RVowpOuIg9bDsWyz54P43zsDCj3frwWmw8WYPkfK7HnmRERz99NbnxrBbYcKsDd/c/1tByihPtpmbUlJ9svSOhtlhlti0CiAU2EYlotVTXwcV5xNGy/wMvZjfJEl3Dj7Ho3I28azf7ceGLy4FlO0ohG1AOKSDmP6mwya8s8afkKd9lyqABAyAQZ7bjpU2aaF+eYK0vBFWYp/nGiArX5nsxSVQTeWC+1PS+3X+CNEG4MbnYdisM+27ORgVNti55WJBL9o9faBjexcy+8SYX9/PmfrfL6ot8dpSNixo4G7Vsky8AN4ifgc2M7iJ/3jzfqUC6WCH1zsw3agYSbMMNfLSU5FNtvKU4d28LVRu363IRjMGYG34SudzEGjIsLr7j4fO6WN5rQaG4cpGXLPGnDl0nN4YJiTPt+u82rK4gVZ1avi+nO9gvyb8rBm1Aif1YM8L4CVELCTZjhx7mp+N/T7Rc417uiuYkeq5Rj3BRIFKptF+Pc6OUhfE2UOgPKUT8vkQHGVZW4C/WgqKTceTGi9P2oURfT7WKbrWIsE+hYzc6Q1zHaONMYPaGbzFLxjoHmxkmzd6654ZilosTn5hOXdgZ3KpzEWkdmy6FY8Tk6b9hVx26n5kkPn5FIffTaFABon3FYhTJO2n4XfG70zVLu3swbi3/HF+sOuppmpNHdONPjqkirpcIM36FY+b8dolVz44Zw89Bnm5wXxAWU5ginDsXymaA6LefPTDOguJBGtOC1OcYNDZ56ub9TLVssEc5yc4P4uRDnRr4tXLjMvTsPn8bT31WYKq/o1sjFlCOL8v3K4tyQz018wxvrpQbppM1buZZXxcLmcxNFdimnvhIBZZt1WBbZZ1Va7s1wYnPwM0NrljK/Ru+R2ttbKjpMd7HiUOx1PXTD50ZPoHFT0D5RVOpaWl6i0dxEiRDuqXCzePFijBo1Cg0bNoTP58MXX3xhes2iRYvQvXt3pKWl4ZxzzsGsWbPCX1AH2Nl+QaRyON/xmmeWcg7Px0iEcDQHpzNuV2dsYVRtB7NQ3K+dQTw68bpcbpgl3OjwY8VM6oYW0W5egJjPjRlys5QyjkuMvIQIEtDrJ6uyz01RURG6dOmCV199Vej83bt3Y/jw4bjooouwbt06PPzww7jvvvswZ86cMJfUPjzVnNnGmSLtx3H75V3vQrv12s7qJo6FBZ04Oe4bpSpXSzlMI1o7bqZyoXBzbymha2zn5i7R+n7UuO1zs/tYEWbJltEr0uYc8/td8LnR2TXXBXceXrIxjVorHfS58aIwMjz1uRk2bBiGDRsmfP6sWbPQtGlTzJgxAwDQrl07rF69GtOnT8dVV10VplI6gx/nRhJudDQ36u/cmDQOfUAcXW2Qrs2Ew9FvO3UEDZeKXxPEz63VUnY0Vfw+PKqwoy1xa0sLQCWkeviQYkS20bQbp8Ue+PxCSxNBNyIU663IclPrGivv0wz1JC7oc+PxTDemfG6WLVuGwYMHK44NGTIEq1evRllZGfeakpISFBQUKP4iCndvqYr/9eq2ugHx2qrT9ssVmFwY3rx2/nQTRfwGx8/bvbTM0rd0nQtpiBIIMFsRXu343Ohh51LlQGcvczc6evVz+N+aA47TDAdazY3DiZjB5eGagOjtl+SmaTA6/KOco91+ITqIKeEmLy8P9erVUxyrV68eysvLcezYMe4106ZNQ05OTvCvSZMmkShqEKNdwfV9btTf3bchhWu1VFThcMbNdD47LEoYfW74ZrBoIBBgGPHKLxj+8hLr10bRrdjXTLrvczPxvxscpxkOvH5dbjQvuVlKHYGXUKIJ4leJ12apmBJuAM6SysrKpjczmjRpEvLz84N/+/fvD3sZ5RgF8dNVtaq6h7BobpxdrouXDpdu4+Zut5HQkDjOI4yv4OSZUmzLLcD2vNOWr3XTzGHPsdydvJ0Sq1pRt4tttnrNDcFeT1sTTYJ2tKB2uA6NyV6VqIKYinNTv3595OXlKY4dOXIESUlJqFWrFvea1NRUpKamRqJ4XHgvWGp8wpobXsA9F80koXyc46bDnVOcal6cakKUwkbom7qDdCsehPMVYdHZc9u5Lzc71miZuXuR88rdJ7DvxBlc3b2x8DWRfES8rNwQQPyM/85dFTAVpmrmuY+KXfQeidd3E1PCTa9evfD1118rjv3000/o0aMHkpOTPSqVMVyHYhOfGzW8ymOlkfEaDV9gcmHG4zgF93C+2on/2VZZFJ+VibnRp6nTEK5b8s9hfHlOknZXY+GwHrhVCoeCaKS49vVlAIDW9bLQuXF1oWu0mrZwViz3J36A2iwVwlWHYvln5r2mwy5u+sS5iadmqcLCQqxfvx7r168HULHUe/369di3ryL8/qRJk3DLLbcEzx83bhz27t2LCRMmYNu2bXjnnXfw9ttvY+LEiV4UXwieYGG2cabIUspwaG7cIFZV5zzCpYIOl0NxtASbcxvNxpkRvrlICYBmeGkS2X/irPjJAv1XOHFdmIpAPxDLzVWvfXitifJUuFm9ejW6deuGbt26AQAmTJiAbt264fHHHwcA5ObmBgUdAGjRogW+++47LFy4EF27dsWTTz6Jl19+OWqXgeshVQA9E47IzCf8u2hHNhG9y5w0D8dbJrjY5RhpkcIRoNipGc1tnNyjeoWVSDn1+lXnGhPvhiGrEwc3+wgr9Ul9pttPzEwocLtrlD/3SCwGECH/bBlW7j4RFb6KyiB+LFhXvFZEeWqW6t+/v+HLeffddzXHLr74YqxduzaMpXIXnkNxMM6NzjX3fbwOb916fvB7OPxj+LFzHCaK+NXcODVryd+YxufGpRmOXgnf+WU3Nh44heev7Wq4PUZ49wCK1sSsZefWI7IlfFq8xCtTh7oehdXcydVqm2dopa4rnIvD5FNoVSv37A/b8eGKfRg/oCUmDmkTnkIJot1+ofJLVY5QXBWws/3CvG1HVOdrz3O+K7jYMTfS9QrHPjOKGYmLZXGYllAess9Tv9mKL9Yfwvxthz0pl1O8DpzmxjOK1LONhvep1dyEUWgO0yRNkZ7ss7s+N4z7WYQPV1RYNF5dsMtz7Y06yGVItqnCZqmqgFGcG9E6GQ7Va7g0LLbTjcKRVT0jcUK4OkgrnCn1a47Fgp+OxudG4Bq9jtXeQOv8GXnxbEUHvY9W7MMt76xEUUm5QVpOymH/WtO0Ocfc9k0KV4RqJ5OvLk2qBz+7EZHZCQEd52uvIeEmzDSukaE5JlUA0c5HvbcO4ILmxoLEtOKP4xj0/EIs/Z0fKFEgCU9QekrYMQOE6WbClqxxwrzfnfSL+WfLMO7fa/DD5lz7iQjgtanT6ao7J9c5QTTHhz/fhMW/HcU7v+wWSssfYHj1551YvecE/1yP+wCRtm7FFKyMc+Om5sY+ibLi/+3TDSgu005cIoXafC89Iq9Xf5FwE2aGdKiHBjlpimPBjTMF0+A6FDsslxWz1M/bj+D3o0X4WWUu46brcs/mJDWnZinl3nk2hCOdGb+6gwzP3lLW1YK8e/zXgl0YPfNXnCnVzupfmb8TP2zJw7gPzH3gnAwKWh8OJ2lZv0ZnD0Vr+dq8LpKcOsvfwkbNp6v3Y/pPv+HqWcu4v4f7XhWTFk5m7gtXoQSjcQXlVxsO4YPle90rjEXUu4JHi0MxCTdhJikxAdUzUhTHzLZfUGPXac5qmnqU+aXymp8bTxE8zTpRa2mF3/xjp7wMxiP3cz/uwNp9p/CfVdrI3ifOlNornEXsPK/wBfGzmYYnZilr5/sFG+/vRwpN8nVPGDWDr4B2eYLlkubmeGEJd5LgNF0AOHq6xNH1rsFAmpuqRKLqKQeD+AnWZ17FZwzIzT/roCHz0+Thr1wiIKK9sK22t3WVWZrOBiWmmpE4KkuYVNu6+YmeJ6iVKC3X2kaTE8S7DydCrx2fGz3sXOuKWSpCuhv5gGI1TyPhxtLqIs21lophinzM5G8A7C7KSYO91E8WlaL7U/PQdcpcblrh0MRHCvVS8GiBhJsIoF4OLlWGk4IzX151eefX3eg17Wc8++MOW2XiLy/nV0zJYU2kXceV5sahWUtPcFAn5cYMp2IJph3TmTINKyQniRfcSacXVT43NtOI1LYkTuqsa46pLgqjtrIXyNDuUnC797LxYD4AoNQfqghuCE1uXe8EvYUXtFqqCqAWbhgDjpwuxuNfbhG6nldvf911HADw2sLfbZXJSlso90vCjYDmxlZpwoTDTsndJciM+9lN7AgqTu4xyYLmxskt2wnvrtet2hJS3TBLRVfL4OJ3SQLTBCF1+dbNknNbGFYE8bMpAHLro4P+SbuBtNUSuYe2fVZ8J7NUFUAdOC0QYFhaKZzoEe7B0MpmnOUmQQeVadhU23u9xIKDsh9zU9BRfrc7w5n23bZQGj6oOkux98tMrjEiJcmKWcr+81Nf6vZqGCv52xVSwuZnZZCwdZ8bsfOsPtrwxrnh5edyHrLPdpVbZs8sCrs/YdSaLfK5qUIkqqVsAAkGkWIBd1ShoukbHQNCMzqRASqaGqlTta/RjH1H3mnc8+Fa7Dpy2nK6AcZwuKA4+N1uJ/D64j8U3x1vN2HVLJVowSwVYc2Nbjki/IzCjZvlcU1zE8FnZGWSZjsPuebGZuJmExjHZilHVztDEeeGRY/2PqZ2BY9V1Nr7AGPc3cLl+BlDQmWDCIfPAS9FvVys+dxES9V27rBn5L9w7evLKvZ32XMCqx65hH+9XloALnh6vo0SiWPH78DqM0pWe8qHCa+rlCs+Ny4KaHLk/YQayw7FbrncqDVtEX5/YV2d5aLmJhYCaIqgHzKDfG7iHp7PDW/PKTkKD3STij9z4S7LZbLjcyOikrXbRqOxbSuFI2UJ8ytjgoguwZRfr9lbymb5FOkz80HY7UHHinDjROh10+fGTkVTDkLRZZZSr3DSE6jF0tLX3FhJS7vxr7uYOU2L5GctiJ8bmpsQwThnDoTmSO7fZYZaSCOzVBVC7XNTUu7Hj1vyDK+R9zNm9fbZH4xXTPHqmJWdxkOrKMxbUHRpbuRfrF+vJ8z9dti6KUrZISsTdm3jTIsjm54jIA9eEeVmqXIThw1nZin717qBG5qbcN2CUXuzmqdGUHJLkAunJoWbv7v5yZOzXRdl7YcXCsRqmTWP2MPpoTrIZbQE8SOzVARQa2k+XqkNiKbGDQ99I6y0pWCcGyFTh80CRSF6M8TBLy52LV03sZqsJn6MxQTkmptSfwBJBpocJ7fs5mBlyzzpNAGET+h3KzYNLy37K8OMv7sJr4xCGmYLN6cUbuxqbkJjgD/AkJjgc+So7LTtuglTdZTRMgaQ5iYCqDU3IoRbA2KlcUuaGzGHYnGNULhRKm6sl0EdVtxRWXTt0u7g81n3MXJaDrkwU1JmrLlxZpaycZGbEYoNzJPiabhVGiVuxs9Rx7nRC85mpmmMpM9NRByKFWnbFG4UmhvJLOWgXkWLBAH9fpLMUlUAM/8aHgqzVBjqMV+dyz83FOfGPF3eQBQNGh876Vu08ginFYmAbnaeudV7lMvspWE0S7m7t5T1a92pB+Gp4Jp9yhzkaOS/44RIm0zcyk+qK1b8H/WQv5fQ9jvyzKyl57WpVo46iJ/0lYL4VQFsKG5ccWKTEBVk9DoFf4DTGPXy4qbrDeqylJT7dfd24V/vbMauZ1NXp+WaQ7HFa9zcWZ63PYPy3AhrblzEzIHVahpu4jfyubGYp1tmqfC3eGNhw8mz9nF8Y+S3Yz/OTSjhkM+Nfc2wFX+5cKMU/ljwBZDmpgpgxyzld1Dx1Tjdf6Xcwt5S/H2wvDJLKZ/h+U/NQ/vHf0RxmV/segczK/VFCs2NOq1w7ArOU9ervmv3bLJ2k/L3WmIm3FhKWT8f0bR0IxTbK4HD68MnoKn98ZjuF3PUwo1djUUkzVL8/N3JMGg+Uqx0dG6W4k0WrSareca2SuUSTPkxWpRKJNxEALOAfTzCr7nhCSH864O2eBHNjeAx7TnhbxIFxRVamz+OFgmd76rfk2NByVomUtGNI9g6m6nLTzfX3FhLW44dwSBsEYptryAKz0s31NxYrGiiu4KboU4lnC07nBtnhtqQcX4i8JaCO+njwxU3yQ56QrDXq6VIuIkA6gjFIrihCje63ooQEopzY14QK0JTuHHyDE8UlWL+tiOh610qE2DsJyGKWScb1KgbnOZ0t2251sDM5ybScW704JsxxJ6l+rOlfC3mKYrxaimLaRk8Z2uaG28HXid1jecbY6h1FU2XtxRc9rv0+dSZUk9NTHbQW7nl5gTDDiTcRABbZikn3mYquFdbSFIqi5AGhitIudPZOMFqh3fZq79ghyyejfPw6M5NG4r0uIM0L1+jNNyrV+HU3Gg1Ae52/mZlc0dzo/puKxUtbjqnG5ml5Ji1yXC/L0Xagu1AFPmALKXjphYdkPWnKl+VFX8cR9epc/HAf9abpqER+MP0jE8WleKuD9ZgwfYjuueoV0tFyyaxJNxEADsCrLJBOcufr7rlaVj4GZVZiHPD97kxvy7ckxWrndKBk2cV350WT569RnNjR7NncozXMRuVqeK7VdV46LOpcOPgCbq6K7hA+pprbPqe6KXhJB01xmYpa5Sr9l+wraXSSjeuc+DkGcz+dTfOcPznGIA1e0/i0hcWYcnOo5bSVa42k4SQ0DG7fbHSv0arCWcMmLnwdwDAl+sPWUovnDzz/XZ8vzkPt727SvcctfAfLYonCuIXAeyYpcK+FNzCLD/kAGdeEK9Xtughn5XaETYdmwYN0rKjnTITInkds1kaRrfIW9apdCg2dtJ2ZkoKb6UyS11Uh7pu30m8+vMuPDyiHc6tk2WYh1uzW2Ph1aqwqhbA3NE2huPtDX9pSdCHTpMfY7jl7RUoKvXj5rdXYs8zI2zlwTUf2ayLchOuJJA60bpFyvSXK9vgVw+9fsTr1VIk3EQAp0H83Fyya3RMrxcKxrkRyYurERK4MAwod/P1In+9z84LI2r+MxpEnUY5lZ8fVodiVdKOBlobmkVR35MrZy4FAOw+VoSfJ/Y3zMOtNmEUvdyy5kZjlrJRIBv52kFPsAEqnm1RqdiKSDW8YHtwoS+WXyU9Vyd9fLjMnNp8RCa0fM0mxbmpAjhdLeVca6BNwEpj4tmIdfPinHL3h2uE83ITRYfiULpxs/NQp+XUbGmUidFp2vdpsYOVnR9Jh2IRrDxTMy2K0l/KvCx7T5wxzcNKdTS6F41ZSlAQ46FpI3aFGwMNUCRwKztWWaXlj8W+WUomyHB8GC1PLNTfw/SIxVwRZOcjZJYizU0VwJZZilnrUI0QNUHp5VJuaW8p7UkLdhwFY8zQtyTc3Z9z7Zf59cVlfvyy8xj/ehdiZZihNEtxjlkwQ4kg79TCGudG/V0gMb1ZI7fem6VnUWDgvV/toCj+RBJ8Pl3fGm1UYftPWq25cWM39IprbV9qK70AY0jwueCrGDTtujDRVAhInHQtJhepDYpF6pP6+ZBDcRXCXoTi0GehDtXiklD+MX4a5UHNjUA5dM4xm9mHoz244QgYTEvgnMe+2Iw/vb+ae42oaUO4PCYCK89pUY2Zo67pEmn58zV5wJHeMsFa+sa/q3c9tpOeEx8Jo8mRxmSnmkVbQbtaSp6WDJP+TNRkcuR0MX7YnGu6o7xVGOy5AgBKoZjnc2NXqJA/S34QP2vpassR/gmTHvJ6w2RFoTg3VQA7q2EUFUakghk5FlrS03DSthTnhn+82GRjRd30bF2lxfFMR+Dy/645IHS5Wg6wY5sWjQRtVGwzK4S55St0glH94+VlBSdaDw1codBEMHNBg2FH+yRhxSzFdL+Yo91+we69iglyw2YswbgP1uK9ZXtt5aObP7O3nx8AxYgc0rDI03b+THg+N1ZTDZcPl1k+PPQm4l6bpUi4iQC2Ns60aJayGsxL1FQFyDQ3pqXQFyJKBLc8cBNFh+JwtZTzwjgfIBXJCWZnpPo20yaYL5GWnWsqvdi/53D73JgV3ZWBQyNIiidqKNwYCCRWi601S9lDq7nhp3S8qBQAMH/bYZs56eXP7As3nIHajbAcSr8d55qbiAk3sgfyrwW7cOCk1p9MPVZJ3yiIXxXA6dJjKxtWis7eucd08gn53NhvQXY1N25hplkwQ2QwSkvWb05GV4fDoZgFzzM4x2QQMh/0xTt9J4/f6aouxbXc1XwVx/44Woilu7Q+U0xxrr18nURZNhqojfyoLDsUM/X7tyeQh3vgNdco2nMFqLjW+J5tr5ZStJVgZy373X56gHUTpB2e+3EHrn5tGacsys9S2cgsVQWw85KVZikBzQ1HhRpKgHPIQmuS+9yUlgfw+boDOKwT/0Cv8RebxEERYdnvx3HXB2t081bjqs+NwPXpyYmqa/gXubGHD8+vQfTdS5h11Oa/hz6b3ZOTW45UnJuBzy/CDW+twNZDBbr52x1ERP1QeBgJN0Y7eVstq8b3xcX2E0kYY7ZWqFZcG/oc2r1be8xJulyfG4vpRep9qOttHqfvjaZ9ruSQcBMBIhGh2NAsxZutCp4XCISW9jFUqCb/+p8NGPHyL9y89AbEsyZxJ0Q64jFvLsf3m/Pw0JyNpudWpCn77GCWBADfb84zFaoyUvQXHyo6NzfMUlwNnfYeIxXnxkqUX6s4EQzM0gIQXPIrseVQvm5+dm9DfVlEfG4sYuSDZaW8VoUqt60XAWbNoVjPlBdcLeWKz5W2bcrbzOAXF6OwRD92j5pICRQi6eqOPeRzE/849bkR6bJ4sROCV3M1N2LHymTLMQKMYV6lffxYYQm3HHqNodhFn5t9nDgiZrgRFPEv/zaO15NqZJaS56/qDIxs0/lnyvDjljxNGHn1LfhUx6TO1NgsZdxBWtHsiJrJ7GAUOdcqfF8zk4GCGfwmnK9aCBFPyKj/0ES5dSDEl6sSs9tmtCu4IjuVZ7DW5+oJ6XzNjb17kT8Tns8NULFlhCiReqJiS8Hln2U+NxTErwoQgaXgIbOUqJZGDPWqLbM+Q28wLXYxgq2oSlapCraXl5wN+08Z/q42SynKIvtsRXOz53gR7vz3Gjw0Z5PiuKizr9HAop2pM8PfNXnIPput5nUWxE8/XzcwE+qMNj0t8wewX0DY1jzLMGlubGYBwGRZuU4+vONqE7RZOTSmj/xiPPDJOqw3aW/66VlzKNbTUAU45iM3gvhZCYqqh9sxq5ygDjgrfaXVUlUAW0t9Za1IpEEZaW54iIahL1eUQ2RTNP4Jbmpu1DNMEdyM+KyHWrg5eaYMu46c1uTpV21QaFQ7pHInqFqqsIbO4CLzODah33kdFddJUjcx45+NsLVxpk7PKhKtW2PqMRjkb31nJS56doHhrslSzvrfjDHW3Oina3XwVMeiYjqfebFg5KhN0Fbb29/+ux5frD+EK/71K/d306X7zJpDsV7d5Zl23TBL8jRCltPTtGX7aVnJhwftCl6FsSPB+hWDsXllMXIodjJDUA/EZujJHW4KN+KyjWzwVQlp4SA9Rau5ueSFxZpjVjQ3UrHVAxxvszpeqkamBY0yQaPBMC4bb5arh5sOxSLvz0qTU6dm5Iukznrp78cBAB8sN47Voh2MxB+I0UBt6FAskIXRVgmKNqPzAnn3cbZMrbkxLoi6f/zjaJHh+eYaRWbR50b6n6+xE9FgmeehbYdubkkSLoHC6mbJ8tNptVQVwI7jvtJ/whxjh2ItokHg5D43Qp2lTc2NlaZpZ7WRQli0fLUYaaJmKQuKJ+mdaGbvJkJs8LNBPXLqBKxQtZv63Nh/6kY+MGLXG8+8NUKdkTbE7mopk+/GGGhuHA5y6qakFkz0zjM6rg774PZcwlRJyCz63HCEGIB/b3YXA5iZu6zixMxpBZFk5e0lmvaWIuEmAtgxS/ktahokGUR0V27RNmq5HDqnuBnnRrSD0ZvFhk1zYyTcGGhQjDqBgE5HoY1yrJOv4hqVBsTAx4L33TBt0+0XjNMyQp200x2UNb9rfI30tRl6aZn7oqnzMD5fif7JTlfNqAXY07LdtkXaDO+4m1paHmYCXIAxjRnXMD3tPCCYDqCs2+UWNdmhtEKfpf7LST8UaSdtI2hX8CqMvb2lrKluDM1SnPNFz5M3ZrmzmB56v7trlrIu3NgNSGaFlCSx5qSOJ2Is3PA1N2bL+6XPRr5GZrN+a6ulDE91WQVfwdLfj+H7Tbnca+SPyyzMvdmMnfdcreLELGV0qiY0jY5Ar5u26nvB2bLgZzvvjDHGMUtZw7S7dFlzI6EnKMqPmm0Qq1smjt9OtIRHsJIPD3W8nmgRvEi4iQQ2GppyYDY/39BUwzNBCWp41A7FZuhVbC80N3Ii4VBslK7V9xk6VxJu1MdV6Qf/UebnxF/AdMUeZzaqh5NHrudzc8ObK3DXh2tNVytZjZ6sMUtZFBi4eZh8N8Ko3RnFueG18RnzfsOQFxejoLiMm7Z0XJ2WqOamzM8M/YB4WJ3hi4QdMNpsVHM+p61UfNdOGMtsbvLJC3jppB+KlPgg0mcEdBoImaWqAI4jFAtUZaMGzwDsOlKIR7/YhEOnzlYcE2wdfrnPjcD5diMUWxl4RZ2cFRs7KuJMCGdlCaN7UJZFeZ5R5y4lqdHcmAisoTg3+loLK7uC896rQnNjZd24RcyCDZoFVzRb7WKusRJpi8atXPO+LDwPo1O1gpjxvc6YtxM7Dp/Gvys3q1SfU6AwS8nff+gcpVZMeT2/nZsJI6r2YDIqmj06qxGKecH6ANmqJtnxUruaG05bcuZzo//e3UQkVbWRQfrqtUOxfkhVwjWcRigWqbdGswHGgNEzf0VBcTk2HsjHV+P78tXznKPlap2jCXqnmEUotoItzU0EVkuJpmtttVTFueoOX+89Gx1TD4Smu4IbnKtJ24IJyyrmwQa118gfl1nW6uuNl4Ibp6WHVrYRT8jYLGU8qdFD0kBohBuFWcq8DOp3U8xp5243NxHTuBVXAF3NTXCCEDpmV3PDaytW2sS8rYeRkZKI3i1rc68N34TN/BxdTR1tnBn/GNl/2zeoxj1uNTpoULjh+mKw4Ixs08F86aD2PM4xuc+NE4diu7Zq3pMTXS2lN/iGzSwlWBaN5kbAoVjdWYt08Hpphb4bz/7MdqZXqtqtl0cUM+HDmmDFaR9mGizDq8UwjYJsdK0Vs5TFAqrLJXcolt+tvllK+Z232sp14Ubgd3mfaxrPSed4UGktu14dC0gU+XMOLv4QfDDHCkvwp/dX44a3VnBNZYA7W7rwsGo1YMya4B5OSLiJAEbya+Ma6dzjVjdVC+hUet1jghVQrrmRqxz10N8s0iRCsYXjdrQAVuMG2cHQ7UleFo1ZyiDNynPN4tz4wB+EjcxSZpYSs5k7Exj89NK2gibIXoCZauLkpj4RQdBoewylbGTvTrQmPwvXGqZroLmxMRlR+Nwo3j8/LfVxrnBj8vbd9rkJMGWE4jITM7Ze3xk8Ljtm1ywl7/5Cq6XErj1RVBr8rKtlCpdwI5Cs0iwlWwoelhKJQ8JNBDCamScn8l+B5dVSgntL+TjHjLLxq/aWMkPvFDd20w2VSVBzo5NOuFS4hn5PNvPUcyjWCCo6eRgNUFYiFJtFtA6vWUp7zEr8JTOtHWP8pbrB3xU+N3zMNPDhM0vppyuSg/q9Fsk2bxTZdkBdNjcXDugiIKzKg/iZRTQPCgw62jX5PdrV3PBWa9rRcPh1rrUT+0sEkWaruxScHIrjHyMHuaRE/m/W48sYDKycspgJQRLqpeBm6DVY0eXbIunZ2VvKzMTiBqIOxRqMwutXXqZ2kOQGYeQ4zhopHcwcdc0EQvn9mnWuzsxS2ovLLJhLRSLaGi1rVwqIxmnpl8FAG2SCXbOUWHtVpSffg83EERvQ3hfPt859s5RJXYOyvby1ZDde/Xmn8QXg+aBpBQnbPjeyzwGd/PSQt3w9Z+Sw+dzoHM8/Uxasl9rtFyqgODdVACMJNkkn2pTVTspvYMdV7BHEOWaE2ixlht4kyXSpsODM0C5ubH4HGD83G1temaIb58b0HrQdj/kKC+V3M78vpnMutzRONDecY/JYQbykFY+LcT8qrjda+aUUEK3fx7HCEs1O9lZSMTpXvUXCH8fkWxeY58IMdvAW0cxpVktxzVLuYm5mZIph9YW5v2H6T7/hYOVKUc35khDD1PVf+T+gb5Y6YrZijzMRsKPNlPoYbUBO96WbP44WYltugeb42n0n0WXqT7j343UAALnV77WFvyu0f15Cwk0EMJJgk3Tc+vMtBtMyMkvx4J/HUKJayqkQbkTMUnqaG5ttz4lwo3TiE5/pG2HsV2OguTHKUsBvQqomRwqKMemzjdgsOYbrJMNTqatzsaK54RVRKRDwSq+ftxV470tuHnBqEgswZjiQKwZ8w5T49HhqHl75eZcqTfHrjc1SoR8f/nyTZfOEkXlDL/ClkRbUjkOxVfOFuXDD76vOlvIHXZ6WE+D74vCEm9cW/o6eT8/Hawt/FyqzkX+kxNHTJdx70Ls2HA7Fl+tsXPrGoj8AAN9szK0sizLvL9cfAkBmqSqB0bJEvTDhT3y1BccLSwAIakwMGgzPDsrrA48VlqLNoz8ogqL5Vb4N5vsN6Ry3bZZyB0WnHy7NjV0BzuC30PYLFS/uu025+Hjlfsz+dbdgOlY0N+q8Q7/P334Y/129X3V96LNdzZwIvGvLTMylPFV+xbl8DZRotGW9+/DBaiRy8QdiJDTLy/3JKv33o0aacBmZN3QFYwOhl6+5sVY3rG5lwcvPymAvnakn3CvNUtp0/++H7Yr/eSg1x5WaG4OKdv4/5+GuD9ZWaKFU0bb5Qo9uUrZRrpzTR+99kENxFcCosRr54yz67SgAUbOUzvQDysYZ1CIZJPru0j3Bz1aXguuvlrIp3DhT3QSxurReD+OBz1wDw//NKD+l5kZaUl/IU/1yTApGK57M4tzIf998sAB//99G7JGZPRQdtsn7dfTMOWnLZ9DmJjPj9CvMUvLzlReYbd8gYSXkv7Uo1fq/2Y1zEzzH4F71jhu1Je7eSy4PvGbJBQLWTMS8TWb1jtsO4qfQInOz0/DDljxsOaQ0CwUCOlrUcDndCKD3rElzUwUwMksZzfakjkJkgDeaqSh+kmQb0xQry6AwS5mfr3dOuOIwGKE3wDnyuTGcRRtcZ/SbQJrSwCk9R96qFKb4LNUdeRlUmhud1SF65wPA8aISbo7hXQquPVamMEtx8lNoHcyEE+Vs2Hj7Bf07sbQTtSW7lP5Pduuc3vX6Qgw/XRHziFkxXDdLqRzEzdIIam40PmfS/6Hjpf6ArQkXbzWeiMBfMYkJPaAA499buAKTiuBl3kaQcBMBjBqvUYcoLXcVqTpSh2y2oWLwmGCnaNmhWCdhuxoYt9qN2bJm8XT0fxNdsWYlzZDPjU9xrmhQRKNl0FqfG7XwY1xWZewO43I4eeb81VJyc6lxZ2+WdUCjuQl9PlxQjI0HQv5NhqYeK1FxxU8VNktZuU5/ywH+c2M6z4cXgyj8mAsupqv3OIK5tn3wj5vFzdEtVPAjP10eFWUInehnjCvQRua589E1S3msuqHtFyKA0Us2Em5CmhvzPIy3XwgdDK6WEuj4KtI1HkS01xqXzypOlm0rVigI+lSYYTSYhMNpOrT9QuX3ykzUjt/qdIIadZ1BSZ528BqdvPXQc9jmnuvgmfMuNVsKrrxvY0GHMWVdkZ9/wdPzVWXR68j5bVnvuVhS3Bica2iWEsnDQOCV/6R0qtZ/nmarNd1AxMxoyQeMSeky7jnqlMr8AaQkWdML8KJ5C4X4CGjrsuimx+FCT8MVbXiuuZk5cyZatGiBtLQ0dO/eHUuWLNE9d+HChfD5fJq/7dv1HbmiAUOHYiPhxsKSQV40TQmzGbjRb2aOm9py8I/bmeyI5imCYiPSMGlu7PrVGJVGki3VZqkSnllKMQBJ//MHJdOMZXnr/m4wg9eUzSUhVUKuueGFHlEOzCbpgwnfi1FavHauq8k0LpLwuU5n7EbaOz0TlaFZilMeqyV0w6HYirDNVP+HzuFPGO343fA3zhTr15W+bfw66IXZX0JfcxPhgqjwVLj5z3/+gwceeACPPPII1q1bh4suugjDhg3Dvn37DK/bsWMHcnNzg3+tWrWKUIntYfSOjQQfaeWBSLU1jC0lS8Bn7k+sStd4hqzJym2zlMg5jL+CQG+Ac9IN2B34jJeJG2mDKn6T6on0OniRUnn3a0lzo5F9xJ9ppIP4yQcYXgRa/aXLnPQDynPKjbQhBuXkTVT0Bh0r7cFYW2ivPkp+gEZLwfXqjtFu8Wb+T24gUtdEAjfKz5f/L8HzuQHsBfLjCc+iZim1kMm7LpJ+L2ofUg/lKkM8FW5eeOEF3HHHHfjTn/6Edu3aYcaMGWjSpAlee+01w+vq1q2L+vXrB/8SExMjVGJ7GJqlDKQbKRiS2B4xUoMxHpBCnZoYVn1u9IoartVSjDFc/8ZyXDlzqeFszaqQppufwW9ubb9Q5g/gg+V7sftYUfC6kM+NtTyU6nfjgUjq8OdvO4wv1h0013gYDHJqnJkCtcdKFZobTp030C6oWbDjiKL8fgM1o6HAIGvKvx8txHWvL8MvO48ZZy6AbbOUQIs1jnQrIOho0nOuuTHDrC8JMMY9R3+ZO1P8rz6uxsjfrbjMj49W7MMhVcBAXpBIkTZRIajJ6mZAx6E4Gn1uqmqE4tLSUqxZswaDBw9WHB88eDCWLl1qeG23bt3QoEEDDBo0CAsWLDA8t6SkBAUFBYq/SGO4FNzgusKgcGOeh6FZSpZASHMjpknwmzhuaq7V6RDs+9wYc+pMGVbsPoH1+0/hmGIlj9ZWzTtuuTwGkza7DsXq6975ZTce/WIzBkxfKPO5qTRLCT5HXodtprmRTr3jvdV44D/rceCkNqKrngbM3A/C/kPnPVf5kmOepkXPL4RXjud+3IFCWUwPY82Nfkcun6jc/cFarNh9Ane8t5qfjktjkfAqSd1z1AIvv77oBe4zWjavl4cZZoMid7m5PD+dcvh1JmrBU1WXPPrFZpRxVkcZaW5enPsbHv58Ey57lR8ADwiZ6IVWwQaYRlDn3lsE1Sei+1pVWbPUsWPH4Pf7Ua9ePcXxevXqIS8vj3tNgwYN8MYbb2DOnDn47LPP0KZNGwwaNAiLFy/WzWfatGnIyckJ/jVp0sTV+xDBrtd4ULgRmPsYORRbRZ6Eeim4Wfp6fhq2tSUmlxXJoo4mqyIi6iktnGlutNd+Whnczi2H4uV/HA9+Di0FV37nl037xciXhKvell0g3404dA1/YLNrlvphc67hdRUXaw+VmWhurPgDAcAZ2Z5I5YEA3lu6B0NnaPsVo6QSZe38UD4/1H8wHUF9hrnmUigZ4esDqvbOK4eRsGjm/2S9fBzBVmAjTH6dkN+DVtBRX7H3+Bl8unq/5rjR5pnzth0GULHlBlDRh/+665jKd1HS3Jg/GbUWys/4NSccW7+IoncbXgfx83y1lHrgr4jIyH8sbdq0QZs2bYLfe/Xqhf3792P69Ono168f95pJkyZhwoQJwe8FBQURF3DsvmRpNilScUPbL/BmsdqyiJpQ3FoK7nb0XqmeFJWEBiWj2YtbmhvefTz4v424tkcT4wdkQasjn5iGfG6MzVK6fkecTpz3m/S7X3G++MBq16F43AdrseeZEYbXmi0F52puLJjMKs4PfS4PMDzx1Rb98gQY15ws77fc8kEyO8/paimNcKMn0KDivguKy3TNOxXXu6tBsLPsmTH+cml5P8oT0HhF33OsCO8v26s4Vlaun796mfjts1dh5Z4TyE4NDbVWJqIBlaYmwBhXe2z1uUt7syUlWtdvqDVr5FCsonbt2khMTNRoaY4cOaLR5hhx4YUXYudO/R1fU1NTUa1aNcVfpLH7kiWthBOhAlA2IqkDNlK9y7HsUCyQjhX0BnOp/PJIvUbbC1gZtO2Uh5e/4joLafKW30tKKXGzlDZfM+dP9YzXVEvnguZGBF7Scr8Hv5lztVAeobMO5+tvgrhk51F0nvITvlx/UPPe5PKOqelE8HmYtTkr7Yrvj6euE/L2rjz+5/dXo+vUudh6KJ97DqDj++Hg3fPKbLrMG/znpudYXlwWwM1vr8Dri7V7Q725ZLfmWKlfG4ZBolxVF1fuOQEAOK3op5T/G6FeLcUYfym4FeGGMYZhLy3BRc8u0JRX6HqDOhNNeCbcpKSkoHv37pg7d67i+Ny5c9G7d2/hdNatW4cGDRq4XTxXqZGRovubUbUIam6EbLP6CSq3X6jAyAFNuZeK8e7Lmmt1NTdGwpeYUJAoGz2kcimEGyN/GLmQ5kCFa9Qh6WqtAvwVDhIazY1CoKz4XxJKRcey0GxU3jOq81VrbpjuAMA7ZiQ4qXE7tpCZ5kZeOD2Tihz5gLl670ndsiz/4wQKS8px/yfrFffk8yknMWVmphNRs5TJ71aC+HHNkAaaF7W/1vztRwAAGw7kc88H9CIUO5hMcI6JCI5WzFJfbTiEJTuPYfave4TKVGqguSkViHlhtPiDd65yR3F72iw5JeUB7DxSiNz8Yq5fnVX0svbaodhTs9SECRNw8803o0ePHujVqxfeeOMN7Nu3D+PGjQNQYVI6ePAg3n//fQDAjBkz0Lx5c3To0AGlpaX44IMPMGfOHMyZM8fL2zBlSIf6uKZ7Y5zXrAYmfbZJ+LpgQxGot1Knwh2QeI1BUNOjdMIT0NzoDR4Gjc/Qj0T2W4IPkOZMUnpyR1D1PSkH39DnT1fvR056Mi5pH9IQHi4oRkpiAmpk6guiFeXhF3b2r7ux7wS/o/DrzLbkBS33B7Bu/yl0apSjEL7UZimjaKA8OcbIdMTT3JQrp4naouoIDea7gjsY4DiXygc4s4FMpN83GzB5qPOVLwU313qJ5eGmWUrE2VfxHnXetXEe5ueYIRcSue9eYLUUb/KmJ7j7Lc52jByKRZaJh1ZLiQg3Wg2aWdBKM+Tn2lnWrkZvouy1WcpT4ea6667D8ePHMXXqVOTm5qJjx4747rvv0KxZMwBAbm6uIuZNaWkpJk6ciIMHDyI9PR0dOnTAt99+i+HDh3t1C0IkJvjw3DVdAMBQuOnZoiZW7j4R/G60pYKa4LlmnUtlhTNc7ir7LO9IAgHzstjxubETQr7cXzGjKSwpk5XPSIAK/bZi9wms2H0i6OtRWFIejERr5v+hl8OUr7fqXqNe8cBL86X5O/HKz7swrGN9hcOk2qHYWMulnqkzvPLzLtl3aH5Xo3Ao5eWhowUJ767g2otNfW508tatTzbUeep6a2VvKVFZz25742XB9UMxEIBM5Fxu/rw26Mwkqb1YxATKq49695ORYm0YNKrrQsIN05ZHD6YSZvT6EiurpeR13c5WEqI+N17juUPx3Xffjbvvvpv727vvvqv4/uCDD+LBBx+MQKnCR9cm1bF+/ynd35MSfMHOOrTBmnm6/gDD2VI/vlx/0PA8qVqKNgarvjJ6ZxuawQSzqGhUFSdf9OwC9GtdG+c1rRHKQzN6y/I3yGPf8TOysug7tHPzEMDsmt3HioJCyPeb89ClSXVFeQBthGI1FQ7F8u/Amr0ngzvLV5TDuFwMKpOYhVVIpg7FDjpA3ruzEudGxJncjubG7VV33PPMNEAGY6nYjt/qc+S/mL9fIe2Qo/VSWkxXS+mUQ28peFqytThpRnVZpB4Zadk156ri2jCmMymxUBflj297XgFmzPsN9w1qhY6NcoSup+0XCC4f/OkC/OcvF/J/ZGpNib42Rk2AMUz9Zgumfa/dikIZ50aKl6Kflp7aUlSNykN0JROvLKXlAazcfUIxoBWWlOO7TXkKnxv1IGe29xHXWTEMjrHlAWvduz+gfebBvaVMNEDyz4cLVHF/THwwGGNcfx9F2XQEBdNw94a/GsP1uZH5PfA0N1YEr4o0rGtu5M/K57Pq1OnOeVZm7KZaXegLgnqvVxPzxKHJBFCuLuVda2oCZYx7jp7PTXKiNfuJUd9ptExcnbdof6rWkPKuslJ95XV9wqcb8NPWwxj16i/iCWjKyL8P2jizipGVmoQLzqkldG55gOl6x0u0qJ2J3ceK4A8wfLaWr7XhXS1qZ7ayesboJLuzXMaAx77YjP9UxpJRc7pYf7WUWf4BBiSqHEHLAwxJBhM5W5obE7OUGr/C56bif5EIxZp01JoZzUCm/M5U1/AGfD2zVTjNUryBVRnnhrf9gvlnObY0N6psLQk3wucZn2m8MECJmamm4jtfKNQ3S4mXxw68+zcz/eiapXSWglvVTjvdzyu0FFxEuNFuv2C2Esw0f4cCqOj2C1U+zk1VR2+3XQDYd+IMuj81D7UMnFxTK3enLSkP6Nr85ZVPOsW4gfJnxQzmg7ResqL+MDz0BBtA6VDMc5CV4DVof4AhMcGnEG78AX68GF6aovgDJg7FmvO1mpsEgfemHMS192FqpmDK9HkaEb0NSM032bQ/INjxuVFeb56HaGgEOSJBEfUwG9h+P1qItXtPYmjH+obnWYlQLGIyUpql5GmJTVrsrAQ3NgNrj5lqV6G3/QK/r7UqrMjTUW+zIHZ95f8C88tAQL1xJj+Gj5V7cCqcxUqEYhJuogjGgPsGtcLL80Nxe04UlXIjxUpUS08GAGzLLcDZMn78Be5ScIP6Le+vyv1a51Yj9AYxu2HizQaBM7J7NlyRZTJQS5TrdB6h8hgWh4ufMUt2GZ62LEFgKbhyB3Dt/WmFP+NnwnM61zVLhVFzw7tW4XPDKaf+xpn8gtgRbtTPwkoSZqcOen4RAGXkZG4ZBCcpABTB395a8gdu7d1Mq33SkW5EfW7M/J9Cx8QeFj9CsfG1vx0u5B7Xq7tGz9DnMxYSez/zs2FZeEjXi6+WCp33ys+7FKs8eWUyQ0S4saKBi1aHYvK5iTL+ekkrvDKmm/D5OZXCzfeb+VtWAGrNjRTET3/aoBBuDMxS/Ii4/DQNY9AYCT76lwFQajk0PjeKzplzrc7gbtW8ZYb1maHsc+UXn8lScMZUz55xnoeZz41qxltm4qdkJYifkw6Q957MNDd6Ggg97AQzU8RO4mjKjBA91SjmjpSvaB7yc0+XlOOv/1nP0dzoCYV6eajrFO9M4/ejRq7J4Z3mRkBQvT5OjXpLFyf5S4RWwQqcq6pXi347ise+2Kw5z4pwLlJ+szhNcqLVLEXCjccwVSfs8/nQql6W8PWScGOYB+eYaN3VM0MA/A5Kfyk4wycr9+GV+dpo0k40JaXlWhOOXv5qeGHQywMB02XbVvFbdCg2WgquN6NS39+3m3JRrNq9WOtfofzOVLNE3oAvPyS/PJyzN15nrHQo5kUo1hmkdYrpVHOjnmGbIXqmkwjF6l/UaS3YcdQFh2JVeQQnPKLPineaHedvQL/uGj3DRM42G07renC1lEA6es7RmjQt1F+Rum7kgya+/QI5FBOVSJU90UKlEBJu5Jqbyv8NzUS6PjdKJJ8VEfwBhocqY/wM61QfLetmyzMUKguPknK+2ay4zK/YVJPbwVZeoFz+bF1IMiMQsOYIbBzEj38N7/BL85SCpJkPBmPK983rMNUDOu8zt3wOxgNeZ2y2caZi0iCQub2l4LLPJuZMDaIPxOQ0K3ly/WEMBF4R4VUtbIv63IgLN/qTEqvorZYyGuyTOP2b07h3oSB+5ueaaZLVaVrJ3wij9iC6/YLXPjekuYlCeJvy6VEtzVy4kXcvFTZkvsNd8Gy5JkOx/QIz7fCMNDcS+WfLdX8zKgsPxR5DslUIXaf+hCU7j2l+kxOKI6TUAjgpDw8/s7ZaSj4zDcW5qfiub5bSmkWknYnVaQW/88pq4lCs3DXaWBBSXOfELMWZusp9bngdsbw48k0w9UphK4ifE7OUaB4maVqJHyW0t5TqnoyurTjHvDxWzNci59nRsqnLIU/XaOUory92uiJMqrt2IhTrYS2In/m5omYpvU1KowESbqIIqY5Y09yYK9+MZmdG5QBUWg1NZ2mel0S5zqAImGmRjCnhmKXK/AzFZWqTjP5ALS/bl+sPodPkn3Tzm7P2gEmJtPgDAYtxbkKfpaKZ+tzAfMDQamq0wo68T+ObpfgDhKlDsXHRDOFFUTXT3Mhz3HywwDQPO5qbtftOhsrArAm+vHM/Xb0f//x2q+4gzMPYUd+8nWlNlfy89bIRWTnDfTsG96WIc2PxWiOUZinGPa7NS3wCJ8eoC5f6JtEFGmKaG/O0JEQ0X6LtQfQ9egGZpTymZlZombdUUURNPQCQk2HV58Zn2z6rt5Q4/2wZXpz7Gy7v2lC3Icobizp7o7gVppob2Wopoz1buD43lbNt+UzsuR93GOb32kLtzsFm+APWOmSFo67aLKX3qJi5AKERcjUO2EyhwTALjmcWJNEobytwfW5k9Ym7/YJefjrH7Zg67v9kvSw/sUFIgnfug//bCAAY0Kau4XlyrPnccM7RtGl+CuIRinWLozpPdPB0Ty2gJ7gZaW542YtoSZIT9fUGxZV9lp04N3pY0dwIORQL2t4My+axXYo0Nx7x0vVdMaJTA9zWu4XmN0vCjYDPjbwC+nzWovDKhRI9n43nftyOd5fuwZUzl+oOsKV+ramFlwenNIZlVSwJrkyXH+NCe+0X6w6h25NzsfT344Z5OEXveack8ZuffOm/Os6NiNlPD1OHYlU6phtSyvo/s87ViVnKjs+N1fzsmjrkZbCShFHxjivev3E6llZLCbQL5Wop/fP08ufG0uFcq+iT+Ekb5msHvdVfRu+eHwzQvFA8Xx2JkHBjmoy4WSogbhYVEYRE24PhqjehFMIHaW484vKujXB510aKY1I9MRNuslKTgtsOiAg38jggPghEk1U4FMuEEigFE+mnXUdCcSX0ki4ziJfjTHMjSzcglVlssPu/Hyq2qnhh7m/GmThkw4FTmL/9sOa4iPlRrc1zYpbSLAXn5CV/FTxzkJ5qP5x2d67PTblcw8RbLcVHfyPWijRSEhOEQuirCTBrgRqNzhTxdZGwonHiJ6UvnAiZpQyEI34O0nn89LTXhktzYyzE865Rn59/tkzzm4TRJqqSKV1sQiIutARYRcR1M8TMUvptYPkfss2dXdSsuQ0JN1GI2e7CctlHxKFYPdibVm6Fyla/o5UqdpIsFoSI+lp9jtEswazp8DQ3ogH7IoXeTvAiCjptnBv+eYyZDwTqV8MPkGa8rYHuailTbaCRhkG5WenE/25A/tkyvHFzd/h8Pq5mz8pqKRGkmD7pKYkoPWvHudiagGf0PETiy8jz1c1DYFWL1iGYf71ohGL+uxA7FsTM6cYmdpaC834KMKCk3I8uU/R984yQNDciggFj4gKE6OpVMbOU/jlyoc6o7/Z6tRQJN9FEZSU2q6Dy30VWVqk3+DMPXx5CsZGnzixNXh4xVavyJGPNjXGCvDg3lnwwPETk3Um3YrpaSmBrDPNdopUxNcxWSymEYFOzlPFv0ozTH2D435oKp+09x8+gRe1Mmz43oWPyjRH1iikJchkpiYYzcv17sLZayjAtxR5IZs/V4HcRrYrBOUqzlPmkhfddD3HNjXso7kH20cgszjflMew9fsZ2OSSH4pJycyHaHxCLcyOVSwQhzY3o3oMW4uFEGvK5iSKkamJmrlAINz4famfp7z0FKJf1+QQcihXLgeU+N6oBVDpNbl+24/thHFPBmJJyrUMxd9l3FK5XFJllica5EdqnxmQgWvTbMcUu67z3olw9J/vswKFYufxcqzlyGufGyuqQ9BSDXVMN8DP3fG70tGNm52ryqPz/b59uwHWvL+POxo0EXiZQDqHVUpxrlXvq6eNmu9Vb5m6kfdDbX00dZoF3jh7FlX3WWZOtNQBxh2KzPK2eZ6S5UZxn0PF4rbkh4SYK4UT8Vv4uqzU+APcMaGl4vrxt+HwCKzB0Gr5aRRqMwWJRc6M2d4huBcGDF+eGu62CB6qbc+pkGv4u4nMjPRuzCMWAwGop1Xd1Uh+v3Ie//me9LG/+rJWXnhPHVzMnZt4xszg36rKZhbyX7jXVaEt4AwJMfOZcUQ6VUCG7R7k20ixFszg3jDHMWXsAK3afwBrOVg5mTuZm5VA3XW6E4sqrn/1hO97+ZbcmHyPtlKvCDV9xY9lvxM8YjhXq7/cHGJdb8hOUBxnVI8DEtWGifZzIMy0V0CqJpuUVJNxEEVLdTDKRbtSam1t7NUeDnDThfMw84eUdplwQYUzZgKTPcs2NiDOmelZgNEswU8urNUkni0pNN1KMFEYrJgAxs5Q0cJvvLWXeC4qsbDmr2IhU+y719h6yYupUo9jPirM6j2e2NNfcqDQKJs9GcqA0e2d6BALWAjWqz5WXTyHcWJiIaPIAUzzPohLtYCq6t9Ti345y8zCLnSSxPa8AMxf+jie/2ao5T32J/A24OXjqbZxpdaUcY8Dh/GLhvNRIPjdCmpuAuOZGNLigyDM9W2YueAEmPjdCKYQPEm6iCKmjsaS58VUMkkM61BfKI8CYaSOQV1i1WUq5NUBleWQDgsgGhOqZthOzlJx/L9+Dbk/OxWuLdml+82KCYeYYLqK5kQanBJEgfmaJyU547sftpjF9+Cp5WXIKwdIkdxuaG8Y5JmG2t5T6Enn0ah6SQ3GCz5463eogrD5bfn1JuXJCYZyv8e9ys61ccNVLXxmB2jhtwPg+5OkcPR0y46i3qjByhHdT46o0hfEncCL4Awy5ZsKNkVmq8j0UlYiapcTKJSqkiZwn7UZ/QYuayDQw1Rr192SWIjRY8bmRThWNjRNgAqHyFT4Q8pkc388iSSHcmDcc9WBkGOrbQt/2666KeDUfr9yv+c2LJYtWHMP1kDQUIbMU/zwBxY3iGfxrgXkwQv62BlrhQ32cn7fBbwon5tCXU2fK8O6vu5FXoB1ITDU3qopj1qH7ZRoyO32y1e0bNJolXbOUeFvV5gFFpG6u5kYt3DD93/h5qDU//HLIB/Iy1RYnRo8uHD43fxwtRGGxsW+ZEUUl5fhi/UHh/NQUlwcQCDCusKlJg4n3XaKaG5H0zlS+r8zUJMNJmpHW3WuHYlotFUVIdc7KoCiZK0TV6YEAM+/o9WbSKuc2xoD9J87gy/WHgsdEGqy6QbiluTHCA9nG9J2IzGyCPjcmcW5EOqwyP8PcrYfRvVkN84xh7v9iZW8p0dm5PJ1Jn23E70eLuNcofG4EnFgl4UWvFGUy36YEn8+yMGzZtKH6Ln8Gcm2LmWOnmUNxsaw98laBiZqldPPQCEd8QfOMzL+kzM8M85GHBXDXLAVsPVSA4S8vURwXuc92DarhvKbV8eGKfViy85gi0KYeenXCH2A4XSxm9uHtGaeHqJZLTHNTUb70lERD+1I0+9yQcBNFSHXT5/NVbnDJP08+ZkqfRTfbFPG+11u9wqCcmfkZw5X/+lVxrUjDUasyjVSbIsJStGL2TsQ0N5JGoeK7sVnK+NnP23YY87YdRovaxo7OEnxzD99sIb32TQfycbSwGAPb1lOWz6Boeqvz9AQbQKndENnPyKzjl9JIqGx7VrHcyesIX4DSLGUWBt84QjFTpLXlkHaPLY1DMccsaJy/eXkYA4pk/iXl/oAmQODxwhJ8tzkPl3VpqLjWzcGTMYafOcE0RfqsIR3q4dSZCuFQtE8yejcnzpgLR4C1yNeiz0pPwyOPNyW9r8yUREPNjaHGkuLcEDwSfT6U6zQOtUOxdL4I/oDxjuDSORLq7RfUyymlBm+FMlX+6u96ZYk1Ugz2lwEEV0sFzVIV5+pN5EXMUhK7j+kLDYq8eauldJbTSr+NevUXAMD8v12Mc+tkyc7Vz8eKBkjCXHOjNksFKo/z0yuX+TZVqNMtam4smjbENTcmwo2pWSqU1qaD+ZxzDMxKArckFMQPUJiBSv1KsxQDw+3vrsKGA/lYtfuE4lo3zcl6dUukziX6fMF+t0RQuDFK90SR8VJyCWtmKaHTDDVKSZUxoSTNTUZKkmGwUaN6Tw7FRBB5NTGa9auXggPiPjeMmQePUmpulJX3pGzGYXcFUpkqf/X3eCHDJGaKiDwaciiu+K7/zN0MVF8BN86NwSoXucCxTxXkTNQsJWrekeftDzD8dvg0vlx/MPh8NGYpk3QlIcJn06HYqs8NTzCUOCPTcsgdp3kYaaRue3cV/rta638mR7o8iWP2FDJLqb5zHwMDTp0N9Rtlfm28rA0HKgSvn7bmKS51uueXomwmgq0RCQkh4UZ0ew6jsp8oEpsUWnEoFl8Kzi9/OacOZphqbgyEG9o4k+Ahn9VPG91J8ZtytVSl5kZQuCnxB3CFypSkxmiJr8IsZVMmUQ8EVgeGWMEsIJzIO/tl1zEAAqulLGhu1GSn8hW4fJ+b0Gd1WRRCs+rWRM1SdjR15YEABr+4GPd/sh7ztx2pyE99jonPTaTNUkdPl+CSFxbhrSV/VJRPdr18ibDZQBoIAKeLy/DRin3c399bttfw+tAKTW2QSJE7Mo96XUG+TMNbrtLcyD9nq7aTcTfOjX3NTYLPF2yD8v3sDPNzRXNjvrpVQnTVl16VkmsJJYfijJREw/ZguFpKqDThg4SbKELeUcidUc9vXgMvXtcl9FuiXLip+F9UuBEJzqTnc6OmoNi6SQqwFucmlklPNrb6Jpqt+ZchCbF6fYkT9X01nc1XeavYjPKRO43KBfBAgOHjlfzBF1AKPmZmGB5yf5XVlYHqRMwlcoJLwRPMl/DzsKphOFPqx64jhXjq222a8sk1N2bt1R9gePzLLXj4c/7+ZWZIr5inuRGpUprnrONQLHdmLvMHVFs7hD5npybZMlOKoCckiEyuEhNC2lORbRMAY03KcQGHZMBqhGKh0/Q1N7J2dKZMEm6SDDUwbmrW3IaEmyhFbpZKTkxQLKuTV7YEi5obEeSyhpHK9tCps7bS18a5iU/NjZlZysQlR4GZWYrBvmEqM5VfTu5ScAOfG/kKEHl1nLP2gOHqEOeam9A1xWV+FJf5NQNz8Bzd2XvIt8mOcGO0x47Q9TY1N37G8N2mXNv5Ss+Ft+u8vdVS/HPkE6EKsxRTnlBJdlqSIs0PdTRSdtATNkReXYLPulnKqC6fFBZuxGN0Od1+Qam5kXxuEg19bg5zwjRIUJwbgkuiWriRVRR5nZE+242sysMfdL40XjZ+pEBMtapGa5aKXunfCWZmKSuDqIhZyq7TjV5EbK5ZymBmLxdg5ML42n2nDPO343OjuF52zZZD+Wj3+A+G5/CQaw/ttCTDWE0CyJ/BmTL5smlzh+KUJPvduOS8HNTcOF0tpeNQLPcdMtLcZKUlKer41xtCYSacolcFRMw5iQnWhV5jh2Ixrbc6/IYRoufptTH5wo6gz01qkmG8mgmfbtD9jYQbIghPIwNA03nJK410np3Zph5Sf2o2zpwRCB/Oo+qYpdwUbir+1+swGbPvUFwjk2+W4i4FN9TcyPwqFNt2GJcs4KLmZtWekwqhSxq0gxGK9dKQr0qLxFJwg+uVDsXmS8FTVf2D6FJ/IGRiSeT43IjYpUS29GCMKbQdZSqfG/mKruzUZNcd4+Xl4JlYhByKZZobUYzqhOjO8/6AfpybpAQf2tbPDn4vDzDkmUROBvSFILkGPbhaKtlYc2OE10H8SLiJAqaN7oTaWSmYfk3n4DF5hU5OSFAMhAkcNY7cD4dH7axU4fJIg43ZrFG+ZNUKVuLcxDJuOBRLSJ2y3njjZEDo2CgHXZtU1xw3Wi21as8JHDipNEvKdxSXC6xWohfbcS43GkSkdiENEr8dPm2YhhTEzypOtY+2zVIBptns00rxSzXCDcPp4jIUlpSLmUNU5+gtBZe/V3UQP/kKzPSUxLBFE3eyFDwhwWd5kDfyzSksEV0tpT/JbFM/Gz880A9NaqYDAK7416+4cNp8/LA5j39BJbqaG7nPTVBzk+j5qie7kHATBYzp2RSrHrkEHRrmBI/JBYvUZH2zVDCIn0kFTE8Rf9XSAGbW6EUd69SoG5dRnJtYxsznxkpnebigGP2fW4A/dGLUnC4uN93vRr8cPjw6op3muN7eUmv2nsA1s5Zp3v9pRUj70G9mr9eN1VJ6JFea3MoDAXy/OU+xHYEc+R5edvpyp+OxrubGRKsQYFrNrhUTtfQOJdNkSXkAnSb/hI5P/CgksAUYw46800H/O70gfmqzlPw0uXOtP8CE47VYJcD4WkSRJdSJPp9woFQJo8mhaIRiI4diqZ6qzcoz5v1mnKaIz01pyKHYwroHbvm8goL4RQlq6VjesaQmqR2KQ+eJOhTnnhIf+KSO1qxzK7YZPVjd6ONVc5PmolnqlZ+1m4GqseufkOADkjjezXq7bf9vDX9fHXWgttA1xvnLO287GhAjAUCuuXlxrn6nL92r3b2lJCo23vRZFtLk54uaLKTr1MEirdQrqQ1LA5i8HKcFVkMeyi/GQzMWAwD2PDNCV5CVt/lyVZwbdcwiu/GzzNA3x4iYpcQDpYqkKyzcBPTj3IRcEiwVS7eNyctbVGmWykxJ9Ny8ZBfS3EQp8s7Ap5pNygUh0aXgVgYNqYMz66D1ZsFmbDyQj6EzFgdDodtZ/hsLmEYodtEJ3Ak++Lizfd578QcYtuVqw/gDysHQillKobmx4X9lVE+TEyXNDUONzBTd89R7S9nFjm+GVD47+BlDarKynlnJXzIl8pzKRdrldlVd0HMolgu76gjF6jzdUuSq298bi//A9J+0Aq6oWcrqey3160/+CjmbmPLQ0zYB+jHOTCcTOvdbytPcpBpHKDbCa3MWCTdRirqz462QAsS3X8hOE1fSBTU3YfK52XQwH9vzTuP2d1dj7/EivLlkt610oh2zztBNJ3AnJPhCQoAcvdVSu44UctM5XcJf5WPucyPX3Lgr6Er3ZbbtSLlDs5SEz2d9Jg3Yj1MU4GhurJilXltYsTs8r66KTF6UcXF0TCiMKbQCaodiORV7Kbkj3SSb+CHK8zQj0eezPFiXGkSXFtGKARX+SHpaW73SmC0t0BOkJf+rcn8g+LnCodj4vv/S7xzUr5ZmeI4XkHATpajbN88UJUfPofi7+y7C5V0b4p2x5wvnLXUuUiPQ6yvt+tzImbngd8dpRCumwk20aG58Pm790dtbSh1YTlqtU6jjcyNqlpr02UaM+2CtcLlFkJulDp7Uj8sUdChOAJzEVvXZiJNT7g/geKFY3BM1fsY0gimvXpkJPLzfJZOV0bXyKlLmZ0H/lYeGtQ0eZ9CapXTNVwZmGKtk6ETeViOiNUtM8EFQVgrC03xJ/lGiK0SX7Dym+5veCkpTHzedBilpbs7I3A0qHIqN03t4eDsM79RAc9zr3o2EmxiBZ4oCjJeCr3h4ENo3rIaXru+GLo2rC+clNXap0fD8MQB3hBu5M+QDl7TCJe3qGZwdO2SnJimEm5Z1szTnuBmbyAkJPl/Q8dYMP9PODCXfotMKn5uKc77acAjr9p80TrOyGn28UrsPkhWNIw/pGZ8t8+Pw6Qq/s6Ed6mvOkzRGahOwVRJsrCS/68O1GPfBGlv5Mc774PUFNQ1MclI6aqTdr3laPQn5wFrqDwSdgS88pxZmV06oGNOapfRMLRVCsTvSjd62ImpE4tz4fMaTle7NamiO8YQbs0UGVghFLVc+LzOfJT3TrxR2QNp6ITHBh5TEBCGNFU/b5rVimoSbGEFhlvJpP/MGynoyVaGVcbTgbBkYY8HGqec7svi3o+KJckjwKQev5MQE1Mjgx1yJJT75y4VY/OAAhanwP3+5EC9e1wUNcuTvJDqEG5/PPJSARCDANANhUHOjMkv9dvg07vt4HfafMI5kbWQWyNHZGkIUaWA+daY0WO6aWdqBXr63lBOZ0wfrmpu5Ww/bzxBa8xHPRG0m3PAGYmkPJaMggYtkfUBpecjclCiLF8SgNEsZaW7KXdTcZAoLN2KaGyNN61XnNdYc4z1Ts9hXVghqblQN0uxuTDU3paHoxD7B9sATqLx2RCbhJkbQC/AX1NyY1EArznAl5QGcPFMWbPSitmur1MhIUXRAp4vLPZf2AaBR9XTF98dGtsfnd/cWvr5b0+qokZmCHs0rZnO1s1JRKysVV3ZrrOjcokRxU7laSlC44QQLDGluQn4Ez3y/HVsO5QulaTTTdCrcSPclaZXSkhO4g79893UnnfLZMr9r+vghHcS0mJpVi5z8zYQbnha2WEBzo0zDrzDvScVgTDnQl5lobtzyuclyU7gxMTc2r5WhOVbK0ZCYxb6ygtTuNIonM7OUic+NfEdwwHgS5gsKsNEHCTcxglJz49McNzNxWHWGO3TqbNA8pWeWckpOerJiRpd/ttRzaR+AZvXJ1d0bo1tTrdpZD6kzqJ6RgvWPX4pf/jEg9KPs9qJmtZQVsxTHMVfS3Gw4oBRmJn0mtpmjUZwRtzQ3BZXCjd7M2cmu4HdefI7iuxtvtWnNDFzZLaQNMJpgqAUT3plmwg0vWKBkllJHQNZNozy00kk+IDKm9GsxWhFVEefG+lDp82mFGVHNjYjPjc/nM1y0wcuLF13aTc2NlJbaCd9Uc2OyWkoSbjJTKu7JaOzgbbgq4fVElYSbGEF3b6nKLyLOqVYG09z8YiGHQjPuG9gSb9/ag/tbeYChWLbi6mRRWTC+gpeoOzGrjVTesVfPSFHEu1Fo3aJGuBHX3BRzOmy9eD6ioQL8Aaa7Ms+xcFMptElapYwU5SDUoWE1ACHNQsVqJ2vvpXZmqiICuBu+aGnJCaiTHUrTKKzAWdU2KLzi17Jjlqq8D1HNrcIslRBaXaROu8zPFDvIq3+zo7h59qrOWPLgAMUxUS2JG2YpnnDDExjd9LmR0tI6FIuHXpAjaW6kPlh6fkZvX2orvCy97t1IuIkR9PrbYKwD1QntGlTTnGtlLL3no7W4cubSyuvsV9PLujbEIB0n4bOVOzhL1MhMwakz4gHMwoVaCLR6/0bPWf5TtPjcJPh8uqYH9b2c5QxKojN7PZ79YYfuNgPVHfpgSUKbtJIrPUW5+kMS3MsdaG5SkxMUg5Ybwk1qUiLqyoSbZINnXKwKycDTfhrF+AH4Aeesm6VCwo3csVr9bsv8Adzx3mpuGnaXggcY0wgfvc6pJXSt2Gqpij89eCYwrs9Nintxc6W01OU3e3xmS8Elh+KQ5kY/rZDmRvub190bCTcxgrzD4g0mcu3KvQNb4ukrO2rOsTKYypf7isZk4GHU0IpL/YrZ/d8Gt8aJIntLYt0iKzVJ85ystlEjNa487TC5MlnGB33tXPUM5aDI2yzV6fYZW3MLNPtUSWSnORVuJM1NyElSjjQgyveWstoppyQmuGpuALSaG6No4GrNDQ8zzY2RWUp01/FSf4Br3lOHDjhw8oxuGmUBe0H8ygNM8d7G9m6O685vYj0hHRJMfG4yU7Xvn7fcOz3ZvSE3qLlR5VPuD+D+T9bhlfk7AQC7jhTikhcW4fN1BwCYB/E7o9bcGLSH0EQw+rxuSLiJcqSKJa9gjWtondfks5abezXj+ogYbQcgT//cOspdhdUdX63MFLx243lGxQ5iVOXPlvlRUtmBPjy8LWpnpSo20fOCr8b3cay5MUKelJuzOCekJiXomizrqDZc3XJIG534tIXtAvTQC0dvxZmddw+SOed05UaF6cmJCmFVLdSZDWI8UpMTXHUUlcohb69GJj6Nzw2n+NVMzHtGq6VENTel5aE9oxITfMEJmTrtjSrfLDl2NTf+AFO8t6u7N3bVp41XL+68+Bw0q5WBGdd1DWo55PAEUrVZ1AmScKPWxBzKL8aX6w/h+bm/4ejpEjzx1WbsOlKIv/5nAwB9zWKZyqGYJ7CpkSYP/NX03s7eSLiJcqSORa4NaFwjXXOevCHrOb7xZm81M1PwwR0XKBxKX79Z6SOj7lhTkxI0AbIualWbm6e6n8pOTcKsmyoEo/IAC0a1lTpyuXCjl2a4uKNvC5xTJ0vTKbqpXpW/RysxXMb0VM5C3YyRk56i3Pm3mqxc9XLMI48WONDsBdPQEZB42wLowfPPkZ6TruZG419l3aU9NSnRVV8KwNlGnDzhzGwrEF5+ku+F2bUSa/aeDIYDkGtu1IPp9jz+zuxA5b5TQrkp8QdYWE2+iZztFzo2zMGivw/AFd0acf1xeAK7m/VEEqiNHPJ/2pqn0ezp7V2mdihOT67oB4zqovScyaGYsEyyFIRM5uvAE27k9UhvxiL3X5h543nY/uRQrHn0EvRtVVtxTX2TAe3xUR0UavinruiIf99xgeE1EtXSkzGgbd3g91OVwkxaUkV6ckHq33dcgG1ThyrU8+FE2k4irMKN7LPoUlUA6NSoOs6RadTMNuW0glqDJJ+pNxAIq2620aOIWUNPYzeEE3BPD7VwUyc7FYmJauEmSSHIqR2ppY0vrZCSmOC6cONkOTSvLLwVj2ZB7iT/N1Gz1HM/7gh+TkgICYlqs5QR5QH9ZeJG+FVmKbdXIvI0N2ZaRZ45/9w62mCedskILgXXf147Dxdq3p9eW5PeU2GlljNLRHNT+Zx5JfDa6k7CTZQjdUpynwSzQVHPqz81KVRZB7ati7Tk0IxdrgkwSn9s7+YY2rG+Qrgxmtmp52EBVrEXjpSdtHxYWn4tNcS0yu/pKYlY/HflKggjnES0ldTwas2Xm7NAuSLC2n5fAcUzT3PRdq/2F5EPDCKam+a1Mg1/nzyqg2kaeo7k7RtWw4KJ/XFe0+qmaahNL0+Mai/T3FSapVQDv1oz5LPhc5OanOCqsAmEZuOigoWcLFm9GtOzKf47rhd3Ndy6xy9VfNeTB+zEuZKnZWVjXKMAf0aozVJuL0Ss2FBVeSzRRKtYwNHc1M9JcxSotEnN0MQ2Q8ehWE5RSbmi3wf025qkuSk4W1FukZWKUl/hVmwiNyHhJsqRZtFSeO80Afu+nslC3sGpO+NEwQ5M0qLIy5CcpH+tus4HGIPP5wt2YNJsQSrPR3+6AN2b1cB/7wwFzbMyC3MyyEjqc43mxnaKWuRGDyuam/IAU9ybm4OpeqYvrz8iG+I9eYXWeV0Ob6ao1hqcMtD+tKidKRSzRG5Oe/rKThjZuWHwXeqZpdTv+kRRqeX3rdbczL7tfOEAfHpI7aOaDWFd/mz/dFELnN+8JjeOkVqb46YQL49QbEVYKbfpc6PZaNjhvbSorRTYeWYps/AJPM1NUoKPu5JVhDsvPgdt64euFfHzKiwpV0yE/AGmb5aq7P+k3838tIDQM+AuBffYLkXCTZQjzZq6Na2Bz+/ujV//MRBdm1THdT2a4O9D2nCv0eukjPw0RH04pAYub1gpiRWfb+/TAgAworN2EzUJvX5LGqx7NK+JOXf1RqfGOZo8ReCZ7EQp1RNuKp8nb38oq8iTtqK5Kfcrd392U7hRpyUf9OoKmAQb5KTh6Ss76f4+qnND7UHVKz3lgiO5fBWh5K8l1WtJcFUPCOp3vetIoeVOOTU5UeEoOqBNXbx+cw/TFUpGSKaGajZWi8lXmEl1RiSOkZ7Gt0hgNZaaCt8l64NbuT9gy98o4LJZ6vGR7RXfEzhxbswCX/J8bmpkpqCZiaZTj3I/U2iVRUyhhSXlSJFpbo4Xlii2SZHzxbqD+HXXseBqNhHhJtHI58b06vBCwk2UIzcZdGtaA7WyUuHz+fB/V3fGPQNaBn8TadhGalT1NVMu45sSpMFCXi5pLHxoWFt89KcL8Pw1XYK/8TQ3PNIM1O9W+qlhHcV9NNRIPjfyTuymC5sGn83/xvWynXYQ2YvKShUfuMoDTDEwOzFLqeN/qM1S8mi2dauZCzc++HRXVkwb3QlNa2Vg9HmNFMfVHf9Jjqr8y3v6BD8/cEkrABWO1XpmkpSkBHx5Tx/MHns+mtSsWFGorvMZyUnKtuLjCDfc1PVJSeRrU50EaZTaSbaNIIZys5Qk1Og9M/nt6xVXL+Deor/31y1DanKCLV81+fLpzrIJDg+5k325as8z6V4++pOYLyAA3NqrGQDg4tZ1NGVP5EQoNhMYeU7yNTNTbAemLPcHFP20iObmdHG5IlLygh1HAPBNr0Wlftz41gqs3XcKgDWz1NjezTW/kUMxweW5qzujbnYqXh7TzfK1equljLQaat+DW3s358buSOQIN5JJPSUpAb1b1lZoAtTOwJL2WL1/k/EydfFW0vtc6yusruhaoVn4S79zASjjzzx1RUgjUT0jxTSMvRnyAURkqaVEalKCIu+0JPuam4eHt8M/hrYNfpdmgE9f2QmXd20YfB6A9v3xyElP1vW7kpzTp1/dJajZ46HW3Nw3sCW6NKke/N69WU1snjIET1/ZSXcFVXJiAro0qa5wWFdrJM1mu7f3aWHZPJOSlBB07pRjxzFWQsQspadtlZvwpGel98zk2i69++bFNspOS0LTmtqQFMHfOfGiRJCHnWhg4u81WOZsHmAMqUkJuKhVbfRoVgNNKsNl9G5ZG2/ewo+QrqZPy9pYPmkQ3hl7PjcchJlD8aRhbZGSmICRlZrrnUcKNXnUzEixHZiyLKAMVCiyrLywpBxnZEvS/zGnYksUkaopojWUnlO3pjWw9rFLceMFTc0TjhAk3EQp1/RoghUPD0LHRsazFx56M8a/XtIal7avF1yKLefaHhWzoG4yx03uqovKtOWdonpvEwD47O7e+PcdPTnCTUWrmnOXciNKUTPL1d0bIzMlMTiTV9OMs4GdGS9e1xVrH7sUvc6t0GgYabic+iXIr+aZpcb0rOgc7h/UKjiw9T63Fsb0bKoI8e8krkpSog+1ZTtjS2ndcEFTvHR9N4UZolamgHCTkawbO0Oa/SUk+NCwuv5gpXZy5L2DrNSKlU56gzpP4FMPUhmpiQpziXy7j3dvOx9/H9rG8owzwBgublNHkx/PoVQ4TY5ZSn0vejNruaAlDcB62lx5u9ObFPFWO1VLSzacdPh8PlttUc5d/Vsa/i6vBxWrpXx4//ae+O+4Xoo+8PzKDWzNSPD5UD8nrcK/Rr2oIEG5GKAif+WBOy8+F5unDEG/VnV088hJT3amuZEVS09Q/9ulrYOfC4vLUWzDrAgA1dLNl4LL61XNTOVGyF5rbqIjihjBxZrt3/zcnIxk3VnMPQPORecmOUHHZYAvcEiDToKqY1Fzns5Gk1KnXT8nDV2bVMf6/acAiG8o16NZDTwzuhMYgBnzdmp+txPR1ufzKbQiRmE9nO4h6jMxSz11RUfc3qc5WtbNwl39z4XPF1rlJvfhUK+AkLi2R2P8drgw+Fx5JCX4FB2WWlCSR4kWXa0jF2L/PqRNcFmwvCOXmySb1EzH/hOhFYBqp2M/PypYRfl1zAGSgCFHrWmrk5WK348UBb/L/Q/6t6kLO9TMTEHtrFR8Nb4PGuSENJIiS6Cv6d4Y59bNwjPfb1ccl96JXABWt7Oc9GQc50T0lrdbyX9KLxBftybVsWDHUQAVK+NOc7QNPPNKXkExNz05Iv5aRpxTJxM+n3JwzUhJDGqS5AKI9Gx4faY6yrZEm3rZ2HE4FHNHPlCr0+EJPNygkUkJus7vGSmJSEjwobpt4Ua5kkxPSLp3UCuM7NIQA6YvrNTcaIXsMT2b4uOV+wzzk9KXhBwe6mcgdy/wehNk0tzECUYqYhGSEhMwoE1dxUyxK2f5LW/WLLI3i4S8o5KrdRsJOgInJyYgKTGB21n3bSlmkspKTUJDA5W3kaBlFFSuf5s6eGR4O8O8S2T7AMl9I86pnYm/D2mDxAQfWtXLhq8yQq1ciKkl07bo+dy0qpuN12/ubliGpMQElMjU/+r7PV5YYng9j97n1sLEwa3x1i09cHX30G7W8vokLTEFgO/uu0hxfb5Kc3PktH4Z9Hapv4Szh1k9lc9Q/Zw0xYyS5/Qp187JN2NsVD0d26YOxdKHBuLLe/rg6/F98fGfLwxq1Do3rm4pJtMDl7TCc9d0wbiLz1Ucb1E7E/93VWcAoTg/vC1X9Bw+5XVDaq96AuFz13TBrb2a4fv7L6oI5sk5j6eBknzynrxcf5m/2eRMvdGlmgSfDzVVgolc2JMPrGZ90Df39sXfh7TBqzd0w1/6nYOvxvfB89d2UZwjn7DxzFLqY3oCY4aOuVkSamxrbgIMh06FJgQ84VFqy9JKzMKScmw+qIwqfnX3xpg2mr8AoHW90KIJqX4ZLaTQCDfyiRJpbgg3qJOdim/u7Su0ZFaUpy7viDpZqbi6e2OMfOUXAKoYKNVScbigBH0EhQpAOXv/66Wt8X/fb8fjo9oLr27gbSCYlODDN/f1DS7fbFQ9HQdPafcquvPic3B+s5ro2rQ6/r1sL16ar9X8AMA/hrXF+v2ncHOv5prfzqmTyU0bAF64tqupT448WqjcfPD06E640GSjv1oys5Raq/b2rT0wb9sR3Nyrme5WBhJJCT6Fk6G6k7YSaOy6SnOmz+fD+IEVpkL5Pco78lNnQ1oGtYZNilTt8wEt62Th9r76/jl6VYWnZaqnWsquDlDJW64rl1+byCYN5YEA0lMSkZ6SjobV7a/KA4B5E/pxn3OCD1gwsX/w+4C2dfHhny5Ay7pZuODp+Ypz5ZrPBjlpyM2v0KakKcxSlZobHaG8dlYqplweWsq/9rFL8e3GXDz02abgMbWG49eHBgaDO97cqzkOnirGrEW/y/IMvaDXb+6OO/+9hpu3mUNugq8i8KhcO9WybhYOF5Rorjfb2btjo5ygiX9k5eq9knI/UpISgho2eb1Syy0JPu1qKT0hRS/EgySU59j0ufEHGPYcD+3LxRMeJSdvo5WYwzspF11Uz0gOmoXvHdgK9368DgCQVenT01JWT9V9q3qyWz091P9V+dVSM2fORIsWLZCWlobu3btjyZIlhucvWrQI3bt3R1paGs455xzMmjUrQiWNfjo2ytHEZ3BCjcwUTL6sg8LvR649WDhxAFY+PEjjHGyEvA/qfW5tfDm+L7o3qyl8PS+v8gBD2/rVglqOz+7urTkHqOiMLmlfD7WzUg0bf4OcdCz8+wDcwRlgp1/TBZd3bajxGRLlpgsrVmScUztT0VmKmH/k+zxJGpGs1CR8c29fDGpXD9NGd0JacqLpsv6kRB/XT0riTxedgwcuaYVv7+urOJ6c6MPbt/bAI8PbYd6Efph1U3dM4czc01MS8dNf+2HehIsV96X2q3lnrNZEenmXhpg74WK0rpetWz5eEDI9h2a5cJOU4EPtzFRFp1vIEQTVJr/Jo9ojwQe8eG1X3TJZpWXdbO7gxBuj+7SsjXrV0tCvtdLsJtdUXtO9Mf55ZUd8Nb6PwhcjkaO56duyNl7RWaiQnZYc9L+TeP3m7op216h6uqLuyv23AKWwPKRD/aAPiNnWF2oSVOZiALiwRWgC4OOYpayQmpSIrjKndbnZSb3pZUUQv9Dv9w1sqRvJXb7P1KMj2uG+QRVCv6RZtKu5KfMHcIyjVZW0MM9f0wV1K+s7T9MncVGlT9D7t/fEmJ5N8CdZPze0Y330b1MHN17QNPiO2zcM9f+//GOAon9RL+BwI1yGW3iqufnPf/6DBx54ADNnzkSfPn3w+uuvY9iwYdi6dSuaNtV6Xe/evRvDhw/Hn//8Z3zwwQf49ddfcffdd6NOnTq46qqrPLiDqsP0a7pg66ECXCzrYCtmsdYcW+3GoXn71h7YfaxI4RM05bIOeOKrLbi0vdIcUa9aGoZ1rI/vN+cBCPl3yEP5j+nZFF9tOIQBFv0s6lVLw0vXVwwMd/Y7B4t+OxrcK0dkdcxtfVrg0vb1NCsdRGJWtK2fjYta1UZmShJu69MciQnA7X1bKPw8AGUnnJKYgFJ/AEkJvqDqPsHnM/QHSU9JxAOXtNYcz0lPxqB29TCo0vLWsq6+AMITTtTBwwa2rYcXr+sS3NAPEBPy2tTP1my+2Lw23ywrD0JYPSMFCQk+RcDKBy5pjX9+t00xm31mdCeMnb0K4wdWOLSO7dMCN17YTHgDSYl+retg8W9H0b1ZDazZe9LStTxev6k79hwvwr4TZ7DpQD4GtauLV8Z0w2drD+COvucENQL+AEOvc2opVhvJNaNv3NLdcKWNXHCZPKo9mtfOxMwbz8ONb63A3wZr68XFrevgqW+3Bb+rn9O4/ueiemYKLmpZG499uRm/7DqGyaM6mJqSfD6tv8yF59YC5lZ8LpFt1WLFNK5Ir0VNrNx9AoDyvtViV4AxxYq+uwfoOzs3r52BBjlpaFQ9HTf3aobUpERcd36TYF10Ypa6untj/G/NAVwjM/2O6dkUV3RtpOiLfb6KRQPHCkNlfuPm7mjXoFrw/fRrXQf9WtfBf1aFfG+SExPw7m09Ffme37wGbrigYkGDz+fDxsmDsfNwITYdzMc1PRorzpWbtXir7CKJp8LNCy+8gDvuuAN/+tOfAAAzZszAjz/+iNdeew3Tpk3TnD9r1iw0bdoUM2bMAAC0a9cOq1evxvTp00m4CTNXd28MGLtyGPLZ3b3xr5934ZERxj4pegzi+FPc2rs5+rSshfo5WoHp0ZHtkVdQjNv7tMCAtnVxorAUTWWrNzJTk/DV+L6a66wwaXg7PDSsLa6etQyMMeFl4vJd3e/o2wLHCkvQxkBTIZGQ4FPs4fXIiPbc8+Smv4/+fAE+Xb0fN17QDJf/61cAFYNfqV98MHjtxvMw+est+NcNYjvB68GT/YZ3aoDP1x3C4t8qnFpFhJt3xp6PRz7fhL4tayM3vxgzF/6u60MgX3Yr+cNc2a0R9hwrwsjODTGqS0Nc2r6eQuhuVS8bvz40UJGOVcEGqBhMjheV4psNh4LCTdcm1XH/IO1Kv/YNqmFrboHhNhPpKYlo16Aa2jWoFhTUR3WpuAc5iQk+fPyXCxXH6lVLw50Xn4MaGSlCS4jfuLk75m07jOsrV+91aVIdG58YzF2J2bJuFpITfUFthxQvRiI5MQE3V2os37ylB04UlaJh9XQcNfCrAiqE8KEd6mPu1sOV6fjQpXH14O9nZY6yPVuIrYhSc02PJnj5510AlAJNzxY18cAlrbD8j+M4t04Wzq2TFTT5Jyf6DFd3ZqQk4Zd/VNQfSaiUa770zFZz/9oP4z9apzAByinzBzD18g4Y0qG+ZlNh3iTzkRHtMGfNQfyy6xgA4LxmNRQrLiWu6NYIq/ec1GgGJXw+nyJIZ0ZKEro0qa4I1SAhF0bN3m+48TEnwRgcUFpaioyMDPz3v//FlVdeGTx+//33Y/369Vi0aJHmmn79+qFbt2546aWXgsc+//xzXHvttThz5gySk7UScUlJCUpKQg+5oKAATZo0QX5+PqpVsxcGmyDkSE3I63DjEv4Aw3lPzkUgwLDu8UuRlJiAcn8ALR/5HgCwbepQbMsrwOiZS1EtLQkbJw+JSLl2Hj6Nv/x7De4d2BKjzwvN+ApLyjH4hUU4WliCl67vhuGd9CNcq2GM4Uyp39DX7F8LdmHroQI8cEkrtBIQIt2muMyPF+f9hkvb1UOP5nwT7OGCYny8ch/G9Gyq8ROKBY6eLsGBk2dw6kwZ+raqLSwMfrn+IPYcO4NaWSl49IvNweOpSQnYOnUoEnzAD5vzcE6dLDSukY7M1CQ0f+hbABX+JQk+HzYcOIXhHRvYDpr48cp9WLX7BJ69urOus7rEnmNFyElPRg2H8a5OFJWizB/Ai3N/wyer9uPCc2rik7/0wpfrD+L+T9YDqDAHZqcl4YY3VwAApl7eAbdw/ACNKCn3o82jPyA50YetU4faEtKt8uLc3/Dtplx8emcvx3HB1BQUFCAnJ0do/PZMuDl06BAaNWqEX3/9Fb17h/wXnn76abz33nvYsWOH5prWrVtj7NixePjhh4PHli5dij59+uDQoUNo0EDbKU6ePBlTpkzRHCfhhohniisDd8lnmAdOnkEggKAGa8uhfDSunmHbwdFNyv0BlPmZo/g9RGzz8Oeb8PuRQlzetRFqZaXo7gh/4OQZHCssVfjLxCrFZX78vP0I+raqjWppySgtD+CWd1agTnZa0C/qeGEJ1u07hQFt69raVuJ4YQkYwNXaxBpWhBvPV0upZ7uscmNFK+fzjktMmjQJEyZMCH6XNDcEEc/w1OZycxgAdJA5CnpNUmICHARdJuIAo/3J5DSukaGpy7FKWnKiQlOZkpSAT/6i3OalVlYqLmmvNcuLUisOhBo7eCbc1K5dG4mJicjLy1McP3LkCOrV47/I+vXrc89PSkpCrVr8ZbSpqalITa2aL5cgCIIgqiKeLQVPSUlB9+7dMXfuXMXxuXPnKsxUcnr16qU5/6effkKPHj24/jYEQRAEQVQ9PI1zM2HCBLz11lt45513sG3bNvz1r3/Fvn37MG7cOAAVJqVbbrkleP64ceOwd+9eTJgwAdu2bcM777yDt99+GxMnTvTqFgiCIAiCiDI89bm57rrrcPz4cUydOhW5ubno2LEjvvvuOzRrVrFsMDc3F/v2hdbgt2jRAt999x3++te/4l//+hcaNmyIl19+mZaBEwRBEAQRxLPVUl5hxduaIAiCIIjowMr47fn2CwRBEARBEG5Cwg1BEARBEHEFCTcEQRAEQcQVJNwQBEEQBBFXkHBDEARBEERcQcINQRAEQRBxBQk3BEEQBEHEFSTcEARBEAQRV5BwQxAEQRBEXOHp9gteIAVkLigo8LgkBEEQBEGIIo3bIhsrVDnh5vTp0wCAJk2aeFwSgiAIgiCscvr0aeTk5BieU+X2lgoEAjh06BCys7Ph8/lcS7egoABNmjTB/v37q9yeVXTvVe/eq+p9A3TvdO9V696j6b4ZYzh9+jQaNmyIhARjr5oqp7lJSEhA48aNw5Z+tWrVPK8AXkH3XvXuvareN0D3TvdetYiW+zbT2EiQQzFBEARBEHEFCTcEQRAEQcQVJNy4RGpqKp544gmkpqZ6XZSIQ/de9e69qt43QPdO91617j1W77vKORQTBEEQBBHfkOaGIAiCIIi4goQbgiAIgiDiChJuCIIgCIKIK0i4IQiCIAgiriDhxiVmzpyJFi1aIC0tDd27d8eSJUu8LpIwkydPhs/nU/zVr18/+DtjDJMnT0bDhg2Rnp6O/v37Y8uWLYo0SkpKcO+996J27drIzMzEZZddhgMHDijOOXnyJG6++Wbk5OQgJycHN998M06dOhWJWwyyePFijBo1Cg0bNoTP58MXX3yh+D2S97pv3z6MGjUKmZmZqF27Nu677z6UlpaG47YBmN/72LFjNfXgwgsvVJwTi/c+bdo0nH/++cjOzkbdunVxxRVXYMeOHYpz4vW9i9x7PL731157DZ07dw4GnuvVqxe+//774O/x+r5F7j0e3zcXRjjmk08+YcnJyezNN99kW7duZffffz/LzMxke/fu9bpoQjzxxBOsQ4cOLDc3N/h35MiR4O/PPPMMy87OZnPmzGGbNm1i1113HWvQoAErKCgInjNu3DjWqFEjNnfuXLZ27Vo2YMAA1qVLF1ZeXh48Z+jQoaxjx45s6dKlbOnSpaxjx45s5MiREb3X7777jj3yyCNszpw5DAD7/PPPFb9H6l7Ly8tZx44d2YABA9jatWvZ3LlzWcOGDdn48eM9u/dbb72VDR06VFEPjh8/rjgnFu99yJAhbPbs2Wzz5s1s/fr1bMSIEaxp06assLAweE68vneRe4/H9/7VV1+xb7/9lu3YsYPt2LGDPfzwwyw5OZlt3ryZMRa/71vk3uPxffMg4cYFevbsycaNG6c41rZtW/bQQw95VCJrPPHEE6xLly7c3wKBAKtfvz575plngseKi4tZTk4OmzVrFmOMsVOnTrHk5GT2ySefBM85ePAgS0hIYD/88ANjjLGtW7cyAGz58uXBc5YtW8YAsO3bt4fhrsxRD/CRvNfvvvuOJSQksIMHDwbP+fjjj1lqairLz88Py/3K0RNuLr/8ct1r4uXejxw5wgCwRYsWMcaq1ntX3ztjVee916hRg7311ltV6n1LSPfOWNV532SWckhpaSnWrFmDwYMHK44PHjwYS5cu9ahU1tm5cycaNmyIFi1a4Prrr8cff/wBANi9ezfy8vIU95eamoqLL744eH9r1qxBWVmZ4pyGDRuiY8eOwXOWLVuGnJwcXHDBBcFzLrzwQuTk5ETNc4rkvS5btgwdO3ZEw4YNg+cMGTIEJSUlWLNmTVjv04iFCxeibt26aN26Nf785z/jyJEjwd/i5d7z8/MBADVr1gRQtd67+t4l4vm9+/1+fPLJJygqKkKvXr2q1PtW37tEPL9viSq3cabbHDt2DH6/H/Xq1VMcr1evHvLy8jwqlTUuuOACvP/++2jdujUOHz6Mp556Cr1798aWLVuC98C7v7179wIA8vLykJKSgho1amjOka7Py8tD3bp1NXnXrVs3ap5TJO81Ly9Pk0+NGjWQkpLi2fMYNmwYrrnmGjRr1gy7d+/GY489hoEDB2LNmjVITU2Ni3tnjGHChAno27cvOnbsGCwPEP/vnXfvQPy+902bNqFXr14oLi5GVlYWPv/8c7Rv3z44+Mbz+9a7dyB+37caEm5cwufzKb4zxjTHopVhw4YFP3fq1Am9evXCueeei/feey/oaGbn/tTn8M6PxucUqXuNtudx3XXXBT937NgRPXr0QLNmzfDtt99i9OjRutfF0r2PHz8eGzduxC+//KL5Ld7fu969x+t7b9OmDdavX49Tp05hzpw5uPXWW7Fo0SLdssTT+9a79/bt28ft+1ZDZimH1K5dG4mJiRpJ9MiRIxqpNVbIzMxEp06dsHPnzuCqKaP7q1+/PkpLS3Hy5EnDcw4fPqzJ6+jRo1HznCJ5r/Xr19fkc/LkSZSVlUXN82jQoAGaNWuGnTt3Aoj9e7/33nvx1VdfYcGCBWjcuHHweFV473r3ziNe3ntKSgpatmyJHj16YNq0aejSpQteeumlKvG+9e6dR7y8bzUk3DgkJSUF3bt3x9y5cxXH586di969e3tUKmeUlJRg27ZtaNCgAVq0aIH69esr7q+0tBSLFi0K3l/37t2RnJysOCc3NxebN28OntOrVy/k5+dj5cqVwXNWrFiB/Pz8qHlOkbzXXr16YfPmzcjNzQ2e89NPPyE1NRXdu3cP632Kcvz4cezfvx8NGjQAELv3zhjD+PHj8dlnn+Hnn39GixYtFL/H83s3u3ce8fLe1TDGUFJSEtfvWw/p3nnE6/um1VIuIC0Ff/vtt9nWrVvZAw88wDIzM9mePXu8LpoQf/vb39jChQvZH3/8wZYvX85GjhzJsrOzg+V/5plnWE5ODvvss8/Ypk2b2JgxY7jLJhs3bszmzZvH1q5dywYOHMhdOti5c2e2bNkytmzZMtapU6eILwU/ffo0W7duHVu3bh0DwF544QW2bt264LL9SN2rtExy0KBBbO3atWzevHmscePGYV0maXTvp0+fZn/729/Y0qVL2e7du9mCBQtYr169WKNGjWL+3u+66y6Wk5PDFi5cqFj+eubMmeA58freze49Xt/7pEmT2OLFi9nu3bvZxo0b2cMPP8wSEhLYTz/9xBiL3/dtdu/x+r55kHDjEv/6179Ys2bNWEpKCjvvvPMUSy2jHSnGQ3JyMmvYsCEbPXo027JlS/D3QCDAnnjiCVa/fn2WmprK+vXrxzZt2qRI4+zZs2z8+PGsZs2aLD09nY0cOZLt27dPcc7x48fZjTfeyLKzs1l2dja78cYb2cmTJyNxi0EWLFjAAGj+br31VsZYZO917969bMSIESw9PZ3VrFmTjR8/nhUXF3ty72fOnGGDBw9mderUYcnJyaxp06bs1ltv1dxXLN47754BsNmzZwfPidf3bnbv8freb7/99mB/XKdOHTZo0KCgYMNY/L5vs3uP1/fNw8cYY+HXDxEEQRAEQUQG8rkhCIIgCCKuIOGGIAiCIIi4goQbgiAIgiDiChJuCIIgCIKIK0i4IQiCIAgiriDhhiAIgiCIuIKEG4IgCIIg4goSbgiCIAiCiCtIuCEIIuYYO3YsrrjiCq+LQRBElELCDUEQBEEQcQUJNwRBRC3/+9//0KlTJ6Snp6NWrVq45JJL8Pe//x3vvfcevvzyS/h8Pvh8PixcuBAAcPDgQVx33XWoUaMGatWqhcsvvxx79uwJpidpfKZMmYK6deuiWrVquPPOO1FaWurNDRIEERaSvC4AQRAEj9zcXIwZMwbPPvssrrzySpw+fRpLlizBLbfcgn379qGgoACzZ88GANSsWRNnzpzBgAEDcNFFF2Hx4sVISkrCU089haFDh2Ljxo1ISUkBAMyfPx9paWlYsGAB9uzZg9tuuw21a9fGP//5Ty9vlyAIFyHhhiCIqCQ3Nxfl5eUYPXo0mjVrBgDo1KkTACA9PR0lJSWoX79+8PwPPvgACQkJeOutt+Dz+QAAs2fPRvXq1bFw4UIMHjwYAJCSkoJ33nkHGRkZ6NChA6ZOnYq///3vePLJJ5GQQMpsgogHqCUTBBGVdOnSBYMGDUKnTp1wzTXX4M0338TJkyd1z1+zZg127dqF7OxsZGVlISsrCzVr1kRxcTF+//13RboZGRnB77169UJhYSH2798f1vshCCJykOaGIIioJDExEXPnzsXSpUvx008//X+79uuiaBCAcfyxCIKYNCloMVj1bYIIJtOCSbAI1gWjYWE12QTBv8FgUZtRV4svWDQsbBIWmwZRQVTUS7ew3B1Xbldv+H7qDPOjPTwzajQaenp6km3bv51/uVwUi8XUbDZ/GfP5fH/d72fbA+D/R7gBcLccDofi8bji8bien58VDAbV6XTkdDp1Pp8/zY1Go2q1Wh8fhf9kOp1qv9/L5XJJksbjsdxutwKBwJfeBcD34VkKwF2ybVvValWTyUTv7+9qt9taLpeKRCIKhUKazWZ6e3vTarXS6XRSLpeT1+vVw8ODRqOR5vO5Xl5eVCwWtVgsPtY9Ho8qFAp6fX1Vr9dTuVzW4+Mj/20Ag9DcALhLHo9Hw+FQ9Xpdm81GwWBQtVpN6XRalmVpMBjIsiztdjv1+30lk0kNh0OVSiVlMhltt1v5/X6lUqlPTU4qlVI4HFYikdDhcFA2m1WlUrndRQH8c47r9Xq99SEA4Dvk83mt12t1u91bHwXAF6KHBQAARiHcAAAAo/AsBQAAjEJzAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACM8gOrKwnmXwe6gQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "trainer, model = build_trainer(rpu_config, log=\"mp\")\n", "fit_model(trainer, model)\n", diff --git a/notebooks/tutorial/hw_aware_training.ipynb b/notebooks/tutorial/hw_aware_training.ipynb index fb5b9f75..c4baf281 100644 --- a/notebooks/tutorial/hw_aware_training.ipynb +++ b/notebooks/tutorial/hw_aware_training.ipynb @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "cellView": "form", "id": "8dRBAFI2xcEK", @@ -321,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "id": "9m1qDEsd-C4H" }, @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "DHmjiuKn-C4O" }, @@ -426,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "6_She6Vv-C4P" }, @@ -476,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -484,7 +484,16 @@ "id": "P0-82vyr-C4Q", "outputId": "05431c47-efa4-4ea6-e759-5e3b5b93f66b" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], "source": [ "# - Set seeds\n", "torch.manual_seed(0)\n", @@ -508,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "aG-rrTt5-C4R" }, @@ -535,7 +544,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -543,7 +552,27 @@ "id": "L_Cvn56G-C4R", "outputId": "bd54f7a1-a836-4b27-b627-eb18b524dd14" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-18 19:52:21-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/pre_trained_model.th\n", + "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", + "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1928757 (1.8M) [application/octet-stream]\n", + "Saving to: ‘Models/pre_trained_model.th’\n", + "\n", + "pre_trained_model.t 100%[===================>] 1.84M 2.03MB/s in 0.9s \n", + "\n", + "2024-09-18 19:52:23 (2.03 MB/s) - ‘Models/pre_trained_model.th’ saved [1928757/1928757]\n", + "\n", + "Test loss 0.0016 test acc. 94.12%\n", + "Pretrained test acc. 94.12%\n" + ] + } + ], "source": [ "# - Pre-training of the network\n", "if retrain_baseline:\n", @@ -573,7 +602,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -581,7 +610,38 @@ "id": "CF6ddwgw-C4S", "outputId": "17dbd555-d243-4cac-eed6-c8652d8e79bb" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-18 19:52:32-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/test_accs.th\n", + "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", + "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1521 (1.5K) [application/octet-stream]\n", + "Saving to: ‘Models/test_accs.th’\n", + "\n", + "test_accs.th 100%[===================>] 1.49K --.-KB/s in 0s \n", + "\n", + "2024-09-18 19:52:32 (1.57 GB/s) - ‘Models/test_accs.th’ saved [1521/1521]\n", + "\n", + "--2024-09-18 19:52:33-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/finetuned_model_0.9.1.th\n", + "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", + "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3940538 (3.8M) [application/octet-stream]\n", + "Saving to: ‘Models/finetuned_model_0.9.1.th’\n", + "\n", + "finetuned_model_0.9 100%[===================>] 3.76M 3.81MB/s in 1.0s \n", + "\n", + "2024-09-18 19:52:35 (3.81 MB/s) - ‘Models/finetuned_model_0.9.1.th’ saved [3940538/3940538]\n", + "\n", + "Test loss 0.0018 test acc. 94.34%\n", + "Finetuned test acc. 94.34%\n" + ] + } + ], "source": [ "# - Fine-tuning\n", "analog_model = convert_to_analog(model, gen_rpu_config())\n", @@ -623,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "cellView": "form", "id": "JRMIngM203Ph", @@ -687,7 +747,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -696,7 +756,18 @@ "id": "Lxm4YHJz-C4T", "outputId": "4037e66a-aeb9-4a3b-e691-9d41cc98f9ad" }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.title(\"Finetunig test accuracy\")\n", "plt.plot(test_accs, marker=\"d\", linestyle=\"--\", color=\"b\")\n", @@ -716,7 +787,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -725,7 +796,18 @@ "id": "RMHdErKQ-C4U", "outputId": "5634dc2f-15bb-407c-f9e9-757497359c71" }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "w, _ = (\n", " analog_model\n", @@ -750,7 +832,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -759,7 +841,74 @@ "id": "uAF1fy68-C4V", "outputId": "c5e5762b-cb7b-4dba-8ff9-a33bdd885468" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test loss 0.0033 test acc. 88.78%\n", + "Test loss 0.0019 test acc. 93.97%\n", + "Test loss 0.0036 test acc. 87.66%\n", + "Test loss 0.0019 test acc. 93.68%\n", + "Test loss 0.0032 test acc. 88.64%\n", + "Test loss 0.0019 test acc. 93.72%\n", + "Test loss 0.0031 test acc. 89.45%\n", + "Test loss 0.0019 test acc. 93.63%\n", + "Test loss 0.0036 test acc. 87.65%\n", + "Test loss 0.0019 test acc. 93.54%\n", + "Test loss 0.0036 test acc. 87.44%\n", + "Test loss 0.0020 test acc. 93.22%\n", + "Test loss 0.0034 test acc. 88.21%\n", + "Test loss 0.0020 test acc. 93.36%\n", + "Test loss 0.0040 test acc. 87.01%\n", + "Test loss 0.0020 test acc. 93.37%\n", + "Test loss 0.0036 test acc. 87.88%\n", + "Test loss 0.0020 test acc. 93.36%\n", + "Test loss 0.0042 test acc. 86.62%\n", + "Test loss 0.0020 test acc. 93.36%\n", + "Test loss 0.0057 test acc. 82.82%\n", + "Test loss 0.0020 test acc. 93.26%\n", + "Test loss 0.0048 test acc. 84.68%\n", + "Test loss 0.0021 test acc. 92.89%\n", + "Test loss 0.0051 test acc. 83.34%\n", + "Test loss 0.0021 test acc. 92.76%\n", + "Test loss 0.0050 test acc. 83.18%\n", + "Test loss 0.0021 test acc. 92.90%\n", + "Test loss 0.0050 test acc. 83.71%\n", + "Test loss 0.0021 test acc. 92.72%\n", + "Test loss 0.0069 test acc. 78.54%\n", + "Test loss 0.0025 test acc. 91.39%\n", + "Test loss 0.0065 test acc. 79.48%\n", + "Test loss 0.0025 test acc. 91.97%\n", + "Test loss 0.0076 test acc. 76.09%\n", + "Test loss 0.0024 test acc. 91.88%\n", + "Test loss 0.0059 test acc. 80.29%\n", + "Test loss 0.0025 test acc. 91.81%\n", + "Test loss 0.0074 test acc. 78.20%\n", + "Test loss 0.0023 test acc. 92.37%\n", + "Test loss 0.0088 test acc. 73.72%\n", + "Test loss 0.0029 test acc. 90.65%\n", + "Test loss 0.0087 test acc. 72.81%\n", + "Test loss 0.0025 test acc. 91.41%\n", + "Test loss 0.0107 test acc. 68.39%\n", + "Test loss 0.0026 test acc. 91.45%\n", + "Test loss 0.0077 test acc. 75.68%\n", + "Test loss 0.0025 test acc. 91.74%\n", + "Test loss 0.0088 test acc. 73.60%\n", + "Test loss 0.0025 test acc. 91.80%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "converted_model = convert_to_analog(model, StandardHWATrainingPreset())\n", "# - For programming the model, we need to put it into eval() mode\n", diff --git a/src/aihwkit/inference/noise/pcm.py b/src/aihwkit/inference/noise/pcm.py index bbe7176e..d0da6c19 100644 --- a/src/aihwkit/inference/noise/pcm.py +++ b/src/aihwkit/inference/noise/pcm.py @@ -15,7 +15,7 @@ """Phenomenological noise models for PCM devices for inference.""" from copy import deepcopy -from typing import List, Optional +from typing import List, Optional, Any from numpy import log as numpy_log from numpy import sqrt, interp @@ -39,7 +39,7 @@ class PCMLikeNoiseModel(BaseNoiseModel): r"""Noise model that was fitted and characterized on real PCM devices. Expected weight noise at assumed time of inference with expected - programming noise at 0. +/dccstor/transformer/charles/aihwkit/src/aihwkit/utils programming noise at 0. The statistical noise model is based on measured PCM devices. See also `Nandakumar et al. ICECS (2019)`_ @@ -83,6 +83,7 @@ def __init__( read_noise_scale: float = 1.0, drift_scale: float = 1.0, prog_coeff_g_max_reference: Optional[float] = None, + **kwargs: Any, ): g_converter = deepcopy(g_converter) or SinglePairConductanceConverter(g_max=g_max) super().__init__(g_converter) @@ -107,6 +108,34 @@ def __init__( self.prog_noise_scale = prog_noise_scale self.read_noise_scale = read_noise_scale self.drift_scale = drift_scale + self.valid_kwargs = ['custom_drift_model'] + + if not all(key in self.valid_kwargs for key in kwargs): + ValueError("PCMLikeNoiseModel only supports kwargs = %s" % self.valid_kwargs) + + self.custom_drift_model = kwargs.get('custom_drift_model') + + if self.custom_drift_model is not None: + drift_model_g_min = min(self.custom_drift_model['g_lst']) + drift_model_g_max = max(self.custom_drift_model['g_lst']) + # using Single/Dual/NPairConductanceConverter + if hasattr(g_converter, 'g_min') and hasattr(g_converter, 'g_max'): + g_converter_g_min = g_converter.g_min + g_converter_g_max = g_converter.g_max + # using CustomPairConductanceConverter + elif hasattr(g_converter, 'g_lst'): + g_converter_g_min = min(min(gs)for gs in g_converter.g_lst) + g_converter_g_max = max(max(gs)for gs in g_converter.g_lst) + else: + raise ValueError("Unsupported g_converter and drift model combination.") + + if g_converter_g_min < drift_model_g_min or g_converter_g_max > drift_model_g_max: + raise ValueError("g_converter producing conductances " + "(g_min = %0.3f, g_max = %0.3f) " + "outside the range of the custom drift model " + "(g_min = %0.3f, g_max = %0.3f)" + % (g_converter_g_min, g_converter_g_max, + drift_model_g_min, drift_model_g_max)) @no_grad() def apply_programming_noise_to_conductance(self, g_target: Tensor) -> Tensor: @@ -130,13 +159,62 @@ def apply_programming_noise_to_conductance(self, g_target: Tensor) -> Tensor: @no_grad() def generate_drift_coefficients(self, g_target: Tensor) -> Tensor: - """Return drift coefficients ``nu`` based on PCM measurements.""" - g_relative = clamp(torch_abs(g_target / self.g_max), min=_ZERO_CLIP) + """Return drift coefficients ``nu`` based on custom drift model. + Drift model must be speicified as a dictionary containing three lists: + g_lst, a list of conductances in ascending order; nu_mean_lst, a list + of mean drift coefficients corresponding to the g_lst values: and + nu_std_lst, a list of nu standard deviation values corresponding to + the g_lst values. Nu coeffiecients will be interpolated using this + model information.""" + + if self.custom_drift_model is not None: + assert isinstance(self.custom_drift_model, + dict), "custom_drift_model must be specified as dictionary" + required_keys = ['g_lst', 'nu_mean_lst', 'nu_std_lst'] + assert all(key in required_keys for key in + self.custom_drift_model), ("Missing required key in custom_drift_model: " + "g_lst, nu_mean_lst, nu_std_lst") + assert all(isinstance(val, List) for _, val in + self.custom_drift_model.items()), ("Value corresponding to each key in " + "custom_drift_model must be a list") + assert all(len(val) >= 2 for _, val in + self.custom_drift_model.items()), ("Each key in custom_drift_model must" + "have at least 2 elements") + + g_lst = Tensor(self.custom_drift_model.get('g_lst')) + nu_mean_lst = Tensor(self.custom_drift_model.get('nu_mean_lst')) + nu_std_lst = Tensor(self.custom_drift_model.get('nu_std_lst')) + + g_min = torch_min(g_lst) + g_max = torch_max(g_lst) + + g_target[g_target > g_max] = g_max # clip G values to g_max + g_target[g_target < g_min] = g_min # clip G values to g_min + + assert (g_target >= g_min).all(), "All G values must be >= g_min" + assert (g_target <= g_max).all(), "All G values must be <= g_max" + assert (g_lst >= 0).all(), "All values specified in g_lst must be > 0" + assert (nu_std_lst >= 0).all(), "All values specified in nu_std_lst must be > 0" + assert equal(torch_sort(g_lst)[0], g_lst), "Values in g_lst must be in ascending order" + + nu_mean = from_numpy(interp(g_target.numpy(), + g_lst.numpy(), + nu_mean_lst.numpy())).float() + nu_std = from_numpy(interp(g_target.numpy(), + g_lst.numpy(), + nu_std_lst.numpy())).float() + + nu_drift = torch_abs(nu_mean + nu_std * randn_like(g_target)) + + nu_drift[nu_drift < 0] = 0. - # gt should be normalized wrt g_max - mu_drift = (-0.0155 * log(g_relative) + 0.0244).clamp(min=0.049, max=0.1) - sig_drift = (-0.0125 * log(g_relative) - 0.0059).clamp(min=0.008, max=0.045) - nu_drift = torch_abs(mu_drift + sig_drift * randn_like(g_relative)).clamp(min=0.0) + else: + g_relative = clamp(torch_abs(g_target / self.g_max), min=_ZERO_CLIP) + + # gt should be normalized wrt g_max + mu_drift = (-0.0155 * log(g_relative) + 0.0244).clamp(min=0.049, max=0.1) + sig_drift = (-0.0125 * log(g_relative) - 0.0059).clamp(min=0.008, max=0.045) + nu_drift = torch_abs(mu_drift + sig_drift * randn_like(g_relative)).clamp(min=0.0) return nu_drift * self.drift_scale @@ -275,6 +353,9 @@ def generate_drift_coefficients(self, g_target: Tensor) -> Tensor: """Returns drift coefficients ``nu`` based on custom drift model. Nu coeffiecients will be interpolated using this model information.""" + if self.custom_drift_model is None: + raise ValueError("custom_drift_model is not set.") + g_lst = Tensor(self.custom_drift_model.get('g_lst')) nu_mean_lst = Tensor(self.custom_drift_model.get('nu_mean_lst')) nu_std_lst = Tensor(self.custom_drift_model.get('nu_std_lst')) From eb1b1d230d4d05f246cc10acc610dc288b9027c8 Mon Sep 17 00:00:00 2001 From: pablocarmona Date: Thu, 10 Oct 2024 11:08:26 +0200 Subject: [PATCH 07/14] Feat adv install 0.9.2 (#694) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add release content for 0.9.2 * feat(notebooks/tutorial): add notebook outputs for reference * fix(pcm.py): add a check to not get custom_drift_model as None * fix(travis/build): fix proper version for pytorch on mac osx wheel build * fix(travis/build): fix torch version to match compatibility with osx version * feat(docs): update advance install docs to match different GPU versions Signed-off-by: Pablo Carmona González --- docs/source/advanced_install.rst | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/docs/source/advanced_install.rst b/docs/source/advanced_install.rst index cfd51284..642d3c3a 100644 --- a/docs/source/advanced_install.rst +++ b/docs/source/advanced_install.rst @@ -28,13 +28,29 @@ AIHWKIT can also be installed using pip commands as shown below. $ pip install aihwkit - - GPU:: + - GPU: - $ wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.8.0+cuda117-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + To install the GPU version, select the appropriate combination of Python and CUDA versions: - then:: - - $ pip install aihwkit-0.8.0+cuda117-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - For Python 3.9 and CUDA 11.8:: + + $ wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.9.2+cuda118-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + $ pip install aihwkit-0.9.2+cuda118-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + + - For Python 3.9 and CUDA 12.1:: + + $ wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.9.2+cuda121-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + $ pip install aihwkit-0.9.2+cuda121-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + + - For Python 3.10 and CUDA 11.8:: + + $ wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.9.2+cuda118-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + $ pip install aihwkit-0.9.2+cuda118-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + + - For Python 3.10 and CUDA 12.1:: + + $ wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.9.2+cuda121-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + $ pip install aihwkit-0.9.2+cuda121-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl .. note:: From 030f38a9038119957c2b49b1a7eb266b412d1993 Mon Sep 17 00:00:00 2001 From: pablocarmona Date: Fri, 25 Oct 2024 11:06:05 +0200 Subject: [PATCH 08/14] License changes (#696) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add release content for 0.9.2 * feat(notebooks/tutorial): add notebook outputs for reference * fix(pcm.py): add a check to not get custom_drift_model as None * fix(travis/build): fix proper version for pytorch on mac osx wheel build * fix(travis/build): fix torch version to match compatibility with osx version * feat(license): change LICENSE.txt and license references to MIT License * fix(array.py): add temporal ignore to bypass pylint * fix: pycodestyle errors Signed-off-by: Pablo Carmona González --- .github/CONTRIBUTING.md | 4 +- .travis.yml | 8 +- CMakeLists.txt | 8 +- LICENSE.txt | 223 ++---------------- Makefile | 8 +- README.md | 4 +- cmake/Modules/FindAVX.cmake | 12 +- cmake/Modules/FindCUB.cmake | 8 +- cmake/Modules/FindMKL.cmake | 12 +- cmake/Modules/FindOpenBLAS.cmake | 12 +- cmake/Modules/FindTorch.cmake | 8 +- cmake/dependencies.cmake | 8 +- cmake/dependencies_cuda.cmake | 8 +- cmake/dependencies_test.cmake | 8 +- examples/01_simple_layer.py | 8 +- examples/02_multiple_layer.py | 8 +- examples/03_mnist_training.py | 8 +- examples/04_lenet5_training.py | 8 +- examples/05_simple_layer_hardware_aware.py | 8 +- examples/06_lenet5_hardware_aware.py | 8 +- .../07_simple_layer_with_other_devices.py | 8 +- examples/08_simple_layer_with_tiki_taka.py | 8 +- .../09_simple_layer_deterministic_pulses.py | 8 +- examples/10_plot_presets.py | 8 +- examples/11_vgg8_training.py | 8 +- .../12_simple_layer_with_mixed_precision.py | 8 +- examples/13_experiment_3fc.py | 8 +- examples/14_experiment_custom_scheduler.py | 8 +- examples/15_simple_rnn.py | 8 +- examples/16_mnist_gan.py | 8 +- ..._resnet34_imagenet_conversion_to_analog.py | 8 +- examples/18_cifar10_on_resnet.py | 8 +- examples/20_mnist_ddp.py | 8 +- examples/21_fit_device_data.py | 8 +- examples/22_war_and_peace_lstm.py | 8 +- examples/23_using_analog_tile_as_matrix.py | 8 +- examples/24_bert_on_squad.py | 8 +- .../25_torch_tile_lenet5_hardware_aware.py | 8 +- examples/26_correlation_detection.py | 8 +- examples/27_input_range_calibration.py | 8 +- examples/28_advanced_irdrop.py | 8 +- examples/29_linalg_krylov.py | 8 +- examples/30_external_hardware_aware_model.py | 8 +- examples/31_custom_drift_models.py | 8 +- examples/32_weight_programming_options.py | 8 +- notebooks/README.md | 12 +- setup.py | 12 +- src/aihwkit/__init__.py | 8 +- src/aihwkit/cloud/__init__.py | 8 +- src/aihwkit/cloud/client/__init__.py | 8 +- src/aihwkit/cloud/client/entities.py | 8 +- src/aihwkit/cloud/client/exceptions.py | 8 +- src/aihwkit/cloud/client/session.py | 8 +- src/aihwkit/cloud/client/utils.py | 8 +- src/aihwkit/cloud/client/v1/__init__.py | 8 +- src/aihwkit/cloud/client/v1/api_client.py | 8 +- src/aihwkit/cloud/client/v1/i_api_client.py | 8 +- src/aihwkit/cloud/client/v1/parsers.py | 8 +- src/aihwkit/cloud/client/v1/stubs.py | 8 +- src/aihwkit/cloud/converter/__init__.py | 8 +- .../cloud/converter/definitions/__init__.py | 8 +- src/aihwkit/cloud/converter/exceptions.py | 8 +- src/aihwkit/cloud/converter/v1/__init__.py | 8 +- src/aihwkit/cloud/converter/v1/analog_info.py | 8 +- src/aihwkit/cloud/converter/v1/i_mappings.py | 8 +- src/aihwkit/cloud/converter/v1/inferencing.py | 8 +- src/aihwkit/cloud/converter/v1/mappings.py | 8 +- .../cloud/converter/v1/noise_model_info.py | 8 +- .../cloud/converter/v1/rpu_config_info.py | 8 +- src/aihwkit/cloud/converter/v1/training.py | 8 +- src/aihwkit/exceptions.py | 8 +- src/aihwkit/experiments/__init__.py | 8 +- .../experiments/experiments/__init__.py | 8 +- src/aihwkit/experiments/experiments/base.py | 8 +- .../experiments/experiments/inferencing.py | 8 +- .../experiments/experiments/training.py | 8 +- src/aihwkit/experiments/runners/__init__.py | 8 +- src/aihwkit/experiments/runners/base.py | 8 +- src/aihwkit/experiments/runners/cloud.py | 8 +- src/aihwkit/experiments/runners/i_cloud.py | 8 +- src/aihwkit/experiments/runners/i_local.py | 8 +- src/aihwkit/experiments/runners/i_metrics.py | 8 +- src/aihwkit/experiments/runners/local.py | 8 +- src/aihwkit/experiments/runners/metrics.py | 8 +- src/aihwkit/extension/CMakeLists.txt | 8 +- src/aihwkit/extension/__init__.py | 8 +- .../extension_src/aihwkit_extension.cpp | 8 +- .../extension_src/aihwkit_extension.h | 8 +- .../extension_src/ops/float_prec_op.cpp | 8 +- .../extension_src/ops/float_prec_op.cu | 8 +- .../extension_src/ops/float_prec_op.h | 8 +- .../extension_src/ops/thevenin_equiv_op.cpp | 8 +- .../extension_src/ops/thevenin_equiv_op.cu | 8 +- .../extension_src/ops/thevenin_equiv_op.h | 8 +- src/aihwkit/extension/functions.py | 8 +- src/aihwkit/inference/__init__.py | 8 +- src/aihwkit/inference/calibration/__init__.py | 8 +- .../inference/calibration/calibration.py | 8 +- .../inference/compensation/__init__.py | 8 +- src/aihwkit/inference/compensation/base.py | 8 +- src/aihwkit/inference/compensation/drift.py | 8 +- src/aihwkit/inference/converter/__init__.py | 8 +- src/aihwkit/inference/converter/base.py | 8 +- .../inference/converter/conductance.py | 8 +- src/aihwkit/inference/converter/fusion.py | 8 +- src/aihwkit/inference/noise/__init__.py | 8 +- src/aihwkit/inference/noise/base.py | 8 +- src/aihwkit/inference/noise/custom.py | 8 +- src/aihwkit/inference/noise/hermes.py | 8 +- src/aihwkit/inference/noise/pcm.py | 8 +- src/aihwkit/inference/noise/reram.py | 8 +- src/aihwkit/inference/utils.py | 8 +- src/aihwkit/linalg/__init__.py | 8 +- src/aihwkit/linalg/matrix.py | 8 +- src/aihwkit/nn/__init__.py | 8 +- src/aihwkit/nn/conversion.py | 8 +- src/aihwkit/nn/modules/__init__.py | 8 +- src/aihwkit/nn/modules/base.py | 8 +- src/aihwkit/nn/modules/container.py | 8 +- src/aihwkit/nn/modules/conv.py | 8 +- src/aihwkit/nn/modules/conv_mapped.py | 8 +- src/aihwkit/nn/modules/linear.py | 8 +- src/aihwkit/nn/modules/linear_mapped.py | 8 +- src/aihwkit/nn/modules/rnn/__init__.py | 8 +- src/aihwkit/nn/modules/rnn/cells.py | 8 +- src/aihwkit/nn/modules/rnn/layers.py | 8 +- src/aihwkit/nn/modules/rnn/rnn.py | 8 +- src/aihwkit/optim/__init__.py | 8 +- src/aihwkit/optim/analog_optimizer.py | 8 +- src/aihwkit/optim/context.py | 8 +- src/aihwkit/simulator/CMakeLists.txt | 8 +- src/aihwkit/simulator/__init__.py | 8 +- src/aihwkit/simulator/configs/__init__.py | 8 +- src/aihwkit/simulator/configs/compounds.py | 8 +- src/aihwkit/simulator/configs/configs.py | 8 +- src/aihwkit/simulator/configs/devices.py | 8 +- src/aihwkit/simulator/configs/helpers.py | 8 +- src/aihwkit/simulator/configs/utils.py | 8 +- src/aihwkit/simulator/noise_models.py | 8 +- src/aihwkit/simulator/parameters/__init__.py | 8 +- src/aihwkit/simulator/parameters/base.py | 8 +- src/aihwkit/simulator/parameters/enums.py | 8 +- src/aihwkit/simulator/parameters/helpers.py | 8 +- src/aihwkit/simulator/parameters/inference.py | 8 +- src/aihwkit/simulator/parameters/io.py | 8 +- src/aihwkit/simulator/parameters/mapping.py | 8 +- src/aihwkit/simulator/parameters/pre_post.py | 8 +- src/aihwkit/simulator/parameters/runtime.py | 8 +- src/aihwkit/simulator/parameters/training.py | 8 +- src/aihwkit/simulator/presets/__init__.py | 8 +- src/aihwkit/simulator/presets/compounds.py | 8 +- src/aihwkit/simulator/presets/configs.py | 8 +- src/aihwkit/simulator/presets/devices.py | 8 +- src/aihwkit/simulator/presets/inference.py | 8 +- src/aihwkit/simulator/presets/utils.py | 8 +- src/aihwkit/simulator/presets/web.py | 8 +- .../simulator/rpu_base_src/rpu_base.cpp | 8 +- src/aihwkit/simulator/rpu_base_src/rpu_base.h | 8 +- .../rpu_base_src/rpu_base_devices.cpp | 8 +- .../simulator/rpu_base_src/rpu_base_tiles.cpp | 8 +- .../rpu_base_src/rpu_base_tiles_cuda.cpp | 8 +- .../simulator/rpu_base_src/rpu_base_utils.cpp | 8 +- src/aihwkit/simulator/tiles/__init__.py | 8 +- src/aihwkit/simulator/tiles/analog.py | 8 +- src/aihwkit/simulator/tiles/analog_mvm.py | 8 +- .../simulator/tiles/analog_mvm_irdrop_t.py | 8 +- src/aihwkit/simulator/tiles/array.py | 10 +- src/aihwkit/simulator/tiles/base.py | 8 +- src/aihwkit/simulator/tiles/custom.py | 8 +- src/aihwkit/simulator/tiles/floating_point.py | 8 +- src/aihwkit/simulator/tiles/functions.py | 8 +- src/aihwkit/simulator/tiles/inference.py | 8 +- .../simulator/tiles/inference_torch.py | 8 +- src/aihwkit/simulator/tiles/module.py | 8 +- src/aihwkit/simulator/tiles/periphery.py | 8 +- src/aihwkit/simulator/tiles/rpucuda.py | 8 +- src/aihwkit/simulator/tiles/torch_tile.py | 8 +- .../simulator/tiles/torch_tile_irdrop_t.py | 8 +- src/aihwkit/simulator/tiles/transfer.py | 8 +- src/aihwkit/simulator/tiles/utils.py | 8 +- src/aihwkit/utils/__init__.py | 8 +- src/aihwkit/utils/analog_info.py | 8 +- src/aihwkit/utils/export.py | 8 +- src/aihwkit/utils/fitting.py | 8 +- src/aihwkit/utils/legacy.py | 8 +- src/aihwkit/utils/visualization.py | 8 +- src/aihwkit/utils/visualization_web.py | 8 +- src/aihwkit/version.py | 8 +- src/rpucuda/CMakeLists.txt | 8 +- src/rpucuda/cuda/CMakeLists.txt | 8 +- src/rpucuda/cuda/bit_line_maker.cu | 8 +- src/rpucuda/cuda/bit_line_maker.h | 8 +- src/rpucuda/cuda/bit_line_maker_test.cpp | 8 +- src/rpucuda/cuda/chopped_weight_output.cu | 8 +- src/rpucuda/cuda/chopped_weight_output.h | 8 +- src/rpucuda/cuda/cuda_buffer.cu | 8 +- src/rpucuda/cuda/cuda_buffer.h | 8 +- src/rpucuda/cuda/cuda_fp16_util.h | 8 +- src/rpucuda/cuda/cuda_math_util.cu | 8 +- src/rpucuda/cuda/cuda_math_util.h | 8 +- src/rpucuda/cuda/cuda_util.cu | 8 +- src/rpucuda/cuda/cuda_util.h | 8 +- src/rpucuda/cuda/forward_backward_pass.cu | 8 +- src/rpucuda/cuda/forward_backward_pass.h | 8 +- .../cuda/forward_backward_pass_test.cpp | 8 +- src/rpucuda/cuda/io_iterator.h | 8 +- src/rpucuda/cuda/io_iterator_test.cpp | 8 +- src/rpucuda/cuda/io_manager.cu | 8 +- src/rpucuda/cuda/io_manager.h | 8 +- src/rpucuda/cuda/io_manager_test.cpp | 8 +- src/rpucuda/cuda/maximizer.cu | 8 +- src/rpucuda/cuda/maximizer.h | 8 +- src/rpucuda/cuda/maximizer_test.cpp | 8 +- src/rpucuda/cuda/noise_manager.cu | 8 +- src/rpucuda/cuda/noise_manager.h | 8 +- src/rpucuda/cuda/pulsed_weight_updater.cu | 8 +- src/rpucuda/cuda/pulsed_weight_updater.h | 8 +- .../cuda/pulsed_weight_updater_test.cpp | 8 +- src/rpucuda/cuda/pwu_kernel.h | 8 +- src/rpucuda/cuda/pwu_kernel_parameter.h | 8 +- src/rpucuda/cuda/pwu_kernel_parameter_base.h | 8 +- src/rpucuda/cuda/rpu_cub.h | 8 +- src/rpucuda/cuda/rpucuda.cu | 8 +- src/rpucuda/cuda/rpucuda.h | 8 +- .../cuda/rpucuda_buffered_transfer_device.cu | 8 +- .../cuda/rpucuda_buffered_transfer_device.h | 8 +- .../rpucuda_buffered_transfer_device_test.cpp | 8 +- .../cuda/rpucuda_chopped_transfer_device.cu | 8 +- .../cuda/rpucuda_chopped_transfer_device.h | 8 +- .../rpucuda_chopped_transfer_device_test.cpp | 8 +- .../cuda/rpucuda_constantstep_device.cu | 8 +- .../cuda/rpucuda_constantstep_device.h | 8 +- .../cuda/rpucuda_dynamic_transfer_device.cu | 8 +- .../cuda/rpucuda_dynamic_transfer_device.h | 8 +- src/rpucuda/cuda/rpucuda_expstep_device.cu | 8 +- src/rpucuda/cuda/rpucuda_expstep_device.h | 8 +- src/rpucuda/cuda/rpucuda_expstep_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_hidden_device.cu | 8 +- src/rpucuda/cuda/rpucuda_hidden_device.h | 8 +- src/rpucuda/cuda/rpucuda_hidden_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_linearstep_device.cu | 8 +- src/rpucuda/cuda/rpucuda_linearstep_device.h | 8 +- src/rpucuda/cuda/rpucuda_linearstep_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_mixedprec_device.cu | 8 +- src/rpucuda/cuda/rpucuda_mixedprec_device.h | 8 +- .../cuda/rpucuda_mixedprec_device_base.cu | 8 +- .../cuda/rpucuda_mixedprec_device_base.h | 8 +- .../cuda/rpucuda_mixedprec_device_test.cpp | 8 +- .../cuda/rpucuda_mixedprec_int_device.cu | 8 +- .../cuda/rpucuda_mixedprec_int_device.h | 8 +- .../rpucuda_mixedprec_int_device_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_onesided_device.cu | 8 +- src/rpucuda/cuda/rpucuda_onesided_device.h | 8 +- .../cuda/rpucuda_onesided_device_test.cpp | 8 +- .../cuda/rpucuda_piecewisestep_device.cu | 8 +- .../cuda/rpucuda_piecewisestep_device.h | 8 +- src/rpucuda/cuda/rpucuda_powstep_device.cu | 8 +- src/rpucuda/cuda/rpucuda_powstep_device.h | 8 +- .../cuda/rpucuda_powstep_reference_device.cu | 8 +- .../cuda/rpucuda_powstep_reference_device.h | 8 +- src/rpucuda/cuda/rpucuda_powstep_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_pulsed.cu | 8 +- src/rpucuda/cuda/rpucuda_pulsed.h | 8 +- src/rpucuda/cuda/rpucuda_pulsed_device.cu | 8 +- src/rpucuda/cuda/rpucuda_pulsed_device.h | 8 +- .../cuda/rpucuda_pulsed_device_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_pulsed_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_simple_device.cu | 8 +- src/rpucuda/cuda/rpucuda_simple_device.h | 8 +- .../cuda/rpucuda_simple_device_test.cpp | 8 +- .../rpucuda_softbounds_reference_device.cu | 8 +- .../rpucuda_softbounds_reference_device.h | 8 +- src/rpucuda/cuda/rpucuda_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_transfer_device.cu | 8 +- src/rpucuda/cuda/rpucuda_transfer_device.h | 8 +- .../cuda/rpucuda_transfer_device_test.cpp | 8 +- src/rpucuda/cuda/rpucuda_vector_device.cu | 8 +- src/rpucuda/cuda/rpucuda_vector_device.h | 8 +- .../cuda/rpucuda_vector_device_test.cpp | 8 +- src/rpucuda/cuda/test_helper.cu | 8 +- src/rpucuda/cuda/test_helper.h | 8 +- src/rpucuda/cuda/update_management_helper.cu | 8 +- src/rpucuda/cuda/update_management_helper.h | 8 +- .../cuda/update_management_helper_test.cpp | 8 +- src/rpucuda/cuda/weight_clipper_cuda.cu | 8 +- src/rpucuda/cuda/weight_clipper_cuda.h | 8 +- src/rpucuda/cuda/weight_clipper_cuda_test.cpp | 8 +- src/rpucuda/cuda/weight_drifter_cuda.cu | 8 +- src/rpucuda/cuda/weight_drifter_cuda.h | 8 +- src/rpucuda/cuda/weight_drifter_cuda_test.cpp | 8 +- src/rpucuda/cuda/weight_modifier_cuda.cu | 8 +- src/rpucuda/cuda/weight_modifier_cuda.h | 8 +- src/rpucuda/cuda/weight_remapper_cuda.cu | 8 +- src/rpucuda/cuda/weight_remapper_cuda.h | 8 +- src/rpucuda/dense_bit_line_maker.cpp | 8 +- src/rpucuda/dense_bit_line_maker.h | 8 +- src/rpucuda/math_util.cpp | 8 +- src/rpucuda/math_util.h | 8 +- src/rpucuda/rng.cpp | 8 +- src/rpucuda/rng.h | 8 +- src/rpucuda/rpu.cpp | 8 +- src/rpucuda/rpu.h | 8 +- src/rpucuda/rpu_buffered_transfer_device.cpp | 8 +- src/rpucuda/rpu_buffered_transfer_device.h | 8 +- src/rpucuda/rpu_chopped_transfer_device.cpp | 8 +- src/rpucuda/rpu_chopped_transfer_device.h | 8 +- src/rpucuda/rpu_constantstep_device.cpp | 8 +- src/rpucuda/rpu_constantstep_device.h | 8 +- src/rpucuda/rpu_dynamic_transfer_device.cpp | 8 +- src/rpucuda/rpu_dynamic_transfer_device.h | 8 +- src/rpucuda/rpu_expstep_device.cpp | 8 +- src/rpucuda/rpu_expstep_device.h | 8 +- src/rpucuda/rpu_forward_backward_pass.cpp | 8 +- src/rpucuda/rpu_forward_backward_pass.h | 8 +- src/rpucuda/rpu_hidden_device.cpp | 8 +- src/rpucuda/rpu_hidden_device.h | 8 +- src/rpucuda/rpu_linearstep_device.cpp | 8 +- src/rpucuda/rpu_linearstep_device.h | 8 +- src/rpucuda/rpu_mixedprec_device.cpp | 8 +- src/rpucuda/rpu_mixedprec_device.h | 8 +- src/rpucuda/rpu_mixedprec_device_base.cpp | 8 +- src/rpucuda/rpu_mixedprec_device_base.h | 8 +- src/rpucuda/rpu_mixedprec_int_device.cpp | 8 +- src/rpucuda/rpu_mixedprec_int_device.h | 8 +- src/rpucuda/rpu_onesided_device.cpp | 8 +- src/rpucuda/rpu_onesided_device.h | 8 +- src/rpucuda/rpu_onesided_device_test.cpp | 8 +- src/rpucuda/rpu_piecewisestep_device.cpp | 8 +- src/rpucuda/rpu_piecewisestep_device.h | 8 +- src/rpucuda/rpu_powstep_device.cpp | 8 +- src/rpucuda/rpu_powstep_device.h | 8 +- src/rpucuda/rpu_powstep_reference_device.cpp | 8 +- src/rpucuda/rpu_powstep_reference_device.h | 8 +- src/rpucuda/rpu_pulsed.cpp | 8 +- src/rpucuda/rpu_pulsed.h | 8 +- src/rpucuda/rpu_pulsed_device.cpp | 8 +- src/rpucuda/rpu_pulsed_device.h | 8 +- src/rpucuda/rpu_pulsed_meta_parameter.cpp | 8 +- src/rpucuda/rpu_pulsed_meta_parameter.h | 8 +- src/rpucuda/rpu_pulsed_test.cpp | 8 +- src/rpucuda/rpu_simple_device.cpp | 8 +- src/rpucuda/rpu_simple_device.h | 8 +- .../rpu_softbounds_reference_device.cpp | 8 +- src/rpucuda/rpu_softbounds_reference_device.h | 8 +- src/rpucuda/rpu_transfer_device.cpp | 8 +- src/rpucuda/rpu_transfer_device.h | 8 +- src/rpucuda/rpu_transfer_device_test.cpp | 8 +- src/rpucuda/rpu_vector_device.cpp | 8 +- src/rpucuda/rpu_vector_device.h | 8 +- src/rpucuda/rpu_weight_updater.cpp | 8 +- src/rpucuda/rpu_weight_updater.h | 8 +- src/rpucuda/sparse_bit_line_maker.cpp | 8 +- src/rpucuda/sparse_bit_line_maker.h | 8 +- src/rpucuda/utility_functions.cpp | 8 +- src/rpucuda/utility_functions.h | 8 +- src/rpucuda/weight_clipper.cpp | 8 +- src/rpucuda/weight_clipper.h | 8 +- src/rpucuda/weight_drifter.cpp | 8 +- src/rpucuda/weight_drifter.h | 8 +- src/rpucuda/weight_modifier.cpp | 8 +- src/rpucuda/weight_modifier.h | 8 +- src/rpucuda/weight_remapper.cpp | 8 +- src/rpucuda/weight_remapper.h | 8 +- tests/__init__.py | 8 +- tests/helpers/__init__.py | 8 +- tests/helpers/decorators.py | 8 +- tests/helpers/experiments.py | 8 +- tests/helpers/infer_experiments.py | 8 +- tests/helpers/layers.py | 8 +- tests/helpers/testcases.py | 8 +- tests/helpers/tiles.py | 8 +- tests/test_bindings_tiles.py | 8 +- tests/test_calibration.py | 8 +- tests/test_client.py | 8 +- tests/test_cloud_runner.py | 8 +- tests/test_continue_training.py | 8 +- tests/test_conversions.py | 8 +- tests/test_experiment_runners.py | 8 +- tests/test_experiments.py | 8 +- tests/test_export.py | 8 +- tests/test_extension.py | 8 +- tests/test_inference.py | 8 +- tests/test_inference_tiles.py | 8 +- tests/test_layer_base.py | 8 +- tests/test_layers.py | 8 +- tests/test_layers_convolution.py | 8 +- tests/test_layers_linear.py | 8 +- tests/test_layers_mapped.py | 8 +- tests/test_layers_rnn.py | 8 +- tests/test_localrunner_infer.py | 8 +- tests/test_optimizers.py | 8 +- tests/test_presets.py | 8 +- tests/test_rpu_configurations.py | 8 +- tests/test_simulator_tiles.py | 8 +- tests/test_specific_tiles.py | 8 +- tests/test_torch_tiles.py | 8 +- tests/test_utils.py | 8 +- 397 files changed, 422 insertions(+), 2983 deletions(-) diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md index 4a4401ea..284217b4 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/CONTRIBUTING.md @@ -10,7 +10,7 @@ the project maintainers. ## Open Development & Community Driven -`aihwkit` is open-source under the [Apache License 2.0]. All the work +`aihwkit` is open-source under the [MIT License]. All the work done is available on GitHub, and the resulting Python packages are available in PyPI. @@ -75,6 +75,6 @@ bugs - and we aim to keep a close eye on them. Before filling a new bug, please try to browse through the list in case the bug is already reported. [`issues`]: ../../../issues -[Apache License 2.0]: LICENSE.txt +[MIT License]: LICENSE.txt [Code of Conduct]: CODE_OF_CONDUCT.md [GitHub documentation]: https://docs.github.com/en/github/getting-started-with-github/fork-a-repo diff --git a/.travis.yml b/.travis.yml index 53170b1d..7be621c8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. notifications: email: false diff --git a/CMakeLists.txt b/CMakeLists.txt index 7cd799cf..9150cfbc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. cmake_minimum_required(VERSION 3.18.0) project(aihwkit C CXX) diff --git a/LICENSE.txt b/LICENSE.txt index 28270709..741deca2 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,202 +1,21 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. +MIT License + +Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Makefile b/Makefile index cc991d52..e00fc418 100644 --- a/Makefile +++ b/Makefile @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. .PHONY: build_inplace clean clean-doc clang-format mypy pycodestyle pylint pytest build_inplace_mkl build_inplace_cuda build_cuda diff --git a/README.md b/README.md index 54129a0d..25c623d3 100644 --- a/README.md +++ b/README.md @@ -221,9 +221,9 @@ at the ``aihwkit@us.ibm.com`` email address. ## License -This project is licensed under [Apache License 2.0]. +This project is licensed under [MIT License]. -[Apache License 2.0]: LICENSE.txt +[MIT License 2.0]: LICENSE.txt [Python package index]: https://pypi.org/project/aihwkit [`PyTorch`]: https://pytorch.org/ diff --git a/cmake/Modules/FindAVX.cmake b/cmake/Modules/FindAVX.cmake index 5cae15c5..f03680b3 100644 --- a/cmake/Modules/FindAVX.cmake +++ b/cmake/Modules/FindAVX.cmake @@ -3,17 +3,7 @@ # Copyright (c) 2016-, Facebook Inc. All rights reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# Licensed under the MIT license. See LICENSE file in the project root for details. INCLUDE(CheckCSourceCompiles) INCLUDE(CheckCXXSourceCompiles) diff --git a/cmake/Modules/FindCUB.cmake b/cmake/Modules/FindCUB.cmake index 7d99161c..aa841d47 100644 --- a/cmake/Modules/FindCUB.cmake +++ b/cmake/Modules/FindCUB.cmake @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # Try to find the CUB library and headers. # CUB_FOUND - system has CUB diff --git a/cmake/Modules/FindMKL.cmake b/cmake/Modules/FindMKL.cmake index b34f78c6..2231e3bf 100644 --- a/cmake/Modules/FindMKL.cmake +++ b/cmake/Modules/FindMKL.cmake @@ -3,17 +3,7 @@ # Copyright (c) 2016-, Facebook Inc. All rights reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# Licensed under the MIT license. See LICENSE file in the project root for details. # - Find INTEL MKL library # diff --git a/cmake/Modules/FindOpenBLAS.cmake b/cmake/Modules/FindOpenBLAS.cmake index 6e452f42..b6d5ba7a 100644 --- a/cmake/Modules/FindOpenBLAS.cmake +++ b/cmake/Modules/FindOpenBLAS.cmake @@ -3,17 +3,7 @@ # Copyright (c) 2016-, Facebook Inc. All rights reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# Licensed under the MIT license. See LICENSE file in the project root for details. SET(Open_BLAS_INCLUDE_SEARCH_PATHS /usr/include diff --git a/cmake/Modules/FindTorch.cmake b/cmake/Modules/FindTorch.cmake index f33d74f9..c98925e6 100644 --- a/cmake/Modules/FindTorch.cmake +++ b/cmake/Modules/FindTorch.cmake @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # Try to find the Torch library and headers. # TORCH_INCLUDE_DIRS - the torch include directory diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake index 2b836b6c..9c1ace63 100644 --- a/cmake/dependencies.cmake +++ b/cmake/dependencies.cmake @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) diff --git a/cmake/dependencies_cuda.cmake b/cmake/dependencies_cuda.cmake index e96ad743..48a63e53 100644 --- a/cmake/dependencies_cuda.cmake +++ b/cmake/dependencies_cuda.cmake @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) diff --git a/cmake/dependencies_test.cmake b/cmake/dependencies_test.cmake index 9efb4210..6745ad2f 100644 --- a/cmake/dependencies_test.cmake +++ b/cmake/dependencies_test.cmake @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) diff --git a/examples/01_simple_layer.py b/examples/01_simple_layer.py index 7fcd36b7..4fa87953 100644 --- a/examples/01_simple_layer.py +++ b/examples/01_simple_layer.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 1: simple network with one layer. diff --git a/examples/02_multiple_layer.py b/examples/02_multiple_layer.py index d2c8b5df..c5f3ba5c 100644 --- a/examples/02_multiple_layer.py +++ b/examples/02_multiple_layer.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details.. """aihwkit example 2: network with multiple layers. diff --git a/examples/03_mnist_training.py b/examples/03_mnist_training.py index bc9d3467..f5fd84ab 100644 --- a/examples/03_mnist_training.py +++ b/examples/03_mnist_training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 3: MNIST training. diff --git a/examples/04_lenet5_training.py b/examples/04_lenet5_training.py index 370f8f4c..4809385b 100644 --- a/examples/04_lenet5_training.py +++ b/examples/04_lenet5_training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 4: analog CNN. diff --git a/examples/05_simple_layer_hardware_aware.py b/examples/05_simple_layer_hardware_aware.py index db31b84d..d88d9afb 100644 --- a/examples/05_simple_layer_hardware_aware.py +++ b/examples/05_simple_layer_hardware_aware.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 5: simple network hardware-aware training with one layer. diff --git a/examples/06_lenet5_hardware_aware.py b/examples/06_lenet5_hardware_aware.py index 0bce1ce1..de3a3516 100644 --- a/examples/06_lenet5_hardware_aware.py +++ b/examples/06_lenet5_hardware_aware.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 6: analog CNN with hardware aware training. diff --git a/examples/07_simple_layer_with_other_devices.py b/examples/07_simple_layer_with_other_devices.py index 60ca32ae..d5052511 100644 --- a/examples/07_simple_layer_with_other_devices.py +++ b/examples/07_simple_layer_with_other_devices.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 7: simple network with one layer using other devices. diff --git a/examples/08_simple_layer_with_tiki_taka.py b/examples/08_simple_layer_with_tiki_taka.py index c73afe9e..172c1acc 100644 --- a/examples/08_simple_layer_with_tiki_taka.py +++ b/examples/08_simple_layer_with_tiki_taka.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 8: simple network with one layer using Tiki-taka learning rule. diff --git a/examples/09_simple_layer_deterministic_pulses.py b/examples/09_simple_layer_deterministic_pulses.py index b3c1ba64..b7d0dd4a 100644 --- a/examples/09_simple_layer_deterministic_pulses.py +++ b/examples/09_simple_layer_deterministic_pulses.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 9: simple network with one layer using deterministic pulse trains for update. diff --git a/examples/10_plot_presets.py b/examples/10_plot_presets.py index 7582ca00..a98e9a91 100644 --- a/examples/10_plot_presets.py +++ b/examples/10_plot_presets.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 10: plotting of presets. diff --git a/examples/11_vgg8_training.py b/examples/11_vgg8_training.py index 6438ae5e..3c862aa4 100644 --- a/examples/11_vgg8_training.py +++ b/examples/11_vgg8_training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 11: analog CNN. diff --git a/examples/12_simple_layer_with_mixed_precision.py b/examples/12_simple_layer_with_mixed_precision.py index 78c1bfe0..284a9ade 100644 --- a/examples/12_simple_layer_with_mixed_precision.py +++ b/examples/12_simple_layer_with_mixed_precision.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 12: simple network with one layer using Mixed Precision learning rule. diff --git a/examples/13_experiment_3fc.py b/examples/13_experiment_3fc.py index b9f35bac..d694d43a 100644 --- a/examples/13_experiment_3fc.py +++ b/examples/13_experiment_3fc.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 13: Experiment training (3 fully connected layers). diff --git a/examples/14_experiment_custom_scheduler.py b/examples/14_experiment_custom_scheduler.py index c1af0135..1dbdc688 100644 --- a/examples/14_experiment_custom_scheduler.py +++ b/examples/14_experiment_custom_scheduler.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 13: Custom experiment training (3 fully connected layers). diff --git a/examples/15_simple_rnn.py b/examples/15_simple_rnn.py index 933ca85c..df6c641e 100644 --- a/examples/15_simple_rnn.py +++ b/examples/15_simple_rnn.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 15: hardware-aware training of analog RNN model. diff --git a/examples/16_mnist_gan.py b/examples/16_mnist_gan.py index 2d97b255..bbc6de69 100644 --- a/examples/16_mnist_gan.py +++ b/examples/16_mnist_gan.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 16: Train a GAN using Linear Layers to generate MNIST characters. diff --git a/examples/17_resnet34_imagenet_conversion_to_analog.py b/examples/17_resnet34_imagenet_conversion_to_analog.py index e8b3ebff..ada972d1 100644 --- a/examples/17_resnet34_imagenet_conversion_to_analog.py +++ b/examples/17_resnet34_imagenet_conversion_to_analog.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 17: resnet34 CNN conversion to analog. diff --git a/examples/18_cifar10_on_resnet.py b/examples/18_cifar10_on_resnet.py index df522e39..290cd283 100644 --- a/examples/18_cifar10_on_resnet.py +++ b/examples/18_cifar10_on_resnet.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 18: resnet32 CNN with CIFAR10. diff --git a/examples/20_mnist_ddp.py b/examples/20_mnist_ddp.py index 8ee25dd2..54efeed9 100644 --- a/examples/20_mnist_ddp.py +++ b/examples/20_mnist_ddp.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 20: MNIST training with PyTorch Distributed Data Parallel (DDP). diff --git a/examples/21_fit_device_data.py b/examples/21_fit_device_data.py index 52263a09..74677e71 100644 --- a/examples/21_fit_device_data.py +++ b/examples/21_fit_device_data.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 21: Fitting a device data to a piecewise step device. diff --git a/examples/22_war_and_peace_lstm.py b/examples/22_war_and_peace_lstm.py index 3d3f67d1..59980909 100644 --- a/examples/22_war_and_peace_lstm.py +++ b/examples/22_war_and_peace_lstm.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 22: 2-layers LSTM diff --git a/examples/23_using_analog_tile_as_matrix.py b/examples/23_using_analog_tile_as_matrix.py index 8f5896bc..0a64f700 100644 --- a/examples/23_using_analog_tile_as_matrix.py +++ b/examples/23_using_analog_tile_as_matrix.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 22: Simple example of how to use an analog tile as a matrix """ diff --git a/examples/24_bert_on_squad.py b/examples/24_bert_on_squad.py index ed383524..b1e63d6e 100644 --- a/examples/24_bert_on_squad.py +++ b/examples/24_bert_on_squad.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 24: Example using convert_to_analog to run BERT transformer on SQuAD task **Source**: diff --git a/examples/25_torch_tile_lenet5_hardware_aware.py b/examples/25_torch_tile_lenet5_hardware_aware.py index 3a02d33d..4aaf2fc1 100644 --- a/examples/25_torch_tile_lenet5_hardware_aware.py +++ b/examples/25_torch_tile_lenet5_hardware_aware.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 25: analog CNN with hardware aware training. diff --git a/examples/26_correlation_detection.py b/examples/26_correlation_detection.py index 493112f1..2f971d7a 100644 --- a/examples/26_correlation_detection.py +++ b/examples/26_correlation_detection.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 25: Simple correlation detection with analog optimizers. """ diff --git a/examples/27_input_range_calibration.py b/examples/27_input_range_calibration.py index e34823fc..aa2e745b 100644 --- a/examples/27_input_range_calibration.py +++ b/examples/27_input_range_calibration.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 27: Post-training input range calibration. diff --git a/examples/28_advanced_irdrop.py b/examples/28_advanced_irdrop.py index 78fa430d..39924786 100644 --- a/examples/28_advanced_irdrop.py +++ b/examples/28_advanced_irdrop.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 28: advanced (time-dependent) IR drop effects diff --git a/examples/29_linalg_krylov.py b/examples/29_linalg_krylov.py index aed516f4..873fa448 100644 --- a/examples/29_linalg_krylov.py +++ b/examples/29_linalg_krylov.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=invalid-name diff --git a/examples/30_external_hardware_aware_model.py b/examples/30_external_hardware_aware_model.py index 854a86fc..685b4e8e 100644 --- a/examples/30_external_hardware_aware_model.py +++ b/examples/30_external_hardware_aware_model.py @@ -4,13 +4,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 30: Importing and using external hardware-aware trained models. diff --git a/examples/31_custom_drift_models.py b/examples/31_custom_drift_models.py index 516080c1..75326c23 100644 --- a/examples/31_custom_drift_models.py +++ b/examples/31_custom_drift_models.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 31: customized conductance drift models diff --git a/examples/32_weight_programming_options.py b/examples/32_weight_programming_options.py index b8f93d2e..805e5d6a 100644 --- a/examples/32_weight_programming_options.py +++ b/examples/32_weight_programming_options.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 32: weight programming options diff --git a/notebooks/README.md b/notebooks/README.md index 5ccafcfb..5f8d9967 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -1,17 +1,7 @@ # AIHWKIT Notebooks diff --git a/setup.py b/setup.py index a0a8420b..e1098fa3 100644 --- a/setup.py +++ b/setup.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Setup.py for `aihwkit`.""" @@ -50,13 +44,13 @@ def get_long_description() -> str: url="https://github.com/IBM/aihwkit", author="IBM Research", author_email="aihwkit@us.ibm.com", - license="Apache 2.0", + license="MIT", classifiers=[ "Development Status :: 4 - Beta", "Environment :: Console", "Environment :: GPU :: NVIDIA CUDA", "Intended Audience :: Science/Research", - "License :: OSI Approved :: Apache Software License", + "License :: OSI Approved :: MIT License", "Operating System :: MacOS", "Operating System :: Microsoft :: Windows", "Operating System :: POSIX :: Linux", diff --git a/src/aihwkit/__init__.py b/src/aihwkit/__init__.py index 022e664a..9af1c46b 100644 --- a/src/aihwkit/__init__.py +++ b/src/aihwkit/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog hardware library for PyTorch.""" diff --git a/src/aihwkit/cloud/__init__.py b/src/aihwkit/cloud/__init__.py index 0b63d2ab..18bbd70c 100644 --- a/src/aihwkit/cloud/__init__.py +++ b/src/aihwkit/cloud/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Functionality related to the cloud client for AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/__init__.py b/src/aihwkit/cloud/client/__init__.py index 6173ff9b..395ac606 100644 --- a/src/aihwkit/cloud/client/__init__.py +++ b/src/aihwkit/cloud/client/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Client for connecting to the the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/entities.py b/src/aihwkit/cloud/client/entities.py index 89a230df..b57e03fc 100644 --- a/src/aihwkit/cloud/client/entities.py +++ b/src/aihwkit/cloud/client/entities.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Data classes for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/exceptions.py b/src/aihwkit/cloud/client/exceptions.py index a06ccc07..af14f4cc 100644 --- a/src/aihwkit/cloud/client/exceptions.py +++ b/src/aihwkit/cloud/client/exceptions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Exceptions related to the cloud client.""" diff --git a/src/aihwkit/cloud/client/session.py b/src/aihwkit/cloud/client/session.py index 806d78c1..515b8c74 100644 --- a/src/aihwkit/cloud/client/session.py +++ b/src/aihwkit/cloud/client/session.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Session handler for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/utils.py b/src/aihwkit/cloud/client/utils.py index 7e838127..f242aa7f 100644 --- a/src/aihwkit/cloud/client/utils.py +++ b/src/aihwkit/cloud/client/utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Utilities for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/v1/__init__.py b/src/aihwkit/cloud/client/v1/__init__.py index f087435a..bbf752d4 100644 --- a/src/aihwkit/cloud/client/v1/__init__.py +++ b/src/aihwkit/cloud/client/v1/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helpers for the AIHW Composer API (version 1).""" diff --git a/src/aihwkit/cloud/client/v1/api_client.py b/src/aihwkit/cloud/client/v1/api_client.py index 07fcb027..dd884159 100644 --- a/src/aihwkit/cloud/client/v1/api_client.py +++ b/src/aihwkit/cloud/client/v1/api_client.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """API client the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/v1/i_api_client.py b/src/aihwkit/cloud/client/v1/i_api_client.py index 334d06cc..d510bf72 100644 --- a/src/aihwkit/cloud/client/v1/i_api_client.py +++ b/src/aihwkit/cloud/client/v1/i_api_client.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """API client the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/v1/parsers.py b/src/aihwkit/cloud/client/v1/parsers.py index 5dd6050b..8b581b4a 100644 --- a/src/aihwkit/cloud/client/v1/parsers.py +++ b/src/aihwkit/cloud/client/v1/parsers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Parsers for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/client/v1/stubs.py b/src/aihwkit/cloud/client/v1/stubs.py index 2c827275..56a5cf74 100644 --- a/src/aihwkit/cloud/client/v1/stubs.py +++ b/src/aihwkit/cloud/client/v1/stubs.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """API stubs for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/converter/__init__.py b/src/aihwkit/cloud/converter/__init__.py index 83008c20..de44757c 100644 --- a/src/aihwkit/cloud/converter/__init__.py +++ b/src/aihwkit/cloud/converter/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Conversion utilities for interacting with the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/converter/definitions/__init__.py b/src/aihwkit/cloud/converter/definitions/__init__.py index c81d4b1d..15e15ae1 100644 --- a/src/aihwkit/cloud/converter/definitions/__init__.py +++ b/src/aihwkit/cloud/converter/definitions/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Protobuf definitions for the AIHW Composer API.""" diff --git a/src/aihwkit/cloud/converter/exceptions.py b/src/aihwkit/cloud/converter/exceptions.py index 00e792ce..26563f23 100644 --- a/src/aihwkit/cloud/converter/exceptions.py +++ b/src/aihwkit/cloud/converter/exceptions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Conversion-related Exceptions.""" diff --git a/src/aihwkit/cloud/converter/v1/__init__.py b/src/aihwkit/cloud/converter/v1/__init__.py index a1529b5f..f4ba86a9 100644 --- a/src/aihwkit/cloud/converter/v1/__init__.py +++ b/src/aihwkit/cloud/converter/v1/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helpers for version 1 of the AIHW Composer format.""" diff --git a/src/aihwkit/cloud/converter/v1/analog_info.py b/src/aihwkit/cloud/converter/v1/analog_info.py index 9b284dab..d5995980 100644 --- a/src/aihwkit/cloud/converter/v1/analog_info.py +++ b/src/aihwkit/cloud/converter/v1/analog_info.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helper class for adding rpu_config to neural network model""" # pylint: disable=no-name-in-module,import-error diff --git a/src/aihwkit/cloud/converter/v1/i_mappings.py b/src/aihwkit/cloud/converter/v1/i_mappings.py index caed34a5..3773a732 100644 --- a/src/aihwkit/cloud/converter/v1/i_mappings.py +++ b/src/aihwkit/cloud/converter/v1/i_mappings.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=no-name-in-module, import-error, too-few-public-methods diff --git a/src/aihwkit/cloud/converter/v1/inferencing.py b/src/aihwkit/cloud/converter/v1/inferencing.py index 4a0bd4b7..fbefbd43 100644 --- a/src/aihwkit/cloud/converter/v1/inferencing.py +++ b/src/aihwkit/cloud/converter/v1/inferencing.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=no-name-in-module, import-error diff --git a/src/aihwkit/cloud/converter/v1/mappings.py b/src/aihwkit/cloud/converter/v1/mappings.py index c56641c6..98766dab 100644 --- a/src/aihwkit/cloud/converter/v1/mappings.py +++ b/src/aihwkit/cloud/converter/v1/mappings.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=no-name-in-module, import-error diff --git a/src/aihwkit/cloud/converter/v1/noise_model_info.py b/src/aihwkit/cloud/converter/v1/noise_model_info.py index 7b1772e6..484c1a29 100644 --- a/src/aihwkit/cloud/converter/v1/noise_model_info.py +++ b/src/aihwkit/cloud/converter/v1/noise_model_info.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Noise model info in rpu_config to neural network model""" diff --git a/src/aihwkit/cloud/converter/v1/rpu_config_info.py b/src/aihwkit/cloud/converter/v1/rpu_config_info.py index 92cafe79..5426f01f 100644 --- a/src/aihwkit/cloud/converter/v1/rpu_config_info.py +++ b/src/aihwkit/cloud/converter/v1/rpu_config_info.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Creates InferenceRPUConfig to add to nn model""" from typing import Dict, Any diff --git a/src/aihwkit/cloud/converter/v1/training.py b/src/aihwkit/cloud/converter/v1/training.py index 55905a3c..fb8bbeb5 100644 --- a/src/aihwkit/cloud/converter/v1/training.py +++ b/src/aihwkit/cloud/converter/v1/training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=no-name-in-module,import-error diff --git a/src/aihwkit/exceptions.py b/src/aihwkit/exceptions.py index baa62ddb..3410860a 100644 --- a/src/aihwkit/exceptions.py +++ b/src/aihwkit/exceptions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Custom Exceptions for aihwkit.""" diff --git a/src/aihwkit/experiments/__init__.py b/src/aihwkit/experiments/__init__.py index 15a06136..3202fe88 100644 --- a/src/aihwkit/experiments/__init__.py +++ b/src/aihwkit/experiments/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High-level interface for executing Experiments.""" diff --git a/src/aihwkit/experiments/experiments/__init__.py b/src/aihwkit/experiments/experiments/__init__.py index f729bfc5..c032d794 100644 --- a/src/aihwkit/experiments/experiments/__init__.py +++ b/src/aihwkit/experiments/experiments/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Experiments for aihwkit.""" diff --git a/src/aihwkit/experiments/experiments/base.py b/src/aihwkit/experiments/experiments/base.py index 5e7f6d2c..a6fb66b5 100644 --- a/src/aihwkit/experiments/experiments/base.py +++ b/src/aihwkit/experiments/experiments/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for an Experiment.""" diff --git a/src/aihwkit/experiments/experiments/inferencing.py b/src/aihwkit/experiments/experiments/inferencing.py index 86b0dea6..9c45f424 100644 --- a/src/aihwkit/experiments/experiments/inferencing.py +++ b/src/aihwkit/experiments/experiments/inferencing.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Basic inferencing Experiment.""" diff --git a/src/aihwkit/experiments/experiments/training.py b/src/aihwkit/experiments/experiments/training.py index 507c52f9..8975559a 100644 --- a/src/aihwkit/experiments/experiments/training.py +++ b/src/aihwkit/experiments/experiments/training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Basic training Experiment.""" diff --git a/src/aihwkit/experiments/runners/__init__.py b/src/aihwkit/experiments/runners/__init__.py index fbed9929..c1fec0fd 100644 --- a/src/aihwkit/experiments/runners/__init__.py +++ b/src/aihwkit/experiments/runners/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Experiment Runners for aihwkit.""" diff --git a/src/aihwkit/experiments/runners/base.py b/src/aihwkit/experiments/runners/base.py index 4aa0de4f..45ddd319 100644 --- a/src/aihwkit/experiments/runners/base.py +++ b/src/aihwkit/experiments/runners/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for an Experiment Runner.""" diff --git a/src/aihwkit/experiments/runners/cloud.py b/src/aihwkit/experiments/runners/cloud.py index 5a20d77a..95458068 100644 --- a/src/aihwkit/experiments/runners/cloud.py +++ b/src/aihwkit/experiments/runners/cloud.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for an Experiment Runner.""" diff --git a/src/aihwkit/experiments/runners/i_cloud.py b/src/aihwkit/experiments/runners/i_cloud.py index 961eaf92..800a87cb 100644 --- a/src/aihwkit/experiments/runners/i_cloud.py +++ b/src/aihwkit/experiments/runners/i_cloud.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for an Experiment Runner.""" diff --git a/src/aihwkit/experiments/runners/i_local.py b/src/aihwkit/experiments/runners/i_local.py index cfd617b5..7bb24baa 100644 --- a/src/aihwkit/experiments/runners/i_local.py +++ b/src/aihwkit/experiments/runners/i_local.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Runner that executes Experiments locally.""" diff --git a/src/aihwkit/experiments/runners/i_metrics.py b/src/aihwkit/experiments/runners/i_metrics.py index e3534fb1..2e455d7a 100644 --- a/src/aihwkit/experiments/runners/i_metrics.py +++ b/src/aihwkit/experiments/runners/i_metrics.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helper for retrieving Metrics of an Experiment.""" diff --git a/src/aihwkit/experiments/runners/local.py b/src/aihwkit/experiments/runners/local.py index 246d8c9b..b32cc049 100644 --- a/src/aihwkit/experiments/runners/local.py +++ b/src/aihwkit/experiments/runners/local.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Runner that executes Experiments locally.""" diff --git a/src/aihwkit/experiments/runners/metrics.py b/src/aihwkit/experiments/runners/metrics.py index 9acfad53..2166cffc 100644 --- a/src/aihwkit/experiments/runners/metrics.py +++ b/src/aihwkit/experiments/runners/metrics.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helper for retrieving Metrics of an Experiment.""" diff --git a/src/aihwkit/extension/CMakeLists.txt b/src/aihwkit/extension/CMakeLists.txt index e4392f24..3b38e61a 100644 --- a/src/aihwkit/extension/CMakeLists.txt +++ b/src/aihwkit/extension/CMakeLists.txt @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # CPU ops files file(GLOB AIHWKIT_EXTENSION_OPS_CPU_SRCS extension_src/ops/*.cpp) diff --git a/src/aihwkit/extension/__init__.py b/src/aihwkit/extension/__init__.py index c7b8f132..a5af0f21 100644 --- a/src/aihwkit/extension/__init__.py +++ b/src/aihwkit/extension/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=import-error, no-name-in-module, invalid-name diff --git a/src/aihwkit/extension/extension_src/aihwkit_extension.cpp b/src/aihwkit/extension/extension_src/aihwkit_extension.cpp index 66bc3d45..fcfc3b67 100644 --- a/src/aihwkit/extension/extension_src/aihwkit_extension.cpp +++ b/src/aihwkit/extension/extension_src/aihwkit_extension.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "aihwkit_extension.h" diff --git a/src/aihwkit/extension/extension_src/aihwkit_extension.h b/src/aihwkit/extension/extension_src/aihwkit_extension.h index 73229cdc..e0f52510 100644 --- a/src/aihwkit/extension/extension_src/aihwkit_extension.h +++ b/src/aihwkit/extension/extension_src/aihwkit_extension.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/aihwkit/extension/extension_src/ops/float_prec_op.cpp b/src/aihwkit/extension/extension_src/ops/float_prec_op.cpp index e74cef29..11d6c137 100644 --- a/src/aihwkit/extension/extension_src/ops/float_prec_op.cpp +++ b/src/aihwkit/extension/extension_src/ops/float_prec_op.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "float_prec_op.h" diff --git a/src/aihwkit/extension/extension_src/ops/float_prec_op.cu b/src/aihwkit/extension/extension_src/ops/float_prec_op.cu index 14b4c57a..9ccb44b5 100644 --- a/src/aihwkit/extension/extension_src/ops/float_prec_op.cu +++ b/src/aihwkit/extension/extension_src/ops/float_prec_op.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/aihwkit/extension/extension_src/ops/float_prec_op.h b/src/aihwkit/extension/extension_src/ops/float_prec_op.h index 6347c618..ce38552c 100644 --- a/src/aihwkit/extension/extension_src/ops/float_prec_op.h +++ b/src/aihwkit/extension/extension_src/ops/float_prec_op.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include diff --git a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cpp b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cpp index 6eb92a8b..4181eebd 100644 --- a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cpp +++ b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "thevenin_equiv_op.h" diff --git a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cu b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cu index 428b165e..6b142c58 100644 --- a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cu +++ b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.h b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.h index e5af648d..bd958dce 100644 --- a/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.h +++ b/src/aihwkit/extension/extension_src/ops/thevenin_equiv_op.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include diff --git a/src/aihwkit/extension/functions.py b/src/aihwkit/extension/functions.py index 9f32825a..1b91a456 100644 --- a/src/aihwkit/extension/functions.py +++ b/src/aihwkit/extension/functions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=abstract-method, no-name-in-module diff --git a/src/aihwkit/inference/__init__.py b/src/aihwkit/inference/__init__.py index 581add28..1214b4f7 100644 --- a/src/aihwkit/inference/__init__.py +++ b/src/aihwkit/inference/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level inference tools.""" diff --git a/src/aihwkit/inference/calibration/__init__.py b/src/aihwkit/inference/calibration/__init__.py index 85c49f6c..1185c1ef 100644 --- a/src/aihwkit/inference/calibration/__init__.py +++ b/src/aihwkit/inference/calibration/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level inference tools.""" diff --git a/src/aihwkit/inference/calibration/calibration.py b/src/aihwkit/inference/calibration/calibration.py index a3a3fcc9..ee7506b9 100644 --- a/src/aihwkit/inference/calibration/calibration.py +++ b/src/aihwkit/inference/calibration/calibration.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Calibration for inference.""" diff --git a/src/aihwkit/inference/compensation/__init__.py b/src/aihwkit/inference/compensation/__init__.py index 8057d5ad..ff5d1461 100644 --- a/src/aihwkit/inference/compensation/__init__.py +++ b/src/aihwkit/inference/compensation/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Compensation methods such as drift compensation during analog inference.""" diff --git a/src/aihwkit/inference/compensation/base.py b/src/aihwkit/inference/compensation/base.py index 633c16b2..496c9078 100644 --- a/src/aihwkit/inference/compensation/base.py +++ b/src/aihwkit/inference/compensation/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base drift compensation for inference.""" diff --git a/src/aihwkit/inference/compensation/drift.py b/src/aihwkit/inference/compensation/drift.py index 78140533..fdad6068 100644 --- a/src/aihwkit/inference/compensation/drift.py +++ b/src/aihwkit/inference/compensation/drift.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Global drift compensation for inference.""" diff --git a/src/aihwkit/inference/converter/__init__.py b/src/aihwkit/inference/converter/__init__.py index 7a5e7a64..711aaf24 100644 --- a/src/aihwkit/inference/converter/__init__.py +++ b/src/aihwkit/inference/converter/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Converter of weight matrix values into conductance values and back for analog inference.""" diff --git a/src/aihwkit/inference/converter/base.py b/src/aihwkit/inference/converter/base.py index 9f2ba479..9df3718f 100644 --- a/src/aihwkit/inference/converter/base.py +++ b/src/aihwkit/inference/converter/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base conductance converter for the phenomenological noise models for inference.""" diff --git a/src/aihwkit/inference/converter/conductance.py b/src/aihwkit/inference/converter/conductance.py index 50778796..718b5519 100644 --- a/src/aihwkit/inference/converter/conductance.py +++ b/src/aihwkit/inference/converter/conductance.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Conductance converters for the phenomenological noise models for inference.""" diff --git a/src/aihwkit/inference/converter/fusion.py b/src/aihwkit/inference/converter/fusion.py index d7a5a64b..3518a1fe 100644 --- a/src/aihwkit/inference/converter/fusion.py +++ b/src/aihwkit/inference/converter/fusion.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Conductance converter for the fusion chip.""" diff --git a/src/aihwkit/inference/noise/__init__.py b/src/aihwkit/inference/noise/__init__.py index b719ba25..5c5e9d58 100644 --- a/src/aihwkit/inference/noise/__init__.py +++ b/src/aihwkit/inference/noise/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Noise models to apply to converted weight values during analog inference.""" diff --git a/src/aihwkit/inference/noise/base.py b/src/aihwkit/inference/noise/base.py index be26f86c..b20bf89e 100644 --- a/src/aihwkit/inference/noise/base.py +++ b/src/aihwkit/inference/noise/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for the phenomenological noise models for inference.""" diff --git a/src/aihwkit/inference/noise/custom.py b/src/aihwkit/inference/noise/custom.py index ef3730b4..9127ba6d 100644 --- a/src/aihwkit/inference/noise/custom.py +++ b/src/aihwkit/inference/noise/custom.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Phenomenological noise model for inference.""" diff --git a/src/aihwkit/inference/noise/hermes.py b/src/aihwkit/inference/noise/hermes.py index e9601c70..e9f1d33a 100644 --- a/src/aihwkit/inference/noise/hermes.py +++ b/src/aihwkit/inference/noise/hermes.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes, too-many-arguments, too-many-branches diff --git a/src/aihwkit/inference/noise/pcm.py b/src/aihwkit/inference/noise/pcm.py index d0da6c19..244c4975 100644 --- a/src/aihwkit/inference/noise/pcm.py +++ b/src/aihwkit/inference/noise/pcm.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/inference/noise/reram.py b/src/aihwkit/inference/noise/reram.py index b9f09abc..e01e64b1 100644 --- a/src/aihwkit/inference/noise/reram.py +++ b/src/aihwkit/inference/noise/reram.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/inference/utils.py b/src/aihwkit/inference/utils.py index 1df60b59..d41df9c3 100644 --- a/src/aihwkit/inference/utils.py +++ b/src/aihwkit/inference/utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Utilities for inference.""" diff --git a/src/aihwkit/linalg/__init__.py b/src/aihwkit/linalg/__init__.py index a015121b..559fbc43 100644 --- a/src/aihwkit/linalg/__init__.py +++ b/src/aihwkit/linalg/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Linear Algebra functionality.""" diff --git a/src/aihwkit/linalg/matrix.py b/src/aihwkit/linalg/matrix.py index 95b91503..764d81ef 100644 --- a/src/aihwkit/linalg/matrix.py +++ b/src/aihwkit/linalg/matrix.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """ Defines an analog matrix """ diff --git a/src/aihwkit/nn/__init__.py b/src/aihwkit/nn/__init__.py index cff0cba1..aa97c927 100644 --- a/src/aihwkit/nn/__init__.py +++ b/src/aihwkit/nn/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Neural network modules.""" diff --git a/src/aihwkit/nn/conversion.py b/src/aihwkit/nn/conversion.py index 678f8b79..41b92f99 100644 --- a/src/aihwkit/nn/conversion.py +++ b/src/aihwkit/nn/conversion.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Digital/analog model conversion utilities. diff --git a/src/aihwkit/nn/modules/__init__.py b/src/aihwkit/nn/modules/__init__.py index 54b51b11..5958c55b 100644 --- a/src/aihwkit/nn/modules/__init__.py +++ b/src/aihwkit/nn/modules/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Neural network modules.""" diff --git a/src/aihwkit/nn/modules/base.py b/src/aihwkit/nn/modules/base.py index 3b4cb1d4..1424061d 100644 --- a/src/aihwkit/nn/modules/base.py +++ b/src/aihwkit/nn/modules/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base class for adding functionality to analog layers.""" from typing import Any, List, Optional, Tuple, NamedTuple, Union, Generator, Callable, TYPE_CHECKING diff --git a/src/aihwkit/nn/modules/container.py b/src/aihwkit/nn/modules/container.py index 7314f3b0..7f5d36be 100644 --- a/src/aihwkit/nn/modules/container.py +++ b/src/aihwkit/nn/modules/container.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog Modules that contain children Modules.""" diff --git a/src/aihwkit/nn/modules/conv.py b/src/aihwkit/nn/modules/conv.py index 1644cb71..67348872 100644 --- a/src/aihwkit/nn/modules/conv.py +++ b/src/aihwkit/nn/modules/conv.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Convolution layers.""" diff --git a/src/aihwkit/nn/modules/conv_mapped.py b/src/aihwkit/nn/modules/conv_mapped.py index 162a04aa..65caa2ff 100644 --- a/src/aihwkit/nn/modules/conv_mapped.py +++ b/src/aihwkit/nn/modules/conv_mapped.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Mapped convolution layers.""" diff --git a/src/aihwkit/nn/modules/linear.py b/src/aihwkit/nn/modules/linear.py index 2bc5d0f9..9db3bee2 100644 --- a/src/aihwkit/nn/modules/linear.py +++ b/src/aihwkit/nn/modules/linear.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog layers.""" from typing import Optional, Type diff --git a/src/aihwkit/nn/modules/linear_mapped.py b/src/aihwkit/nn/modules/linear_mapped.py index cac8f609..0a8ecf4c 100644 --- a/src/aihwkit/nn/modules/linear_mapped.py +++ b/src/aihwkit/nn/modules/linear_mapped.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog mapped linear layer.""" diff --git a/src/aihwkit/nn/modules/rnn/__init__.py b/src/aihwkit/nn/modules/rnn/__init__.py index b47fb2ec..6dee811e 100644 --- a/src/aihwkit/nn/modules/rnn/__init__.py +++ b/src/aihwkit/nn/modules/rnn/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog RNN related modules.""" diff --git a/src/aihwkit/nn/modules/rnn/cells.py b/src/aihwkit/nn/modules/rnn/cells.py index ced030d7..02011246 100644 --- a/src/aihwkit/nn/modules/rnn/cells.py +++ b/src/aihwkit/nn/modules/rnn/cells.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """ Analog cells for RNNs. """ diff --git a/src/aihwkit/nn/modules/rnn/layers.py b/src/aihwkit/nn/modules/rnn/layers.py index dcdaf958..5e41ce28 100644 --- a/src/aihwkit/nn/modules/rnn/layers.py +++ b/src/aihwkit/nn/modules/rnn/layers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """ Analog RNN layers """ diff --git a/src/aihwkit/nn/modules/rnn/rnn.py b/src/aihwkit/nn/modules/rnn/rnn.py index c607591a..e723a37a 100644 --- a/src/aihwkit/nn/modules/rnn/rnn.py +++ b/src/aihwkit/nn/modules/rnn/rnn.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """ Analog RNN modules. """ diff --git a/src/aihwkit/optim/__init__.py b/src/aihwkit/optim/__init__.py index df2c700c..67ea7615 100644 --- a/src/aihwkit/optim/__init__.py +++ b/src/aihwkit/optim/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog Optimizers.""" diff --git a/src/aihwkit/optim/analog_optimizer.py b/src/aihwkit/optim/analog_optimizer.py index db5e33f8..347693b5 100644 --- a/src/aihwkit/optim/analog_optimizer.py +++ b/src/aihwkit/optim/analog_optimizer.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog-aware inference optimizer.""" diff --git a/src/aihwkit/optim/context.py b/src/aihwkit/optim/context.py index 2fec8a18..d9228d03 100644 --- a/src/aihwkit/optim/context.py +++ b/src/aihwkit/optim/context.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Parameter context for analog tiles.""" diff --git a/src/aihwkit/simulator/CMakeLists.txt b/src/aihwkit/simulator/CMakeLists.txt index 7d08b5fa..bf496388 100644 --- a/src/aihwkit/simulator/CMakeLists.txt +++ b/src/aihwkit/simulator/CMakeLists.txt @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. set(python_module_name rpu_base) diff --git a/src/aihwkit/simulator/__init__.py b/src/aihwkit/simulator/__init__.py index 93c63214..9b5e233e 100644 --- a/src/aihwkit/simulator/__init__.py +++ b/src/aihwkit/simulator/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """RPU simulator bindings.""" diff --git a/src/aihwkit/simulator/configs/__init__.py b/src/aihwkit/simulator/configs/__init__.py index f16be6b9..93f582af 100644 --- a/src/aihwkit/simulator/configs/__init__.py +++ b/src/aihwkit/simulator/configs/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Configurations for resistive processing units.""" diff --git a/src/aihwkit/simulator/configs/compounds.py b/src/aihwkit/simulator/configs/compounds.py index 571157f5..bcf6ea9a 100644 --- a/src/aihwkit/simulator/configs/compounds.py +++ b/src/aihwkit/simulator/configs/compounds.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes, too-many-lines diff --git a/src/aihwkit/simulator/configs/configs.py b/src/aihwkit/simulator/configs/configs.py index 65d5a3d1..e02bb938 100644 --- a/src/aihwkit/simulator/configs/configs.py +++ b/src/aihwkit/simulator/configs/configs.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Configurations for resistive processing units.""" diff --git a/src/aihwkit/simulator/configs/devices.py b/src/aihwkit/simulator/configs/devices.py index 1ae8a4bb..1ad5ecef 100644 --- a/src/aihwkit/simulator/configs/devices.py +++ b/src/aihwkit/simulator/configs/devices.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Configuration for NVM devices for Analog (Resistive Device) tiles.""" diff --git a/src/aihwkit/simulator/configs/helpers.py b/src/aihwkit/simulator/configs/helpers.py index 3390c533..fc271683 100644 --- a/src/aihwkit/simulator/configs/helpers.py +++ b/src/aihwkit/simulator/configs/helpers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helper for generating presets.""" diff --git a/src/aihwkit/simulator/configs/utils.py b/src/aihwkit/simulator/configs/utils.py index 0eb2ada3..3fbfd78b 100644 --- a/src/aihwkit/simulator/configs/utils.py +++ b/src/aihwkit/simulator/configs/utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Legacy location of the utils module. Please import from parameter.utils / enum in future.""" diff --git a/src/aihwkit/simulator/noise_models.py b/src/aihwkit/simulator/noise_models.py index cbe7a923..7ad8ec89 100644 --- a/src/aihwkit/simulator/noise_models.py +++ b/src/aihwkit/simulator/noise_models.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Legacy class for import the noise models for inference""" diff --git a/src/aihwkit/simulator/parameters/__init__.py b/src/aihwkit/simulator/parameters/__init__.py index 4c360e2a..413f5e0a 100644 --- a/src/aihwkit/simulator/parameters/__init__.py +++ b/src/aihwkit/simulator/parameters/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """RPU simulator bindings.""" diff --git a/src/aihwkit/simulator/parameters/base.py b/src/aihwkit/simulator/parameters/base.py index 1b508a50..229d4e12 100644 --- a/src/aihwkit/simulator/parameters/base.py +++ b/src/aihwkit/simulator/parameters/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base classes for the RPUConfig.""" diff --git a/src/aihwkit/simulator/parameters/enums.py b/src/aihwkit/simulator/parameters/enums.py index a2483065..0d152ea4 100644 --- a/src/aihwkit/simulator/parameters/enums.py +++ b/src/aihwkit/simulator/parameters/enums.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/parameters/helpers.py b/src/aihwkit/simulator/parameters/helpers.py index 846dbd25..4329dc82 100644 --- a/src/aihwkit/simulator/parameters/helpers.py +++ b/src/aihwkit/simulator/parameters/helpers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Utilities for resistive processing units configurations.""" from sys import version_info diff --git a/src/aihwkit/simulator/parameters/inference.py b/src/aihwkit/simulator/parameters/inference.py index f6afb125..f74b3c99 100644 --- a/src/aihwkit/simulator/parameters/inference.py +++ b/src/aihwkit/simulator/parameters/inference.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes # pylint: disable=too-many-lines diff --git a/src/aihwkit/simulator/parameters/io.py b/src/aihwkit/simulator/parameters/io.py index d2ca22c6..b6d2c03a 100644 --- a/src/aihwkit/simulator/parameters/io.py +++ b/src/aihwkit/simulator/parameters/io.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/parameters/mapping.py b/src/aihwkit/simulator/parameters/mapping.py index 3bd9c3c9..b0791e36 100644 --- a/src/aihwkit/simulator/parameters/mapping.py +++ b/src/aihwkit/simulator/parameters/mapping.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/parameters/pre_post.py b/src/aihwkit/simulator/parameters/pre_post.py index cb54b67c..41f2f9ad 100644 --- a/src/aihwkit/simulator/parameters/pre_post.py +++ b/src/aihwkit/simulator/parameters/pre_post.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/parameters/runtime.py b/src/aihwkit/simulator/parameters/runtime.py index 24d0c391..58aafda4 100644 --- a/src/aihwkit/simulator/parameters/runtime.py +++ b/src/aihwkit/simulator/parameters/runtime.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes # pylint: disable=too-many-lines diff --git a/src/aihwkit/simulator/parameters/training.py b/src/aihwkit/simulator/parameters/training.py index 304f8562..2236b9e7 100644 --- a/src/aihwkit/simulator/parameters/training.py +++ b/src/aihwkit/simulator/parameters/training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/presets/__init__.py b/src/aihwkit/simulator/presets/__init__.py index f6e69bbf..39f50907 100644 --- a/src/aihwkit/simulator/presets/__init__.py +++ b/src/aihwkit/simulator/presets/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Configurations presets for resistive processing units.""" diff --git a/src/aihwkit/simulator/presets/compounds.py b/src/aihwkit/simulator/presets/compounds.py index 41e1122c..9faed595 100644 --- a/src/aihwkit/simulator/presets/compounds.py +++ b/src/aihwkit/simulator/presets/compounds.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Compound configurations presets for resistive processing units.""" diff --git a/src/aihwkit/simulator/presets/configs.py b/src/aihwkit/simulator/presets/configs.py index 822be933..4c2b60a0 100644 --- a/src/aihwkit/simulator/presets/configs.py +++ b/src/aihwkit/simulator/presets/configs.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-lines diff --git a/src/aihwkit/simulator/presets/devices.py b/src/aihwkit/simulator/presets/devices.py index 30d88b5e..48307d68 100644 --- a/src/aihwkit/simulator/presets/devices.py +++ b/src/aihwkit/simulator/presets/devices.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Device configurations presets for resistive processing units.""" diff --git a/src/aihwkit/simulator/presets/inference.py b/src/aihwkit/simulator/presets/inference.py index 770a1be0..317385e2 100644 --- a/src/aihwkit/simulator/presets/inference.py +++ b/src/aihwkit/simulator/presets/inference.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-lines diff --git a/src/aihwkit/simulator/presets/utils.py b/src/aihwkit/simulator/presets/utils.py index 8b22d4db..860767cb 100644 --- a/src/aihwkit/simulator/presets/utils.py +++ b/src/aihwkit/simulator/presets/utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Utils for configurations presets for resistive processing units.""" diff --git a/src/aihwkit/simulator/presets/web.py b/src/aihwkit/simulator/presets/web.py index 696689f4..096660c9 100644 --- a/src/aihwkit/simulator/presets/web.py +++ b/src/aihwkit/simulator/presets/web.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """RPU configurations presets used for the composer interface.""" diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base.cpp b/src/aihwkit/simulator/rpu_base_src/rpu_base.cpp index d9a7a1e2..1b7aa0cc 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base.cpp +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_base.h" diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base.h b/src/aihwkit/simulator/rpu_base_src/rpu_base.h index d9358dc5..31ab625c 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base.h +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base_devices.cpp b/src/aihwkit/simulator/rpu_base_src/rpu_base_devices.cpp index aa488ce5..3f60a0a5 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base_devices.cpp +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base_devices.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu.h" diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles.cpp b/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles.cpp index 3aa048dd..bf8a1c03 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles.cpp +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu.h" diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles_cuda.cpp b/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles_cuda.cpp index 340bea88..a6bf9bc5 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles_cuda.cpp +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base_tiles_cuda.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #ifdef RPU_USE_CUDA diff --git a/src/aihwkit/simulator/rpu_base_src/rpu_base_utils.cpp b/src/aihwkit/simulator/rpu_base_src/rpu_base_utils.cpp index 4e90922e..770ec220 100644 --- a/src/aihwkit/simulator/rpu_base_src/rpu_base_utils.cpp +++ b/src/aihwkit/simulator/rpu_base_src/rpu_base_utils.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_base.h" diff --git a/src/aihwkit/simulator/tiles/__init__.py b/src/aihwkit/simulator/tiles/__init__.py index e05e2e40..5f95fbbf 100644 --- a/src/aihwkit/simulator/tiles/__init__.py +++ b/src/aihwkit/simulator/tiles/__init__.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles.""" diff --git a/src/aihwkit/simulator/tiles/analog.py b/src/aihwkit/simulator/tiles/analog.py index 4492fb3b..5e4d6422 100644 --- a/src/aihwkit/simulator/tiles/analog.py +++ b/src/aihwkit/simulator/tiles/analog.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=abstract-method diff --git a/src/aihwkit/simulator/tiles/analog_mvm.py b/src/aihwkit/simulator/tiles/analog_mvm.py index 36ec27bb..b05932ea 100644 --- a/src/aihwkit/simulator/tiles/analog_mvm.py +++ b/src/aihwkit/simulator/tiles/analog_mvm.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Implementation of analog MVM for torch tiles.""" diff --git a/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py b/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py index a40159ff..6c6cf1c7 100644 --- a/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py +++ b/src/aihwkit/simulator/tiles/analog_mvm_irdrop_t.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals, too-many-arguments diff --git a/src/aihwkit/simulator/tiles/array.py b/src/aihwkit/simulator/tiles/array.py index 31fea246..43fdbc17 100644 --- a/src/aihwkit/simulator/tiles/array.py +++ b/src/aihwkit/simulator/tiles/array.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Implements analog tile module array .""" from typing import Any, Optional, Tuple, List, TYPE_CHECKING @@ -154,7 +148,7 @@ def forward(self, x_input: Tensor, tensor_view: Optional[Tuple] = None) -> Tenso # pylint: disable=arguments-differ,arguments-renamed if self.analog_tile_count == 1: - analog_tile = self.array[0][0] + analog_tile = self.array[0][0] # pylint: disable=unsubscriptable-object result = analog_tile(x_input) else: # mapped version diff --git a/src/aihwkit/simulator/tiles/base.py b/src/aihwkit/simulator/tiles/base.py index 3b970792..d9383d51 100644 --- a/src/aihwkit/simulator/tiles/base.py +++ b/src/aihwkit/simulator/tiles/base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles (base).""" # pylint: disable=too-few-public-methods, abstract-method, too-many-instance-attributes diff --git a/src/aihwkit/simulator/tiles/custom.py b/src/aihwkit/simulator/tiles/custom.py index 466946de..de1d4425 100644 --- a/src/aihwkit/simulator/tiles/custom.py +++ b/src/aihwkit/simulator/tiles/custom.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles (floating point).""" diff --git a/src/aihwkit/simulator/tiles/floating_point.py b/src/aihwkit/simulator/tiles/floating_point.py index b3425301..40333dc0 100644 --- a/src/aihwkit/simulator/tiles/floating_point.py +++ b/src/aihwkit/simulator/tiles/floating_point.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles (floating point).""" diff --git a/src/aihwkit/simulator/tiles/functions.py b/src/aihwkit/simulator/tiles/functions.py index c7e9feb2..e7ead29f 100644 --- a/src/aihwkit/simulator/tiles/functions.py +++ b/src/aihwkit/simulator/tiles/functions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Autograd functions for aihwkit.""" diff --git a/src/aihwkit/simulator/tiles/inference.py b/src/aihwkit/simulator/tiles/inference.py index b16ce862..c2d63144 100644 --- a/src/aihwkit/simulator/tiles/inference.py +++ b/src/aihwkit/simulator/tiles/inference.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles (inference).""" diff --git a/src/aihwkit/simulator/tiles/inference_torch.py b/src/aihwkit/simulator/tiles/inference_torch.py index 2e1c31bd..305e6b64 100644 --- a/src/aihwkit/simulator/tiles/inference_torch.py +++ b/src/aihwkit/simulator/tiles/inference_torch.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """High level analog tiles (inference).""" diff --git a/src/aihwkit/simulator/tiles/module.py b/src/aihwkit/simulator/tiles/module.py index 1d4dc0e0..4f242e6e 100644 --- a/src/aihwkit/simulator/tiles/module.py +++ b/src/aihwkit/simulator/tiles/module.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tile module base.""" diff --git a/src/aihwkit/simulator/tiles/periphery.py b/src/aihwkit/simulator/tiles/periphery.py index da5af0a3..a9f2d950 100644 --- a/src/aihwkit/simulator/tiles/periphery.py +++ b/src/aihwkit/simulator/tiles/periphery.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Base tile with added periphery and common utility methods.""" diff --git a/src/aihwkit/simulator/tiles/rpucuda.py b/src/aihwkit/simulator/tiles/rpucuda.py index cdddeb75..e549d438 100644 --- a/src/aihwkit/simulator/tiles/rpucuda.py +++ b/src/aihwkit/simulator/tiles/rpucuda.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Wrapper for the RPUCuda C++ tiles.""" diff --git a/src/aihwkit/simulator/tiles/torch_tile.py b/src/aihwkit/simulator/tiles/torch_tile.py index 62829c96..6c8dbd66 100644 --- a/src/aihwkit/simulator/tiles/torch_tile.py +++ b/src/aihwkit/simulator/tiles/torch_tile.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Low level implementation of torch-based tile.""" diff --git a/src/aihwkit/simulator/tiles/torch_tile_irdrop_t.py b/src/aihwkit/simulator/tiles/torch_tile_irdrop_t.py index c74ba8d6..b05105c0 100644 --- a/src/aihwkit/simulator/tiles/torch_tile_irdrop_t.py +++ b/src/aihwkit/simulator/tiles/torch_tile_irdrop_t.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals, too-many-arguments diff --git a/src/aihwkit/simulator/tiles/transfer.py b/src/aihwkit/simulator/tiles/transfer.py index 8569e269..12939aff 100644 --- a/src/aihwkit/simulator/tiles/transfer.py +++ b/src/aihwkit/simulator/tiles/transfer.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-instance-attributes diff --git a/src/aihwkit/simulator/tiles/utils.py b/src/aihwkit/simulator/tiles/utils.py index 8e02c078..12434c18 100644 --- a/src/aihwkit/simulator/tiles/utils.py +++ b/src/aihwkit/simulator/tiles/utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Low level implementation of torch-based tile.""" diff --git a/src/aihwkit/utils/__init__.py b/src/aihwkit/utils/__init__.py index 5d776fae..b9121372 100644 --- a/src/aihwkit/utils/__init__.py +++ b/src/aihwkit/utils/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Utilities and helpers for aihwkit.""" diff --git a/src/aihwkit/utils/analog_info.py b/src/aihwkit/utils/analog_info.py index 973d15e9..d25c72d7 100644 --- a/src/aihwkit/utils/analog_info.py +++ b/src/aihwkit/utils/analog_info.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Analog Information utility. diff --git a/src/aihwkit/utils/export.py b/src/aihwkit/utils/export.py index dfa72016..c4bd5791 100644 --- a/src/aihwkit/utils/export.py +++ b/src/aihwkit/utils/export.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals diff --git a/src/aihwkit/utils/fitting.py b/src/aihwkit/utils/fitting.py index e2f2c401..acb05c2d 100644 --- a/src/aihwkit/utils/fitting.py +++ b/src/aihwkit/utils/fitting.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals, too-many-branches diff --git a/src/aihwkit/utils/legacy.py b/src/aihwkit/utils/legacy.py index 9c733501..25d5304b 100644 --- a/src/aihwkit/utils/legacy.py +++ b/src/aihwkit/utils/legacy.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Conversion script of legacy checkpoints (pre v0.8) to the new format.""" diff --git a/src/aihwkit/utils/visualization.py b/src/aihwkit/utils/visualization.py index 05b55e80..c0a1f888 100644 --- a/src/aihwkit/utils/visualization.py +++ b/src/aihwkit/utils/visualization.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Visualization utilities. diff --git a/src/aihwkit/utils/visualization_web.py b/src/aihwkit/utils/visualization_web.py index e0039e04..6d3579ec 100644 --- a/src/aihwkit/utils/visualization_web.py +++ b/src/aihwkit/utils/visualization_web.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Visualization utilities (web).""" diff --git a/src/aihwkit/version.py b/src/aihwkit/version.py index ec3d141f..9ef65a72 100644 --- a/src/aihwkit/version.py +++ b/src/aihwkit/version.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Package version string.""" diff --git a/src/rpucuda/CMakeLists.txt b/src/rpucuda/CMakeLists.txt index 202e846c..461f3cf5 100644 --- a/src/rpucuda/CMakeLists.txt +++ b/src/rpucuda/CMakeLists.txt @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # Simulator main files. file(GLOB RPU_CPU_SRCS *.cpp) diff --git a/src/rpucuda/cuda/CMakeLists.txt b/src/rpucuda/cuda/CMakeLists.txt index 17500106..23dd1ecd 100644 --- a/src/rpucuda/cuda/CMakeLists.txt +++ b/src/rpucuda/cuda/CMakeLists.txt @@ -1,12 +1,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # Simulator main files. file(GLOB RPU_GPU_SRCS *.cu) diff --git a/src/rpucuda/cuda/bit_line_maker.cu b/src/rpucuda/cuda/bit_line_maker.cu index 04d81960..1c7ee352 100644 --- a/src/rpucuda/cuda/bit_line_maker.cu +++ b/src/rpucuda/cuda/bit_line_maker.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "bit_line_maker.h" diff --git a/src/rpucuda/cuda/bit_line_maker.h b/src/rpucuda/cuda/bit_line_maker.h index d3d044d1..b254a7ad 100644 --- a/src/rpucuda/cuda/bit_line_maker.h +++ b/src/rpucuda/cuda/bit_line_maker.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/bit_line_maker_test.cpp b/src/rpucuda/cuda/bit_line_maker_test.cpp index a5bedc6e..b135078d 100644 --- a/src/rpucuda/cuda/bit_line_maker_test.cpp +++ b/src/rpucuda/cuda/bit_line_maker_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "bit_line_maker.h" diff --git a/src/rpucuda/cuda/chopped_weight_output.cu b/src/rpucuda/cuda/chopped_weight_output.cu index 6fbb046d..d5dff5dd 100644 --- a/src/rpucuda/cuda/chopped_weight_output.cu +++ b/src/rpucuda/cuda/chopped_weight_output.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "chopped_weight_output.h" diff --git a/src/rpucuda/cuda/chopped_weight_output.h b/src/rpucuda/cuda/chopped_weight_output.h index 504aad69..9af118f6 100644 --- a/src/rpucuda/cuda/chopped_weight_output.h +++ b/src/rpucuda/cuda/chopped_weight_output.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/cuda_buffer.cu b/src/rpucuda/cuda/cuda_buffer.cu index 835b9ec1..0e844439 100644 --- a/src/rpucuda/cuda/cuda_buffer.cu +++ b/src/rpucuda/cuda/cuda_buffer.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_buffer.h" diff --git a/src/rpucuda/cuda/cuda_buffer.h b/src/rpucuda/cuda/cuda_buffer.h index b212fb9b..fc8e4bcb 100644 --- a/src/rpucuda/cuda/cuda_buffer.h +++ b/src/rpucuda/cuda/cuda_buffer.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/cuda_fp16_util.h b/src/rpucuda/cuda/cuda_fp16_util.h index f7066388..4ab7d01e 100644 --- a/src/rpucuda/cuda/cuda_fp16_util.h +++ b/src/rpucuda/cuda/cuda_fp16_util.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/cuda_math_util.cu b/src/rpucuda/cuda/cuda_math_util.cu index 04aebd4d..4eadeae3 100644 --- a/src/rpucuda/cuda/cuda_math_util.cu +++ b/src/rpucuda/cuda/cuda_math_util.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/cuda_math_util.h b/src/rpucuda/cuda/cuda_math_util.h index a570a9e7..aafdd30f 100644 --- a/src/rpucuda/cuda/cuda_math_util.h +++ b/src/rpucuda/cuda/cuda_math_util.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/cuda_util.cu b/src/rpucuda/cuda/cuda_util.cu index dc184fdd..b1c45a9a 100644 --- a/src/rpucuda/cuda/cuda_util.cu +++ b/src/rpucuda/cuda/cuda_util.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/cuda_util.h b/src/rpucuda/cuda/cuda_util.h index bb67c0a7..f6eeea5b 100644 --- a/src/rpucuda/cuda/cuda_util.h +++ b/src/rpucuda/cuda/cuda_util.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/forward_backward_pass.cu b/src/rpucuda/cuda/forward_backward_pass.cu index 9f2f6fee..02c75447 100644 --- a/src/rpucuda/cuda/forward_backward_pass.cu +++ b/src/rpucuda/cuda/forward_backward_pass.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "io_manager.h" diff --git a/src/rpucuda/cuda/forward_backward_pass.h b/src/rpucuda/cuda/forward_backward_pass.h index baa3b63d..95e9d691 100644 --- a/src/rpucuda/cuda/forward_backward_pass.h +++ b/src/rpucuda/cuda/forward_backward_pass.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/forward_backward_pass_test.cpp b/src/rpucuda/cuda/forward_backward_pass_test.cpp index edc30be2..0338c1d6 100644 --- a/src/rpucuda/cuda/forward_backward_pass_test.cpp +++ b/src/rpucuda/cuda/forward_backward_pass_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/io_iterator.h b/src/rpucuda/cuda/io_iterator.h index 05788ebf..b99992c5 100644 --- a/src/rpucuda/cuda/io_iterator.h +++ b/src/rpucuda/cuda/io_iterator.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/io_iterator_test.cpp b/src/rpucuda/cuda/io_iterator_test.cpp index 56545583..064f02e5 100644 --- a/src/rpucuda/cuda/io_iterator_test.cpp +++ b/src/rpucuda/cuda/io_iterator_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/io_manager.cu b/src/rpucuda/cuda/io_manager.cu index b09e804f..d402c392 100644 --- a/src/rpucuda/cuda/io_manager.cu +++ b/src/rpucuda/cuda/io_manager.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "io_manager.h" diff --git a/src/rpucuda/cuda/io_manager.h b/src/rpucuda/cuda/io_manager.h index cd1944b3..e496d87d 100644 --- a/src/rpucuda/cuda/io_manager.h +++ b/src/rpucuda/cuda/io_manager.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/io_manager_test.cpp b/src/rpucuda/cuda/io_manager_test.cpp index 5da9c235..0cb08f6f 100644 --- a/src/rpucuda/cuda/io_manager_test.cpp +++ b/src/rpucuda/cuda/io_manager_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/maximizer.cu b/src/rpucuda/cuda/maximizer.cu index ff626f4c..442580c9 100644 --- a/src/rpucuda/cuda/maximizer.cu +++ b/src/rpucuda/cuda/maximizer.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "maximizer.h" diff --git a/src/rpucuda/cuda/maximizer.h b/src/rpucuda/cuda/maximizer.h index b8b8b8ee..66208873 100644 --- a/src/rpucuda/cuda/maximizer.h +++ b/src/rpucuda/cuda/maximizer.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/maximizer_test.cpp b/src/rpucuda/cuda/maximizer_test.cpp index 44081465..2dd26c23 100644 --- a/src/rpucuda/cuda/maximizer_test.cpp +++ b/src/rpucuda/cuda/maximizer_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/noise_manager.cu b/src/rpucuda/cuda/noise_manager.cu index e1747bd6..96fec531 100644 --- a/src/rpucuda/cuda/noise_manager.cu +++ b/src/rpucuda/cuda/noise_manager.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "noise_manager.h" diff --git a/src/rpucuda/cuda/noise_manager.h b/src/rpucuda/cuda/noise_manager.h index 97c38086..801cf0f9 100644 --- a/src/rpucuda/cuda/noise_manager.h +++ b/src/rpucuda/cuda/noise_manager.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/pulsed_weight_updater.cu b/src/rpucuda/cuda/pulsed_weight_updater.cu index 3d9b9589..d4a54012 100644 --- a/src/rpucuda/cuda/pulsed_weight_updater.cu +++ b/src/rpucuda/cuda/pulsed_weight_updater.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/pulsed_weight_updater.h b/src/rpucuda/cuda/pulsed_weight_updater.h index 1c457e2f..cfd229ae 100644 --- a/src/rpucuda/cuda/pulsed_weight_updater.h +++ b/src/rpucuda/cuda/pulsed_weight_updater.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/pulsed_weight_updater_test.cpp b/src/rpucuda/cuda/pulsed_weight_updater_test.cpp index 6459c0d0..e241bc18 100644 --- a/src/rpucuda/cuda/pulsed_weight_updater_test.cpp +++ b/src/rpucuda/cuda/pulsed_weight_updater_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "bit_line_maker.h" diff --git a/src/rpucuda/cuda/pwu_kernel.h b/src/rpucuda/cuda/pwu_kernel.h index 4dc9c0db..5879198a 100644 --- a/src/rpucuda/cuda/pwu_kernel.h +++ b/src/rpucuda/cuda/pwu_kernel.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/pwu_kernel_parameter.h b/src/rpucuda/cuda/pwu_kernel_parameter.h index 7ef684ec..ccc78e00 100644 --- a/src/rpucuda/cuda/pwu_kernel_parameter.h +++ b/src/rpucuda/cuda/pwu_kernel_parameter.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/pwu_kernel_parameter_base.h b/src/rpucuda/cuda/pwu_kernel_parameter_base.h index 390f684a..268be129 100644 --- a/src/rpucuda/cuda/pwu_kernel_parameter_base.h +++ b/src/rpucuda/cuda/pwu_kernel_parameter_base.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpu_cub.h b/src/rpucuda/cuda/rpu_cub.h index b1fe2469..48a756c4 100644 --- a/src/rpucuda/cuda/rpu_cub.h +++ b/src/rpucuda/cuda/rpu_cub.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda.cu b/src/rpucuda/cuda/rpucuda.cu index 22477f59..d0246dec 100644 --- a/src/rpucuda/cuda/rpucuda.cu +++ b/src/rpucuda/cuda/rpucuda.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "forward_backward_pass.h" diff --git a/src/rpucuda/cuda/rpucuda.h b/src/rpucuda/cuda/rpucuda.h index 6da9a6a9..0d572b13 100644 --- a/src/rpucuda/cuda/rpucuda.h +++ b/src/rpucuda/cuda/rpucuda.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_buffered_transfer_device.cu b/src/rpucuda/cuda/rpucuda_buffered_transfer_device.cu index 857085e9..260bdb44 100644 --- a/src/rpucuda/cuda/rpucuda_buffered_transfer_device.cu +++ b/src/rpucuda/cuda/rpucuda_buffered_transfer_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/rpucuda_buffered_transfer_device.h b/src/rpucuda/cuda/rpucuda_buffered_transfer_device.h index 677c82a6..aebbeaee 100644 --- a/src/rpucuda/cuda/rpucuda_buffered_transfer_device.h +++ b/src/rpucuda/cuda/rpucuda_buffered_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_buffered_transfer_device_test.cpp b/src/rpucuda/cuda/rpucuda_buffered_transfer_device_test.cpp index 9b25171e..9aca0ce9 100644 --- a/src/rpucuda/cuda/rpucuda_buffered_transfer_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_buffered_transfer_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_chopped_transfer_device.cu b/src/rpucuda/cuda/rpucuda_chopped_transfer_device.cu index 4a27e9dc..b609ede3 100644 --- a/src/rpucuda/cuda/rpucuda_chopped_transfer_device.cu +++ b/src/rpucuda/cuda/rpucuda_chopped_transfer_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/rpucuda_chopped_transfer_device.h b/src/rpucuda/cuda/rpucuda_chopped_transfer_device.h index 4bf3baaf..fc768ddf 100644 --- a/src/rpucuda/cuda/rpucuda_chopped_transfer_device.h +++ b/src/rpucuda/cuda/rpucuda_chopped_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_chopped_transfer_device_test.cpp b/src/rpucuda/cuda/rpucuda_chopped_transfer_device_test.cpp index 8993848b..aa1c4bc2 100644 --- a/src/rpucuda/cuda/rpucuda_chopped_transfer_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_chopped_transfer_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_constantstep_device.cu b/src/rpucuda/cuda/rpucuda_constantstep_device.cu index 8af3c7c7..ae978911 100644 --- a/src/rpucuda/cuda/rpucuda_constantstep_device.cu +++ b/src/rpucuda/cuda/rpucuda_constantstep_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_constantstep_device.h b/src/rpucuda/cuda/rpucuda_constantstep_device.h index 6c6b54f4..7800709b 100644 --- a/src/rpucuda/cuda/rpucuda_constantstep_device.h +++ b/src/rpucuda/cuda/rpucuda_constantstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.cu b/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.cu index ee41f20a..e3348da1 100644 --- a/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.cu +++ b/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.h b/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.h index ec8469d1..db1366ab 100644 --- a/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.h +++ b/src/rpucuda/cuda/rpucuda_dynamic_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_expstep_device.cu b/src/rpucuda/cuda/rpucuda_expstep_device.cu index e5f27642..15b010e3 100644 --- a/src/rpucuda/cuda/rpucuda_expstep_device.cu +++ b/src/rpucuda/cuda/rpucuda_expstep_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_expstep_device.h b/src/rpucuda/cuda/rpucuda_expstep_device.h index fcc9cf40..117cc66a 100644 --- a/src/rpucuda/cuda/rpucuda_expstep_device.h +++ b/src/rpucuda/cuda/rpucuda_expstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_expstep_test.cpp b/src/rpucuda/cuda/rpucuda_expstep_test.cpp index e706985f..9b89db35 100644 --- a/src/rpucuda/cuda/rpucuda_expstep_test.cpp +++ b/src/rpucuda/cuda/rpucuda_expstep_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_hidden_device.cu b/src/rpucuda/cuda/rpucuda_hidden_device.cu index a0fd3e46..297027b4 100644 --- a/src/rpucuda/cuda/rpucuda_hidden_device.cu +++ b/src/rpucuda/cuda/rpucuda_hidden_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_hidden_device.h b/src/rpucuda/cuda/rpucuda_hidden_device.h index 4bb6f811..e834db98 100644 --- a/src/rpucuda/cuda/rpucuda_hidden_device.h +++ b/src/rpucuda/cuda/rpucuda_hidden_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_hidden_test.cpp b/src/rpucuda/cuda/rpucuda_hidden_test.cpp index 70cce1ac..a7482b6f 100644 --- a/src/rpucuda/cuda/rpucuda_hidden_test.cpp +++ b/src/rpucuda/cuda/rpucuda_hidden_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_linearstep_device.cu b/src/rpucuda/cuda/rpucuda_linearstep_device.cu index da5fc63e..84983c39 100644 --- a/src/rpucuda/cuda/rpucuda_linearstep_device.cu +++ b/src/rpucuda/cuda/rpucuda_linearstep_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_linearstep_device.h b/src/rpucuda/cuda/rpucuda_linearstep_device.h index 6e68965f..5b545de1 100644 --- a/src/rpucuda/cuda/rpucuda_linearstep_device.h +++ b/src/rpucuda/cuda/rpucuda_linearstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_linearstep_test.cpp b/src/rpucuda/cuda/rpucuda_linearstep_test.cpp index 476e9289..0d51bc1e 100644 --- a/src/rpucuda/cuda/rpucuda_linearstep_test.cpp +++ b/src/rpucuda/cuda/rpucuda_linearstep_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_device.cu b/src/rpucuda/cuda/rpucuda_mixedprec_device.cu index edb0fbe1..a20c40be 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_device.cu +++ b/src/rpucuda/cuda/rpucuda_mixedprec_device.cu @@ -2,13 +2,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_device.h b/src/rpucuda/cuda/rpucuda_mixedprec_device.h index ebed8d9a..d8d3b44f 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_device.h +++ b/src/rpucuda/cuda/rpucuda_mixedprec_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_device_base.cu b/src/rpucuda/cuda/rpucuda_mixedprec_device_base.cu index a89b3c67..9a0fca48 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_device_base.cu +++ b/src/rpucuda/cuda/rpucuda_mixedprec_device_base.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_device_base.h b/src/rpucuda/cuda/rpucuda_mixedprec_device_base.h index c6e1e691..54b2cc07 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_device_base.h +++ b/src/rpucuda/cuda/rpucuda_mixedprec_device_base.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_device_test.cpp b/src/rpucuda/cuda/rpucuda_mixedprec_device_test.cpp index d84bb22b..4ade5196 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_mixedprec_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_int_device.cu b/src/rpucuda/cuda/rpucuda_mixedprec_int_device.cu index c4f65c0e..c5d411c7 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_int_device.cu +++ b/src/rpucuda/cuda/rpucuda_mixedprec_int_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_int_device.h b/src/rpucuda/cuda/rpucuda_mixedprec_int_device.h index e9906c90..832f2615 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_int_device.h +++ b/src/rpucuda/cuda/rpucuda_mixedprec_int_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_mixedprec_int_device_test.cpp b/src/rpucuda/cuda/rpucuda_mixedprec_int_device_test.cpp index ca6d2d3c..fd21888d 100644 --- a/src/rpucuda/cuda/rpucuda_mixedprec_int_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_mixedprec_int_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_onesided_device.cu b/src/rpucuda/cuda/rpucuda_onesided_device.cu index 31ca6da3..c24b5a91 100644 --- a/src/rpucuda/cuda/rpucuda_onesided_device.cu +++ b/src/rpucuda/cuda/rpucuda_onesided_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "forward_backward_pass.h" diff --git a/src/rpucuda/cuda/rpucuda_onesided_device.h b/src/rpucuda/cuda/rpucuda_onesided_device.h index 3a9fc0fe..24203418 100644 --- a/src/rpucuda/cuda/rpucuda_onesided_device.h +++ b/src/rpucuda/cuda/rpucuda_onesided_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_onesided_device_test.cpp b/src/rpucuda/cuda/rpucuda_onesided_device_test.cpp index a684b45f..f4052f31 100644 --- a/src/rpucuda/cuda/rpucuda_onesided_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_onesided_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_piecewisestep_device.cu b/src/rpucuda/cuda/rpucuda_piecewisestep_device.cu index e96c44d4..38849dd5 100644 --- a/src/rpucuda/cuda/rpucuda_piecewisestep_device.cu +++ b/src/rpucuda/cuda/rpucuda_piecewisestep_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_piecewisestep_device.h b/src/rpucuda/cuda/rpucuda_piecewisestep_device.h index 2772cfec..8a73070b 100644 --- a/src/rpucuda/cuda/rpucuda_piecewisestep_device.h +++ b/src/rpucuda/cuda/rpucuda_piecewisestep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_powstep_device.cu b/src/rpucuda/cuda/rpucuda_powstep_device.cu index c529de26..638df386 100644 --- a/src/rpucuda/cuda/rpucuda_powstep_device.cu +++ b/src/rpucuda/cuda/rpucuda_powstep_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_powstep_device.h b/src/rpucuda/cuda/rpucuda_powstep_device.h index 16426d9d..a5928484 100644 --- a/src/rpucuda/cuda/rpucuda_powstep_device.h +++ b/src/rpucuda/cuda/rpucuda_powstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_powstep_reference_device.cu b/src/rpucuda/cuda/rpucuda_powstep_reference_device.cu index 6276a065..e653b84e 100644 --- a/src/rpucuda/cuda/rpucuda_powstep_reference_device.cu +++ b/src/rpucuda/cuda/rpucuda_powstep_reference_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_powstep_reference_device.h b/src/rpucuda/cuda/rpucuda_powstep_reference_device.h index d336425d..6aeab6ee 100644 --- a/src/rpucuda/cuda/rpucuda_powstep_reference_device.h +++ b/src/rpucuda/cuda/rpucuda_powstep_reference_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_powstep_test.cpp b/src/rpucuda/cuda/rpucuda_powstep_test.cpp index dcb6e9f7..0858649d 100644 --- a/src/rpucuda/cuda/rpucuda_powstep_test.cpp +++ b/src/rpucuda/cuda/rpucuda_powstep_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_pulsed.cu b/src/rpucuda/cuda/rpucuda_pulsed.cu index 0b553548..eb0d2130 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed.cu +++ b/src/rpucuda/cuda/rpucuda_pulsed.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "forward_backward_pass.h" diff --git a/src/rpucuda/cuda/rpucuda_pulsed.h b/src/rpucuda/cuda/rpucuda_pulsed.h index 3669a2a2..b4738890 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed.h +++ b/src/rpucuda/cuda/rpucuda_pulsed.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_pulsed_device.cu b/src/rpucuda/cuda/rpucuda_pulsed_device.cu index eb80ac84..f41eca18 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed_device.cu +++ b/src/rpucuda/cuda/rpucuda_pulsed_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_pulsed_device.h b/src/rpucuda/cuda/rpucuda_pulsed_device.h index fb8a7c34..93039855 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed_device.h +++ b/src/rpucuda/cuda/rpucuda_pulsed_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_pulsed_device_test.cpp b/src/rpucuda/cuda/rpucuda_pulsed_device_test.cpp index 77496c78..45bb0ea0 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_pulsed_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_pulsed_test.cpp b/src/rpucuda/cuda/rpucuda_pulsed_test.cpp index 226fbe6f..8fb0eee6 100644 --- a/src/rpucuda/cuda/rpucuda_pulsed_test.cpp +++ b/src/rpucuda/cuda/rpucuda_pulsed_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_simple_device.cu b/src/rpucuda/cuda/rpucuda_simple_device.cu index fea310b1..28919e7c 100644 --- a/src/rpucuda/cuda/rpucuda_simple_device.cu +++ b/src/rpucuda/cuda/rpucuda_simple_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_simple_device.h b/src/rpucuda/cuda/rpucuda_simple_device.h index 4143fbb3..6e0e6172 100644 --- a/src/rpucuda/cuda/rpucuda_simple_device.h +++ b/src/rpucuda/cuda/rpucuda_simple_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_simple_device_test.cpp b/src/rpucuda/cuda/rpucuda_simple_device_test.cpp index f1174841..6631ea6b 100644 --- a/src/rpucuda/cuda/rpucuda_simple_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_simple_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_softbounds_reference_device.cu b/src/rpucuda/cuda/rpucuda_softbounds_reference_device.cu index af6f4b60..c41807c8 100644 --- a/src/rpucuda/cuda/rpucuda_softbounds_reference_device.cu +++ b/src/rpucuda/cuda/rpucuda_softbounds_reference_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "pwu_kernel_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_softbounds_reference_device.h b/src/rpucuda/cuda/rpucuda_softbounds_reference_device.h index 1eec085f..257c6828 100644 --- a/src/rpucuda/cuda/rpucuda_softbounds_reference_device.h +++ b/src/rpucuda/cuda/rpucuda_softbounds_reference_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_test.cpp b/src/rpucuda/cuda/rpucuda_test.cpp index 964e79ed..dee02854 100644 --- a/src/rpucuda/cuda/rpucuda_test.cpp +++ b/src/rpucuda/cuda/rpucuda_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/rpucuda_transfer_device.cu b/src/rpucuda/cuda/rpucuda_transfer_device.cu index 864b9f1e..374eb824 100644 --- a/src/rpucuda/cuda/rpucuda_transfer_device.cu +++ b/src/rpucuda/cuda/rpucuda_transfer_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "forward_backward_pass.h" diff --git a/src/rpucuda/cuda/rpucuda_transfer_device.h b/src/rpucuda/cuda/rpucuda_transfer_device.h index 635443c8..c60270fb 100644 --- a/src/rpucuda/cuda/rpucuda_transfer_device.h +++ b/src/rpucuda/cuda/rpucuda_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_transfer_device_test.cpp b/src/rpucuda/cuda/rpucuda_transfer_device_test.cpp index c059d072..760b68c1 100644 --- a/src/rpucuda/cuda/rpucuda_transfer_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_transfer_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_util.h" diff --git a/src/rpucuda/cuda/rpucuda_vector_device.cu b/src/rpucuda/cuda/rpucuda_vector_device.cu index 1391ac15..da12e24b 100644 --- a/src/rpucuda/cuda/rpucuda_vector_device.cu +++ b/src/rpucuda/cuda/rpucuda_vector_device.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_pulsed_meta_parameter.h" diff --git a/src/rpucuda/cuda/rpucuda_vector_device.h b/src/rpucuda/cuda/rpucuda_vector_device.h index 727df8b1..842bd76d 100644 --- a/src/rpucuda/cuda/rpucuda_vector_device.h +++ b/src/rpucuda/cuda/rpucuda_vector_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/rpucuda_vector_device_test.cpp b/src/rpucuda/cuda/rpucuda_vector_device_test.cpp index 461b4478..ca794ec3 100644 --- a/src/rpucuda/cuda/rpucuda_vector_device_test.cpp +++ b/src/rpucuda/cuda/rpucuda_vector_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/test_helper.cu b/src/rpucuda/cuda/test_helper.cu index 52efbe2a..284faa71 100644 --- a/src/rpucuda/cuda/test_helper.cu +++ b/src/rpucuda/cuda/test_helper.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/test_helper.h b/src/rpucuda/cuda/test_helper.h index 673c4a6c..22f8f6a7 100644 --- a/src/rpucuda/cuda/test_helper.h +++ b/src/rpucuda/cuda/test_helper.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/update_management_helper.cu b/src/rpucuda/cuda/update_management_helper.cu index 01c24b0d..524489ac 100644 --- a/src/rpucuda/cuda/update_management_helper.cu +++ b/src/rpucuda/cuda/update_management_helper.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "bit_line_maker.h" diff --git a/src/rpucuda/cuda/update_management_helper.h b/src/rpucuda/cuda/update_management_helper.h index b55a8529..d823857b 100644 --- a/src/rpucuda/cuda/update_management_helper.h +++ b/src/rpucuda/cuda/update_management_helper.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/update_management_helper_test.cpp b/src/rpucuda/cuda/update_management_helper_test.cpp index 4cb981b9..56455a90 100644 --- a/src/rpucuda/cuda/update_management_helper_test.cpp +++ b/src/rpucuda/cuda/update_management_helper_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "bit_line_maker.h" diff --git a/src/rpucuda/cuda/weight_clipper_cuda.cu b/src/rpucuda/cuda/weight_clipper_cuda.cu index dad6ece5..5f6427ee 100644 --- a/src/rpucuda/cuda/weight_clipper_cuda.cu +++ b/src/rpucuda/cuda/weight_clipper_cuda.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/weight_clipper_cuda.h b/src/rpucuda/cuda/weight_clipper_cuda.h index cb8d9305..8e1feb5c 100644 --- a/src/rpucuda/cuda/weight_clipper_cuda.h +++ b/src/rpucuda/cuda/weight_clipper_cuda.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/weight_clipper_cuda_test.cpp b/src/rpucuda/cuda/weight_clipper_cuda_test.cpp index 0e154735..2bbe80f9 100644 --- a/src/rpucuda/cuda/weight_clipper_cuda_test.cpp +++ b/src/rpucuda/cuda/weight_clipper_cuda_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda.h" diff --git a/src/rpucuda/cuda/weight_drifter_cuda.cu b/src/rpucuda/cuda/weight_drifter_cuda.cu index 59237996..20978ea3 100644 --- a/src/rpucuda/cuda/weight_drifter_cuda.cu +++ b/src/rpucuda/cuda/weight_drifter_cuda.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/weight_drifter_cuda.h b/src/rpucuda/cuda/weight_drifter_cuda.h index 4275d839..da7197c4 100644 --- a/src/rpucuda/cuda/weight_drifter_cuda.h +++ b/src/rpucuda/cuda/weight_drifter_cuda.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/weight_drifter_cuda_test.cpp b/src/rpucuda/cuda/weight_drifter_cuda_test.cpp index 0dd8c039..559bf42c 100644 --- a/src/rpucuda/cuda/weight_drifter_cuda_test.cpp +++ b/src/rpucuda/cuda/weight_drifter_cuda_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_math_util.h" diff --git a/src/rpucuda/cuda/weight_modifier_cuda.cu b/src/rpucuda/cuda/weight_modifier_cuda.cu index 0380a739..99905828 100644 --- a/src/rpucuda/cuda/weight_modifier_cuda.cu +++ b/src/rpucuda/cuda/weight_modifier_cuda.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/weight_modifier_cuda.h b/src/rpucuda/cuda/weight_modifier_cuda.h index 7c6549c4..36de5897 100644 --- a/src/rpucuda/cuda/weight_modifier_cuda.h +++ b/src/rpucuda/cuda/weight_modifier_cuda.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/cuda/weight_remapper_cuda.cu b/src/rpucuda/cuda/weight_remapper_cuda.cu index 0ac32978..9a3c0ea4 100644 --- a/src/rpucuda/cuda/weight_remapper_cuda.cu +++ b/src/rpucuda/cuda/weight_remapper_cuda.cu @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "cuda_fp16_util.h" diff --git a/src/rpucuda/cuda/weight_remapper_cuda.h b/src/rpucuda/cuda/weight_remapper_cuda.h index e1e90606..c222b79a 100644 --- a/src/rpucuda/cuda/weight_remapper_cuda.h +++ b/src/rpucuda/cuda/weight_remapper_cuda.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/dense_bit_line_maker.cpp b/src/rpucuda/dense_bit_line_maker.cpp index d760b079..c66f0be4 100644 --- a/src/rpucuda/dense_bit_line_maker.cpp +++ b/src/rpucuda/dense_bit_line_maker.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "dense_bit_line_maker.h" diff --git a/src/rpucuda/dense_bit_line_maker.h b/src/rpucuda/dense_bit_line_maker.h index 1f87e417..87315ae0 100644 --- a/src/rpucuda/dense_bit_line_maker.h +++ b/src/rpucuda/dense_bit_line_maker.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/math_util.cpp b/src/rpucuda/math_util.cpp index 2a6f8b23..48b6cbad 100644 --- a/src/rpucuda/math_util.cpp +++ b/src/rpucuda/math_util.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "math_util.h" diff --git a/src/rpucuda/math_util.h b/src/rpucuda/math_util.h index 0789d83a..f32af617 100644 --- a/src/rpucuda/math_util.h +++ b/src/rpucuda/math_util.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rng.cpp b/src/rpucuda/rng.cpp index da6630c1..fc934cef 100644 --- a/src/rpucuda/rng.cpp +++ b/src/rpucuda/rng.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rng.h" diff --git a/src/rpucuda/rng.h b/src/rpucuda/rng.h index 0ec8d62e..15599a54 100644 --- a/src/rpucuda/rng.h +++ b/src/rpucuda/rng.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu.cpp b/src/rpucuda/rpu.cpp index 4978bf5f..b58dd501 100644 --- a/src/rpucuda/rpu.cpp +++ b/src/rpucuda/rpu.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu.h" diff --git a/src/rpucuda/rpu.h b/src/rpucuda/rpu.h index 787059a8..73ec9498 100644 --- a/src/rpucuda/rpu.h +++ b/src/rpucuda/rpu.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_buffered_transfer_device.cpp b/src/rpucuda/rpu_buffered_transfer_device.cpp index 03535a4c..4e71de76 100644 --- a/src/rpucuda/rpu_buffered_transfer_device.cpp +++ b/src/rpucuda/rpu_buffered_transfer_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_buffered_transfer_device.h" diff --git a/src/rpucuda/rpu_buffered_transfer_device.h b/src/rpucuda/rpu_buffered_transfer_device.h index 5e983f8a..14ef65f2 100644 --- a/src/rpucuda/rpu_buffered_transfer_device.h +++ b/src/rpucuda/rpu_buffered_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_chopped_transfer_device.cpp b/src/rpucuda/rpu_chopped_transfer_device.cpp index 750e7c27..4a8ce29e 100644 --- a/src/rpucuda/rpu_chopped_transfer_device.cpp +++ b/src/rpucuda/rpu_chopped_transfer_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_chopped_transfer_device.h" diff --git a/src/rpucuda/rpu_chopped_transfer_device.h b/src/rpucuda/rpu_chopped_transfer_device.h index 51ff13d8..dc346738 100644 --- a/src/rpucuda/rpu_chopped_transfer_device.h +++ b/src/rpucuda/rpu_chopped_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_constantstep_device.cpp b/src/rpucuda/rpu_constantstep_device.cpp index 51991526..d284b35c 100644 --- a/src/rpucuda/rpu_constantstep_device.cpp +++ b/src/rpucuda/rpu_constantstep_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_constantstep_device.h" diff --git a/src/rpucuda/rpu_constantstep_device.h b/src/rpucuda/rpu_constantstep_device.h index c8c75be2..82587ec0 100644 --- a/src/rpucuda/rpu_constantstep_device.h +++ b/src/rpucuda/rpu_constantstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_dynamic_transfer_device.cpp b/src/rpucuda/rpu_dynamic_transfer_device.cpp index e03c9c57..c723dd8b 100644 --- a/src/rpucuda/rpu_dynamic_transfer_device.cpp +++ b/src/rpucuda/rpu_dynamic_transfer_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_dynamic_transfer_device.h" diff --git a/src/rpucuda/rpu_dynamic_transfer_device.h b/src/rpucuda/rpu_dynamic_transfer_device.h index a51fe590..da567683 100644 --- a/src/rpucuda/rpu_dynamic_transfer_device.h +++ b/src/rpucuda/rpu_dynamic_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_expstep_device.cpp b/src/rpucuda/rpu_expstep_device.cpp index 139b4851..7293bb80 100644 --- a/src/rpucuda/rpu_expstep_device.cpp +++ b/src/rpucuda/rpu_expstep_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_expstep_device.h" diff --git a/src/rpucuda/rpu_expstep_device.h b/src/rpucuda/rpu_expstep_device.h index 138725fa..623f374f 100644 --- a/src/rpucuda/rpu_expstep_device.h +++ b/src/rpucuda/rpu_expstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_forward_backward_pass.cpp b/src/rpucuda/rpu_forward_backward_pass.cpp index 9661554a..329d62be 100644 --- a/src/rpucuda/rpu_forward_backward_pass.cpp +++ b/src/rpucuda/rpu_forward_backward_pass.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_forward_backward_pass.h" diff --git a/src/rpucuda/rpu_forward_backward_pass.h b/src/rpucuda/rpu_forward_backward_pass.h index 8b074c50..bfcaa2ff 100644 --- a/src/rpucuda/rpu_forward_backward_pass.h +++ b/src/rpucuda/rpu_forward_backward_pass.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_hidden_device.cpp b/src/rpucuda/rpu_hidden_device.cpp index 85ed88d1..79471626 100644 --- a/src/rpucuda/rpu_hidden_device.cpp +++ b/src/rpucuda/rpu_hidden_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_hidden_device.h" diff --git a/src/rpucuda/rpu_hidden_device.h b/src/rpucuda/rpu_hidden_device.h index 4f022c69..a2b8a3ce 100644 --- a/src/rpucuda/rpu_hidden_device.h +++ b/src/rpucuda/rpu_hidden_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_linearstep_device.cpp b/src/rpucuda/rpu_linearstep_device.cpp index ed46f4e6..c730d5c0 100644 --- a/src/rpucuda/rpu_linearstep_device.cpp +++ b/src/rpucuda/rpu_linearstep_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_linearstep_device.h" diff --git a/src/rpucuda/rpu_linearstep_device.h b/src/rpucuda/rpu_linearstep_device.h index f5cb0e40..0b5e735d 100644 --- a/src/rpucuda/rpu_linearstep_device.h +++ b/src/rpucuda/rpu_linearstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_mixedprec_device.cpp b/src/rpucuda/rpu_mixedprec_device.cpp index 071a5836..117cf00e 100644 --- a/src/rpucuda/rpu_mixedprec_device.cpp +++ b/src/rpucuda/rpu_mixedprec_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_mixedprec_device.h" diff --git a/src/rpucuda/rpu_mixedprec_device.h b/src/rpucuda/rpu_mixedprec_device.h index 7c9cab78..f9c8e1ad 100644 --- a/src/rpucuda/rpu_mixedprec_device.h +++ b/src/rpucuda/rpu_mixedprec_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_mixedprec_device_base.cpp b/src/rpucuda/rpu_mixedprec_device_base.cpp index 465aafee..3e94f35d 100644 --- a/src/rpucuda/rpu_mixedprec_device_base.cpp +++ b/src/rpucuda/rpu_mixedprec_device_base.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_mixedprec_device_base.h" diff --git a/src/rpucuda/rpu_mixedprec_device_base.h b/src/rpucuda/rpu_mixedprec_device_base.h index 18e82f2b..f0da25cd 100644 --- a/src/rpucuda/rpu_mixedprec_device_base.h +++ b/src/rpucuda/rpu_mixedprec_device_base.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_mixedprec_int_device.cpp b/src/rpucuda/rpu_mixedprec_int_device.cpp index 774f3f43..5aec215c 100644 --- a/src/rpucuda/rpu_mixedprec_int_device.cpp +++ b/src/rpucuda/rpu_mixedprec_int_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_mixedprec_int_device.h" diff --git a/src/rpucuda/rpu_mixedprec_int_device.h b/src/rpucuda/rpu_mixedprec_int_device.h index 6c08f6bc..3720abea 100644 --- a/src/rpucuda/rpu_mixedprec_int_device.h +++ b/src/rpucuda/rpu_mixedprec_int_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_onesided_device.cpp b/src/rpucuda/rpu_onesided_device.cpp index 11888981..720f2362 100644 --- a/src/rpucuda/rpu_onesided_device.cpp +++ b/src/rpucuda/rpu_onesided_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_onesided_device.h" diff --git a/src/rpucuda/rpu_onesided_device.h b/src/rpucuda/rpu_onesided_device.h index cb7d7ec5..5ccbe578 100644 --- a/src/rpucuda/rpu_onesided_device.h +++ b/src/rpucuda/rpu_onesided_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_onesided_device_test.cpp b/src/rpucuda/rpu_onesided_device_test.cpp index 0a21c64d..d8dc63af 100644 --- a/src/rpucuda/rpu_onesided_device_test.cpp +++ b/src/rpucuda/rpu_onesided_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rng.h" diff --git a/src/rpucuda/rpu_piecewisestep_device.cpp b/src/rpucuda/rpu_piecewisestep_device.cpp index f745dd22..64948181 100644 --- a/src/rpucuda/rpu_piecewisestep_device.cpp +++ b/src/rpucuda/rpu_piecewisestep_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_piecewisestep_device.h" diff --git a/src/rpucuda/rpu_piecewisestep_device.h b/src/rpucuda/rpu_piecewisestep_device.h index 676046b7..6027d830 100644 --- a/src/rpucuda/rpu_piecewisestep_device.h +++ b/src/rpucuda/rpu_piecewisestep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_powstep_device.cpp b/src/rpucuda/rpu_powstep_device.cpp index 2a872f80..f4572ef8 100644 --- a/src/rpucuda/rpu_powstep_device.cpp +++ b/src/rpucuda/rpu_powstep_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_powstep_device.h" diff --git a/src/rpucuda/rpu_powstep_device.h b/src/rpucuda/rpu_powstep_device.h index d71fdf40..0cb1f9e3 100644 --- a/src/rpucuda/rpu_powstep_device.h +++ b/src/rpucuda/rpu_powstep_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_powstep_reference_device.cpp b/src/rpucuda/rpu_powstep_reference_device.cpp index 01d7d1e7..2d5fec6f 100644 --- a/src/rpucuda/rpu_powstep_reference_device.cpp +++ b/src/rpucuda/rpu_powstep_reference_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_powstep_reference_device.h" diff --git a/src/rpucuda/rpu_powstep_reference_device.h b/src/rpucuda/rpu_powstep_reference_device.h index 8e466721..ba171b93 100644 --- a/src/rpucuda/rpu_powstep_reference_device.h +++ b/src/rpucuda/rpu_powstep_reference_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_pulsed.cpp b/src/rpucuda/rpu_pulsed.cpp index 814c6205..7d575b6b 100644 --- a/src/rpucuda/rpu_pulsed.cpp +++ b/src/rpucuda/rpu_pulsed.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_pulsed.h" diff --git a/src/rpucuda/rpu_pulsed.h b/src/rpucuda/rpu_pulsed.h index 56e1c172..d9865735 100644 --- a/src/rpucuda/rpu_pulsed.h +++ b/src/rpucuda/rpu_pulsed.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_pulsed_device.cpp b/src/rpucuda/rpu_pulsed_device.cpp index 4016b673..f8cf6fc5 100644 --- a/src/rpucuda/rpu_pulsed_device.cpp +++ b/src/rpucuda/rpu_pulsed_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_pulsed_device.h" diff --git a/src/rpucuda/rpu_pulsed_device.h b/src/rpucuda/rpu_pulsed_device.h index 97f83127..983bc3bc 100644 --- a/src/rpucuda/rpu_pulsed_device.h +++ b/src/rpucuda/rpu_pulsed_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_pulsed_meta_parameter.cpp b/src/rpucuda/rpu_pulsed_meta_parameter.cpp index d670d78d..8bff996b 100644 --- a/src/rpucuda/rpu_pulsed_meta_parameter.cpp +++ b/src/rpucuda/rpu_pulsed_meta_parameter.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_pulsed_meta_parameter.h" diff --git a/src/rpucuda/rpu_pulsed_meta_parameter.h b/src/rpucuda/rpu_pulsed_meta_parameter.h index dac1942c..afadf1f0 100644 --- a/src/rpucuda/rpu_pulsed_meta_parameter.h +++ b/src/rpucuda/rpu_pulsed_meta_parameter.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_pulsed_test.cpp b/src/rpucuda/rpu_pulsed_test.cpp index 7f802920..bb3feaec 100644 --- a/src/rpucuda/rpu_pulsed_test.cpp +++ b/src/rpucuda/rpu_pulsed_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rng.h" diff --git a/src/rpucuda/rpu_simple_device.cpp b/src/rpucuda/rpu_simple_device.cpp index 1cdfb34c..ef96e2fd 100644 --- a/src/rpucuda/rpu_simple_device.cpp +++ b/src/rpucuda/rpu_simple_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_simple_device.h" diff --git a/src/rpucuda/rpu_simple_device.h b/src/rpucuda/rpu_simple_device.h index 23e6ba59..b6ef9a01 100644 --- a/src/rpucuda/rpu_simple_device.h +++ b/src/rpucuda/rpu_simple_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_softbounds_reference_device.cpp b/src/rpucuda/rpu_softbounds_reference_device.cpp index 99ac1ab7..a55deb83 100644 --- a/src/rpucuda/rpu_softbounds_reference_device.cpp +++ b/src/rpucuda/rpu_softbounds_reference_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_softbounds_reference_device.h" diff --git a/src/rpucuda/rpu_softbounds_reference_device.h b/src/rpucuda/rpu_softbounds_reference_device.h index 680c1949..f2a5b561 100644 --- a/src/rpucuda/rpu_softbounds_reference_device.h +++ b/src/rpucuda/rpu_softbounds_reference_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_transfer_device.cpp b/src/rpucuda/rpu_transfer_device.cpp index dea7a24c..2809fd49 100644 --- a/src/rpucuda/rpu_transfer_device.cpp +++ b/src/rpucuda/rpu_transfer_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_transfer_device.h" diff --git a/src/rpucuda/rpu_transfer_device.h b/src/rpucuda/rpu_transfer_device.h index 93940ff8..b78cb379 100644 --- a/src/rpucuda/rpu_transfer_device.h +++ b/src/rpucuda/rpu_transfer_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_transfer_device_test.cpp b/src/rpucuda/rpu_transfer_device_test.cpp index 239f846e..b4170b25 100644 --- a/src/rpucuda/rpu_transfer_device_test.cpp +++ b/src/rpucuda/rpu_transfer_device_test.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rng.h" diff --git a/src/rpucuda/rpu_vector_device.cpp b/src/rpucuda/rpu_vector_device.cpp index 6426330e..db65f50d 100644 --- a/src/rpucuda/rpu_vector_device.cpp +++ b/src/rpucuda/rpu_vector_device.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_vector_device.h" diff --git a/src/rpucuda/rpu_vector_device.h b/src/rpucuda/rpu_vector_device.h index 8f853350..2f307ddc 100644 --- a/src/rpucuda/rpu_vector_device.h +++ b/src/rpucuda/rpu_vector_device.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/rpu_weight_updater.cpp b/src/rpucuda/rpu_weight_updater.cpp index 05f782fe..747ac3e5 100644 --- a/src/rpucuda/rpu_weight_updater.cpp +++ b/src/rpucuda/rpu_weight_updater.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "rpu_weight_updater.h" diff --git a/src/rpucuda/rpu_weight_updater.h b/src/rpucuda/rpu_weight_updater.h index 0f26148c..1ee61b1f 100644 --- a/src/rpucuda/rpu_weight_updater.h +++ b/src/rpucuda/rpu_weight_updater.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/sparse_bit_line_maker.cpp b/src/rpucuda/sparse_bit_line_maker.cpp index e1aa2cd6..9ad07786 100644 --- a/src/rpucuda/sparse_bit_line_maker.cpp +++ b/src/rpucuda/sparse_bit_line_maker.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "sparse_bit_line_maker.h" diff --git a/src/rpucuda/sparse_bit_line_maker.h b/src/rpucuda/sparse_bit_line_maker.h index b706a977..97ce6b3e 100644 --- a/src/rpucuda/sparse_bit_line_maker.h +++ b/src/rpucuda/sparse_bit_line_maker.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/utility_functions.cpp b/src/rpucuda/utility_functions.cpp index 369a11fd..07eeb313 100644 --- a/src/rpucuda/utility_functions.cpp +++ b/src/rpucuda/utility_functions.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "utility_functions.h" diff --git a/src/rpucuda/utility_functions.h b/src/rpucuda/utility_functions.h index ff202800..9054c5ea 100644 --- a/src/rpucuda/utility_functions.h +++ b/src/rpucuda/utility_functions.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/weight_clipper.cpp b/src/rpucuda/weight_clipper.cpp index 4a36cd76..c8084e1e 100644 --- a/src/rpucuda/weight_clipper.cpp +++ b/src/rpucuda/weight_clipper.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "weight_clipper.h" diff --git a/src/rpucuda/weight_clipper.h b/src/rpucuda/weight_clipper.h index 8aa72a5b..612c13e7 100644 --- a/src/rpucuda/weight_clipper.h +++ b/src/rpucuda/weight_clipper.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/weight_drifter.cpp b/src/rpucuda/weight_drifter.cpp index 84056e5a..258721c4 100644 --- a/src/rpucuda/weight_drifter.cpp +++ b/src/rpucuda/weight_drifter.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "weight_drifter.h" diff --git a/src/rpucuda/weight_drifter.h b/src/rpucuda/weight_drifter.h index ce89871d..098edd7a 100644 --- a/src/rpucuda/weight_drifter.h +++ b/src/rpucuda/weight_drifter.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/weight_modifier.cpp b/src/rpucuda/weight_modifier.cpp index 380156e7..5d716860 100644 --- a/src/rpucuda/weight_modifier.cpp +++ b/src/rpucuda/weight_modifier.cpp @@ -2,13 +2,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "weight_modifier.h" diff --git a/src/rpucuda/weight_modifier.h b/src/rpucuda/weight_modifier.h index 8c937ebb..5c12ffc1 100644 --- a/src/rpucuda/weight_modifier.h +++ b/src/rpucuda/weight_modifier.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/src/rpucuda/weight_remapper.cpp b/src/rpucuda/weight_remapper.cpp index 6eac2292..cdddc3fa 100644 --- a/src/rpucuda/weight_remapper.cpp +++ b/src/rpucuda/weight_remapper.cpp @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #include "weight_remapper.h" diff --git a/src/rpucuda/weight_remapper.h b/src/rpucuda/weight_remapper.h index 3b73fd60..5bda4455 100644 --- a/src/rpucuda/weight_remapper.h +++ b/src/rpucuda/weight_remapper.h @@ -1,13 +1,7 @@ /** * (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. * - * This code is licensed under the Apache License, Version 2.0. You may - * obtain a copy of this license in the LICENSE.txt file in the root directory - * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. - * - * Any modifications or derivative works of this code must retain this - * copyright notice, and modified files need to carry a notice indicating - * that they have been altered from the originals. + * Licensed under the MIT license. See LICENSE file in the project root for details. */ #pragma once diff --git a/tests/__init__.py b/tests/__init__.py index d9fc34f2..1e9c7961 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit tests.""" diff --git a/tests/helpers/__init__.py b/tests/helpers/__init__.py index 57365259..18fb9e85 100644 --- a/tests/helpers/__init__.py +++ b/tests/helpers/__init__.py @@ -2,12 +2,6 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Helpers for aihwkit tests.""" diff --git a/tests/helpers/decorators.py b/tests/helpers/decorators.py index 6dc7896c..02d07d9e 100644 --- a/tests/helpers/decorators.py +++ b/tests/helpers/decorators.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Decorators for aihwkit tests.""" diff --git a/tests/helpers/experiments.py b/tests/helpers/experiments.py index cbbec9db..6b65dab3 100644 --- a/tests/helpers/experiments.py +++ b/tests/helpers/experiments.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=missing-function-docstring,too-few-public-methods diff --git a/tests/helpers/infer_experiments.py b/tests/helpers/infer_experiments.py index 844d6240..7cfd493c 100644 --- a/tests/helpers/infer_experiments.py +++ b/tests/helpers/infer_experiments.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=missing-function-docstring,too-few-public-methods """Models helpers for aihwkit tests.""" diff --git a/tests/helpers/layers.py b/tests/helpers/layers.py index b083407a..ef8b40ee 100644 --- a/tests/helpers/layers.py +++ b/tests/helpers/layers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=missing-function-docstring, too-few-public-methods, no-member diff --git a/tests/helpers/testcases.py b/tests/helpers/testcases.py index dd9d94a0..dd7b320c 100644 --- a/tests/helpers/testcases.py +++ b/tests/helpers/testcases.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """TestCases for aihwkit tests.""" diff --git a/tests/helpers/tiles.py b/tests/helpers/tiles.py index d9ac4de9..5116d08a 100644 --- a/tests/helpers/tiles.py +++ b/tests/helpers/tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tile helpers for aihwkit tests.""" diff --git a/tests/test_bindings_tiles.py b/tests/test_bindings_tiles.py index 02ea034d..770a840b 100644 --- a/tests/test_bindings_tiles.py +++ b/tests/test_bindings_tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for the RPU array bindings.""" diff --git a/tests/test_calibration.py b/tests/test_calibration.py index 7cf9146c..23f3ba48 100644 --- a/tests/test_calibration.py +++ b/tests/test_calibration.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for input range calibration.""" diff --git a/tests/test_client.py b/tests/test_client.py index 8f778cdb..3831f2ef 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for the AIHW Composer API client.""" diff --git a/tests/test_cloud_runner.py b/tests/test_cloud_runner.py index 497bbd14..cc5f19bb 100644 --- a/tests/test_cloud_runner.py +++ b/tests/test_cloud_runner.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for the AIHW Composer cloud runner.""" diff --git a/tests/test_continue_training.py b/tests/test_continue_training.py index 04b67e35..c8b255ae 100644 --- a/tests/test_continue_training.py +++ b/tests/test_continue_training.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for continuing to train.""" diff --git a/tests/test_conversions.py b/tests/test_conversions.py index 85067147..7047f26a 100644 --- a/tests/test_conversions.py +++ b/tests/test_conversions.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for model conversions.""" diff --git a/tests/test_experiment_runners.py b/tests/test_experiment_runners.py index 67db2f07..fff36085 100644 --- a/tests/test_experiment_runners.py +++ b/tests/test_experiment_runners.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for Experiment Runners.""" diff --git a/tests/test_experiments.py b/tests/test_experiments.py index 64dd3749..fdd5cfb3 100644 --- a/tests/test_experiments.py +++ b/tests/test_experiments.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for Experiments.""" diff --git a/tests/test_export.py b/tests/test_export.py index 45cd9058..ea33a414 100644 --- a/tests/test_export.py +++ b/tests/test_export.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals, too-many-public-methods, no-member """Test for different utility functionality.""" diff --git a/tests/test_extension.py b/tests/test_extension.py index 11606bdf..13d211ed 100644 --- a/tests/test_extension.py +++ b/tests/test_extension.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=invalid-name, no-name-in-module, import-error diff --git a/tests/test_inference.py b/tests/test_inference.py index bca33361..fd487139 100644 --- a/tests/test_inference.py +++ b/tests/test_inference.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for general functionality of layers.""" diff --git a/tests/test_inference_tiles.py b/tests/test_inference_tiles.py index a8555da6..93c3c0c2 100644 --- a/tests/test_inference_tiles.py +++ b/tests/test_inference_tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=raise-missing-from diff --git a/tests/test_layer_base.py b/tests/test_layer_base.py index 434dda15..a74131a4 100644 --- a/tests/test_layer_base.py +++ b/tests/test_layer_base.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for linear layer.""" diff --git a/tests/test_layers.py b/tests/test_layers.py index c26d7c7e..e42553ff 100644 --- a/tests/test_layers.py +++ b/tests/test_layers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for general functionality of layers.""" diff --git a/tests/test_layers_convolution.py b/tests/test_layers_convolution.py index 026de4cb..cb53285d 100644 --- a/tests/test_layers_convolution.py +++ b/tests/test_layers_convolution.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for layer abstractions.""" diff --git a/tests/test_layers_linear.py b/tests/test_layers_linear.py index 98568838..05d3e60d 100644 --- a/tests/test_layers_linear.py +++ b/tests/test_layers_linear.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for linear layer.""" diff --git a/tests/test_layers_mapped.py b/tests/test_layers_mapped.py index 1d8faa1c..e48c029e 100644 --- a/tests/test_layers_mapped.py +++ b/tests/test_layers_mapped.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 1: simple network with one layer. Simple network that consist of one analog layer. The network aims to learn diff --git a/tests/test_layers_rnn.py b/tests/test_layers_rnn.py index f4d25c57..5daaf42e 100644 --- a/tests/test_layers_rnn.py +++ b/tests/test_layers_rnn.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for RNN layers.""" from torch import randn, ones, no_grad diff --git a/tests/test_localrunner_infer.py b/tests/test_localrunner_infer.py index 6d2f0d8f..413ce840 100644 --- a/tests/test_localrunner_infer.py +++ b/tests/test_localrunner_infer.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for Experiment Runners.""" diff --git a/tests/test_optimizers.py b/tests/test_optimizers.py index 08aea429..bb2ee466 100644 --- a/tests/test_optimizers.py +++ b/tests/test_optimizers.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for optimizers.""" diff --git a/tests/test_presets.py b/tests/test_presets.py index 760ee013..78eee455 100644 --- a/tests/test_presets.py +++ b/tests/test_presets.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for analog presets.""" diff --git a/tests/test_rpu_configurations.py b/tests/test_rpu_configurations.py index cc35c40b..18c44ecd 100644 --- a/tests/test_rpu_configurations.py +++ b/tests/test_rpu_configurations.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for the high level simulator devices functionality.""" from sys import version_info diff --git a/tests/test_simulator_tiles.py b/tests/test_simulator_tiles.py index a13271a5..4ef404f6 100644 --- a/tests/test_simulator_tiles.py +++ b/tests/test_simulator_tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals diff --git a/tests/test_specific_tiles.py b/tests/test_specific_tiles.py index 2577ccff..34eac448 100644 --- a/tests/test_specific_tiles.py +++ b/tests/test_specific_tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Some more tests for specific tiles.""" diff --git a/tests/test_torch_tiles.py b/tests/test_torch_tiles.py index d4f82a14..925d834c 100644 --- a/tests/test_torch_tiles.py +++ b/tests/test_torch_tiles.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """Tests for torch-based inference tiles.""" diff --git a/tests/test_utils.py b/tests/test_utils.py index ac318008..a0e4d4aa 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -2,13 +2,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. # pylint: disable=too-many-locals, too-many-public-methods, no-member """Test for different utility functionality.""" From efbb41d4906feeb6c6befe4b6af910e1a975da32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julian=20B=C3=BCchel?= Date: Fri, 6 Dec 2024 16:12:55 +0100 Subject: [PATCH 09/14] Fix HWA training notebook (#700) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Initital changes. Signed-off-by: Julian Buechel * Executed notebook Signed-off-by: Julian Buechel --------- Signed-off-by: Julian Buechel Signed-off-by: Pablo Carmona González --- notebooks/tutorial/hw_aware_training.ipynb | 250 ++++++++------------- 1 file changed, 88 insertions(+), 162 deletions(-) diff --git a/notebooks/tutorial/hw_aware_training.ipynb b/notebooks/tutorial/hw_aware_training.ipynb index c4baf281..eacd460d 100644 --- a/notebooks/tutorial/hw_aware_training.ipynb +++ b/notebooks/tutorial/hw_aware_training.ipynb @@ -56,18 +56,24 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "cellView": "form", "id": "8dRBAFI2xcEK", - "jupyter": { - "source_hidden": true - }, "tags": [ "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/dccstor/broccoli/miniconda3/envs/torch-nightly/lib/python3.10/site-packages/transformers/utils/hub.py:124: FutureWarning: Using `TRANSFORMERS_CACHE` is deprecated and will be removed in v5 of Transformers. Use `HF_HOME` instead.\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# various utility functions\n", "\n", @@ -76,8 +82,6 @@ "import torch.nn.init as init\n", "import torchvision\n", "import numpy as np\n", - "import os\n", - "from typing import List\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", @@ -238,90 +242,12 @@ " testset, batch_size=batch_size, shuffle=False, num_workers=1\n", " )\n", "\n", - " return trainloader, testloader\n", - "\n", - "\n", - "def load_cifar10_ffcv(batch_size, path):\n", - " # - FFCV specific imports\n", - " from ffcv.fields import IntField, RGBImageField\n", - " from ffcv.fields.decoders import IntDecoder, SimpleRGBImageDecoder\n", - " from ffcv.loader import Loader, OrderOption\n", - " from ffcv.pipeline.operation import Operation\n", - " from ffcv.transforms import (\n", - " RandomHorizontalFlip,\n", - " Cutout,\n", - " RandomTranslate,\n", - " Convert,\n", - " ToDevice,\n", - " ToTensor,\n", - " ToTorchImage,\n", - " )\n", - " from ffcv.transforms.common import Squeeze\n", - " from ffcv.writer import DatasetWriter\n", - "\n", - " datasets = {\n", - " \"train\": torchvision.datasets.CIFAR10(path, train=True, download=True),\n", - " \"test\": torchvision.datasets.CIFAR10(path, train=False, download=True),\n", - " }\n", - "\n", - " for name, ds in datasets.items():\n", - " writer = DatasetWriter(\n", - " os.path.join(path, f\"cifar_{name}.beton\"),\n", - " {\"image\": RGBImageField(), \"label\": IntField()},\n", - " )\n", - " writer.from_indexed_dataset(ds)\n", - "\n", - " # Note that statistics are wrt to uin8 range, [0,255].\n", - " CIFAR_MEAN = [125.307, 122.961, 113.8575]\n", - " CIFAR_STD = [51.5865, 50.847, 51.255]\n", - "\n", - " loaders = {}\n", - " for name in [\"train\", \"test\"]:\n", - " label_pipeline: List[Operation] = [\n", - " IntDecoder(),\n", - " ToTensor(),\n", - " ToDevice(device),\n", - " Squeeze(),\n", - " ]\n", - " image_pipeline: List[Operation] = [SimpleRGBImageDecoder()]\n", - "\n", - " # Add image transforms and normalization\n", - " if name == \"train\":\n", - " image_pipeline.extend(\n", - " [\n", - " RandomTranslate(padding=4),\n", - " RandomHorizontalFlip(),\n", - " Cutout(\n", - " 8, tuple(map(int, CIFAR_MEAN))\n", - " ), # - Note Cutout is done before normalization.\n", - " ]\n", - " )\n", - " image_pipeline.extend(\n", - " [\n", - " ToTensor(),\n", - " ToDevice(device, non_blocking=True),\n", - " ToTorchImage(),\n", - " Convert(torch.float32),\n", - " torchvision.transforms.Normalize(CIFAR_MEAN, CIFAR_STD),\n", - " ]\n", - " )\n", - "\n", - " # - Create loaders\n", - " loaders[name] = Loader(\n", - " os.path.join(path, f\"cifar_{name}.beton\"),\n", - " batch_size=batch_size,\n", - " num_workers=4,\n", - " order=OrderOption.RANDOM,\n", - " drop_last=(name == \"train\"),\n", - " pipelines={\"image\": image_pipeline, \"label\": label_pipeline},\n", - " )\n", - "\n", - " return loaders[\"train\"], loaders[\"test\"]\n" + " return trainloader, testloader\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "id": "9m1qDEsd-C4H" }, @@ -332,15 +258,10 @@ "import numpy as np\n", "from tqdm import tqdm\n", "\n", - "# - Tutorial specific imports\n", - "#from utils.misc import load_cifar10, load_cifar10_ffcv, device, resnet32\n", - "#from utils.plotting import plt\n", - "\n", "# - AIHWKIT related imports\n", "from aihwkit.nn.conversion import convert_to_analog\n", "from aihwkit.optim import AnalogSGD\n", "from aihwkit.simulator.presets.utils import IOParameters\n", - "from aihwkit.simulator.presets import StandardHWATrainingPreset\n", "from aihwkit.inference.noise.pcm import PCMLikeNoiseModel\n", "from aihwkit.inference.compensation.drift import GlobalDriftCompensation\n", "from aihwkit.simulator.configs import InferenceRPUConfig\n", @@ -404,10 +325,10 @@ "\n", " rpu_config.forward = IOParameters()\n", " rpu_config.forward.is_perfect = False\n", - " rpu_config.forward.out_noise = 0.0\n", + " rpu_config.forward.out_noise = 0.04\n", " rpu_config.forward.inp_bound = 1.0\n", " rpu_config.forward.inp_res = 1 / (2**8 - 2)\n", - " rpu_config.forward.out_bound = 12\n", + " rpu_config.forward.out_bound = 10\n", " rpu_config.forward.out_res = 1 / (2**8 - 2)\n", " rpu_config.forward.bound_management = BoundManagementType.NONE\n", " rpu_config.forward.noise_management = NoiseManagementType.NONE\n", @@ -476,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -517,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "id": "aG-rrTt5-C4R" }, @@ -544,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -557,16 +478,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2024-09-18 19:52:21-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/pre_trained_model.th\n", + "--2024-12-06 09:28:52-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/pre_trained_model.th\n", "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1928757 (1.8M) [application/octet-stream]\n", "Saving to: ‘Models/pre_trained_model.th’\n", "\n", - "pre_trained_model.t 100%[===================>] 1.84M 2.03MB/s in 0.9s \n", + "pre_trained_model.t 100%[===================>] 1.84M --.-KB/s in 0.07s \n", "\n", - "2024-09-18 19:52:23 (2.03 MB/s) - ‘Models/pre_trained_model.th’ saved [1928757/1928757]\n", + "2024-12-06 09:28:53 (27.0 MB/s) - ‘Models/pre_trained_model.th’ saved [1928757/1928757]\n", "\n", "Test loss 0.0016 test acc. 94.12%\n", "Pretrained test acc. 94.12%\n" @@ -602,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -615,7 +536,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2024-09-18 19:52:32-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/test_accs.th\n", + "--2024-12-06 09:29:06-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/test_accs.th\n", "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", @@ -624,21 +545,21 @@ "\n", "test_accs.th 100%[===================>] 1.49K --.-KB/s in 0s \n", "\n", - "2024-09-18 19:52:32 (1.57 GB/s) - ‘Models/test_accs.th’ saved [1521/1521]\n", + "2024-12-06 09:29:06 (22.4 MB/s) - ‘Models/test_accs.th’ saved [1521/1521]\n", "\n", - "--2024-09-18 19:52:33-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/finetuned_model_0.9.1.th\n", + "--2024-12-06 09:29:06-- https://aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud/finetuned_model_0.9.1.th\n", "Resolving aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)... 169.63.118.98\n", "Connecting to aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud (aihwkit-tutorial.s3.us-east.cloud-object-storage.appdomain.cloud)|169.63.118.98|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 3940538 (3.8M) [application/octet-stream]\n", "Saving to: ‘Models/finetuned_model_0.9.1.th’\n", "\n", - "finetuned_model_0.9 100%[===================>] 3.76M 3.81MB/s in 1.0s \n", + "finetuned_model_0.9 100%[===================>] 3.76M --.-KB/s in 0.09s \n", "\n", - "2024-09-18 19:52:35 (3.81 MB/s) - ‘Models/finetuned_model_0.9.1.th’ saved [3940538/3940538]\n", + "2024-12-06 09:29:07 (43.3 MB/s) - ‘Models/finetuned_model_0.9.1.th’ saved [3940538/3940538]\n", "\n", - "Test loss 0.0018 test acc. 94.34%\n", - "Finetuned test acc. 94.34%\n" + "Test loss 0.0018 test acc. 94.35%\n", + "Finetuned test acc. 94.35%\n" ] } ], @@ -683,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": { "cellView": "form", "id": "JRMIngM203Ph", @@ -747,7 +668,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -759,7 +680,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp8AAAIMCAYAAACzGsflAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3hURRfG3930SkhoCaHXGHovISBIVYqIUhQpAlIChABKUQJSpErviIBAAJUq5QNEpKh0SAIioCC9hpDQUnbP98dxcu/u3k02IQ2c3/Pss7v3zp2Ze3aTvDkz5xwdEREkEolEIpFIJJJsQJ/TE5BIJBKJRCKR/HeQ4lMikUgkEolEkm1I8SmRSCQSiUQiyTak+JRIJBKJRCKRZBtSfEokEolEIpFIsg0pPiUSiUQikUgk2YYUnxKJRCKRSCSSbEOKT4lEIpFIJBJJtiHFp0QikUgkEokk25DiUyLJACtWrIBOp7Pp0ahRIwDAlStXUo7t378/R+f/qtC9e3cTG0skEokk9yPFp0QiSUGKufRTvHhx6HQ6jB07Nqenoon8p0cikeQ27HN6AhLJy86OHTvQoEEDq+ft7OyycTYSiUQikeRupPiUSF4QFxcXuLu7p9muePHiIKJsmNF/hxUrVmDFihU5PQ2JRCKRpAO57C6RSCQSiUQiyTak+JRIsom09t6Z7x3cunUrmjVrhvz588PZ2RnlypXD6NGjERcXl+ZYf/31F0JDQ1GhQgV4enrCxcUFpUuXRp8+ffDnn39atBcBVCtXrgQA/PLLL1YDp9TtdTpdqvNIbQ/p2LFjodPpULx48RT79OvXD8WLF4eTkxMKFiyIDh064NSpUxnqXxATE4NPPvkEZcuWhYuLCwoWLIhWrVrhf//7n819pDb2P//8AwAYN26chc2s7QPdsmULOnTogCJFisDZ2Rl58+ZFnTp1MG3aNDx9+tTqmElJSVi0aBFef/115M+fHw4ODvD29ka5cuXQunVrzJkzB/fv309pX7x4cZQoUSLl/euvv24xx/TuA7158yYWL16Mtm3bolixYnB2doarqytKliyJDz/8EEeOHLGpn3v37mHs2LGoU6cO8uXLBycnJxQtWhSNGjXC9OnTce3aNavXHj58GD179kSZMmXg7u4ODw8PBAQEoGPHjvj++++RkJBg0t6Wfblp/XyKcytWrIDRaMSiRYvQoEED5M+fH3q93qTv+Ph4/PDDD+jevTsCAgLg5uYGR0dH+Pr64q233sKGDRtsWgVJSEjAokWL0KJFC/j6+qb8XNSoUQOffPIJTp48mdL2iy++gE6ng4uLC2JjY1Pt9+DBgyn3s2PHjjTnIZFkOiSRSNLNN998QwAIAP388882XXP58uVUrylWrBgBoPDwcAoNDU1pa/6oXLkyxcfHWx1n9uzZ5ODgYPV6e3t7Wr58udX7sfZo2LChZvvU6Natm8W1gvDwcAJAxYoVo/3791OePHk0x3VycqI9e/aku38iovPnz5Ofn5/Vexo3blyafaR1b6k9wsPDTa6JjY2lZs2apXpNmTJl6K+//rIYLz4+nurUqZPmmN99913KNeI7ldrD1u+vwMvLK9X+dDodTZo0KdU+1q9fT+7u7qn2061bN4vrnj17Rl27dk33Pal/tqyR1s+nOLdo0SJq3Lhxqp91u3bt0pxjmzZtKCEhwep8IiMjqWTJkqn2UaxYsZT2165dI71eTwBo/vz5VvslIurRowcBoMKFC1NycnKqbSWSrECKT4kkA2Sl+BR/cHr37k3Hjh2jBw8e0B9//EF9+/ZNuX7kyJGaYyxcuDClTevWrWnXrl108+ZNun//Pu3fv59atmxJAEiv19PevXtTrktKSqL4+Hh6//33CQAFBQVRfHy8yePp06ea958atohPLy8v8vb2pkqVKtHGjRvp1q1bdPv2bVq5cmWK0ClSpAglJSWlq/+nT59S6dKlCQA5OjpSeHg4Xbhwge7fv08HDx6kFi1akE6nS7F3esXn8+fPKT4+nooWLZrymZjbTC0ukpKSqH79+gSA3NzcKDw8nE6dOkUPHjygq1ev0vLly1OEckBAAD158sRkvM8++yzF5gMGDKCjR4/SrVu36MGDBxQdHU3ffPMNtW7dmjZu3JhyzZMnT+js2bMp1+3YscNijukVH/Xq1aOxY8fS//73P4qOjqZ79+7R5cuX6X//+x+98847KWPt3LlT8/otW7aQTqcjAOTr60tz5syh8+fPU0xMDF2+fJk2btxIXbt2pY8//tjiWnX/TZo0oW3bttGNGzfowYMHdObMGZo7dy7VqlUrS8Wnv78/6fV6GjJkCJ0+fZru379PZ86coaNHj6a07dOnDw0cOJA2btxIJ0+epFu3btGNGzfo999/pyFDhpCLiwsBoBEjRlidi7e3NwEgZ2dn+uSTT+j48eN0//59unnzJv300080bNgwqlmzpsl14ue7evXqVu8zPj4+RfiPGjXKajuJJCuR4lMiyQBq8aX1B108Hj9+nHKNreITAE2YMEFz3NatWxMAKlSokMW5W7dukbOzc6p/VIxGI3Xs2JEAUMWKFS3O2+oFzEzxCYCqVKliYivBDz/8kKqYSa3/adOmpVy7evVqi/MGg4FatWqV0ia94lNgi7AhIpo5c2aK8Dx16pRmm6tXr1K+fPkIAE2fPt3kXLVq1QgAvf322+maX1rfu8zmk08+IQAUHBxsce7Jkycp91eqVCm6efOm1X7M/9lYv369ifg2Go02X5uZ4hMALViwwGo/trBjxw4CQO7u7hQXF2dxXohIR0dHOnjwoNV+zO9T/fMSGRmpec3y5ctT2ly8ePGF7kMiyShyz6dE8oK0atUKHh4emo/ChQunu78iRYpgxIgRmud69OgBALh9+7bFnrhFixbh+fPnKFasGMaNG6d5vU6nw5QpUwAAUVFRiIyMTPf8soIpU6bAzc3N4ni7du3g5eUFADh27Fi6+vzmm28AALVq1cL7779vcV6v12PmzJnpn2wGmT17NgAgNDQUVapU0WxTpEgRhISEAADWrFljci45ORkA4Ofnl3WTzAS6desGAPj1118t9q+uXr06ZU/qwoUL4evra7Ufe3vTZCyzZs0CwPs3Z86cmep+Y/NrM5OAgAD069fvhfpo2bIl8ufPj8ePH+O3334zOXfhwgXs3LkTADBs2DAEBQVZ7cf8Plu3bo2CBQsCAJYvX655jfi5aNiwIUqXLp3he5BIXgQpPiWSXEbTpk2t5gYtV65cyuvbt2+bnNu7dy8AoHHjxnj+/DkeP36s+fDx8UG+fPkApF/QZQVOTk54/fXXNc/p9XqUKVMGgOX9psbDhw9x7tw5AEDbtm2ttitbtizKly+fjtlmjEuXLuHKlSsA+POx9tk8fvwYFStWBACcOXMGiYmJKX0IwfrNN99gzZo1Jueym+PHj6Nv376oVKkS8uTJAzs7u5QAlsDAQAAslv/66y+T68R3tHDhwmjatKnN48XHx+Po0aMAgC5dusDBwSGT7iT9tGrVyqZ2169fx+eff4569erBx8cHDg4OJoFe9+7dAwCLAEBhI4CD2tKDg4NDivhfvXo1kpKSTM5funQJBw8eBAD07NkzXX1LJJmJFJ8SyQvy888/g3gLi8UjrahTLVLzbLm6uqa8NvcqnT9/HgCLE2ueWPEQ3ifxBzAnEVHb1hD3nFoUuDkiAh0wFexaZIf4FJ8NADRp0iTVz+add94BABiNRsTExKRcN3bsWHh6euLp06f44IMPkC9fPrRq1QqTJk3C77//nm05ZEePHo1atWph8eLFiIqKQlxcHIxGo2bbR48embwXYrRy5crpGvPKlSswGAwAYNVrnF2ULFkyzTZbtmxBQEAAJkyYgN9++w0xMTEpnmtzrNnI1dU15R+v9NCrVy8AwP3797F161aTc8Lr6enpiQ4dOqS7b4kks5DiUyLJZdhaEclcbJj/EbOF58+fp/uazCaj95sajx8/TnmdVgEAWwoEvCgZ+WwA08+nRIkSOHnyJLp27QpXV1fEx8dj586dGD16NOrWrYsSJUqkpMrKKtavX49JkyaBiNCgQQOsWbMGZ8+exb179xAXF4f4+HhERUWltDcXXCJNmIeHR7rGVacXS++1mY36H0Atrly5gk6dOuHx48coXrw45syZg+PHj+PWrVt49OgR4uPjER8fD39/fwCZZyNBmTJlEBwcDEARmwD/M7Nq1SoAQKdOndK8D4kkK5EVjiSSVwR3d3fExsYiLCwMM2bMyNKx0srvKbDm7clq1ILyyZMnqbZVC9WsQj2fyMjIlKX19FKqVCmsWrUKy5Ytw7Fjx/Dbb7/hp59+wt69e/HPP/+ge/fuePDgAcLCwjJr6ibMnz8fAFCvXj3s378fer2l/8J8qVeNp6cnAF5GTw/iuoxcC9j2fc2s7+ry5cvx/PlzeHp64vfff0/Zg2mOtXy9GbWRml69euHAgQPYtWsXbt26BV9fX+zevRvXr18HIJfcJTmP9HxKJK8IYjnQfJ9dVuDs7Jzy+tmzZ1bb3bx5M8vnokXRokVTXmsl1VeT1vnMQL1Umxmfj6OjI+rXr49hw4Zh586d+Ouvv1KCRyZMmJCyRJ3ZnD59GgDw3nvvaQpPACaeT3PEHM+cOZOucYsXL57iIRdzSA/i+5od31Uxv8aNG1sVnlevXrUqPoWNnj59iosXL2ZoDh06dICXlxcMBkOKN1x4QQMDA1G7du0M9SuRZBZSfEokrwjNmzcHwAELDx48yFAfYu9lWuJFHaVsTbzFxsbaXO0ms/H29kZAQAAA3n9njYsXL+KPP/54obFssVmFChVS9vKuW7fuhcbTomjRoujTpw8ADra6e/euxfzSmqMtiMpBqfXz7bffWj0ngoxu3LhhEliTFh4eHqhTpw4AICIiIlXvqhbi+5raPxq7du1KV5/WeFEbvfHGGymvM7qNwsXFJSXDw4oVKxATE5PycyC9npLcgBSfEskrwoABA+Ds7IwnT56gR48eFiUGzVEHwQhEFHxaXqCqVavC0dERgPU/kMOHD09XkFBmIyKFjxw5oin4jEYjhg4d+sLj2GIznU6XshS+YcMGizRK5hgMBly6dMnkmNbnpUZ4VO3s7JAnT56U497e3inLzi/q3RMe3K1bt2ruwV2xYkWqorJLly7Inz8/AKB///64c+eO1bbmy+ChoaEAgMuXL2PYsGGpztP8WuHp27NnD27dumXR/vz585g7d26qfdqKsNHhw4c1/wmMjo7G5MmTrV5fpkwZvPnmmwCA6dOnW6RiUpPaVgERePTnn39iwIABSEhIgIODA7p27WrTfUgkWYkUnxLJK0LhwoUxZ84cAMC2bdtQvXp1LF++HJcuXUJsbCxu376NI0eOYM6cOWjYsCFq1qxp0UeNGjUAAH///TeWLFmChw8fIjk5GcnJySaeHA8Pj5Ro2dmzZ2PcuHG4cuUKYmJicPjwYbRv3x5ff/21SV3x7CYkJASlSpUCwLknv/jiC1y6dAkxMTH49ddf0bp1a2zbtu2F5yhstnnzZuzfvx9PnjxJsZk6CnzQoEFo2LAhiAgffPABPvjggxQxFBsbiytXrmDnzp0YPnw4SpQokZLXUvDaa6/hjTfewIIFC3DixAncvXsX9+7dw8mTJxEWFoYlS5YA4NRS6mASFxeXlPRH8+fPx7lz55CQkJAyx/QEcnXs2BEA8Msvv6BLly44ceIEHjx4gMjISISFhaFXr1547bXXrF7v6uqKr7/+GjqdDhcvXkT16tUxb948XLx4EbGxsbh69Sq2bt2KHj16pOQ7FXTo0CHlOzdnzhw0b94cO3bswK1bt/Dw4UNER0dj0aJFqFevHg4dOmRybbdu3WBnZ4enT5+iRYsW2LdvH2JiYnDlyhUsWLAADRo0sLpEnl6EjWJiYtC8eXPs2bMHd+/exeXLlzF79mwEBwfD3d0d3t7eVvuYP38+vL29kZCQgCZNmmDkyJE4deoUYmJicOfOHRw4cAAjR45E/fr1rfZRpUoVVK9eHYDibW/dunWK+JdIcpQcSW0vkbzkZHVt94z2QUT09ddfp5TvS+2RN29ei2ufP39O5cqV02xvXgHo5s2bVLx4cc22er2evvrqK5tru6dGw4YNCdCu9Z1WRaZz585RoUKFrNogPDycPvzww5RyjRnh3LlzKZWltPpXExcXRx06dEjzswFAQ4YMMbnWlmuqVKlCt2/ftpij+vtq/khP1aMnT55QzZo1rfYVGBhIR44cSbPviIgIcnV1TfVerNV279KlS5p20Bp30qRJVtsHBATQb7/9ZlOFo2+++SZNO/Xv3z/Vn7uDBw+m+fN+5swZqz9f4pHWz86iRYtM2v/4449pzl0iyQ6k51MiecXo2bMnLl++jLFjx6Ju3brw8fGBnZ0d3NzcUK5cOXTs2BFLly61WNYFOOH7L7/8goEDB6JcuXImgUXm+Pr64siRIxg0aBBKlCgBR0dHFChQAG3atMH+/fsxZMiQrLxNmwgICEB0dDSGDh2KUqVKwcnJCfnz50fz5s3x448/YuzYsSnR7uqI6vSOcfjwYbz33nvw9/dPNWeph4cHvvvuOxw8eBA9e/ZE2bJl4e7uDnt7e/j4+KB27doYNGgQdu/ejenTp5tce+LECUydOhUtW7ZE2bJl4enpCQcHBxQsWBDNmjXD0qVLcfToUU0PXvfu3fHdd9+hSZMmKd+HjODq6or9+/cjPDwc5cuXh5OTE/LkyYOqVati4sSJOHr0KAoUKJBmP506dcKlS5cwcuRIVK1aFXny5IGTkxOKFSuGRo0aYcaMGZg4caLFdc7OzlizZg327duH999/H8WKFYOzszM8PT0REBCATp06YePGjahXr57FtSNHjsTGjRvRqFEjeHp6wsXFBQEBARg7diyOHTuGQoUKZcgmWsyfPx8rVqxAnTp14ObmBhcXF5QuXRoDBw7EqVOnUq1aJKhUqRL++OMPzJkzB6+//jry5csHBwcHFCpUCDVq1MCIESNS3c8MAJ07d06pHObn54cWLVpkyv1JJC+KjiibMhOnk2vXrmHKlCnYuXMnrl+/Dg8PD1SvXh2DBg1K2Q+jZuzYsVZLCgr++OOPbEkoLZFIXh4qV66MyMhIDBw4MGXbgkTyKpCQkIBChQohNjYWI0eOxKRJk3J6ShIJgFya5/PYsWNo0aIFYmJi4Ovri5YtW+LBgwf4+eefsXv3bowZM8aq0KxcubLVChjqTfgSiUTy999/p6QGEvvjJJJXhU2bNiE2NhY6nU5GuUtyFblOfD5//hzvvPMOYmJi0LFjR3zzzTdwcXEBwKK0ZcuW+OKLLxAUFKRZG7hdu3YYO3ZsNs9aIpHkRmJiYqwGdiQnJ2PgwIEgIjg7O6daA14ieRkRQWtNmjRJyR8qkeQGct2ez02bNuHatWvw8vLCokWLUoQnANSsWRNjxowBAHzxxRc5NUWJRPKSsHz5ctSpUwdLly7FH3/8gdjYWNy4cQObNm1CcHAwduzYAQAYNmwYvLy8cnayEkkm8fDhQ4waNSolz+4nn3ySwzOSSEzJdZ7PY8eOAeAlMK0/BiIB7+HDh3H79u1M3SQukUhePY4cOZJqsvsuXbqk/FMrkbzMrFixAj169DA59u6772quEkokOUmuE58i8tTHx0fzvEjoTEQ4efIkWrVqZXL+5MmTGDFiBGJiYlKiMFu3bg0PD4+snbhEIsl1vPvuu0hKSsLu3btx+fJl3Lt3DwaDAQUKFEDt2rXRs2dPtGzZMqenKZFkKnZ2dihevDg6d+6MUaNG5fR0JBILcp34FGk6/v77b83z6uOXL1+2OL9t2zZs27bN5FiePHkwZ84cfPjhh5k4U4lEktspVqwYRo4ciZEjR+b0VCSSLKd79+4plb0kktxMrhOfjRs3xsSJE3HixAmcOnUKVatWNTm/aNGilNdxcXEpr0uVKoVJkyahZcuWKFasGADg3LlzmDx5Mn788ceUChei3m1q2JKD7eTJk8iTJ09KBRWJRCKRSCSSl4G//voL3t7eOHv2bI6MnyvzfDZs2BAHDhyAv78/FixYgODgYDx48AALFizAV199BXt7eyQlJWHy5Mn49NNP0+xv0KBBmDt3LvLnz4/r16+n1KS2hi3i8+jRo7C3t0fx4sVtvS2JRCKRSCSSHOfKlSvIkycPbt26lSPj50rxeffuXbRv3x6HDx+2OBcaGopDhw7h+PHjWLJkCXr37p1mfzExMShQoAAMBgMOHDiABg0avPAcg4KCEBMTg+PHj6da0eS/RlJSEvbs2YOmTZtKu6iQdtFG2sU60jbaSLtoI+2ijbSLNg0bNoRer8ehQ4dyZPxct+wO8L7PgwcPYu/evdi3bx8ePHiAggULom3btqhRowb8/PwAABUrVrSpP29vbxQoUAC3bt3C9evXM3WuDg4O8gutgbSLNtIu2ki7WEfaRhtpF22kXbSRdjFFp9Pl6Pi5UnwCbJimTZtapIj466+/cOvWLfj4+KBatWo29WUwGPDo0SMAkFHvEolEIpFIJDlIrksynxbTp08HAPTp0yfNvZuCrVu34unTp9DpdKhRo0ZWTk8ikUgkEolEkgq5UnyeO3fOJJId4FJ4kyZNwuLFi1G6dGmMHj065dzVq1exevVqPH/+3KKvzZs3o1evXgCA999/Xyall0gkEolEIslBcuWy+5IlS7B48WJUr14dhQsXRkJCAn7//XfcuXMHpUuXxp49e+Dm5pbSPiYmBl27dkW/fv1QtWpVFC5cGM+ePcO5c+dw8eJFAMDrr7+OhQsX5tQtSSQSiUQikUiQS8Vnq1atcOXKFZw8eRLHjx+Hk5MTypUrh6FDhyIkJMSk3jsAFClSBJ9++imOHTuGS5cu4eTJk0hMTES+fPnw1ltvoUuXLujYsSP0+lzp6JVIJBKJRCL5z5ArxWezZs3QrFkzm9v7+Phg8uTJWTgjiUQikUgkEklmIF2BEolEIpFIJJJsQ4pPiUQikUgkEkm2kSuX3XMj5iU3IyMj4e/vn0OzkUgkEolEInk5kZ5PiUQikUgkEkm2IT2fNmJe/1TUdpdIJBKJRCKR2I70fEokEolEIpFIsg0pPiUSiUQikUgk2YYUnxKJRCKRSCSZTHQ0ULs2cPZsTs8k9yHFp0QikUgkEkkmQgSEhADXr/MzUert/2tCVYpPiUQikUgkkgyiJRwjIoCLF4GjR4E//wTWrbN+fXqF6quAFJ8SiUQikUj+82TE+6glHOPigGHDgOnTgcKF+XnoUCA+XruP9AjVVwUpPiUSiUQikfynyaj3UUs4jhsHlCsHdOrEbTp3BsqW5ePmAldLqA4aBNSo8WovwUvxKZFIJBKJ5D+NuYicNi1tL6g14bhwITBvHqDTcTudDpg/n4/16GEqcM2FaqdOQFISz8GaCH4V9odK8SmRSCQSieQ/i7mInDYN+Pxz4Nq11L2g1oTja68BgYGmbQMDgcaNgchI4MgRFpdDhwKzZgGhoYpQXbcOcHLifs6etVyCf1X2h0rxaSNBQUEmj8jIyJyekkQikUgk/wmy0ttnLiIFrVtb34MZHW3p4RTCMTracp5xccCpU4CrK3DwIDB1KgtPFxd+Vu8VnTULGDAAcHcHunVjb6wgIx7a3IgUnxKJRCKRSHItWentMxeRcXHA8OHAhAnAqlXslTQPFhLz6d9f8XCaC0fzeY4bB5Qvz+MMHQocOMDn331Xe6/omDF8v0RAhw7agUy2emhzI7K2u43I2u4SiUQikWQ/am9fzZos1Dp3fvF+tUSkEIDDhgG3bwM7dijBQtOnK/P54w/g8WP2OAYGmgrHN98ESpUCChYEZs5kb+esWcDGjUCbNsDcucCyZXwPQnQOGgQ8eQIcO8YiePt29nwCLC6HDQPWrgWKFNH20G7blnl2yQ6k51MikUgkEkmuxNa0RRlZlheiNjxc6UPtBQ0PBy5cYDE5fz73Lebj4wPcusXi9dEjYMkSntfZs0DTprz8fu8e8MEHHGQkltcB4P59Fr6rV7Pw3bqV+8iXj/eLijHmzQMqVQKKFwe++orFsNouaXloczNSfEokEolEIsl1REezN9HfXzttkcB8WT4qKn2R6h4e2l5QT08+P3Mm0KsXnx87FvDyAmJj2RN7/jxQsiSL1alTecn9+nVToRgfD5w4wcvrU6cCf/3FwUd6PQvc48c5wOjaNfaACi9q584sKG/c4H6KFuW+1Uv0w4bxnNUe2tTsmVv2h0rxKZFIJBKJJFdBxB7DO3dMj4u0RcITCZguy58/D3TsmPb+UPMgo9WrgV9/BXbuBH75RWknxC7A4nHBAhaWM2awJ7Z1ayAmRhGYkZE8j/z5lT5q1+axpk0DRo8G7OxYbBJxnwkJStt585QHAEyZwiLVxQW4ehXo188ynZOWh1YgBGd0tKlAz2mk+JRIJBKJRJJhhMDZvDnzPGtr17KQ69NH8fYJiNj72KMHL1erl+Xbt2dBt28fP69fr9PsXyyTiyCjsDAWhOfOAY0aAb17Aw8f8vmhQ4EVK3gMgwEwGlngAjxHAChUCHB05NfCYyowGPg5Lo5fGwwc+R4RwcFEAODtzYnlASA4mL2vERHcjghYupQ9wIsXW6Zz0vLQEpl6hN97zzRK/t69F/2EXgwpPiUSiUQikWQIIXCuXQO6d8+ciPS4OO7DzY29hep9nmI8nQ44c4Y9k8KDGRcHbNrE75cu5evCwuwwdGiwhSDu04e9l1FR3N7JiY8XKMDPy5ZxmiMibvfxx4CzM5CcDDx/Dqxfz6L7yBH2ZN67B5QuDVSuzF7Va9eUsY4eZc9kaKhy7OOPgcGD2Ztpbw98+SXPxcuLn2/c4PPPn3OfXbrw/dy4wXMyT+ek9tBGRwNlyrDtLl4EfvqJBWf79sq+2StXdCmiOCeQ4lMikUgkEkmGEEveo0axOBw16sXrk48aBTx9ysvKHh6m+zzFeMeOsWDcuZOXpnU6ZSl9wwZefq5Ykb2EN254IDTUzkQQh4fzPDt25KV9Ly/g5585anzHDm6zZw8vx1+8yCmNevZkAZqYyGJ4/nxu16gRjy+WwGfM4OX1woX52JIlfDwxkds3bMj7PAMDWSSWKAGsXMkidP58TsnUpg1Hv+v1nHYJ4Ch5Jyc+1rs30LYt0K4de2t1Ovaizp/PntC//+Y5T5vGQrxcOeD77/kz6txZWcbPKaT4lEgkEolEkm5E0M4XXwCTJvF+xIkTgfHjbatPrhUAEx3NS8uVKytpg65dA549A2bPZu/h9OmAnx+LO72eBaI6Ur1CBQ7C6diRl8INBh3OntWZCGJPT+Dtt1mAduvGAvPmTaBWLaB5cyBvXqBYMWVJX4jrihVZuHl6At98w33dvcte3z/+4EAigJfmf/uN0yzNnMmeUoBTMP3wg7JH89o13kN64gRQrRrfc4cOwMmTfM9EHNW+Zg0fK1qUI+CJgCtXgC1bgFat2CP72Wd8v9evc5qn5GTuf+FCFuTlyrFA1+mAkiUJt25l0hchA0jxKZFIJBKJJN0IT+PZs/w8Zw57KM+eTbs+uVbiePWS+pgx/Pz8OS8XHz3KYiohgUVlRASL33LlWFyZR6oPGcLjd+hgRMuWl5EvH5mkIoqL47yb5cpxPk1XV45Uj49nQXv7NovD114DgoKARYuAJk142XvOHE6XZDCw1/LBA/Z0Pn2q3J+jI3DoEAvm8+cVG4wbx2maxB7NDz/k6xISFDuMHg04OLAYNRj4+u7dWYxevMjieuVKFvw6HfDPP5ysPi6ORbGTE89PeE179eJr1IFarq6Ar2+Wfj1SRYpPiUQikUgk6UJ4GgcPZmE2bx6Lnfnz+bWI6NaqTw5Ylolct0459vHHvHRtNLKgPHFCuS4hgT2Ow4bxkrKbG7eLjGThm5TE7WbOZGG5aZMebdv+hdhYHZydFXEsKg5t2MCe1oAAXuYePZqvv3CBI9vnzWMPqYcHjzF9Oi+/V6jAjxs3eB7FiyteT4CXvIcOZS+qKL8pngFlK8HRo2w3b2++p5AQFpE1arDndPJkvk7sz3R2Bk6fZhsNH67sUd2yhb3Fr73GHmGjEXj9dVObBwayPUW0e9GiGfnkMwmS2ET9+vVNHh4eHhQQEECJiYk5PbVcRWJiIm3evFnaxQxpF22kXawjbaONtIs22WkXo5GoYUOisDB+HjpUOffoEZGbG1FAANGQIfzs60sUF2faxteXaO1afr9mDVHBgkSFCvExcf6jj9gfqtMRlSjBr/PlI3J1JWrQgGj1ar7G1ZXIwYHPlylDFBFB5OJCFBVFFBxsoLZtL9KKFUlkb89tAgP5fHQ0j1+gAB8vUYLIzo6vE/d15gyf8/AgqlmT752Ir7Wz43HXrOFjH38s/LdEycnch58fUfHifKxiRVNbzJ3Lx6dMIfL2Vq51cCDato3bREUROToSeXryHDw8iLy8lD7Cw5XrXFy4r7x5iezt+XOYOpXI2Vm5V2HbMmXqUf369TP1e5EepOdTIpFIJBKJzQgP5WuvmVYIAtijWK0apykKDORnLy/T5OfmOTY7d+ZlZgcHPiZSB23cyMvDHTuyxzMigoNkEhK4zfDhPFb16kCePNzXxYvcX2AgezZDQ4343/+KQ6djD2OFChyg8/rr3CYmhvdsAhxRrtNxIM+ff3L99erVeQ4i0p6IqxadP8/9FSzIHssbN7hSkasreyOFF9jfH/jxR+7z7FklcMpo5D2a1avzfVSsyNcASiS+0cheyoEDOQdpcrLpFgYi4LvvlPctWrDHlwioW5eX6Zs2VR5Go2LbnI52l57PDFK/fn3p+dRAeiW0kXbRRtrFOtI22ki7aJNddhGes2XL+HnJEqJJk4hGjSLq1Yu9didOsDdQtMuXT/G+RUWZeh0Fwnspjgvv6ocfmnpJiYjatmVvaMOGRO7u7CUU3tM6dRRPYLNmRPXqGahVq0vk62ukoUOJnJz4Wr2e6MgRou+/57aFC/M43bvz+379uC3AHk5XV/Y4hobyMTc39sw6OhKVL88ezoAAUw+uwGgkql9f8US6uBB16sRzuHGD22zaxP3a2/O8fX2JBgzgfoWXs3p1ojx5FK/st9/yvbi58bUVKhD5+yt2CQ5WzgFEn3+uzMfTsz75+UnPp0QikUgkkhzElvKL5kFG165xJPikSZwb87XX2Lso9jSeO8cexsBADugxDwwS9O3LXsQBA1gqiUpGa9ealtckYu8nEQcECS9hp06cZzMqiiPiXVyA3buBo0d1ePrUAWXLEn77jdMZ+fqyF7B9e2DvXu737bd5vrt2cZs1a7gNwPss58zh13Pn8vOQIVxv3dWVvZ4FCnCuz5kzeT7q4KaICODyZQ4+mjmTPbnr1nF2AD8/vpdZs/iaiRN53j168J7a8eN5v2l0ND8cHfm+FyzgdEtEfKxTJy7beecOfxalS7Pn9skT3hfbpg2nfIqPZ9v6+ZFJCdBsJ8dk70uO9HxqI70S2ki7aCPtYh1pG22kXbR5UbsIT6OfH1GjRsreRnOEp1E8t2uneN08PIju3VPabt3K7ebOZS+fuzvvXaxe3dLz+egRewy9vNhr+PAhUUICe0MrVFDmM2oUj+fpyd7B69f5mlatiIKC2EtpNBLt389juroayd4+mSZOTCI3N6Jy5fi6SpW4n7x5+XnzZp5TrVpEkyfztWKPaPPm3Ge5cvzeyYkoNpbns3o1ez+rVFHsJmw5dKjp/lZx3NWVPZarV3Mfa9YoHk6jkb2XDg7s5QwLM+1PeJRfe43nUrkyj2swsPfWzY29zMLbWa4ce2MfPVL6kJ5PiUQikUgk2YqWh1Mr+lwL4Wns3Zufz5/n4zdvctR4vnz8PikJmDCB2332GXsinz9nT9zNm5YpmDw9uT+AvYr9+/M1depw5LlIrSQ8j8+fc4L2mTN5b+eOHcDhw1xrXafj/Ze1agGVKhGaN/8H8+bZITmZ93fOmMFz0+t5T6qbG/DGG+yNPXIE+OQTnltyMo/19CnPOyaG3ycnc4oogPeJFi3KEeii1rrw2i5YwPs1xf5WnY69ss+e8fPw4ew1FblEPTy4zfffc98ffcTeT1GpKDycPcqFCyuJ5f/8kz2m69ZxRHxCglIVacQItlnp0pyLdehQ/owiIrhN4cIv8CV6QaT4lEgkEonkP4JWfk2RLF7UR1eXszRHVAYKDOTnixf5eNmyytL4gwdAlSpcxefBA+7n3XeVPlq35uXxQoV4mVvQuTOLJgcH4JdfeNm7Z08lB+ewYSyuHBy4WtCwYSzwHj7k6/V6Hi8qio+//TZw9aoORISyZQmBgXy/773HArR5c77Ox4cFqNpG9vZKANDp0yze7t3jwKZChZTtAUScE1SdRglg+7z7LifAnzuXz4vl9bAwHr9sWRbI6uArgP8xWLGCRWLXrkqlIg8PpY1Ox8nx7ex4mX3oUN4G8OmnfD8HDvDxsmWB/Pk5HdaMGZwvdNgwoFgxwo0bNn1lsgQpPiUSiUQi+Y+g5eHUij4XUdlqoqM5ajo0lAXRwIFK/smRIxUBlpjIfRuNwLffshfz++85+bmzM++nzJOHRaODg9K/8BjevcveUYCjwOfNY8/j0qUsTqtU4XPPnvFeUSGAdTr2xHbsyInVZ80CQkIM2Lu3OKpXN+LUKRaVgwfzNevXc031q1fZHoKBA9m7mS8fzy8+nsUfwJ5Dg4Hryq9bx22fPmUPr9qbS8R7MF1cWAyrbR8ertyrv7/iMVUjPoOtWy0/v5s3WfxeucL2OHKEKzJ16sR7RCtUYLGs03HfW7dyVgBhp3LlWGznZIUjueczg8g9n9rI/VjaSLtoI+1iHWkbbaRdtLHFLlr5NfPl044+j442zQ+p3hPasCE/QkOJatTg3JrqfaJhYUSlSyuR4snJvM/Ty4v3hZYvr+Tv7NuXI+Br1eKxjEYeQ/gVHz7k/Yzu7rxXMjqaqHdvPjdqFNEffyhtBw/ma/V6oj59eE4NGhjozTcvkZOTkQCeh15P9PXXyn35+xMVKcKvr13j8yEhbB9nZ95POmMGHzMa+biXF9tOtNWyrZ+fkhXg+nXLqP20EHtQp0yx7EOMN3UqUcmSRPnzK1Hx0dHKZ7pmDdvN0ZH3sjo7s71zes+nFJ8ZRIpPbeQfBm2kXbSRdrGOtI020i7a2GKXsDBTkWgwcFBL9epptxdiSgggkTJo82YWNPnzsyiKiuL3kyYpojAigo+JJOl2dny8dWsO3qlRQwl0Wr2ayMeHz7u78zzWrOH+haCaN4/PBwcryeft7FiI6nTcl4MDB9f4+RkpJOQk+fgYUwKIHB05UCohgftft46vW7tWEckGg2mgjxpxXK/n+RsMyjzNRaKtgVypYa0PMZ46mEj92TVowEFcTZvyPQcEKEFLjo71qU4dKT5fOqT41Eb+YdBG2kUbaRfrSNto81+3i9pLqEbLLuq2Wvk116zh6j5OTpb9EbGoyZePBZ4Ql+I6X1/2+DVqZFrJqH59fp8nj1K1R7T18uLjOh0f//JLjtC2t2ePo4h2F7k0HRxMhZwQw7/8oohIIWS9vZVcm/nyKdWHFi1Korx5n9GqVUk0Y4YiiAFun5jIwq1VK74OYHErUHsR1WzaxPfh5KQcsyYShQdTy8a2otWHWhybz1NUmipRgoW/yCt6/ryscPRSERQUZPKIjIzM6SlJJBKJ5D+EVrCQLW0HDOC8kaIKEKAEGc2apeTfNO/Pw4ODVS5f5n2cHTvycbEf8cQJfvj68v5NnY6Dcx4/5n2SixZx+9u3+frKlbnaERHvpTx9GilBLwcPAlWr8v5JLy8+ljevaUCOCHa6eJH3gup0nOMS4AAff3+u1R4YyPtLk5OBzZv1KFw4Hu+9R9i6VQkyAnhP6oYN3N/atRyhX6AA708VtggM5Hyc5vs5Z83i4CxRJx2wvo9TRNGb5zZND1p9qKPqAdN5ikpQ168DH34I7N/PdmzcmJ/z58/4XDIDKT4lEolEInkJsDUdknnb06f5ASjiRB1kJESdeX8REcD9+xz1nZjIATqAkjLot99YZE6dCowezQEsCQnA119zkFGzZhyNTQR88w0LNiE2O3QAtmzh13o9MGgQsG8fp0+aPRt46y3uQy3kRGnI0aM5KMnFhRPbz5vH6Zj27uVgm/nzgYAAwN0d2LVLh5Ytr2D9eh0uXuRylF9/zWUtk5PZHtOnA9u381wfP7a0hbl9IiKAyEi+Xl1aFMgcoZke1OJ4zBieZ0QEv2/alO22bRuno9qwQbFnjpNjPteXHLnsrs1/fUnMGtIu2ki7WEfaRpvcbBdrS+KZgVZAi6+vEmSitou67aNHSlJzseQ6b56SJF7MecAAXp7t3VsZr1AhXsZu146Xl8V4RiMndBfL1/Xr87k8eXgJ3d6eg4zCwogCAzkh+pAhRElJnNzdzY33eer1vDQu9ndWq8bHAaKaNbX3R4oAIUdHXnI2T+quZvVqIr3eSHnzPqVChYwWwT4tW3I/167x/NV7ItW2Vdv7+nXTZPi5AfXnLYKhRJnPqVO1v5P16slld4lEIpFIXmrSsySeEWxNh2TedvRo9tCVK8epij75hNMD2duzx2/AAJ7z4cOceFx4N8eN42XvR484v+WAAcp4ERHsYRMULQoUKQKsXMlL2a6u7GVbsgRo0QKIjeXr7O05cfrq1ew5rFpVKWFpNHLS+5s3OW3RmTM8jjlnz7I3tmxZLkV54YKy/Dx/vmni/C5dOMn8w4fOcHEhk1ya0dHsaa1UifNqennxPEUid3PbimO1avF9VK5smpszJxEe4aFDgeBg3rqQmMjezmHDstcTazM5JntfcqTnU5vc7JXISaRdtJF2sY60jTa51S7m0eCZ6RXTChYiMk2HJOxy8mSiSVtRnlJEob/7ruKxdHdnL9nBg0qwDcABPSKCfcAApfRjdDR7QPPnJ+rfXwkm0uuJbtzg8cLC2INYqBCnO3J0ZNuY2ypvXp5b3brcj6sre0S//Zbo1Cmel5eXqfdR7eHcskWZ7/jxytjmEeWnTiWSq2sCOTgY6dEjy36ioznCPV8+089MK9AoOpqoYkW+p6zwbr8I6mCnmjXT9sBLz6dEIpFIJC8x6akQlF6ER7V/f0vvVWAgHw8JYU/esGHB6N3bLqVtdDRf7+LC77t1U0o3AuzpBNhDef++cjwkhNuXLw/88APfT1ISMHYsBy0lJSlBQW++yYFJbdrw+/Bw9iDmzWuZIF1tq86d2WMpEp8/fcqe0OrV+TkxkY+NHq1cq07SXr68cnzzZmVs8/2agYHA0qV7oNOxJ9S8n8BAoGFD3iuq9mRqBRq99hrg7c2e49zmSVQHO33zTS71dqrIteLz2rVrCAkJQalSpeDk5IR8+fKhefPm2L59u819LFiwADqdDjqdDr169crC2UokEonkv0p6lsTTi1ooaREezlV9unSxx61bboiK0mHMGEW09u3Ly+rr1rF4IlKEY3Iyi64ffjDt8++/gVOnOCK9fHkWmC1asHC9e5eXyH/6idsGBPDy94kTvOQtloDv32chPn48i00hxMeN41rjGzdyffWiRfm4Tsfi9q+/+H2ZMrwkvnAh96sW+B4eQKlSynzt7PhZvfysFv5ubskIDzdg+3Zealf3Ex3N0eJaVYa0Ao1S+yxymuwOdnoRcqX4PHbsGKpUqYL58+fj2bNnaNmyJQICAvDzzz/jrbfeQrgNn/zff/+NTz75BDrzb5NEIpFIJJlEdDQLJLV4sbYHMb2YCy4tPD2B9u1ZJNnbE1xdOXI7IoJFaZkywKhRLMh69GDBB3CEuYsLi8enT/lY06b8bDRyqqJ9+4A5c3iv6LFjypgODly3HWCR/d137LEUXsLOnVnoNmoEDB9uKsSXLOHa42I/YsOG7E0dMgRo0sRUfI4Zw7YMCWFhqhb4QnAC7I0UWBP+w4YR/P2Bli2VOvRCoA8YoC3Y1GL2xo20PwtJOsixBX8rPHv2jIoUKUIAqGPHjvT06dOUc0ePHiUfHx8CQLt377bah8FgoAYNGpC7uzt169aNANBHH32UqfOUez61ya37sXIaaRdtpF2sI22jTW6yi7Uoa4HWHsT0YMv1ItI5b14j5cv3hFasSEqJdBZlLPV63qc5ZIhpVaM1a3jfp0jo3rGjso+yRg2OkA8J4Wtat+Z9kf7+fN7fn+jDD7l8pNZeV/WeSfXrDz/k+URF8cPBgRPdi72dAwZw/598wrYNCeF+nZ05Ol/NwoU8j8hI0+NbtyrVkdTfl99/5/GmTuVzYp+uel+pOZlRoSg3Ivd8mrFp0yZcu3YNXl5eWLRoEVxcXFLO1axZE2PGjAEAfPHFF1b7mD17Ng4ePIgpU6agePHiWT1liUQikfwHsWVJPK18nKmxZAl73bQW8MQ+RLHk/+wZ8OiREypVIsTEsPfywgVuYzSyh3PRIvbc2dmxV7RzZ8Bg4DbOzsreSZ0OuHQJ6NWLl6QvXmRP55w5nKsT4MTx338PfP659l5X9Z7J115TXl+6xB7XyEjeEuDoyH16eHCi+vnzuf+YGB530iRlzlOnmmYR6NsXuHaNE86r7TJjBvDxx5Y2q10bWLECmDnTdk+mtcTxkhcj14nPY//69qtXrw4vsTFFxRtvvAEAOHz4MG7fvm1x/s8//8To0aPRsGFD9OvXL0vnKpFIJJL/JlpL4t98wymLBNb2IJoTHc3C6OxZ09d9+rCQUguuqVN52XjxYmXJf+5cXsr29EzA4MF2SE5W9maWLs1pi+bOBXr2ZLFYoAALt3/+YdEKAJMnsxD19FTu5803OVF7cLCy5N2+PfDOO0Dx4rx0ntpeV7X4Dg/nRPfnznES+QEDeF9ptWrK9d98o9znpk2KbTt3BqpUAU6eTFvIp/UPgTplknruqfEy7aV8Wch14vPx48cAAB8fH83z+fLlAwAQEU6ePGlyzmAwoFu3btDpdPj666/lfk+JRCKRZAnmQUZHjrC4CwoybZdW8JF5GUx1rlBRsUYIrlOngE8/ZXF17JgSBR8ZycLx2TMHREXp0Lu34qFr3JgDdypV4mNGI1ciCg9XIsnd3YEGDbiPx4/ZixkQwCIzKYmFbP36fL1OxwL00SMWkuZ7XYcOZWEMWBffzZvzPtOEBM47Kq4PDWUb+vqy0BO21en4vpOTUxfytuyRlZ7M3IF9Tk/AnAIFCgDggCEt1McvX75scm7atGk4cuQIZs6ciVLqULh0EmT+20ODyMhI+Pv7IykpKcPjvIoIe0i7mCLtoo20i3WkbbTJLXZZssQe335rQHIyuyWvXdMBsEfFioSkpGSTtoMH6/Dhh3b48stki34iInS4eNEOhw8no2pVe+h0wMmTyahXzx5btxoweTIwdKgdmjdPxpkzPAYA/PQTISkJWLGC244Zk4jhw1lJjRyZhGXL7EGkA2BAUhJncv/mG3s4ObHgevAgGTt22MPFBdizJxkhIXb44APC4cM63Lunw2uvGWEw2CEgwIhr13SYPBn47LNkPHkCDB1qDx8f4IMPjChb1gjxURAB06fboXdvShmzQwdg8WI71KqlQ6VKbKvatfn16dM6jBtHaNbMkCICQ0KAtWvtMXt2MpKTTfvt149w8qQO4eGEKVOMFrYMD9ejbFkd3nnHkDInre9L2bLAoUPivG2f96sGEeWogy7Xic/GjRtj4sSJOHHiBE6dOoWqVauanF+0aFHK67i4uJTX0dHRCA8PR7169TBo0KBsm++ePXuybayXCWkXbaRdtJF2sY60jTY5bZfGjQPx+ed5APwKnQ745ZeiAKrCweEuduz4PaUdEfD55/XRpEksduwwDX1/+tQeoaFN0KPHafz22x0kJXG4+e+/70GnTgUxeHAFzJ//E7y9a6Nnz1h4eCQCeA0AL5m///4fqFq1JPLli8euXTEoXjwPAB1CQ2PRvLkeu3aVwIoVhNdf3w0Xl2QULBiM27fd4OcXh2rV3PH4sR4DB57Chg1AdHQg+vXbhwYNHBAS0hg//MDyICjoNMqUicHAgU1Qt24MihaNh719Ady964BatfZhxw5FUP/yS+GUftTHO3TwwNy5VdGhwykAwNy5VfHhh6eQP38x7NlTHCNHnkFw8A0QAZ99Vh/Nm8fin3/O4p9/LPstWdIFw4YFo0SJgyhaVHGB/vOPBxYsaIjp0/dj505L12hOf19yG7GxsfBWpwnIZnREmV0E7MVp2LAhDhw4AH9/fyxYsADBwcF48OABFixYgK+++gr29vZISkrC5MmT8emnnyI5ORm1a9fGuXPncPr0aZQrVy6lr7Fjx2LcuHH46KOPsGzZskybY1BQEGJiYnD8+HE4ODhkWr8vO0lJSdizZw+aNm0q7aJC2kUbaRfrSNtok1vsEhcHVKxojylTDOjUiTB5sh5jxtihe3cjliwxpLSLiNBh5Eg7REUlmywFR0cDLVvao0gRwuHDBnz6qR6nTulgNAI1ahAmTzaiaVM7VK9O+PBDI+rVs8ebbxrx/fdKjqHy5Y04f16HsmUJFy/q0LLl3xg3zg/Bwc44fDgZvXvb4cQJHbp2NWLIECPq1rWHhwcQFmbA7Nl2KFKEsHOnAZUqKfeRmAi4uzuo7jMJzs5Ay5Z2+OknHRwdeTn9q6+4vTV72GrD0qVZ5P71VzJ+/NHSVlr9fvIJ22r3bvaYEiHFVuYe0dzyfcltNGzYEHq9HoeECzi7ybE4+1S4c+cO1a9fnwBYPEJDQ6lGjRoEgJYsWUJERGPHjiUANGXKFIu+wsPDZaqlbCQ3pUHJTUi7aCPtYh1pG21yg12iorh84ZQpnAYoLo5TAok0RQsWcDuRBsm81KbRqKQyqlmTUwWp0xKJkpnq12FhRN7eyhgAkZ0dUe/eXO6xeHEjOTkl0Z49SSkpmqKiuI1Op6SEWrOG0y45OSn9qlMIPXrE7QGiggWV40lJStomrZRDGU0rtXo1z//jj7VtpdWvuV1TS5mUG74vuZGcTrWU65bdAd73efDgQezduxf79u3DgwcPULBgQbRt2xY1atSAn58fAKDiv/kVNm3aBADYtm0bduzYYdLXlStXAADbt29Ho0aNAAD79+/PlvuQSCQSyauFOkBoxw4lmEidfGXfPk4tZB6UJFi7loOE+vQBtmwBOnY0LZ8pSmbu26e83ryZUx0BHNn+4AEniq9dm1Me3bkDJCTYo3dvwscfs2f19GmgYEEOMDpzBti2DXBz4z4rVODxlizhCHGx/W/cOI4sr1WL57ZuHQdNbdjA1z55woFB6u2CokrQ8ePpD+Dp0oVTLS1ZAtSoYWora/2qA5mCgznIaMYMmfz9pSLHZG8GuXTpEgEgHx8fSkhIICKiypUra3pJrT0yA+n51Eb+l6mNtIs20i7WkbbRJj12ER7K6OjMG1942URS9alT2WtZtarikaxYkccWXks1jx4ReXkR5c3Lnrr+/dmbeOOGaRvh2VO/dnXl/sVY1avzuTVriOrXN5CLS6KJVzRPHvZy6nR8bVyc4vkUnla1Z9F8zmvWcP/iXgMCeEy1JzKtRPu2EB3NSfFr1rS9X1uTv8ufI21y2vOZ61ItpcX06dMBAH369IGjoyMA4PTp0yAizYcoxfnRRx+lHJNIJBLJq43aQynKPr4o6lQ+Iqn6zJnARx9x6qHatbndhQvWyzaOGsVphubN4zlt2sTe0a++UtqoPXs6Hb8OC1Mis0+dAkqW5ETxej2wahXQs6cRSUnKn/RatTiHZ3Iy5+NMTua5DxvGeTZF0neRzikiwnLO6pyYXl5AbCx7QzO73nlgIPcpatDb0q9MmfRykyvF57lz50wi2QEgOTkZkyZNwuLFi1G6dGmMFgnKJBKJRCIxQ4iXo0dfrMqQGvNldCHOABZ6AwdyxZ6EBBaG5sIpOppzYFauzNeOG8fXN2/OS89vvgmcOGHa97hx/LpcORaHVaoAhQqxCHz+HLh/H/jf/4D8+YFWrS6jcGFW2U5OPE6ZMrxkXrYs12gX8xcJ4HfsYHE7YAC/V89ZCDxfX+DePV7aVlcyysx65xmpoy6Tv7+85ErxuWTJEhQsWBBBQUHo2LEj2rVrB39/f4wePRqlSpXCnj174ObmltPTlEgkEkkuRMtDmVaVobQQ1YTMk6rPnw8sW8b7IIcPB4oV43Nvvgm88QZXKgIUT6xOx95GnY73Ofr4sPA0GFgIXr+u9C0StovXCxZwwvcLF3jP5uuvs9D18AAaNyZ06vQnjEZu+/vvXDFIiDNnZ97/KeZvvm/y6VOgenVLsRcYCDRsyOOZi+70VAmyhazqV5L7yJXis1WrVmjevDmuXr2KLVu24Oeff0bRokUxdepUREZGynrtEolEIrGKNQ+ltSpDaSGEozooSBAYyIFDmzaxl/HaNT7+yy+mS/7CE/vxx0rJzEaNgI0buX1oKAtCUTtFXaOcCJgyBbC3V7yBM2cCe/dyW70ecHAAXF2T8eWXBsydC/Turcw1IgK4eZNFq3r+wi61a7OXdN8+RSwLRNCPlujO7CVvuZT+3yFXRrs3a9YMzZo1y5S+xo4di7Fjx2ZKXxKJRCLJ3QgP5bFjlmKpRg2gR4/0L9MK4bhtm/b5Vq04Et3bG8iblyPP794F/vgDqFkTWL6ca6rPmMEe0fLlWUTu28fXv/UWi8maNdlj+9FHPJYYMyKCI77d3VmAAsC/laYBsKd3xQodCha0FGzCC6wVDS7s0rMnz3H5ciXKXuTPtLZ3VSx5ZzZZ1a8kd5ErPZ8SiUQikaSXtDyUIm1ReoKPbKkXLpbz4+OB/ft5eXvxYmXJf/BgoHRpXrpu2pTfi8Cj117jfZ7x8eyJ1Om4XVgYX0vE7RMSOL3SpUs8lroKdLlyQFiYHR48cMaIEXYYOJCX3AHr6Z7UdhFL82IfaGYGE0kkWkjxaSNBQUEmj8jIyJyekkQikUhUpCWWzMWVLWiJt0WLeD9nbCy/Fzk+8+ThvJXmS/7Pn/PezoEDeSl++3YWqD4+7GUUWwJ0Oo5Kv3oV8PPjPsaO5Sh3/b9/rf39+blECd7XefEi8N13HPA0ZEhDlC1LOHYMKbk+zZfMUyMjQT8SSUaQ4lMikUgkLz22eCjV4srW4KMlS5SUR4J+/YCffuK+AEV8BgSwF9N8f+QHH3B0+rlzHH1/6RJ7M58+5Wj1+fNZJEZH8zGAE8+fPct9OTmxFxXgvaWC2rUVj2qXLkYkJdmhaVMjLl3ioCZrS+apIYN+JNmBFJ82cujQIZNHpUqVcnpKEolEIvmXtJaXBekNPurTRwkQAoDHj5VzN2/y861b/Hz0KEeML1rE+zejovj4hAn87ODAHk11ftCQEF5679cPeO89riAEsAe0b19O3fTVV7yHFGARK8ZVM2uWEU5OBkyfbofp04Eff8zYkrkM+pFkB1J8SiQSieSlR8tDqYU6hZEtmC/VnzunnHvnHX4Wns/ERGDrVk4Cf/y4Ejk+cyYL3tu3WdgVKsSR8YDS95AhnBtUBBT99BOXx6xWDWjShPd8AuzVbdPGcp6enkDJkrF4+hRo0ODFlsxl/kxJViPFp0QikUheGqKjgeHDgy1SApl7KOfOBSpWZBFmNCrt1CmMbMF8qV6M26QJR64DvEcT4Pd+fuyBBVhYiuj777/n48OG8bXx8Up+0KFDgS++UFImAcDBg7zXc+FCJfennx+wciUv7W/ZYmmXqKj8qFiRULu2XDKX5G6k+JRIJBLJSwEREBrKUd2hoXYmUevmHsqtW1mQzZgBxMQo7TISwa1eqhfiU+0VjIlh0ThtGr8vX56fz59Xou8rVOBKQ8KD2aoVH9+xg/dzLl0KVK2qeESNRr42MJD3hTo5AUWKAG3b8tJ+9+6KqBZ2adXqMpYtM8glc0muJ1fm+ZRIJBKJxJyICODSJR2mTTuAzz5rhnXrWBgCph7Kt97iHJuCu3c5L2ZqOS9TQ+yDrFkT+OEHXgr39eU9nk+e8B7MefMU0Smef/uNvZciP2i5crysnpzMXtLAQD7m6spL8StWcF8izbUQyC1acDS72G+6eTNXUho8mD28wi4zZvyJwMBiMk+mJNcjPZ8SiUQiyRVER3MEt/mSOqAIx8mTDfDxeY7Jkw0WUevCQzliBKcKEty7x8/jxrGXcdYs7TFSIzCQg4KmTuVxvvqK59qtG4vHlSuVJf/XXuPnf/7h9kLoHjzIwhMA/v6bBXP79sCVK7yUHhjIArdQIWD1aj4v0OmUfvz9ORhpwQL29gq7uLgkp++mJJIcQopPiUQikeQ4IkG8uiSlGhHN3rEjn+jUiSyi1nU63kO5cKHptffusbCdP5/fa42RmvAV53/5hc+vW8f7SQEWua6uwJkz7IEEgOLFATs7fl27ttLHjBn8XK8e14G/cYNTJ5Urx2IWAMaPZ89pWvs1585lMVqjhqldJJKXASk+JRKJRJLjiL2YR49aJoIXQTta9cXnz1cEIxF7NUXQjuDuXRabTZrwsrb5GGkJX/V5vZ6Txfv58TmjkfdkJidzTs34eBaeRLw0//Aht4uLA3bv5teDBpnm0pw8WYm+F1H7Z88qYvjddzmyXi2M9Xpg4kTOCyr3d0peNqT4lEgkEkmOok4QL0pSiiX19JTMFAJWRKELfvqJxebJk9pjpCZ8AeX80KFct/35c8s8oQEBLARHj+b3gwaxsKxRg99/9pmy5F6/vpJLc+5c9nqK6Ps+fdgr2qABcOEC0KsXR8pv2cJiVkDElY2GDJEpkSQvH1J8SiQSiSRHMU8Qr44ut7Vk5vLlioA191zu2sVBQurlbDHGqFHWhS9gKozFPlKjUSl3KahaFahUiT20Z8/y3IWQjY7maPY1azgBfeHCSi7NyEjT+wsP5z2gsbEsokVe0Xr1AG9vZTxZd13yMiOj3W0kKCjI5H1kZCT8RZFdiUQikWQIsaR+7Jjlknr16hx0M3t22iUz+/RhgdmpEwvLuDheGk9K4hRFP/+sPUblysp1AF+7ZAmLx+nTeYn98WPe47l8ObcpUICFaOnSXCoT4LFGjOD+evRgYSmEbMmSvCTfpYvp3K1F3wthe+sW13A/cwZo2jTt6ySSlwXp+ZRIJBJJjpDWknqFCiweO3bkYxcvAo0b2+HEiQImbStW5FREJUsq4tLTkz2NiYmc3khrDCLLvZLqvaSbNnHUubMzi9DoaG7j6srXipycAEeoBwZyFPqZM+zhnDeP95v+9huXzjRHqyTouHFKv0ePKimj/vor9eskkpcJKT5tRNZ2l0gkkswlraXjP/9kMbh+Pb/v3h04dEiP8ePrprQhYmHYpg3n4FTTti3QsiWPMWaM6TkhfPv25UAi9T5PkVbpgw8AFxcul3n+vFJGMzaWz4vKQwCLTwCYNInF6ahR7P00GHiZ/u232XMaF8ftoqM5VZI6WEh4gadM4fePH7N49vNjG5w9q32dRPKyIcWnRCKRSLId9V5KraXj6GjA3R3ImxcIC+M9mMePW7YTAvbePQ7amTSJg3XWreNjR49y9Pv27drXTZpkuc8T4OXup0+B99/nPZp9+vBxvZ6XuydO5Ch3EfUuxKenJwvDp0+Vvaciyv6jj7jCkRC+AwYo3li1F7hxY9M9pe3a8fEBAyyvk0heRqT4lEgkEkm2o95LaY4QYgB7F728eKk5MdG0jRCwb78NXL7MHtTDh4FDh7jk5WefAQ8ecBUiIS537uQ9nqGhivBVBzgB3O/IkSwst27l60SkuaMjL3eLvaZxcfy+ZEllbl26sDgU4tPRkZ91Ol7C1/L4qo85OHAkvMDDg4+fOcMBSjLISPKyI8WnRCKRSLIVIt6P6eDAIpSI93auXs0eQiHEjh/nJexr13gPpeCLLw4DYLFYujQvtwsheeYMt6lcGVi7VrmmRAluv2IFR5MXKqTsmdTpeA/l3Ln8fuBA3kO6axcfHzeOl+CdnTldkohA79yZg6IKF+ZylwKdDihaVFkW37lTOT5smKXHV8sLXLw4R7cPHw6sWqV4Zc0j+SWSlxEpPiUSiUSSrUREsJArVw6IiuIAm3XrgK5dOV2ROvXR3Lm8hF28OO/hrFfPiEqV7kOn46h0Hx8lhVJsrJIOqUIFXioXlYY++IATuf/xByd+b99eEYcxMdxXYiJHmK9Zw3tIK1Zkj+nixbwFoH9/Fq0DBijBSuK8mqgorufeoIHpcT8/Hsff3zLIyDyAaM8e9tpOmaIkpK9She1jnmNUInnZkOJTIpFIJNmG8PLNns0eSCcnXjL/7DM+7+TEQT7VqvF7nY4F5J9/8j7L/fsNKX21b8/L4nPncrs//+Tjfn5Anjymy9NLlrAYFamRdu1SvIii7CXAnlFnZxZ+RiOL4Hff5XPh4ez5PHOGxTIRXysSxAN8rGNHvocvvzS993HjlL2hakRVI3UAkXqpXiSknzePbWcudiWSlw0pPiUSiSQXEh0NDB8ebLXWeFaOm1qN8xdFePl69uS9mrdv89K1iBy/eRP4+29g5UoWqsOHc7Wg5GT2DB45osPmzaXw8886/PUXi7yoKL5WiM9y5fjZ01PZi/nPP0Dv3rycDrCAXLyYx5g3T5nf9OksjC9d4nEjI3kuY8Zwf0KoDhnC0evmezeXL+d5zJnDAtrTUznXvj2fM4+u79OH+7W2pC4S0r/2mqXYlUheRqT4lEgkklwGERAaaocHD5wRGmqXbfv80qpx/qKoa7THxwMbN7JQLFuWvYwAUPffLEpr1gBjx/K5EydYZJ49C0yapMeKFRUwY4Yely+zUBTBRObiE+A9oQAv4YtUSQCXyBw9mh/OznysSBEWeD17AuPH81yTk3luorpQ5868n9TODhg82HLv5uDBPH6PHtzvpk18rmxZDpwSgUrq6HpRpcm8rKc5sqqR5FVBik+JRCLJZUREAJcu6TBt2gFcuKBLU5Rk5rip1Th/EcwTyo8bx3s1N2zg2uWCypVZoF29ysvNrVrxnIj4sWcPr03/8osO06ezUBSR6o6OLDLLl1f6u3aNn//8E/jlF9M5ubqywBTBQvfvA59+ykvdZ8/yFoDHj7m/AQO4jVgGv3OHvajqfZoiUGnDBmUJvXFjbrthg9LOPLpeS5Cak1ZqKonkZUKKT4lEIslFCJExebIBPj7PMXmyIVVRktnjWqtxbg1bl+nVXju1B7RCBSAggNvY2QFff815MQGgVClg1iye1/PnnPsyOZnP2duz8BNicMECoEMH9toOGqTM7cIF4JNPeN/m119b3rPBwN7PO3d4WX7GDF7GX7iQhS/AgT4ODsp1RiNfV0BVaElE8Ldpw/ekpkABFtUCrUAlc0FqjqxqJHmVkOLTRoKCgkwekZGROT0liUTyCiJERseOvObdqROlKkoye1x1jXNr4wrBGR1t2zK9Wti6u1uW1BT7PV9/nb2XIpn8pUu8Z1PkvKxShZffARZwwrsoKhKJOeh0iqd14ECOGF+4EHj0iFMutWmjzMvNjSsnxcfz/Z45wwFDAwbwOYA9weLeRECRqyu/F95hEcH/4EHa2xW0ApXUItpcyMuqRpJXDSk+JRKJJJeg9ggKkaGuNZ5VQUDpGVe9L/S992xbplcL24gI7m/1ag60efiQl6pbtWKPY0AA9+3pybk/ixThoB8AqFoVGDeOo90fP9YhNlYZw3zfpPn+SE9Pvsfnz7n0peDXX1mEiupBzs7cT1iYsmQfE6P0KwKK5s5lATl0KKd3EhH8ly5lfO+muYhW21tWNZK8SkjxaSOytrtEIslKzPdEqgkM5ONZEQSU3nGFcPrpJxZh7dunvUwvUgnFx7NIq1GDl7mXLmWx2aED5/IsV44j3Yn4vV7PS+8icXzFisCPP+qh13N00uXLyhi//cYitlcvRQxOn85L+UeO8H5P4c1t1065btAgnv/u3fz+zh2ex1dfKR7ZkBBFZKoDikR/tWopEfwvunczLREtkbwKSPEpkUgkuYC0RIatEdFZOa5aOC1dyoLr++9ZaKW2TC9SCY0dy9c8fszHPTx4P+SMGTzGm2+ytzMoiIVn9+7AhAmK5/P+fQ7EKlbsEQD2lp49y57bPn04ybyrqyIGO3XifuvU4bROtWtziiSAl/91Ohal165xcBHAxzZs4GXu7t35/vv353urVs00oMg8B6dO9+J7N9XBR2oRLYOMJK8UJMkQ9evXp4CAAEpMTMzpqeQqEhMTafPmzdIuZki7aCPtwjx6ROTrS7R2rXJMyzZr1nC7uLisG1cLMW5ICFGjRkSRkUQuLkRRUUQNGxINHcrtoqOJnJ35WWscZ2eiLVuI3N05dv34caLLl5UxvLyIChQgKlSI+3R3J4qNFXHufHzVqiSaMuUXKl7cSHo9UVAQz8HNjdt89BFRrVrKHK5dU64HiDw9ee579xLdu0ek0/Hx+fOVNo8fE4WF8b0ajdxPVBSRhwdRt25p2zU6mscwt0NUlLZ9zDEa+Z78/EznkBryZ0kbaRdt6tWrR/Xr18+x8aXnUyKRSHIYc2/YmTNA8+Z2OH8+r0m7tLxqLzquNTp35qXpRYt4r+PAgewNrFBB2Re6eTMvO7/3nuX2AOHNs7MDvviCPZ8uLhwBXrw4t3nzTV5qd3Pj1EbHjnFATmIiewHLlePjHTsSbt92RWIieziPHWPPaJUq3I+DAy+ziy0E+fOb3kt8PKc/atKEvaJEgK8v77W0t+c2t29bepojI9n7KOq/p8aL7t3U8qhKJK8SUnxKJBJJDmNeXrFTJ+Dnn/UYMSLYpJ21WuKZNW5qPH/O7SIjTZfphdDq3p33SF6+DJw/b7k9QAjnkydZ5FWurIg9gEVp5cp8ffHiHLgTHs7isXt3rlAkktOvWFEBkycbEBoKJCSwsPv7b+5HbAMQJCRYlq08fpzbnDzJx6pX5zaFC/P71at5i0GPHkBoaMaWv19076aoaiSDjCSvIlJ8SiQSSQ5jXl7xxg3tdlopejJr3OhoFmHly3Okt0EpoY61azlfZs+epiLs4UPg2285fVF8PEeRX7oENGoEdOvGUfBq7OyUVEirVinHRSqhb75hD+bKlcDUqTyGucdwwgQ9ChZ8gps3dejTh72DgYHArVvcV7lypp7hceOU/ZwAp0kqX573n4p8oEJ0+vnx8+zZXH1p0iS2g3oPqa3IvZsSiXWk+JRIJJIcxtxL1qKFdruMRj5bSwQvxo2IYIF35Qq/nzmTPZEAewBDQjiQx8FBEWG7d7OI+/BDrr/erx8wcSJft3EjC8wOHUyj5G/e5ETuycnsUQQsxWXNmnzst98s7zk6Gli8WI+3376EESPsEBcH/PADR6ADQN687BUW6aFECil1uc1OnZR8moJatfj5yy/5vgICeFwAeOONjC9/m0fDywTxEgkjxadEIpHkINHRQNOmLMZEip6ZM/mcXm9MqeiTWoqe1KoMpVavXXjnBgxg0fnWW8q5H3/k59GjeS/m/PnAihXKMn2+fBx9DvDSdp8+LLQ2buRjr7/OY5pHyYtE8zt2sGfUXFx++y2LtIULeU7myen79jWiVKmHKfMsW5aX6f392bP62mu8H1Xk7ezfHyhaVLmvMmWUFFLVqrGHtXt3PtewIX8WI0Yoie4rVcr48rfcuymRaCPFp0Qi+U9ia1nIrEQtDHfsUIKJfH0BJyeC0ahPyTVpLTgoNXEJpF2vXQT6VK/OIktw5Qo/L17M8+rc2XSZvlo1Foh2dtxu2jT2fu7aBYwfD+zZwymThg5lAVuuHHsA69XjsfR6zrc5dKipuBwwgMtUenhwO3Vy+osXgc8+M2LBgioA+Eb/+Ye9pWfPsmd23ToWsmfO8P7U8HD2XgpEHffwcF6q9/fnuajtOWOGsgQvqitlFLl3UyKxRIpPiUTynyMtwZZdqIXhhQssBBcsAM6dA+bONWDEiCPw8Um9vGJq4tKWeu0i0EckjRfExHAkudGolLRUbw8g4r2gQgyvXcveW39/HsvFhduIKPl58zjA5+xZHr9yZRZ/rq6m4jI8nMXgypWcUzM0VElOP306X3/yZEEULswf2g8/sNBV77EU9yc+19atWeg6OXFAEqDd/upV3k8bGansE31R8SmRSDTIsSRPLxn169c3eXh4eMg8nxrInGraSLtok1N2WbOGcyhev25bnsuswDzHpjqXposLUZ48Rpo+/WdKSEg0yaVpSx8iD6h5rkqRP1L0FRWl5KNs3pxzXNaoQeTqyq8rVOD5qMdo25ZzVQ4fzjaMiyNq2lTJkfnTT9x+2TLOy+nvz8c3byYaMYJff/wxj5knD5GDA+fi1PocxPyHDOFng4GocGEj5cv3hNq3N6SMWby46f1Vr87tg4NN7WZuH3N7rF+v9Cfyhv75Z0Y+3exH/o7RRtpFG5nnUyKRSLIRW7yB2YH5MroITgF4D+WjRzo4Ohqxbp3OapCRtT7GjUu7Xnt0tGlZTS8vbuPnx9HrAKdMmjjR1EbXrnHapTlzlP2nAwdy+9Klge3blVKT7duzd9nVlfdVHjvG7apV4zH/+YfnVKmS9pYC4WlduJDHX7eOg5Z69DiLwYONeP11oG5d7k/c39ChwIkT/DxsmGlaKvM8qeapq7Zs4ed794AnT/i1iISXSCSZSI7J3pccWeFIG/lfpjbSLtrkhF3S8gZmB2qPoxpRIUivZ69bx47nKG9eo6ZnNrU+nJzYg2ntnsLCiAICFM8lEdGwYUR58xL5+BA1bszju7iwN1LYKCxM8Qjq9TwHIqKWLYkcHYl++02p4PPoEVcssrMj6t6d2zs58bXHjilzmTKFvZ9HjmjPdc0aHrNuXfaktmhhoAoV7lJCguV3Ji3Pp7CPsJv6s4+KUuYnvJ+DBmnPKTcif8doI+2iTU57PqX4zCBSfGojf9C1kXbRJrvtkpboS6vsYWaQltgdPNi8HKTRorxiWn0IMfjokfb5a9dYDIaEmB43GLhfsez+3nvKMrWwkZhXmzYs8H79ld9PmaLM6fJlor59eQ5hYVwms2tXRbQ+e2b7vRiNRPXr83UBAUT37iVS3rzPaNWqJIu26u0UXl780CpFKv4BWb2a2z96xHMIDTUt5WlracvcgPwdo420izY5LT7lsrtEIvlPIIKMxDKzGpF6JzuCj9LK1SkSnwucnbWDjP74A9i/3zJaPy4OOHWKl7q3b9ceY+ZMXuY2rwak1/OSfEAABwetW6csUwcGAi1bcjtvb04wf/48p2cqUoSXpy9e5NyedeooUfLHj3MQjyij6ezMD0FaVZt0Oj5XvDindtLrge7do/Hpp3Ymc08tFZU54eE895AQbv/jjzz3L77gqHuAqxxpZQeQSCQvTq4Vn9euXUNISAhKlSoFJycn5MuXD82bN8d2K79Nd+7ciV69eqFGjRrw9fWFk5MTPDw8UKVKFYwaNQr3RUI6iUTynyQt0Wee6D0r0BJIx49zpLvAaDS95t493gNq3oePD0eLh4QABw8Cd+7w+XHjOPn7vHnKPs2BAzm6/PFjbrNkCTBlilINSOQSBVhkHj8OVK1qKQxr1ODnEiW4klHFihwVP2oUJ5qfPp33Sj54wCL+5k3F5mXLAnnycFontWC2pWpTYCCP99prXOEoOPgGypQhi0pGYt/ouHF8v5Urm1Y7Enh68v09fQo0aKB8JkS8nxXg6P/Ro3NmP7BE8sqTYz7XVDh69Ch5e3sTAPL19aW2bdtSUFAQOTg4EAAaM2aMxTXvv/8+AaDSpUvTG2+8QZ07d6ZmzZqRl5cXAaACBQpQdCauqclld23kEoc20i7aZJddzKPCrWEeDZ3ZmO83vXZNWeYVnDjB7x0djWRnxxHdlSopWwLEfk1fX15ezpuX27dty+fd3Ym2bTPdpynGWLnSdB5btnD7Dz7gfZWLFpnO13xPZP783I+7O9HcubwUnjcvL683bMjtjUaismWVMTt3Vvpq0EDZjylsIJbKbbE579c00pw5P9GpU4kpWyiiopRtE+rX6v2dasT+zho1eGwxn7AwXqoXcx83Lvv3A2cU+TtGG2kXbXJ62T3Xic9nz55RkSJFCAB17NiRnj59mnLu6NGj5OPjQwBo9+7dJtedOnWKbt26ZdFffHw8vfvuuwSA6tSpk2nzlOJTG/mDro20izbZZRdz0UdEdPw40YQJRM+fK8eyOvhICEPB0aOK0BHziI4matKEqG5dAwFGAjgISMzf3Z0FnxDSpUvz9UOGWN7r1q1KgBBANHMmtxFiPCCA71WkShLiNC6OqFs3TrWk3hPp4sLthPjNk4fFpYMD0dSpfK0Qk0WLclsHB6KYGO30Vrb+U6AmNDQ5JeBI3KsILNL6/FILMIuOJqpVSxGtLi5Eq1YR2dvz3L/5Jnv3A78I8neMNtIu2kjxacbatWsJAHl5edHDhw8tzs+ePZsAUFBQkM19Xr16lcDlMOiRtR346USKT23kD7o20i7aZJddzEUfkSLI5swxPb51K7fPCsyFkMGgRLbfvKm0MxqJgoMN5On5jACiL79URFr16uydMxiI/vlHuY+ePflaIejWrGGR9cEHSht1gFH//jz2jRvsWQWIdu3ic0lJRDodHytWjIOJ1MJx0iQWbZs3s2CbMkXxxPr68nsnJ7YjwCLVWk7T9Ab13L+vBByJiHoRWKTlRdXKhWrexly0BgbyvPfs0f7cciPyd4w20i7a5LT4zHV7Po/9mwiuevXq8BKJ51S88W+dtMOHD+P27ds29Wlvbw8A0Ov1cHBwyJyJSiSSlwZ1WUhzLl5UXtuy//BFMN9Xqtdz8A7A+yQFERHAhQs6JCTw767YWN6TOGiQUkZy/Xpg+XJuX7MmVxg6e9ayXvuCBcDXX3M7UcEoLo5rsJcrB3z1FSB+lRYqxM/29hywBPB+x88/5/KZIi/q3LnA3r1A27ZcUlOUBm3blvvcvp33oi5YwH08esR5RNX5SNWVj9JT89zTM30BR+pKRjduaLcx3w8sSpqK6kbZsR9YIvkvkevE5+N/d8T7+Phons+XLx8AgIhw8uTJNPtLSEjAqFGjAABNmzaFi6gTJ5FI/jOYiwd1gM2/v1IApB2U9KKYl3RMSFDEZ0wMPwsRVaUKwd8/HuvXJ6NPHxZuSUkcfDNrFvexbBlfU7ky1yxv04YFtLpeu4cHR68XKaKISxGUtGEDC8R79/h4wYL8HB3N1wMcmKPGPFF7eLhSGvTECY5Kv3SJj3/wAc9Tr1eiyAXPn7PozEjNcxFwVKuWElhUq5Z2onr1nLXamIvW8+dZLANKgnmtUpwSiSTj5DrxWaBAAQDA33//rXleffzy5csW50+ePInu3bujW7duaNWqFfz9/bFixQrUrFkTX4t//yUSyX8Kc/Fw65ZyLk8efk5Pqp4XQS3eatRQIt2F57N1a+DuXWDvXh0GDz6Ft98mlCzJwtnJiYVhpUosmm/cYPFasyaL6+vX2UNZvjyPsW8fe0Pr1uW65atWmdaJr1AB+PBDxSOcLx+/7tsXsLPjYwcOAOPHcyqqihU5TZOokqT2tM6cyedXrgSmTjWN5u/fn+cmxP/atXzffftmzIY6HTB7tgH+/spc/P2te1FFZSetNuZVog4eVM6pvwfmolsikWQc+5yegDmNGzfGxIkTceLECZw6dQpVzf7tXrRoUcrruLg4i+uvXr2KlStXmhx74403sHjxYhS2sU5aUFBQmm0iIyPh7++PpKQkm/r8ryDsIe1iirSLNtlplw4dgMWL7RAeTvj8cyMmTtTjyhWgQwcjkpKA8HA9ypbV4Z13DMjq6cyaBdSrZw+DAQBYCd27l4xTpwiHD9vDYNChcmUjihaNR1JS0r/C2B7Tpxtw8qQOISE68OKQHi1aGFCzphGAA3Q6wujR7Nn19yf06UNo0ECPqlUJX31lQEAAMGCAHfr1I5Qty/fdqROweLEDPDwIRMn49lsdTp+2Q8GCwI0bOgQGGhEaasCsWfaIjtbhzh0DypY1om9fPQYM0GH3bkOKbc+f14EIOHzYiPfeMyIiQoeLF+2wcWMyatbUYehQO9Stm4yQEHu4ugJjxyan29biu1K2bBIOHVKOi9fW+itbVrvNkiX2+PZbA5KTWYG3awd88YU9GjcmJCUZTPoYPFiHDz+0w5dfJiO3IX/HaCPtog0RQZee/S6ZTK4Un8HBwThw4ADatGmDBQsWIDg4GA8ePMCCBQuwatUqODg4ICkpCXq9peO2Xbt2ICIYDAZcv34de/fuRXh4OCpUqIBVq1ahQ4cOmTrfPXv2ZGp/rwrSLtpIu2iTXXbp0MEDw4YFo0SJgwgMjE/JafnPPx5YsKAhpk/fj507s2ddNSioMvbsKQ4AGD/+MJyc4tC1a014e7vg3j03lCz5F4iAceOisX17SeTNC3h4HEatWvZYubIJWrX6G8WKFcbRo0b8/fdBODq2+nePKKFYsUf46y9n1Kp1Dg8fVsW+fXr89ttPWLkyL6KjA9Gv3z7s2MEC6to1D5QoUQ03bnjg22/3YciQRkhI0MHf/w5u3PCDnd1d7Nx5BK6uwQDy4tat89ix41LKPEaOjEZw8A106OCBuXOromzZJ1i0qDACA3/G558HoUeP0zh48AY8PQFv7/qoVs0djx/rMXDgKRw8eCPD9sus70zjxoH4/PM8AH5N8YjOmcNbBXbsUNoRAZ9/Xh9NmsRix46zmn3lBuTvGG2kXUyJjY2Ft9jzkwPoiLK6nkf6uXv3Ltq3b4/Dhw9bnAsNDcWhQ4dw/PhxLFmyBL17906zvytXriAwMBB6vR4XL15EIbHx6QUICgpCTEwMjh8/LoOYVCQlJWHPnj1o2rSptIsKaRdt1Hb5808HfPyxHZYsMWRoH6CtfPKJHqdOscdOp2NR0bSpHapXJ0yZYky7g0xi+3Yd3n7bHgULEq5dS0ZEhA6ffmqH2Fjg+XMdJk5MRGDgTnTv3gaxsTrMnp2Mfv3413VEhA4jRtjh11+TUa+ePaZMMWD2bD1OnNDDyYlgbw8sWGDA8OF2uHtXB4AwdKgRM2fq8frrhLg4mNhZ2ODiRR2ePgW6dDFi3To9Hj7UoXFjI3btMqBwYXvcu6dDtWpG/PYb207MIzo6OWWJ2mgECha0R3IyUKMGpdgZ4GX6Fi3sUaQI4fBhQ7oCjQSZ/bMUFwdUrMg27NTJ+p/DiAgdRo60Q1RUcpZuy8go8neMNtIu2jRs2BB6vR6H1MsH2Uiu83wCvO/z4MGD2Lt3L/bt24cHDx6gYMGCaNu2LWrUqAE/Pz8AQMWKFW3qr3jx4nj99dexfft27NmzB127ds20uTo4OMgvtAbSLtpIu2hjb++AIUMccOMGMGSIHvv2pS8COj2MGweULAm0batHqVK8Z/HSJS6x6OBglzWDanD3Lj/Hxupw964DRowAqlUDjh7lYJy8eXllp3hx4PRpYNkyewwcyHbp2pUj3efNc8D06bwknzcv9+fqqkPPnkDXrvb46isex8VFh6VL7WA0AlFROtjbW9p5wQIOWDIYADs7O1SqBOzaBTg46DF0qB737vE+0Js39fjhBz06d1bmMWkSz0OwciXQvj0wZIgOjo7KCpW9PQfz/PST6fGMkFk/Sz4+SLFhu3ba+33j4oARIzgTgrd37v75lb9jtJF2MSUnl9yBXBhwJNDpdGjatCm+/PJLLFmyBOPHj0eNGjXw119/4datW/Dx8UG1atVs7s/NzQ0Ae1UlEknuYt06HS5eZOGV1SltPD1ZfO7axUEos2dbDzKKjgZq17asn/6iREcrEfVubhzxnTcvB/f4+vJxMZ8yZdgbd+WKYpf//Q8IDuZURSJt0blzfO7xY+777FmuhQ5wtLuIZH/40NTOIvK/SBHg2TPej7piBQdfGQwsSGfP5jbTprEAE4Fb1uqyt20LhIZyX2JtjYjTLw0YkLEI96wkrWAi86AkiUTyYuRa8WmN6f/+e92nTx84OjradE1CQkKKa7ls2bJZNjeJRJJ+nj61x4gRdpg+XckjmZ0pbTw9tUWFEEvXr/NzZm1QEv3GxvL7YsXYG+jiwvlIRRIPT09+rlaNBy5fXrHLuHEcgd6okdKv2L5VqhSnNQoJUVIG3b4NfPstv7azA/z8FDt/8AEL4HfeUQSWyIvq6MjzdXYGvvsOGDLEVKillhfVPL1VVqexehFENPyCBZb/aKizA+Sws0gieWXIleLz3LlzFpHsycnJmDRpEhYvXozSpUtj9OjRKefu3r2LhQsXaka/37hxA127dsXNmzdRvHhxNG3aNMvnL5FIbGfdunIoW5ZMEpBndUobkUQc4KVuLVEhxFJme2NFvwMHsrgrUYKPJySwMDMY+FjBgiw6a9Tg5zt32C5jx/IyPACMGcP93bzJojE4mD2gYoz69bndw4d8HcBL+rdvK3b+/XfO6XnoEItRnU4Rjt9/z/d9+DBnCwBMvZ2pCUpbkrvnJgIDOWG++h+N3OytlUheanKstlIqDB48mJydnal+/fr03nvvUdu2bakg/yam0qVL0+XLl03aX758mQCQo6Mj1apVi9577z169913qU6dOuTo6EgAyM/Pj06fPp1pc5TlNbWRpcy0kXbR5uTJRHJ0TKJTp0ztkpX1tBMSlNKRAFH79pZttEoy+vqalmTMCFr95svH8/D1NR3rwQP+zty/n5gy3wMH2C4AkZ0d0f37SjlLYS/1GB98wCUuRU32woX5ed8+His6WrFF+/amJSSt3bMoRRkSknZddtHWzy/zylNm5c+SLaU4cyvyd4w20i7ayPKaGrRq1QrNmzfH1atXsWXLFvz8888oWrQopk6disjISBQvXtykfYECBTBjxgy0bNkSDx48wM6dO7Fp0yZcunQJderUwbRp0/DHH3+gcuXKOXNDEonEAiIgNNQOLVtesfAqBQZyYvLMXO4W3Lxp2ufz55ZtzPf4ZZY3VqvfUqX4dUwMz0uMNWEC/3r29ORrACAqSpl7QAAwaZJSzlJ458aO5f2bnTrxUvujR+xhdXfnZ0ApsxkYyEvqAO/RVHt4rd2z8HYCae+DTC25e27kZfPWSiQvLTkme19ypOdTG/lfpjbSLpawV8lIERE/atrF3AuVWRw4oHg9AaLXXzc9HxXFnkJzr+uLemPV/T5+TBQfz8ePHlXm8vixMpaLi5HmzPmJEhMT6cABvr56daVt3brs1Rw6VPHOHTlCpNcT2dsTXbzIfa1ZQ1SgAJGDAx9v1IhowwY+l5yseD7nz7f0dvI8lHsWn4na05rdZPXPUlZ4a7MD+TtGG2kXbaTnUyKR/OcQpSwnTzbAxUW7WkxW1dO+ds30vdrzKfb49e9vucfvRbyx5v2uXs3etA8+4BKbol7GxYuc+uett4DevY1YsqQiiIAGDYAzZ9jzKTylp04BXboAc+dyFLq7O/DJJ+z1TE7m4CBh55kzOdrd15dLbr77Lvdx/75yLxMm8Lhqb6f5Pshx4/j8jh2v7j7Il81bK5G8jEjxaSNBQUEmj8jIyJyekkTy0iKWnzt2VFTc8eMsopJVWjSzg4+io1nQzpkDrFkD7N3LkcyCtCKyzSO4bcW8X7FsnS8fi5v8+fn9t9/y8vudO8CYMUbcuOGB9et1iItjAejqqiydJycDW7ZYjvHDD5xP88cfuW69iFhPTuaykuq5376tzKNsWeCLLyyjvsU9T5vGx1u1yr1R65lFYCBw5MirKa4lktxArkwyL5FIXm2WLGGxpPYq1azJzz4+QM+e/FpEVnfpApMk5hlBeB/v3AE2boRFInvhJZwxw/oeP7U39q23bNsLqNXvpUv8XKYMP69dC/zyCws/MY6nJ9C9ezQ+/bQ6Dh1i72/t2iz67t7l/m7f5pRLYWF8L199BVSvzvs3hb3KlAGGD+dzRDz3OnXYC+rgALRuzV7Tzp0VOwtv5759PI9p0/gz6d6dc3emZiOJRCJJC+n5tJFDhw6ZPCpVqpTTU5JIXlpEHkmt5WsRDANYzyOZkeTvaaVOMg8Gun+fk6Vv3mzaLr3eWK0E5cLzKcRn48ZKoBCg5PgMDr4BPz/C0qXswfz1V+DJE16uX72ac4W2asUi0sFBGePzz5Wxjh3j+XbqxHNPSOAk+z//DLz2GrB1K3uB1Xa25uHdtk0mW5dIJC+OFJ8SiSTbEeJm/XrLDXWNGyuvtZbBM5L8XXgfp08HfvqJE6qHhnLlnqVLuc2SJUqeS4AjybduBd5+27Qva1V9rGHeb2KiIj7VNS90OvZCAor4FBQsCLRsya+PH+dnsQd14EBlqV5UOfL05Pyd77zD0e5vvsn963Sc1xQA9u9XRPy0aaZ2No/6Hj6c94QWKSL3QUokkhdHik+JRJLtCHHz6ad2ePbMHgaDck6II7VgVC/xZiT5u9r7OHw4CygfHxagn37Kbcy9sdZEbWpVfbQw7zc6mvde5s3L1Y0AFopz5gDLlvF7IT4PHCiMW7d0uHABaNaMj02aBPzxB78WIr5RI6BAAQ4CEuPUqsXe21atOOAoPp7PiQT7+/dz+2vX2FM6bZqpnYWHt1Yttt2wYXIfpEQiyRyk+JRIJDlC585ct3zdunIppSYBFmWA9nK1WpDaWoozOhpYuJAFZ2Ii75cU/QNc3QewXGoOC+Nne3vAaFT6S2+ZSPN+T57kZ3VlpY0bgcGDlQAgT0++1xUrKmDyZAM8PDgqXvDTT0q76dOBEydY0J45Y1nOMiJC2SYQEcHVjgBejj96lO2hFv8CGfUtkUiyCik+JZL/EBnZK5lV6HTA7NkG7NxZHEePKsdv3LBeTzu9yd/NUxwJr5+LC6cvAngPpNFomdqpUCEeOzkZuHeP21rzxqaGeb/lygG9ewPt2iltXF352d6eRWa5cpxkvnDh+JSMABUrKu2Fx1TYoHx5DjQCOMWSOkG6p6cSwT54MHtBixVj2zx/zsLznXe4vbmIl1HfEokkK5DiUyL5j5CRvZJZTWAg0KLFFUyfboeiRfnYjz9q19NWezCFIBXeufnztQW1uZdS5PgsUoQFqGD1an5Wi1kHBxaggCJatbyxttC5M3tqy5YFvL15H2hIiHL+11/5uVkz9khOmQIsW6ZH27Z/pdyroyMv33frpuz/FDYYOpSj5StX5nmLpXIxz8BADi5KTgY6duTodjU9emRuSiuJRCJJDSk+JZL/CBnZK5kddOr0Jy5d0sHPj98fOWI9yCg9yd+1vJRCRPr7K2UlAd73GR+viNkFC4BRo4Bbt/h8at7Y9HDnDgs99Tyjo1k4AsqSOAD06mXEli2lTNqGhQErVrCHVCD2oPbty3O/f58Frnqe0dH8cHBge4iAJ0GhQqmLeIlEIslMpPiUSP4DZGSvZHbh6pqMyZMNOHOG32/ZYj3IKD3J37W8lGrPp6OjIs5KlLCs6vPtt/y+QQN+aHljbSUigmvKd+0KnD4NrFrFx4WoFkvwDx4o13z2mZJkPq2+hW2EEM+Xjz2d6jFCQnjJ/fPPgQ4dTD2/BQu+WAUniUQiSQ9SfEpeeXLTPsecIr17JbObYsWAZ8/4tY+P9SAjIUjv3+dUR48e8XutUpzmKY4A9mAC7PnU6RTv50cfmaZOCg/n9EUA8MYbwM6dGa/qo55/nTocGPTRRzxPIRyHDOG2f/7JOTjXr1cnmbez+k+Clm3MhbiWcN+3D6halV+rKyxltIKTRCKRpIcMic/Y2FisX78effr0QY0aNVCkSBG4u7ujSJEiqFGjBj7++GOsX78eseoQVokkB8iN+xyzm4zslcxu9u1TFGKrVqkHGQGce7NvX2DQIOWYuaDWSmQ/cCB7Vjt35vfffcfCcuVK09RJnp5KyqfExPQHGalRz1+kSCLiPkW/Yr8rAFy+rJQYDQ6+gTJlyOo/CVq2Mc/RKcYgUvJ1Fi3K5wH2koplfC0RL5FIJJkOpYPIyEj66KOPyNXVlfR6Pel0OqsPvV5Prq6u1KtXLzpz5kx6hsmV1K9f3+Th4eFBAQEBlJiYmNNTy1UkJibS5s2bc41d1qwh8vMjun6dyNeXaO3anJlHTtnFaCRq2JBo6FDt82FhRI0acbucQNhl4MBkYnlE9Nlnpm3c3Ym2bTM99uab3Hb2bNPjW7dyeyKiR49s+8zFdyQuzvR4hw48hr09UblyGbNRVBSRiwtRdDS/r1eP+yxRgp9r1uR+ExOJtmyhFBvMm6fY5tSpRJM+1H07O1seJ1I+dz8/5fM1/6zPnSNq04aoSxfta619Z3Ka3PY7Jrcg7aKNtIs29erVo/r16+fY+DZ5Pu/evYuPPvoIVatWxfLly+Hm5oZ33nkHX331Ff73v//h+PHjuHDhAo4dO4Zdu3Zh+vTpePvtt+Hm5oavv/4a1apVQ69evXBXJNiT5EpeteXp3LzPMbvIyF7JnODhQ8XVKbx+Ai0P5uPH/FyggHLMPPn71au8r3HwYOufeWqpkxISlPkkJqY/yMg8SMpg4P2eANdHF5H0gFJjXezDXLZMuV+xB1XtuRd9W9uDqpWj03wbQkAAe4HXrLG8Nj0VnCQSiSTd2KJQPT09SafTUevWrWnz5s2UlJRkk7JNSkqijRs30ltvvUU6nY68vLxeSCnnJurXr/9KeT61PCUZITf9l2nu6clJj05O2CU9nj9fX0vPnzWioohq1dL2uKUXYZdWrQwEEFWuTPTrr6ZttO7jtdfYQ/jTT8oxtQdTfNa+vkR58vB3gYho0SKi1auJ4uP5fbt27NW8etVybm+8oXgi3dzS/pkwt4u5R/XsWaWv5GTL+1qzhkiv5zb58hGtWpWU8p3RaqvlrU0NW73c0vP5ciLtoo20izY57fm0SXy+8cYbdPz48Rca6OjRo/TGG2+8UB+5iVdNfGbW8nRu+UE3X+4UREdbX6rMSnLCLlkhNjLrnxSBsEvduiw+f/hBu525QBaisE0bfm9NnF2/zkLO0ZEoMlIRdzdv8ndEp+P3O3ZYjtm6NS+5i7FiY63fh7ldYmMtf45WreJ+1L/vxX1dv07k7a2M9dVXRL6+RoqI+DHlO6Num5Gf0RfdhpBbyC2/Y3Ib0i7aSLtok9Pi06Zl9z179qC6KJ+RQWrWrIk9e/a8UB+SrOFVW57OSE7IVxHzZVajkZelx41TSkoC6VtmzapcoTExPElvb+3z6mAidSnIEyf4WR14Y/59nj2bl7X79FHKZPr48HfA15ffP39uOebWrRyZ7uXF70WkvBbmdunSxTIQSF1W0/y+2rY1va/331dKj5q3NU8gbyu2BBNlpIKTRCKRpBeZakmS69PwpJeXZZ9jVmO+V1KnA0aMAMaONU1mbr5X0hpZ+U+KmE9UlBIRLoiO5hRFQ4ZwkvfDh5Vz9vaWyd+1vs9VqiAlj6iXF/D99/wdKVOGj2mJT4G/Pz+LBPXmaNll507ep6neJ/r++1y56J13lGM6HefcPHHCtHymp6coPVoiZQ92ZtRaT+tnO6MVnCQSiSRd5JjP9SXnVVl2z+zl6Zxe4siqfY4vSm7Z8+nlxcu6588rx6wts5rvYcyKPbTCLkeOJFKzZjy3Dz9UzpsvZw8ZQlS3LlGRItzW29t0Dql9n+3slEhzYRcRNf/119bn2KIFt1m+3Ha7FCzIS/1RUanfv8HAe1KrVyf6+GMeJzxcsU2bNhepYUNDpmYjiI7WtlFq0fO5iZz+HZNbkXbRRtpFm5di2d0Wtm/fjqCgILi7u8PDwwONGjXC3r17M6t7SRbwKi5Pm3tukpKAL77g5VA1L7t31xbMl1mvXgVE6l0RLW5tmdU8P2pUVNbmCq1aValXnpSkHDdfzg4MBK5c4XKYAN+P8HKn9X0W/d+4oXxHRJJ5Lc9nu3ZA06Yc6Q5wZaDo6LTtAgB+fnxd27ap//wMHMifzdatvBUAUJLbA1x69MIFXaZ66TMSPS+RSCSZSaaIzw0bNqB169Y4ffo0AgICUKRIERw4cAAtWrTArl27MmMISRbwKi5Pm+9zXLWK72PSJNN2/5V0MmqRffu2clyIT2vLrGrRd/480LFj1v+T4uDAz0J8ai1nf/45MH48J0oHeA/nhAksnNP6Pr/+ujKOEIupic9ffgH27mWhVqUK78l877207RIRwTXcX38d+PtvYPlyts2PPwK//66kkrp+HVi0iK/381PEp7rEpig9mtl7sG2pgiSRSCRZRaaIz88//xxBQUG4evUqjh07hnPnzmH//v1wcnLC2LFjM2MISSZjS2DBy1jtxHyf46VL/KzOqQjYvs8xq8nq3KrCO7lggekYjx9b7pUUmIu+9u1ZqISFaY/xov+kPHjgjOnT9fj+e34vxKe1vchnz/JxQbNmtn2fheAmUioKpSY+xbGbN4G7d4Gff+b7bN/eul3U89i0CbCzY2/i7ducx7NuXSV/aLt2Ym8nvxd7UteuNZ1Hp06U6V56a1WQZJCRRCLJDmwSn7/++qvVcwkJCbh48SKGDh0Kb1WoanBwMJo1a4Yz4jeqJFeh5fG6fBn45BP+Yyt42ZanzYVQZCQ/V6pk2i43eHqyq/SnWGadOVM5Fh9vfZnVPHJ80yZ+/9VXfF5EjAte9J+UGzfcMWqUHfbv5/dJSamXBJ07FzhyRLk+Ls7y+0wETJ4MbN6stOvalZOqly+vfJ8//piDj9RBQOJ6IT4nTeL7W7qUx/j+exZs5nYh4mAuMY88eYCJE1ls9u3LbZydAVdXvr8TJ9hrq//3t3DPnvzcoIHpXLLKS/+i0fMSiUSSYWzaGKrXU//+/SlOIzrDYDCQo6MjLViwwOJcrVq1yMfH58V3puZCXvaAI62SheXLc8BD3bqmx9UlC9MiN2zuVgcTFS7M97RxoxJQY2tQUmaiZZfsLP356BFR3rxKHsneva0HGamDUUQwjQhG+fVXtmmvXqbXqYOP0pOEPjExkT755EjKvABO7p5aIFOlStxuwACi58/5mPn3ed8+pT/zYB1bvs/PninX161LNHIkkYMD31vDhhwgpLbLiRNEJUtyHtFTp0ztUrCg0pe/v2Ir0Yd6fhcu8NjCNps3b6aEhMQsS/oeHZ15BQOyi9zwOyY3Iu2ijbSLNjkdcGST+AwLCyN7e3sqXLgwbdq0yeL8m2++Sd7e3vT111/TuXPn6NixY/Txxx+TXq+n999/P7PnnCO8arXdtRKQqwWAIL0RzbnhB13MuX9/03tatYrP50Q9c3O7aCVFz+roexFN7eHBgshc7Gp91mpRFxZGVKaM5XdEsHUrV+9JTxL6xMRE6t//lMnnFBCQepLz1q25XY8eyjHzz/TIEaW/Bw9Sv0ctYmKU63/+WXn97BkLNVF/XYwdFMSiHSAaM8a0r3XrlOsrV7b9nw7xnVm5MilXJ33PbnLD75jciLSLNtIu2rwU4pOI6MSJE1StWjXS6/XUvn17unHjRsq5y5cvU7FixUiv16c8dDodlSlThm7evJklE89uXjXxqeX90xKf6a12klt+0KOjiZycTO/p889zLp2MuV1yovTnvHlsB2dnbWGo9Vmr5/noEacF0hKfYv6tWqXPm5uYmEgffhhNAFHt2pxmyMvL9LrERNO5BgXx+Hnzpu7N9vXldkeP8vuVK4n69SMqVEi57s8/iSIiiA4fNp3X9evKfa5erbz+6y8+X706z9Ng4LG9vFh4A5zSSRSEE3apUIHPlStn+z8diYmJtHbtj+Tra8xWL31uJ7f8jsltSLtoI+2izUsjPol4iX3GjBnk7u5OefLkoYULF6aci4+Pp0WLFlG/fv2of//+tGzZMnry5EmmTzi38LIvuxNZ/uErVoz/QH7wAb/PyPJ0bvlBj4piD59afHbqlDtqu+dU6c9p09gOPj6WY1j7rM2P9+ql2DM5WWm3Zg2LukKF0ufNTUxMpLffvkAA5/A0F+VxcdzH228r15Qrx+MXKMBe0p07tccTInXdOn6fPz+/nzRJ6Wv6dNPvvGDWLC696e7OfRYowO0OHODz167xEntIiCI+vby4VjxAFBjIWwKEoJ84UbFbgwa2/dORVXk+X3Zyy++Y3Ia0izbSLtrktPhMV7S7Xq9HWFgYoqOjUb9+ffTv3x9BQUH4448/4O7ujo8//hgLFizA/Pnz8dFHH8HV1TWrtqpKMgHzYKLixfn5rbf4+WWtdiICeXQ6fhQrxsePHMk9QUZZlbYotej5QYOA3bt5jGvXTM9Z+6zNg4k+/FA5J4KLRIR3tWoczJPeSlmPH3OOJW9vy1RZT55wvsxt25Qo+Lt3+TlPHq6GJILK1ONduKB87n/9xUFS9+/z+65dlbG1ot3j4rgS0Zo1nD2hXDm+L4Aj3gGuMtS3L2cLGD6cKyUVKcLR4gUKsP3Dw5Uo8idP+DoHB6BkScsgKvNsBAB/lrt2lcCsWYYMVTOSSCSSXMuLKNeIiAgqVKgQOTk50ZgxYyghISGzRHGu51XwfBKZVjuJjWWPTnx8xpenc8N/meo9dV5eigdUp+NzOYGt+/deJBjKvBqQlrdsyhS2RbdupsfF3k4RLHTqFFHHjkQLF/I+R7V3bvVq04CdsDCiGjUy5s1NTEykunVvEMBz69KF+xJzNxiU5ezz53kJXngQhTdy1CjT8cTeS/Ho2ZPo4EHlvQhSIiJatoyPvfWW6f0I+wm7dOmiXC8CikR1Ir2eqG1bPufgwJWQxPxEP7//TjRzJtH48drBTlrbMIKDDdS27cWX/ndMZpMbfsfkRqRdtJF20eal8nya06lTJ5w/fx5du3bFhAkTUKVKFRw8eDCzdLEkG1BXO3Fx4aTYu3e/vNVOzHNUzpuneLWIuGJNTvH0qT1GjLAzyae4dSvbW2DuaUxPHlDzakBaeTfd3flZ5LwUiPyoAwZw6qeePYH16zmpu6Oj4p2LjuaUQyI/anQ0nwPS581V39cHH5zDzp3J8PPjHJenTilz1+uVnJ7nzwPPngGtWrH38OlTPi6qNgE8hvBmAlw5yd9fycWZJw/g5KScd3HhZ7XnU+19FXapUoXPOTnx/MTcJk5kr6r4tVevntL27l0lVVTt2sDgwZy0Xiu3rFbS90uXdOjU6U/LxhKJRPKyY6tKffToEc2YMYPeeecdat68OfXs2ZO2bNmScv6XX36h8uXLk16vpz59+lBsbGyWqOXcwqvi+SRSvG3CYwNkPPI6p//LFB6khATek2g0sidNr+f7+vbbnEkto7V/Ly5Osbf6x0V4MMPCbI8ctyV6fulSxSvYvLnl9WLf4vXr7J0DiDp3VtqEhXE6Ll9fbm8eZGSrN1ftoW3Y0ECbNvH35ddfecz8+ZW5nzyp2OjLL037e/99Pi4Saoh+PT35eLVqii3y5eNjpUubzu2HH/h4UJDpfVavzjbq14/HWrmSaPduonv3iH78kT2dX37J41Wpwl51gGjJEv4sS5bkuvFq0greE5+ZCNZatSpJemw0yOnfMbkVaRdtpF20yWnPp03iUx3NrtPpUh7mqZQSEhIoPDycnJycyNfXl7777rssm3hO8yqJTyL+wyeWNwGi2bMz1k9O/qCrA3kiIohcXYk++ojf29tzUEnNmranAcpMEhMTydk5iTZtSko5lpSk2HvXLtP2W7dytL6tkeO2RM937KiMZ/47Ry0+4+KISpRQ2n77Lbe5dk0RWQDRhAmWQUbWUIth01RDRgoLO0aJiYl07Bj3W7iwMvdt25TxxFYBca9Ll5oumYt+O3dWovqF7UJDtXPYbt/Ox6tXN7WFtzcfr1nTUsgvXsznqlbl8f74Q5nj5s3aInPbNhbA33xj3Ubm2yYSEuQfTS2kmNBG2kUbaRdtclp82rTsHhYWhqtXr2L06NG4fv06nj17hhMnTiA4OBgRERHY/G8ZEUdHR4wdOxanT59G6dKl0bFjR7Rp0yYrHbeSTKJzZ17SFNSvn3NzyQjmgTyRkbwsa2fH7wcN4ooyN26kviydlTRrdgWzZulTlp/t7ZXgl0OHlKXo6GgOeLG3N61rbq2CUGrVgObPV5bsRdALYNnPuHFA5cr8+PRTrnYliInh55kzOShIMGOGZZARwMvjiYmm/YtgoFGjTLdFhIQYMHNmNXz2mS4loCg5WVnmF+VRRb9RUUpJUC8vPh4ba7rd4u+/lX5q1uRl+1Kl+Fj+/Kbz0go48vQEPviAXzs4WAZOFS7Mz1FRSuUjUaVo9WrtUpXvvccBT9WqwSriM/P3tyx5KpFIJK8UtihUT09PatKkicXxq1evkk6no0GDBmlet3jxYsqbN++LyeNcyqvm+TQYTIM0du/OWD859V+mubepVSu+j/nz+b06NY5on9VJ3dVYy9m4ZAnPMzhY8XoFBLAX2paUPGnlB1V7RBs3Vj7fkiWVNmqPcXQ0kaOj6XdhyBAlAE0deFO2rGVloeRknruTk5ITU7B1KwfkiPkYjURBQYaU/kRQkLe3MvfXXlPG8/AgKlWK+wgJIdqzh49XrKjcZ3KysmWgQgWeh6Mj23nbNqJDh0zndOsWeyN//NH0+IoV3EexYvxeHZh36pQSXBQZyXZR26tmTc4funUrP585o5xLT9pj6bHRRtpFG2kXbaRdtHkpPJ9EBJ3Gv+HiGFnJC9OnTx+cP3/+BaSxJLtQe34A4MGDnJlHRlB7vYS3SaTfqVyZn7/6Cihdmr2d8fE5U7Pe1TUZkycbUjyYV64A+/bxud9+42Chn35iD19CAnszU/NkAmnXqFcHsqg9nyLgyNxjHBioeAkFP/ygBKC5uSnHW7dWAnLEr4CzZ3kcBwcl1ZEY54sv+Fl49Xju4vcKYcsWfiU8oOHhwM2bSh9vvgncuaOcDwri9ytWKJ7fq1f53hwcgG+/5baJiezJHT9e8ZYKChUCunfnvtUkJPDz9et8T+rAvEePlHmGhADduvF7nQ4oWJBfT5gAtGnDdeD79VP69fGBRCKR/OexSXw2atQI+/btw4QJE3D79m0kJibizJkz6NatG3Q6HRo1amT12gIFCmTWXCVZiFqYAEpOxJcB8xyVDx+yaACAihWVZekLF/jc2LHWxVxW06kTpYjeixeVpf+kJBZyS5ZwBLaTE1C0qOm15pHjWqLbHPPoeYCvEUJPS7yWLs3PIu/rnTss5sPDTbdmuLpaRmkfOcLPNWvylgfB2rXcR79+fB9i7kOGGADwFoPZsxVbiLl36MCvmzYFfvkFCAhQ+nR25mX0sDBFPDs785xCQjjqvGpVbrtqFX8nbM2hKu6zVCnlGnGv/fopy+x//skZAb7+mkX4hQs8jrD1vn3K1gFPT84cIJFIJP95bHGPXrp0iYoUKZISZKQuodlZHQ77CvOqldc05/Jl06XDsWMz1k9OLHGYL/2eO6cs34pl6cGDlXtzc1PaZledd7VdxBLunDmWy9sODpwfsn597aV0deS4rXMXNhClMUUpydRyii5ZoixfOzoqgUjt2yvzHTyY265ZwxHq1aubnh85UhnHy8u0HKaY+88/JxFAVLy4kRwcOBp9/HhlHuqSoA0bcnUmseRvNKYdQT5jhjKfWbMsa9o/fcrfnY0bTa+bPJmv6dLF1Eb9+/P2DVG6U+vnZM0axdZOTlwy1Hyrgy3I5UJtpF20kXbRRtpFm5di2b1UqVK4cOECZs6ciffffx8tWrRA3759sWvXLqxduzar9bEkG1B7PufP5yXVlwXzpd+HD/nZy0vx7I0fz4EcAC+HCsw9d9mBWMJduFA5NmYMcOAAe8ZmzQIWL9b2yqo9mebVgKyh03G7uDh+L5bOU6tg1auXEpzj7Q1UqsTt1Z5P0V+nTry0ff488L//KedF4M+oURz8NW8ee2ijozloaM4c5bPKl48wYQJ7CZs1U/oQXlAXF6B6dSX46d49YNkyoHdvoEQJ6/cuvLcAEBrKS+xqL3BsLH/X333X9DoRMJUnj2LvGzeAjRvZZg8esPezZk3LMTt3VrzWDg5K3k/zYCeJRCL5z5Jjsvcl51ULODpyhL0zRYu+WD858V+muQfv9GlOv/PBB6bHRfDKokWm11sLPhLVfjIjJ6i5XR49UvJRliyppLpSBxmFhXHwysiRRDExSl/Ck1m9uqnnc/t2ooEDuQKRGtG+f3/2cC9axF5Ac4+xORMnssfxo484eMbdneiLLxRP4jvvcDvh+TQPvGnShG1oZ8f3IYKMKlXi840bEy1YwJ7PZs04/6m/P1GRIso9JScTPX6sVGYSjzFj2F4i9dOVK9x+3z5+La7v2dP0uhMnTAO0YmKUc+ZfWYOBj5mnQIqK4tyxUVHcLjqaA/T++Ue5duNG7jNPHqWKknnez7SQHhttpF20kXbRRtpFm5z2fErxmUFeNfGZkMB/tC9derF+cjLa3VxAqpelHz3ivJ8A0WefmV6rFTFuS6nK9KBll6Agnk/Lljx3Z2dTMfjokSKMevc27W/rVhZfanHt76+0V2O+NC1Eb48elvfWvDlHiaujws3tEx9PdPcul6lUC/933zUVehUr8nUODsp9rVmjlDtVP957z0AGAy+T63SWArpTJ9P2f/zBolZE5p85w0LR3p7f//OPEsWvvu7aNdOSn0+fKudSy3wQHW39H5EhQ/j6YcOUY2pRe+wYi/3vv7fevxbyj6Y20i7aSLtoI+2iTU6LT5uW3Z+p19pegMzqR2I7tpZndHTk6OT8+TmwQ0RhvyxoRa+rl6XHjQNE7Jt5JL9Yll68WDlmS6nKFyEuDjhzhl//8gsv09arB3z2mbJ9wNOTc2gCpnk5iXibQd++psFEWsvvWkFJosRmjx6W9xYdzQ8HB+WYeVCSuzt/T5ycTJfuP/+cx/D05HbXrvF1H3/M8330iOdSo4bS9+rVyRg37jCGDjUgMZHvhYjbiXuOjlYCpAC2SaFCnItTLI8/esTZA5KTORCKc4hyIFKdOsq1+fObBm6pA4DMMz6oCQzkYCqtcrN37vCziHQHeMuH2N7g6cmlNd95x3r/EolE8l/C5j2fixYtgsFgyNAgycnJmD9/PkqZ53BJhWvXriEkJASlSpWCk5MT8uXLh+bNm2P79u0WbY1GI3799VeMGTMGQUFB8PHxgYODA/Lly4emTZtizZo1VtNBvcqINDrpifI9exZo1Aj46KMsn16mIqLXFyzg5N+AshdUJCYXez3NE6ALMSdqbpvXh08twXtGGTdOSdju4cFR2fv2cbS0Wgy2a8fPf6pKfKvFoFp06zV+moU4fOstFlzDh7M4E6jvLTkZuHWLjxcpws/m4lX9K8A8uX3FisCiRYpwjY0Fpk3j+ud//gl06cJzsbfn8/PmAe+9R6hc+T6qVuW0RIKSJXnuERHAG28ATZoo/zx8+y2LuzlzlHt++JBtAgBlynBdemEjETHv4aHUdRd7fTdsUASoWnzOnMmJ4XfssLQpABw/DrRty/8AaIlPnY737q5dq8xbIpFIJP9ii3u0evXqpNPpyN/fn0aPHk0XLlywya16/vx5GjFiBBUuXJh0Oh3VqFHDpuuOHj1K3t7eBIB8fX2pbdu2FBQURA4ODgSAxowZY9L+4sWLBIAAkLe3NzVr1ow6duxINWvWTDn+1ltvUUJCgk3j20JOLrvbuhfRtIxh6iUQf/uNl1VFZK6HR8bmltNLHGFhvGfQyYloxAi+74AAvrd9+4iGDycyr/pqvixtS6nK9GJuF3d3TmT+229EFy8S7dzJdvfzM90+MHUqH7e35/daEeoiet7Pz3TZXSSGj47m74Dop1o1fr1jh+m9/fOPkjzdYOC5eXsrWQOIlDHq1ePXWknvGzRQ5vHggWJjnY5o/XquDw8Q/fSTYpf79xPJ11fZw/nNN2yjFi2UTAANG/JrUe6TiD9bgKhXL6KZM/l127aKjR49UiLkS5UynavYqiG2Iah/rXXowMfmzdP+PH/5hc+XKcPbFADrhRl+/53o11+JHj7UPm+NnP5Zyq1Iu2gj7aKNtIs2Ob3sbpP4NBqNtGTJEipQoEBKuqWiRYtSx44daezYsTR37lxauXIlzZ07l8aOHUvvvfceFSlSJCUdU4ECBWjp0qVktGHj3LNnz6hIkSIEgDp27EhPnz5NOXf06FHy8fEhALRb9Zv+0qVL1LhxY9q5cyclJyeb9Ld//35yc3MjADRu3Dhb7ZImOSU+bd2LaC5S0qroI1LaqKvgZESr5/QPunpv54QJSmqcGzest1fbSV3tR416n2BGMLeLucD980+es7u7Igbj4xVxVaIEaV4nCAszDfhJTjYVzKJ/T0+upgQQbdig3JuLC9GqVfRv2iM+vnIlvxdVfog4XZIYQ6dTvk/37hFFRHBAU3Q0i387O0W8iWAif39lH+bFi4pdQkOTqVEjZQ9n7dpcxUh8lmPGEPXpw69HjVLmI1I7OTpyYBTA/5gJG4WFKeIwMNDUZuJnSYwRGamce/NNPrZsmfbnefEin3d15ZrtYt+pFhUr8vk5c7TPWyOnf5ZyK9Iu2ki7aCPtos1LIT4Fz549oyVLllClSpVIp9NZ5P1U5//U6XRUuXJlWrp0qYmATIu1a9cSAPLy8qKHGq6C2bNnEwAKCgqyuc/x48cTACpl7vp4AXJKfNrqzUyv90542D74gMUakHYpQC0PbG74Qa9ZUxGfhQopnk8t1HZKT6nK9KIV7a7+/B4/VkTd77+zQNuyRTlWu7apJ9OcR49Y7In2y5aZenNFSUhfX6X06Ndfm96byAYgIu6rV+f3/v5KO/OIdvG/3nff8fsqVZS25v/w/P47txk6lGjXLv7nJjExkWbP/omcnY0UHa0EIxUsyOJT5NOcOFHxRqrXa0Q0u07HnzWgBG4Je0VEaAdtEXHglrMz2+v+feV4kyZ8zZo12p+nOlBJPG7fNm1z44bpZ1i1avq+O7nhZyk3Iu2ijbSLNtIu2rxU4lPN5cuX6euvv6aQkBB69913qVmzZvTee+9RSEgILV++nC5fvpyhfocMGUIANGvJExGdPXuWAJBOp6Nbt27Z1OePP/5IAMjR0TFDc9IiJ8Snrd7MjHjvxHJ7v37KMqVIJaOFNQ9sbvhBF97bvHmV1DguLkRHjxL9/TdHPBNZirm0EpanlpRdja2ifNAg9kT+/ju/F17Fs2dNPXYAL1WntfQvPjch3tTzPHxYWXp+7z1+PXu26b2J5ecuXdgWBQrwe1Fr3WCwFFzi/8Phw/n9xx8rfWqJ+ZYt2Uv56BG/T0hIpMDAezRkSLKJDaZNYy+w+CynTeM67G+9xSmlBPfuEd25Q9S6tTKnTp34cw8OVsa+fl0RyqnNT1CvHvdlnnxejbkX2Lz/pUtNbZU/f9rfHTW54WcpNyLtoo20izbSLtrktPi0KeBIi+LFi6Nnz56YO3cuNmzYgP/9739Yv3495s6dix49eqC4OrtzOnj8b9FpHytFkPPlywcAICKcPHnSpj4v/huJ4Ovrm6E55RbMk4JrRXiLICNRblCNeXlGNSLJvJsb8K+JU63vntXR4C9CbCw/58/PQS0VKnBS927dOJClWzfFTgMGmJZ7TG+pSnPSE+R14QKPK6LIRRL8a9f4mAigAXjOqdVwB4Dt2zmYyM2NS2Sqk8eLz9fVlYOOdu5UgpnEvb3zDgcD+fmxLUaP5nNPn/KzVjS4SDT/11/8rP7OWcsiAHDwEQCsW6fDrVtu+OwzIwClpnrTphwwFh3N7x0dOcJ92zagVSulv3z5+HOOieFgonbtgMmTgdOnlZKgAAeOqct9irlYs6m4V2dny3MCPz9+dnHhMpzmAV8ioEwwfnzmB65JJBLJy0iGxWdWIWrB/y3Ko5ihPn758uU0+3v69CnmzJkDAHjnJc51Yh5ZDGjXJ0/tDypgvaKPWpwI3W+tvntWRIPbmhLKFoT4/OYbRQyFhwO3b/PrxERLO5kL+2fPuHrOjz+a9q0l+NWkR5SLzGM//8z3LcTn9evA1atKdZ/27TmyOzVhDLD9jh7le1682DT1khCQbm6c6qhFC8va8V9/DdSvzxHaals8fw4YjabVjUTE+qNH/Cyi5MX/d5MmsZ2GDFGyCADAiRNAw4YslPftA0aMsEP37mdTKh8lJnIKqHz5+LMR4ja1mugREcDly/xzcOSIMrfUUH+HL13iykziHgDlXl1crPchxOaECfzzY/5Zb91q2vajj1L/7kgkEsl/BRt+TWcvjRs3xsSJE3HixAmcOnUKVatWNTm/aNGilNdx4i9TKvTv3x+XL1+Gn58fRo0aZdMcgoKC0mwTGRkJf39/JAmFkIUQAQMG2KFvX0LZskaoh0xMBPLksUf37oSdOw0YNsweU6YY4OxM0JqaiwswebIOQ4faoXnz5BQx8/ixHQA9nJ0N6N+f0KmTDoGBRs0+wsP1KFtWh3feMSApiVPZLF5sh/BwwoQJfEF67CLu7/p1HQYMIOzebUizZGRqPHxoD0AHN7ckk/KM3brpMWuWHeLijBg2TGdipyVL7PHttwYkJ7Orct48PZYts8OyZUBioum9DB6sw4cf2uHLL5NNjrOgYfsXKEAmdnZ2trTLkyds8xYtjBgwAJg0yYhPPgHKlSN06mSHSpWA06f12L2bUL06pdg7NcqWBQ4dwr9jqeemA2APFxcjkpKsp0ybNQvo08cOM2ca/hV8Dv9en/SvEHSAvT3969HVISYmGUlJhFu32OYFCvD7Bw/0uHjRDm5uhFGjklPmsm2bHnv22MHdndCyJVC7thENGtxAYuJrGDDADgMHEqZMMabMp1w5O5w5o0dyMvdrzsGDwEcf2cPVFahWLRllytihVi0dKlXituHhpv0J1N/hpk3tcOCAHmvWJOPdd/m658/5fuzttceNiwMuXbKHoyNgb2/E5Mlk8jMVHQ1s2MB9AICjI4EoGbNmAXXr2uODD5I1c4aqEd+V7Pgd8zIh7aKNtIs20i7aEBF0L/KH9gXJleIzODgYBw4cQJs2bbBgwQIEBwfjwYMHWLBgAVatWgUHBwckJSVBr5XYUMX48eOxcuVKODs7Y8OGDVaX8l+EPXv2ZHqf5vzyS2FERweiX7992LFDETxEwGef1UdiojtOn3ZA8+YP4ONjBw+PX1PyE27eXAr79hXFF18chpcXJ7j09AS8veujZ89Y9OjBrsa//qoBoDCuXDmL1167DHd39typ80sCwD//eGDBgmBMn/4Ldu5UXJ0dOnhg2LCGKFHidxQtmj67iPubNu0Ahg1riJEjoxEcfCNjxgJQpkwtxMc74vTpo7hyRUnq6emZH0A9nD0LBATcN7FT48aB+PzzPAB+hU4HGI15AQTD0zMBO3bsSumDCPj88/po0iQWO3aYummXLw+Ej0+elH617Ky2y507rwPwRIUKR7FwYRX88APf97RpbI8yZR4C8ENiogF58lzBd99dgLu79i/QZ8/ssHdvMRABtWvfhptbItzdle+Kk5MdFi1ygl5PWLLEDn/+6Y18+Z6hcuV7Fn2NHg388w97E/PlawonJwO2bz+ApCQ71KhRBQBw9aoH7t51w44dJ/Dw4W3cuPEWADucP/8zHj58ips3ywIIQNGiMTh48FBK30eP8vfs9df/wo4dJVGy5HnodMDnn5/T/I5/+qk9xo2rg//9LxZFikRbzHXChFp4/twXz58T2rd/il69InHrVgV06HAKADBsWDBKlDiIokWV7yp/hxti+vT92LkzHo8f1wFQEEePRsLN7RoAYPp0HRIT7XD3rgE7dliKz+XLA1GypBf69IlETIwznJ0fw9u7Gnr2jEX37mfx2Wf10axZLLZsKQ0AeP5chx3/ftmaNQtE1655MH78rzb9k5Udv2NeRqRdtJF20UbaxZTY2Fh4m+8Nyk5ybLdpKty5c4fq169PACweoaGhVKNGDQJAS5YssdrHjBkzCAA5OTnRzp07M32OIuDoyZMnlJiYmGUPzn9opFWrkizOrVyZRH5+Rrp8OZG8vIwEGGntWtN2Ithh0KBkk+MbNyaRu7sx5f3Vq4l08mQi3bhhfS4JCYkUHGygIUOSNc+HhiZTcHAybdq02cIuJ08mUs2aBjp1KvX7W7kyiXx9jfTgQebbcs+epH+joY1pzuP0abadj4/RpJ2wufn8Tp5MJBcXy35PnUokZ2cjHTv2lDZvNrVL8eJGAogOHUpKue/Ll5V5BAUZTAJWTpywfm/nzyeatF282PL7Ih6zZycTQPTOO4aUY48fJ1LevEYKDDTS/ftp2/LvvxOpTh0DDR6cTHfuKGPHxfH5pk157s2aGUyuq1mTj3/3Hd9zoUIG+vrrXVSokIFWrUqiq1f5XmJjTW2oZduTJxPJzs5oct/t25uOFxqaTA0bGighwfp3uE0bntOCBdZtZu2zDg1lW4aFJad81pMmKd8RDw+jha1T+5lWP548eWLxnZEPaRdpF2mXzHjUrVv35Yx2z2qMRiPt3r2bRowYQb1796bPPvuMjh07RkREvr6+BIB+++03zWvnzJmTEt3+448/Zsn8sjLaXR0tbS29j3nk9erVnCKpcGHTtuKP8rp1yrG0UgrduUO0fDnnRVRHbNsWDW6ksLBjJnZJLTdpViR0t8avv7ItSpbUPq/OHnDjBre1s1PmZi3a3ZYUTQ0bGmjTJtOISxFNHhnJfdSrR5QnD1Hp0vw+KopTAYn0Q/v3W7+306dNI6u/+sp62xUruE3Llsqxv//mY05OtqcDEvlBjx3j75fI6RkVpeTrrF7d9JqCBYWQ5nGCgw3k7f2UGjY0kNHIqZoATsVkbkPz70n9+pa12/PmNf1+amWIMP8Oi7rxs2alfc/mn/X77yvR+EREAwbwvYsUTSJJvnm+0LTy7hLJKF1rSLtoI+2ijbSLNjkd7Z5rxac1Ll26RADIx8dHs2LRvHnzUoTntm3bsmweWSU+zYWauzvnLDRH64+xSEiuFkfe3kr6HkFaInLxYiVfohjD/I+4wcAC4d4902tXrkyivHmf0YMHil2s5SbNioTuqQmn48ct81aaXyuERdOmiqCJj+fz1v4RyKgod3fn/i9d4vciJ6R5dak6dfj4pk3W7+3gQVMRNnas6fkffyT69FOuavT990o+T4Go2JPeVLjW/nno3Jn7K1pUafvsmTI/8b05dSqRypSJoVOn2C4iR6v4zo8fz4UCjh61FJFubkQ1apjed/Xqlv8ECKFnLTdu9+587eTJ/N5g4Pn36KF89uq+xGd97Zoy7qpVfD4kxFR87trFeUavXDHtx5Z/suQfTW2kXbSRdtFG2kUbKT7TSd++fQkAjRw50uLcwoULs0V4EmWd+DQXaq1aWQoekZ/yk0+UY0Yj/yHW6zmfYFwcH7O35z+O169zO2veu+nTWbBcvUoUGqr8IRdtzUWGSNwtKu8IeEkykbp2TaaoKO5Dnd9QCIFHj7Imofv+/WwbrRoE16+zkPnsM+vXC2+eOmH7tWvWE7zbmvtTS5T/+ivRnj2csJyIPzNzwUvEHkqAvdHW2LHDVIQNGWJ6fsgQPv7ppyyIANOE8JMn87GaNU2v69CB840eO8b5NZ2c+HPZsoW9fKtWaXsWhSfWxUXpa/t2S++q+R8G8/yaItfp3r2mIjJfPhZ5hw6Z3vfRo5afU1pVwfr2NRXsT55ofw7mn/Xt20o7kXvU3Z2/02l5NYnYq+3ubv28/KOpjbSLNtIu2ki7aJPT4jPXpVoCgHPnzllEsicnJ2PSpElYvHgxSpcujdEiCeG/LF26FP3794ejoyN++OEHvPXWW9k55UxBK4XRiRPA+fNKGpfYWE6H8/w5MHUqcO4cH4+IAG7e5HyWiYnA2LGcLib539iNP/7gZ/OUQoI5c/iaixeBb7/lY48f8xwGDeIo6A4dlPQ9IjWTOtsVERAaagc7O8KaNXqEhPDck5KAjh25jUhV1LlzxlJCpUVsLNsmOdnyXOHCnI5n/Hjr1wcGAu+/DxhUAeEPH5rmBFVjbs/kZE69c/iwabtOnQh+fo8xYYLyI1e3LvDGG0o6Hw8PDlICgJMngRkzgB9+APLmVeZhDfM0V+aJIESqJVdXwN2dX/+bUhdESi7Oq1dNc5NevMiR2zEx3EdCAt/j77+zLY8fV2xz6JDy/S1RglNHlS/P1xABItmEeb5NNQ4cXJ8SHZ/4b7yYo6Py3alZk8+HhHB6KYGjI58zz2UrUpL5+5umKhOIXJ4it6c6n6k6z6f5Z50/v3JOfIZ9+vDPbJkyqadUIuLPV52GSiKRSP4r5ErxuWTJEhQsWBBBQUHo2LEj2rVrB39/f4wePRqlSpXCnj174ObmltL+9OnT+Pjjj0FEKFmyJL7//nt0795d85Gb0UoiX748UK2akkdz1SpTYTFliqlonTSJ/4DPmwccO6a0W7yYRcSCBdp/gIWYXLWKE7EDnOezUyf+Q29nB3z2Ged7BFiICoQoiogALl3Swc/vMRwcgFOnWMTZ2wPr13MbnY7nvGMHEBr6YgndtRBz8fKy/Rpz1MnXN2/m3JHWhPKSJTxHYc+VK4HPPwfMs3XpdEDbtpewdGnqP3Ii1+eePfyZjhqlJCuPibF+XVriU11EwFx8RkQAd+8q7dSC39WVn58+VXJfuroqIjkujq99+BBo2VL5/np6crL8kyc5+XtEBHDvHuf2dHW1/k9FauJTiEgXF+5z7FjTnJ4FC/Kz1j8ugYH8OWqlN2rXjv+5at2a34v7tLc37d/8s9brgU8/5euCg03HrlnTNLm+OWnl45VIJJJXmVwpPlu1aoXmzZvj6tWr2LJlC37++WcULVoUU6dORWRkpEX1pNjYWNC/bo7z589j5cqVVh+5ldSSyP/0E3vtRo1ir5qatWv5D6L6j/7s2fxHfORI9hQBqXvvAMUztn49e1TFNWvX8h96nY6FxuDBfC5PHqBIEX599qwigNu0MeLePRc4ObGQ6d2b56MWkRs2sMjavl3xTn3//f/bO/PwmK43jn8ne4QsErEkiKVC7UKpvRSNWmqraqmlLVX8qKW1tEVbWi1aqmpXWqpVW9VSexGKEEuofVeUhIQkZJnz++PtmXtn5k4yM5kkk3g/z5Nn5t577r3nnnsm93vfc973pcDnd1SRf7IK6K6FDDAvrYVq9Ho6/o0sojjdvk2fnp4UkP2jjywHeO/fnyxY8joyLITQFAJYt64i3nqL1HtiIrXLokXG5aT4PHiQPkuWzFnLp7xv4eG0rls343ulJT69vY3FpwzeX7So9ouN+uXouefM+4MaKT6l6FSLT4D6XEoKiUV5P3r2pM/WrenT1heXZs2oXzdsSMuWshuZ3muAsin99ptizfX1Bb78EvjmGwqWr4U12bQYhmEKMjkmPlu1aoXy5cujQoUKNu/bunVrrF27FlevXsWjR4+QkJCAgwcPYtSoUfDWSDnSvHlzCJq/muWfM5JVSsxBg+iBPmcO8F8CKJQqBbRsSUOgixcbP/R79ABq1aL0gh070rqLFy1bWtTZa/r2VR7Cej09JL/+mupXogRZTv/5h9IpSsvZiRMkECtWBNaudUH58gkoVUoYHsimInLePHqInz2rWKe6daMsM6NHK/XSSs+YFVJ8alk+792j9gsNtSwSAWUqQdGiwDPPGFujTTMxmVrZOnVSjqOOaWyaRvLWLbL8Dh9ufG4p6KXVulQpoFcvYNs2uheW6NyZxPx33wFvvw106GC8XZ3hqGRJesn4+WfF2t6oEVC9Ol2n+l5J8ZmSohzD25tePgASUjIz0BdfmPff2Fg6fmho5mlhJZlZPgHtaSNjx1J2ptdfV9bZ8+IisZTdyN6pIKZYmvrCMAzzxJBTk0krV64sdDqdcHFxyalT5CnWOBypQyZlhnXe0uQEU748OThUrKg4cGg5Lfz2Gzl2BAUpIYMsOcU8eKA4Tty8SetkeJ/69RVv9+LFhShUiJyIpAMLIMTLL5NjyeuvC1G3boZwd08TQUF68cUXivOH2oNdOhP9+KPimCGPpfbAtifs0v/+R8fR8EczOo908tHi1VeVUEQVKijOL5YcV9RhczIyFCeva9dou5a3+5EjVKZUKeNzjx9v7EDz+uvWX3tmNGlCx1u5UllnTbSBl1+m/WbOFGLyZPrerx/1L4D6d8WK9P3PP42PM3Qo9UHpyDRtmhCffkre/fIcMTHGzgBz5pBT2J49dAzZD8+epWVL0R+0yMqhR3LrFjkuHT9OywcP0jlLlzYvm1WIJPlb/eIL7ba15LimBTtKaMPtog23izbcLtoUWIejzz77DIsXL8Yi03HFJwRpzbx+3dj5wRTTITghyKr2+LFSRg4jenqSQwhAVpmzZ+m7qRVPOjP066dYSnU6y5YWOcwMKOUHDSIr1LRptK+vLzB9OlmgDh82zsG+eTPw8stkSRMCKFPmAapWFRg5UnH+ePpp5ftHH5EFSadTrFPSkqaeY2fPvLjMht09PZXv6vY1JSODrnP/frLwymu1lLddbWV7+FBpQ2kRnDgRqFRJoEkTZbxfPQyuplcvYPduxXIbFWW579iC2vIJZG1tl/dKWv+Sk40tn+phd9O87pKDB6mdGzSg38GXX9K84WvXlHMMG+ZqdH0DBtBUEzln1tTyqTX0rYUtDj3r1tH5PviAluWwu1Ze96wsqtKqOXIkOf+pf/uyzS1NfWEYhnliyDPZm89o1KiR0V+RIkUytXxaim1pimlIIWlReuUV43IyqLa7O22vXVsJ2O3rK0Ramvm5Z882tqKlp2vX4Y03lLie8lxaFke5PjhYqYeLC52/cGGyrpUqpRdeXmlizRqq0O7dQvj70/Xfv09tMWUKWXCLFaPg5IULC7FkCR3v+efpXNaGMDLlk08ozNKvv5pv0+uVtrh9W3t/aa0+flwJOTVihHawcrUFTIZoql1bOcfatYqla+VK43iWW7ZQmRo1zOuwbJkSpN3fn+Kuzp1LVkFL/PEHhWI6fVqIuDjzuJKXL1P4o/v3afndd+nYV69qh7OS19uuHSUu+PprIebPp/s/c6YQMTFKTFJLYYmk1XPYMLJyy3IXLqjPYR7/VM21a1Re9m9r+0VWowlqZN9r3ZqW09OFuHfPPIatRN7rrKya1gS4zwy22GjD7aINt4s23C7a5LXlk8WnldgiPrMSKmpMhxGXL1ce0qb89psypOvuTqJVLTpNz/3118biMy5O+9oKFyZBcfCgUl/5kExPNx5O/e03GnqXx/Tzo7I6HQmmpUvTRIcO50SzZhnizh0hwsKU+oaECNGxI5UrUYL2DQ0lcbdjB5WrVInOY2+cz6yQovnqVfNtpsPqn3xCZd94w7pMTMOHk/iQbbN6NZUZPtw8k8/atVSmQQPjOsj7V6oUbR87lkQ6QFMoLNGhA5X5+GPl/BkZ2mUTEuilASBBumMH3Yv27Y3LZdZvHz0S4tw5Jbi9aWD8QYOUWKn9+hnHxFTnhjCNf/rwIZXNTKBZO/Rt7YvLzz9TvZo2ta68ENZn5soqwH1m8ENTG24XbbhdtOF20SavxadTers7I3v37jX6q1GjhsWyWiGTLA3VmQ4jtm+veM5eu6aUk8OIgwcDtWvTsPKsWcbD1KbnVns8L1li7r2rrsPq1eTZrZ4G4O1NThzNm9OQs6zDwIGKY4ynJw27PvccLW/Z4oI9e0KwZ48OZcoAly9TzMcyZcjL/MQJKtehAzk0Xb9OTjo6HTkdvf125iGhTDF1AMoKOfQuh3PVmA6rX7hA669csRyJ4NtvjZ2P5HD++fPkuHLuHE05OH9ehy+/3I2zZ3VYscI49JGa8ePJG71GDZrGMHw4IH327t2zPNwsvbqltzygOISZMnGi0g4PHtA9SEhQhtUlmfVbT09yMKteneo5c6ayLTaWnMRkH7lzhyI2SM6dU76bxj8dOZIc26ZP1657VvWS12eLQ48cXlfH98wKU+cjS1NEZF1NHdcYhmGeaOxRrMuXLxflypUTmzZtslhm06ZNoly5cmKl2sOhAGHJ4cjWlJFaVhqZMnDKFMVhSW2NtHbYb+RIZdg4M9R1UFt09Hpy/pBD8gsWKHVo3FixZJUpQ9bQIUOE0On0RtZWf38hjh0TYvFiZd0771BqRH9/GpqtU4fWBwba5mSUVeYaLbTSjarbYMwYcqhq357qJ6/BmkxMasetM2foeAsW0OfSpWli7dq1YsmSNFGypBDffEPl1NZG2XdkvnLpZHPokHLchATtesg+s369Yt2VDk9CCPHRR+Tsk5BAlu5y5ajMpk2UKQsQYsAA8+Na67QjkffE3Z3aEhCienWyegNCPPus8b1KTU0VY8fuF4UL04ohQ6jcuHGUaWjYMKqf6ZQRa38D1iCnQMjj7dkjxFtvCfHdd5nvZ61VMzbWOsdDU9hiow23izbcLtpwu2iT15ZPu8Rn+/btRUBAgGZudcmjR4+Ev7+/eOmll+yunDOjJT6zEk6Z5QaXw4gLFyrio1Qp+mvShIap1Q83eayRI4Vo00aIAwfMz/3WW8pQbGb8/TelUfT3N58GkJFBczoB4zSZpjm1K1em+YuAXhQu/FgcOJAqIiIo17VsFzkkXbkyCbxmzWgeq1xfsWLm8+JMowdozastVoza6soV7WsdMkSIN980Fmbq9vzqK6pL585Kakd3d+uGeM+eVebBSkH87rv0+fgx/QN8/DhVNGtGQm/zZrpvQhj3ncqV6Tg7dijb5BD2pUva9QgPp+27dpGIVwvsjAzjua7Dh9Mwu/R+ly8SixcbH1OvF6JqVbq+996jechBQUre8gkTKAd6nTrm92TwYOP5rwAJ3lu3jIXa48epomrVO+Ldd9MN9wGg892+reyr9WJh7dB3Vsi89q6udLzvvqPlrP512fPyYwv80NSG20UbbhdtuF20yZfis2zZsqJZs2ZZlmvWrJkoZ5r8u4CgJT6tDZlkaiFRPzQrVFAeuG5uJKx8fISoUoXKrV5NonLxYjpWpUpUduhQ83N3707b3nyTBKUl4bJihTJ/MyLC/EEaGkrbIyKU9XJuobSyVatG9Rk3Lk24uaWLmJhUg3VqyhQShXK+qpeXcQgmKaykE5KWxcn0QS+dl0zn1cq2u3vX4q0zQ22tHjqU9h81ipx8ALKWZoY8t8yZDpAluHZt5bjqf4BaVnB135HhtLp1U7YHB9O6yZO16yDniB4+rFg19++nbQ8fKvV6+NDYGWjuXEX8nzljfl3S+tu+vRCtWtH3H36g7XIuapEiNHdVfU8SEmi7tDQXK0bzXNXtlZhIcz6LFk02zPl8/30q/+679IIA0BxhLbLr0CORfblUKTper1603KNH1vvaa9W0Bn5oasPtog23izbcLtrktfi0a87nrVu3EBISkmW5kJAQ3JLpTwo41mQtsZR5Rc4fnD3bOPtOejrNmUxNpVSXDx9SisD584Fjx+hYV65Q2e+/Nz93QgJ9LlhAc0k3bdKul5zrV6MGzV88edI4kLYM/D14MNVVCJrj5uMDfPwxbTtzhrK9LFrkitatL2PYMFc8/TTwxhsUwiYoCHjxRSqblqaE+KlalYLlAxQI/84d4+DsEtP5mK++aj6vtlw5pbwM3ZQVQhiHHLp4kdaXLw8cPUpza0NClLmWf/5J59bKxDRrFi17e1ObnjyZdSgjIcz7jgx9tXKlsk9gIH1Om6adtUeu8/VVwiDJ+y/nl8q6+fpSEgKAsmA9ekTHf+oppZys02uv0bJpqCWA0kvKc586ZXxPfH0pOYGnJx3rwgUl8L1sr7FjgdGjXdGnz0lDv1UHmTcNs2SK+vd044Z9WYMSE+m3160b9dOpUymlKmB5jrSazNJ2MgzDMNrYJT4LFSqEuLi4LMvFxcXBw9KTo4BhrZODJWeJqlVJqKljDDZtSg4nQ4aQ08rEicb5tXv0UERWUJD5uV9+mR7MUmhYSs8oxUnx4iSKgoIUgSyEIrRk/MpFi0gAzpwJjBpFIiQtDYiIAJ56SkCn0xkca4Qgx6JbtygOpE5HcTS7dVPOL52VJGpHq9hYcoQaNoyEQUgIpULcuJFyxKsdgGScRm9vc0csSUoKxQKVwsbUUUSKz3LlgB9+oKxSd+8qYlw6Xw0bphxTZmLavp3uQa9etD41VamTKa1bAzExJNhN+47aaUgi87sXL27ed4RQnIuKFDHOPgQYi0YpGCtXpk+ZL75BA2PnLlkn+WJgmts9MdE413zPnvRyM3CgcaYt2deLFDG+VzJzlWn8U3nfrBGf6nPY69AzcSJQpQo5TQ0cSMeTba0V55NhGIbJPnaJz6pVqyIqKgrx6qePCfHx8di7dy8qy6dcAWfePHqgygdsQgKwdSvw++/G5TJLGdmvn/L94EEKkH39OjBhguJZLS2jhQrRsVq0oOXnnzf3DO/blwSbFBBZiU8fHxJh9+5RkPOJE0loSREgc4EPHQqULUuiUK9XPLarVQOmTcvA1q1lMHhwBv73P7K6FiqkpAH19KQc7sWKKeeXokYixae0Sp4+TWKke3dat2kTCbRffjHeTx5Tr7fsFd6kCVkzt2/XDvAvU2uWL09RAL77joKjm1qr//pL+S6jALzzDrXXZ58p2yx5UK9dS31k8mTzvrN8OQmiNWuU8lOmUIrNMWPM+44QwPr1dO6AAKBdO6p72bK0Xd5fdUD7cuXIcujmRtZG9f1QRxuQ99Y0t/vEicae+p0704vByJFK26st+upoBEKQxVwI4OuvM4z6rS2WT/U5QkOti46gJjZWO4qB/E2pLcYMwzCM47BLfHbp0gVJSUno2bMnkk3jswBISUlBr169kJKSgq5du2a7kvkB05BJBw6QdWvUKONyUqhoZV6R4kanIxGhFkZyqHbvXiojrTLly9NnZg9ome3HkvhUZ7/x9aX63blDD/WhQ8n6+tNPZB0bMoREyKVLQM2aQFyckgve3Z2G7l944TL++MMFqalkhYuIoGtyd6djbNyohA9S10tek8zi9NNPNJybkUEi6eefFUvlF19QOJ5168yPk5FhOf+2bKfHj80tjnfuUFvodBQaavx44PhxYN8+qq/a4rh6tfLd1Ho6aZJynn/+ybzNg4OpDuq+U6cOXfdLLynlGzUiUbRggXnfcXGhKQ2vvELnHTWKBOozzxifS4rFxETaPmcO8L//UcikzZsVS7c6C4+8J+rc7v/8Q6Ktdm2lDqVKAb/+Si8OU6cq66tWNc/0s3w5tevAgebD1TVrAr170/XKsFVZDZ7YM/Stnm5RuTJNYzlwgF5cChemMrt2WX6JYRiGYbKBPRNFk5OTxdNPPy1cXFxESEiIGDVqlFi4cKFYuHChGDVqlAgNDRUuLi6iSpUqIikpydHzVJ0CU4cjU+eHq1cVpyF1UIDMnCJkXnJfX8Wx5s4dIeQ86YQExTlEOuV88QUt9+plfryTJ8nrW4b16dRJ2ab2HB8xgraPHEnbpHOPDIckg5VLr+v27Y1D/5w7RznIg4MppNDy5b8Lf3+98PFRQj0VK0YOS1qOGStXUvgl6SAVGkrHLVGCHK1GjKB2K16c1i1bpl2/qVNp/7Awy0HImzWjMj//bO7Zf/YsOXyVL6+sK1yYyk+dqnxXhzxS3/d79ygkUOHCitPQ779TuejoVDF0aLT46y+6mV260Pa336brcHTWHjU7dypRBoQw9hKX9Ve3s/oc0dHKPZFOT3XrUll5DYCSOSkykhyE1CGh1G2UkED3LCCAzpGZM8DevUoUBEejvk61Q1ZSEjnoSUcqWzNsORJ2lNCG20UbbhdtuF20yWuHI7vEpxBCXLt2TdStW1fodDrh4uJi9KfT6USdOnXEFUvxbgoAlrzdpejZtUt5oMmQN5llXklIUEIatW5NwrB+fVrevVspR+GMlFSL8+aZe0YLQYJMp6NtMnxQ8+a0zdRzfMAA2j5+vLJ/bCyJRXV4pWXLSCg1aKBcm/r3TNevFwsXbhb+/nrh5kYxHj08lPA8GRkUbuf4ceP66vUUA1KGKho2jASRFAh6PQmg0qUpVWOpUhQiSqejOp08qZwrJISy1WiF3GndWvHYtiaLkhSRxYpRph7AOO6l+hi1a1Pdu3RRvLznz6dygwen/+dFTyGFIiNpe3i4Ivoyy9rz11903pIlzQX8rVsU/WDjRlpOSxMiPp7+hKD4o4cPC3HkiOLZv2UL9YulS6k9ixUjD3j1/RaC2tjXl+5FmzbkSV+8ONVTXoM6FNL9+3QPXnzRuI7y+t56y7g/ZPZgSE6mdKGmXvjZxfR3mJZmHCUhIYFeHufNy/ye5DT80NSG20UbbhdtuF20ybfiUwgh9Hq9WLdunRg4cKBo27ataNu2rXj77bfF2rVrhd7RQe/yGGvSa6pDJg0erDzQZJz9zMTO8OFCNGxIVqrDh2mdtCxNnaqUa9qU1rVrR8upqdo52xMTlfOvXk2fNWvSNtP4mDNmUGBtrVBMy5aRIJk3j2I8LligWMDc3Y3L6vVKGsnw8Azh4UFCRS027txR6qVlEZbhmACyjqmFkLc3bZcCSW2xqlbN+JpGjNAOjt6uHZVfsMC6NIwREco5Zs1Svr/+OuWPV4dMkqGedu8mQVyiBInC9HQhPv44/b/9yEwrLbDSAphVjEpZ3svLvA/J1KTSsjlpEi2/8Yb5/ZHnWLhQuZb33tO2JJti2l4yRJdp2s8pU2i9jGEqzy1jw9arZxxkXv1gSE8nsfzwoXYdHIHW71D2u+vXjetsT9xQR8EPTW24XbThdtGG20WbfC0+nySsze0uY1t27qw83D/+OOvMK6ZDwEIow/Bjxijr7t0j4ZBV1hkZI9HVlb5//bUQq1bZlndeCHoAlylDxwoJoWU5vO3nZ14+JiZVVKgQL4KC9OKLL8iCO2WKco6MDPP86seOkUj98Ue6Vi8vEgNqIfTDD8r1+PnR+kWLlDZ2cVGu6ccfSfAOGWJeP3lfZs+27vql6KtZkwTLrVtKHE1ptRSCRJPMl/7PP8bHXbpUqWebNnRBMquTnOogROZZe2Qs1MaNzQXzunWKqBNCmWbRtavxcdRDzTKfOUDrpaU7KMiyGDcVbf/+K8Qvv9CfGrWVWh0Avm5dEuTq6zN9MMhMWJGR2nVwBFq/NflCdfCg8XpbMzw5En5oasPtog23izbcLtrktfjk3O5WYm1ud+lgIR2DAPL0VTtxaGHqsAQo8QrVXtZ+fsDSpdoOS2pkmB0/P/IEHjqUPJJtyTsPkPNNp070vV49WpahkdLTta+/atU4VK0qMHIkOXGMGqWcw8WFwgUBlBMeICek27dp34QE8nL28KBz/fwzxdt86y0qm5FB23/+mZxvAHK60uspz3hWyJzm0plFff0ffkjX+OOPSnnpMPTaaxReascO8iYHKPKAdDK6e5fqoNOR57g87pAhxk5nt2+TW/Xly7QcGWncdqbOOUJQvnvpBZ6SYh4rVn7K/iLjfMo+cPAg1XPIEMWBzdVVOW/DhnTu6Ghgxgxzz36JqVd+sWIUMksdNgug7VOnUqQGde7zf/4Bzp7N3DFI7e1+4gTdkyVLLJe3B63fmnSeio6m+KTDh5MTkiXnQIZhGMZ+7BKf+/fvR79+/bBv3z6LZaKiotCvXz8cPHjQ7srlV8aPVx78AHlLq72hLe0TEwO8+aYSZFyKCLUQMPWs/vdfEpKdOxsfT55fHgOwHFrmhRcoZucff2jXTXqmS69jGXJHBlJXExsLbN5cziiEjmnInZIlaf3NmyQw5PFSU8kD+513SHCVKEEi4OWXKWSRjFGZmkpCat8+OvblyxQHtVUrEraDBwOffkrB+E3r17ChIgxN67Z/P4kP2XaxsUrcz9RURfTJ+oeGUoirkyeVl42AAPLM1+monX/4gSICSG7fpuM+fEje+qaCefx4Erlq0Xb0KL0wABRb0/SFISvx+csvFNpIp1NeOtRhkmRIJsD82EIAbdrQ+ZOTSWjq9cgUIaifRUbaHgDeVHx++im1oSMxbWOAXjoA4NAhaq+vviLRm9XvlmEYhrEdu8TnvHnzsHz5clSST3ANKlWqhGXLlmGBNE89Qfj6KuKmfn0SB97eSgghS/sAFMD93Dn6Lh/UUkQkJpIVplYt4xiEP/9McSPVokBmt5EBx6OiSFj0729uefr1V3rYjxqlHVpGhp6RgcxDQuiB3LSpuZVu2DBXREZe0szqI616JUrQups3SWhKBgyga37zTRKc9++TmIuIoPYMCiLLZUaGcn0+PtS2mzZRIPt//6XjjxxpnEVIMngwhfpp29a8bocO0XLJkkooHhmg//59CiPk4kKB4QESvdevk0VbirXHj2nfs2cpqxRA9ZXcvk3HHTIEePdd4/iagHnWnqFD6d7ITFL37imC+dtvSfiaik91kHkhgFWraFndP1q3Bj76iEIsqWNjmsah1ekoq9PZs7T/48fU3zJDviD99JPtAeC14nxKa7Wj0Mo0VrcufUZHKy9DS5bYnjGJYRiGyRq7xOe+fftQq1YtBAUFWSxTrFgx1K5dG3v27LG7cvkZf3/6PHOGBEBKirkQUpORoYhMOexrOuwuMxxt3Kisk0JDCGNrq6nls1Ursri9/rr5uaWQ/ecf7fiYpuIzLIwC3//2m7mV7vx5HV555YzmNUqLkzzf1q2K0HZ1JQvfCy+Q4PvsM3rw371LMTXv3aPh0GHDKDamECSMkpLIavv228p5+vWjbVoWLkuMH6/Uq2RJRUB9+SWlLn31VRLpN24oGXAePQJ276bh2QsXaF16Op0vLY3EqQx47+pKN16v1+HMmcytadL6WK8eHWfwYCVmZ0ICHVOdolPea1PLp6z/3bvKvj/9RN9dXKg/tWljfG6tOLTq4PQ+PpaH5QHjwP2+vrYHgLc1yLy9mFp4GzQAxo2joP/yxaZYMdszJjEMwzBZY5f4vHHjBsLCwrIsV7ZsWfxjKcp2AUdmtvHyIsuNzEluSQjdvasI06VLyaIVFkZDl/XrK1ln5ANcBv/29FRyUN+/rxyvYkUSCd26kSCQD3L5qUaKrqFDtYWFqfiUaOXW/vzzDHh7a0wGVZWXMzE2bybrH0BiKCKCgqsDFOA7IoKG0/39lQxH48ZRgHs5b7RyZcrk9Pzzynmio83rJ69JCGNhI1Fbt3Q6RUA99xwFPa9dm6ycAFnE5H2QqUddXIAuXSgw/IgRJLrUuLoCJUs+hJeXwOefkzXyl1+UuadqpGXT25vu74QJSqIAIRRxJMW1vF55DfIzLY3mTD77LC27u5OV1pJwBMyndQDG4tPPL/M5wqZzim0NAJ9b4tN0Kkjx4jTE/+KLShYx9bxYhmEYxnHYJT5dXFyQqqViTEhLS0O6llfKE8CMGYoF7MUXgb//NhdCam7dos/gYGV4ulEjsnJ+8gktDxyoOPmYCgJAESUAiaWpU2l4d+JERazeu0cC5uOPgZUraZ3MXNO5s7awkPMDpfi8e5dE4u3b5rm1u3e3YNr9jx49yEHIx4dSPNavT+uFoGxFsh0SEugaunShoXS9noZ7ixShKQbx8bRPnz4kJNRDs+qUpqYWrnHjSMy8955xveLjleHxzp3Nh4nT0pS5uMuXK4J8yhSy1NapQy8LP/1E0xLmz1es3wDd1+Rkd6SmUhrSvn1JTGuJTwAoXZqs3F9/Tdfs6UmCdds25d5LcX34MLBwIR0PoGFyb29K0Qko5+jYke71uHHa5zRNNypR97VChbRTZgLGaTltSXOpJrfEJ2A5+5I875071lnNGYZhGNuwS3yGhYVh//79mQrL9PR07N+/H2XV3gxPEA0akIXP15dymv/wQ+ae5TJXuL+/ttPJuXMkDCRSTMp9AGPLp5p585Q0nPfukcVx/HjFkUeK4Rs3tPPOh4fTMaZMoeXly+nBPXSo7bm1dTpl/59/VrzJw8JItE2apJRNSyPBFBFBovvdd5U6pqbS+q+/pnWTJtGUglKljIfgTecwSiFj+u4k6yGjA8hriY+nF4DFi0mguLmRZXrNGpoj+scfVHb2bGUOJkBl1fM5R4zIQHBwMl57TY9hw5T16vuoxtSCCJAobtnSWGj36EHW4VOnSAAnJtK9nTCBhv0/+USxNDdsSOlPtYSjpXMCxuLT29uyV35WER2soUQJoGtXmg6Q0+ITMP6tXbtmPN1g9OjMpxgwDMMw9mGX+GzTpg3+/fdfTJgwwWKZiRMn4t9//8ULL7xgb93yNdKz/H//o+VTp8wdRSRCkHctQNaWIkXMh7OnTjUeBpRD7YC2+Lx1ix6mycnkZCTDGt27pwhdgKxk8iE/cSKdxzS0TPHiFOpI5hqXllIpSmwdWlWX37iRROebb9K2N95QvNqnTqUc62vXkkh2dSUxGhBAIqhQIeCppxSra+vWtJ+6W5rOYVTndlfz6BFNVahc2fhaTp4ky7Xc39WV5lq2aKE4NVWtSvNE336bBP0//5A4k3MtFy8GBg0SGDQoBvXrC8O9d3dXLH2mmIY1soSpuJ44kV5wNm6kuo0apViufXxo/qpOR5ZX9fzjzKyWppZPwPILUnY9w59+mizy06bljvhUT80YMMDYka9r18ynGDAMwzB2Yk9w0Bs3boiAgADh4uIiXnrpJbFhwwZx4cIFceHCBbFhwwbx0ksvCRcXF+Hn5yeuXbvm6NikToFWek2JXk8ByF94gbK8AJQ9RgbclsG6jx9XgrDL1Jre3hTkW6ablCkyMzIoA5Eso0adMlIiU0FOmkSB5QsVUgLFy0wzgBAtWyrf/fwosHtW6QQ//JDKDxpkvs2agL56vRA3bwoRE6Md8HvBAgoSf+KEsu6dd5S2KFaMypQsKQyB7P/6SztbkWmuchkgv2fPzK9Rcvy40j4A1Ssx0fy44eG0Xaej7FYJCXSfACEmT6Z26djxnAAoDSdA99wSWll4tm4VYu5cIc6dM27Lp56i+7ZoEZ1zyhSq25UrlAFr/Xqq944dtM/gwcZZp7LK5NOqlXFmJ3XbliypZJWyJw96Zv3l5k3KLX/xou3HtQV19iX5t38/tV1sbObJIXISDo6tDbeLNtwu2nC7aJPXQebtznC0bds24efnZzG3u6+vr9iyZYsj65qnWJvhSAh6KMuH2LlzSkYfmeo+IYEyvVSpQp8eHpRx588/hfjsMyUzjhSugBBJSZS/HBAiMND4fA8fUn5qNTI156xZtPzii7RcqJAi4lq1omN9+CGlivT31xaf6ekkfNasoQfyiBG0/6hR5u1kzQ/98WPlugYO1E45aiq+ZP5tFxdlvTqLkJZY00qfOXMmHadbN4vVM+LqVWNRUqOGcv+ee47Ee0YGCXdAiAoVaFtiImUYcnUV4vPPqV369DkhALrv8oXEElp1lyJQ/ZLx44/K/fTxoReCkiVJoANC7Ntn3p4JCcb32lRIW4sUraVKWU4bmxVa/UWvN+/POYk6+1KpUtRu27Yp2zNLi5uT8ENTG24XbbhdtOF20SavxafdGY5atmyJ2NhYDB06FOHh4fDy8oKXlxcqVaqEoUOHIjY2Fq1atXKkkTZfIJ02JEWK0NAwoHhy+/rS/L0zZyi0EEBzDZs2Bd5/Xxnqk7EHAZp39tRTNI9v/37jc/r40FxE03rIcwE0H9DVFWjSRHFGqVaNgpxPnEgB22vWpD+tYcZWrSjTUUKCMuyuDlRuCx4eQGAgfY+MJGcsdVYhwHxYd+hQ+qRYojQ0rM4ipDVkrDWHUc6XtMJfDoCx05C7Ow07T5hAx929G9i+ndpYOnt9+iltmziRvNkbN1Y84v39aaz/0iValu2ohZanvmnorcREmmcprzk5mYa+w8ONA/lfuWLcnr6+1FbJydRXrQ0Ab4qt832t4fRpmnYRHJz9Y1mLOvtSo0a0TkYQAGwL2cUwDMNYQZ7J3nyOpWH34cOFaNpUsZQlJJAFDBBi+nQqI61a5cpRDnN17nMhjIf6ChdWLKi2UL8+7bdunXK+L75QhmWDgpQ84uq885aGGeUQ8qVLQvTuTd+/+ML8vNa+ZVarplhx5RC0qeVNWjb//pssnoMHm1uhTpygbb17G++rviY1lnKHDxxIuc1/+814vV6vWBa/+orq4+VFQ9mRkcZW0aAgqtu6dUo+cJkbPDU1VUycGGVWPjNMh8Nlu0+ZQsuDBpHVXPaR7t2prj//rPRBX18alo+LM7YU6/V0D3S6vLHqSUz7y/nzVO/ChYX4/XcaCZDW25zA1MI8Zoxyf9So2y63YIuNNtwu2nC7aMPtok2+tXwy2sybZ+xt7e2tpC+U8QOlU4iPD1mLRo0ii1qnTuSkog4gLkP6ZOZxu3kzWfe+/lpZp7Z8SgvgyJHkCLNxI3mSV6lCFp6GDSlOJuVl184MpI71aepwZA8yy5FMPVmypLnFVVo269al65gxw9wKdfw4tfHFi9Z5XoeFAR06UDQCNSdOUMgiGZ9Vom735cspaLurK/DFF8D69XTeCxfo7/Rpqtvo0eS8Yurs5OenHDwgwDwWqCmmsSjVls/YWEpFWrOmkpFn8mRy3ho50jg71r17ZDE3jbbg5UXOZFlZLRcsoO06nZJpKadQh1patQoYM4ZivuYUptbxypW1y2UWqYJhGIaxDRafDqZ/f+Cbb+i7qys9TPv3p9zfI0cqXvCRkTTM9/bb9FC/dYuGcKUnuhRZkgcPKJPOqFEkBtRcukRhi9TJpOQw8L//0vm++IIe4j4+dBwhSHD16UPHVp9La5hRLT47dKCc67Vr299OclhYIofO1VEAdDoaYk9OJi9tFxftwPYzZgDnz1vned28OcUT/egj4/Uy1JJpvSZOVIbqjx4lIVerFnDkCA2rlytHYazKl6epBJ06UdsNH25ej4AAxcV+xgzyjM8KdVgjeQ8SE8lbXaejeKIyPqmfH2VhunZNGeqX3vt16hh7xquHmrOKUqDuG/HxWdc5O+RmnE/APKpA9+40xUQmP5CYRhVgGIZh7Mct6yKWiY6Oxq+//oozZ84gMTERQiN3pE6nw/bt27NzmnzF+PHKHE8Zw7FSJfoTgiwsb7xB+cELFaL4lMnJSoiXKVMotI8UWX360PrERMqwM3UqxXqUoYkAJci8OtSStHxOm0aWTBcXCg8EKCKud29FyMo0l4CxwGvXjqxo6kDzPXvSX3YwFXk1ayoia8cOetgLQdbc4cMpxJKkRw8SDTLEUr9+1NYjRtC82ZEj6bqtncN44oQyD7NUKWW9fFEYP54scGlpFDdz/Xqayzl0qNI+ALX56tVUp88+I8udrEdaGlCkSCp0OgEhdHjuOevbavx4EpEyq9PRo2TxHThQsaoDJE7r16cXm23bgOnTSaTKeavSEtunj21tpI5Fmh1rtzVI8anXK1ZoR+d2V9O/P7XDiy8qyQq2bDEvp5V2lGEYhrEPuy2fI0eORP369fHFF19g3bp12LVrl9Hfn3/+afj+JOHrq1hNTB+a0hKWmkqC89tv6eF/7ZpS/sIFxYLXowc5XoSF0TCtHO42DUwuxYW0dgpBD8nmzenY48cr6RkBstDVqAFs2GD5OkyHGS2l2LQXOewuiYuzPnaklqOLaaalrHJyq4foBw5UlmW95ND9O++QuJVUrkwWz8GD6T6qY4pOnKhsnzOH6qeux7VrReDmRtmVdu4kEWkN8mVg0yZa3r+fXgYmTTKeFrB6NX3+9BO1yfbtxg5Tsj0B69pIYhpkPidRxz2VL2S5FWQ+MxwVx5RhGIaxU3yuXLkS06dPR0hICObOnYvW/0X3/uOPPzBr1iw8++yzEEJg9OjR2LFjh0MrnB94+20aymzcmJaTkmiu4IABJCIWLyah9MorNEzavDmVq1zZ2MNZpyPL29275IUr5/aZWp9Mg8yfPElD7CdPKtatokWV8h070hB36dKKNbRePeNjmg4zSvGZlETzB69ds95jXIv69ZUA/ABNC7AUXF/LOmca2N5az+s9e0jkV6tGy2pBptPRkLx6/fjxylzd4GBqt9mzaXjW3Z3OdfKkcZB2wHi+rFyeN68GBg/WIyCAsjHJ6RnW0KMH9Q/5EjFrFrVLQACwbBlZ8GS/8fMjC+2GDUp2IxmFYehQsnbb4p1ekMWnVlQBUyylHWUYhmHswy7xOW/ePLi6umL79u146623UPK/MdRWrVrhnXfeQVRUFMaNG4fp06fDT44JP0H4+9MczC1blDmM771HVsNy5WhI0dubrGrdutF8z0qVKD+32uJoOtRnydFHPewuLXanT9NQr8z3LUMuAUBMDGWSOXCA0kOGh5vP3zQ99+DBZM175hka9i9Thhx07KVhQwrzJLl4kaxPtlow1ViTacnNjUTzo0eKqHjrLdpWooS28JXG+4QEZQ7m6NE0JcDdnZYHDaK/p5+mtho4kKZJSIvaihU63Lzpgw8+0BuG+E2dmzJDpwMWLSLhXKsWtRNALwWvvkr3Rm2pHjWKhHjXrnQv1ZmPbE2Bqe5vllK4OgoPD5o20L499V+5LifJypnIUtpRhmEYxk7scZEPDAw0ctHv06ePcHFxMSqTkZEhwsLCRJcuXbLjje+0ZJbhSKIOCyTDt9SrRyGDSpakDEYVKwoxdqwQKSnKfjI8j2nw7/HjlcDsaq5fp/VubhR0vGRJCibv728cpHzxYsq2Yxq8XJ5PTWaBx4sXp/MdO2a+zdqwFjJQe6tWlDVHHcomNpayFuVEVpnoaKp7aKhyf/74g8IRvfgihTaKiDAOPyTDTMlfiwzPs2yZEI0aCeHpqR2w3TgDkF4MH35IREenCjc3OlaZMraHONLKCCWJjVXCZwkhxIoVFEppyhQKDyUzH9kaLuiHH5Trr1zZsWGZMusvTZrQOX/91XHns4Rp20kshezKDThEjDbcLtpwu2jD7aJNvgy19ODBA5QpU8aw7PGfaeKhakKgi4sL6tevj6ioqGzK4/zH5csUluf555X5ZHK49MIFCokzdSqVO3yY5u7JXO2mTiENG5JzzsiRli2fctg9PZ3K9e+vODENH64MJ/bpQ44z6mFGLUeKrIYZHRFqacIE8hD/7DMaBlZbn2zNFW8L0oqWnExTGmbNopzwZ88Cv/9OQ/eHD5PFUA5LS+cumTNBDtWOHEnbZJ5403ZTW3ErVRJo0uQGJkxwRXo6lb93z7bA5ffvA82aUSICOax/6RKwZg1Zs9We8Xo9Xd8LLwAffkjD/F9/bd/QsdrCfft27gVbnz0b+PNPciLLadRtZ03ILoZhGMZ+7BKfxYoVw33V+FtQUBAA4PLly0blkpKSkCjdrp8g9u0DXnuNHvRS6EkP+IgIY2FiGjfR1CmkenUSkerMQqbz7goVIoednj2prPSKFoJEr6X4mRMnajtSaA0zXrlCDiwnT2ZffMoYlUeOUAzPq1eVOZvffmscbsnRSCewhASa9mAqKqpWpXv0wQck4ACKTLBiBTkSSWQbDhhAw9s1a5pPFVDPQ/366wykpLhh925lomX79pnPNTTl+nWax/n334oA3LqVsmVJxyfpQPO//9F97dyZ1q9fb9/QcWIiTSH58UfqT7Nm2Vbn7FCtGgnPYsVy/lyA9Q5vDMMwTPawS3yGhYXhypUrhuXatWtDCIHly5cb1t26dQt//vknyqpjweRjGjdubPR3/Phxi2WlY5C3tyJSTpygdX/9RQ/upCRg5kzj2JZaTiFyruaDBxSb8sQJstCo0elonuLy5WRBlU4vlSqRs5J0ilGXl8HLhw41toapHWfUDinff0+W3K++UuJK2iM+1V7k8tquXqVPSwHuHYm0fGZkWBYVa9fSvZApPQsVormzas9xnQ5o25bquWqVZWcntRV3xYpwhIQoF9aokW2By+U9cnFRBKB8B5SWdV9fcjb67jtg7FjqM59+Ss5l9qTAlC8ir75Ky7kRbL1UKbpP6vBfuYFWDFl2MmIYhnE8donPli1b4vTp0wZLZ2RkJIoWLYopU6agW7duGDFiBOrXr4+kpCR06dLFkfXNF6i90qXQk8LFz48e3KNGkYWtXj1FbGk5hajFZ3AwWYPUsSgB2rd7dxK7MTGKd3bFiuQAU62auaCrWpW2pacrTkmZDTNKb/fbt5V19uR2V1uT/v2X1kmPeyDn82jLIXKdThEVL79M9+LPP2k5NJQiFsyerQSfNyUxkYaxlywhi2dWUwViY4HNm8MwYoTesM7HxzZrr6xvRgZZ0idOpKF7wFgYy2xIkycrma3smcYg45yqRWtuWKhTU8nZaO5cOvetWzlzHi2y4/DGMAzDWIdd4vOVV15Bv379cO2/AJU+Pj5YvHgxvLy8sGrVKnz11Ve4du0a6tSpgzFjxji0wnnF3r17jf5q1Khhsaza8gnQQ3/UKPperRqJmhMnSPi9/DKJrS+/pPVt2xoP9alTKlpi0SLybq9alcRS27a0XoqbU6dISKgFXWws/bm707AqkPkwoxSaUjC6uRmHxbEGa0LWWBP6Jjt88w0JtdatlWH1Y8doCoBanH/zDdWxQwft49jiAS0EMGyYKyIjL+OZZ5STNGxom7VX3WaTJ1N/uXiRlqX4lIJxyZKsw05lVWdpoS5aVEmveeZMzluoZb+aNo0yX8k4uLmBtSG7GIZhGPuxS3xWqVIF8+fPR5MmTQzr2rdvj3PnzuG7777DpEmTsHr1avz1118olNMpUZwQU/EJkAPL3r00nD5wIIkdgKyPX35p2SlELT4XLqQ5oqdOKceVw8Pe3hTT8dw5cuQBaG6gdKQoVkxxPpLCYvBgOp81w4zS8pmeTudT56+3FlPBJuemqnzXAOTs0O6SJcAPPwCbN9PwNUBTEwDjuYUuLuQIdviwuYXP0tQES/z0E3D+vA6vvHLGKLh+aCh9WmvtdXdX5qyGhNB9lWGgAgKMLdcdO2bPaUv9IiKtxYAi2HPSQm36UpPToZZMyUmHN4ZhGMbBud1LlSqFAQMGYMyYMXjppZfg6urqyMPnG7TEZ+nSNMcvJIScWWQZKRQBbacQtfhcvJge+n//rWwfMoSO9eyztJyQQM5BAImkkydpn/v3FecjtbCwdphRik9PTxKstgRIl5jm0d62jRxiTDMt5WQebZlOUW2xkxZWdSxUIYCVK2k4Pjse0NLa+/nnGfD2ToefnyIg5RQGW6y96v4wfryS1crf33EOMqYWavX7o4zKkJMW6rwWnwzDMEzO4lDxyRBa4lONOkWlTkdD8pacQooVo+HZevXMMxwJQdltOnRQrIf375MV9dlnaf3gwUrmoNu3aUhWLSysHWZ0RHpNU+FXrRo568hsQ5KczKNtarF7/FgJZq4Wn1LIrVuXPQ9oae3t3p0uWqcDli4ly6va0mqttVctPn19FeupXu84BxlTC7UUnLL+ttbZVkzFZ07mdmcYhmFyH6cVn9euXcPgwYNRoUIFeHp6IigoCG3atMEGCwnJr127hrlz56J///6IiIiAp6cndDod3pRBGnORXr1IYHTtqqyTYWrGjlU83728SCRm5hRSqRIQFUWixzTE0U8/0THi4oyzHFWqREP8ixcrwumVV8hRxcXF3MJpzTCjFJ///ktD9NLiZgvOkEfb15fa8bXXaJ6sOhKYvEa15S8kJHse0KbWXoDm+bZpY+ywZa21d/p0sshWqkTLM2aQ89GYMY5zkDGtc+HCFGvW35/aw9Y62wpbPhmGYQo2Tik+Dx06hFq1auHbb79FSkoKIiMjUaVKFezcuRPt2rXDeA1VsmrVKrz99tuYP38+jhw5gtTsJB7PJhERJEDr1FHW6XQ03P7ZZ8Du3bSudm3bHBvUFlUpkGbMAM6fpxiQgBJ6x8XFeGh08WJ6iIeH2+dIUa4c5V9v1Ijq3KaNbfsDzpNHOz2dXgamTlXqUagQIGeJmFr+suMBrTXMr4W11t6XXqKXmv9C6+LFFynIfNmyjnOQMa2ziwsFs79501gY5pSFun594LnnlGUWnwzDMAULpxOfjx49QpcuXRAfH4/u3bvjwoULWLt2Lfbs2YOoqCgEBgbi448/xtatW432K1euHIYMGYLFixfj2LFjGDduXB5dgWVkiCQXFxIwtjqFqC2fUiD160ci6o8/aNu8eYpTCEDCqXx5chKaMQOIjrbPkaJ4cZoe8PLLSh3swRnyaMth5GXLaP5shQrK3FstZ6LseEBLa+/PP2e+U3asvY52kNGyUHt6Gg+/AzlnoV6wgKYlSFh8MgzDFCycTnyuWbMG165dg7+/P+bMmQNv1cTJevXq4aOPPgIAfGySGqhjx46YOXMm+vTpgxo1asDNzS1X661m927gt9/MY0SWLEmfP/9MVtD337fueOXLk9Xwzh1aLlTIeGi0Rw8aenVxocw2Lqq7qtORlezRI8cIuqQkpQ72oA5wn10vcnuRYqZrVxLu587RVIjMnInsFXjS2vv++65ISdHuk7ZYe48epUxLp07RXNU1a8jjXf3CkV2cwULt6krZmzZuVKZDMAzDMAUDpxOfhw4dAgBERETAXx05+z+ef/55AEBUVBRu5Wb0aRsYP56smnJ4XSLF5927tsVITEw0FgHe3sZDo9KJxdOT1qs5cYK86Hv2zJ6gEwI4dEjxTM9OBK28zqMtxWffvrmTTpFeDgRWrAjX3G6LtfebbygpwNq19DLSuTPQsqXjxXpeW6hdXSmjVmQkxZRlGIZhCg5OJz4f/udOHRgYqLld5pEXQuCIDJbpZFjydpdOOk2a2BYjUVqW5syhvPFBQeZDo5YEncx8ZE9oJFMaNABWr6bv9mQ3UpOXebSl97SHR+6kU9TpgBkzMrBpU1i2rb1qb3c5v9ff3/HiMy8t1C+/TGHBZPIDhmEYpmBhl03h448/Rq1atdDBUvqX/1i/fj1iYmIMQ+XWEBwcDAC4KFO3mKBef+nSJauPawuNGzfOsszx48cRGhqKNBmnR0VyshsAHdzd05GWRkowMRHYvZvWb9gAuLoKvPsu0KZNepZip3Bh2q9MmXTUrUvH8/YGPv9chxEjXA3HGDsWqF7dDT/+mIFXXhFYtEiHM2dc8d13GfDyEtCoqk0ULuyGxERSG15eGUhLMx/rle2h1S5q1PV/9tl0jBzphilTHFPPrHB3p/ZMSkoHACQmuqJyZSAiQqBLl4wcOX+lSml44YV/MHRoOWzdmgadjl4OBg1yxcCBApUq6a06b6FCLgBckZCQgbt3BQA3BAQIpKWl50CdgQEDXDBokA5btmTYXefM0OovDx+64v59F0yfrkdSkh69euVAGqV8gLW/pScNbhdtuF204XbRRggBXR6mcLNLfE6YMAF9+vTJUnz+9ttvWLRokU3is0WLFpg0aRIOHz6MmJgY1K5d22j7nDlzDN8T1XFy8ghTxycAiItrCaAwjh7dj7S0eADAokVV4ecXjMRECibp4ZGOoKAE9Ot3H337Zp4kOz29MYBA7Np1BKmpNw3rfX2BokUbGR3jlVdCMHRoNaSl/YmhQ1uiVKkHCA7eiY0bs3+tbm6tAZA599ati9i48ZTFslrtYoqsf0SED0qVuo8iRfY5pJ5ZERxcG3q9D44fj8XffwciKakaihR5jC5dorBpUw7k9PyPV15xw6BBoRgzJhZNm97An3+GIDa2KgYO3IGNG60Tj//8UxFAVZw+fQNbt/4DoAGABGzc+GeO1PmZZ9ywZEnLbNXZGtT9JS7uGQAlcfCgC2JjMxAYmAudwomx5rf0JMLtog23izbcLsbcv38fRYsWzbPz5+hsKr1eb7OybtGiBZo2bYrdu3ejQ4cOmD17Npo2bYq4uDjMnj0bS5cuhbu7O9LS0uDikjOzBvbu3ZtlmcaNGyM+Ph6tWrWCu0lgQhcXt/+u5VlERAjExgJbt7ph48Z0bN6cgSlTXFGpkhu+/94Pzz4biAkTymY6z3H2bFecPg2sXl0PoaF6vP22YnEMCwMaNlSOERkJHD7sitGjWyMtDfjtN29Uq9bWrnYwJTDQDfHxNH+xe/dyaNs2zKxMWloatm7dqtkuWoSFAf37u2LePDdUreqYemZFW8NpGuKTT6gP9ejhhrffbmJxn+wi22XaNB3GjYvAkCE1MXCgG77+OgNdurS2+jjXr7tgyRLA1zcUFStS+ISwMF+0bZtzbZeWpsPo0fbXOfNjm/eXpUtdcfAgbS9UyC1Hr82ZsfW39KTA7aINt4s23C7aTJkyJU/Pn6Pi89q1ayhsh6vqypUr0blzZ0RFRZlZV4cNG4a9e/ciOjo6T1W7xN3d3axDyzmfRYq4wc0NePdd4J13gObN3Q0B5itU0KFWLXe88w7w7rvu2LHD8vw5GUD+/HkdPv3UFUOGKGlLa9WiuZ7qY3z7LWVF6tULqF3bcT82OT1gxgwdIiMz7zpa7aJFrVr4T2jkzfRjGb7Kz88V7u45nw72tddcsGSJDo0auSM8HOjZ082meZPSBy8pyQUPH1KbBQS4wN0959qvVy9g0SLYXWdrUPcXdUYjDw/dE//AsPa39KTB7aINt4s23C7G5OWQO2CD+Fy6dKnR8vnz583WSdLT03Hy5Ens3LkTz8qk4zYQHByMPXv2YNu2bdixYwfi4uJQvHhxdOzYEXXr1kWp/wJmVq9e3eZj5wbqNJjSkWb9elonp6yWK0ef48cDlSuT402PHtrHq1IFhvl2Wl7mpsc4fpyEoiOcjNQ4IsWmsyGjCORUQHtT5MtBv372OeyoHY7u3aPvGkEhHEp262wr6ucDx/hkGIYpeFgtPvv06WOklKOiohAVFWWxvBACLi4uGDlypF0V0+l0aNWqFVq1amW0/sKFC7h58yYCAwNRR51CyIn47juKh+npSR7U06YpouHrr+lTPlTVMRXbtdMWQRMnAs2bAy1aaOeLVx+jaVPzczoK6eF+8yal6nTNeUNhjtCvH8WPnDpVSa+pzuue08iYofZQuzawcCGluQwOBgIDKeRRTpOdOtsKi0+GYZiCjdXi8/XXXzeIzyVLlqBChQpo1KiRZlkPDw+EhobipZdecrh1curUqQCA/v37w8NJn0yvv06fI0ZYjoUoc3MDZK2cN49E5n+XZ4bamqqFPIY9KSCtpXdvYNMmypYUHJyzWYhykoQE4PZt4/ipuWX5zC6lS5N4lpj44xUIKlZUvjvpT5xhGIbJBlaLz++//97wfcmSJWjcuDEWLVqUE3XCqVOnEBoaCl+VOSo9PR1ffPEF5s6di4oVKzpl+kxT5s2jYXf1MOXevcCff9I8OolOR0L11Vcti091ak0tcmNotHt3YNIkClx/967jj59byDmFqakkOosVo7iSjHMwejRQowblrWfxyTAMU/Cwy+Ho0qVLdjkSWcu8efMwd+5cREREICQkBI8fP8Zff/2F27dvo2LFiti6dSt8TKKc37x5E506dTIsX79+HQCFe2rQoIFh/ezZs3N0uD4lBdixg4aoZRaiF19UxGCjRvSnRggqN2CA9jHV80G1ht0lOT00KoQyZ3XBAspGlMdzlu1CCprUVHo5yE+kplL/evgQKFECSE8noeYEvncOJSKCsjhxak2GYZiCh13is2zZspluT0hIgK+vr93eVG3btsXly5dx5MgRREdHw9PTE+Hh4RgxYgQGDx5slO9d8vjxYxzQUF537tzBHZkUHTkfG/TmTZq76eNDud2zciYCzJ2STMnIUL5nJ61ldpkzR8ntfv161tflrEjL5+PHeVsPe3j8mMJpATS94swZmr8q1xUUihenFLUMwzBMwcOu+CyxsbGYOXMmzp49a7R+586dKFeuHIoWLYrg4GCjoXpbaN26NdauXYurV6/i0aNHSEhIwMGDBzFq1ChN4QkAYWFhEEJk+de8eXO76mQt6tSaakegBxZilycmZp3WUb1ePVyfmyQmAu+/ryyPGJH5dTkzastnfkNt8L92jT5z2ts9t/nqKyA0lDJ2MQzDMAUPu8TnzJkzMXz4cCMhGBcXh5deeglXrlyBEAJxcXF48803ERMT47DK5gdM87r36EHORRMnapefODFrByE59OjmRuGTRB5kG5w4kaxRks6dM78uZ0Zt+WzYEHjuOeDff/O2Ttbi4qL0BzkPuKCJz4cPgRs3gBkzaI40wzAMU7CwS3xGRUWhatWqKF26tGHdDz/8gAcPHmDAgAG4f/8+li5dCr1ej28cHWwyj2jcuLHR3/HjxzXLSUEgxad0BJo9GzhpkkUzNpbWZ+UgtG8ffRYrRsOsK1Zk82JsJDaWwkepra4+PnRd335rfl3OTunS5CVerBiwfz+wa1f+ChtlaiEvaM5SMtRScjJZQRmGYZiChV3i8/bt2yhTpozRuq1bt8LV1RWffvopfH190bNnT9SuXRv79+93SEXzC6aWT4AcgQYOBAYPVqyWQtDyoEHINLVmYiIwcyZ9v3mTjpObw92ynu+8Azz1lLLe15fq/c47xteVHxg6FDhyBHjjDWVdfgm1BJjXtaBZPjnOJ8MwTMHGLvGZmJgIP5nz8T8OHDiAWrVqITAw0LDuqaeewo0bN7JXQydh7969Rn81atTQLKclPgHKQqS2Wkono/HjMz/vxInGcQ/T03N3uFtdTxn5qm5d5bvpdeUnpID39MxfIkctPr286K8gweKTYRimYGOX+PT19TUSlX///Tfi4+PRsGFDs7J5nT80t7EkPtXORzduZO1kBCjD3TNmKOvc3XNvuNvUGUorvaY1TlXOSn4LMC9R17egWT0BFp8MwzAFHbvEZ61atbBv3z6cP38eALBw4ULodDo0a9bMqNylS5dQsmTJ7NcyHxERQcPk77xjvk06H1mThUg93F2vHtCtG63398+94W5TZygpqE1FZlZOVc7GsmVAhQrKHNb8Jj7ffReYPJleDCZMyOvaOB4WnwzDMAUbu+J8DhgwADt27EBERATKly+P48ePIzg4GC+++KKhzIMHD3D06FG0b9/eYZXND1SqZJw6U40tWYhMY3+aZjgaP966GKLZwTRDU6lS9GnqGa7O0PTZZzlTF0eSlETB8qWYzm/is0MH+iuoBAUp31l8MgzDFDzssnx269YNEyZMQHp6Oo4dO4ayZcti5cqV8JQxbAD88ssvSEtLM7OGPunILERZORmZDsubis/cGO6WGZqkdTU0lETb7dvG5bLK0ORsSEGTkgIEBhqLHSbveekl6tcAi0+GYZiCiF3iEwA++ugj3Lt3D//++y8uXryIxo0bG21v1aoVYmJi0Ldv32xX0tmJjQXq16c5mBcuUO72S5fsP55W7M+dO+nzyBFlXU4Pd2s5E5UrZx7ax1rnKWdBviO1aEE56rdvz9v62Mrly8CHHwJhYcCWLXldm5zhtddoekT37nldE4ZhGMbR2C0+AcDDwwNBFsxGZcqUQc2aNXM0B7wzIOdmXr9OnwsWAM2bGzsJ2cq8eWT5UQ/Ly3T0L7+srJPD3XPn2n+uzHBUhiZnIz9nOAKA778HPv0UuHIF6Ns3f4W5spbatWkah+z3DMMwTMEhW+ITAE6dOoUFCxbgs88+w2+//WZYr9frkZpfn+42sGKFDufOAQcPkpXw6FFabyELqFWYDncDQFQUWVPr1lXW5cZwtyMyNDkbUnzmx9zuAPCfnx8AEv/5McxVZuzeTfOZX3opr2vCMAzD5AR2i89r167h+eefR/Xq1TFgwAB88MEHWLt2rWH7/Pnz4e3tje35bUzTBjIydBg92hVTpwIhIWT9272btmVHfGoNd3t50TCrmtwY7nZEhiZnQw67HzpEqTUXLcrb+thCYiLw++/Kcvv2+TPMVWY8ekT9f9267E1fYRiGYZwTu8RnfHw8mjVrhh07dqBq1aoYOHAghMnY38svvwwXFxcja2hB4+5db1SqJAxWvx49lKHn7IhPZxvuzk6GJmfE11fJ1rRrF3D1ap5WxyYmTqQXHclzz+WvMFfWoA61tGlT3tWDYRiGyRnsEp9TpkzB5cuXMXLkSBw7dgyzZs0yKxMQEIDq1atj79692a6kM6CV2/3ePU98/XWGweqn0wEy8dH9+9k7n7MNd9ubockZadAAOHsW6NmTlvPLXFWZdGDQIGVdQEDuJR3ILTjOJ8MwTMHGLvG5bt06hIWF4fPPP880g1H58uXxzz//2F05Zycg4LGZ1U8+LFetyp4jiLMNd9uTocnZSUykz/xwDeqkA9WqKetzM+lAbsHik2EYpmBjl/i8cuUK6tSpAxeXzHf38PBAfHy8XRVzNrRyuxcrlmJWTqbXvH07+44gzjbcbUuGpvyAnNIg89Q7M2pLs1osy7BXWvOE8ytq8akKHcwwDMMUEOwSn15eXnhghYfD1atX4efnZ88p8gUuLuZmpv79KfXh2LGOcQRxpuFuaY0NDc1/TkZqrl4FatZUYqc6u+XTdH5vmTL04hEeDpQtS2VyI+lAbqEWn7du5V09GIZhmJzBLvFZuXJlHDlyBElJSRbL3L17F8eOHUMNOQmygJKRQYHfY2MBvZ6CYo8ZQ2LBEY4gzjbcbU2GJmdHCOD4cWXZ2cWn6fzewEDqb6dPG2dnyumkA7mF2llv4cKCMZWAYRiGUbBLfHbt2hVxcXEYPnw49Hq9ZplRo0YhOTkZ3Qt4ipKHD4GICKB6dSA9XVnvyADwBW24O69RzyN0d3d+8amVdECLnE46kFscPAi4udH3GzcKxlQChmEYRsEq8dmiRQt88cUXhuVBgwahWrVqWLBgAZ555hlMnjwZAHDhwgVMnz4dzz77LJYuXYpatWqhT58+OVJxZ0EdqNzdnR6U1aoB0dGOCwBfUIa7nQW1+ExJAWrVyrOqWIVW0gEtciPpQE4jpxj8738koidOLBhTCRiGYRgFN2sK7dq1C2GqCOdeXl74448/0K1bN+zbtw8xMTEAFKccIQTq1auHtWvXwl09gasAohafgwYB8+eTBbR7dxI269c75jxyuJvJPmonltTU7MVkzQ3Gj6eMPytWkBXcEnI+sKP6XF4gpxhMnUovWUIAv/5K66dOzevaMQzDMI7AKvGpRcmSJbF371788ccf2LBhAy5evAi9Xo/SpUsjMjISHTt2zDQMU0FAr9cZ5QefO5fmfQLA5csU/sbZh3SfRNSWz8ePnV98quf9tmun3aekxXDatPzb52Qc0x07KI1sWhoQE0NW/7p1KY99fp5rzDAMwxB2i09JmzZt0KZNG0fUJd9x5463keVTPf21fHmK9Tl5cv4VAwUVtTG+QwclJaoz06MHzf20ZAHM7aQDjkYdx7RKFXLiAyhZgzqO6Y4dPO2EYRgmv2N3bncGuHfPE3//rb3t++8LhudxQUQtXvbsybt62IKzJR1wNCtW6AwhxNQvBzK3e0GKY8owDPOkw+IzGwQEPMYXX7hqbouIKHhpDwsSy5fTZ4kSeVsPW3C2pAOOIjnZDaNHuxpCiKnFpxTTBSmOKcMwzJOO1eJzyZIlcHV1tfnPzS3bI/tOgVZu96CgFFy/rkNgIA0VqvH0LHhpDwsKQgCff07fExPz171xpqQDjmLFinBUqiQMUwbU/zLUzmEFJY4pwzDMk47V4lMIYfdfQcXVVaBLFz3u3aP5nWqkxYaHC52Pn34Crl+n72lp+eveOFvSAUewZUsYhg3TG34zOh0wahTw+uvG1tyCEseUYRjmScdqs+QLL7yA999/Pyfr4tTs3bvXaLlx48a4c+ce1q1zQXg48PzzJAwSE4E6dZRy1ngqM7mH9AqPj6dlH5/8d2+k81FBSTrQuvVlfP11eXTsqLy0qcIKGygIcUwZhmEYG8RniRIl0KxZs5ysS77j7l1vVKkiMHq0Dh99BPzyC9CgAeBqMg00K09lJveQXuE3b9Kyp6cylJtf7o10PurXL387GUleeeUMRoyo8ETEMWUYhmHY4Shb3Lvnifr1Bdq3B/z9gUaNzIUnwMOFzoKMIzlrlrLOyyt/OobJpAP51clITaFC6fj884xMnYmkxTq/TzFgGIZhWHxmi4CAx9iwgcxOascIU3i4MO9Rx5GsWpWiEQDAN9+wY5gz8MorIlNnovwex5RhGIZRKBiu6HlEUFAKbt3KWnzycGHeY3oPZJajjAz6tDaFJZMzyKkE9eqZZzKScUyjo/P/FAOGYRiGLZ/ZwtVVoH17MpW5WGhJHi7Me7TugXxZkOlROY5k3lNQ45gyDMMwxlglPvV6PRYtWpTTdcmXVKtGT8nTp7W383Bh3qN1D3btos9Nm5R1HEcy7ymIcUwZhmEYY9jymU2k5ezs2YKZ9rAgMG8eWTTV92DwYPrs3VtZx45heU9BjGPKMAzDGMPiM5s8fkyf1arxcKGz0r8/OXypnYlmzgTu3QOaN1fWsWOYcyAt0AUljinDMAxjDIvPbFK/vsDQocDw4Txc6KxoZZnS6Sg8lhq+Z86BdD4KDeVRA4ZhmIIIe7tbSePGjY2Wjx8/jtDQULzwAsX5BCgn9YgRQNOmNFw4bRoPFzoD1mSZkk5JfM+cAxnHlGEYhil4sOXTgfBwofOSlTMRO4YxDMMwTO7Alk8r0crtHh8fj7t3Ab2ehnB9fApW2sOCBMeRZBiGYRjngC2f2WTUKFeEhlLaRqBgpT0saHAcSYZhGIbJe1h8ZhPp7Z5ZhiPGeeA4kgzDMAyTtzit+Lx27RoGDx6MChUqwNPTE0FBQWjTpg02bNiQ6X7btm1D27ZtERQUBG9vb1SuXBnjxo3Dw4cPc6SeLD7zFxxHkmEYhmHyFqcUn4cOHUKtWrXw7bffIiUlBZGRkahSpQp27tyJdu3aYbwFM9VXX32FVq1aYfPmzahatSrat2+PhIQETJ48GXXr1sXdu3cdXte0NPqUucIZ54cdwxiGYRgm73A68fno0SN06dIF8fHx6N69Oy5cuIC1a9diz549iIqKQmBgID7++GNs3brVaL+YmBiMGDECrq6u2LBhA/7880/88ssvuHDhAlq2bIkzZ87g7bffdnh92fKZ/+A4kgzDMAyTdzid+FyzZg2uXbsGf39/zJkzB97e3oZt9erVw0cffQQA+Pjjj432++yzzyCEQN++fREZGWlYX6hQISxcuBAuLi5YtWoVTltKwm4nLD7zJ+wYxjAMwzB5g9OJz0OHDgEAIiIi4G+aggbA888/DwCIiorCrVu3AACpqamGuaCvvvqq2T5ly5ZFo0aNAJC4dSQsPhmGYRiGYazH6cSndAwKDAzU3B4UFAQAEELgyJEjAICzZ88iOTkZAFC3bl3N/eT6mJgYh9a3Y0eBN94AypZ16GEZhmEYhmEKJE4XZD44OBgAcPHiRc3t6vWXLl0y+vT390cRC27LpUuXNirrKEaP1sPd3dWhx2QYhmEYhimoOJ34bNGiBSZNmoTDhw8jJiYGtWvXNto+Z84cw/fExEQAwIMHDwAAPj4+Fo9buHBho30ywzSPuxYyt3uadHdnAMDQHtwuxnC7aMPtYhluG224XbThdtGG20UbIQR0eeht65Tis2nTpti9ezc6dOiA2bNno2nTpoiLi8Ps2bOxdOlSuLu7Iy0tDS4ueT9rYNWqXXB1FfD2TocTVMdpMI1GwBDcLtpwu1iG20YbbhdtuF204XYx5v79+yhatGiend/pxCcArFy5Ep07d0ZUVBQ6dOhgtG3YsGHYu3cvoqOjDQ0nh9qTkpIsHlPOJfX19c3y/KZ53LWQud3ffTcScXE6HD2ahqefznK3Ak9aWhq2bt2KVq1awd3dPa+r4zRwu2jD7WIZbhttuF204XbRhttFmylTpuTp+Z1SfAYHB2PPnj3Ytm0bduzYgbi4OBQvXhwdO3ZE3bp1UapUKQBA9erVAQBhYWEASMk/ePBAc97ntWvXjMo6Cunt7uPjDu7XCu7u7vxD14DbRRtuF8tw22jD7aINt4s23C7G5OWQO+Ck4hOghmnVqhVatWpltP7ChQu4efMmAgMDUadOHQBAeHg4ChUqhOTkZERHR+O5554zO150dDQAGPZxFKmp9MmhlhiGYRiGYbIm381SnDp1KgCgf//+8Pgvp6WHhwdefPFFAMDy5cvN9rly5Qr27dsHAOjUqZPD6iIEkJpKbw8sPhmGYRiGYbLGKcXnqVOnzLzS09PTMXnyZMydOxcVK1bEuHHjjLaPHj0aOp0OixcvxubNmw3rk5OT8cYbbyAjIwNdunRB5cqVHVZPIZTvnNudYRiGYRgma5xy2H3evHmYO3cuIiIiEBISgsePH+Ovv/7C7du3UbFiRWzdutUsrFKdOnUwbdo0DB8+HG3btkWzZs0Mc0dv3ryJ8PBwozBNjkAIZc4EWz4ZhmEYhmGyxinFZ9u2bXH58mUcOXIE0dHR8PT0RHh4OEaMGIHBgwcb5XtX8+6776J69eqYNm0aDh48iKSkJJQpUwZjxozBmDFjLAagtxe2fDIMwzAMw9iGU4rP1q1bo3Xr1nbt+/zzzxvyv+c0Oh3Qs6ceGRkucOUkRwzDMAzDMFnilOIzv+DqKrBoUQbc3Z1y6izDMAzDMIzTweLTSkxTbsr0mgzDMAzDMIz1sMkuGwgBJCcDGRl5XROGYRiGYZj8AVs+rcQ05Wbjxo1x40YC/P3dUaYMcOVKHlWMYRiGYRgmH8GWz2wgQy1xmCWGYRiGYRjrYPGZDWSoJRafDMMwDMMw1sHiMxtIyyfH+GQYhmEYhrEOFp/ZgC2fDMMwDMMwtsHiMxvwnE+GYRiGYRjbYPGZDfR6+uRhd4ZhGIZhGOvgUEvZwN1dj06d9KhdmzU8wzAMwzCMNbD4zAY+Pun4+WdOr8kwDMMwDGMtrJoYhmEYhmGYXIMtn1ailds9JCTU4PHOMAzDMAzDZA1bPrPB3bve8PJyw+DBeV0ThmEYhmGY/AFbPq1EK7f76dMpEEIHV9c8qhTDMAzDMEw+gy2f2YDjfDIMwzAMw9gGi89swBmOGIZhGIZhbIPFZzbg3O4MwzAMwzC2weIzG7Dlk2EYhmEYxjZYfGYDnvPJMAzDMAxjGyw+s4GnZzpat9ajXLm8rgnDMAzDMEz+gEMtZYOgoEf4/XdOr8kwDMMwDGMtrJoYhmEYhmGYXIPFJ8MwDMMwDJNr8LC7lWjldk9Pr4KiRd3wyy9AZGQeVYxhGIZhGCYfweIzG+j1OqSk6ODC9mOGYRiGYRirYPFpJVq53Q8dygDAQeYZhmEYhmGshW122YCDzDMMwzAMw9gGi89swEHmGYZhGIZhbIPFZzZgyyfDMAzDMIxtsPjMBtLyyXM+GYZhGIZhrIMdjrKBt3c6atbUo0gR1vAMwzAMwzDWwOIzG5Qp8wC7dnF6TYZhGIZhGGth1cQwDMMwDMPkGiw+GYZhGIZhmFyDxWc2OHMmAKVLuyE9Pa9rwjAMwzAMkz/gOZ9WopXbXa+vgX//BVxd86hSDMMwDMMw+Qy2fGYTT09Ap8vrWjAMwzAMw+QP2PJpJVq53aOiOMA8wzAMwzCMLbDlM5uw+GQYhmEYhrEeFp/ZhLMbMQzDMAzDWI/Tis+rV69i8ODBCA8Ph7e3N7y8vFCuXDn07t0bx44d09wnPj4eY8aMQZUqVeDt7Y2AgAA0bdoUP/zwQ47Vky2fDMMwDMMw1uOUcz4PHDiAVq1a4cGDBwgJCUHr1q3h6uqKo0ePYunSpVi+fDmWL1+Obt26Gfa5ePEiWrRogStXriAwMBAtW7ZESkoK/vrrL+zZswfbt2/H4sWLoXOgd5CXVzqqVxcA2OOIYRiGYRjGGpzS8tm/f388ePAA/fv3x6VLl7Bu3TqsXr0a58+fxwcffID09HT0798fjx49MuzTo0cPXLlyBc2bN8e5c+fw+++/Y/v27Th27BgqVKiAJUuWYMGCBQ6tZ7lyifjllwyHHpNhGIZhGKYg43TiMy4uDsePHwcAfPrpp3B3dzdsc3FxwYQJE+Dt7Y379+/j77//BgDs378fBw8ehKurKxYsWICAgADDPhUrVsT06dMBAJ988gmEELl4NQzDMAzDMIwapxOfnjZMogwKCgIAHDp0CAAQFhaGChUqmJV7/vnnAQDXrl3DwYMHHVBLhmEYhmEYxh6cTnwWLlwYTZo0AQB88MEHSEtLM2zT6/WYMGECUlJSEBkZidKlSwMAHj58CAAIDAzUPGahQoXg7e0NADh8+LDD6nrunD/eeIPTGzEMwzAMw1iLUzoczZ8/H23btsW8efOwYcMG1K1bF66uroiJBWurHQAAJKVJREFUicGNGzfQq1cvzJo1y1A+ODgYAHDp0iXN4926dQspKSmZlrGH9HQXxMU57HAMwzAMwzAFHqcUn+Hh4di/fz969eqFLVu24MaNG4ZtTz/9NJo3bw5fX1/Duueeew46nQ537tzB2rVr8dJLLxkdb86cOYbviYmJWZ7fNI+7FjQvtQbc3fVIS2OnI4m0VKst1gy3iyW4XSzDbaMNt4s23C7acLtoI4RwaPQfW3FK8RkVFYXOnTvDzc0Ny5cvR4sWLeDh4YGoqCgMHz4cb7zxBqKiorBw4UIAQIUKFdCzZ0/88MMP6NevHx4+fIjIyEikpKRg2bJlmDx5Mtzd3ZGWlgYXF8fONIiPv4WNGx03lF9Q2Lp1a15XwSnhdtGG28Uy3DbacLtow+2iDbeLMffv30fRokXz7Pw64WTu3/fv30elSpVw9+5d7N+/H/Xr1zfafvHiRVSvXh3JycnYsWMHnnvuOQBAUlISevbsibVr15od8+WXX0ZqairWrl2LsWPHYtKkSdmup8zt/tpru7B4sVM1YZ6SlpaGrVu3olWrVkaRCp50uF204XaxDLeNNtwu2nC7aMPtok2zZs3g4uKCvXv35sn5nc7yuWHDBty5cwcVKlQwE54AUL58edSvXx87d+7Etm3bDOLTx8cHa9aswf79+7F582bcvHkTRYsWRZs2bfDcc8+hYcOGAIDq1as7tL7e3jq4uztdM+Y57u7u/EPXgNtFG24Xy3DbaMPtog23izbcLsbk5ZA74ITi8+rVqwBgNKfTFD8/PwCUTtOUZ599Fs8++6zRugcPHuDo0aNwc3MziFVHwbndGYZhGIZhrMfpQi2FhIQAAE6fPo2EhASz7WlpaThy5AgAoFy5clYdc/bs2UhJSUG3bt1QvHhxh9XV0zMDpUo57HAMwzAMwzAFHqcTn5GRkfDx8UFKSgreeustQwxPAEhNTcW7776Lq1evwt3dHV27djVsu3DhAu7cuWN0LCEEFi1ahA8//BBFixbFtGnTHFrX8uUT8N57eocek2EYhmEYpiDjdMPuxYoVw5w5c9C3b1+sXLkSu3btQr169eDu7o7o6GjcuHEDLi4umDlzJsqXL2/Yb/369Rg1ahTq1KmDMmXKQAiB6OhoXLlyBcHBwdi0aRNKlizp0LpeuuSLkyeBWrUceliGYRiGYZgCi9NZPgGgZ8+eiI6ORp8+fVCkSBFs374dmzZtgpubG1577TXs378fb7/9ttE+jRo1QpcuXXDnzh1s3LgRmzdvhq+vLz788EOcOXMGderUcXg909NdMGyYK5wrXgDDMAzDMIzz4nSWT0nNmjWxePFiq8vXq1cPK1asyMEamaPTCRw7psOKFUCPHrl6aoZhGIZhmHyJU1o+8wtpaa7o0EFgxAjgwYO8rg3DMAzDMIzzw+Izmzz7rB6VKgETJ+Z1TRiGYRiGYZwfpx12dzZM873L3O6ensC33wJ16wJ9+wJVq+ZN/RiGYRiGYfIDbPnMJp6eJDjfeQcYPBjsfMQwDMMwDJMJbPm0EtP8pzK3u8xwNH48ULky2PmIYRiGYRgmE9jymU08PenT1xeYOhXsfMQwDMMwDJMJLD6zgZubHkWKKMs9eoCdjxiGYRiGYTKBxWc2eOqp+2jUSJnkqdOR5XPu3DysFMMwDMMwjBPD4tOBCAFMmwYMGJDXNWEYhmEYhnFO2OHIgfz0E3DuHLB+fV7XhGEYhmEYxjlh8ekgEhOBkSPJ8qmeB8owDMMwDMMo8LC7g5g4EQgPB155Ja9rwjAMwzAM47yw5dMBxMYCs2cD0dHkdMQwDMMwDMNow5bPbCIEZTYaNIhTazIMwzAMw2QFWz6tRCu3e2hoKFas0LGTEcMwDMMwjJWw+MwGaWk6jB7tyk5GDMMwDMMwVsLi00q0crsfOKBHo0YCr7zCEz0ZhmEYhmGsged8ZgM3Nz2+/jqDnYwYhmEYhmGshMVnNihXLpGdjBiGYRiGYWyAxSfDMAzDMAyTa7D4ZBiGYRiGYXINFp8MwzAMwzBMrsHik2EYhmEYhsk1WHwyDMMwDMMwuQaLT4ZhGIZhGCbX4CDzVmIpvSbDMAzDMAxjPWz5ZBiGYRiGYXINtnxaiVZ6zfj4+DyqDcMwDMMwTP6ELZ8MwzAMwzBMrsHik2EYhmEYhsk1WHwyDMMwDMMwuQaLT4ZhGIZhGCbXYPHJMAzDMAzD5BosPhmGYRiGYZhcg8UnwzAMwzAMk2uw+GQYhmEYhmFyDRafDMMwDMMwTK7BGY6shHO7MwzDMAzDZB+2fDIMwzAMwzC5Bls+rYRzuzMMwzAMw2QftnwyDMMwDMMwuQaLT4ZhGIZhGCbXYPHJMAzDMAzD5BpOKz6vXr2KwYMHIzw8HN7e3vDy8kK5cuXQu3dvHDt2THOfuLg4jBkzBtWrV4ePjw88PDwQGhqKbt26Yffu3bl8BQzDMAzDMIwpTik+Dxw4gGrVquHbb79FUlISWrdujbZt20Kn02Hp0qWoW7cuVq5cabTPhQsXUKNGDXz++ee4efMmmjdvjo4dO8LX1xe//vormjVrhunTp+fRFTEMwzAMwzCAk4rP/v3748GDB+jfvz8uXbqEdevWYfXq1Th//jw++OADpKeno3///nj06JFhn+HDh+Off/7Biy++iCtXrmDDhg1YuXIlTp06hblz5wIA3n//fVy/fj2vLothGIZhGOaJx+nEZ1xcHI4fPw4A+PTTT+Hu7m7Y5uLiggkTJsDb2xv379/H33//bdi2Y8cOAMD48ePh4+NjdMz+/fvjqaeeQnp6Og4dOpQLV8EwDMMwDMNo4XTi09PT0+qyQUFBhu9eXl4278MwDMMwDMPkLk4nPgsXLowmTZoAAD744AOkpaUZtun1ekyYMAEpKSmIjIxE6dKlDdsiIyMBABMnTkRycrLRMefPn49z586hevXqePbZZ3PhKhiGYRiGYRgtdEIIkdeVMOXMmTNo27YtLl68iJCQENStWxeurq6IiYnBjRs30L17d8yaNQu+vr6GfW7fvo0XX3wRhw8fRmBgIBo0aIBChQrh5MmTOH36NCIjIzF//nyULFkyy/Ob5nHX4uDBg3Bzc0OtWrWg0+mydb0FCSEE7t+/D39/f24XFdwu2nC7WIbbRhtuF224XbThdtHmxIkT8PHxwc2bN/Pk/E6ZXjM8PBz79+9Hr169sGXLFty4ccOw7emnn0bz5s2NhCcAFC9eHLt27cLAgQPx448/YsOGDYZtpUuXRosWLVCsWDGH1TEjIwMAzUO1BTmftUaNGgVyvxMnTgAAihYtmivnyy/7cbtoU9DbJTv7FvS24XZx7H7cLtpwu2jz6NEjpKen27SPI3FKy2dUVBQ6d+4MNzc3TJ06FS1atICHhweioqIwfPhwnDt3Dv369cPChQsN+5w+fRrt27fHnTt38Nlnn6F9+/bw9fVFTEwMRo4ciejoaLRq1QqbNm2Cq6trtusoraOmOd95P96P9+P98vKcvB/vx/vxfjm1n6Nwujmf9+/fR6dOnXDnzh2sXr0aPXr0QPHixREQEIB27dph8+bNKFSoEBYtWoSdO3cCANLT09GlSxecP38e8+fPx8CBAxEaGgpfX180a9YMW7ZsQYkSJbB161YsXbo0j6+QYRiGYRjmycXpxOeGDRtw584dlC9fHvXr1zfbrl6/bds2ABSU/tSpU/D09ETnzp3N9gkICDA4JMl9GIZhGIZhmNzH6cTn1atXAcBsTqcaPz8/AEB8fLzRPoUKFbI4pG66D8MwDMMwDJP7ON2cz6VLl6J3797w9vbGzZs3DaJRkpaWhooVK+Lq1auYMmUK3nvvPezevRvNmjUDAJw9exZPPfWU2XEbNmyI/fv3Y+DAgZg9e3a265nX8yWcFW4XbbhdtOF2sQy3jTbcLtpwu2jD7aJNXreL01k+IyMj4ePjg5SUFLz11lt4+PChYVtqaireffddXL16Fe7u7ujatSsA4Nlnn0VISAgA4M0338SdO3cM++j1enz++efYv38/AKBHjx65eDUMwzAMwzCMGqcLtVSsWDHMmTMHffv2xcqVK7Fr1y7Uq1cP7u7uiI6Oxo0bN+Di4oKZM2eifPnyAAB3d3csXboU7du3x+7du1GxYkXUr18fRYoUwbFjx3DhwgUAwNixYw0B7BmGYRiGYZjcx+nEJwD07NkT1atXx9dff43du3dj+/btEEKgZMmSeO211/C///0PzzzzjNE+LVq0wIkTJzB9+nRs374de/fuRXp6OooVK4ZOnTph4MCBaNWqVR5dEcMwDMMwDAM4qfgEgJo1a2Lx4sU27VO+fHnMmjUrh2rEMAzDMAzDZBenczhiGIZhGIZhCi5O53DEMAzDMAzDFFxYfDIMwzAMwzC5BotPhmEYhmEYJtdg8ckwDMMwDMPkGiw+GYZhGIZhmFyDxSfDMAzDMAyTa7D4tIOVK1eiefPmCAgIgI+PD2rWrIkvvvgCaWlpeV21HCEtLQ3bt2/HqFGjUK9ePfj7+8Pd3R0lSpRAhw4dsGHDBs39JkyYAJ1Ol+nf6dOnc/lqHEufPn2yvMZHjx5p7nv48GF069YNxYsXh5eXF8qVK4chQ4bg33//zeWrcCyXL1/Osk3k3+7duw37FZT+cubMGXzzzTfo06cPqlevDjc3N+h0Onz66adZ7rtt2za0bdsWQUFB8Pb2RuXKlTFu3DijNMNanD9/Hn369EFoaCg8PT0RGhqKPn364OLFi466rGxja7vo9Xrs27cPH330ERo3bozAwEC4u7sjKCgIrVq1wrJly2ApUuD333+fZV/avHlzTl6u1djTX7L7WymI/QWA1f93li5darRffukv9j6LJc70/8Vpg8w7K8OGDcOMGTPg5uaGFi1aoHDhwtixYwfef/99rF+/Hlu2bIG3t3deV9Oh/Pnnn4bsUCVKlEDjxo3h4+ODU6dOYf369Vi/fj369++POXPmQKfTme1fs2ZN1KpVS/PYfn5+OVn1XKNRo0aoWLGi5jZXV1ezdb/++it69OiB9PR01KtXD+XKlUN0dDRmzZqFlStXYu/evRaP5+wULlwYvXv3trj91KlTOHToEIoUKYKIiAiz7fm9v3z33XeYMWOGzft99dVXGD58OHQ6HZo0aYLixYtjz549mDx5MlatWoW9e/ciKCjIbL+oqCi0bt0aycnJqFq1Kho3bozY2FgsWbIEv/76K7Zt24YGDRo44tKyha3tcvHiRTRq1AgAULRoUdStWxcBAQG4ePEitm3bhm3btmHFihVYtWoVPDw8NI9RoUIFNG7cWHNbSEiI7ReRA9jbXwD7fisFtb8AyPT/ztWrV7Fz507odDo0a9ZMs4yz95fsPIud7v+LYKxmzZo1AoAoXLiwOHz4sGH9nTt3RPXq1QUAMWLEiDysYc6wfft20aVLF7F7926zbStWrBCurq4CgFiyZInRtvHjxwsAYvz48blU09ynd+/eAoBYvHix1fvcuHFDFCpUSAAQc+fONaxPT08XPXv2FABEvXr1hF6vz4Ea5z2RkZECgHjrrbeM1heU/jJ//nwxcuRIsWzZMvH333+LXr16CQDik08+sbjPkSNHhE6nE66urmLjxo2G9UlJSaJly5YCgOjSpYvZfklJSaJUqVICgBgzZozRtjFjxggAonTp0iI5OdlxF2gntrbL+fPnRYsWLcSmTZtEenq60bZdu3YJHx8fAUBMnDjRbN/FixcLAKJ37945cSkOxZ7+Yu9vpSD3l6wYOHCgACBatWplti2/9Bd7n8XO+P+FxacN1KtXTwAQn376qdm2PXv2CADC09NT3L9/Pw9ql3e88cYbAoBo2bKl0fqCIiYywx7xOWrUKAFAPP/882bbHjx4IPz8/AQAsXnzZgfW1Dm4fv26cHFxEQDEX3/9ZbStoPYX2Ucye2h269ZNABBvvvmm2bbLly8b2uzvv/822vbtt98KAKJSpUoiIyPDaFtGRoaoVKmSACDmzJnjmItxINa0S2Z88sknAoCoUKGC2bb8Iia0sKZd7P2tPKn9JSUlRfj7+wsAYsWKFWbb83N/UWPpWeyM/194zqeV3LhxA4cOHQIAvPrqq2bbGzdujNKlS+Px48fYuHFjblcvT6lduzYA4Nq1a3lck/zBmjVrAGj3o8KFC6NDhw4AgNWrV+dqvXKD77//Hnq9HlWrVkX9+vXzujpOQWpqqmGullafKFu2rGH4WfYdiVx+5ZVX4OJi/O/cxcUF3bt3B1Aw+xL/37GdJ7W/rFq1Cvfv30fRokXx0ksv5XV1cgyt34Sz/n/hOZ9WEhMTA4DmHpUrV06zTN26dXHt2jXExMSgR48euVm9POXcuXMAgJIlS2puP3LkCEaPHo34+Hj4+fmhdu3aaN++PYoUKZKb1cxRdu7ciRMnTuDBgwcIDAzEM888g7Zt28LT09Oo3IMHD3D+/HkA1F+0qFu3Ln744QdDnytIfP/99wCAN954w2KZJ6G/qDl79iySk5MBZN4n9uzZY9Yn5HJm+6nLFSSy+r8DkKPEBx98gH///ReFCxdGtWrV0KFDB825bfkRW38rT2p/WbRoEQCgZ8+eZv+T1eT3/qL1m3DW/y8sPq3k0qVLAIAyZcpYLFO6dGmjsk8Ct27dMgiKLl26aJaRE6HV+Pn5YebMmXj99ddzuoq5gqn3JED/ABYtWoQXXnjBsO7y5cuG75b6UkHtR3/++SfOnz8PDw8P9OrVy2K5J6G/qJH32d/f36Jo0OoTDx48QFxcHICs+9KdO3eQlJQEHx8fh9U7L0lOTsbMmTMBWP6/A5CzRFRUlNE6Ly8vTJgwAe+//36O1jE3sOW38qT2l8uXL2Pnzp0AMn/pBfJ3f7H0LHbW/y887G4lDx48AIBMG7dw4cIAgMTExFypU16Tnp6Onj17IiEhAdWrV8eAAQOMtleoUAGTJ09GTEwM4uPjER8fj71796Jdu3ZISEhA7969sWzZsjyqvWOoWbMmZsyYgdjYWCQmJuL27dvYsmULGjZsiJs3b6JDhw7YtWuXobzsR4DlvlRQ+5G0PliyJDwJ/UULe/+32NKXTPfN77zzzju4dOkSSpUqhbFjx5ptL1GiBMaNG4cDBw7gzp07SExMxKFDh/D666/j8ePHGD16NCZPnpwHNXcM9vxWntT+snjxYgghULduXdSoUUOzTH7vL5k9i532/4vNs0SfUCZNmiQAiEaNGlksM3bsWAFAtG7dOhdrlnfIyc2BgYHizJkzNu07ZMgQAUAUK1ZMPH78OIdqmHfo9XrRsWNHAUDUrFnTsD4qKkoAEABEWlqa5r5btmwRAISHh0cu1TbnSUhIMHj4q70trSU/95esHCWWLVsmAIiQkBCLx5g3b55h4r/kxo0bhr507tw5zf3Onj1rKPPPP/9k70IcjL0OJB9//LEAILy8vMTevXttPu+0adMMzqG3bt2yef+cJruOWJZ+K09if8nIyBBlypQRAMTs2bPtOq+z9xchMn8WO+v/F7Z8Wok0VyclJVksIwO1+vr65kqd8pKhQ4di4cKFCAgIwNatW1GpUiWb9p8wYQJcXV1x584dHDhwIIdqmXfodDpMnDgRAHDs2DHDBHD1sIelvlQQ+9GKFSuQnJyM0NBQtGnTxub9C3J/sfd/iy19yXTf/Mr06dPx0UcfwdPTE2vWrDE4StjC0KFDERQUhMePH2PLli05UMu8xdJv5UnsL9u2bcPVq1fh7e2t6WxjDc7eX7J6Fjvr/xcWn1YSFhYGIHPPSrlNli2ojBgxAjNnzoS/vz+2bNli8LCzhaJFiyI4OBgAcP36dUdX0SmoUqWK4bu8xrJlyxrWXb16VXO/gtiP5JB7nz59zLwmraEg9xd5n+/fv2801KVGq08UKVIERYsWBZB1XwoKCsr38/e++eYbjBgxAh4eHli1apXRXGpbcHV1xVNPPQWg4PUlwPJv5UnrL4Dyf6dLly52J6hw5v5izbPYWf+/sPi0EnlT4+LiLDqCREdHAwDq1KmTa/XKbd577z1Mnz4dfn5+2LJli0UvuKzIyMhAQkICABRYL2Y5WRtQrtHX19eQuUj2F1MKWj86deoUDhw4AJ1Oh759+9p1jILcX8LDw1GoUCEAtvcJuVzQ+9K3336L//3vfwbh+eKLL2brePK3WdD6EpD5b+VJ6S8AEB8fj7Vr1wLI2tEoK5yxv1j7LHbW/y8sPq0kNDQU9erVAwAsX77cbPvevXtx7do1eHp6om3btrldvVxh9OjR+PLLL+Hn54etW7ca2sMefvvtNyQnJ0On09ktYJ2dFStWACDBGR4ebljfqVMnANr96OHDhwbv1c6dO+dCLXOehQsXAgCee+45lC9f3q5jFOT+4uHhYRBTWn3iypUr2LdvHwCl70jk8ooVK6DX64226fV6/PzzzwDyd1+aM2cOBg8ebBCe7dq1y9bxjhw5grNnzwIAnnnmGUdU0anI7LfyJPQXybJly/D48WNUqFDBYjpNa3DG/mLLs9hp/7/YNEP0CcdSes27d+8W6PSaQggxbtw4AUD4+/uLgwcPZln+ypUr4ocffhApKSlm29asWSOKFi0qAIiePXvmRHVzhZiYGLFu3Tozx6GMjAyxYMEC4eXlJQCIDz74wGi7Or3mvHnzDOvT09MNKeQKSnrN1NRUERwcLACIZcuWWSxXkPuLNY4Shw8fNqS/27Rpk2G9Lenvxo4da7RNOkCGhoY6RbpEU6xpl3nz5gmdTic8PDzE+vXrrTpuUlKSmDVrlkhMTDTb9ueff4qwsDABQDRu3NjuuuckWbVLdn4rBb2/qKlVq5YAICZNmpRpufzWX2x9FgvhnP9fdEIIYbtkfXIZOnQoZs6cCXd3d7Rs2RI+Pj7Yvn077t+/j0aNGmHr1q3w9vbO62o6lN9++w0dO3YEQEFlq1atqlkuKCgIU6dOBQAcPXoUtWvXRuHChVG7dm2EhIQgJSUFp06dMgTCfe655/Dbb78ZhWvIT6xduxadOnVCQEAA6tSpg+LFi+P+/fuIjY01zJHp0aMHli5dCjc345C6K1euRI8ePZCRkYH69esjLCwMhw4dwsWLF1G8eHHs3bvXMDyfn1mzZg06d+4Mf39/3Lx5E15eXprlClJ/OXLkCN555x3D8oULF3D37l2EhoYiJCTEsH7NmjVGwaC/+uorDB8+HDqdDs2aNUNwcDD27NmDmzdvIjw8HHv37tUMURUVFYXWrVsjOTkZ1apVQ7Vq1RAbG4vY2Fj4+Phg27ZtaNCgQc5etBXY2i5Hjx5FnTp1IIRA5cqVM82IJeMbAjS3LSAgAJ6enqhduzbKlCmD9PR0nD17FrGxsQCA6tWr448//sg0QH1uYU+7ZOe3UlD7i5qYmBjUqVMHrq6uuHr1KkqVKmXxPPmpv9jzLJY43f8Xm+UqI37++WfRtGlT4evrK7y9vUW1atXE559/nu9CwFiLzHub1V/ZsmUN+9y9e1e8//77okWLFqJMmTLCx8dHuLu7i5IlS4p27dqJ5cuXm+WKzW9cvHhRDBs2TDRu3FiEhIQILy8v4enpKcqUKSO6du0qNmzYkOn+0dHRonPnzqJYsWLCw8NDlC1bVgwaNMhpw3nYQ7t27QQA8c4772RariD1l507d1r1e7l06ZLZvlu3bhUvvPCCKFq0qPD09BRPPfWUGDNmjKZVRs25c+fE66+/LkqVKiXc3d1FqVKlxOuvvy7Onz+fQ1dpO7a2i7XlTR9jjx8/Fh9++KGIjIwU5cqVE0WKFBFubm6iWLFi4vnnnxdz5851qv/VtraLI34rBbG/qBk8eLAAINq2bZvlefJTf7HnWazGmf6/sOWTYRiGYRiGyTXY4YhhGIZhGIbJNVh8MgzDMAzDMLkGi0+GYRiGYRgm12DxyTAMwzAMw+QaLD4ZhmEYhmGYXIPFJ8MwDMMwDJNrsPhkGIZhGIZhcg0WnwzDFHjCwsKg0+mMMuEUVL7//nvodDr06dMnr6vCMAyjCYtPhmGeSPKjSLt8+TJ0Oh3CwsLyuioMwzB245Z1EYZhGCa/0KlTJzRo0AB+fn55XRWGYRhNWHwyDMMUIPz8/Fh4Mgzj1PCwO8MwTxxhYWHo27cvAGDJkiXQ6XSGv+bNm5uV//XXX/HCCy+gWLFi8PDwQEhICHr27IlTp06ZlVUPjWdkZGD69OmoXbs2ChcuDJ1OZyh36tQpjB8/Ho0aNUJISAg8PDwQGBiI559/Hr/88ovZcfv06YNy5coBAK5cuWJUZ/Vxs5pOcPDgQbz88ssoVaoUPDw8EBwcjPbt22Pr1q2a5fv06WOYL3vp0iX06tULJUqUgKenJypUqIAPPvgAjx8/ttjWDMMwprDlk2GYJ46uXbvir7/+QlRUFCpUqIDGjRsbtlWuXNnwPT09Ha+99hp++eUXeHp6IiIiAiEhITh79iyWLVuG1atXY/Xq1XjhhRfMziGEQOfOnbF582Y0adIEVapUwcmTJw3bp0+fjoULF6Jy5cqoXr06/P39cfXqVezcuRPbt2/HX3/9henTpxvKN27cGA8fPsSqVavg4+ODrl272nzd8+fPx9tvvw29Xo/atWujefPmuHLlCn7//Xf8/vvvmDBhAsaPH6+579GjRzF06FAEBASgWbNmiI+PR1RUFCZNmoSTJ09izZo1NteHYZgnFMEwDFPAKVu2rAAgFi9ebFi3ePFiAUD07t3b4n5jx44VAET9+vXFxYsXjbatXLlSuLq6ioCAAHHv3j3D+kuXLgkAAoAIDQ0VZ86c0Tz2rl27xIULF8zWnz59WoSGhgoA4sCBA0bb5LHLli1rsc6Wruv48ePCzc1N6HQ6sXTpUqNtGzduFB4eHgKA2LJli9G23r17G65n3LhxIj093bDtxIkTwsfHRwAQ+/bts1gnhmEYNTzszjAMo0F8fDy++uoreHl5YdWqVYYhb0nXrl0xYMAA3Lt3Dz/++KPmMSZPnoxKlSppbmvWrBnKly9vtj48PBwffvghABrudxQzZsxAeno6OnXqhF69ehlti4yMRP/+/QEAX375peb+ERER+OSTT+Dq6mpYV61aNcOxtm3b5rC6MgxTsOFhd4ZhGA127tyJlJQUtGzZEiEhIZplmjdvjtmzZ2Pfvn0YPHiw2fYuXbpkeo6HDx9i06ZNiImJwd27d5GamgoAuHnzJgDgzJkz2bwKhV27dgGAxbmgb7zxBmbNmoU9e/YgIyPDSGQCQLt27YzmlkqqVKkCALhx44bD6sowTMGGxSfDMIwGFy9eBABs375dU3SpuXPnjtm64OBgFCpUyOI+69evR9++fREXF2exTGJiopW1zRopDk0tuJIKFSoAAB49eoS4uDgEBwcbbS9Tpozmfr6+vob9GIZhrIHFJ8MwjAZ6vR4AULFiRTRq1CjTsmonJYm3t7fF8jdu3ED37t2RkpKC9957D6+99hrCwsJQuHBhuLi4YMuWLWjTpg2EENm7CAfi4sKztBiGcQwsPhmGYTQoXbo0AJqD6ei0nOvXr0dKSgo6deqEKVOmmG0/d+6cQ88HACEhIbhw4QIuXryIatWqmW2Xll4vLy8ULVrU4ednGIaR8KsswzBPJB4eHgAonJIWLVu2hIeHB3bt2oV///3XoeeOj48HAJQtW9ZsmxACy5cv19wvqzpnhoxfaklIL1q0CADQpEkTuLmxXYJhmJyDxSfDME8koaGhAKAZKB4AihcvjiFDhiApKQnt27fHiRMnzMo8fvwYv/32G06fPm3TuaWTzq+//mpwLgKAjIwMfPTRR9i3b5/mfjLI/a1btwwC1lqGDh0KNzc3rF271sw7f8uWLZg7dy4AYOTIkTYdl2EYxlb49ZZhmCeSBg0aoFSpUoiJiUGdOnVQvXp1uLu7Izw8HKNGjQIAfP7557h58yaWL1+OWrVqoWbNmihfvjzc3Nxw/fp1HD16FElJSdi0aZPmvE9LtG/fHhERETh8+DAqVaqEZs2awcfHBwcOHMA///yD999/X3M43t3dHR06dMCvv/6KWrVqoXHjxganpgULFmR6zurVq+Pbb7/FwIED0atXL3z11VeoXLkyrly5gn379kEIgQkTJqB169Y2tCLDMIztsPhkGOaJxMPDA3/88QfGjRuH/fv349ixY9Dr9WjWrJlBfLq5uWHZsmXo2bMnFixYgAMHDiA2NhY+Pj4oWbIk2rdvjw4dOqBp06Y2ndvNzQ27du3CZ599hlWrVmH79u3w9fVFw4YNsWrVKjx48EBTfALA3LlzERgYiE2bNuHXX39FWloagKzFJwD0798fNWvWxNSpU7F3714cP34cfn5+aNu2LYYOHYpWrVrZdB0MwzD2oBPO5E7JMAzDMAzDFGh4zifDMAzDMAyTa7D4ZBiGYRiGYXINFp8MwzAMwzBMrsHik2EYhmEYhsk1WHwyDMMwDMMwuQaLT4ZhGIZhGCbXYPHJMAzDMAzD5BosPhmGYRiGYZhcg8UnwzAMwzAMk2uw+GQYhmEYhmFyDRafDMMwDMMwTK7B4pNhGIZhGIbJNVh8MgzDMAzDMLnG/wHo2t3/AMcuSgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -787,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -799,13 +720,23 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArEAAAH4CAYAAABdZbUUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbP0lEQVR4nO3deXxU1f3/8fcEQggJJEJYHRbZgrIpBqUyLEJAAUUBWaQCAf2pdauFLgSLuCDUVtyrYssSRGQxoChKCYjUgVZBAiFaDAgICMoyBbIgZDm/P+jMlzGTZbLNXPJ6Ph55wL3nnHs/95NM8snJmXttxhgjAAAAwEJCAh0AAAAA4C+KWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihiAQAAYDkUsQAAALCcoC5iz58/r5dfflkOh0P169dX7dq1ZbfbNWjQIC1btsznmPXr12vw4MGKiYlReHi4OnTooMcee0xZWVnFnmvv3r1KSEiQ3W5XWFiY7Ha7EhIStG/fvsq4NAAAAJSDLVgfO3v48GHddNNN+vrrrxUTE6MePXooIiJChw4d0o4dOzRo0CC9++67XmNeeOEFTZ48WTabTb169VLjxo312Wef6YcfflBsbKycTqdiYmIKnWvz5s0aOHCgcnJy1LFjR3Xq1Enp6en66quvFBERofXr16tHjx5VdekAAAAoQVAWsWfPnlW3bt20e/duPfHEE5o2bZpCQ0M97Tk5OcrIyNDVV1/t2Zeamqprr71WISEh+uCDDzRo0CBP36FDh2rDhg0aMWJEocI3JydH7dq105EjR5SYmKhZs2Z52qZNm6bZs2erefPm+uabbxQeHl65Fw4AAIBSCcrlBLNnz9bu3bt17733asaMGV4FrCTVqVPHq4B1jzHGaOLEiZ4C1t133rx5CgkJUXJysnbv3u01buHChTpy5Ijat2+vmTNnerXNnDlT7du316FDh7Ro0aKKvUgAAACUWdAVsbm5uXr99dclSb/73e9KNeb8+fNas2aNJGns2LGF2lu2bKmePXtKklatWuXV5t4eM2aMQkK80xESEqLRo0dLklauXOnHVQAAAKAy1Qx0AD+3fft2nThxQs2aNVPbtm21a9curVy5UkeOHNFll12mXr16adCgQV4FZ0ZGhnJyciRJcXFxPo8bFxenzz77TKmpqV773dvFjbu4HwAAAAIv6IrYtLQ0SZLdbtfUqVP15z//WRcv23322Wd1zTXX6L333lOLFi0kSfv375ckRUdHq27duj6P27x5c6++kpSZmamTJ09KkudYRY07fvy4srOzFRERUZ7LAwAAQAUIuiLWXVSmpqbqiy++0IMPPqhHHnlETZo08WynpqZqyJAh2r59u0JDQ5WZmSlJxRaYkZGRkqQzZ8549rnHFTfWPc49tqQi1uFwlHCFF2abo6Ki1KZNmxL7AgAABINvv/1W9evX11dffRXoUCQFYRHrnnXNzc3VnXfeqVdffdXTFh8fr5SUFMXGxio9PV1Lly7VuHHjAhVqmeXl5en06dNyuVyBDgUAAKBUTp8+HegQvARdEXvxcoD77ruvUHuLFi00ZMgQJScna/369Ro3bpxnTHZ2dpHHdT/soF69ej7PVdTYix+ScPHYojidzhL7OBwOuVwubdu2rdCdF6qz3NxcpaSkaMCAAeTlIuTFt2qXl6ioUnXLDQ9Xyvz51ScvpVTtvl5Kibz4Rl5869OnT6E3wQdS0BWxrVu39vl/X32OHj0qSWrVqpUk6dSpU8rMzPS5LvbQoUNefaULRWz9+vXlcrl08OBBde3atchxMTExFb4eNjQ0lBeHD+TFN/LiW7XJy9mzfnWvNnnxE3nxjbz4Rl682Wy2QIfgJXjK6f/p1q2bJ0knTpzw2ce9371eNTY2VnXq1JEkbdu2zecY9/5u3boVOl9ZxgEAACBwgq6IbdKkiefNUevXry/Unpubq02bNkmSrrvuOklSrVq1NGTIEEnSkiVLCo357rvvtGXLFknSsGHDvNrc20uXLlVBQYFXW0FBgZYtWyZJGj58eJmvCQAAABUr6IpYSZoxY4akC0/h+ve//+3Zn5eXpylTpmjfvn2qW7euJk6c6GmbOnWqbDabFixYoLVr13r25+Tk6O6771Z+fr5GjBihDh06eJ0rISFBzZo1U0ZGhqZPn+7VNn36dGVkZMhut2v8+PGVcakAAAAog6BbEytJ/fv319NPP63p06erV69euu6669SkSRNt375dBw4cUHh4uN555x01btzYM6Zbt26aM2eOJk+erMGDB6tPnz5q1KiRPvvsMx09elSxsbF64403Cp2rTp06Wr58uQYOHKhZs2Zp9erV6tSpk9LT05Wenq6IiAitWLFC4eHhVZkCAAAAFCMoZ2Il6Y9//KP+8Y9/aMCAAdq9e7c++OAD5efnKyEhQdu3b/csH7jYb37zG6WkpOimm25SWlqa3n//fUVGRioxMVFbt25VTEyMz3P17NlTO3fu1Pjx4+VyuZScnCyXy6Xx48dr586d6tGjR2VfLgAAAPwQlDOxbgMHDtTAgQP9GhMfH6/4+Hi/z9W2bVslJSX5PQ4AAABVL2hnYgEAAICiBPVMLACgkpX2vo//e5oiAAQLZmIBAABgORSxAAAAsByWE1QB98Mb3NLS0mS32wMUDQAAgPUxEwsAAADLYSa2CjidTq9th8Mhl8sVoGgAAACsj5lYAAAAWA5FLAAAACyHIhYAAACWQxELAAAAy6GIBQAAgOVQxAIAAMByKGIBAABgORSxAAAAsByKWAAAAFgORSwAAAAshyIWAAAAllMz0AFUBw6Hw2s7LS1Ndrs9QNEAAABYHzOxAAAAsBxmYquA0+n02nY4HHK5XAGKBgAAwPqYiQUAAIDlUMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDncnAACUzGYrfV9jKi8OAPgfZmIBAABgORSxAAAAsByKWAAAAFgOa2IBoKJV9/Wj1f36AVQJitgq4HA4vLbT0tJkt9sDFA0AAID1sZwAAAAAlsNMbBVwOp1e2w6HQy6XK0DRAPBS2j9982dvAAgqzMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDkUsAAAALIe7EwBAIPnzYAAAgAczsQAAALAcilgAAABYDkUsAAAALIciFgAAAJZDEQsAAADL4e4EVcDhcHhtp6WlyW63BygaANVCVJR09mygowCASsNMLAAAACyHmdgq4HQ6vbYdDodcLleAogEAALA+ZmIBAABgOczEAkBp8GQtAAgqzMQCAADAcihiAQAAYDlBWcQmJCTIZrMV+/HTTz/5HPvll19q5MiRaty4sWrXrq0rrrhCDz/8sI4dO1bsOX/88Uc99NBDuuKKKxQWFqbGjRtr5MiR2r59e2VcIgAAAMohqNfE9uzZU23btvXZVqNGjUL73n33Xd15553Ky8tT9+7ddcUVV2jbtm169dVXtWLFCjmdTp/Hy8jIUK9evXTs2DG1bt1at99+u/bv3693331X7733npYvX65hw4ZV+PUBAACgbIK6iL3nnnuUkJBQqr5HjhzRhAkTlJeXp7lz5+ree++VJOXn5yshIUGLFy/W2LFj9fnnn8t20Rs0jDEaM2aMjh07pnHjxmnBggWeAvnNN9/Ufffdp/Hjx2vPnj1q0qRJhV8jAAAA/BeUywnK4sUXX1ROTo7i4+M9Bax0Ycb29ddfV1RUlLZu3ap169Z5jfv444+Vmpqq6Ohovfbaa14zvPfee6/69++vrKwsvfTSS1V2LQAAACjeJVPErlq1SpI0duzYQm2RkZEaOnSoJGnlypU+xw0dOlSRkZGFxrqP9/NxAAAACJygXk6wceNG7dq1S5mZmWrQoIGuu+46DR48WGFhYV79MjMztXfvXklSXFycz2PFxcXprbfeUmpqqtd+93Zx4yRpz549ys7OVkRERLmuCQAAAOUX1EXsokWLCu1r2rSp5s+fr5tvvtmz78CBA57/t2jRwuexmjdvLknav3+/1373dknjjDE6cOCAOnbsWPoLAAAAQKUIyiK2a9eueumll9S/f3+1aNFCZ8+e1c6dO/XEE09oy5YtGjp0qNatW6e+fftKujAT61bUTKl7qcCZM2e89rvHljTO11hfHA5HiX3S0tJkt9uVm5tbYt/qxJ0P8uKNvPhWbF6iokp/oPDwCoooOOT+73pyrXJdpf269udzevq0j9PwOvKFvPhGXnwzxni9OT7QbMYYE+ggSssYo2HDhun9999X165dtWPHDknSli1b1LNnT0kXvuBq1ixcm6ekpGjgwIGqVauWzp0759lfq1Yt5ebmKiUlRfHx8YXG5ebmqlatWp7z/OIXvyg2Rn+K2NmzZ5fYFwAAIBgkJiaqfv36cjqdgQ5FUpDOxBbFZrPpySef1Pvvv6+dO3fq0KFDat68uerWrevpk52drSgfv7FnZWVJkurVq+e1v27dunK5XMrOzvZ5Tvc4X2N9Kc0n1uFwyOVyacCAAQoNDS2xf3Xh/mWCvHgjL74Vmxd/Zu0uMbnh4UqZP18DJk1S6NmzgQ6nZD5mTX2qgJlYXkeFkRffyItvzz77bKBD8GKpIlaSrrzySs//Dx8+rObNm6tly5aefQcPHlTnzp0LjTt06JAkqVWrVl77W7VqJZfLpYMHD/o8n3uczWbzOk9FCA0N5cXhA3nxjbz45jMvVijeKlno2bPWKGJL+zXtz7UUc0xeR76RF9/Ii7dgWkogWfAWWydPnvT83z0DW69ePc+TuLZt2+ZznHt/t27dvPa7t0sa165dO5+34AIAAEDVs1wRu3TpUkkXCtfY2FjPfvdjYZcsWVJoTFZWlj744ANJ0vDhw73a3ONWr17tc0mB+3g/HwegGDZb6T8AACiDoCtid+zYodWrVysvL89rf0FBgebNm6dp06ZJkh555BGvKf5HH31UderU0fr16/W3v/3Nsz8/P18PPPCATp06pe7du2vgwIFexx00aJCuueYanTp1Sg888IDy8/M9bW+++aY2bNigyMhI/frXv66MywUAAEAZBN2a2AMHDmjYsGG67LLL1K1bNzVu3FinTp1Senq6Z93qnXfeqRkzZniNa9asmRYuXKg777xT9957r+bNm6dWrVpp69at2rdvnxo3bqwlS5YUWs9hs9n0zjvvqFevXlq0aJGcTqe6d++u/fv364svvlDNmjW1aNEiNWnSpMpyAAAAgOIF3Uxs165d9eijj6pjx47avXu3Vq5cqQ0bNkiS7rjjDq1Zs0ZLlizxeRutkSNH6vPPP9fw4cO1b98+rVq1Svn5+XrwwQe1c+dOz7rZn4uNjVVaWpoefPBB5efna9WqVdq/f7+GDx+uzz//3LPkAAAAAMEh6GZir7jiCr3wwgtlHn/ttdcqOTnZ73FNmjTRq6++qldffbXM5wYAAEDVCLqZWAAAAKAkFLEAAACwHIpYAAAAWA5FLAAAACwn6N7YdSlyOBxe22lpabLb7QGKBgAAwPqYiQUAAIDlMBNbBZxOp9e2w+GQy+UKUDQAAADWx0wsAAAALIciFoA12GzeH1FRF/ZHRRVuAwBc8ihiAQAAYDkUsQAAALAcilgAwKXl58tLilt+AsCyKGIBAABgORSxAAAAsByKWAAAAFgODzsAEFisSwQAlAEzsQAAALAcilgAAABYDssJqoDD4fDaTktLk91uD1A0AAAA1sdMLAAAACyHmdgq4HQ6vbYdDodcLleAogEAALA+ZmIBAABgORSxAAAAsByKWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMvhFlsAgMCx2QIdAQCLYiYWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcnhjVxVwOBxe22lpabLb7QGKBgAAwPooYgEAKIk/d1EwpvLiAOBBEVsFnE6n17bD4ZDL5QpQNAAAANbHmlgAAABYDkUsAAAALIciFgAAAJZDEQsAAADLoYgFAACA5VDEAgAAwHIoYgEAAGA53CcWAFB9+fMQAwBBhZlYAAAAWA5FLAAAACyHIhYAAACWw5rYKuBwOLy209LSZLfbAxQNAACA9TETCwAAAMthJrYKOJ1Or22HwyGXyxWgaAAAAKyPmVgAAABYDkUsAAAALIflBABKh5vCAwCCiCVmYn//+9/LZrPJZrNp5syZRfZbv369Bg8erJiYGIWHh6tDhw567LHHlJWVVezx9+7dq4SEBNntdoWFhclutyshIUH79u2r6EsBAABABQj6InbLli2aM2eObCXMAr3wwgsaMGCA1q5dq44dO+rWW2/V6dOnNWvWLMXFxenEiRM+x23evFldu3ZVUlKSoqOjNWzYMEVHRyspKUldunTRv//978q4LAAAAJRDUBexOTk5SkhIUNOmTXXbbbcV2S81NVVTpkxRjRo1tGbNGm3atEnLly/Xt99+q/79++ubb77R/fff7/P4o0aNUk5OjhITE5Wenq6lS5cqPT1diYmJys7O1qhRo3T27NnKvEwAAAD4KaiL2MTERO3Zs0dvvvmmoqKiiuw3e/ZsGWM0ceJEDRo0yLO/Tp06mjdvnkJCQpScnKzdu3d7jVu4cKGOHDmi9u3bF1qmMHPmTLVv316HDh3SokWLKvbCAAAAUC5BW8R++umneuWVVzR+/HgNHjy4yH7nz5/XmjVrJEljx44t1N6yZUv17NlTkrRq1SqvNvf2mDFjFBLinYqQkBCNHj1akrRy5cqyXwgAAAAqXFAWsVlZWZo0aZIaN26sF198sdi+GRkZysnJkSTFxcX57OPen5qa6rXfve3vOAAAAARWUN5i67e//a3279+vVatW6bLLLiu27/79+yVJ0dHRqlu3rs8+zZs39+orSZmZmTp58qQkqUWLFsWOO378uLKzsxUREeHfhQAAAKBSBF0Ru27dOs2dO1djxozR7bffXmL/zMxMSSq2wIyMjJQknTlzptC44sa6x7nHlqaIdTgcJfZJS0uT3W5Xbm5uiX2rE3c+yIu3oMlLeHhgz/8zuf+LJzfI4go08uJbleYl0K9VPwTN95cgQ158M8aUeLeoqhRURezp06d19913q2HDhnrllVcCHU6lS0lJCXQIQYm8+BbwvLzzTmDPX4SU+fMDHUJQIi++VUlePvqo8s9RwQL+/SVIkRdvp06dUv369QMdhkdQFbGPPvqoDh8+rGXLlikmJqZUY9xLCLKzs4vs437YQb169QqNK27sxQ9JuHhscZxOZ4l9HA6HXC6XBgwYoNDQ0FIdtzrIzc1VSkoKefmZSs9LMXf+CGa54eFKmT9fAyZNUii3wfMgL75VaV5On67c41cgvu/6Rl58e/bZZwMdgpegKmJXrVqlmjVr6rXXXtNrr73m1ea+Pda8efO0fv16NWnSREuXLlWrVq0kXfjtIDMz0+e62EOHDkmSp690oYitX7++XC6XDh48qK5duxY5LiYmplLWw4aGhvLi8IG8+FZpebF4oRN69izFmg/kxbcqyYsFv3/xfdc38uItmJYSSEFWxEpSXl6eNm3aVGT7gQMHdODAAbVs2VKSFBsbqzp16ignJ0fbtm3TjTfeWGjMtm3bJEndunXz2t+tWzetX79e27Zt06233lrqcQAAAAisoLrF1qlTp2SM8fkxYcIESdLTTz8tY4wOHDggSapVq5aGDBkiSVqyZEmhY3733XfasmWLJGnYsGFebe7tpUuXqqCgwKutoKBAy5YtkyQNHz684i4SAAAA5RZURWxZTZ06VTabTQsWLNDatWs9+3NycnT33XcrPz9fI0aMUIcOHbzGJSQkqFmzZsrIyND06dO92qZPn66MjAzZ7XaNHz++Sq4DAAAApRN0ywnKolu3bpozZ44mT56swYMHq0+fPmrUqJE+++wzHT16VLGxsXrjjTcKjatTp46WL1+ugQMHatasWVq9erU6deqk9PR0paenKyIiQitWrFA4t6oBAAAIKpfETKwk/eY3v1FKSopuuukmpaWl6f3331dkZKQSExO1devWIu920LNnT+3cuVPjx4+Xy+VScnKyXC6Xxo8fr507d6pHjx5VfCUAAAAoiWVmYhcuXKiFCxcW2yc+Pl7x8fF+H7tt27ZKSkoqY2QAAACoapfMTCwAAACqD8vMxALwQ5Ddyw8AgIrGTCwAAAAshyIWAAAAlsNygirgcDi8ttPS0mS32wMUDQAAgPUxEwsAAADLYSa2CjidTq9th8Mhl8sVoGgAAACsj5lYAAAAWA5FLAAAACyH5QQAAARKae/pbEzlxgFYEDOxAAAAsBxmYgEAqEg8MQ+oEszEAgAAwHIoYgEAAGA5FLEAAACwHIpYAAAAWA5FLAAAACyHIhYAAACWwy22qoDD4fDaTktLk91uD1A0AADL8ee2XTwYAdUEM7EAAACwHGZiq4DT6fTadjgccrlcAYoGAADA+piJBQAAgOVQxAIAAMByKGIBAABgORSxAAAAsBze2AVYRVSUdPZsoKMAACAoMBMLAAAAy6GIBQAAgOVQxAKBZrMV/xEVFegIAQAIOhSxAAAAsByKWAAAAFhOmYvYSZMmaf78+SX2W7hwoSZNmlTW0wAAAACFlPkWWwsXLpSkEgvUzZs3KykpqVQF76XK4XB4baelpclutwcoGgAAAOur9OUE+fn5Cglh1QIAAAAqTqU/7GDPnj2KqubvrnY6nV7bDodDLpcrQNEAAABYn19F7FNPPeW1vWPHjkL73PLy8vTVV19py5Ytio+PL3uEAAAAwM/4VcQ+8cQTstlsMsZIulDE7tixo9gxERERevzxx8scIAAAAPBzfhWxjz/+uKeIfeqpp3T11Vfrtttu89m3Vq1astvtuummm9SoUaMKCRYAAACQyjAT6+YuYmfMmFHRMQEAAADFKvMbuwoKCioyDgAAUBFsttL3PX++8uIAKhn3vgIAAIDllPsWW0eOHNHGjRv1/fff66effvLZx2azafr06eU9FQAAACCpnEXs5MmT9eqrryo/P1+SPHctcHO/CYwiFgAAABWpzEXs888/rxdffFE2m0033XSTrrzyStWrV68iYwMAAAB8KnMRO2/ePNWsWVPr1q1T3759KzAkAAAAoHhlfmPXt99+K4fDQQELAACAKlfmmdi6deuqadOmFRnLJcvhcHhtp6WlyW63BygalJk/t6352fpwAABQsco8E9urVy/t3LmzImMBAABVKSrq//612Yr+AIJQmWdiH3/8cfXo0UN///vfdc8991RkTJccp9Ppte1wOORyuQIUDQAAgPWVuYg9c+aMJk+erPvuu0/r1q3TLbfcohYtWigkxPfkbu/evcscJAAAAHCxMhexffv29dwHNjk5WcnJyUX2tdlsysvLK+upAAAAAC9lLmJ79+4tG+tkAAAAEABlLmI//fTTCgwDAAAAKL0y352gMr399tsaP368unbtqkaNGik0NFRRUVG67rrrNHv2bGVlZRU5dv369Ro8eLBiYmIUHh6uDh066LHHHit2jCTt3btXCQkJstvtCgsLk91uV0JCgvbt21fRl4eqUNy7bHnXLQAAlheURezrr7+uxYsXKy8vT926ddPIkSMVFxen9PR0TZs2Tddcc42OHDlSaNwLL7ygAQMGaO3aterYsaNuvfVWnT59WrNmzVJcXJxOnDjh83ybN29W165dlZSUpOjoaA0bNkzR0dFKSkpSly5d9O9//7uyLxkAAAB+KPNygn/+859+9ffn7gRz5sxRu3btVL9+fa/9J0+e1O233y6n06kpU6bonXfe8bSlpqZqypQpqlGjhj744AMNGjRIkpSTk6OhQ4dqw4YNuv/++/Xuu+96HTMnJ0ejRo1STk6OEhMTNWvWLE/btGnTNHv2bI0aNUrffPONwsPD/bpmAAAAVI5y352gNPy9O8H111/vc3+DBg00a9Ys9e7dW+vWrfNqmz17towxmjhxoqeAlaQ6depo3rx5at26tZKTk7V792516NDB075w4UIdOXJE7du318yZM72OOXPmTCUnJysjI0OLFi3SfffdV+prQDXHMgUAACpVmZcT9O7d2+eHw+FQ8+bNPf1+8YtfqFevXhUSrCTVrHmh7g4LC/PsO3/+vNasWSNJGjt2bKExLVu2VM+ePSVJq1at8mpzb48ZM6bQPW5DQkI0evRoSdLKlSsr6AoAAABQXpV2d4K0tDQlJCQoIiJCH330UVlP4yUzM1NPPPGEJGno0KGe/RkZGcrJyZEkxcXF+RwbFxenzz77TKmpqV773dvFjbu4HwAAAAKvzEVsSbp06aKVK1eqY8eO+stf/qKpU6f6fYx169ZpyZIlKigo0I8//qh//etfyszM1M0336xnn33W02///v2SpOjoaNWtW9fnsdyzw+6+0oWi+OTJk5KkFi1aFDvu+PHjys7OVkREhN/XAQAAgIpVaUWsJLVq1Urdu3fXokWLylTEfv3110pKSvLaN3bsWD3//POKiory7MvMzJSkYgvMyMhISRcel/vzccWNdY9zjy2piHU4HMW2Sxdmqe12u3Jzc0vsW52481EhefHnTXilPV+A3tiX+7/z5vLGQi/kxTfy4ht58a3UealmP68q9OfRJcQYE1QPuqrUIlaSGjZsqC+++KJMYx999FE9+uijys3N1cGDB/X+++9r5syZWrt2rVatWuXXHQ+CUUpKSqBDCEoVkpeL7lxRotIud/HnmJUgZf78gJ4/WJEX38iLb+TFtxLzUkHLAq2Gn9PeTp06VejOUYFUqUXs+fPntXXrVtWpU6dcxwkNDVWbNm00efJk9ezZU7/4xS901113eW575V5CkJ2dXeQx3A87qFevnmffxUsPihp78UMSLh5bFKfTWWIfh8Mhl8ulAQMGKDQ0tMT+1UVubq5SUlIqJi8XzdSX6PTpij9mBcoND1fK/PkaMGmSQs+eDUgMwYi8+EZefCMvvpU6L6X9PnmJqNCfR5eQi5dyBoNKKWKzs7P1n//8R08++aQOHTqk4cOHV9ixr7/+el111VX66quvtG3bNvXq1UutWrWSdOE3hMzMTJ/rYg8dOiRJnr7ShSK2fv36crlcOnjwoLp27VrkuJiYmApfDxsaGsqLw4cKyYs/P6RKe64A/+ALPXuWH74+kBffyItv5MW3EvNSTX9W8XPaWzAtJZDKcYutGjVqFPlRr149XX/99VqzZo2ioqIK3X+1vNzF5LFjxyRJsbGxntnebdu2+Rzj3t+tWzev/e5tf8cBAAAgcMpcxBpjivyoWbOmWrZsqXvuuUfbt29XbGxshQV84sQJ7dy5U5LUvn17SVKtWrU0ZMgQSdKSJUsKjfnuu++0ZcsWSdKwYcO82tzbS5cuVUFBgVdbQUGBli1bJkkVOpsMAACA8ilzEVtQUFDkx7lz57Rv3z69+eabXn++L42vv/5ab7/9tn766adCbRkZGRo5cqTOnTunHj16qHPnzp62qVOnymazacGCBVq7dq1nf05Oju6++27l5+drxIgRXk/rkqSEhAQ1a9ZMGRkZmj59ulfb9OnTlZGRIbvdrvHjx/t1HQAAAKg8lX53An8dO3ZMd911l+677z5dc801stvtOn/+vA4ePKjt27eroKBAV155pWeG1K1bt26aM2eOJk+erMGDB6tPnz5q1KiRPvvsMx09elSxsbF64403Cp2vTp06Wr58uQYOHKhZs2Zp9erV6tSpk9LT05Wenq6IiAitWLFC4dyWBQAAIGiUeSa2snTs2FHPPPOMevXqpcOHD+uDDz7Qhx9+qMOHD6t///56/fXXlZqa6vPhBL/5zW+UkpKim266SWlpaXr//fcVGRmpxMREbd26VTExMT7P2bNnT+3cuVPjx4+Xy+VScnKyXC6Xxo8fr507d6pHjx6VfdkAAADwQ7lnYk+ePKm//e1v2rhxo77//ntJ0uWXX65+/frpnnvuUYMGDfw6XsOGDTVt2rQyxxMfH6/4+Hi/x7Vt27bQgxUAAAAQnMpVxK5bt0533nmnTp06JWOMZ//XX3+t9evX6y9/+YuWLFmigQMHljtQAAAAwK3MReyePXs0fPhw5eTkqEuXLpo4caLatGkjSdq3b58WLlyoHTt2aPjw4UpNTVW7du0qLGgAAABUb2UuYv/0pz8pJydHTzzxhB5//PFC7Y888oiefvppzZgxQ88++6z+/ve/lytQAAAAwK3MReyGDRsUGxvrs4B1mz59upYsWaL169eX9TSXBIfD4bWdlpYmu90eoGgAAACsr8x3J/jhhx9K9RSrbt266YcffijraQAAAIBCyjwTGxER4Xnsa3GOHTvmeUxsdeV0Or22HQ6HXC5XgKIBAACwvjLPxF599dX65z//qV27dhXZJy0tTZs2bdLVV19d1tMAAAAAhZS5iP1//+//KTc3V/Hx8XrttdeUlZXlacvKytKrr76qAQMGKD8/X/fee2+FBAsAAABI5VhOMGbMGH388cd666239PDDD+vhhx/2PNjg5MmTkiRjjMaPH6/Ro0dXTLQAAACAyvnY2aSkJL322mu64oorZIzRiRMndOLECRlj1Lp1a73++utauHBhBYUKAAAAXFDux87ef//9uv/++/X99997PXb28ssvL3dwAAAAgC9+FbFbt27V0aNHdeWVVxZ6AtfPC9c9e/boP//5j5o1a6a4uLiKiRYAAACQH0XsiRMn1L9/f9WtW1c7duwosX90dLQeeOAB5eTkaN++fYqOji5HmAAAAMD/KfWa2MWLFysrK0tPPvmkGjZsWGL/hg0b6qmnntKpU6e0ePHicgUJSJJsttJ/AABQHVWjn5WlLmI/+ugjRUREaMKECaU++Lhx4xQZGakPP/ywTMEBAIAgUI0KI1hHqYvY9PR0XX/99QoNDS31wUNDQ3XdddcV+0AEAAAAwF+lLmJdLpeaNGni9wkaN27suW8sAAAAUBFK/causLAwZWdn+32CnJwchYWF+T3uUuJwOLy209LSZLfbAxQNAACVyJ8lBcZUXhy45JW6iG3SpInS0tL8PkFaWlqZZnDhQ2WtNeKbCAAgEEr7c42fU/Ch1MsJbrjhBh04cEBbtmwp9cE3b96s/fv364YbbihTcJcKp9Pp9dGlS5dAhwQAAGBppS5if/nLX8oYo3vvvVenT58usf+pU6d07733ymaz6c477yxXkECl4h23AABYTqmL2Pj4ePXv319ff/21rr32Wq1evVrGx/S+MUbvv/++4uLitHv3bvXt21cDBw6s0KABAABQvfn12NmlS5eqZ8+eysjI0LBhwxQdHa1u3bqpUaNGkqRjx45p+/btOnXqlIwxatu2rZYtW1YpgQMAAFQL/DXQJ7+K2AYNGuiLL77QQw89pHfeeUf//e9/tWHDBtn+l1z3zGxISIjGjh2rV155hcfNAgCA6oO7M1QZv4pYSapXr54WLVqkJ598Uh9++KG2bdum48ePS7rwqNlrr71Wt9xyi1q3bl3hwQIAAABSGYpYtyuuuEIPP/xwRcYCAAAAlEqp39gFAAAABAuKWAAAAFgORSwAAAAshyIWAAAAllPmN3ahGuK2IQAAIEhQxFYBh8PhtZ2Wlia73R6gaAAAQFDgIQblwnICAAAAWA4zsVXA6XR6bTscDrlcrgBFE4Tcv4mGh0vvvCNFRUlnzwY2JgBA8GA5G3xgJhYAAACWQxELAAAAy6GIBQAAgOVQxAIAAMByKGIBAABgORSxAAAAsByKWAAAUD3ZbL4/oqIutEdF8UCCIEYRCwAAAMvhYQcAAODSwcxptUERC17wAADAclhOAAAAAMthJrYKOBwOr+20tDTZ7fYARQMAAPzCXyyDEkUsKgcveAAAUIkoYquA0+n02nY4HHK5XAGKBgAAwPpYEwsAAADLoYgFAACA5VDEAgAAwHIoYgEAAGA5QVfE5ubmasOGDfrd736n7t27Kzo6WqGhoWrSpImGDh2qNWvWFDt+/fr1Gjx4sGJiYhQeHq4OHTroscceU1ZWVrHj9u7dq4SEBNntdoWFhclutyshIUH79u2ryMsDAABABQi6InbTpk2Kj4/Xc889p8OHD8vhcGj48OFq2LChPvjgA91yyy267777ZIwpNPaFF17QgAEDtHbtWnXs2FG33nqrTp8+rVmzZikuLk4nTpzwec7Nmzera9euSkpKUnR0tIYNG6bo6GglJSWpS5cu+ve//13Zlw0AAAA/BF0RGxISohEjRuif//ynjh49qg8//FDLli3Trl27tHTpUtWoUUNvvvmm3nrrLa9xqampmjJlimrUqKE1a9Zo06ZNWr58ub799lv1799f33zzje6///5C58vJydGoUaOUk5OjxMREpaena+nSpUpPT1diYqKys7M1atQonT17tqpSAAAAgBIEXRHbr18/vfvuu+rVq1ehttGjRyshIUGStGjRIq+22bNnyxijiRMnatCgQZ79derU0bx58xQSEqLk5GTt3r3ba9zChQt15MgRtW/fXjNnzvRqmzlzptq3b69Dhw4VOh8AAAACJ+iK2JJcc801kqRDhw559p0/f96zVnbs2LGFxrRs2VI9e/aUJK1atcqrzb09ZswYhYR4pyMkJESjR4+WJK1cubKCrgAAAADlZbkids+ePZKkpk2bevZlZGQoJydHkhQXF+dznHt/amqq1373tr/jAAAAEDiWKmJ/+OEHLVy4UJI0YsQIz/79+/dLkqKjo1W3bl2fY5s3b+7VV5IyMzN18uRJSVKLFi2KHXf8+HFlZ2eX7wIAAABQIWoGOoDSysvL01133aXTp0+rc+fOuu+++zxtmZmZkqSIiIgix0dGRkqSzpw5U2hccWPd49xjizuHJDkcjmLbJSktLU12u125ubkl9vUSHu5ff4vJ/d/15V7i1+kv8uIbefGNvPhGXnwjL75Vm7z4WYcYY2Sz2SopGP9Zpoi9//77tWHDBjVo0EDvvvuuatWqFeiQyi0lJcW/Ae+8UzmBBJmU+fMDHUJQIi++kRffyItv5MU38uLbJZ+Xjz7yq/upU6dUv379SgrGf5YoYn/9619r3rx5uuyyy5SSkqL27dt7tbuXEBT35373ww7q1atXaFxxYy9+SMLFY4vidDpL7ONwOORyuTRgwACFhoaW2N8jKqr0fS0oNzxcKfPna8CkSQrllmYe5MU38uIbefGNvPhGXnyrNnk5fdqv7s8++2wlBVI2QV/ETpkyRS+//LKio6O1bt06z90JLtaqVStJF35DyMzM9Lku1n03A3df6UIRW79+fblcLh08eFBdu3YtclxMTEyJSwn8FRoa6l8Reym/kC4Sevbspf1No4zIi2/kxTfy4ht58Y28+HbJ58WfGkQKqqUEUpC/sev3v/+9nn/+eUVFRWndunVF3kEgNjZWderUkSRt27bNZx/3/m7dunntd2/7Ow4AAACBE7RF7NSpU/WXv/xFUVFRSklJUffu3YvsW6tWLQ0ZMkSStGTJkkLt3333nbZs2SJJGjZsmFebe3vp0qUqKCjwaisoKNCyZcskScOHDy/7xQAAAKBCBWUR+8c//lHPPvusoqOjSyxg3aZOnSqbzaYFCxZo7dq1nv05OTm6++67lZ+frxEjRqhDhw5e4xISEtSsWTNlZGRo+vTpXm3Tp09XRkaG7Ha7xo8fXzEXBwAAgHILujWxq1ev1jPPPCNJatu2rf7617/67BcTE6PnnnvOs92tWzfNmTNHkydP1uDBg9WnTx81atRIn332mY4eParY2Fi98cYbhY5Tp04dLV++XAMHDtSsWbO0evVqderUSenp6UpPT1dERIRWrFih8Ev9NhsAAAAWEnRFrMvl8vx/27ZtRa5VbdmypVcRK0m/+c1v1LlzZ82ZM0dffPGFsrOz1aJFCyUmJioxMbHIByH07NlTO3fu1NNPP63169crOTlZDRs21Pjx4/X444+rTZs2FXeBAAAAKLegK2ITEhKUkJBQ5vHx8fGKj4/3e1zbtm2VlJRU5vMCAACg6gTlmlgAAACgOBSxAAAAsByKWAAAAFgORSwAAAAsJ+je2HUpcjgcXttpaWmy2+0BigYAAMD6mIkFAACA5TATWwWcTqfXtsPh8LofLgAAAPzDTCwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDkUsAAAALIciFgAAAJbDY2ergMPh8NpOS0uT3W4PUDQAAADWx0wsAAAALIeZ2CrgdDq9th0Oh1wuV4CiAQAAsD5mYgEAAGA5FLEAAACwHIpYAAAAWA5FLAAAACyHIhYAAACWQxELAAAAy6GIBQAAgOVQxAIAAMByKGIBAABgORSxAAAAsByKWAAAAFhOzUAHUB04HA6v7bS0NNnt9gBFAwAAYH3MxAIAAMBymImtAk6n02vb4XDI5XIFKBoAAADrYyYWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDkUsAAAALIciFgAAAJZDEQsAAADLoYgFAACA5dQMdADVgcPh8NpOS0uT3W4PUDQAAADWx0wsAAAALIeZ2CrgdDq9th0Oh1wuV4CiAQAAsD5mYgEAAGA5FLEAAACwHIpYAAAAWA5FLAAAACwnKIvYb775Rq+88ooSEhLUuXNn1axZUzabTTNnzixx7Pr16zV48GDFxMQoPDxcHTp00GOPPaasrKxix+3du1cJCQmy2+0KCwuT3W5XQkKC9u3bV1GXBQAAgAoSlEXs66+/rkceeURJSUlKT09Xfn5+qca98MILGjBggNauXauOHTvq1ltv1enTpzVr1izFxcXpxIkTPsdt3rxZXbt2VVJSkqKjozVs2DBFR0crKSlJXbp00b///e+KvDwAAACUU1AWsZ06ddJvf/tbvf322/rPf/6jcePGlTgmNTVVU6ZMUY0aNbRmzRpt2rRJy5cv17fffqv+/fvrm2++0f33319oXE5OjkaNGqWcnBwlJiYqPT1dS5cuVXp6uhITE5Wdna1Ro0bp7NmzlXGpAAAAKIOgvE/sPffc47UdElJyrT179mwZYzRx4kQNGjTIs79OnTqaN2+eWrdureTkZO3evVsdOnTwtC9cuFBHjhxR+/btCy1XmDlzppKTk5WRkaFFixbpvvvuK+eVAQAAoCIE5Uysv86fP681a9ZIksaOHVuovWXLlurZs6ckadWqVV5t7u0xY8YUKpZDQkI0evRoSdLKlSsrPG4AAACUzSVRxGZkZCgnJ0eSFBcX57OPe39qaqrXfve2v+MAAAAQOJdEEbt//35JUnR0tOrWreuzT/Pmzb36SlJmZqZOnjwpSWrRokWx444fP67s7OwKixkAAABlF5RrYv2VmZkpSYqIiCiyT2RkpCTpzJkzhcYVN9Y9zj22uHNIksPhKDHetLQ02e125ebmltjXS3i4f/0tJvd/15d7iV+nv8iLb+TFN/LiG3nxjbz4Vm3y4mcdYoyRzWarpGD8d0kUsVaVkpLi34B33qmcQIJMyvz5gQ4hKJEX38iLb+TFN/LiG3nx7ZLPy0cf+dX91KlTql+/fiUF479Looh1LyEo7s/97ocd1KtXr9C44sZe/JCEi8cWxel0ltjH4XDI5XJpwIABCg0NLbG/R1RU6ftaUG54uFLmz9eASZMUyi3NPMiLb+TFN/LiG3nxjbz4Vm3ycvq0X92fffbZSgqkbC6JIrZVq1aSLvyGkJmZ6XNd7KFDh7z6SheK2Pr168vlcungwYPq2rVrkeNiYmJKXErgr9DQUP+K2Ev5hXSR0LNnL+1vGmVEXnwjL76RF9/Ii2/kxbdLPi/+1CBSUC0lkC6RN3bFxsaqTp06kqRt27b57OPe361bN6/97m1/xwEAACBwLokitlatWhoyZIgkacmSJYXav/vuO23ZskWSNGzYMK829/bSpUtVUFDg1VZQUKBly5ZJkoYPH17hcQMAAKBsLokiVpKmTp0qm82mBQsWaO3atZ79OTk5uvvuu5Wfn68RI0Z4Pa1LkhISEtSsWTNlZGRo+vTpXm3Tp09XRkaG7Ha7xo8fXyXXAQAAgJIF5ZrY7du364EHHvBsf/vtt5KkuXPn6sMPP/TsX7VqlZo2bSrpwp/758yZo8mTJ2vw4MHq06ePGjVqpM8++0xHjx5VbGys3njjjULnqlOnjpYvX66BAwdq1qxZWr16tTp16qT09HSlp6crIiJCK1asUPilfpsNAAAACwnKIvbMmTP6/PPPC+0/fPiwDh8+7Nk+d+6cV/tvfvMbde7cWXPmzNEXX3yh7OxstWjRQomJiUpMTCzyQQg9e/bUzp079fTTT2v9+vVKTk5Ww4YNNX78eD3++ONq06ZNxV4gAAAAyiUoi9i+ffvKGFOmsfHx8YqPj/d7XNu2bZWUlFSmcwIAAKBqXTJrYgEAAFB9UMQCAADAcihiAQAAYDkUsQAAALCcoHxj16XG4XB4baelpclutwcoGgAAAOtjJhYAAACWw0xsFXA6nV7bDodDLpcrQNEAAABYHzOxAAAAsByKWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDkUsAAAALKdmoAOoDhwOh9d2Wlqa7HZ7gKIBAACwPmZiAQAAYDnMxFYBp9Ppte1wOORyuQIUDQAAgPUxEwsAAADLoYgFAACA5VDEAgAAwHIoYgEAAGA5FLEAAACwHIpYAAAAWA5FLAAAACyHIhYAAACWQxELAAAAy6GIBQAAgOXw2Nkq4HA4vLbT0tJkt9sDFA0AAID1MRMLAAAAy2Emtgo4nU6vbYfDIZfLFaBoAAAArI+ZWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihiAQAAYDkUsQAAALAcilgAAABYDkUsAAAALIciFgAAAJZTM9ABVAcOh8NrOy0tTXa7PUDRAAAAWB8zsQAAALAcZmKrgNPp9Np2OBxyuVwBigYAAMD6mIkFAACA5VDEAgAAwHIoYgEAAGA5FLEAAACwHIrYi6xYsUJ9+/bVZZddpoiICHXt2lV//vOflZubG+jQAAAAcBGK2P959NFHNWrUKG3evFnXXXedbr75Zh08eFB/+MMf1K9fP509ezbQIQIAAOB/KGIlvffee3rppZcUGRmpzz//XP/4xz+UnJysPXv2qHPnznI6nZo+fXqgwwQAAMD/UMRKmjVrliRp6tSp6tatm2d/TEyMXnvtNUnSq6++qtOnTwckPgAAAHir9kXs999/r61bt0qSxo4dW6jd4XCoefPmOnfunD766KOqDg8AAAA+VPsiNjU1VZJUv359XXHFFT77xMXFefUFAABAYFX7Inb//v2SpBYtWhTZp3nz5l59AQAAEFg1Ax1AoGVmZkqSIiIiiuwTGRkpSTpz5kyJx3M4HCX2+eKLL1SzZk316dNHNputlJFKCrm0f+cwubk6lZioZ3NzZbvEr9Uf5MU38uIbefGNvPhGXnyrNnnp2dOv7rt27Sq2Xqpq1b6IDYT8/HxJUoifL4y0/33hdOnSxb9xaWmWGLcrLU06fFj1r7++Ss5nlXHkxTfy4ht58Y28+EZefKs2efFnIk3STz/9pLy8PL/GVKZqX8TWrVtXkpSdnV1kn6ysLElSvXr1Sjye0+kssY97trY0fRnHOMYxjnGMYxzjgmlcsLiE58hLp1WrVpKkQ4cOFdnH3ebuCwAAgMCq9kXsNddcI0k6efJkkW/c2rZtmyR53UMWAAAAgVPti1i73a7u3btLkpYsWVKo3el06tChQwoLC9PgwYOrOjwAAAD4YDPGmEAHEWjvvfeehg0bpsjISG3atMkz43ry5EndeOON2rVrl6ZMmaLnnnuuQs5X1rUolzry4ht58Y28+EZefCMvvpEX38iLb8GWl2o/EytJt99+ux555BFlZWWpR48eGjRokO644w61bdtWu3btUs+ePfX0008HOkwAAAD8D0Xs/7z00ktatmyZfvGLX2jLli366KOPZLfb9ac//UmffPKJwsPDAx0iAAAA/qfa32LrYqNGjdKoUaMCHQYAAABKwEwsAAAALIc3dgEAAMBymIkFAACA5VDEAgAAwHIoYgEAAGA5FLEAAACwHIpYAAAAWA5FLAAAACyHIrYCZGZmatq0aYqNjVV4eLhiYmI0ZMgQffLJJ2U+ZkFBgebOnavrr79edevWVd26dXX99dfrzTfflD93RXvttddks9lks9l0zz33lDmesgiWvHz88ce65557FBcXp6ZNmyosLEx169bV1VdfrWnTpunEiRNljqcsgiEvBQUF2rJlix5//HE5HA41aNBAoaGhiomJ0YABA/T222/79XVWEYIhL5J06NAhzZ07V/fee6+uvfZahYWFVfrrZ8WKFerbt68uu+wyRUREqGvXrvrzn/+s3NzcMh3vyy+/1MiRI9W4cWPVrl1bV1xxhR5++GEdO3as2HE//vijHnroIV1xxRUKCwtT48aNNXLkSG3fvr1McZRXoPOSn5+vd999V4mJiRo4cKAaNGggm82mmjUD+5ygQOfl4MGDmjt3roYPH66WLVsqLCxMkZGR6tq1q6ZNm6bjx4+X5/LKLNB5OXz4sH7/+99rwIABatWqlerWrauwsDC1aNFCY8aMkdPpLM/llVmg8+LL999/r8suu6z8ryeDcvnxxx9N+/btjSTTtGlTM3LkSNO7d29js9mMzWYzL7/8st/HzMvLM8OHDzeSTJ06dcytt95qbr31VhMeHm4kmZEjR5r8/PwSj/Ptt9+aiIgIY7PZjCRz9913l+USyySY8vLLX/7SSDJt27Y18fHx5s477zQDBw400dHRRpJp1KiRSU9Pr4jLLlGw5GXPnj1GkpFk6tevbwYOHGhGjx5tunfv7tl/yy23mHPnzlXUpRcrWPJijDEvvPCCJwcXf1TW6+fXv/61kWRq1qxpBg4caIYPH+752nQ4HCYnJ8ev461YscLUrFnTSDLdu3c3o0aNMq1btzaSTOPGjc2ePXt8jvvmm29Mo0aNjCTTunVrM2rUKM/XQ82aNc3KlSsr4nJLLRjy8t///tfn10KNGjUq6jL9Fgx56dmzpyeG7t27m9GjR5sBAwaYevXqGUmmYcOGJjU1tYKuuHSCIS8pKSlGkrnssstMz549zR133GFuv/12Exsb6/naefbZZyvqkkslGPLiy6BBgzy1SXleTxSx5XTbbbcZSaZ///4mOzvbs3/NmjWmRo0aJiQkxOzcudOvY7p/iF5++eVm3759nv379u0zzZo1M5LMK6+8Uuwx8vPzTa9evUxkZKSZMGFClRexwZSX1NRUc/To0UL7MzMzzciRI40k06NHD79iKatgycvevXtNv379zMcff2zy8vK82j799FMTERFhJJknn3yyDFfpv2DJizHGvPfee+bhhx82CxYsMDt37jSPPfZYpb1+Vq1aZSSZyMhI8+WXX3r2Hz9+3HTu3NlIMlOmTCn18b7//ntTp04dI8nMnTvXsz8vL8/cddddnh88BQUFXuMKCgrMNddcYySZcePGeX1NzJ071xOjr9dRZQiWvGRlZZlf/vKX5rnnnjOffPKJ2bFjR0CL2GDJy6hRo8wLL7xgTpw44bX/2LFjpm/fvkaSadeuXaHvLZUlWPLyww8/mNTUVJ+/HC9ZssTzvezrr78uw1X6L1jy8nN/+9vfjCTz0EMPUcQG0ldffeX5BBw4cKBQ+913320kmTFjxpT6mPn5+aZJkyZGklm8eHGh9rfeestIMs2aNSt2Nvb55583ksxf//pXM2PGjCotYoM5Lz938OBBz2/Ip0+fLvW4srBSXp5++mkjybRp06bUY8oq2PNSma8f90znzJkzC7V99tlnRpIJCwszp06dKtXxfve73xlJJj4+vlBbZmamiYqKMpLM2rVrvdrWrFljJJno6GiTmZlZaGz//v2NJDN16tRSXln5BEtefm7//v0BLWKDNS8XO3TokOd76meffVbqceVhhbwYY0y/fv2MpDL9ZaksgjEvBw4cMHXr1jU9evQw3377LUVsIM2cOdNIMr179/bZvmHDBiPJREREmPPnz5fqmE6n0/OFdfbs2ULtOTk5platWkaS2bJli89j7N6924SHh5s+ffqYgoKCKi9igzUvvhw5csRIMiEhIX7/WcVfVsrLhx9+aCSZWrVqlXpMWQV7Xirr9XP48GHPD/uLZ4ov1rx5cyPJLFmypFTHbNu2rZFk5s+f77N93LhxRpK59957vfbfc889RpIZP368z3Hz5s0zkkz79u1LFUd5BFNefi6QRWww5+XnYmJi/IqjPKyUl4EDBxaaxawswZiXgoIC069fPxMWFma+/vrrCnk98cauckhNTZUkxcXF+Wx378/OztaePXv8OmbHjh1Vu3btQu3h4eHq2LGjV9+L5efna8KECbLZbJo3b55sNlupzluRgjEvvpw7d07Tpk2TJA0YMEDh4eGlGldWVsmLJM/5mzZtWuoxZWWlvFQk93nr16+vK664wmcf97WXJsbMzEzt3bvXa1xpj1faz8GePXuUnZ1dYizlEUx5CSZWycuJEyf03//+V1LVfv8I9rysWbNGGzduVO3atTVw4MBSjyurYMzLa6+9pk8++UQzZszQlVdeWeI5S4Mithz2798vSWrRooXP9nr16qlevXpefct7TElq3rx5kcf8y1/+os8//1zPPPOM2rRpU6pzVrRgzIskbd++XQkJCZowYYIGDx4su92uhQsXqnv37po3b16p4iiPYM3Lz+Xk5Ojll1+WJI0YMaJUY8rDKnmpaBUd44EDBzz/L+qYRR2vpFjc44wxXuepDMGUl2Bilbw899xzys/PV9OmTXXDDTeUelxZBWteHnjgASUkJOiOO+5Qly5ddMstt6h27dpavHixWrVqVWIc5RVsefn222/1hz/8Qddee61+97vflXi+0grsfUIsLjMzU5IUERFRZJ/IyEidOXNGZ86cqdBjSip0zPT0dM2YMUM33HCDHnnkkVKdrzIEW17cDh48qKSkJK998fHxmjt3ri6//PJSxVEewZqXn3vggQe0f/9+NWvWzDNTXZmskpeKVtExuo9X3DGLOl5JsbjHlTaW8gimvAQTK+Rl/fr1eu655yRJc+bMUa1atUo1rjyCNS9LlizR6dOnPdsNGzbUG2+8oeHDh5cYQ0UIprwUFBQoISFB58+f14IFCyr0FnXVtoj9/e9/r9WrV/s97u9//7scDkclRFQ+eXl5mjBhgkJCQjR//nyFhJRtkv1Sy8vFbr/9dhljlJ+fr8OHD2v9+vWaMWOGOnXqpEWLFumOO+4ocuylnJeLPf3000pKSlLt2rW1fPlyNWjQoNj+1SUvAIq3a9cujRw5Uvn5+Xr44Yd15513BjqkgDp16pQkyeVyKT09XbNmzdKIESM0ZswYLV68WDVq1AhsgFXoxRdflNPp1JNPPqnOnTtX6LGrbRF75MgRffPNN36Py8rK8vy/bt26klTsGjF3f/efQ0tS1mM+88wz2r59u5599lnFxsaW6ly+XGp58aVGjRpq2bKl7r77bvXv318dO3bUxIkT5XA41KRJE59jqkNenn/+eT3++OMKCwvTqlWr1LNnzxLPXx3yUlkqOkb38dzHjIqKKvXx6tatK5fLVWQsF3++KjtfwZSXYBLMedm9e7fi4+N16tQpTZw4US+99FKJ568owZwX6cKa1N69e6tXr1669dZbtXTpUvXs2VMPPfRQiWPLI1jy8s033+ixxx5T165dlZiYWLrg/VBt18QuXrxY5sLdGfz6uPnmmz3HcK9rOXjwoM9zXPznz9KugSnpmNKFJwr9/JirVq2SJH3wwQfq27ev18fChQslXVhY7t5XlEstL6U57o033qisrCylpKQU2e9Sz8srr7yiKVOmqFatWkpOTvaKuziXel4qk/u87jh88SfGli1bev5f1HUXdbyS8uUeZ7PZvM5TGYIpL8EkWPOSkZGhfv366dixYxo/frz+/ve/V+kbioM1Lz9ns9mUkJAg6f9+XlemYMnLxx9/rJ9++knZ2dkaMGCAV20yZswYSRfekO7et3bt2hJjuVi1LWIrQrdu3SRJ27Zt89nu3h8REaH27dv7dcyvvvpKP/30U6H2s2fP6quvvvLqezGn06lNmzZ5fXz33XeSpB9++MGzrzIFY16K417f488j88oiWPPy17/+VY888oingB0yZEipzl1RgjUvle2aa66RJJ08ebLIN1a4r700MdarV09t27b1Glfa45X2c9CuXTuv9bGVIZjyEkyCMS979uzRjTfeqKNHj+quu+7SggULyryUrayCMS9FqaqfNVLw5WXv3r2FapPPP//c0+7e98MPP5QYi5cy35wLJj093XOPs++++65Qe6Bv0u5W1feJtUpejDHmp59+8jy9afXq1aUeVxbBmJfXX3/d6H/3g/3ggw/8u6AKEox5udil9LAD9+Mmi3vYQVZWVqGxl/rDDorKy89Vt4cdFJeXvXv3mssvv9xIMnfddZdf33crWjDlpThTpkwxkszw4cP9GldWwZ6Xing9UcSWk/txmfHx8V43y//oo4+KfVzmuHHjTGxsrM/HXhb3uEz3N42SHjt7saouYo0Jnrz8+OOP5rXXXvP5NK7Dhw97HjvbqlUrnzfFr2jBkhdjjHnzzTeNzWYLaAHrFkx5+bnKfP0U9VjIEydOFPlYyJUrV5rY2FjTr1+/Qse7+LGQb775pmd/Xl6e50bkJT12dvz48UH72NmqzsvPBbqIDZa87Nu3z3Oj/HHjxgW0gDUmePIyd+5cs3v37kLHO3/+vJk7d64JDQ0tU/FbVsGSl6JQxAaBH3/80bRr185IMk2bNjWjRo0yffv2NTabzUgyL730ks9xffr0MZLMjBkzCrXl5eWZYcOGGUmmTp06ZujQoWbo0KGeL5477rjDr28agShigyUv7hdJrVq1zHXXXWdGjRplRo4caXr06OF5YlOzZs3Mjh07KiMNhQRLXlJTUz3n7NChg5kwYUKRH1UhWPJizIWnuF1//fWeD3fB27BhQ6/9F/9QKI9HHnnESDKhoaHm5ptvNiNGjPDMaPTs2bPQk+QWLFhgJJmWLVv6PN7y5ctNjRo1jCRz/fXXm9GjR5vWrVsbSaZx48Zmz549Psft3r3bNGzY0EgyrVu3NqNHjzbXXXedkWRq1qxpVq5cWSHXW1rBkpdf/epXns/51VdfbSR5juH+eOqppyr68osUDHlx/8ITFhZmxo0bV+T3jqp67KwxwZEX9/ejNm3amKFDh5qxY8ea/v37e/4qFBISYmbPnl0Zl1+kYMhLUShig8Tp06fN1KlTTbt27UxYWJipX7++ufnmm8369euLHFPcD19jLvw59I033jBxcXEmIiLCREREmO7du5s33nij1L/luAWiiDUmOPKSnZ1t5syZY2677TbTpk0bU7duXVOzZk0TExNjevfubf7yl7/4nKWtTMGQl40bN3p+GJf0UVWCIS/G/N831pI+Nm7cWAFXfcGyZctM7969Tb169Ux4eLjp1KmT+dOf/mTOnTtXqG9JP2SMMWbbtm1m+PDhpmHDhqZWrVqmZcuW5sEHHzQ//PBDsXEcPXrUPPjgg6Zly5amVq1apmHDhmb48OEVVrD7Kxjy4v4aK+6jqn7Zcwt0Xlq2bFmq18iCBQsq6IpLJ9B5WbNmjbn33ntN165dTcOGDU3NmjVN3bp1TceOHc2vfvUrn39NqgqBzktRKqKItRljjAAAAAAL4e4EAAAAsByKWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDlUMQCAADAcihigWruwIEDstlsstlsOnDgQLF9W7VqJZvNpoULF1ZJbNVdQkKCz3wvXLhQNptNCQkJAYmrJH379pXNZtOnn34a6FBKrahcl1Wwf46ASwFFLAAAQcL9S2WrVq0CHQoQ9GoGOgAAgH+GDRumHj16KCoqKtChXDJmz56tqVOnqmnTpoEOBUApUcQCgMVERUVRwFawpk2bUsACFsNyAgDldvEayB07dmj48OGKiYlRWFiYrrrqKs2ZM0fGmELjLl6HuH//fo0bN05NmjRRWFiY2rRpoz/+8Y86d+5ckeddunSp+vfvr/r16yssLEwtW7bUpEmTlJGR4bO/e03vgQMH9P7776tfv36qX7++1/pN9/pgSVq8eLGuu+46RUZGqmHDhrrzzjt18OBBSZIxRq+++qquvvpqRUREKCYmRgkJCTp27Fih8+bm5mrx4sX65S9/qQ4dOqhevXoKDw9XbGysHnnkER05csSvfBe13tIde3EfTzzxRKHjffnll/rlL3+pFi1aKCwsTPXr19dNN92kjz76qMgYDh06pEmTJqlp06aqXbu22rVrp8cee0xnz57161okafLkybLZbHr++ecLtV111VWy2Wy67rrrCrU99dRTstlsevzxxwu1ZWRk6L777lObNm1Uu3ZtRUVFqXfv3lq8eLHPGIpbE5uXl6c5c+aoU6dOql27tho1aqSRI0fq66+/LtXa1+zsbCUmJqpt27YKCwtTkyZNNGHCBH3//feFYrjiiiskSd99912hzx0Ab8zEAqgw//jHP/T888+rTZs2GjBggI4ePSqn06nf/va3OnTokF588UWf43bs2KFf//rXuuyyy9SnTx+5XC5t3rxZzzzzjL766iutWrXKq78xRgkJCVq0aJFq1qyp3r17q1GjRtq+fbsWLFigZcuWKTk5WTfffLPP882ZM0evvvqq4uLidPPNN+vIkSOqUaOGV5/ExEQ999xz6t27twYNGqQvvvhCS5cu1ebNm7Vz507df//9Wr16tfr27avWrVtr8+bNSkpKUmpqqrZu3apatWp5jvXjjz9q3LhxioqK0pVXXqkuXbooOztbO3bs0CuvvKKlS5dqy5Ytatu2bbnyP2HChCLbli9frrNnzxa6zpdeekmTJ09WQUGBrr76al1//fX64Ycf9Omnn2rdunV68sknCxWJu3fvVp8+fXTs2DE1bdpUQ4cOVXZ2tl544QVt3LjR77jj4+P1wgsvaP369Zo8ebJn/5EjR/Sf//xH0oVC+9SpU4qOjva0r1+/3jP+YitWrND48eP1008/qUOHDho8eLBOnz6tzz//XOPGjdMnn3yi+fPnlyq2goICDRs2TB9++KFq1aqlvn376rLLLtPWrVvVvXt3TZo0qdjxp0+f1g033KCDBw+qV69e6tSpk/71r39p0aJF2rRpk3bu3OmZVXc4HMrKylJycrIiIiJ0xx13lCpGoNoyAKq1/fv3G0lGktm/f3+xfVu2bGkkmQULFnjt79Onj+cYb7zxhlfbhg0bjM1mMzVq1DCHDh3yapswYYJn3GOPPWby8vI8bbt27TIRERFGktmyZYvXuNdff91IMjExMSY1NdWzv6CgwMyYMcNIMtHR0ebYsWM+469Ro4Z5//33fV6jO54GDRqYHTt2ePbn5OQYh8NhJJnOnTubNm3amAMHDnjajx8/btq2bWskmcWLF3sd88yZM+b99983586d89p//vx5k5iYaCSZwYMHF4rFnZ+f53vBggVGkpkwYYLPa/i5adOmGUkmNjbWnDx50rN/7dq1xmazmZiYGLNp0yavMWlpacZutxtJ5tNPP/Vq6969u5FkRo0aZc6ePevZ/91335k2bdp4crhx48ZSxZeVlWVCQ0NNRESEV46SkpKMJNOlSxcjySQnJ/scc/78ea+4w8LCTO3atb36G2PMgQMHTOfOnY0kk5SU5NVWVK5feuklI8k0bdrU7N6927M/Ly/P/PrXv/Zc688/F+7PkSRz0003mdOnT3vaXC6Xufrqq40kM2vWLK9x7tdjy5YtS5U7oDqjiAWquYosYocPH+5z3M0332wkmUWLFnntdxcO1157rSkoKCg07v777zeSzFNPPeW1310ovfzyy4XGFBQUeIqeZ555xmf8kyZNKvIa3bn461//Wqht5cqVnvY1a9YUap8zZ46RZCZOnFjk8X1p1qyZCQkJMWfOnPHaXxFF7Ny5c40k07hxY7Nv3z6vtuuvv95IMu+++67PscuXLzeSzIgRIzz7nE6nkWQiIiLMiRMnCo1ZtWqV30WsMcb06tWrUME8btw4T64lmfvvv9/T5t43aNAgr+OMHj3aSDLPPfecz/N88cUXnq+5ixWV69atWxtJZu7cuYWOde7cOXP55ZcXW8RGRESYI0eOFBq7dOlSI8n069fPaz9FLFB6rIkFUGFuvfVWn/uvvPJKSSq0BtDtlltu8bnmz9e4w4cP69tvv5Xk+8/nNptNEydOlKQi/7Rdmj/TDh48uNC+du3aSZJq1qypgQMHFtle1BrXnTt36vnnn9fDDz+sSZMmKSEhQQkJCcrLy1NBQYH27t1bYlz+WLNmjR544AFFREToww8/9Ky3lKQTJ07oiy++UHh4eJGft759+0qStmzZ4tnnXjt88803q0GDBoXG3HbbbWV605l7SYB7iYAkbdiwQW3bttXgwYPVrFkzrzZfSwkKCgr08ccfS5JGjx7t8zxxcXGKjIxUamqqfvrpp2JjOnz4sPbt2ydJGjt2bKH2WrVqlfi1FBcX5/MNYyW9JgCUjDWxQDV3cfFofLz56mLu9qLeZNKiRQuf++vVqydJRRYN/oxz/9Bv0KCBp/3n2rRp49X350pzD05fMUVGRkq68E72mjULf/usW7duoXilC2/sGTduXKG1vT935syZEuMqrS+//NJTyC1btkxxcXFe7fv375cxRmfPnlVYWFixxzp+/Ljn/4cPH5Ykr4L4Yu57nO7cudOveOPj4zVjxgytX79eTz/9tL7++msdOXJEv/rVryRJ/fv311tvvaXvvvtOLVu29FnEnjx50pPD5s2bl3jOkydP6vLLLy+y3X2tMTExns/9z5X0tVTW1wSAklHEAtVcRESE5//Z2dnF9s3KypKkIn+gh4SU7Y87ZR1XVuHh4SX2KS4mf+NNTEzUqlWr1KFDB/3pT39S9+7dFRMT43nz1w033KB//etfJf4SUVoHDhzQkCFDlJ2drTfffFNDhgwp1KegoEDShc/liBEjKuS85XHdddepXr162rp1q06fPu0pUgcMGCDpQrH61ltvKSUlRUOHDlV6eroaNWqkzp07e47hviap+De5uZVUvLsVd2eAku4aUNVf20B1QhELVHP169dXZGSksrKytHfvXnXq1MlnP5fLJZfLJano2aWq4J45c8+6+ZqNdf8JuLhZtqq0fPlySRdmRLt06VKofc+ePRV2LpfLpUGDBunHH3/UY489pv/3//6fz37umUqbzab58+eXuthy57S4RxR/9913/gWtC0s0+vTpow8++EAbN27U+vXrVaNGDd14442SvJcb1KlTR8YY9e/f36uIjImJUXh4uM6ePavnnntOMTExfsdxMfe1Hj9+XNnZ2V6/8LmV9KhmAJWHXxGBai4kJER9+vSRJCUnJxfZ791335UkXXbZZbr66qurIjSf7Ha7Z7mAr3t6GmM8+90FUKC5i/+WLVsWavvHP/6hEydOVMh5zp07p9tuu027d+/W+PHjNXPmzCL7NmvWTF26dFFmZqbWrl1b6nO4v1bWrl3rua6LrV69WqdOnfI7dun/CtWPP/5YmzZtUlxcnOeWWs2aNdOVV16pDRs2KCUlxau/W40aNTwzt+5fHMqjefPmnuUC77zzTqH28+fPF/uaKQv37HxeXl6FHhe4FFHEAtDvf/972Ww2vf3225o3b16h9n/961+aNm2aJGnKlCkKDQ2t6hC9/Pa3v5UkPf30015rL40xmjlzpnbs2KHo6OgiZyGrmvtNPK+88orX/m+++Ub3339/hZzDGKNx48bJ6XQqPj5ef//730sc4y5yJ06cqA8++MDnMT///HOtW7fOs69Xr17q1q2bsrKy9OCDD3o9jOLQoUOez01ZuIvSRYsW6cyZM56C9OL2EydOaOnSpV79LzZjxgzVqlVLv/vd75SUlOS1xMAtPT1dK1euLFVMjzzyiOe4Fz9Eo6CgQImJiTp06FDpLq6UGjZsqFq1aumHH37w+UsCgP/DcgIA6t27t1588UVNnjxZ99xzj2bNmqVu3bqpZs2a2rt3r7788ksZYzRmzBhNnTo10OHqvvvu05YtW/TWW28pLi5Offr08Tzs4JtvvlF4eLiWLFmihg0bBjpUSRcKoDvuuEPTp0/X8uXL1bFjRx07dkyfffaZevXqpWbNmnndAaAsnE6nVqxYIenCG8yKKuBvv/123X777ZIu3E3ipZde0pQpUzR06FC1bdtWsbGxioqK0vHjx7Vz504dO3ZMf/jDH7zuxvDWW2+pb9++Wrp0qf75z3/K4XAoJydHn3zyibp06aKYmBj961//8vsarrrqKjVr1sxzdwdfRewrr7yin376Se3atfO5rKVbt25avHix584Pf/zjH3XVVVepYcOGcrlc2rVrlw4fPqzRo0dr+PDhJcb0yCOPKCUlRR9//LG6dOmiG2+8UdHR0dq6dauOHDmiBx54QK+99prXwy3KIzQ0VEOHDtW7776rq6++Wg6HQ3Xq1JGkUv1iAlQnFLEAJF34Yd27d2+9+uqr+uc//6mPPvpIeXl5atiwoW677TZNnDhRQ4cODXSYki6s41y0aJEGDRqkN998U19++aWys7PVpEkTJSQkaOrUqYqNjQ10mB7Dhw/Xpk2b9OSTT2rnzp369ttv1bp1az3xxBP67W9/6/N2Xf7Kz8/3/L+4uyC0atXKU8RKFz7v/fr10yuvvKKNGzdqw4YNCgkJUZMmTXTNNddoyJAhhd74ddVVV2nbtm2aMWOGPv74Y7333nuy2+16+OGH9fjjj/u8PVlpue9CEBERoV/84hdebX379lXNmjWVl5fncxbWbeTIkerevbtefvllpaSkaPPmzcrPz1fjxo3Vtm1bPfTQQ6V+GlaNGjX0/vvv68UXX9TChQu1ceNG1a1bV7169dJ7773nyXV5199ebO7cuWrQoIE+/vhjvfvuu8rNzZVEEQv8nM1U1NthAQCoZvr166eNGzcqOTm5VDO7ACoOa2IBACjGjh07dP78ea9958+f1xNPPKGNGzeqUaNG5Zp9BlA2LCcAAKAYjz76qHbs2KGuXbuqadOm+u9//6tdu3bp6NGjql27tpKSklS7du1AhwlUOywnAACgGG+//bbefvttpaWl6eTJkzLGqFmzZrrxxhs1ZcoUXXXVVYEOEaiWKGIBAABgOayJBQAAgOVQxAIAAMByKGIBAABgORSxAAAAsByKWAAAAFgORSwAAAAshyIWAAAAlkMRCwAAAMuhiAUAAIDl/H/h/wAaYtRSKgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "device(type='cuda')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -832,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -846,61 +777,61 @@ "name": "stdout", "output_type": "stream", "text": [ - "Test loss 0.0033 test acc. 88.78%\n", + "Test loss 0.0053 test acc. 82.19%\n", "Test loss 0.0019 test acc. 93.97%\n", - "Test loss 0.0036 test acc. 87.66%\n", - "Test loss 0.0019 test acc. 93.68%\n", - "Test loss 0.0032 test acc. 88.64%\n", - "Test loss 0.0019 test acc. 93.72%\n", - "Test loss 0.0031 test acc. 89.45%\n", + "Test loss 0.0068 test acc. 78.89%\n", + "Test loss 0.0019 test acc. 93.67%\n", + "Test loss 0.0054 test acc. 81.96%\n", + "Test loss 0.0019 test acc. 93.71%\n", + "Test loss 0.0055 test acc. 81.99%\n", "Test loss 0.0019 test acc. 93.63%\n", - "Test loss 0.0036 test acc. 87.65%\n", + "Test loss 0.0081 test acc. 76.28%\n", "Test loss 0.0019 test acc. 93.54%\n", - "Test loss 0.0036 test acc. 87.44%\n", - "Test loss 0.0020 test acc. 93.22%\n", - "Test loss 0.0034 test acc. 88.21%\n", - "Test loss 0.0020 test acc. 93.36%\n", - "Test loss 0.0040 test acc. 87.01%\n", + "Test loss 0.0077 test acc. 75.50%\n", + "Test loss 0.0020 test acc. 93.23%\n", + "Test loss 0.0084 test acc. 74.17%\n", "Test loss 0.0020 test acc. 93.37%\n", - "Test loss 0.0036 test acc. 87.88%\n", - "Test loss 0.0020 test acc. 93.36%\n", - "Test loss 0.0042 test acc. 86.62%\n", + "Test loss 0.0100 test acc. 71.00%\n", + "Test loss 0.0020 test acc. 93.37%\n", + "Test loss 0.0077 test acc. 75.34%\n", "Test loss 0.0020 test acc. 93.36%\n", - "Test loss 0.0057 test acc. 82.82%\n", - "Test loss 0.0020 test acc. 93.26%\n", - "Test loss 0.0048 test acc. 84.68%\n", - "Test loss 0.0021 test acc. 92.89%\n", - "Test loss 0.0051 test acc. 83.34%\n", + "Test loss 0.0096 test acc. 72.63%\n", + "Test loss 0.0020 test acc. 93.35%\n", + "Test loss 0.0136 test acc. 63.10%\n", + "Test loss 0.0020 test acc. 93.27%\n", + "Test loss 0.0136 test acc. 61.79%\n", + "Test loss 0.0021 test acc. 92.87%\n", + "Test loss 0.0119 test acc. 64.55%\n", "Test loss 0.0021 test acc. 92.76%\n", - "Test loss 0.0050 test acc. 83.18%\n", - "Test loss 0.0021 test acc. 92.90%\n", - "Test loss 0.0050 test acc. 83.71%\n", - "Test loss 0.0021 test acc. 92.72%\n", - "Test loss 0.0069 test acc. 78.54%\n", - "Test loss 0.0025 test acc. 91.39%\n", - "Test loss 0.0065 test acc. 79.48%\n", + "Test loss 0.0119 test acc. 64.27%\n", + "Test loss 0.0021 test acc. 92.92%\n", + "Test loss 0.0116 test acc. 65.11%\n", + "Test loss 0.0021 test acc. 92.74%\n", + "Test loss 0.0195 test acc. 47.69%\n", + "Test loss 0.0025 test acc. 91.38%\n", + "Test loss 0.0172 test acc. 49.95%\n", "Test loss 0.0025 test acc. 91.97%\n", - "Test loss 0.0076 test acc. 76.09%\n", - "Test loss 0.0024 test acc. 91.88%\n", - "Test loss 0.0059 test acc. 80.29%\n", + "Test loss 0.0198 test acc. 44.55%\n", + "Test loss 0.0024 test acc. 91.86%\n", + "Test loss 0.0152 test acc. 53.56%\n", "Test loss 0.0025 test acc. 91.81%\n", - "Test loss 0.0074 test acc. 78.20%\n", + "Test loss 0.0200 test acc. 46.39%\n", "Test loss 0.0023 test acc. 92.37%\n", - "Test loss 0.0088 test acc. 73.72%\n", - "Test loss 0.0029 test acc. 90.65%\n", - "Test loss 0.0087 test acc. 72.81%\n", + "Test loss 0.0304 test acc. 30.78%\n", + "Test loss 0.0029 test acc. 90.64%\n", + "Test loss 0.0255 test acc. 33.30%\n", "Test loss 0.0025 test acc. 91.41%\n", - "Test loss 0.0107 test acc. 68.39%\n", - "Test loss 0.0026 test acc. 91.45%\n", - "Test loss 0.0077 test acc. 75.68%\n", - "Test loss 0.0025 test acc. 91.74%\n", - "Test loss 0.0088 test acc. 73.60%\n", + "Test loss 0.0267 test acc. 32.28%\n", + "Test loss 0.0026 test acc. 91.47%\n", + "Test loss 0.0260 test acc. 34.54%\n", + "Test loss 0.0025 test acc. 91.75%\n", + "Test loss 0.0245 test acc. 34.71%\n", "Test loss 0.0025 test acc. 91.80%\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -910,7 +841,7 @@ } ], "source": [ - "converted_model = convert_to_analog(model, StandardHWATrainingPreset())\n", + "converted_model = convert_to_analog(model, gen_rpu_config())\n", "# - For programming the model, we need to put it into eval() mode\n", "converted_model = converted_model.eval()\n", "analog_model = analog_model.eval()\n", @@ -952,7 +883,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "torch-nightly", "language": "python", "name": "python3" }, @@ -966,12 +897,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" - }, - "vscode": { - "interpreter": { - "hash": "8552d10987f98ef8320154686d1598142476aa8dfb1019e7b5164f51d5b1d29f" - } + "version": "3.10.13" } }, "nbformat": 4, From 908377b51b1d1f0648ec8761682d1f3ee1a46e73 Mon Sep 17 00:00:00 2001 From: charlesmackin <45808803+charlesmackin@users.noreply.github.com> Date: Thu, 26 Dec 2024 01:48:22 -0800 Subject: [PATCH 10/14] Weight Programming Optimization Feature Addition (#703) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * passing code checkers Signed-off-by: Charles Mackin * minor updates Signed-off-by: Charles Mackin --------- Signed-off-by: Charles Mackin Co-authored-by: Charles Mackin Signed-off-by: Pablo Carmona González --- .../33_weight_programming_optimization.py | 1090 +++++++++++++++++ requirements-examples.txt | 3 + src/aihwkit/inference/converter/wpo.py | 638 ++++++++++ tests/test_inference_tiles.py | 84 +- 4 files changed, 1813 insertions(+), 2 deletions(-) create mode 100644 examples/33_weight_programming_optimization.py create mode 100644 src/aihwkit/inference/converter/wpo.py diff --git a/examples/33_weight_programming_optimization.py b/examples/33_weight_programming_optimization.py new file mode 100644 index 00000000..5fec9111 --- /dev/null +++ b/examples/33_weight_programming_optimization.py @@ -0,0 +1,1090 @@ +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# Licensed under the MIT license. See LICENSE file in the project root for details. + +"""aihwkit example 33: Example using weight programming optimization to improve BERT transformer +accuracy on SQuAD task. Weight Programming Optimization implementation which is similar to the +framework reported in the following paper: + + C. Mackin, et al., "Optimised weight programming for analogue memory-based + deep neural networks" 2022. https://www.nature.com/articles/s41467-022-31405-1. + +The example is adapted from code in + https://github.com/huggingface/notebooks/blob/main/examples/question_answering.ipynb +""" +# pylint: disable=invalid-name, too-many-locals, import-error +# pylint: disable=too-many-branches, too-many-lines, too-many-statements +import os +import pickle +from typing import Type, Dict, List + +from argparse import ArgumentParser +from collections import OrderedDict, defaultdict +from copy import deepcopy +from numpy import argsort + +import numpy as np +import matplotlib.pyplot as plt + +from transformers import ( + AutoTokenizer, + AutoModelForQuestionAnswering, + Trainer, + TrainingArguments, + DefaultDataCollator, +) + +import torch + +from evaluate import load +from datasets import load_dataset + +from aihwkit.simulator.configs import ( + InferenceRPUConfig, + WeightClipType, + WeightNoiseType, + BoundManagementType, + NoiseManagementType, + WeightClipParameter, + MappingParameter, +) + +from aihwkit.simulator.presets import PresetIOParameters +from aihwkit.inference import PCMLikeNoiseModel, GlobalDriftCompensation +from aihwkit.nn.conversion import convert_to_analog + +from aihwkit.nn import AnalogLinear +from aihwkit.inference.converter.conductance import ( + BaseConductanceConverter, + SinglePairConductanceConverter, + DualPairConductanceConverter, +) +from aihwkit.inference.converter.wpo import ( + WeightProgrammingOptimizer, + loss_weights, + downsample_weight_distribution, +) + +# Check device +DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") + +# max length and stride specific to pretrained model +MAX_LENGTH = 320 +DOC_STRIDE = 128 + +# specifications +IN_FEATURES = 512 +OUT_FEATURES = 1024 +BATCH_SIZE = 512 +SUFFIX = 'bert' + +rmin, rmax = (0.00, 0.80) # blue color specs +bmin, bmax = (0.27, 1.00) +gmin, gmax = (0.80, 0.93) + +# BERT model from Hugging Face model hub fine-tuned on SQuAD v1 +MODEL_NAME = "csarron/bert-base-uncased-squad-v1" +TOKENIZER = AutoTokenizer.from_pretrained(MODEL_NAME) + +# Parse some arguments +parser = ArgumentParser("bert example") +parser.add_argument('--result_dir', default='33_results', type=str) +parser.add_argument('--sub_dir', default='m0.1_r0.3_kw1_lm0.2', type=str) +parser.add_argument('--mutation', default=0.1, type=float) +parser.add_argument('--recombination', default=0.3, type=float) +parser.add_argument('--use_max_kw', default=1, type=int) +parser.add_argument('--loss_margin', default=0.2, type=float) +parser.add_argument('--test_out_features', default=20, type=int) +parser.add_argument('--optimize', default=1, type=int) +parser.add_argument('--inference', default=1, type=int) +parser.add_argument('--optimize_f_lst', default=1, type=int) +args = parser.parse_args() + + +args.sub_dir = 'm' + str(args.mutation) + '_r' + str(args.recombination) \ + + '_kw' + str(args.use_max_kw) + '_lm' + str(args.loss_margin) +args.result_dir = os.path.join(args.result_dir, args.sub_dir) +os.makedirs(args.result_dir, exist_ok=True) + + +def plot_g_converters(g_converter_baseline: Type[BaseConductanceConverter], + g_converter_optimized: Type[BaseConductanceConverter], + weights: torch.Tensor, suffix: str = ''): + """Plots comparison on weight programming strategies (baseline vs optimized)""" + max_abs_w_unitless = np.amax(np.abs(weights.detach().cpu().numpy())) + + rows, cols = 1, 2 + width, height = 6, 5 + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + + plt.subplot(rows, cols, 1) + w_unitless = np.linspace(-max_abs_w_unitless, max_abs_w_unitless, 1000) + w_uS = np.zeros_like(w_unitless) + f_lst = [1.0] if isinstance(g_converter_baseline, + SinglePairConductanceConverter) else g_converter_baseline.f_lst + for j, f in enumerate(f_lst): + g_lst, _ = g_converter_baseline.convert_to_conductances(torch.Tensor(w_unitless)) + gp_j, gm_j = g_lst[0::2][j], g_lst[1::2][j] + plt.plot(w_unitless, gp_j, label=r"$g_{%d}^+(W)$" % j) + plt.plot(w_unitless, gm_j, label=r"$g_{%d}^-(W)$" % j) + w_uS += f * (np.asarray(gp_j) - np.asarray(gm_j)) + plt.xlabel(r"$Weight \ [1]$") + plt.ylabel(r"$Conductance \ [\mu S]$") + title_str = type(g_converter_baseline).__name__ + \ + ' (' + ', '.join([r"$f_{%d}=%0.1f$" % (i, f) for i, f in enumerate(f_lst)]) + ')' + plt.title(title_str) + plt.legend() + + plt.subplot(rows, cols, 2) + w_unitless = np.linspace(-max_abs_w_unitless, + max_abs_w_unitless, + len(g_converter_optimized.g_lst[0])) + w_uS = np.zeros_like(w_unitless) + f_lst = g_converter_optimized.f_lst + for j, f in enumerate(f_lst): + gp_j, gm_j = g_converter_optimized.g_lst[0::2][j], g_converter_optimized.g_lst[1::2][j] + plt.plot(w_unitless, gp_j, label=r"$g_{%d}^+(W)$" % j) + plt.plot(w_unitless, gm_j, label=r"$g_{%d}^-(W)$" % j) + w_uS += f * (np.asarray(gp_j) - np.asarray(gm_j)) + plt.xlabel(r"$Weight \ [1]$") + plt.ylabel(r"$Conductance \ [\mu S]$") + title_str = type(g_converter_optimized).__name__ + \ + ' (' + ', '.join([r"$f_{%d}=%0.1f$" % (i, f) for i, f in enumerate(f_lst)]) + ')' + plt.title(title_str) + plt.legend() + + plt.savefig(os.path.join(args.result_dir, type(g_converter_baseline).__name__ + + '_vs_' + type(g_converter_optimized).__name__ + + '_' + suffix + '.png')) + plt.close() + + +def plot_weights(weights, filename=''): + """Plots histogram of weight distribution""" + plt.figure() + plt.hist(weights.flatten(), bins=100, density=True) + plt.xlabel('Weights [1]') + plt.ylabel('Density [1]') + plt.savefig(os.path.join(args.result_dir, filename)) + plt.close() + + +def plot_contour(ideal_vals: torch.Tensor, time_dict: Dict, + effective_vals_lst: List[np.ndarray], + xlabel: str = '', ylabel: str = ''): + """ + Generates color coded contour plots which show maximum weight dispersion as + a function of time. + + Args: + ideal_vals: ideal values (weights or activations) + time_dict: dictionary with numerical time steps at which weight programming + was evaluated with corresponding time step labels for plotting + effective_vals_lst: list of effective values at each time step + xlabel: x axis label for graph + ylabel: y axis label for graph + + Returns: None + """ + + ideal_vals = ideal_vals.detach().cpu().numpy().flatten() + effective_vals_lst = [w.flatten() + for w in effective_vals_lst] + + for i, (label, effective_vals) in enumerate(zip(time_dict.keys(), + effective_vals_lst)): + + density, xbins, ybins = np.histogram2d(ideal_vals, + effective_vals, + bins=200, + range=[[np.amin(ideal_vals), + np.amax(ideal_vals)], + [np.amin(effective_vals_lst[-1]), + np.amax(effective_vals_lst[-1])]], + density=True) + + ratio = (float(i) + 1.) / len(effective_vals_lst) + rbg = (np.clip(rmin + (rmax - rmin) * ratio, rmin, rmax), + np.clip(bmin + (bmax - bmin) * ratio, bmin, bmax), + np.clip(gmin + (gmax - gmin) * ratio, gmin, gmax)) + + _ = plt.contour(density.transpose(), + extent=[xbins[0], xbins[-1], ybins[0], ybins[-1]], + linewidths=1, + colors=[rbg], + levels=[0.0]) + plt.plot(10, 10, color=rbg, label=label) + + ax = plt.gca() + color_sel = (rmin, bmin, gmin) + ax.spines['bottom'].set_color(color_sel) + ax.spines['top'].set_color(color_sel) + ax.spines['right'].set_color(color_sel) + ax.spines['left'].set_color(color_sel) + ax.tick_params(axis='x', colors=color_sel) + ax.tick_params(axis='y', colors=color_sel) + ax.xaxis.label.set_color(color_sel) + ax.yaxis.label.set_color(color_sel) + plt.xlabel(xlabel) + plt.ylabel(ylabel) + plt.xlim(np.amin(ideal_vals), np.amax(ideal_vals)) + plt.ylim(np.amin(effective_vals_lst[-1]), np.amax(effective_vals_lst[-1])) + for text in ax.legend(loc='upper left').get_texts(): + color_sel = (rmin, bmin, gmin) + text.set_color(color_sel) + + +def plot_errors(ideal_weights: torch.Tensor, time_dict: Dict, + effective_weights_time_lst: List[np.ndarray], + xlabel: str = '', ylabel: str = ''): + """ + Generates color coded contour plots which show maximum weight dispersion as + a function of time. + + Args: + ideal_weights: ideal weights we wish to program + time_dict: dictionary with numerical time steps at which weight programming + was evaluated with corresponding time step labels for plotting + effective_weights_time_lst: list of effective weights at each time step + xlabel: x axis label for graph + ylabel: y axis label for graph + + Returns: None + """ + + ideal_weights = ideal_weights.detach().cpu().numpy().flatten() + effective_weights_time_lst = [w.flatten() + for w in effective_weights_time_lst] + + for i, (label, effective_weights) in enumerate(zip(time_dict.keys(), + effective_weights_time_lst)): + + ratio = (float(i) + 1.) / len(effective_weights_time_lst) + rbg = (np.clip(rmin + (rmax - rmin) * ratio, rmin, rmax), + np.clip(bmin + (bmax - bmin) * ratio, bmin, bmax), + np.clip(gmin + (gmax - gmin) * ratio, gmin, gmax)) + + plt.hist(effective_weights - ideal_weights, + density=True, + bins=100, + color=rbg, + zorder=len(effective_weights_time_lst) - i) + + plt.plot(10, 10, color=rbg, label=label) + + ax = plt.gca() + color_sel = (rmin, bmin, gmin) + ax.spines['bottom'].set_color(color_sel) + ax.spines['top'].set_color(color_sel) + ax.spines['right'].set_color(color_sel) + ax.spines['left'].set_color(color_sel) + ax.tick_params(axis='x', colors=color_sel) + ax.tick_params(axis='y', colors=color_sel) + ax.xaxis.label.set_color(color_sel) + ax.yaxis.label.set_color(color_sel) + plt.xlabel(xlabel) + plt.ylabel(ylabel) + plt.xlim(np.amin(ideal_weights), np.amax(ideal_weights)) + for text in ax.legend(loc='upper left').get_texts(): + color_sel = (rmin, bmin, gmin) + text.set_color(color_sel) + + +def plot_weight_comparison(d: Dict, suffix: str = ''): + """Plots weight programming strategy + + Args: + d: dictionary containing ideal_weights, time_dict, list of effective + weights, title string, and correspond loss for plotting + suffix: string with model name for plot naming + + Returns: None + """ + print("Plotting weight dispersion comparison over time: %s" + % os.path.join(args.result_dir, d['baseline_title'] + '_comparison.png')) + + xmax = np.amax(np.abs(np.asarray(d['ideal_weights'].detach().cpu().numpy()))) + ymax = np.amax(np.abs(np.asarray( + d['effective_weights_baseline_time_lst'] + d['effective_weights_optimized_time_lst']))) + xymax = max([xmax, ymax]) + + rows, cols = 1, 2 + width, height = 6, 5 + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + plt.subplot(rows, cols, 1) + plot_contour(d['ideal_weights'], + d['time_dict'], + d['effective_weights_baseline_time_lst'], + xlabel=r'$Ideal \ Weights \ [1]$', + ylabel=r'$Effective \ Weights \ [1]$') + plt.xlim(-xmax, xmax) + plt.ylim(-ymax, ymax) + plt.plot(np.linspace(-xymax, xymax, 2), np.linspace(-xymax, xymax, 2), '--', c='gray') + title_str = "%s (Loss = %0.6f)" % (d['baseline_title'], + np.round(d['baseline_loss'], + decimals=6)) + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.subplot(rows, cols, 2) + plot_contour(d['ideal_weights'], + d['time_dict'], + d['effective_weights_optimized_time_lst'], + xlabel=r'$Ideal \ Weights \ [1]$', + ylabel=r'$Effective \ Weights \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['optimized_title'], + np.round(d['optimized_loss'], + decimals=6)) + plt.xlim(-xmax, xmax) + plt.ylim(-ymax, ymax) + plt.plot(np.linspace(-xymax, xymax, 2), np.linspace(-xymax, xymax, 2), '--', c='gray') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.tight_layout() + plt.savefig(os.path.join(args.result_dir, + d['baseline_title'] + '_w_comparison_' + suffix + '.png')) + plt.close() + + # make corresponding error plots + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + plt.subplot(rows, cols, 1) + plot_errors(d['ideal_weights'], + d['time_dict'], + d['effective_weights_baseline_time_lst'], + xlabel=r'$Weight \ Errors \ [1]$', + ylabel=r'$Density \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['baseline_title'], + np.round(d['baseline_loss'], + decimals=6)) + plt.gca().set_yscale('log') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.subplot(rows, cols, 2) + plot_errors(d['ideal_weights'], + d['time_dict'], + d['effective_weights_optimized_time_lst'], + xlabel=r'$Weight \ Errors \ [1]$', + ylabel=r'$Density \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['optimized_title'], + np.round(d['optimized_loss'], + decimals=6)) + plt.gca().set_yscale('log') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.tight_layout() + plt.savefig(os.path.join(args.result_dir, + d['baseline_title'] + '_w_error_comparison_' + suffix + '.png')) + plt.close() + + +def plot_z_comparison(d: Dict, suffix: str = ''): + """Plots weight programming strategy + + Args: + d: dictionary containing ideal_weights, time_dict, list of effective + weights, title string, and correspond loss for plotting + suffix: string with model name to label plots + + Returns: None + """ + print("Plotting z dispersion comparison over time: %s" + % os.path.join(args.result_dir, d['baseline_title'] + '_comparison.png')) + + xmax = np.amax(np.abs(np.asarray(d['z_ideal'].detach().cpu().numpy()))) + ymax = np.amax(np.abs(np.asarray( + d['z_baseline_time_lst'] + d['z_optimized_time_lst']))) + xymax = max([xmax, ymax]) + + rows, cols = 1, 2 + width, height = 6, 5 + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + plt.subplot(rows, cols, 1) + plot_contour(d['z_ideal'], + d['time_dict'], + d['z_baseline_time_lst'], + xlabel=r'$Ideal \ Activations \ [1]$', + ylabel=r'$Actual \ Activations \ [1]$') + plt.xlim(-xmax, xmax) + plt.ylim(-ymax, ymax) + plt.plot(np.linspace(-xymax, xymax, 2), np.linspace(-xymax, xymax, 2), '--', c='gray') + title_str = "%s (Loss = %0.6f)" % (d['baseline_title'], + np.round(d['baseline_loss'], + decimals=6)) + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.subplot(rows, cols, 2) + plot_contour(d['z_ideal'], + d['time_dict'], + d['z_optimized_time_lst'], + xlabel=r'$Ideal \ Activations \ [1]$', + ylabel=r'$Actual \ Activations \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['optimized_title'], + np.round(d['optimized_loss'], + decimals=6)) + plt.xlim(-xmax, xmax) + plt.ylim(-ymax, ymax) + plt.plot(np.linspace(-xymax, xymax, 2), np.linspace(-xymax, xymax, 2), '--', c='gray') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.tight_layout() + plt.savefig(os.path.join(args.result_dir, + d['baseline_title'] + '_z_comparison_' + suffix + '.png')) + plt.close() + + # make corresponding error plots + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + plt.subplot(rows, cols, 1) + plot_errors(d['z_ideal'], + d['time_dict'], + d['z_baseline_time_lst'], + xlabel=r'$Activations \ Errors \ [1]$', + ylabel=r'$Density \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['baseline_title'], + np.round(d['baseline_loss'], + decimals=6)) + plt.gca().set_yscale('log') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.subplot(rows, cols, 2) + plot_errors(d['z_ideal'], + d['time_dict'], + d['z_optimized_time_lst'], + xlabel=r'$Activations \ Errors \ [1]$', + ylabel=r'$Density \ [1]$') + title_str = "%s (Loss = %0.6f)" % (d['optimized_title'], + np.round(d['optimized_loss'], + decimals=6)) + plt.gca().set_yscale('log') + plt.title(title_str, color=(rmin, bmin, gmin)) + plt.tight_layout() + plt.savefig(os.path.join(args.result_dir, + d['baseline_title'] + '_z_error_comparison_' + suffix + '.png')) + plt.close() + + +def plot_accuracy_comparison(acc_dict: Dict, suffix: str = ''): + """Plots accuracies to compare baseline and optimized weight + programming strategies""" + + print("Plotting accuracy comparison over time: %s" + % os.path.join(args.result_dir, 'accuracy_comparison.png')) + time_steps = np.asarray(list(acc_dict['time_dict'].values())) + + rows, cols = 1, 2 + width, height = 6, 5 + plt.subplots(rows, cols, figsize=(cols * width, rows * height)) + plt.subplot(rows, cols, 1) + plt.plot(time_steps, + np.asarray(acc_dict['accuracy_baseline']['f1_lst']), + label=acc_dict['label_baseline']) + plt.plot(time_steps, + np.asarray(acc_dict['accuracy_optimized']['f1_lst']), + label=acc_dict['label_optimized']) + plt.gca().set_xscale('log') + plt.gca().set_xticks(list(acc_dict['time_dict'].values())) + plt.gca().set_xticklabels(list(acc_dict['time_dict'].keys())) + plt.xlabel('Time [1]') + plt.ylabel('F1 Score [1]') + plt.legend() + + plt.subplot(rows, cols, 2) + plt.plot(time_steps, + np.asarray(acc_dict['accuracy_baseline']['exact_match_lst']), + label=acc_dict['label_baseline']) + plt.plot(time_steps, + np.asarray(acc_dict['accuracy_optimized']['exact_match_lst']), + label=acc_dict['label_optimized']) + plt.gca().set_xscale('log') + plt.gca().set_xticks(list(acc_dict['time_dict'].values())) + plt.gca().set_xticklabels(list(acc_dict['time_dict'].keys())) + plt.xlabel('Time [1]') + plt.ylabel('Exact Match [1]') + plt.legend() + plt.tight_layout() + plt.savefig(os.path.join(args.result_dir, 'accuracy_comparison_' + suffix + '.png')) + plt.close() + + +def plot_device_models(rpu_config, filename): + """Plots device models (programming errors, drift coffecients, read noise) as a reference""" + + g_lin = torch.linspace(rpu_config.noise_model.g_converter.g_min, + rpu_config.noise_model.g_converter.g_max, + 1000) + gs = g_lin.repeat(10000, 1) + g_prog = rpu_config.noise_model.apply_programming_noise_to_conductance(gs) + g_nu = rpu_config.noise_model.generate_drift_coefficients(gs) + g_read_noise = rpu_config.noise_model.apply_drift_noise_to_conductance(gs, + torch.zeros_like(gs), + 1.0) + + rows, cols = 1, 3 + plt.subplots(rows, cols, figsize=(5 * cols, 4)) + plt.subplot(rows, cols, 1) + plt.plot(g_lin, g_prog.mean(0) - g_lin) + plt.fill_between(g_lin, -g_prog.std(0), g_prog.std(0), alpha=0.2) + plt.xlabel(r"$Conductance \ [\mu S]$") + plt.ylabel(r"$Programming \ Error \ [\mu S]$") + + plt.subplot(rows, cols, 2) + plt.plot(g_lin, g_nu.mean(0)) + plt.fill_between(g_lin, + g_nu.mean(0) - g_nu.std(0), + g_nu.mean(0) + g_nu.std(0), alpha=0.2) + plt.xlabel(r"$Conductance \ [\mu S]$") + plt.ylabel(r"$Drift \ Coefficient \ [1]$") + + plt.subplot(rows, cols, 3) + plt.plot(g_lin, g_read_noise.mean(0) - g_lin) + plt.fill_between(g_lin, -g_read_noise.std(0), g_read_noise.std(0), alpha=0.2) + plt.xlabel(r"$Conductance \ [\mu S]$") + plt.ylabel(r"$Read \ Noise \ [\mu S]$") + + plt.tight_layout() + plt.savefig(filename) + plt.close() + + +def create_rpu_config(tile_size=512, dac_res=256, adc_res=256): + """Create RPU Config emulated typical PCM Device""" + + rpu_config = InferenceRPUConfig( + clip=WeightClipParameter(type=WeightClipType.FIXED_VALUE, fixed_value=1.0), + mapping=MappingParameter( + digital_bias=True, + learn_out_scaling=True, + weight_scaling_omega=1.0, + out_scaling_columnwise=True, + weight_scaling_columnwise=True, + max_input_size=tile_size, + max_output_size=0, + ), + forward=PresetIOParameters( + w_noise_type=WeightNoiseType.PCM_READ, + w_noise=0.0175, + inp_res=dac_res, + out_res=adc_res, + out_bound=10.0, + out_noise=0.04, + bound_management=BoundManagementType.ITERATIVE, + noise_management=NoiseManagementType.ABS_MAX, + ), + noise_model=PCMLikeNoiseModel(), + drift_compensation=GlobalDriftCompensation(), + ) + return rpu_config + + +def create_model(rpu_config): + """Return Question Answering model and whether or not it was loaded from a checkpoint""" + + model = AutoModelForQuestionAnswering.from_pretrained(MODEL_NAME) + + model = convert_to_analog(model, rpu_config) + model.remap_analog_weights() + + return model + + +def preprocess_validation(dataset): + """Preprocess the validation set""" + # Some of the questions have lots of whitespace on the left, + # which is not useful and will make the + # truncation of the context fail (the tokenized question will take a lots of space). + # So we remove that + # left whitespace + dataset["question"] = [q.lstrip() for q in dataset["question"]] + + # Tokenize our dataset with truncation and maybe padding, + # but keep the overflows using a stride. This results + # in one example possible giving several features when a context is long, + # each of those features having a + # context that overlaps a bit the context of the previous feature. + tokenized_dataset = TOKENIZER( + dataset["question"], + dataset["context"], + truncation="only_second", + max_length=MAX_LENGTH, + stride=DOC_STRIDE, + return_overflowing_tokens=True, + return_offsets_mapping=True, + padding="max_length", + ) + + # Since one example might give us several features if it has a long context, + # we need a map from a feature to + # its corresponding example. This key gives us just that. + sample_mapping = tokenized_dataset.pop("overflow_to_sample_mapping") + + # We keep the example_id that gave us this feature and we will store the offset mappings. + tokenized_dataset["example_id"] = [] + + for i in range(len(tokenized_dataset["input_ids"])): + # Grab the sequence corresponding to that example + # (to know what is the context and what is the question). + sequence_ids = tokenized_dataset.sequence_ids(i) + context_index = 1 + + # One example can give several spans, + # this is the index of the example containing this span of text. + sample_index = sample_mapping[i] + tokenized_dataset["example_id"].append(dataset["id"][sample_index]) + + # Set to None the offset_mapping that are not + # part of the context so it's easy to determine if a token + # position is part of the context or not. + tokenized_dataset["offset_mapping"][i] = [ + (o if sequence_ids[k] == context_index else None) + for k, o in enumerate(tokenized_dataset["offset_mapping"][i]) + ] + + return tokenized_dataset + + +def postprocess_predictions( + examples, features, raw_predictions, n_best_size=20, max_answer_length=30 +): + """Postprocess raw predictions""" + features.set_format(type=features.format["type"], columns=list(features.features.keys())) + all_start_logits, all_end_logits = raw_predictions + + # Map examples ids to index + example_id_to_index = {k: i for i, k in enumerate(examples["id"])} + + # Create dict of lists, mapping example indices with corresponding feature indices + features_per_example = defaultdict(list) + + for i, feature in enumerate(features): + # For each example, take example_id, map to corresponding index + features_per_example[example_id_to_index[feature["example_id"]]].append(i) + + # The dictionaries we have to fill + predictions = OrderedDict() + + print( + f"Post-processing {len(examples)} example predictions " + f"split into {len(features)} features." + ) + + # Loop over all examples + for example_index, example in enumerate(examples): + # Find the feature indices corresponding to the current example + feature_indices = features_per_example[example_index] + + # Store valid answers + valid_answers = [] + + context = example["context"] + # Looping through all the features associated to the current example. + for feature_index in feature_indices: + # We grab the predictions of the model for this feature. + start_logits = all_start_logits[feature_index] + end_logits = all_end_logits[feature_index] + + # This is what will allow us to map some the positions in our + # logits to span of texts in the original + # context. + offset_mapping = features[feature_index]["offset_mapping"] + + # Go through all possibilities for the `n_best_size` greater start and end logits. + start_indexes = argsort(start_logits)[-1 : -n_best_size - 1 : -1].tolist() + end_indexes = argsort(end_logits)[-1 : -n_best_size - 1 : -1].tolist() + for start_index in start_indexes: + for end_index in end_indexes: + # Don't consider out-of-scope answers, either because the indices are + # out of bounds or correspond + # to part of the input_ids that are not in the context. + if ( + start_index >= len(offset_mapping) + or end_index >= len(offset_mapping) + or offset_mapping[start_index] is None + or offset_mapping[end_index] is None + ): + continue + + # Don't consider answers with a length + # that is either < 0 or > max_answer_length. + if end_index < start_index or end_index - start_index + 1 > max_answer_length: + continue + + # Map the start token to the index of the start of that token in the context + # Map the end token to the index of the end of that token in the context + start_char = offset_mapping[start_index][0] + end_char = offset_mapping[end_index][1] + + # Add the answer + # Score is the sum of logits for the start and end position of the answer + # Include the text which is taken directly from the context + valid_answers.append( + { + "score": start_logits[start_index] + end_logits[end_index], + "text": context[start_char:end_char], + } + ) + + # If we have valid answers, choose the best one + if len(valid_answers) > 0: + best_answer = sorted(valid_answers, key=lambda x: x["score"], reverse=True)[0] + else: + # In the very rare edge case we have not a single non-null prediction, + # we create a fake prediction to avoid + # failure. + best_answer = {"text": "", "score": 0.0} + + # Choose the best answer as the prediction for the current example + predictions[example["id"]] = best_answer["text"] + + return predictions + + +def create_datasets(): + """Load the SQuAD dataset, the tokenized version, and the validation set""" + print("Creating dataset.") + squad = load_dataset("squad", split='validation[:100%]') # can select fractional amount + + eval_data = squad.map( + preprocess_validation, batched=True, remove_columns=squad.column_names + ) + + return squad, eval_data + + +def make_trainer(model, eval_data): + """Create the Huggingface Trainer""" + training_args = TrainingArguments( + output_dir=args.result_dir, + save_strategy="no", + per_device_eval_batch_size=4, + no_cuda=False, + report_to="none", # no wandb + ) + + collator = DefaultDataCollator() + + trainer = Trainer( + model=model, + args=training_args, + data_collator=collator, + eval_dataset=eval_data, + tokenizer=TOKENIZER, + ) + + return trainer + + +def do_inference(model, trainer, squad, eval_data, time_dict): + """Perform inference experiment at weight noise level specified at runtime. + SQuAD exact match and f1 metrics are captured in Tensorboard + """ + + # Helper functions + def predict(): + # Perform inference + evaluate metric here + raw_predictions = trainer.predict(eval_data) + predictions = postprocess_predictions( + squad, eval_data, raw_predictions.predictions + ) + # Format to list of dicts instead of a large dict + formatted_preds = [{"id": k, "prediction_text": v} for k, v in predictions.items()] + out_metric = metric.compute(predictions=formatted_preds, references=ground_truth) + return out_metric["f1"], out_metric["exact_match"] + + model.eval() + metric = load("squad", experiment_id=args.sub_dir) + ground_truth = [{"id": ex["id"], "answers": ex["answers"]} for ex in squad] + time_steps = list(time_dict.values()) + + f1_lst, exact_match_lst = [], [] + for t_inference in time_steps: + model.program_analog_weights() # new prog errors + drift coeffs + model.drift_analog_weights(t_inference) # drift weights + new read noise + drift alphas + f1, exact_match = predict() + print("Inference time = %f: f1 = %f, exact match = %f" % (t_inference, f1, exact_match)) + f1_lst.append(f1) + exact_match_lst.append(exact_match) + + results_dict = {'f1_lst': f1_lst, + 'exact_match_lst': exact_match_lst, + 'time_dict': time_dict, + } + return results_dict + + +def extract_weights(model): + """Extracts analog weights from network""" + params = [] + for name, param in model.named_parameters(): + if 'analog' in name and 'weight' in name: + params.append(param.flatten()) + weights = torch.cat(params, 0) + return weights + + +def plot_weight_distribution(weights, suffix=''): + """Plots histogram of weight distribution""" + plt.figure() + plt.hist(weights.detach().cpu().numpy(), bins=100, density=True) + plt.xlabel('Weights [1]') + plt.ylabel('Density [1]') + plt.title("%0.1f million weights" % (1.e-6 * weights.numel())) + plt.savefig(os.path.join(args.result_dir, suffix + '_weight_distribution.png')) + plt.close() + + +def save_object(obj, filename): + """Save object""" + with open(filename, 'wb') as outp: # Overwrites any existing file. + pickle.dump(obj, outp, pickle.HIGHEST_PROTOCOL) + + +def load_object(filename): + """Loads object""" + try: + with open(filename, 'rb') as handle: + obj = pickle.load(handle) + return deepcopy(obj) + except Exception as error: + raise ValueError("%s does not exist" % filename) from error + + +def main(): + """Compare weight programming strategies (i.e. g_converters) + """ + # times to optimize for + time_dict = OrderedDict([('1 second', 1), + ('1 minute', 1 * 60), + ('1 hour', 1 * 60 * 60), + ('1 day', 1 * 60 * 60 * 24), + ('1 month', 1 * 60 * 60 * 24 * 30), + ('1 year', 1 * 60 * 60 * 24 * 30 * 12), + ]) + time_steps = list(time_dict.values()) + + # model name for labeling + suffix = SUFFIX + + # set up baseline g_converter + g_min, g_max = 0., 25. + g_converter_baseline = DualPairConductanceConverter(f_lst=[1.0, 1.0], + g_min=g_min, + g_max=g_max) + + # Define RPU configuration and use it to create model and tokenizer + rpu_config_baseline = create_rpu_config() + rpu_config_baseline.noise_model.g_converter = g_converter_baseline + + # make baseline model + model_baseline = create_model(rpu_config_baseline) + + # device models being optimized for + plot_device_models(rpu_config_baseline, + os.path.join(args.result_dir, 'device_models.png')) + + # extract and save model weights + weights_ideal = extract_weights(model_baseline) + torch.save(weights_ideal, os.path.join(args.result_dir, 'ideal_weights_' + suffix + '.pt')) + + # plot model weights + max_abs_weight = torch.max(torch.abs(weights_ideal)) + plot_weight_distribution(weights_ideal, suffix=suffix) + + # weight programming optimization + if args.optimize: + + # get f_lst from g_converter if exists + f_lst = g_converter_baseline.f_lst if hasattr(g_converter_baseline, 'f_lst') else [1.0] + + # keep or optimize f_lst params + f_lst = [1.0] + [None] * (len(f_lst) - 1) if args.optimize_f_lst else f_lst + + wpo = WeightProgrammingOptimizer(weights_ideal, + f_lst, + rpu_config_baseline, + time_steps, + g_converter_baseline, + mutation=args.mutation, + recombination=args.recombination, + use_max_kw=args.use_max_kw, + test_out_features=args.test_out_features, + loss_margin=args.loss_margin, + ) + g_converter_optimized, success = wpo.run_optimizer() + print("Successful convergence: %s" % str(success)) + + # make optimized rpu_config + rpu_config_optimized = create_rpu_config() + rpu_config_optimized.noise_model.g_converter = g_converter_optimized + + # save optimization results + baseline + save_object(rpu_config_baseline, + os.path.join(args.result_dir, 'rpu_config_baseline_' + suffix + '.pkl')) + save_object(rpu_config_optimized, + os.path.join(args.result_dir, 'rpu_config_optimized_' + suffix + '.pkl')) + save_object(wpo, + os.path.join(args.result_dir, 'WeightProgrammingOptimizer_' + suffix + '.pkl')) + else: + # load optimization results + baseline + try: + rpu_config_baseline = load_object( + os.path.join(args.result_dir, 'rpu_config_baseline_' + suffix + '.pkl')) + rpu_config_optimized = load_object( + os.path.join(args.result_dir, 'rpu_config_optimized_' + suffix + '.pkl')) + wpo = load_object( + os.path.join(args.result_dir, 'WeightProgrammingOptimizer_' + suffix + '.pkl')) + except Exception as error: + raise FileNotFoundError("All requisite data not properly loaded.") from error + + # shorthand + g_converter_baseline = rpu_config_baseline.noise_model.g_converter + g_converter_optimized = rpu_config_optimized.noise_model.g_converter + + # plot weight programming strategy + plot_g_converters(g_converter_baseline, g_converter_optimized, weights_ideal, suffix=suffix) + + # evaluate weight programming optimization + if args.inference or args.optimize: + + # get effective weights for baseline strategy at different time steps + fc_baseline = AnalogLinear(IN_FEATURES, OUT_FEATURES, bias=False, + rpu_config=rpu_config_baseline).to(DEVICE).eval() + + fc_optimized = AnalogLinear(IN_FEATURES, OUT_FEATURES, bias=False, + rpu_config=rpu_config_optimized).to(DEVICE).eval() + + weights_test = downsample_weight_distribution(weights_ideal, + torch.Size([IN_FEATURES, + OUT_FEATURES])).to(DEVICE) + + # set weights + for layer in fc_baseline.analog_layers(): + layer.set_weights(weights_test.T, torch.zeros(OUT_FEATURES)) + + for layer in fc_optimized.analog_layers(): + layer.set_weights(weights_test.T, torch.zeros(OUT_FEATURES)) + + # dummy activations + x = 0.5 * torch.randn(BATCH_SIZE, IN_FEATURES).to(DEVICE) + z_ideal = torch.matmul(x, weights_test) + + # save weight and activation distributions over time + effective_weights_baseline_time_lst, effective_weights_optimized_time_lst = [], [] + z_baseline_time_lst, z_optimized_time_lst = [], [] + for t_inference in time_dict.values(): + + fc_baseline.program_analog_weights() + fc_baseline.drift_analog_weights(t_inference) + weights_baseline_tile_lst = [] + for layer in fc_baseline.analog_layers(): # only one layer + for tile in layer.analog_tiles(): + weights_baseline_tile_lst.append( + tile.alpha * tile.get_weights()[0].T.to(DEVICE)) # includes get_scales() + effective_weights_baseline_time_lst.append( + torch.cat(weights_baseline_tile_lst, 1).detach().cpu().numpy()) + z_baseline_time_lst.append(fc_baseline(x).detach().cpu().numpy()) + + fc_optimized.program_analog_weights() + fc_optimized.drift_analog_weights(t_inference) + weights_optimized_tile_lst = [] + for layer in fc_optimized.analog_layers(): # only one layer + for tile in layer.analog_tiles(): + weights_optimized_tile_lst.append( + tile.alpha * tile.get_weights()[0].T.to(DEVICE)) + effective_weights_optimized_time_lst.append( + torch.cat(weights_optimized_tile_lst, 1).detach().cpu().numpy()) + z_optimized_time_lst.append(fc_optimized(x).detach().cpu().numpy()) + + # create weight info + weight_dict = {'ideal_weights': weights_test, + 'time_dict': time_dict, + 'effective_weights_baseline_time_lst': + effective_weights_baseline_time_lst, + 'effective_weights_optimized_time_lst': + effective_weights_optimized_time_lst, + 'baseline_title': type(g_converter_baseline).__name__, + 'optimized_title': type(g_converter_optimized).__name__, + 'baseline_loss': loss_weights(fc_baseline.to('cpu'), + time_steps, weights_test.to('cpu'), + max_abs_weight.to('cpu'), 0, 0, + get_baseline=True), + 'optimized_loss': loss_weights(fc_optimized.to('cpu'), + time_steps, weights_test.to('cpu'), + max_abs_weight.to('cpu'), 0, 0, + get_baseline=True), + } + + # create activation info + z_dict = {'z_ideal': z_ideal, + 'time_dict': time_dict, + 'z_baseline_time_lst': z_baseline_time_lst, + 'z_optimized_time_lst': z_optimized_time_lst, + 'baseline_title': type(rpu_config_baseline.noise_model.g_converter).__name__, + 'optimized_title': type(rpu_config_optimized.noise_model.g_converter).__name__, + 'baseline_loss': np.mean(np.stack([(z - z_ideal.detach().cpu().numpy()) ** 2 + for z in z_baseline_time_lst], axis=1)), + 'optimized_loss': np.mean(np.stack([(z - z_ideal.detach().cpu().numpy()) ** 2 + for z in z_optimized_time_lst], axis=1)), + } + + # save results + save_object(weight_dict, os.path.join(args.result_dir, 'weight_dict_' + suffix + '.pkl')) + save_object(z_dict, os.path.join(args.result_dir, 'z_dict_' + suffix + '.pkl')) + + # plot weight dispersion over time + plot_weight_comparison(weight_dict, suffix=suffix) + + # plot accuracy comparison over time + plot_z_comparison(z_dict, suffix=suffix) + + # create dataset + squad, eval_data = create_datasets() + + # evaluate accuracy with baseline weight programming strategy + print("Evaluating model with baseline weight programming.") + trainer_baseline = make_trainer(model_baseline, eval_data) + accuracy_baseline = do_inference(model_baseline, trainer_baseline, + squad, eval_data, time_dict) + + # evaluate accuracy with weight programming optimization + model_optimized = create_model(rpu_config_optimized) + # model_optimized = deepcopy(model_baseline) + # for _, tile in model_optimized.named_analog_tiles(): + # tile.rpu_config.noise_model.g_converter = g_converter_optimized + + print("Evaluating model with optimized weight programming.") + trainer_optimized = make_trainer(model_optimized, eval_data) + accuracy_optimized = do_inference(model_optimized, trainer_optimized, + squad, eval_data, time_dict) + + # create and save accuracy info + accuracy_dict = {'accuracy_baseline': accuracy_baseline, + 'accuracy_optimized': accuracy_optimized, + 'label_baseline': type(g_converter_baseline).__name__, + 'label_optimized': type(g_converter_optimized).__name__, + 'time_dict': time_dict, + } + save_object(accuracy_dict, + os.path.join(args.result_dir, 'accuracy_dict_' + suffix + '.pkl')) + + # compare accuracy results + plot_accuracy_comparison(accuracy_dict, suffix=suffix) + + else: + try: + # load results + weight_dict = load_object( + os.path.join(args.result_dir, 'weight_dict_' + suffix + '.pkl')) + accuracy_dict = load_object( + os.path.join(args.result_dir, 'accuracy_dict_' + suffix + '.pkl')) + z_dict = load_object( + os.path.join(args.result_dir, 'z_dict_' + suffix + '.pkl')) + + # plot weight dispersion over time + plot_weight_comparison(weight_dict, suffix=suffix) + + # plot test output activations comparison over time + plot_z_comparison(z_dict, suffix=suffix) + + # plot accuracy comparisin over time + plot_accuracy_comparison(accuracy_dict, suffix=suffix) + + except Exception as error: + raise FileNotFoundError("Run optimization and inference first") from error + + +if __name__ == "__main__": + + main() diff --git a/requirements-examples.txt b/requirements-examples.txt index 2fa5e822..e4fd0e90 100644 --- a/requirements-examples.txt +++ b/requirements-examples.txt @@ -2,3 +2,6 @@ torchvision>=0.7.0 matplotlib>=3.0 pyamg jupyter +transformers +evaluate +accelerate \ No newline at end of file diff --git a/src/aihwkit/inference/converter/wpo.py b/src/aihwkit/inference/converter/wpo.py new file mode 100644 index 00000000..1385748e --- /dev/null +++ b/src/aihwkit/inference/converter/wpo.py @@ -0,0 +1,638 @@ +# -*- coding: utf-8 -*- + +# (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. +# +# Licensed under the MIT license. See LICENSE file in the project root for details. + +"""Weight Programming Optimization implementation which is similar to the framework +reported in the following paper: + + C. Mackin, et al., "Optimised weight programming for analogue memory-based + deep neural networks" 2022. https://www.nature.com/articles/s41467-022-31405-1. +""" + +from datetime import datetime + +from typing import ( + Type, + Union, + List, + Dict, + Tuple, + Optional, + Any +) + +from copy import deepcopy +import pickle +from math import ceil, isnan + +import numpy as np +from scipy.optimize import differential_evolution, OptimizeResult + +from torch import ( + Tensor, + Size, + zeros, + max as torch_max, + abs as torch_abs, + sum as torch_sum, + linspace, + cat, + from_numpy, + sort, +) + +import torch.nn.functional as F + +from aihwkit.inference.converter.conductance import ( + SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter, +) + +from aihwkit.simulator.configs import InferenceRPUConfig + +from aihwkit.nn import AnalogLinear + + +def downsample_weight_distribution(weights: Tensor, + shape: Size) -> Tensor: + """Downsamples weight distribution via interpolation + + Params: + weights: original tensor of weights + shape: torch.Size object containing shape of desired downsampled matrix + + Returns: + downsampled N-dimensional weight distribution that is representative of + overall network weight distribution. Note: this function will also + correctly upsample weights when shape.numel() > weights.numel() + + """ + # interpolation on flattened, sorted weights likely represents distribution better + # randomly shuffle to re-introduce disorder after sorting + return shuffle_weights(F.interpolate(sort(weights.flatten())[0].unsqueeze(0).unsqueeze(1), + size=(shape.numel(),), + mode='linear', # interpolation type + align_corners=True, # keep boundary values + # detach otherwise pickle of deepcopy won't work + ).reshape(shape).detach()) + + +def stop_criterion(intermediate_result: OptimizeResult) -> None: + """Terminate weight programming optimization once strategy once + (current loss - baseline loss) / baseline loss + loss margin is less + than zero, where baseline loss is determined by g_converter_baseline. Current + loss is determined by the current weight programming optimization strategy. + + Args: + intermediate_result: a keyword parameter containing an OptimizeResult with + attributes x and fun, the best solution found so far and the objective + function, respectively. Note that the name of the parameter must be + intermediate_result for the callback to be passed an OptimizeResult. + + Raises: + StopIteration: when intermediate_result.fun (loss function) becomes + negative, which means optimization has adequately converged as defined + by the loss_margin parameter + + """ + + print("\t(current loss - baseline loss) / baseline loss + loss margin = %0.10f (%s)" + % (intermediate_result.fun, datetime.now())) + + if intermediate_result.fun < 0.0: + raise StopIteration + + +def partition_parameters(x: Tensor, d: Dict) -> Tuple: + """Separates array of x parameters from differential evolution into + parameters corresponding to f_p factors (if they exist) and x_g parameter, + which will be used to find corresponding valid conductance combinations. + + Args: + x: hypercube parameters corresponding to a weight programming strategy + d: dictionary with all WeightProgrammingOptimization attribution + that were previously serialized/pickled to be compatible with + scipy differential evolution + + Returns: + f_lst: list of conductance pair scaling parameters f + k_w: unitless to micoSiemens weight rescaling factor [uS/1] + x_g: hypercube parameters corresponding to remaining weight programming + strategy parameters + """ + f_lst = d['f_lst'].copy() # don't alter original + cnts = f_lst.count(None) # count None occurences + if cnts > 0: # only compute if None exists + inds = [i for i, f in enumerate(f_lst) if f is None] # indices of None occurences + f_lst_none = [x_f * (d['f_max'] - d['f_min']) + d['f_min'] # calc f vals to replace None + for x_f in x[0:cnts]] + for ind, f_val in zip(inds, f_lst_none): # replace None values in f_lst + f_lst[ind] = f_val + x = x[cnts:] # done - can drop params + x_k_w = 1.0 if d['use_max_kw'] else x[0] # get xkw + x_g = x if d['use_max_kw'] else x[1:] # get remaining xg values + + w_us_absolute_max = sum(f * (d['g_max'] - d['g_min']) for f in f_lst) + lower_bound, upper_bound = 0.05 * w_us_absolute_max, w_us_absolute_max + w_us_max = x_k_w * (upper_bound - lower_bound) + lower_bound + k_w = w_us_max / d['max_abs_weight_unitless'] + + return (f_lst, k_w, x_g) + + +def reformat_x_g(x_g: Tensor, len_f_lst: int, symmetric: bool) -> Tuple: + """Get x values in same format as CustomPairConductanceConverter g_lst + + Args: + x_g: list of hypercube parameters + len_f_lst: length of conductance pair scaling parameters f in f_lst + symmetric: whether or not weight programming optimization solution + will be symmetric for positive and negative weights (reduces + dimensionality of optimization problem) + + Returns: + x_g_lst: reformatted xg to correspond to CustomPairConductanceConverter + g_lst formatting + g_len: number discretized weights specified in CustomPairConductanceConverter + """ + g_len = int(len(x_g) / (2 * len_f_lst - 1)) + x_g_lst = [x_g[i:i + g_len].tolist() for i in range(0, len(x_g), g_len)] + g_len = g_len * 2 - 1 if symmetric else g_len + return x_g_lst, g_len + + +def loss_weights(model: AnalogLinear, t_steps: List[float], test_weights: Tensor, + max_abs_weight_unitless: float, loss_baseline: float, + loss_margin: float, get_baseline: bool = False) -> float: + """Computes Time-Averaged Normalized Mean Squared Error (TNMSE) for weight distribution + + Args: + model: one AnalogLinear layer used for test evaluation + t_steps: time steps to optimize over + test_weights: test weights (2d) that we want to implement + max_abs_weight_unitless: maximum weight value positive or negative + loss_baseline: baseline loss (tnmse) for baseline weight programming strategy + loss_margin: how much we are trying to beat the baseline loss by 0.1 = 10% + get_baseline: whether to return true loss (tnmse) or the normalized version where + we have beat the baseline loss by the loss margin amount once the value becomes + less than zero + + Returns: + tnmse: Time-Averaged Normalized Mean Squared Error (TNMSE), usually the normalized + version where where we have beat the baseline loss by the loss margin when + the value becomes less than zero. + + """ + error_amplification = 10. + + # could optionally reshuffle weights at each time step for better representation (but slower) + for layer in model.analog_layers(): + layer.set_weights(test_weights.to(test_weights.device).T.clone(), + zeros(model.out_features).to(test_weights.device)) + + nse = 0 + for t in t_steps: + model.program_analog_weights() # new prog errors + new drift coefficients each time + model.drift_analog_weights(t) # drifts weights + new read noise + new drift comp alpha + effective_weights_lst = [] + for layer in model.analog_layers(): # only one layer + for tile in layer.analog_tiles(): # potentially split across multiple tiles + effective_weights_lst.append( + tile.alpha * tile.get_weights()[0].T) # global and channelwise + effective_weights = cat(effective_weights_lst, 0) + nse += torch_sum((error_amplification * (effective_weights.to(test_weights.device) + - test_weights) / max_abs_weight_unitless) ** 2) + tnmse = nse / (model.in_features * model.out_features * len(t_steps)) + tnmse = tnmse.detach().cpu().numpy() + tnmse = np.inf if isnan(tnmse) else tnmse + + return tnmse if get_baseline else (tnmse - loss_baseline) / loss_baseline + loss_margin + + +def shuffle_weights(weights: Tensor) -> Tensor: + """Sample weights to test programming strategy + + Params: + weights: tensor of weights + + Returns: + shuffled tensor of weights with equivalent dimensions + + """ + # numpy shuffle implementation (faster than torch version) + weights_np = weights.detach().cpu().numpy() # ensure correct shape + np.random.shuffle(weights_np) # returns none, shuffle in place + return from_numpy(weights_np) # back to torch + + +def loss_rpu_config(d: Dict) -> float: + """Computes Time-averaged Normalized Mean Squared Error (TNMSE) + between the target weight distribution and implemented weight + distribution according to weight programming strategy and + corresponding programming errors, read noise, drift, and + drift compensation. This serves as a loss function to be + minimized. + + Args: + d: dictionary with all WeightProgrammingOptimization attribution + that were previously serialized/pickled to be compatible with + scipy differential evolution + Returns: + Loss, which is a Time-averaged Normalized Mean Squared Error (TNMSE) + """ + + device = d['device'] # must be cpu for scipy differential evoluation multiple workers + + # create test model + model = AnalogLinear(d['test_in_features'], + d['test_out_features'], + bias=False, + rpu_config=deepcopy(d['rpu_config'])).eval().to(device) + + return loss_weights(deepcopy(model), + d['t_steps'], + d['weights_downsampled_unitless'], + d['max_abs_weight_unitless'], + d['loss_baseline'], + d['loss_margin'], + get_baseline=d['get_baseline']) + + +def span_of_remaining_pairs(span_of_each_pair: List, ind: int) -> Tensor: + """Computes the span of the remaining conductance pairs. Informs interdependent + constraints on conductance programming based on how previous conductance pair was + programmed. + + Args: + span_of_each_pair: range of each conductance pair including f factor + ind: index of remaining conductance pairs + + Returns: + Remaining conductance range (i.e. maximum positive/negative conductance + value that could programmed in the remaining conductance pairs) + """ + remaining_span = 0 if ind > len(span_of_each_pair) else sum(span_of_each_pair[ind:]) + return remaining_span + + +def denormalize(x: Tensor, d: Dict) -> Tuple: + """De-normalizes a hypercube input parameter x to corresponding + f_p values and gp_p and gm_p values. + + Args: + x: hypercube parameters representing a weight programming strategy + d: dictionary with all WeightProgrammingOptimization attribution + that were previously serialized/pickled to be compatible with + scipy differential evolution + + Returns: + f_lst: conductance pair scaling factors for CustomPairConductanceConverter + g_lst: conductance programming spec for CustomPairConductanceConverter + """ + # pylint: disable-msg=too-many-locals + + f_lst, k_w, x_g = partition_parameters(x, d) + w_discretized_us = (k_w * d['weights_discretized_unitless']).tolist() # uS weights + span_of_each_pair = [f * (d['g_max'] - d['g_min']) for f in f_lst] + xg_lst, g_len = reformat_x_g(x_g, len(f_lst), d['symmetric']) + + if d['symmetric']: + w_discretized_us = w_discretized_us[0:int(g_len / 2) + 1] + + # solve for g_lst + g_lst = [[None for _ in range(g_len)] for _ in range(2 * len(f_lst))] + for i, w_us in enumerate(w_discretized_us): + w_us_center = w_us + for j, f_factor in enumerate(f_lst): + + # x to determine gp and gm breakdown that produces delta_g + x_g = xg_lst[2 * j][i] + + # x to determine conductance pair contribution: delta_g = g_p - g_m + # (i.e. which equipotential line) + x_delta_g = xg_lst[2 * j + 1][i] if j < len(f_lst) - 1 else 1.0 + + span_of_current = f_factor * (d['g_max'] - d['g_min']) + lower_bound = max(w_us_center - span_of_remaining_pairs(span_of_each_pair, j + 1), + -span_of_current) + upper_bound = min(w_us_center + span_of_remaining_pairs(span_of_each_pair, j + 1), + span_of_current) + + # delta_g (which equipotential line) for this g pair + f_delta_g = x_delta_g * (upper_bound - lower_bound) + lower_bound + + w_us_center = w_us_center - f_delta_g # new center based on delta_g from previous + delta_g = f_delta_g / f_factor # remove f factor amplification + + # gp lower bound for equipotnl line + underprog + lower_bound = d['g_min'] + max(delta_g, 0) - d['g_err'] + + # gp upper bound for equipotnl line + overprog + upper_bound = d['g_max'] + min(delta_g, 0) + d['g_err'] + + g_p = x_g * (upper_bound - lower_bound) + lower_bound # where on equipotential line + g_p = max(min(g_p, d['g_max']), d['g_min']) # constrain (for slight over/underprog) + g_m = g_p - delta_g + g_m = max(min(g_m, d['g_max']), d['g_min']) # constrain (for slight over/underprog) + + g_lst[2 * j][i] = g_p + g_lst[2 * j + 1][i] = g_m + + if d['symmetric']: + g_lst[2 * j][g_len - i - 1] = g_m # mirror for positive weights + g_lst[2 * j + 1][g_len - i - 1] = g_p + + return (f_lst, g_lst) + + +def loss_fxn(x: Tensor, *args: Union[bytes, bytearray]) -> float: + """Computes loss based on hypercube x values being probed by differential evolution. + + Args: + x: hypercube values corresponding to a programming strategy + args: any additional arguments necessary for optimization, + must be pickled to work with multiple workers in + scipy differential evolution algorithm + + Returns: + Loss of corresponding programming strategy defined by x + """ + d = deepcopy(pickle.loads(args[0])) + f_lst, g_lst = denormalize(x.copy(), d) + + # udpate rpu_config g_converter + rpu_config = deepcopy(d['rpu_config']) + rpu_config.noise_model.g_converter \ + = CustomPairConductanceConverter(f_lst.copy(), + g_lst.copy(), + g_min=d['g_min'], + g_max=d['g_max'], + invertibility_test=False) + d.update({'rpu_config': rpu_config}) # update rpu_config + iterations = 1 + # input deepcopy(d) so each run gets independent copy + optional averaging + return sum(loss_rpu_config(deepcopy(d)) for _ in range(iterations)) / iterations + + +class WeightProgrammingOptimizer: + """Weight Programming Optimization Class. + + Uses differential evoluation to minimize the time-averaged normalized mean-squared + error (TNMSE) loss between ideal weights and effective weights, which include device + non-idealities such as programming errors, read noise, conductance drift, and + algorithmic drift compensation. Can also optimize for significance pair scaling + factors f and be employed to optimize symmetric weight programming (for negative + and positive weights), which reduces the dimensionality and search space. Alternatively, + one can also optimize weight programming in a ~2x higher-dimensional space for positive + and negative weights in the event the weight distribution is highly asymmetric. + + Params: + weights: ideal unitless weight distribution to program + f_lst: list significance pair scaling factors. Passing a list of None values + will cause optimizer to solve for the best hardware f factors. Alternatively, + a specified f_lst such as [1.0, 3.0] will constrain the optimization to a + specific set of hardware f factors. + rpu_config: resistive processing unit configuration. + t_steps: time steps used in the optimization process. Will try to minimize weight + errors at all of the specified time steps. + g_converter_baseline: a baseline g_converter which the weight programming optimizer + will try to outperform. You can input an instantiated SinglePairConductanceConverter + or a DualPairConductanceConverter. Alternatively, you can also pass a previously + optimized CustomPairConductanceConverter in the event you would like to improve + on an previously optimized weight programming strategy. + symmetric: boolean that specifies whether or not to employ a symmetric weight programming + strategy for negative and positive weights. Enforcing symmetric reduces the + optimization dimensionality / search space and leads to faster optimization times. + kwargs: optional parameters that allows the user to override the baseline parameters + passed to scipy differential_evolution algorithm. The baseline parameters have been + heavily optimized and should be sufficient. In some cases, it may be beneficial to + adjust these values to improve the speed or quality of results. + + Returns: + CustomPairConductanceConverter: instantiated with optimized weight programming strategy + success: boolean flag indicating whether scipy differential_evolution successfully + terminated + + """ + # pylint: disable=too-many-instance-attributes, too-many-statements + def __init__( + self, + weights: Tensor, + f_lst: List, + rpu_config: Type[InferenceRPUConfig], + t_steps: List, + g_converter_baseline: Union[SinglePairConductanceConverter, + DualPairConductanceConverter, + CustomPairConductanceConverter], + symmetric: bool = True, + **kwargs: Optional[Any]): + + self.f_lst = f_lst + self.rpu_config = deepcopy(rpu_config) # to avoid modifying outside + + # turn off out scales during optimization (to avoid weight distortion) + self.mapping_saved = deepcopy(self.rpu_config.mapping) + self.rpu_config.mapping.weight_scaling_omega = 0.0 + self.rpu_config.mapping.weight_scaling_columnwise = False + self.rpu_config.mapping.learn_out_scaling = False + self.rpu_config.mapping.out_scaling_columnwise = False + + self.noise_model = self.rpu_config.noise_model + self.t_steps = t_steps + + self.symmetric = symmetric + self.test_in_features = self.rpu_config.mapping.max_input_size + + # default settings + self.nbins = 6 # weight RHS (positive) number of bins + self.test_out_features = 20 # weight/drift compensation averaging + self.g_err = 0.00 # over/under programming + self.f_min = 0.1 # min hardware f_p value + self.f_max = 5.0 # max hardware f_p value + self.use_max_kw = False # force max g range + self.loss_margin = 0.125 # margin to beat baseline + self.baseline_iterations = 100 # iterations to estimate average baseline loss + self.callback = stop_criterion # default to print convergence status updates + self.disp = True # print status (disable for tests) + + # differential evolution params + self.strategy = 'best1bin' # best1bin works well + self.popsize = 100 # defaults to 100x number of dimensions + self.maxiter = 200 # max iterations + self.tol = 0.0 # tolerance + self.atol = 0.02 # absolute tolerance + self.mutation = 0.1 # mutation/dithering: larger = wider search space + self.recombination = 0.3 # recombination/crossover: larger = faster convergence + self.polish = True # polish with grad descent + self.workers = -1 # parallel, -1 = max CPUs available + self.seed = 100 # seed, reproducibility + self.x_init = 'latinhypercube' # x initialization method + self.device = 'cpu' # must be cpu for diff evo multi-workers + + if set(kwargs.keys()).issubset(self.__dict__.keys()): + self.__dict__.update(kwargs) + else: + invalid_kwargs = set(kwargs.keys()).difference(self.__dict__.keys()) + raise Exception("The following argument(s) are not supported:\n %s" % invalid_kwargs) + + valid_g_converter_baselines = [SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter] + + if not any(isinstance(g_converter_baseline, g_converter) + for g_converter in valid_g_converter_baselines): + raise TypeError("g_converter_baseline = %s not supported" + % type(g_converter_baseline).__name__) + + self.g_converter_baseline = deepcopy(g_converter_baseline) + self.g_min = self.g_converter_baseline.g_min # use baseline g_min, g_max + self.g_max = self.g_converter_baseline.g_max # for fair comparison + self.g_err = self.g_err * (self.g_max - self.g_min) # for over/underprog + + g_lst_init = [[self.g_min] * (self.nbins * 2 - 1)] * 2 * len(f_lst) + self.g_converter = CustomPairConductanceConverter(f_lst, + g_lst_init, + g_max=self.g_max, + g_min=self.g_min, + invertibility_test=False, + ) + + # other parameters + self.get_baseline = False # switch to get true loss or relative to baseline + self.loss_baseline = float('inf') # g_converter_baseline loss + self.best_loss = float('inf') # best loss after optimization + + self.weights_downsampled_unitless \ + = downsample_weight_distribution(weights.to(self.device).flatten(), + Size([self.test_in_features, self.test_out_features])) + + self.max_abs_weight_unitless = torch_max(torch_abs(self.weights_downsampled_unitless)) + self.weights_discretized_unitless = linspace(-self.max_abs_weight_unitless, + self.max_abs_weight_unitless, + self.nbins * 2 - 1).to(self.device) + + def generate_hop_bounds(self) -> Tuple[Tuple[float, float], ...]: + """Generates the bounds applied to the differential weight evolution + algorithm. + + Returns: tuple of tuples which specify the number and constraints + (hypercube) used for differential evoluation optimization + """ + g_bnds = (0.0, 1.0) + + n_bnds = len(self.weights_discretized_unitless.tolist()) + + if self.symmetric: + n_bnds = ceil(n_bnds / 2) + + n_bnds *= (2 * len(self.f_lst) - 1) # multiply by conductance pairs + n_bnds += sum(f is None for f in self.f_lst) # f_lst params if necessary + n_bnds = n_bnds if self.use_max_kw else n_bnds + 1 # for kw + bnds = (g_bnds,) * n_bnds + return bnds + + def get_loss_baseline(self) -> float: + """Estimates the time-averaged normalized mean square error (TNMSE) value + for the weight progamming optimizer to beat based on a user-specified + standard weight programming procedure. + + Returns: + Loss, which is a time-averaged normalized mean square error (TNMSE), + which the weight programming optimizer will try to outperform + """ + + # copy rpu_config + rpu_config = deepcopy(self.rpu_config) + + # udpate rpu_config g_converter with baseline for comparison + rpu_config.noise_model.g_converter = self.g_converter_baseline + baseline_loss_params = deepcopy(self.__dict__) + baseline_loss_params.update({'get_baseline': True}) + + loss_baseline = sum(loss_rpu_config(deepcopy(baseline_loss_params)) + for _ in range(self.baseline_iterations)) / self.baseline_iterations + if self.disp: + print("\n\tloss baseline = %f (%s)\n" % (loss_baseline, + type(self.g_converter_baseline).__name__)) + + return loss_baseline + + def differential_weight_evolution(self) -> Tuple[CustomPairConductanceConverter, bool]: + """Runs differential evolution for weight programming optimization. + + To increase the chances of finding a good minima: increase popsize + along with mutation, but lower recombination. + + Returns: + g_converter: CustomPairConductanceConverter instantiated + with optimal f_lst, g_lst weight programming specifications + success: whether weight programming optimization was successful + or not + """ + + bnds = self.generate_hop_bounds() + if self.disp: + print("\t\thypercube dimensions = %d \n" % len(bnds)) + + res = differential_evolution(loss_fxn, + bnds, + args=(pickle.dumps(deepcopy(self.__dict__)),), + callback=self.callback, + strategy=self.strategy, + maxiter=self.maxiter, + popsize=self.popsize, + tol=self.tol, + atol=self.atol, + mutation=self.mutation, + recombination=self.recombination, + seed=self.seed, + disp=False, + polish=self.polish, + workers=self.workers, + updating='deferred' if self.workers == -1 else 'immediate', + ) + + # success if converged or beat baseline by margin + success = True if res.fun < 0. else res.fun + + # invert loss in tnmse + self.best_loss = (res.fun - self.loss_margin) * self.loss_baseline + self.loss_baseline + + f_lst, g_lst = denormalize(res.x.copy(), self.__dict__.copy()) + optimal_g_converter = CustomPairConductanceConverter(f_lst=f_lst, + g_lst=g_lst, + g_min=self.g_min, + g_max=self.g_max, + invertibility_test=False) + + return optimal_g_converter, success + + def run_optimizer(self) -> Tuple: + """Runs a series of steps that optimizes the weight programming + strategy based on programming noise, read noise, conductance- + dependent drift models, and drift compensation so as to maintain + weight fidelity as best as possible overtime and help the + network achieve iso-accuracy. + + Returns: + optimal_g_converter: optimal weight programming strategy in + the form of an instantiated CustomPairConductanceConverter + success: boolean flag specifying whether or not the optimization + was a success + + """ + + self.loss_baseline = self.get_loss_baseline() + optimal_g_converter, success = self.differential_weight_evolution() + + # update object + self.rpu_config.mapping = self.mapping_saved # restore mapping params + self.rpu_config.noise_model.g_converter = optimal_g_converter + self.f_lst = self.rpu_config.noise_model.g_converter.f_lst + + return (optimal_g_converter, success) diff --git a/tests/test_inference_tiles.py b/tests/test_inference_tiles.py index 93c3c0c2..1eedfdcd 100644 --- a/tests/test_inference_tiles.py +++ b/tests/test_inference_tiles.py @@ -8,11 +8,11 @@ """Tests for inference tiles.""" -from typing import Optional, List +from typing import Optional, List, Type from unittest import SkipTest from parameterized import parameterized -from torch import ones +from torch import ones, randn from torch import Tensor from torch.nn.functional import mse_loss from torch.optim import SGD @@ -30,6 +30,17 @@ from aihwkit.inference import PCMLikeNoiseModel from aihwkit.exceptions import TorchTileConfigError + +from aihwkit.inference import ( + BaseConductanceConverter, + SinglePairConductanceConverter, + DualPairConductanceConverter, + NPairConductanceConverter, + CustomPairConductanceConverter, +) + +from aihwkit.inference.converter.wpo import WeightProgrammingOptimizer + from .helpers.decorators import parametrize_over_tiles from .helpers.testcases import ParametrizedTestCase from .helpers.tiles import ( @@ -41,6 +52,8 @@ TorchInferenceIRDropTCuda, ) +g_min, g_max = 0., 25. + @parametrize_over_tiles( [ @@ -256,6 +269,73 @@ def test_post_update_step_remap_column(self): scales = analog_tile.get_mapping_scales() self.assertTensorAlmostEqual(scales, expected_scales) + @parameterized.expand( + [ + ("single_pair", SinglePairConductanceConverter(g_min=g_min, + g_max=g_max),), + ("dual_pair", DualPairConductanceConverter(f_lst=[1.0, 1.0], + g_min=g_min, + g_max=g_max),), + ("n_pair", NPairConductanceConverter(f_lst=[1.0, 1.0, 1.0], + g_min=g_min, + g_max=g_max),), + ("custom_pair", CustomPairConductanceConverter(f_lst=[1.0], + g_lst=[[g_min, + g_min, + g_min, + (g_max - g_min) / 2 + g_min, + g_max], + [g_max, + (g_max - g_min) / 2 + g_min, + g_min, + g_min, + g_min]], + g_min=g_min, + g_max=g_max, + invertibility_test=False),) + ] + ) + def test_weight_programming_optimization(self, _, g_converter: Type[BaseConductanceConverter]): + """Tests weight programming optimization using each inference tile""" + + # optimization time steps + time_steps = [1.0] + + # dummy weights + weights = randn(16, 16) + + # get f_lst from g_converter if exists + f_lst = g_converter.f_lst if hasattr(g_converter, 'f_lst') else [1.0] + + # whether to optimize f_lst + optimize_f_lst = True + + # keep or optimize f_lst params + f_lst = [1.0] + [None] * (len(f_lst) - 1) if optimize_f_lst else f_lst + + wpo = WeightProgrammingOptimizer(weights, + f_lst, + self.get_rpu_config(), + time_steps, + g_converter, + nbins=2, # speed up test + popsize=1, # speed up test + maxiter=1, # speed up test + baseline_iterations=1, # speed up test + loss_margin=-1e9, # speed up test + polish=False, # speed up test + disp=False, # suppress updates + callback=None, # suppress updates + ) + g_converter_optimized, success = wpo.run_optimizer() + + self.assertTrue(success) + self.assertIsInstance(g_converter_optimized, CustomPairConductanceConverter) + self.assertEqual(len(f_lst), len(g_converter_optimized.f_lst)) + self.assertEqual(g_min, g_converter_optimized.g_min) + self.assertEqual(g_max, g_converter_optimized.g_max) + self.assertEqual(len(g_converter_optimized.g_lst), 2 * len(f_lst)) + @parameterized.expand( [ ("none", None), From 4d9a5798f1c277e46add63e0bc38736729e4843e Mon Sep 17 00:00:00 2001 From: charlesmackin <45808803+charlesmackin@users.noreply.github.com> Date: Thu, 2 Jan 2025 09:07:42 -0800 Subject: [PATCH 11/14] Updated Examples/README.md (#704) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * passing code checkers Signed-off-by: Charles Mackin * minor updates Signed-off-by: Charles Mackin * updated examples README.md Signed-off-by: Charles Mackin --------- Signed-off-by: Charles Mackin Co-authored-by: Charles Mackin Signed-off-by: Pablo Carmona González --- examples/README.md | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/examples/README.md b/examples/README.md index 808a3dc1..c0659981 100644 --- a/examples/README.md +++ b/examples/README.md @@ -590,6 +590,29 @@ Example of how to import and perform inference using a model which has been trained in a hardware-aware fashion using an external library (i.e., not the AIHWKIT). +## Example 31: [`31_custom_drift_models.py`] +Example of how to modify analog device time-dependent drift +characteristics. + +## Example 32: [`32_weight_programming_options.py`] +Example of how to implement different unit cells for +weight programming. These include the default +SinglePairConductanceConverter along with a DualPairConductanceConverter, +which uses two conductance pairs per unit cell. An +NPairConductanceConverter is also available for studying the effects of +additional conductance pairs along with a CustomPairConductanceConverter, +which enables highly customizable weight programming strategies where +allowing the user to define how to split weights across multiple conductances +as a function of the weight being implemented. + +## Example 33: [`33_weight_programming_optimization.py`] +Example of how to improve inference accuracy--including as a function +of time–-via more optimized weight programming strategies based on +specific analog device characterstics such as programming errors, +conductance drift, and read noise. This example is based on the +paper: [C. Mackin, et al., "Optimised weight programming for analogue +memory-based deep neural networks," Nature Communications, 2022.] + [Resistive Processing Units]: https://aihwkit.readthedocs.io/en/latest/using_simulator.html#resistive-processing-units [Inference and PCM statistical model]: https://aihwkit.readthedocs.io/en/latest/pcm_inference.html [Unit Cell Device]: https://aihwkit.readthedocs.io/en/latest/using_simulator.html#unit-cell-device @@ -611,6 +634,8 @@ Front. Neurosci.]: https://www.frontiersin.org/articles/10.3389/fnins.2020.00103 [ImageNet]: https://www.image-net.org/ [Rasch MJ, Carta F, Fagbohungbe O and Gokmen T (2023) Fast offset-corrected in-memeory training. ArXiv preprint]: https://arxiv.org/abs/2303.04721 +[C. Mackin, et al., "Optimised weight programming for analogue memory-based deep neural +networks," Nature Communications, 2022.]: https://www.nature.com/articles/s41467-022-31405-1 [`01_simple_layer.py`]: 01_simple_layer.py [`02_multiple_layer.py`]: 02_multiple_layer.py @@ -642,3 +667,6 @@ offset-corrected in-memeory training. ArXiv preprint]: https://arxiv.org/abs/230 [`28_advanced_irdrop.py`]: 28_advanced_irdrop.py [`29_linalg_krylov.py`]: 29_linalg_krylov.py [`30_external_hardware_aware_model.py`]: 30_external_hardware_aware_model.py +[`31_custom_drift_models.py`]: 31_custom_drift_models.py +[`32_weight_programming_options.py`]: 32_weight_programming_options.py +[`33_weight_programming_optimization.py`]: 33_weight_programming_optimization.py From 5f02fd0ca1a51b413b65beec89f8197b475ee0c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julian=20B=C3=BCchel?= Date: Fri, 10 Jan 2025 12:23:18 +0100 Subject: [PATCH 12/14] added FP preset (#705) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Julian Buechel Signed-off-by: Pablo Carmona González --- src/aihwkit/simulator/presets/__init__.py | 3 +-- src/aihwkit/simulator/presets/inference.py | 24 +++++++++++++++++++++- tests/test_presets.py | 21 ++++++++++++++++++- 3 files changed, 44 insertions(+), 4 deletions(-) diff --git a/src/aihwkit/simulator/presets/__init__.py b/src/aihwkit/simulator/presets/__init__.py index 39f50907..62730742 100644 --- a/src/aihwkit/simulator/presets/__init__.py +++ b/src/aihwkit/simulator/presets/__init__.py @@ -68,8 +68,7 @@ MixedPrecisionGokmenVlasovPreset, MixedPrecisionPCMPreset, ) -from .inference import StandardHWATrainingPreset - +from .inference import StandardHWATrainingPreset, FloatingPointPreset from .devices import ( ReRamESPresetDevice, ReRamSBPresetDevice, diff --git a/src/aihwkit/simulator/presets/inference.py b/src/aihwkit/simulator/presets/inference.py index 317385e2..057b74c1 100644 --- a/src/aihwkit/simulator/presets/inference.py +++ b/src/aihwkit/simulator/presets/inference.py @@ -10,7 +10,7 @@ from typing import Optional from dataclasses import dataclass, field -from aihwkit.simulator.configs.configs import InferenceRPUConfig +from aihwkit.simulator.configs.configs import InferenceRPUConfig, TorchInferenceRPUConfig from aihwkit.simulator.parameters import ( MappingParameter, IOParameters, @@ -34,6 +34,28 @@ # Inference +@dataclass +class FloatingPointPreset(TorchInferenceRPUConfig): + """Preset configuration for FP-like AIMC (Analog In-Mememory Compute) + accuracy evaluation/training. + + This preset configuration does not inject any noise in any form (weight noise + quantization etc.) and is equivalent to the FP model. + """ + + mapping: MappingParameter = field( + default_factory=lambda: MappingParameter(max_input_size=0, max_output_size=0) + ) + + forward: IOParameters = field(default_factory=lambda: IOParameters(is_perfect=True)) + + pre_post: PrePostProcessingParameter = field( + default_factory=lambda: PrePostProcessingParameter( + input_range=InputRangeParameter(enable=False) + ) + ) + + @dataclass class StandardHWATrainingPreset(InferenceRPUConfig): """Preset configuration for AIMC (Analog In-Mememory Compute) diff --git a/tests/test_presets.py b/tests/test_presets.py index 78eee455..d78ea4da 100644 --- a/tests/test_presets.py +++ b/tests/test_presets.py @@ -6,7 +6,7 @@ """Tests for analog presets.""" -from torch import Tensor +from torch import Tensor, randn from aihwkit.simulator.tiles.analog import AnalogTile from aihwkit.simulator.presets import ( @@ -50,6 +50,7 @@ TTv2EcRamPreset, TTv2EcRamMOPreset, TTv2IdealizedPreset, + FloatingPointPreset, ) from .helpers.decorators import parametrize_over_presets from .helpers.testcases import AihwkitTestCase @@ -131,3 +132,21 @@ def test_tile_preset(self): self.assertEqual(tile_biases, None) # TODO: disabled as the comparison needs to take into account noise # self.assertTensorAlmostEqual(tile_weights, weights) + + +class PresetTestFP(AihwkitTestCase): + """Test for FP preset.""" + + def test_tile_preset(self): + """Test fwd behavior of FP preset.""" + out_size = 2 + in_size = 3 + weights = randn(out_size, in_size) + inp = randn(in_size) + fp_out = inp @ weights.T + + rpu_config = FloatingPointPreset() + analog_tile = AnalogTile(out_size, in_size, rpu_config, bias=False) + analog_tile.set_weights(weights) + tile_out = analog_tile(inp) + self.assertTensorAlmostEqual(fp_out, tile_out) From b63092161d8c806b2f13ef0949b3d03df90d9422 Mon Sep 17 00:00:00 2001 From: GhaziSyed <115798228+GhaziSyed@users.noreply.github.com> Date: Mon, 13 Jan 2025 22:31:29 +0530 Subject: [PATCH 13/14] New notebook (#682) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Added Notebook on Device Non_Idealities Signed-off-by: Ghazi Sarwat Syed * Added the updated tutorial Signed-off-by: Ghazi Sarwat Syed * Add files via upload Signed-off-by: Ghazi Sarwat Syed * Cleanup of the notebooks directory. (#444) Signed-off-by: Ghazi Sarwat Syed * fix typo (#445) Signed-off-by: Ghazi Sarwat Syed * [ImgBot] Optimize images (#448) *Total -- 450.13kb -> 41.19kb (90.85%) /examples/img/replay_fake_images_gan.gif -- 423.50kb -> 24.00kb (94.33%) /notebooks/examples/imgs/xbar.png -- 26.62kb -> 17.19kb (35.44%) Signed-off-by: ImgBotApp Signed-off-by: ImgBotApp Co-authored-by: ImgBotApp Signed-off-by: Ghazi Sarwat Syed * for pr 437 * ghs-tutorial * changed to non executable code * change code to markdown * trying again with markdown changes --------- Signed-off-by: Ghazi Sarwat Syed Signed-off-by: ImgBotApp Co-authored-by: Kaoutar El Maghraoui Co-authored-by: Malte J. Rasch <17587387+maljoras@users.noreply.github.com> Co-authored-by: imgbot[bot] <31301654+imgbot[bot]@users.noreply.github.com> Co-authored-by: ImgBotApp Co-authored-by: Borja Godoy Gago Co-authored-by: pablocarmona Signed-off-by: Pablo Carmona González --- ...analog_device_nonIdealities_tutorial.ipynb | 879 ++++++++++++++++++ 1 file changed, 879 insertions(+) create mode 100644 notebooks/analog_device_nonIdealities_tutorial.ipynb diff --git a/notebooks/analog_device_nonIdealities_tutorial.ipynb b/notebooks/analog_device_nonIdealities_tutorial.ipynb new file mode 100644 index 00000000..1a2209b0 --- /dev/null +++ b/notebooks/analog_device_nonIdealities_tutorial.ipynb @@ -0,0 +1,879 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nonvolatile resistive memories—such as phase-change memory (PCM)—based computational devices allow limited numerical compute accuracy due to certain non-ideal device characteristics. In this post, you will get a feel for these non-idealities, gauge their impact on computational precision, and learn about software schemes to correct them.\n", + "
\n", + "\n", + "To learn more about how PCMs work, you can refer to [Materials Science and Technology 33.16 (2017): 1890-1906](https://doi.org/10.1080/02670836.2017.1341723) or [Journal of Applied Physics 124 (2018), 111101](https://doi.org/10.1063/1.5042413) or [Journal of Vacuum Science & Technology B 28.2 (2010): 223-262.](https://doi.org/10.1116/1.3301579) \n", + "
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "
\n", + " July 02, 2022
\n", + " ghs@zurich.ibm.com\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lets get started \n", + "\n", + "-We first import basic python libaries and modules to help us do maths and plot data\n", + "
\n", + "-We also call some in-built codes to make this post look aesthetically nice " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\n", + "import numpy as np\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.style.use('ggplot')\n", + "plt.close('all')\n", + "from IPython.core.display import HTML as Center\n", + "Center(\"\"\" \"\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1:\n", + "
\n", + "We construct a 256 $\\times$256 2D array (matrix). Every element in the array can be thought of as a distinct PCM device and encodes a conductance state in micro-Siemens (μS). For purposes of illustration, we want the matrix elements to be normally distributed around a mean of 0 μS" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Word Line Number')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "PAR_NumWL = 256\n", + "PAR_NumBL = 256\n", + "PAR_NumPCM = PAR_NumWL*PAR_NumBL\n", + "PAR_GMax = 15\n", + "PAR_DistMean = 0\n", + "PAR_DistStd = PAR_GMax/3\n", + "PAR_MatrixRef = np.random.normal(PAR_DistMean, PAR_DistStd, PAR_NumPCM)\n", + "\n", + "\n", + "fig = plt.subplots()\n", + "plt.title(\"Conductance distribution\")\n", + "plt.hist(PAR_MatrixRef,bins=100,edgecolor=\"green\", color=\"green\")\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Counts', fontsize=16)\n", + "plt.ylim([0, 3500])\n", + "\n", + "fig = plt.subplots()\n", + "plt.title(\"PCM Matrix\")\n", + "PAR_MatrixRef2D= PAR_MatrixRef.reshape(PAR_NumWL,PAR_NumWL)\n", + "plt.imshow(PAR_MatrixRef2D,cmap='RdBu')\n", + "plt.colorbar(label='G ($\\mu S$)')\n", + "plt.xlabel('Bit Line Number', fontsize=16)\n", + "plt.ylabel('Word Line Number', fontsize=16)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 1-5 defines the matrix size (word and bit lines), matrix's conductance mean, matrix's conductance standard deviation\n", + "
\n", + "Lines 6 initializes the matrix elements with a Gaussian (normal) distributed conductance values\n", + "
\n", + "Lines 9-14 creates a histogram plot of the matrix\n", + "
\n", + "Lines 16-22 creates a 2D plot of the matrix\n", + "
\n", + "
\n", + "We refer to this conductance distribution as ideal. It is free from any non-indeality and is therefore our reference distribution\n", + "
\n", + "\"In the following we will see how each non-indeality individually alter this ideal matrix\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1.1: We inject the non-ideality of resistance drift into all conductance states\n", + "
\n", + "Definition: 'When amorphous, the disordered atomic structure of the phase-change material relaxes towards the lower energy states in time. This process is manifested in the embodiment of a time-dependent decrease in conductance. In doped PCMs we also observe resistance drift in the crystalline state, likely a result of the relaxations in excess amorphous like grain boundaries.'\n", + "
\n", + "
\n", + "Mathematically drift follows a power law relation $G_{i,j}=G_{0_{i,j}}\\times (\\frac{t}{t_{0}})^{-\\nu}$, where $\\nu$ is drift coefficient, t is elapsed time after programming and G is conductance. \n", + "
\n", + "
\n", + "To simulate resistance drift we first have to define the state-dependent (conductance) mean and standard deviation of $\\nu$. Each PCM element of unique conductance value in the matrix gets altered distinctly owing to this state dependency. We extract the state dependency using mathematical functions that was fitted experimental data " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 3500.0)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get state dependent mean and standard deviation of drift coefficients\n", + "PAR_DriftMean=[]\n", + "PAR_DriftStd=[]\n", + "x=np.arange(0.01,1,0.01)\n", + "PAR_G = x*PAR_GMax\n", + "\n", + "def f(x):\n", + " for i in range(0,len(x)):\n", + " DUM_A= min(np.append(max(np.append(-0.0155*np.log(x[i])+0.0344,0.049)),0.1))\n", + " DUM_B= min(np.append(max(np.append(-0.0125*np.log(x[i])-0.0059,0.008)),0.035))\n", + " PAR_DriftMean.append(DUM_A)\n", + " PAR_DriftStd.append(DUM_B)\n", + "\n", + "PAR_D=f(x)\n", + "fig = plt.subplots()\n", + "#plt.title('State dependent drift coeff')\n", + "plt.plot(PAR_G,PAR_DriftMean,color=\"green\",label='Mean')\n", + "plt.plot(PAR_G,PAR_DriftStd,color=\"Red\",label='SD')\n", + "plt.xlabel('G ($\\mu S$)', fontsize=18)\n", + "plt.ylabel('Drift Coeff', fontsize=18)\n", + "leg = plt.legend();\n", + "\n", + "# Modify the reference matrix conductance values using the drift coefficients\n", + "PAR_t = 500\n", + "PAR_MatrixRD2D=np.zeros((256,256))\n", + "for i in range(0,PAR_NumWL):\n", + " for j in range(0,PAR_NumWL):\n", + " DUM_C=PAR_MatrixRef2D[i][j]\n", + " DUM_DIndex= np.argmin(abs(abs(DUM_C)-PAR_G))\n", + " DUM_Factor= PAR_DriftMean[DUM_DIndex]+PAR_DriftStd[DUM_DIndex]*np.random.normal(0, 1, 1);\n", + " PAR_MatrixRD2D[i][j]= DUM_C*(PAR_t**-DUM_Factor)\n", + "\n", + "PAR_MatrixRD=PAR_MatrixRD2D.reshape(256*256)\n", + "fig= plt.subplots()\n", + "plt.title(\"Conductance distribution\")\n", + "plt.hist(PAR_MatrixRD,bins=100,edgecolor=\"green\", color=\"green\")\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Counts', fontsize=16)\n", + "plt.ylim([0, 3500])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 2-5 initialzes variables \n", + "
\n", + "Lines 7-12 is a function that establishes the relationship between G and Drift \n", + "
\n", + "Lines 14-21 creates a plot of the G and Drift relationship\n", + "
\n", + "Lines 24-31 initialzes variables \n", + "
\n", + "Lines 25-30 associates a mean and a drift coefficient with every element in our reference conductance matrix\n", + "
\n", + "Lines 33-39 creates a histogram plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1.2: We inject the non-ideality of READ noise into all conductance states\n", + "\n", + "Definition: 'These are conductance fluctuations that are characterized by a power spectral density that scales inversely with the frequency. The mechanism that leads to READ noise is still debated, however, a few models propose the concept of a bi-stable configuration where the atoms or electrons can reversibly toggle'\n", + "
\n", + "Mathematically read noise follows $\\sigma_{i,j}=G_{i,j}\\times Q_{s}\\sqrt{log(\\frac{fmax}{fmin}})$, where Q is some constant dependent of G and f$_{max/min}$ is the frequency window. READ noise is equivalent to the standard deviation of a conductance time-series signal.\n", + "
\n", + "
\n", + "For further reading, refer to [IEEE International Conference on Electronics, Circuits and Systems (ICECS), 2019, pp. 727-730](10.1109/ICECS46596.2019.8964852) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 3500.0)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHVCAYAAADsJ8/rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRrUlEQVR4nO3deXgUVaL38V8n3SEJ2SGYQAhrwiqERZBFYeC6McwwuCCoA04AF7iAzusMOvFelgEB51W8onPFUUBzRQQ0AzOig4LLgAsgYl6MssewBMKSTghNSIfU+wc3NXTSgcpCkk6+n+fhgao+VXWqT6fz49SpUzbDMAwBAADgivzqugIAAAC+gNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALCA0AQAAWEBoAgAAsIDQBDRCbdu2Vdu2beu6GpD04IMPymazKTMz01yXmZkpm82mBx98sM7qZbPZNHToUI91s2fPls1m06efflondZLqx3uDxovQBNSAH3/8UdOmTVP37t0VHh6ugIAAtWzZUj//+c/1+uuvq7CwsK6rWOe8hQNcG59++qlsNptmz55d11WpEm+BDagP7HVdAcDXzZ07V3PmzFFJSYluvPFGTZgwQaGhoTpx4oQ+//xzTZo0Sf/93/+tHTt21HVV4SNatWqlH374QeHh4XVWhx9++EHBwcF1dvyK1If3Bo0XoQmohvnz52vWrFlq3bq11qxZo/79+5cr8+GHH+rZZ5+tg9rBVzkcDnXu3LlO61DXx69IfXhv0HhxeQ6ooszMTM2ZM0cOh0MbNmzwGpgk6fbbb9cHH3xQbv0777yjm266SeHh4QoKClL37t31zDPPeL2UVzoGyeVy6Xe/+53i4+PVpEkTdezYUQsXLpRhGOW2MQxDL730krp166bAwEC1atVKU6dOVV5entd6Xmm8ypXGkbhcLi1atEh9+/ZVaGioQkJC1KVLF02fPl0nTpyQdOlyyxtvvCFJateunWw2m2w2m8e4qm+++UYzZsxQz549FRUVpcDAQCUkJOi3v/2tzpw5U+64K1askM1m04oVK/TJJ59o6NChCg0NVVhYmEaMGKHvv//e63laqe/lZRcsWKCkpCQ1bdpUISEhGjBggN5++22v+76Sjz/+WDfddJOaNm2qqKgo/epXv9IPP/zgtWxF7/fx48f129/+Vp06dVLTpk0VFhamjh07avz48Tpw4ICkS5dBf/azn0mS5syZY77Xl7ft5e/d+++/r5tvvllhYWGy2Wzmsa52ieyNN95Qr169FBQUpBYtWig5OVnHjx8vV+5K4+fKfuZK6yVJn332mUfdSy81XumzeOzYMU2ZMkVt27ZVQECAoqOjNXr0aG3fvr1c2ap+ftC40dMEVNHy5cvldrs1duxYde/e/YplmzRp4rE8c+ZMPfvss4qOjtb999+vpk2basOGDUpJSdGHH36ojz/+WAEBAR7buN1u3XrrrTp27JjuuOMO2e12/fWvf9VTTz2l8+fPa86cOR7lH3vsMb344ouKjY3VQw89JIfDoXXr1mnbtm0qKioqt/+qyM3N1c9+9jN999136ty5s5KTkxUQEKD9+/dr2bJluvPOO3Xddddp1qxZ+utf/6rvvvtOM2bMUEREhCSZf0vSX/7yF6WlpWnIkCH6t3/7N128eFE7duzQ4sWLtWHDBm3fvl2hoaHl6vD3v/9d69at0x133KFHHnlEGRkZZvmMjAxFR0dXur6S5HQ6NWzYMH377bfq06ePkpOTVVJSon/84x+677779P3332vevHmW3qe1a9fq3nvvVUBAgO69917FxsZqy5YtGjBggHr27GlpHy6XSwMHDtShQ4d0yy236Be/+IUMw9BPP/2kv/3tbxozZow6dOigX/3qV5IuhZohQ4Z4BJ+y4WXNmjX68MMPNWLECD3yyCM6dOiQpbosXrxYGzdu1L333qvbb79dW7Zs0fLly/Xpp5/q66+/9njPKyMpKUmzZs3SnDlz1KZNG49gdLUxTgcPHtTgwYOVnZ2t4cOHa9y4cTp8+LDWrFmj999/X2vWrNGoUaPKbVeZzw8gA0CV/OxnPzMkGX/5y18qtd2WLVsMSUabNm2MEydOmOvdbrcxYsQIQ5Ixb948j23atGljSDLuuOMOw+VymetPnDhhhIeHG2FhYUZRUZG5fuvWrYYko0OHDsbp06fN9efPnzduvPFG8/iXmzVrliHJ+OSTT8rV+dChQ4YkY8KECR7rx40bZ0gyHnnkEePixYser+Xn5xu5ubnm8oQJEwxJxqFDh7y+L5mZmUZxcXG59a+88oohyViwYIHH+uXLlxuSDH9/f+Pjjz/2eO3JJ580JBkLFy6sdn3/7//9vx7lzp8/b9x2222GzWYzdu7c6fVcLnf27FkjKirKsNvtxvbt2z1ee+yxxwxJ5d4Xb+/3unXrDEnGjBkzyh3jwoULRn5+vrn8ySefGJKMWbNmea1T6Xtns9mMDz74wGsZScaQIUM81pV+RhwOR7lzLz2X5ORkj/Vt2rQp91kru7+ynzlvxy5V0Wfxlltu8drm//znPw0/Pz8jMjLS4z2qyucH4PIcUEWllyLi4uIqtd3y5cslSU8//bRatGhhrrfb7Xr++efl5+en119/3eu2S5YsUVBQkLncokULjRo1Svn5+dqzZ0+5Y6SkpCgqKspcHxgYqAULFlSqvhXJycnRO++8o9jYWD333HPy8/P8OgkNDfXoSbqaNm3ayN/fv9z6hx56SGFhYdq4caPX7caNG6fhw4eX20aSx2WZytT39OnT+p//+R/dcMMN+j//5/94lAsMDNSiRYtkGIZWrlx51fNat26dzpw5o/vuu099+/b1eG327NmWBzSXXrbyNjg7ICDAay/c1fzyl7/U7bffXuntfv3rX6tXr14e60rPZeXKlbpw4UKl91kdR44c0UcffaQ2bdqUa6/Bgwdr7Nixys3NVVpaWrltrX5+AInLc0CVGf87jujycSBWfPvtt5Jkjju5XKdOnRQXF6dDhw7J6XR6hI6IiAh16NCh3DatW7eWdOnSU6mdO3dKkoYMGVKu/E033SS7vfo/+tu3b1dJSYluvvnmGrnLyu12a+nSpVq1apUyMjKUl5enkpIS8/WjR4963a5sEJG8vyeVqe/27dt18eJFSfJ6277b7ZZ0aaqJq7lSW4SHhyspKUmfffbZVfczZMgQtWrVSgsXLtS3336rESNGaODAgUpKSvIaNq2oaByelbqUdfm5/PDDD0pKSqrSvqui9Geqos/2v/3bv2nlypXauXOnxo8f7/Ga1c8PIBGagCpr2bKlfvzxRx05cqRS25UOxI6JifH6emxsrLKyspSXl+cRmirqkSj9JVH6S/7yY5SOz7mcv7+/mjVrVqk6e+N0OiVdugW8Jtx7771KS0tT+/btNWrUKMXExJhjwV544YUKey+8vS/e3pPK1Pf06dOSLoWnK/U2FBQUXHVfV2oLqeLPQVlhYWH66quvNGvWLK1fv14ffvihJCk6OlpTp05VSkpKpcOw1WOXdbVzqehmg2vFys/U5eUuZ/XzA0jcPQdU2eDBgyVJmzZtqtR2pV/S3u40kqTs7GyPclVRum3Zu8GkS78ISkPB5UovVxUXF5d7rTRwXK400FXUA1QZO3bsUFpamoYPH64ff/xRy5cv14IFCzR79mz953/+p4qKiqp9jMrUt/T9e/zxx2UYRoV/PvnkE8v78tYWUsWfA2/i4uL0+uuvKycnR7t379aLL76oqKgozZ49W3/84x8t76dUZXtJS13tXC7/7Pr5+Xn9TEneP1dVURs/U4BEaAKq7De/+Y0cDofeffddZWRkXLHs5b0kpWNBvN3av3//fh05ckTt2rWr1Higsnr37i1JXi/7/POf//T6SywyMlKSdPjw4XKveZuYs1+/fvLz89M///lPuVyuq9ap9BKSt/+979+/X5I0atQoORwOj9e2bdum8+fPX3X/V1OZ+l5etrqu1BZ5eXnatWtXpfdps9nUrVs3TZs2TR999JEkeYzXudJ7XROudC6BgYHq0qWLuT4yMlInTpwwL2lerqIJX/38/CpV99KfqS1btnj9bJeG29K2AKqK0ARUUdu2bTV79mwVFRXp5z//eYW/AD788EPdcccd5nJycrIkad68eTp58qS5/uLFi3riiSdUUlKiiRMnVqtupbdqz58/32OOo8LCQj311FNetykd37J8+XKPXzyHDx/W3Llzy5WPjo7W2LFjdezYMc2cObPcXFEFBQUel0NKLwl6C2Wlt8KXDZI5OTmaOnVqBWdZOZWpb4sWLXT//fdrx44d+uMf/+j1F/GBAwcs3aI/atQoRUZGauXKleU+I7Nnz7Z8KWv37t1eH0FT2usTGBhorrvSe10TUlNTzXFEpUrPZdy4cR5TbPTv31/FxcXmzQmlVqxYoa1bt3rdf7NmzSpV97i4ON1yyy3KzMzUCy+84PHa119/rZUrVyoyMlKjR4+2vE/AG8Y0AdXwhz/8QcXFxZozZ45uuOEGDRw4UH379lVISIj5GJV9+/Z5DDYdOHCgfv/73+vZZ59V9+7ddffdd6tp06b64IMPtHv3bg0ePFi/+93vqlWvQYMGadq0aVqyZIl5jNJ5miIjI80xHpfr16+fhg4dqk8//VT9+vXTsGHDdOLECf3tb3/Tbbfd5vWX2EsvvaTdu3frpZde0qZNm3TrrbcqICBAhw4d0j/+8Q+tX7/enF9n+PDh+tOf/qTJkyfrrrvuUkhIiCIiIvTv//7vuuGGGzRo0CC99957GjhwoAYPHqwTJ07ogw8+UKdOndSyZctqvR9Vqe9LL72kffv26T//8z+VmpqqwYMH67rrrtOxY8f0ww8/aPv27Xr77bfVrl27Kx4zJCREr776qu69917ddNNNHvM07d69WzfffLM+//zzq9b9448/1m9/+1sNHDhQnTt3VosWLXTkyBGtW7dONpvN4zPTqVMntWrVSqtWrZLD4VB8fLxsNpt+/etfq02bNtV6DyVpxIgRGjRokMaMGWOey5YtW9S2bVstXLjQo+z06dO1fPlyPfroo9q0aZNat26t7777Tl988YVGjhypv//97+X2P3z4cK1atUqjRo1Sr169ZLfbdfPNN+vmm2+usE6vvPKKBg0apN/97nfauHGj+vbta87T5Ofnp+XLl1fpDkPAQx1NdQA0KBkZGca///u/G926dTNCQ0MNh8NhxMTEGLfffrvx2muvGYWFheW2efvtt41BgwYZISEhRpMmTYyuXbsa8+bNM86fP1+ubFXmuikpKTGWLFlidO7c2QgICDBiY2ONKVOmGE6ns8L9OZ1O46GHHjKio6ONgIAAo1u3bsbSpUsrnBvHMAyjoKDAmDdvnnH99dcbQUFBRkhIiNGlSxdjxowZHvNQGYZhPPfcc2Z9VGauqNOnTxuPPvqo0aZNG6NJkyZG+/btjaeeeso4d+6c1/qWzrOzfPlyr++LKpjrpzL1vXDhgrFkyRJjwIABRlhYmBEQEGC0bt3aGDZsmLF48WLj1KlTXo/tzcaNG41BgwYZQUFBRkREhPHLX/7S+OGHH7zOX+Xt/c7IyDAef/xxo0+fPkbz5s2NgIAAo02bNsZdd91lbN26tdzxtm3bZgwbNswICwszbDabx2fkau9dRe/f5Z+1FStWGD179jQCAwON5s2bGw8++KBx7Ngxr/vaunWrcfPNNxtBQUFGaGioMWLECOO7776r8LN74sQJY9y4cUaLFi0MPz8/jzmnrvRZPHLkiPHII48Y8fHxhsPhMJo1a2aMGjXK2LZtW7myVf38oHGzGYaX5y8AAADAA2OaAAAALCA0AQAAWEBoAgAAsKDe3z23ceNGbdy40bw1Oy4uTnfffbc5L8fLL79cbs6QhIQEzZ8/31x2u91KTU3V1q1bVVRUpO7du2vSpEkesyIXFBRo+fLl5i3Bffv2VXJyspo2bXqtTxEAAPiAej8QfMeOHfLz8zOnx//ss8+0fv16Pfvss2rdurVefvll5eXlacqUKeY2drtdISEh5vJf/vIXffPNN5oyZYpCQ0P15ptvqqCgQIsWLTJnQX7mmWd0+vRpPfzww5KkpUuXKjo6Wk8++WQtni0AAKiv6v3lub59+6p3795q2bKlWrZsqXHjxikwMFD79u0zy9jtdkVERJh/Lg9MLpdLmzdv1vjx49WjRw+1a9dO06ZNU1ZWltLT0yVdekL2rl279MgjjygxMVGJiYl6+OGHtXPnTh07dqzWzxkAANQ/9f7y3OVKSkr05Zdf6sKFC0pMTDTXZ2RkaNKkSWratKm6dOmicePGmc8YOnjwoC5evKgePXqY5aOiohQfH6+9e/cqKSlJe/fuVXBwsBISEswyiYmJCg4O1p49eyqcWM/tdpd7NIDD4Sj3GAgAAOD7fCI0ZWVlKSUlRW63W4GBgXriiScUFxcn6dIzhwYMGKDmzZsrJydH77zzjubOnauFCxfK4XDI6XSWu1wnXXpwY+nDIp1Op9cHOV5expu0tDStXbvWXB40aJBmzJhR/RMGAAD1jk+EppYtW+pPf/qTzp07p6+//lovv/yy5syZo7i4OA0cONAsFx8frw4dOmjKlCnauXOn+Swtb6wM5TIM44pPAR89erRGjhxpLpeWzc3NrfCp3jXNZrOpefPmOnXqlKVzQt2gnXwD7eQbaCff4EvtZLfbzYeWX7FcLdSl2ux2uzkQvEOHDjpw4IA2bNighx56qFzZyMhIRUdHKzs7W5IUERGh4uJiFRQUePQ25efnq1OnTmYZbw/NzM/P99oDVaqiS3HFxcVen+h9LZQGNbfbXe8/lI0Z7eQbaCffQDv5hobYTvV+ILg3hmFUGErOnj2r06dPm4mxffv28vf3Nwd9S5d6grKyssxxUYmJiXK5XNq/f79ZZt++fXK5XGawAgAAjVu972lauXKlevXqpWbNmqmwsFBbt27V999/r5SUFBUWFmr16tW68cYbFRERoZMnT+rtt99WaGio+vXrJ0kKDg7WsGHDlJqaqtDQUIWEhCg1NVXx8fHm4PC4uDglJSVp6dKlmjx5siTp1VdfNe/aAwAAqPehKS8vTy+99JJyc3MVHBysNm3aKCUlRT169FBRUZEOHz6szz//XOfOnVNkZKS6deumxx57TEFBQeY+JkyYIH9/fy1evNic3HLmzJnmHE2SNH36dC1btsycFLNPnz6aOHFirZ8vAACon+r95Ja+6OTJk7U6pik2NlbZ2dkN5ppxQ0Q7+QbayTfQTr7Bl9rJ4XAoOjr6quV8ckwTAABAbSM0AQAAWEBoAgAAsIDQBAAAYAGhCQAAwAJCEwAAgAWEJgAAAAsITQAAABYQmgAAACwgNAEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYQGgCAACwgNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALCA0AQAAWEBoAgAAsIDQBAAAYAGhCQAAwAJCEwAAgAWEJgAAAAsITQAAABYQmgAAACwgNAEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYYK/rClzNxo0btXHjRp08eVKSFBcXp7vvvlu9evWSJBmGoTVr1mjTpk0qKChQQkKCJk6cqNatW5v7cLvdSk1N1datW1VUVKTu3btr0qRJatasmVmmoKBAy5cv144dOyRJffv2VXJyspo2bVqLZwsAAOqret/TFBUVpfvuu08LFizQggUL1L17dz377LM6fPiwJGndunV6//33lZycrAULFigiIkLz5s3T+fPnzX2sWLFC27Zt04wZMzR37lwVFhZq4cKFKikpMcu8+OKLyszMVEpKilJSUpSZmaklS5bU+vkCAID6qd6Hpr59+6p3795q2bKlWrZsqXHjxikwMFD79u2TYRjasGGDRo8erf79+ys+Pl5Tp07VhQsXtGXLFkmSy+XS5s2bNX78ePXo0UPt2rXTtGnTlJWVpfT0dEnSkSNHtGvXLj3yyCNKTExUYmKiHn74Ye3cuVPHjh2ry9MHAAD1RL2/PHe5kpISffnll7pw4YISExOVk5Mjp9Opnj17mmUcDoe6du2qPXv26JZbbtHBgwd18eJF9ejRwywTFRWl+Ph47d27V0lJSdq7d6+Cg4OVkJBglklMTFRwcLD27Nmjli1beq2P2+2W2+02l202m4KCgsx/14bS49TW8VA1tJNvoJ18A+3kGxpiO/lEaMrKylJKSorcbrcCAwP1xBNPKC4uTnv27JEkhYeHe5QPDw/XqVOnJElOp1N2u10hISHlyjidTrNM2X2ULeNNWlqa1q5day63a9dOixYtUnR0dFVOs1piYmJq/ZioPNrJN9BOvoF28g0NqZ18IjS1bNlSf/rTn3Tu3Dl9/fXXevnllzVnzhzz9bIp1jCMq+7TapkrJeTRo0dr5MiR5epx8uRJFRcXX3X/NcFmsykmJkbHjx+3dE6oG7STb6CdfAPt5Bt8qZ3sdrulDg+fCE12u91Mqh06dNCBAwe0YcMGjRo1StKlnqLIyEizfH5+vtlzFBERoeLiYhUUFHj0NuXn56tTp05mmby8vHLHvXw/3jgcDjkcDq+v1fYHxDCMev+hBO3kK2gn30A7+YaG1E71fiC4N4ZhyO12q0WLFoqIiDAHdEtScXGxMjIyzEDUvn17+fv7e5TJzc1VVlaWEhMTJV0av+RyubR//36zzL59++Ryucz9AACAxq3e9zStXLlSvXr1UrNmzVRYWKitW7fq+++/V0pKimw2m0aMGKG0tDTFxsYqJiZGaWlpatKkiQYPHixJCg4O1rBhw5SamqrQ0FCFhIQoNTVV8fHx5uDwuLg4JSUlaenSpZo8ebIk6dVXXzXv2gMAAKj3oSkvL08vvfSScnNzFRwcrDZt2iglJcUMPKNGjVJRUZFee+01nTt3Th07dlRKSop5F5skTZgwQf7+/lq8eLE5ueXMmTPl5/evjrbp06dr2bJlmj9/viSpT58+mjhxYu2eLAAAqLdsRkO50FiPnDx50mMqgmvJZrMpNjZW2dnZDeaacUNEO/kG2sk30E6+wZfayeFwWBoI7pNjmgAAAGoboQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYQGgCAACwgNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALLDXdQUAoD4Yu2GsjhYcld1uV3FxsVqFtNKqEavquloA6hFCEwBIOlpwVAfzDtZ1NQDUY1yeAwAAsIDQBAAAYAGhCQAAwAJCEwAAgAWEJgAAAAsITQAAABYQmgAAACwgNAEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYQGgCAACwgNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALCA0AQAAWEBoAgAAsMBe1xW4mrS0NG3btk1Hjx5VQECAEhMT9cADD6hly5ZmmZdfflmfffaZx3YJCQmaP3++uex2u5WamqqtW7eqqKhI3bt316RJk9SsWTOzTEFBgZYvX64dO3ZIkvr27avk5GQ1bdr0Gp8lAACo7+p9aMrIyNBtt92mDh066OLFi1q1apXmzZun559/XoGBgWa5pKQkTZkyxVy22z1PbcWKFfrmm280Y8YMhYaG6s0339TChQu1aNEi+fld6nB78cUXdfr0aaWkpEiSli5dqiVLlujJJ5+shTMFAAD1Wb2/PJeSkqKhQ4eqdevWatu2raZMmaJTp07p4MGDHuXsdrsiIiLMPyEhIeZrLpdLmzdv1vjx49WjRw+1a9dO06ZNU1ZWltLT0yVJR44c0a5du/TII48oMTFRiYmJevjhh7Vz504dO3asVs8ZAADUP/U+NJXlcrkkySMUSZd6pCZNmqQZM2bolVdeUV5envnawYMHdfHiRfXo0cNcFxUVpfj4eO3du1eStHfvXgUHByshIcEsk5iYqODgYO3Zs+danhIAAPAB9f7y3OUMw9Abb7yhzp07Kz4+3lzfq1cvDRgwQM2bN1dOTo7eeecdzZ07VwsXLpTD4ZDT6ZTdbi8XtMLDw+V0OiVJTqdT4eHh5Y55eZmy3G633G63uWyz2RQUFGT+uzaUHqe2joeqoZ18E+1VP/Hz5BsaYjv5VGh6/fXXlZWVpblz53qsHzhwoPnv+Ph4dejQQVOmTNHOnTvVv3//CvdnGMZVj2kYRoUNnpaWprVr15rL7dq106JFixQdHX3V/da0mJiYWj8mKo92qr/KjoO02+2KjY2to9rACn6efENDaiefCU3Lli3TN998ozlz5njc8eZNZGSkoqOjlZ2dLUmKiIhQcXGxCgoKPHqb8vPz1alTJ7PM5Zf0Li/jrQdKkkaPHq2RI0eay6Xh6uTJkyouLq7cCVaRzWZTTEyMjh8/bikEom7QTvVf2Z/Z4uJi8zsE9Qs/T77Bl9rJbrdb6vCo96HJMAwtW7ZM27Zt0+zZs9WiRYurbnP27FmdPn1akZGRkqT27dvL399f6enpZq9Ubm6usrKydP/990u6NH7J5XJp//796tixoyRp3759crlcZrAqy+FwyOFwVFjv2mQYRr3/UIJ28jW0Vf3Gz5NvaEjtVO9D0+uvv64tW7bo97//vYKCgszxRcHBwQoICFBhYaFWr16tG2+8URERETp58qTefvtthYaGql+/fmbZYcOGKTU1VaGhoQoJCVFqaqri4+PNweFxcXFKSkrS0qVLNXnyZEnSq6++qt69e3vMCQUAABqneh+aNm7cKEmaPXu2x/opU6Zo6NCh8vPz0+HDh/X555/r3LlzioyMVLdu3fTYY4+Zg7IlacKECfL399fixYvNyS1nzpxpztEkSdOnT9eyZcvMSTH79OmjiRMnXvuTBAAA9Z7NaCh9ZvXIyZMnPe6qu5ZsNptiY2OVnZ3dYLo/GyLaqf67afVNOpj3r/nf2oe31z/H/LMOa4SK8PPkG3ypnRwOh6UxTT43TxMAAEBdIDQBAABYQGgCAACwgNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALCA0AQAAWEBoAgAAsKDeP7AXAKpr7IaxOlpw1FxuFdJKq0asqsMaAfBFhCYADd7RgqMeD+MFgKrg8hwAAIAFhCYAAAALCE0AAAAWEJoAAAAsYCA4gEYnuyBbN62+qdw6ALgSQhOARsdtuMvdTWf34+sQwJVxeQ4AAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAs4HYRAA1K2YfzSkwnAKBmEJoANCjeHs7LdAIAagKX5wAAACwgNAEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsYJpcAKhBZR/j0iqklVaNWFWHNQJQUwhNAHyGt+fK1bdQ4u0xLgAaBkITAJ/hLZBkF2TrptU3eSwDwLVwzUJTSUmJDhw4oNzcXLVt21YtWrS4VocC0Ii5DbdHkOLhvACulWp9u+zatUsff/yxBgwYoEGDBpnrz5w5o2effVaHDh2SJNlsNt1111265557qldbAACAOlKt0PT5559r+/btuvPOOz3Wv/HGGzp06JCCg4PVokULZWVlae3atbr++uvVuXPnalUYAOoKg7yBxq1aoenAgQMKDg5W+/btzXUFBQXatm2bwsLC9NxzzyksLExfffWVFi9erA0bNhCaAPiEsmOlStedv3i+jmoEoK5VKzTl5+erefPmHut2796tkpISDRo0SGFhYZKkG2+8UREREfrpp58qfYy0tDRt27ZNR48eVUBAgBITE/XAAw+oZcuWZhnDMLRmzRpt2rRJBQUFSkhI0MSJE9W6dWuzjNvtVmpqqrZu3aqioiJ1795dkyZNUrNmzcwyBQUFWr58uXbs2CFJ6tu3r5KTk9W0adNK1xuAbys7VkpivBTQ2FVrcssLFy7Iz89zFz/++KMkqXv37h7rmzVrptOnT1f6GBkZGbrttts0f/58Pf300yopKdG8efNUWFhollm3bp3ef/99JScna8GCBYqIiNC8efN0/vy//ke4YsUKbdu2TTNmzNDcuXNVWFiohQsXqqSkxCzz4osvKjMzUykpKUpJSVFmZqaWLFlS6ToDAICGp1qhKTw8XDk5Obp48aK57rvvvpOfn5+6dOniUbaoqEhNmjSp9DFSUlI0dOhQtW7dWm3bttWUKVN06tQpHTx46X+AhmFow4YNGj16tPr376/4+HhNnTpVFy5c0JYtWyRJLpdLmzdv1vjx49WjRw+1a9dO06ZNU1ZWltLT0yVJR44c0a5du/TII48oMTFRiYmJevjhh7Vz504dO3asqm8RgEau9DLf5X/Gbhhb19UCUAXVCk1dunSRy+XS2rVrVVhYqM2bN+vYsWNKSEjwuKRVXFys7OxsRUVFVbvCLpdLkhQSEiJJysnJkdPpVM+ePc0yDodDXbt21Z49eyRJBw8e1MWLF9WjRw+zTFRUlOLj47V3715J0t69exUcHKyEhASzTGJiooKDg839AEBllV7mu/xP2Qk6AfiGal2gHz16tLZv36733ntP7733nrm+7N106enpKi4uVmJiYnUOJ8Mw9MYbb6hz586Kj4+XJDmdTkmXer0uFx4erlOnTpll7Ha7GbQuL1O6vdPpLLePsmXKcrvdcrvd5rLNZlNQUJD579pQepzaOh6qhnaqmrHvj9WRgiPmcn2cuLKqbcpnoer4efINDbGdqhWaWrdurVmzZmnt2rU6ceKEmjVrphEjRigpKcmj3Oeff67g4GD16tWrOofT66+/rqysLM2dO7fca2UbxTCMq+7PapmKGjwtLU1r1641l9u1a6dFixYpOjr6qvutaTExMbV+TFQe7VQ5xwuPewzGdvg5ypWxyXbF5WtZxm63KzY2tty6q+3H23aoPH6efENDaqdq3wrSsWNHPfnkk1cs89hjj1X3MFq2bJm++eYbzZkzx+OOt4iICEmXeooiIyPN9fn5+WbPUUREhIqLi1VQUODR25Sfn69OnTqZZfLy8sod9/L9lDV69GiNHDnSXC4NVydPnlRxcXEVz7RybDabYmJidPz4cUshEHWDdqqasj9Hhsq/d2XX1WaZw87D6vBCB491ZXvDvO2ndMgCqoafJ9/gS+1kt9stdXhUKzR99tlnCg8PL9ez5M13330np9OpIUOGVOoYhmFo2bJl2rZtm2bPnl3ucSwtWrRQRESE0tPT1a5dO0mXvpAyMjJ0//33S5Lat28vf39/paena+DAgZKk3NxcZWVlmWUSExPlcrm0f/9+dezYUZK0b98+uVwuM1iV5XA45HCU/59vab1rk2EY9f5DCdqpoanOtAR8DqqPnyff0JDaqVqh6c9//rM6d+5sKTT99a9/VUZGRqVD0+uvv64tW7bo97//vYKCgszxRcHBwQoICJDNZtOIESOUlpam2NhYxcTEKC0tTU2aNNHgwYPNssOGDVNqaqpCQ0MVEhKi1NRUxcfHm4PD4+LilJSUpKVLl2ry5MmSpFdffVW9e/f2mBMKAAA0TrU2U1tVU+bGjRslSbNnz/ZYP2XKFA0dOlSSNGrUKBUVFem1117TuXPn1LFjR6WkpJiDsiVpwoQJ8vf31+LFi83JLWfOnOkxz9T06dO1bNkyzZ8/X5LUp08fTZw4sUr1BgAADUuthSan06nAwMBKb7d69eqrlrHZbBozZozGjBlTYZmAgAAlJycrOTm5wjIhISGaPn16pesIAAAavkqFplOnTiknJ8djncvlUkZGRoXbFBUVKSMjQ9nZ2eZYIQBozMo+144H/wK+oVKh6ZNPPvG4xV6SsrKyNGfOHEvb//znP6/M4QCgQfI2gBxA/Vep0BQdHa2uXbuayxkZGQoODlbbtm0r3CYgIEDXXXedBg4cqM6dO1e5ogAAAHWpUqFp6NCh5uBrSbr33nsVHx+vWbNm1XS9AAAA6pVqDQSfNWuWgoODa6ouAAAA9Va1QtPll+oAAAAashqbcsDlcunEiRMqLCy84pxMBC0AAOCLqh2aMjIytHLlSu3bt++qZW02m1at4rZaAADge6oVmnbv3q1nnnlGFy9elN1uV4sWLRQWFuYxyzYAAEBDUK3QtGbNGl28eFGDBw/Wgw8+qNDQ0JqqF4BGZuyGsTpacNRjXXZBdh3VBgDKq1ZoOnjwoIKDgzV16lR6lwBUy9GCo+UmfLT71dqTngDgqqr1jWS32xUTE0NgAoBqKPtYFYlHqwD1UbVCU0JCgg4ePCjDMGSz2WqqTgDQqPBYFcA3VKuL6O6775bL5dLf/va3mqoPAABAvVStnqaoqCiNHz9eqamp2rNnj4YNG6brrrtOgYGBFW7TvHnz6hwSAACgTlQrNE2dOtX8944dO7Rjx44rlmeeJgAA4KuqFZroNQIAAI1FtULTyy+/XFP1AAAAqNeYBAVAnSg7mSUTWQKo7whNAOpE2cksmcgSQH1XrW+pU6dOVXobxkEBAABfVGN3z1nB3XMAAMBXXbO75y5cuKCzZ89Kkvz9/RUZGVmdQwEAANSpa3r3nMvl0qZNm/Tuu+9q8ODBGjduXHUOBwAAUGeu6cjL4OBg/eIXv1Dr1q21YMECtWrVSjfffPO1PCQAAMA1USu3qyQlJSk6OlobNmwgNAGABdkF2bpp9U3mcquQVlo1gjGhQF2qtXt8mzZtqqNHj169IIAGp+ycTBLzMl2N23B7TMkAoO7VSmjKy8vTkSNHrvggXwANV9k5mSTmZQLge67pt1Z+fr4OHDigVatWqbi4WNdff/21PBwAAMA1U63QdO+991ouGxERofvuu686hwMAAKgz17SnqUmTJrruuuuUlJSkX/ziFwoLC7uWhwOABqvswHCJweFAbatWaHrnnXdqqh4AgCtgYDhQ9/zqugIAAAC+gNAEAABgQY2MaXK73dq6dau+++47ZWdn6/z58woKClJsbKx69uypQYMGyeFw1MShAAAA6kS1Q9PBgwe1ePFi5eTklHvt0KFD+uKLL/Tuu+/q8ccfV/v27at7OAAAgDpRrdB0+vRpzZs3T+fOnVNoaKiGDx+u1q1bKzw8XHl5eTp8+LA2b96snJwczZ8/X3/6058UFRVVU3UHAACoNdUKTWlpaTp37pz69eunadOmKSAgoFyZu+66Sy+99JK+/vprpaWlaeLEidU5JAAAQJ2o1kDwXbt2qUmTJpo6darXwCRJAQEBmjJlipo0aaJvv/22OocDAACoM9XqacrNzVV8fPxVnykXGBioVq1aKSsrqzqHAwBcpuyEl0x2CVxb1QpNgYGBysvLs1Q2Ly+PB/YCQA1iwkugdlXr8lz79u11+vRpbd269YrltmzZotOnT3P3HAAA8FnV6mm64447lJ6erpdfflkHDhzQ7bffrhYtWpiv5+Tk6IMPPtDGjRvN8pWVkZGh9evX69ChQ8rNzdUTTzyhfv36ma+//PLL+uyzzzy2SUhI0Pz5881lt9ut1NRUbd26VUVFRerevbsmTZqkZs2amWUKCgq0fPly7dixQ5LUt29fJScnq2nTppWuMwAAaHiqFZp69+6tUaNGad26dXr//ff1/vvvy+FwKCwsTPn5+XK73WbZX/3qV+rdu3elj3HhwgW1bdtWP/vZz/Tcc895LZOUlKQpU6aYy3a752mtWLFC33zzjWbMmKHQ0FC9+eabWrhwoRYtWiQ/v0udbS+++KJOnz6tlJQUSdLSpUu1ZMkSPfnkk5WuMwAAaHiqPbnlfffdp06dOumvf/2r9u3bJ7fbrdOnT0uSbDabOnXqpFGjRlUpMElSr1691KtXryuWsdvtioiI8Pqay+XS5s2bNW3aNPXo0UOSNG3aND366KNKT09XUlKSjhw5ol27dmn+/PlKSEiQJD388MN6+umndezYMbVs2bJKdQcAAA1HjTxGpU+fPurTp48KCwt1/PhxFRYWKjAwUDExMbUy+DsjI0OTJk1S06ZN1aVLF40bN07h4eGSLs1YfvHiRTMwSVJUVJTi4+O1d+9eJSUlae/evQoODjYDkyQlJiYqODhYe/bsqTA0ud1uj940m82moKAg89+1ofQ4tXU8VA3thNrSGD5j/Dz5hobYTpUOTYcPH9aJEycUFhamxMREj9cCAwPVtm1bj3V79+5Vfn6+YmJiFBcXV63KetOrVy8NGDBAzZs3V05Ojt555x3NnTtXCxculMPhkNPplN1uV0hIiMd24eHhcjqdkiSn02mGrIrKeJOWlqa1a9eay+3atdOiRYsUHR1dI+dWGTExMbV+TFReY22nspfMJckm2xWXKVP5Mna7XbGxseXKNVSN9efJ1zSkdqpUaLpw4YLmzZuns2fPatasWZa2MQxDzz33nKKiovTCCy/U+IN7Bw4caP47Pj5eHTp00JQpU7Rz507179//ivW6GsMwrpiQR48erZEjR5rLpWVPnjyp4uJiK9WvNpvNppiYGB0/ftzSOaFuNLZ2Gvv+WB0pOGIuZxdklytjyLjiMmUqX6a4uFjZ2eXf64amsf08+Spfaie73W6pw6NSoWnr1q1yOp265ZZb1KlTJ0vbdOrUScOHD9dHH32krVu3aujQoZU5ZKVFRkYqOjra/OKIiIhQcXGxCgoKPHqb8vPzzXOIiIjwOt9Ufn6+1x6oUg6Ho8IQWNsfEMMw6v2HEo2nnY4UHPGYP8juVyMjAXAV2QXZGvzOYI91DXnCy8by8+TrGlI7VWqepm3btkmq/NQBP//5zyVJX3/9daW2q4qzZ8/q9OnTioyMlHRpLil/f3+lp6ebZXJzc5WVlWVeXkxMTJTL5dL+/fvNMvv27ZPL5bIcDgGgrpVOdnn5n6MFR+u6WkCDUan//mVmZioyMlKtWrWq1EFiY2MVFRWlzMzMSm0nyRxcXionJ0eZmZkKCQlRSEiIVq9erRtvvFERERE6efKk3n77bYWGhppzOQUHB2vYsGFKTU1VaGioQkJClJqaqvj4eHNweFxcnJKSkrR06VJNnjxZkvTqq6+qd+/e3DkHAAAkVTI0nT17Vm3atKnSgSIjI/XTTz9VersDBw5ozpw55vKbb74pSRoyZIgmT56sw4cP6/PPP9e5c+cUGRmpbt266bHHHjPvYpOkCRMmyN/fX4sXLzYnt5w5c6Y5R5MkTZ8+XcuWLTMnxezTp48mTpxYpXMFAAANT6VCk8PhUFFRUZUOVFRU5PUOmqvp1q2bVq9eXeHrpZNRXklAQICSk5OVnJxcYZmQkBBNnz690vUDAACNQ6XGNEVGRurEiRMecxNZ4Xa7deLECUVFRVVqOwAAgPqiUqGpc+fOKioq0ldffVWpg3z55ZcqKipS586dK7UdAABAfVGp0FQ6XcBbb72lU6dOWdrm1KlTeuuttyRdGocEAADgiyoVmjp16qQbb7xRubm5SklJ0ZdffqmSkhKvZUtKSvTFF18oJSVFTqdT/fv3p6cJAAD4rEqPzJ46darOnDmjvXv36oUXXlBYWJg6deqkFi1aKDAwUIWFhcrJydHevXvNCSMTExM1derUGq88AABAbal0aAoICNDs2bO1Zs0affDBB8rPz9f27du9lg0MDNTtt9+ue+65p0p3zgEAANQXVUoy/v7+Gjt2rH75y19q586d2rt3r86cOaPz588rKChIUVFRSkxMVO/evRUcHFzTdQYAAKh11er+CQ4O1uDBgzV48OCrFwbQII3dMLbcozq8PaAXAHwd18wAVMvRgqMeD+eVeEAvgIapUnfPAQAANFaEJgAAAAsITQAAABYQmgAAACwgNAEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALeNYBADRg2QXZumn1TeZyq5BWWjViVR3WCPBdhCYAaMDchrvcswEBVA2X5wAAACwgNAEAAFhAaAIAALCAMU0A0IiUHRguMTgcsIrQBKBSxm4Yq6MFR83l7ILsOqwNKouB4UDVEZoAVMrRgqMev3TtfnyNAGgcGNMEAABgAaEJAADAAvrVAVSo7PgliTFMABovQhOACpUdvyQxhglA48XlOQAAAAsITQAAABbQzw7AxBxMAFAxQhMAE3MwAUDF+EYEgEau7KNVeKwK4B2hCQAaOR6tAljDQHAAAAALCE0AAAAWEJoAAAAsIDQBAABYQGgCAACwoN7fPZeRkaH169fr0KFDys3N1RNPPKF+/fqZrxuGoTVr1mjTpk0qKChQQkKCJk6cqNatW5tl3G63UlNTtXXrVhUVFal79+6aNGmSmjVrZpYpKCjQ8uXLtWPHDklS3759lZycrKZNm9beyQIAgHqr3vc0XbhwQW3btlVycrLX19etW6f3339fycnJWrBggSIiIjRv3jydP3/eLLNixQpt27ZNM2bM0Ny5c1VYWKiFCxeqpKTELPPiiy8qMzNTKSkpSklJUWZmppYsWXLNzw8A6pvSeZsu/zN2w9i6rhZQ5+p9aOrVq5fGjh2r/v37l3vNMAxt2LBBo0ePVv/+/RUfH6+pU6fqwoUL2rJliyTJ5XJp8+bNGj9+vHr06KF27dpp2rRpysrKUnp6uiTpyJEj2rVrlx555BElJiYqMTFRDz/8sHbu3Kljx47V6vkCQF0rnbfp8j+XP14HaKzq/eW5K8nJyZHT6VTPnj3NdQ6HQ127dtWePXt0yy236ODBg7p48aJ69OhhlomKilJ8fLz27t2rpKQk7d27V8HBwUpISDDLJCYmKjg4WHv27FHLli29Ht/tdsvtdpvLNptNQUFB5r9rQ+lxaut4qBraCQ1Bffn88vPkGxpiO/l0aHI6nZKk8PBwj/Xh4eE6deqUWcZutyskJKRcmdLtnU5nuX2ULeNNWlqa1q5day63a9dOixYtUnR0dBXOpnpiYmJq/ZiovPreTna751eCTeW/7Mquo0zjKGO32xUbG1tufV2q7z9PuKQhtZNPh6ZSZVOsYRhX3cZqmSsl5NGjR2vkyJHl6nHy5EkVFxdfdf81wWazKSYmRsePH7d0TqgbvtJOZT+3hsrXtew6yjSOMsXFxcrOzi63vi74ys9TY+dL7WS32y11ePh0aIqIiJB0qacoMjLSXJ+fn2/2HEVERKi4uFgFBQUevU35+fnq1KmTWSYvL6/c/i/fjzcOh0MOh8Pra7X9ATEMo95/KEE7wbfVt88uP0++oSG1U70fCH4lLVq0UEREhDmgW7r0v6GMjAwzELVv317+/v4eZXJzc5WVlaXExERJl8YvuVwu7d+/3yyzb98+uVwucz8AAKBxq/c9TYWFhTp+/Li5nJOTo8zMTIWEhKh58+YaMWKE0tLSFBsbq5iYGKWlpalJkyYaPHiwJCk4OFjDhg1TamqqQkNDFRISotTUVMXHx5uDw+Pi4pSUlKSlS5dq8uTJkqRXX31VvXv3rnAQOAAAaFzqfWg6cOCA5syZYy6/+eabkqQhQ4Zo6tSpGjVqlIqKivTaa6/p3Llz6tixo1JSUsy72CRpwoQJ8vf31+LFi83JLWfOnCk/v391tE2fPl3Lli3T/PnzJUl9+vTRxIkTa+ksAQBAfVfvQ1O3bt20evXqCl+32WwaM2aMxowZU2GZgIAAJScnVzhBpiSFhIRo+vTp1aorAABouHx6TBMAAEBtITQBAABYUO8vzwG4NsZuGFvu0RjZBfVjHh4AqI8ITUAjdbTgqA7mHfRYZ/fjKwEAKsLlOQAAAAv4byUA4KqyC7J10+qbzOVWIa20asSqOqwRUPsITQCAq3Ib7nKXc4HGhstzAAAAFhCaAAAALCA0AQAAWEBoAgAAsICB4EAjUXYySyayBIDKITQBjUTZySyZyBIAKodvTQBApZWdt0li7iY0fIQmAEClMW8TGiMGggMAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYwIzgQANU9uG8Eg/oBYDqIjQBDVDZh/NKPKAX117Z59HxLDo0NHyLAgBqBM+jQ0NHaAIagLKX47gUBwA1j9AENABlL8dxKQ4Aah53zwEAAFhAaAIAALCA0AQAAGABAx8AANdE2SkIJKYhgG8jNAEArgmmIEBDw+U5AAAACwhNAAAAFhCaAAAALCA0AQAAWEBoAgAAsIDQBAAAYAGhCQAAwAJCEwAAgAU+P7nl6tWrtXbtWo914eHh+stf/iJJMgxDa9as0aZNm1RQUKCEhARNnDhRrVu3Nsu73W6lpqZq69atKioqUvfu3TVp0iQ1a9asVs8FAADUXz4fmiSpdevW+o//+A9z2c/vXx1o69at0/vvv68pU6YoNjZW7733nubNm6cXXnhBQUFBkqQVK1bom2++0YwZMxQaGqo333xTCxcu1KJFizz2BQAAGq8GEZr8/PwUERFRbr1hGNqwYYNGjx6t/v37S5KmTp2qyZMna8uWLbrlllvkcrm0efNmTZs2TT169JAkTZs2TY8++qjS09OVlJRUi2cCXN3YDWN1tOCox7rsguw6qg1QOWWfR8ez6OBLGkRoOn78uB5++GHZ7XYlJCRo3Lhxuu6665STkyOn06mePXuaZR0Oh7p27ao9e/bolltu0cGDB3Xx4kUzMElSVFSU4uPjtXfv3iuGJrfbLbfbbS7bbDaz98pms9X8iXpRepzaOh6qpibb6WjB0XLP87L7NYgfZTQCZZ9H5+2hvnEhcVr184qDFN97vqEhtpPPf9MmJCRo6tSpatmypZxOp9577z09/fTTev755+V0OiVdGuN0ufDwcJ06dUqS5HQ6ZbfbFRISUq5M6fYVSUtL8xhP1a5dOy1atEjR0dHVP7FKiomJqfVjovKq0k63pt6qn/J+MpePnzteroxNtisuU4Yy9bVMsVFc/j8BdrtiY2PLbVsW33u+oSG1k8+Hpl69epn/jo+PV2JioqZNm6bPPvtMCQkJksqnXMMwrrpfK2VGjx6tkSNHmsulxzl58qSKi4st1b+6bDabYmJidPz4cUt1Rt2oTjsdOH3A45eKt14lQ8YVlylDGV8qU1xcrOzsii85873nG3ypnex2u6UOD58PTWUFBgYqPj5e2dnZuuGGGyRd6k2KjIw0y+Tn55u9TxERESouLlZBQYFHb1N+fr46dep0xWM5HA45HA6vr9X2B8QwjHr/oQTtBFhl9T+3/DzVfw2pnRrcrWFut1tHjx5VZGSkWrRooYiICKWnp5uvFxcXKyMjwwxE7du3l7+/v0eZ3NxcZWVlKTExsdbrDwAA6ief72l688031bdvXzVv3lx5eXl69913df78eQ0ZMkQ2m00jRoxQWlqaYmNjFRMTo7S0NDVp0kSDBw+WJAUHB2vYsGFKTU1VaGioQkJClJqaqvj4eI/B4QAAoHHz+dB05swZ/dd//Zfy8/MVFhamhIQEzZ8/37w2OWrUKBUVFem1117TuXPn1LFjR6WkpJh3uUnShAkT5O/vr8WLF5uTW86cOZM5mgAAgMnnQ9Njjz12xddtNpvGjBmjMWPGVFgmICBAycnJSk5OruHaAQCAhoKuFAAAAAt8vqcJaEiY7RsA6i9CE1CPMNs3ANRffBsDAOoVnk+H+orQBACoV8o+nw6oLxgIDgAAYAE9TUAdKjvwm0HfAFB/EZqAOlR24DeDvgGg/uLyHAAAgAWEJgAAAAsITQAAABYQmgAAACxg1CkAoF4rO9mlJHVo1kFv/NsbdVQjNFaEJgBAveZtsku7nV9fqH1cngMAALCAqA7UkltTb9WB0wc81jGZJVA1R/KPaPA7g81lnk+H2kBoAmrJT3k/lb/EwGSWQJW4L/J8OtQ+Ls8BAABYQGgCAACwgNAEAABgAQMqgGtk7IaxOlpw1Fw+fu54HdYGaNi8zeXE4HDUNEITcI0cLTjqMVDV4eeow9oADZu3uZyAmkZoAgA0SPQ+oaYRmgAADRK9T6hphCagBpQdvyQxcSUANDSEJqAGlB2/JDFxJVAflb1kx+U6VAbf6gCARoNLdqgOQhNQBWUvx3EpDgAaPkITUAVlL8dxKQ4AGj6+6QEAjRbTEqAyCE3AVXBnHNBwMcYJlUFoAq6CO+MAABIP7AUAALCE0AQAAGAB1xiAMphOAGjcmAATFSE0AWUwnQDQuJUdHM4ddijFbwM0atwZB+BquMMOpQhNaDQqCkjnL573WEfPEoCr4RJe48RvBzQaTB0AoKbQ+9Q48RsDDRYDugEANYnQhAaLAd0Aaou3weJnCs8oKjDKXOYSnu/jt0gZ//jHP7R+/Xo5nU7FxcXpwQcfVJcuXeq6WiijbC9S2S8niZ4lALXH2+U6u59dzgvOuqkQrglC02W++OILrVixQpMmTVKnTp308ccf65lnntHixYvVvHnzuq5eo2VlALe3Lyd6lgDUJ0xd4Pv4rXKZv//97xo2bJiGDx8uSXrwwQf13XffaePGjbrvvvvquHaNh7exSNzhBsDXeeuNsnIXXtnvRIJW3eE3z/8qLi7WwYMH9atf/cpjfY8ePbRnz566qVQjYLUXCQAaIisTaZb9TmT8VN3ht9H/ys/PV0lJicLDwz3Wh4eHy+l0et3G7XbL7XabyzabTUFBQbLba+9ttdlskiSHwyHDMMq9/tSWp5TjyjGXWwS30ILBCyp9nLL7ySvKU3iA53tVdp2VMsUqVniQZ5lmTZupuKTYXLb72T2Wva2rqTLXct+UoQxl6rZMXR+/qmWsfCeWLVOsYj3yySMeZaryHV3V3xnS1X8/1SdWf28TmsoobeSrrZOktLQ0rV271lweNGiQZsyYocjIyGtWv4pUNObqtdGv1cj+a2o/AIDGpSGNCfar6wrUF2FhYfLz8yvXq5SXl1eu96nU6NGjtWLFCvPP5MmTPXqeasP58+c1c+ZMnT9//uqFUWdoJ99AO/kG2sk3NMR2IjT9L7vdrvbt2ys9Pd1jfXp6ujp16uR1G4fDoeDgYI8/DoejNqprMgxDhw4dqvddn40d7eQbaCffQDv5hobYTlyeu8zIkSO1ZMkStW/fXomJifr444916tQp3XLLLXVdNQAAUMcITZcZOHCgzp49q3fffVe5ublq3bq1nnrqKUVHR9d11QAAQB0jNJVx22236bbbbqvraljmcDh099131/plQVQO7eQbaCffQDv5hobYTjajIV1sBAAAuEYYCA4AAGABoQkAAMACQhMAAIAFhCYAAAALuHvOR+Xk5Ojdd9/V7t275XQ6FRUVpZtuukl33nmnxzN0Tp06pddee03ff/+9AgICNGjQII0fP75Wn4/X2L333nvauXOnMjMzZbfbtWLFinJlaKf64R//+IfWr18vp9OpuLg4Pfjgg+rSpUtdV6vRysjI0Pr163Xo0CHl5ubqiSeeUL9+/czXDcPQmjVrtGnTJhUUFCghIUETJ05U69at67DWjUtaWpq2bdumo0ePKiAgQImJiXrggQfUsmVLs0xDaid6mnzUsWPHZBiGHnroIT3//POaMGGCPvroI61cudIsU1JSogULFujChQuaO3euZsyYoa+//lpvvvlmHda88SkuLtaNN96oW2+91evrtFP98MUXX2jFihW68847tWjRInXp0kXPPPOMTp06VddVa7QuXLigtm3bKjk52evr69at0/vvv6/k5GQtWLBAERERmjdvXoN6bEd9l5GRodtuu03z58/X008/rZKSEs2bN0+FhYVmmQbVTgYajHXr1hlTp041l3fu3GmMGTPGOH36tLluy5Ytxn333WecO3euLqrYqH3yySfGhAkTyq2nneqHp556ynj11Vc91j322GPGW2+9VUc1wuXuuece4+uvvzaXS0pKjMmTJxtpaWnmuqKiImPChAnGxo0b66CGMAzDyMvLM+655x7j+++/Nwyj4bUTPU0NiMvlUkhIiLm8d+9excfHKyoqylzXs2dPud1uHTx4sC6qCC9op7pXXFysgwcPqmfPnh7re/TooT179tRRrXAlOTk5cjqdHm3mcDjUtWtX2qwOuVwuSTJ/FzW0diI0NRDHjx/XBx984PGcPKfTqfDwcI9yISEhstvtcjqdtVxDVIR2qnv5+fkqKSkp1w7h4eG0QT1V2i7e2iwvL68OagTDMPTGG2+oc+fOio+Pl9Tw2olRpvXM6tWrtXbt2iuWWbBggTp06GAunzlzRs8884wGDBig4cOHe5S12WzltjcMw+t6WFeVdroS2ql+8PZ+0wb1W9n2MXjIRZ15/fXXlZWVpblz55Z7raG0E6Gpnrn99ts1aNCgK5a5/AHCZ86c0Zw5c5SYmKiHHnrIo1xERIT279/vsa6goEAXL14sl/pROZVtpyuhnepeWFiY/Pz8yvUq5eXl0Qb1VEREhKRLPRmRkZHm+vz8fNqsDixbtkzffPON5syZo2bNmpnrG1o7EZrqmbCwMIWFhVkqWxqY2rVrpylTpsjPz/Nqa2Jiot577z3l5uaaH9b09HQ5HA61b9++xuvemFSmna6Gdqp7drtd7du3V3p6usct7enp6brhhhvqsGaoSIsWLRQREaH09HS1a9dO0qWxaRkZGbr//vvruHaNh2EYWrZsmbZt26bZs2erRYsWHq83tHYiNPmoM2fOaPbs2WrevLnGjx+v/Px887XSZN+zZ0/FxcXppZde0gMPPKCCggKlpqZq+PDhCg4OrqOaNz6nTp1SQUGBTp06pZKSEmVmZkqSYmJiFBgYSDvVEyNHjtSSJUvUvn17JSYm6uOPP9apU6c8xgmidhUWFur48ePmck5OjjIzMxUSEqLmzZtrxIgRSktLU2xsrGJiYpSWlqYmTZpo8ODBdVjrxuX111/Xli1b9Pvf/15BQUFmb21wcLACAgJks9kaVDvZDF+9sNjIffrpp/rzn//s9bXVq1eb/y6dNHH37t0KCAjQ4MGD9etf/1oOh6O2qtrovfzyy/rss8/KrZ81a5a6desmiXaqL0ont8zNzVXr1q01YcIEde3ata6r1Wh9//33mjNnTrn1Q4YM0dSpU81JEz/++GOdO3dOHTt21MSJE81ByLj2xowZ43X9lClTNHToUElqUO1EaAIAALCAKQcAAAAsIDQBAABYQGgCAACwgNAEAABgAaEJAADAAkITAACABYQmAAAACwhNAAAAFhCaAAAALCA0AUAZWVlZuvfee/Xqq6/WaT1cLpd+85vf6D/+4z/qtB4ALuGBvQB80v79+/Xpp5/qhx9+0JkzZ1RYWKjg4GDFxsaqc+fOGjhwoNq3b1+lfb/11lvy8/PT6NGja7jWUklJib766itt2bJFBw8eVH5+vgICAhQeHq5WrVqpR48eGjBggMLDwxUcHKw77rhDa9eu1fbt23XDDTfUeH0AWEdoAuBTLly4oFdeeUVbt26VJPn7+ysmJkZBQUEqKCjQ/v37tXfvXq1fv169evXSU089Van9//DDD/r22281dOhQRUdH12jdc3Nz9fzzz2vPnj2SpNDQULVu3VrFxcU6duyYsrOztWPHDrVs2VI9evSQJI0YMUJ/+9vftHLlSvXt21c2m61G6wTAOkITAJ9RXFys+fPn68cff1RkZKTGjh2rAQMGKDAw0Cxz7tw5bd++XevXr9fu3bsrfYwPP/xQkjRkyJAaq7ckFRUV6Y9//KOOHDmi66+/Xvfff79HT1hRUZF27dqlDz/8UO3atTPXh4SEqE+fPvriiy+0e/duXX/99TVaLwDWEZoA+Iw1a9aYgWn+/Plq3rx5uTJNmzbV0KFDddNNN2ndunWV2n9+fr62b9+uyMhIdenSpaaqLelSGDty5IjatGmjP/zhD/L39/d4PSAgQP369VO/fv3KbTtw4EB98cUX2rRpE6EJqEMMBAfgE86dO6cPPvhAkvSb3/zGa2C6nL+/v+68885KHWPbtm0qLi5Wr1695OdX/usxJydHY8aM0aOPPlrhPn7zm99ozJgxOnfunMf6HTt2SJIGDBhQLjBdTVJSkvz9/bV9+3a53e5KbQug5hCaAPiEb7/9VoWFhYqIiPDaG1MTMjIyJEkdO3b0+npWVpYkqU2bNl5fz8nJ0blz5xQdHa2mTZt6vJabmytJOn/+fKXrFRAQoPj4eLndbh04cKDS2wOoGYQmAD6hdPB0YmKi116gmrB3715JqvCuu59++kmS1LZt2yu+7i1UtWjRQtKly3Tr16+X0+msVN06dOggSfrxxx8rtR2AmsOYJgA+4cyZM5JU43e0lTIMQ6dPn5YkRUREeC1TGoouH6h9uczMTEneQ9Odd96pjIwMXbhwQf/zP/+jt956S/Hx8erWrZv69eunrl27XrF+pXU6efKkhbMBcC0QmgD4hMLCQklSkyZNvL6+detW/dd//Ve59VOmTNHQoUOvuv9z587p4sWLki7dsebN1XqarhSaunXrpoULF2rdunXasWOHCgsL9dNPP+mnn37Shg0b1L59e02fPl0tW7b0uu/SOuXn51/1XABcG4QmAD6hdFqBCxcueH09LCxMnTp1MpcPHz4sl8tlef+XD7C228t/NV64cEHHjx9XUFCQeamtrKuFqjZt2mj69Olyu93as2eP0tPT9dVXX+n48eM6ePCgnnvuOT377LNeB4oHBARIujQ1AYC6QWgC4BOioqIkVXx56vrrr/e4Hf+Pf/yj/t//+3+W939575LL5SrX23T48GEZhqG2bdt6nWDS5XLp5MmTCgwM1HXXXXfFYzkcDnXv3l3du3fX2LFjtWLFCn344Yc6fPiwMjMzzfFLlysoKJB0aUJMAHWDgeAAfEJiYqKkSwPCS0pKanz/DodDQUFBkv4VUC53pUtvknTgwAEZhqE2bdpUatZuPz8/jRgxwlwuHVdVVmmdwsLCLO8bQM0iNAHwCb169VJgYKDy8vK0bdu2a3KM0stqR48eLfda6XQDFY05+uabbyRVHKqupLi42Px3aY9aWUeOHJFU8Z19AK49QhMAnxASEqLbb79dkrR8+XKdOnWqxo/RuXNnSfI6F1LpeCVv8yydPn1an332maTyocnKwO2NGzdKkpo3b15hKCqtU2kdAdQ+QhMAnzFmzBglJiYqNzdXf/jDH7R582bzrrpSxcXF+uqrr3Ts2LFK779nz56S/jUn1OVKe5o++ugjHT9+3Fx/8OBBLVy40JwBPDIy0mNQ+erVq5WSkqIvv/yy3CD2nJwc/fnPf9aHH34om82miRMnep2D6vjx48rLy1OrVq2uOhM6gGvHZhiGUdeVAACrCgsL9d///d/68ssvJV16XEpMTIyCgoJ09uxZOZ1OM5z07NlTDz30kOW5nQzD0IwZM5STk6NXXnnFnBvp1KlTmjJliqKjo1VYWGjO+u1yuXT27Fl16NBBZ86cUW5urkJDQ3XbbbdpzJgxkqSUlBTt27fPo66BgYE6c+aMnE6nDMNQ06ZN9fDDD+vGG2/0Wq/33ntPq1at0gMPPKBf/vKX1Xn7AFQDd88B8CmBgYF6/PHHNXLkSH366af64YcfdObMGR0/flzBwcGKj49Xp06dNHjw4EqP/7HZbBo+fLjeeustffHFF+YA7dJB4B06dNAvfvELrVixQpmZmQoJCdGtt96q++67T5s3b9Y777yjyMhIJSUlmft8/PHH9fXXX+v777/XiRMn5HQ6zbp27txZSUlJGj58+BUHeG/dulX+/v4aMmRIpd8vADWHniYAuIzL5dK0adMUEhKixYsXy8/Pz+zpueeee3TPPffUan12796tuXPn6tZbb9WkSZNq9dgAPDGmCQAuExwcrLvuukvZ2dn64osvJP2rp6l169a1Xp93331XgYGBuvvuu2v92AA8cXkOAMq49dZb5XK5zPmgSgeBx8fH12o9XC6XunbtqjvuuKPC5+EBqD1cngOAKygqKtKvf/1r2e12paamer27DUDjwE8/AFxBVlaWDMNQXFwcgQlo5OhpAgAAsID/NgEAAFhAaAIAALCA0AQAAGABoQkAAMACQhMAAIAFhCYAAAALCE0AAAAWEJoAAAAsIDQBAABYQGgCAACwgNAEAABgwf8HcMBnlXBBJO4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get state dependent standard deviation/READ noise\n", + "PAR_READStd=[]\n", + "PAR_f_integral = np.sqrt(np.log((1+250e-9)/(2*250e-9)));\n", + "\n", + "def f(x):\n", + " for i in range(0,len(x)):\n", + " DUM_Qs_f= min(np.append(0.0088/x[i]**0.5,2e-1))\n", + " DUM_A = PAR_G[i]*DUM_Qs_f*PAR_f_integral;\n", + " PAR_READStd.append(DUM_A)\n", + "\n", + "PAR_D=f(x)\n", + "fig = plt.subplots()\n", + "plt.title('State depenent READ Noise')\n", + "plt.plot(PAR_G,PAR_READStd,color=\"green\")\n", + "plt.xlabel('G (\\mu S)',fontsize=16)\n", + "plt.ylabel('SD of G (Read Noise)',fontsize=16)\n", + "\n", + "# MAC with Read noise\n", + "PAR_MatrixRead2D=np.zeros((PAR_NumWL,PAR_NumWL))\n", + "for i in np.arange(1,PAR_NumWL):\n", + " for j in np.arange(1,PAR_NumWL):\n", + " DUM_A = PAR_MatrixRef2D[i,j]\n", + " DUM_B=np.argmin(np.abs(np.abs(DUM_A)-PAR_G))\n", + " Factor = PAR_READStd[DUM_B]\n", + " PAR_MatrixRead2D[i,j]= DUM_A+Factor*np.random.uniform(0,1,1)\n", + "\n", + "PAR_MatrixRead=PAR_MatrixRead2D.reshape(PAR_NumPCM)\n", + "fig = plt.subplots()\n", + "plt.title(\"Conductance distribution\")\n", + "plt.hist(PAR_MatrixRead,bins=100,edgecolor=\"green\", color=\"green\")\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Counts', fontsize=16)\n", + "plt.ylim([0, 3500])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 2-3 initialzes variables \n", + "
\n", + "Lines 5-9 is a function that establishes the relationship between G and Read noise\n", + "
\n", + "Lines 11-15 creates a plot of the G and Read noise relationship\n", + "
\n", + "Lines 19-25 associates a read noise to every matrix element in the reference array\n", + "
\n", + "Lines 27-33 plots the histogram of the noisy weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1.3: We inject the non-ideality of temperature sensitivity into all conductance states\n", + "\n", + "Definition: 'Because phase-change materials are typically low-band gap semiconductors, the thermally activated nature of electrical transport implies the device's conductance becomes sensitive to the ambient temperature. Increase in ambient temperature results in decrease of conductance and vice versa'\n", + "
\n", + "
\n", + "Mathematically temperature sensitivity follows the relation $G_{i,j}= G_{0}\\times \\exp^{\\frac{-E_a}{kT}}$, where $E_a$ is activation energy for thermal transport, k is Boltzmann constant and T is the temperature. To simulate the temperature sensitivity, we have to define the state-depenedent (conductance) mean and standard deviation of $E_a$.\n", + "
\n", + "
\n", + "For further reading, refer to [IEEE International Electron Devices Meeting (IEDM), 2021, pp- 28-3](https://ieeexplore.ieee.org/abstract/document/9720519) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 3500.0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHXCAYAAACoBM6aAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvNUlEQVR4nO3dd1gU59oG8HsbXZqAdAEFrIgNFVFRYze2GI2mqNHET9NMOeaYpqabeKI5iZpjNNYYjb0jdgVUUFE0oKAINqqwIJ1l5/uDsBFZFJYywN6/6+Jid+admecRhJupEkEQBBARERFROVKxCyAiIiJqiBiSiIiIiLRgSCIiIiLSgiGJiIiISAuGJCIiIiItGJKIiIiItGBIIiIiItKCIYmIiIhIC4YkIiIiIi0YkoiIiIi0YEgiIiIi0oIhiYgaPDc3N7i5uYldRr3T176JGgqGJKIGrKSkBL/++iv69esHa2trKBQK2NnZwcfHBzNmzMCePXs0YxMSEiCRSDB16tRa2XZtr48aj5p+7QcNGgSJRPLEj6+++qp2iyaqA3KxCyAi7UpKSjBy5EgEBQXB0tISI0aMgLOzMzIyMnDjxg1s2LAB165dw6hRo8QulaicixcvQqFQ4KOPPqp0zHPPPVePFRHphiGJqIH6448/EBQUhE6dOuHkyZOwsLAoNz8zMxMXLlwQqToi7W7evImMjAx06dIFCxYsELscohrh4TaiBio0NBQAMHXq1AoBCQCsrKzwzDPPAAAWLFgAd3d3AMC6devKHdZYu3atZpm1a9fiueeeg4eHB4yNjWFubo7evXtj/fr15dZd1fUBwLlz5zB+/HjY29vDwMAALi4umDlzJu7fv1+tfgVBwM8//4z27dvDyMgITk5OeOONN5CVlVXpMtXZ9qOHkK5du4YxY8bA2toapqamCAgIQHBwcK1uIyEhAS+88AJsbGxgZGSErl27ljs8WpO+q1NXdWuqztdem/PnzwMA/Pz8njqWqKHjniSiBsrW1hYAEBsb+9SxgYGBUCqV+PHHH9GpUyeMGTNGM8/X11fzetasWWjXrh369u0LBwcHpKenY//+/ZgyZQquXbuGr7/+ulrrW7NmDV577TUYGRlh1KhRcHZ2RlxcHFatWoW9e/fi7NmzcHV1rVK/c+bMwX//+184ODjg9ddfh0KhwO7duxEeHo6ioiIYGBiUG6/rtm/duoVevXqhQ4cOmDlzJpKSkrBlyxYMGzYMmzZtwsSJE2u8jcTERPj5+cHDwwMvv/wyMjIysGXLFowZMwaHDx/GwIEDde5b17qqWlNVv/aVYUiiJkUgogbp0qVLgkKhECQSifDiiy8Kf/75pxAfH1/p+Fu3bgkAhClTplQ65saNGxWmFRQUCIGBgYJcLhfu3LlT5fVdv35dUCgUgqenp3D//v1y844ePSpIpVJh9OjRT+yxTGhoqABAaNWqlfDgwQPN9Pz8fKFnz54CAKFly5Y12nZZPwCEDz74oNy8iIgIQS6XC5aWlkJWVlatbGPBggXl5gUFBQkAhKFDh+rcty51VbemR5d50vdSZQIDAwUAwvTp04X58+dr/cjNza32eonEwJBE1IBt3bpVcHBw0PySAyA0b95cGDdunLB///5yY2vyi23btm0CAGHdunVVXt+cOXMEABXqKDNmzBhBKpVqQseTzJgxQwAg/PbbbxXmHT9+vEJY0GXbZf1YWFgI2dnZFZaZMmWKAEBYu3Ztjbfh5uYmqFSqCsu4uroKzZs317lvXeqqbk2PLlPd7yW1Wi1YWFiU+359/MPGxqZa6yQSEw+3ETVg48ePx+jRo3H8+HGEhIQgMjISISEh2LFjB3bs2IFXX30Vq1atgkQiqdL6bt++jUWLFuHo0aO4ffs28vPzy82/d+9elWs7c+YMAODEiRMIDw+vMD81NRVqtRpxcXHo2rXrE9d18eJFAEC/fv0qzOvTpw/k8vI/qmqy7S5duqBZs2YVlgkMDMS6desQGRmJKVOm1Ggbvr6+kMlkFZZxcXHRrFeXvmvSe1VrqonY2FhkZWUhICAAp0+frpV1EomJIYmogVMoFBg8eDAGDx4MoPTWANu3b8err76K3377DaNGjcLo0aOfup74+Hj4+fkhMzMTffr0weDBg2FhYQGZTIaEhASsW7cOhYWFVa7rwYMHAIDvv//+ieNycnKeuq6yk5RbtGhRYZ5MJkPz5s1rbdvatgEA9vb25WqpyTa0nWgPAHK5HGq1WvO+un3XpK6q1lQTZecjderUqVbWRyQ2hiSiRkYmk2HChAm4cuUKvvzySxw9erRKIemHH37AgwcPsGbNmgo3Cfzjjz+wbt26atVR9ks3KysL5ubm1Vq2snWlpKTAw8Oj3LySkhI8ePAATk5OtbLtlJQUrdOTk5PLrbs2+6tMdfuur7p0pWtI+vLLL/Hnn38iPj4exsbGePbZZ7F8+XIYGRnVRZlEVcZbABA1UmWHjARBAADNoZSSkhKt42/cuAFA+038Tp48WWHa09bXs2dPAKiVwypdunSptI7Tp09DpVLV2rYvXryIhw8fVph+4sQJAEDnzp1rvI2qqm7f9VXX0772ldE1JKlUKqxYsQJ//fUX/vjjDxw6dAhLly6t1jqI6oTYJ0URkXabNm0SgoODhZKSkgrzkpKShNatWwsAhD///FMQBEF4+PChIJFIhH79+mld38yZMwUAwu7du8tNDwoKEmQymQBAmD9/vmb609YXExOjucrq+vXrFeYXFhYKp06dqlKvISEh1brKS5dtV+XqNgsLC80JzzXZRmUnPPfr10949MdudfvWpa7q1iQIT//aa1NSUiKYmZkJUqlUyMvLq/Jy2rz22mvCK6+8UqN1ENUGHm4jaqDOnTuHH3/8Efb29ggICNDc4O/WrVvYv38/8vPzMXr0aIwfPx4AYGZmhh49euDUqVN46aWX4OnpCZlMhlGjRsHHxwezZ8/GmjVrMGHCBDz33HNwcnLC1atXERQUhAkTJmDLli3ltv+09bVp0wa//fYbXn31VbRv3x5Dhw6Fl5cXiouLcfv2bZw+fRq2tra4du3aU3vt3bs33nrrLfz000/o0KEDxo8fr7lfkJWVFRwcHMqNr8m2+/bti1WrVuHcuXPo3bu35j5JarUa//vf/zSHsGqzv9rqu77qetrXXpuYmBjk5OTA3NwcixYtqnTdM2fOLNfXnTt38P333+P48eO4d+8eioqKUFhYiLlz5+pcP1GtETulEZF2t2/fFn7++WdhzJgxgpeXl9CsWTNBoVAI9vb2wrBhw4QNGzZU2MsUFxcnjBw5UrC2thYkEokAQFizZo1mfmhoqNC/f3/B0tJSMDMzE3r37i3s3LlTc7n5o3uSqrI+QRCEqKgoYcqUKYKrq6tgYGAgWFlZCe3btxdef/114ejRo1XuV61WCz/99JPQpk0bwcDAQHBwcBBmz54tKJVKoWXLlhX2qFR324/uUYmJiRFGjRolWFpaCsbGxoK/v78QFBSktS5dt6GNtr02uvRdnbp0qUkQqva1f9S6deueeOk/AEEqlZa7/UJ6errQokUL4fnnnxeCgoKEq1evCjExMYKZmZlmDymRmCSC8PcJDURETVhCQgLc3d0xZcqUKj1eg+re+vXr8fbbbyMzM1NzG4t169Zh6tSpiI2Nhaenp8gVkr7j4TYiIhJF8+bNkZOTg127dqFjx444ePAgvv76azRr1gytW7cWuzwiXt1GRETiGD58OGbOnIkpU6bA398fcXFxePHFF+Hj41PlG6QS1SXuSSIiIlFIJBIsW7YMy5YtE7sUIq14ThIRERGRFjzcRkRERKQFQxIRERGRFgxJRERERFowJBERERFpwavbaigzM1PrQyirw9bWFmlpabVUUeOhj32zZ/2hj32zZ/3RmPuWy+WwsrKq2tg6rqXJU6lUKC4u1nn5snuBqFQq6NOFhvrYN3vWj54B/eybPetHz4B+9c3DbURERERaMCQRERERacGQRERERKQFQxIRERGRFjxxm4iISCQqlQp5eXlil1Ft+fn5KCoqErsMrQRBgFwuh6mpaY3XxZBEREQkApVKhdzcXDRr1gxSaeM6sKNQKGp0ZXddy83NRWFhIQwNDWu0nsb1VSEiImoi8vLyGmVAagxMTExQWFhY4/XwK0NERCQSBqS6UXYvp5riV4eIiIhIC4YkIiIiIi0YkoiIiIi0YEgiIiKiKpszZw7s7Ozw4YcfVpg3b948ODk5Yc6cOfVfWB3gLQAamMKSQqTlVe3JylZGVjBV1Pw+EERERNXh5OSEPXv2YMGCBTA2NgYAFBQUYPfu3XBychK5utrDkNTAXE2/ilF7RlVprFQiRYfmHdDDvgd6OvSEn70frI2s67hCIiLSdx07dkRiYiIOHjyIcePGAQAOHjwIR0dHuLq6asYJgoAVK1Zgw4YNSE1Nhbu7O+bMmYORI0cCAEpKSjB37lyEhoYiLS0Njo6OmDJlCmbMmKFZx5w5c5CdnQ0/Pz/873//Q1FREUaPHo2FCxdCoVDUaZ8MSQ2MRCKBkczoqeMECCgsKURUehSi0qPw69VfAQALey3EjA4znrI0ERE1NIIgIF+VL8q2jeXG1b5sfsKECdiyZYsmJG3evBkTJ07EmTNnNGMWLVqEgwcP4ptvvoG7uzvOnj2Lt99+G82bN0evXr2gVqvh4OCAX375BdbW1jh//jzmzp0LOzs7jBr1zw6DsLAw2NnZYevWrbh16xZmzZqF9u3b48UXX6ydf4BKMCQ1MF3suuDmqzerNPZ+zn2EJ4fjbPJZhN4PRXxWPNb8tQbT20+vtXtEEBFR/chX5cNzraco246bGgcThUm1lhk/fjy+/fZb3LlzBxKJBOfPn8eKFSs0ISkvLw+//vortmzZgm7dugEAWrZsiYiICGzcuBG9evWCQqHABx98oFmnq6srzp8/j71795YLSRYWFvjqq68gk8nQunVrDBw4ECEhIQxJVDlHM0eMaT0GY1qPQW5xLjpu6IiE7ATEZsbC29pb7PKIiKgJs7a2xsCBA7F161YIgoABAwbA2vqfUz5iY2NRUFCASZMmlVuuuLgYHTp00Lxfv349/vjjD9y9excFBQUoLi5G+/btyy3j5eUFmUymed+iRQvExMTUUWf/YEhqIkwVpghwDMDRO0cRlBjEkERE1MgYy40RNzVOtG3rYuLEifjkk08AAF999VW5eWq1GkBpCLK3ty83z8DAAACwZ88eLFy4EJ9++im6desGU1NTrFixApGRkeXGazv3SBAEnWquDoakJmSI2xAcvXMUwYnBeKfzO2KXQ0RE1SCRSKp9yEts/fv31zzoNjAwsNw8Ly8vGBoa4t69e+jVq5fW5cPDw9G1a1dMnTpVMy0xMbGuyq02hqQmZJDrIEggwaW0S0jKTYKDqYPYJRERURMmk8lw4sQJzetHmZmZYebMmViwYAHUajX8/PyQk5OD8+fPw8TEBBMmTICbmxu2bduGEydOwMXFBdu3b8fly5fh4uIiQjcVMSQ1IXYmduhs1xkXUy8iODEYU9pNEbskIiJq4po1a1bpvLlz58LGxgY///wzbt++DXNzc3Ts2BFvvfUWAODll1/GX3/9hVmzZkEikWD06NGYMmUKjh07Vl/lP5FEqI+Dek1YWlqaZlejLiQSCRwcHJCUlFQrx1eXXVqGryO+RqBzIH4f9nuN11dXarvvxoA960fPgH72zZ6r33N2djbMzc3roLK6p1AoavS7rz5U9u+rUChga2tbpXXwsSRNzBC3IQCA0PuheFj0UORqiIiIGi+GpCamtWVreFh4oFhdjON3jotdDhERUaPFkNQEDWlZujfpUOIhkSshIiJqvBiSmqCyQ27H7hxDsbphHzMmIiJqqBiSmqAutl1gY2yD7KJsnEk68/QFiIiIqAKGpCZIJpVhkOsgAMChBB5yIyIi0gVDUhNVdl5ScGKw3lyOS0REVJsYkpqoAKcAGMuNcT/3PqLSo8Quh4iIqNFhSGqijOXGmkNu2+K2iVwNERFR48OQ1IRN8JoAANhxYwcKSwpFroaIiKhxYUhqwvo69YW9qT2UhUocTjwsdjlERNREpKWlYe7cuejevTvc3d3h6+uLyZMn4/z58wCAHj16wMnJCU5OTmjVqhV69OiBmTNnIiQkROTKq4chqQmTSWUY7zkeALAldovI1RARUVPx6quvIjo6GkuXLsXp06exZs0a9OrVC0qlUjPmgw8+QGRkJE6dOoUff/wRFhYWeOGFF/Djjz+KV3g1ycUugOrWBM8J+PnSzzhx9wSSc5Nhb2ovdklERNSIZWVl4dy5c9i2bRt69eoFAHB2dkbnzp3LjTMzM4OdnR0AwMnJCT179oSdnR0WL16MESNGoHXr1vVee3VxT1IT18qyFbq36A61oMb2uO1il0NERJURBEjy8kT5QDVuFWNqagpTU1MEBQWhsLB657tOnz4dgiAgODi4uv86ouCeJD0w0WsiIlIisCV2C2Z3mg2JRCJ2SURE9BhJfj4cPD1F2XZSXBwEE5MqjZXL5fjvf/+L999/Hxs3bkSHDh3Qs2dPjB49Gu3atXvislZWVrCxscGdO3dqo+w6xz1JeuBZj2dhLDfGzaybuJB6QexyiIiokXv22Wdx4cIFrFmzBoGBgThz5gyGDh2KLVuefv6rIAiN5o917knSA2YGZhjhPgLb4rbhz9g/0a1FN7FLIiKixwjGxkiKixNt29VlZGSEvn37om/fvnj33XfxwQcf4D//+Q8mTpxY6TIZGRl48OABXF1da1JuveGeJD0x0av0m3b3zd3IV+WLXA0REVUgkUAwMRHlA7WwZ8fT0xN5eXlPHLN69WpIpVIMGTKkxturD9yTpCd6OvSEazNX3H54GwduHcBzns+JXRIRETVCGRkZmDVrFiZMmIC2bdvCzMwMly9fxooVK8qFn5ycHKSmpqK4uBh37tzBjh07sGnTJsybNw/u7u4idlB1DEl6QiqRYoLXBCy+sBh/XP+DIYmIiHRiamqKLl264Ndff0ViYiKKi4vh6OiIyZMn46233tKMW7x4MRYvXgwDAwPY2tqiS5cu2LJlC3r37i1i9dXDkKRHJnhNwA8Xf8CZpDOIfhCNds2ffBUCERHR4wwNDfHJJ5/gww8/rHTMuXPn6rGiusNzkvSIk5kTRriPAACsvLJS5GqIiIgaNoYkPTOz40wAwK6bu5CcmyxyNURERA0XQ5Ke6WzXGd1bdEexuhhro9eKXQ4REVGDxZCkh8r2Jm2I2YC84idfrklERKSvGJL00OCWg+Fm7gZloRJ/xv4pdjlEREQNEkOSHpJJZZjRYQYA4Nerv6JEXSJyRURE+kmtVotdQpMkVOOBvU/CkKSnJnpNhKWhJRKyE3D49mGxyyEi0jsmJiZ4+PAhg1IdyMvLg6GhYY3Xw/sk6SkThQleavsSfr70M1ZeWYmhbkPFLomISK/I5XKYmpoiJydH7FKqzcDAAEVFRWKXoZUgCJDL5QxJVDPT2k3D/6L+h3PJ5xCZGonOdp3FLomISK/I5XKYm5uLXUa1SCQSODg4ICkpqdYOazVUPNymx+xN7TGm1RgAwNLIpaLWQkRE1NAwJOm5t3zfgkwiw5HbR3Ah5YLY5RARETUYjeJw26FDh7Bnzx4olUo4Oztj6tSpaNu2rdax586dQ3BwMBISEqBSqeDs7Iznn38evr6+5cadPXsWW7ZsQUpKClq0aIFJkybBz8+vHrppWFpZtsLzns9jc+xmfHf+O2wZsUXskoiIiBqEBr8nKSwsDGvXrsW4ceOwaNEitG3bFl9//TXS09O1jo+JiYGPjw/mzZuHb7/9Fu3bt8eiRYtw69YtzZjY2FgsXboUffv2xffff4++fftiyZIliIuLq6+2GpR3u7wLhVSBkPshCL0fKnY5REREDUKDD0n79u3DgAEDMHDgQM1eJBsbGwQHB2sdP3XqVIwePRqtW7eGg4MDJk+eDAcHB1y48M+hpP3798PHxwdjx46Fk5MTxo4diw4dOmD//v311VaD4tzMGS+2eREA8N3575r8iXhERERV0aAPt6lUKsTHx2PMmDHlpvv4+OD69etVWodarUZ+fj7MzMw002JjYzFixIhy4zp16oQDBw5Uup7i4mIUFxdr3kskEhgbG2te66ps2Zqsoza83fltbL6+GedTzuP43eMY6DqwTrfXUPquT+xZf+hj3+xZf+hT3w06JGVnZ0OtVsPCwqLcdAsLCyiVyiqtY9++fSgsLESvXr0005RKJSwtLcuNs7S0fOI6d+7ciW3btmneu7u7Y9GiRbC1ta1SHU9jb29fK+vRlQMc8Kbfm1h8ZjF+uPQDXvR7sV7+A4jdtxjYs/7Qx77Zs/7Qh74bdEgqo+2XdVV+gYeEhGDr1q3417/+VSFoPU4QhCeuc+zYsRg5cmSF7aelpUGlUj21lspIJBLY29sjOTlZ9MNcUzynYMX5FYhMjsTqsNUY4THi6QvpqCH1XV/Ys370DOhn3+xZP3oGGn/fcrm8yjs4GnRIMjc3h1QqrbCHJysr66mhJywsDL/88gvee+89+Pj4lJunba/R09apUCigUCi0zquNbxJBEET/ZrM2tMZrHV7D0sil+O78dxjccjDk0rr9FmkIfdc39qw/9LFv9qw/9KHvBn3itlwuh4eHB6KiospNj4qKgre3d6XLhYSEYNmyZXj77bfRpUuXCvO9vLxw5cqVCuv08vKqncIbsdc7vg5LQ0vEKeOw8dpGscshIiISTYMOSQAwcuRIHD16FMeOHcPdu3exdu1apKenY9CgQQCATZs24eeff9aMLwtIr7zyCry8vKBUKqFUKpGXl6cZM3z4cFy+fBm7du3CvXv3sGvXLly5cqXCydz6yMLQAh90/QAA8P3575FRkCFyRUREROJo0IfbAMDf3x8PHz7E9u3bkZmZCRcXF8ybN09zPDEzM7PcPZOOHDmCkpISrF69GqtXr9ZM79evH9544w0AgLe3N+bMmYPNmzdjy5YtsLe3x5w5c+Dp6Vm/zTVQL7d9Gb9f+x0xGTH4/vz3+CbgG7FLIiIiqncSoakfUKxjaWlp5W4NUF0N9UGBYffD8Pz+5yGVSHFw7EF0aN6hVtffUPuuS+xZP3oG9LNv9qwfPQONv2+FQlHlE7cb/OE2Eoe/oz+e9XgWakGNz8I+a5T/EYiIiGqCIYkq9WmPT2EkM8K55HPYE79H7HKIiIjqFUMSVcrJzAlv+r4JAPj83OfIK857yhJERERNB0MSPdEsn1lwbeaK5Nxk/Bj5o9jlEBER1RuGJHoiI7kRFvRcAABYEbUCV9OvilsQERFRPWFIoqca4jYEI91HokQowbsn30WxWver+YiIiBoLhiSqki/9v4SVoRWiM6Kx7NIyscshIiKqcwxJVCW2Jrb4wv8LAMDSyKW4nnFd5IqIiIjqFkMSVdmYVmMwyHUQitXFeP/U+yhRl4hdEhERUZ1hSKIqk0gk+CbgGzRTNENkWiR+vfqr2CURERHVGYYkqhYHUwfM7zkfQOkDcG8ob4hcERERUd1gSKJqe8H7BfRz6oeCkgLMPjYbhSWFYpdERERU6xiSqNokEgl+6PcDrI2s8deDv/B1+Ndil0RERFTrGJJIJ/am9vih7w8AgFVXV+Ho7aMiV0RERFS7GJJIZ4NaDsL09tMBAO+efBcpeSkiV0RERFR7GJKoRj7y+wjtrNvhQcEDzDkxB2pBLXZJREREtYIhiWrESG6E5QOWw0hmhFP3TuGXqF/ELomIiKhWMCRRjXlaeWruxv1txLcIux8mckVEREQ1x5BEtWKS9ySMaz0OJUIJ/u/o/+Fezj2xSyIiIqoRhiSqFRKJBN/1+Q7tm7fHg4IHeO3wayhQFYhdFhERkc50DkkbN27EvXvcW0D/MJYbY/Wg1bA0tMTl9Mv4KPQjCIIgdllEREQ60Tkk7d27F++99x4+/vhjBAcHIzc3tzbrokbKpZkLVgxYAalEii2xW7A+Zr3YJREREelE55A0ePBgmJmZ4caNG1i9ejVef/11LF26FJcuXeLeAz3X17kv5nWfBwCYf2Y+wpPDRa6IiIio+uS6Ljh9+nRMmTIFFy5cwMmTJ3Hp0iWcOXMGZ86cgaWlJfr27Yt+/frB2dm5NuulRmKWzyxcTruMfbf24dXgV7F39F64W7iLXRYREVGV6RySAEAul6NHjx7o0aMHsrOzERISgpMnTyIhIQF79uzBnj170KpVKwQGBqJ3794wNTWtrbqpgZNIJFjSbwnuPLyDy+mX8XLQy9gzeg+sjazFLo2IiKhKahSSHmVubo7hw4dj+PDhuH37Nk6cOIGQkBDcvHkTN2/exLp169C9e3cEBgbC19e3tjZLDZiJwgRrh6zFs7ufxa3sW5gePB1/DP8DRnIjsUsjIiJ6qjq5BYCrqysGDBiA3r17Qyot3YRKpcKZM2fwzTff4J133kFYGG84qA/sTOywfsh6mBuYIzwlHO+fep+PLiEiokah1vYkAUBOTo7mkFt8fDwAQCqVomvXrggMDERWVhaOHTuG+Ph4/Pjjj8jLy8MzzzxTmyVQA+Rt7Y2Vz6zESwdfwq6bu+DazBX/9vu32GURERE9UY1DklqtxsWLF3HixAlERkZCpVIBABwdHdG/f3/07dsXlpaWmvGDBg3C2bNnsWTJEuzdu5chSU/0ceqD7/p+h/dOvof/XvovbE1s8YnDJ2KXRUREVCmdQ9KtW7dw8uRJhIaGIjs7GwBgZGSEPn36YMCAAfDy8qp02Z49e8Ld3R2JiYm6bp4aoYleE3E/5z4WX1iMT8M+RUu7lnjGjiGZiIgaJp1D0r///c/hkjZt2qB///7o1asXDA0Nq7S8kZER1Gqem6Jv5nSeg8zCTKy+uhrTdk/DqkGrMLjlYLHLIiIiqkDnkGRlZYV+/fqhf//+sLe3r/byCxYs0HXT1IhJJBIs6LkAD4se4s/YP/F/R/8PG4ZuQG/H3mKXRkREVI7OIWn58uWaK9eIqkMqkWJx38UokhZh17VdmBY8DX+O+BO+tr5il0ZERKShc8phQKKakEvl+OO5PxDgGIDc4lxMPjAZl9Mui10WERGRhs57kqKjo6s8ViqVwtjYGLa2tjAxMdF1k9TEGMmN8Nvg3/DiwRcRkRKBSQcm4Y/hf6CTbSexSyMiItI9JC1cuFCn5VxcXDBo0CAMHjwYEolE181TE2FmYIaNQzfipaCXGJSIiKhB0fmYWdu2bdGuXTvIZDIAgIGBAVxdXeHt7Q1XV1cYGBgAKH2+W9u2beHh4QETExPcuXMHv/32G77//nte3UYA/glKfi38kFWUhUkHJvHQGxERiU7nPUmfffYZ/vOf/8DQ0BBTpkxB7969oVAoNPNVKhVCQ0Oxfv16mJqa4rPPPoNEIsG5c+fw66+/4sKFCzh+/DgGDhxYK41Q42ZmYIYNQzfg5aCXEZ4SjkkHJmH90PXo1qKb2KUREZGe0nlP0p49e3D+/Hl8+OGHCAwMLBeQgNI9SP369cO//vUvnD9/Hrt27YJEIkHPnj3x1ltvAQBOnTpVs+qpSSkLSj3seyCrKAsvHHgBp+7ye4SIiMShc0g6efIkHB0d0aZNmyeOa9OmDRwdHcsFIl9fX1haWuL27du6bp6aqLJDb4HOgchX5WPKoSk4cOuA2GUREZEe0jkkpaamVvnu2oaGhkhPTy83rXnz5igqKtJ189SEmShMsGbwGoxwH4EidRFmHp2JLde3iF0WERHpGZ1DkpmZGe7cuYPMzMwnjsvMzMTt27dhampabrpSqawwjaiMgcwAKwaswCTvSVALarx36j38L+p/YpdFRER6ROeQ1LVrV6hUKixevLjCXqIy6enpWLx4MUpKStCt2z8n4Obk5ODBgwews7PTdfOkB2RSGb7v8z1mdpwJAPj83OeYf2Y+1AKviiQiorqn89VtL7zwAi5duoQbN27gnXfeQbt27dCyZUsYGRmhoKAAt2/fxl9//QWVSgUbGxtMnDhRs+yxY8cAlJ6bRPQkEokEn/b4FDbGNvgq/CusuroK93Pv47+B/4Wx3Fjs8oiIqAnTOSSZm5vjyy+/xMqVKxEZGYmoqChERUVVGNe5c2e8/vrrMDc310zr168fevXqBQsLC103T3pEIpFgdqfZcDR1xLsn38WBWweQmpeKNYPXwNrIWuzyiIioidI5JAGAtbU1/v3vf+P+/fuIiopCcnIyCgoKYGRkBAcHB/j4+MDBwaHCcgxHpIsxrceghWkLTA+ejvMp5zFq9yhsGLoB7hbuYpdGRERNkM4h6eTJkwAAf39/ODo6wtHRsdaKIqpML4de2DVqF14Kegm3sm9h5O6R+N/A/yHAKUDs0oiIqInR+cTt5cuXY/v27RVuIklU17ysvLB39F50tusMZaESkw9OxtrotWKXRURETYzOIcnc3JyX8JNoWpi0wLYR2zCu9TiUCCX4OPRjzAuZh2J1sdilERFRE6FzSGrTpg3u37/PG0KSaIzkRvhv4H/xUfePIIEE62PWY/KByXiQ/0Ds0oiIqAnQOSQ999xzUKlUWL9+fW3WQ1QtEokEb/i+gd8G/wZThSnCksIwZOcQRKZGil0aERE1cjqfuJ2Xl4exY8di+/btiIuLQ58+feDk5PTER5W0a9dO180RPdHgloOxb/Q+zDg8AzezbmLc3nH4wv8LvNjmRUgkErHLIyKiRkjnkLRw4ULN64SEBCQkJDxxvEQiwebNm3XdHNFTeVl5Yf+Y/Xjv5Hs4kHAAH4Z8iIupF/FV769440kiIqo2nUNS27Zt+Rc6NTjNDJph5TMrsSJqBb6J+AZbYrcgKj0Kvwz8Ba0tW4tdHhERNSI6h6QFCxbUYhlEtafsDt0+Nj6YfWw2YjJiMGznMHwb8C2e83xO7PKIiKiR0PnEbaKGLsApAIefOwx/B3/kqfLw9om38d7J95BXnCd2aURE1AjUWkhSq9XIzs5Genp6ba2SqMZamLTA5uGb8UHXDyCVSLEldguG7xqOvx78JXZpRETUwNXo2W0AcPHiRezfvx+xsbEoKiqqcIL2jh07cOfOHUybNq3cQ26J6otMKsO7Xd5FD/seePP4m4hTxmHkrpH4sPuHeL3j65BKuEOViIgqqtFvh40bN2LRokW4evUq1Go15HI5BEEoN8bS0hJhYWEIDw+vUaFENeXv6I/D4w5jcMvBKFIX4YtzX+CFAy/gfs59sUsjIqIGSOeQdPbsWezduxfW1tb48MMPsWHDBrRq1arCOD8/PwDA+fPnda+SqJY0N26O3wb9hu/6fAdjuTFC74di0I5B2HNzj9ilERFRA6NzSDp06BAA4N1330WXLl0glWpflZmZGezs7JCUlKTrpohqlUQiwYttXsShsYfQyaYTlIVKzDo2C/939P+QUZAhdnlERNRA6BySEhISYGNjAy8vr6eONTc3R0YGf/lQw9LKshV2j96NOZ3nQCaRYW/8XvTf1h9BCUFil0ZERA2AziGpuLgYJiYmVRpbVFRU6Z4mIjEppAr8q9u/sG/0PnhbeSM9Px3TD0/HW8ffQmZBptjlERGRiHS+uq158+ZITk6GSqWCXF75avLy8nDv3j24uLjouikcOnQIe/bsgVKphLOzM6ZOnYq2bdtqHZuZmYn169cjPj4eycnJGDZsGKZOnVpuzIkTJ7B8+fIKy27cuBEGBgY610mNl4+tDw6OPYgfLvyA5VHLsePGDpy6dwpf9PoCz3o8y7vLExHpIZ1373Tq1AlFRUXYv3//E8dt27YNJSUl6NKli07bCQsLw9q1azFu3DgsWrQIbdu2xddff13p/ZiKi4thbm6OcePGoWXLlpWu19jYGCtXriz3wYCk3wxlhpjnNw+7R+2Gl6UX0vPTMevYLEwLnsYr4IiI9JDOIWnMmDEwNjbGH3/8gQ0bNuDevXuaeWq1GomJiVi+fDn2798Pc3NzDB8+XKft7Nu3DwMGDMDAgQM1e5FsbGwQHBysdbydnR2mTZuGfv36PfFwoEQigaWlZbkPIgDoYtcFQeOC8F6X96CQKnD49mH039Yf66LXQS2oxS6PiIjqic6H26ytrTF37lwsXrwY+/btw759+zTzJk2apHltZmaGDz74AM2aNav2NlQqFeLj4zFmzJhy0318fHD9+nVdSwcAFBQUYPbs2VCr1XBzc8PEiRPh7u5e6fji4mIUFxdr3kskEhgbG2te66psWX07nNPQ+zaSG+GDbh/gWY9n8f6p93Ex9SI+Cv0I2+K24duAb9HBpkO119nQe64L+tgzoJ99s2f9oU991+iO2+3atcN//vMf7N27F+Hh4UhLS9PMs7Kygp+fH8aMGQNra2ud1p+dnQ21Wg0LC4ty0y0sLKBUKnWu29HREbNnz4arqyvy8/Nx4MABfPrpp/j+++/h4OCgdZmdO3di27Ztmvfu7u5YtGgRbG1tda7jUfb29rWynsamofft4OCA8LbhWBaxDJ8c+wQXUy9i6M6heKfHO1gYuBDNDKsf/ht6z3VBH3sG9LNv9qw/9KHvGj+WxMrKCq+88gpeeeUVFBQUIC8vD0ZGRlW+8q0qtKXVmiRYLy+vcrcu8Pb2xocffoiDBw/i1Vdf1brM2LFjMXLkyArbT0tLg0ql0rkWiUQCe3t7JCcnV7hbeVPW2Pp+3vV5BDwfgAVnFmBv/F4sObsEm69sxoJeCzDSfWSVvh8bW8+1QR97BvSzb/asHz0Djb9vuVxe5R0cNQ5JjzIyMoKRkVGtrc/c3BxSqbTCXqOsrKwKe5dqQiqVolWrVkhOTq50jEKhgEKh0DqvNr5JBEFolN9sNdWY+rY3sccvA3/BRK+J+Dj0YyQ+TMTMIzPh7+CPL/2/hLe1d5XW05h6ri362DOgn32zZ/2hD3036JsXyeVyeHh4ICoqqtz0qKgoeHtX7RdSVQiCgMTERJ68TVXS36U/jo4/ive6vAcjmRHCksIwaMcgzD8zH9lF2WKXR0REtaTGe5IuX76MyMhIpKamoqCgoNJUKZFI8Nlnn1V7/SNHjsRPP/0EDw8PeHl54ciRI0hPT8egQYMAAJs2bUJGRgbefPNNzTIJCQkASk/Ozs7ORkJCAuRyOZydnQEAW7duhaenJxwcHDTnJCUkJGD69OnVro/0k7HcGO93fR/Pez6PhWcXIigxCKuursKum7swt9tcvOD1AmRSmdhlEhFRDegckgoLC7F48eIKe3lqm7+/Px4+fIjt27cjMzMTLi4umDdvnuZ4YmZmZoV7Js2dO1fzOj4+HiEhIbC1tcWyZcsAALm5uVi5ciWUSiVMTEzg7u6OhQsXonXr1nXaCzU9ruauWD14NU7cOYFPz3yK+Kx4zD09F2v+WoMFPRcgwClA7BKJiEhHEkHHA4rr16/H/v37YWxsjAEDBqB169aac4gq065dO50LbajS0tLK3RqguiQSCRwcHJCUlNTkj+0+qin2XVRShHXR67Dk4hJkFWUBAAa3HIxP/D5BK8tWTbLnp9HHngH97Js960fPQOPvW6FQ1P2J22fOnIFUKsUnn3zCPTBEAAxkBnit42t4zvM5/HDhB6yPWY/gxGAcu30ML7V9Ce91fQ8O0H6LCSIianh0PnE7Ozsb9vb2DEhEj7E2ssaXvb/EkeeOYIDLAKgEFdZGr0Wvzb3wxckvkFecJ3aJRERUBTqHpObNm0Mm44mpRJXxsvLChqEb8OeIP+Fj44Pc4lx8duIz9N7SG+uj16NYrfthWiIiqns6h6SAgADcvXv3ifcWIiKgt2Nv7B+zH8sHLIe7pTtS8lIwL3QeArcGYueNnXweHBFRA6VzSBo3bhzatGmD77//Hrdu3arNmoiaHKlEijGtxyDmjRh84f8FbIxtkJCdgDePv4nBOwYjODG4UZ4ASUTUlOl84vbKlSvRvHlzxMbGYt68eXBzc0OLFi1gaGiodbxEIsGsWbN0LpSoKTCUG2J6h+mY6DURq66uwi9RvyAmIwbTgqfB19YXH3T9AIHOgXrx4EgiooZO55B08uTJcu9v3br11D1KDElEpUwVpnin8zt4pe0rWBG1Ar/99RsupV3CS0EvoatdV3zQ7QP0cezDsEREJCKdQxIDD1HNWRlZ4SO/j/B6x9ex/PJyrItehwupFzDpwCR0b9Ed73Z5F32d+jIsERGJQOeQFBgYWItlEOk3G2MbfNbzM8z0mYlll5dhY8xGRKREYPLByehs2xlzuszBQJeBDEtERPWoQT/glkjftDBpgc97fY6wiWGY0WEGjGRGiEyLxJRDUzBs1zDsv7WfV8MREdWTeglJKSkpSExMrI9NETUJ9qb2WNhrIc6+cBazfGbBWG6MK+lX8PqR19F/W39sid3C+ywREdWxKoekiRMnYv78+VrnLV68GJs3b6502WXLluHDDz+sfnVEes7WxBaf9PgE4ZPC8U7nd2BhYIEbyht47+R76L2lN1ZfXc07eBMR1ZFa2ZMUERGBmJiYJ47hPWCIdGdtZI253ebi3KRz+NjvY9ga2+Jezj18duYzdP+jO74//z3S89PFLpOIqEnhOUlEjUgzg2aY3Wk2zr5wFt/0/gZu5m5QFiqxNHIpevzRA/8O+TduKm+KXSYRUZPAkETUCBnJjfBKu1dw6vlTWPnMSvja+qKgpAAbYjag39Z+mBY8DWeSznAPLhFRDTAkETViMqkMI9xHYN/ofdg2chuecX0GAgQEJwZj/L7xGLZrGLbHbUdRSZHYpRIRNToMSURNgEQiQS+HXlg3ZB1OPn8SL7d9GUYyI1xJv4K3T7yNHn/0wJKLS5CWlyZ2qUREjQZDElET09qyNb4N+BYRkyMwt9tc2JvYIzU/FYsvLIbfH36Yc2IOotKixC6TiKjBY0giaqKsjazxTud3cOaFM1jWfxm62HVBkboIW+O2YtiuYRi5eyS2xW1DYUmh2KUSETVI1XosybVr1zBx4sRqzyMi8RjIDDCm9RiMaT0GkamR+O2v37A3fi8iUyMRmRqJz89+jkltJuGlNi/BpZmL2OUSETUY3JNEpEc623XGT/1/QsSk0kNxDqYOeFDwAD9f+hm9NvfCK0Gv4HDiYZSoS8QulYhIdFXek1TZ3baJqPGxNbHFO53fwRud3kBwYjDWx6zH6XuncfTOURy9cxROZk6Y7D0ZE70nwsHUQexyiYhEUeWQ1K5du7qsg4hEIJfKMdx9OIa7D8dN5U38fu13bIndgns59/D9he/xn4v/wUCXgXixzYvo79Ifcmm1jtATETVqPNxGRACAVpat8FnPz3Bh8gX8GPgjetj3gFpQ4/Dtw5gaPBU9N/fEd+e/w+3s22KXSkRULxiSiKgcI7kRxnuOx45nd+DE+BN4vePrsDK0QlJuEn6M/BG9tvTChP0TsPPGTuSr8sUul4iozjAkEVGlPK08Mb/nfFx48QKWD1iOvk59IYEEofdD8ebxN9H19674d8i/cTH1Ih+BQkRNDk8wIKKnMpQZYnSr0RjdajTuPLyDP2P/1Jy7tCFmAzbEbICnpScmeE3AuNbjYG9qL3bJREQ1xj1JRFQtLs1c8H7X93H2hbPYPHwzxrUeByOZEeKUcfgq/Ct0/6M7Jh+YjB03diCvOE/scomIdMY9SUSkE6lEij5OfdDHqQ++7v019sXvw5bYLYhIicDJeydx8t5JmCpMMb7deAxzGgZ/B3/IpDKxyyYiqjKGJCKqsWYGzTCpzSRMajMJCdkJ2BG3A9vitiHxYSLWXV6HdZfXoYVJC4xuNRrPtX4O7Zu3h0QiEbtsIqIn4uE2IqpVbuZueK/rewidGIqdo3ZiZteZsDS0REpeClZeWYkhO4eg/7b+WHJxCW5l3RK7XCKiSjEkEVGdkEgk6GHfA7+M/AWRL0Xit0G/YYT7CBjKDBGnjMPiC4sR8GcAhu8cjpVXViIpN0nskomIyqnx4bb79+/j0qVLSElJQUFBQaWXAUskEsyaNaummyOiRshQZoghbkMwxG0IsouyEZQQhF03diHkfggup1/G5fTL+Pzs5/Cz98Moj1EY4T4Ctia2YpdNRHpO55CkVquxatUqHD16tMrLMCQRkbmBOSZ4TcAErwlIz0/Hvvh92HVzFyJSInAu+RzOJZ/Dp2c+RS+HXnjW41kMcxsGG2MbscsmIj2kc0jauXMnjh49CqlUim7duqFVq1awsLDgyZhEVGU2xjaY2n4qprafins597Avfh/2xu9FZFokQu+HIvR+KD4K/Qi9HHphpPtIDHMbxj1MRFRvdA5JJ0+eBAD861//QpcuXWqtICLST05mTpjpMxMzfWbidvZt7Lu1D/vi9+Fy+mVNYPo47GP0sO+B4W7DMcx9GBxMHcQum4iaMJ1D0oMHD2BnZ8eARES1ztXcFbM7zcbsTrORmJ2I/bf2awLTmaQzOJN0Bp+e+RRd7bpimNswDHUbCncLd7HLJqImRueQZGFhARMTk9qshYiogpbmLTWB6e7DuziQcAAHbh3A+ZTzuJB6ARdSL+DL8C/R1rothroNxVC3oWhvzfswEVHN6RyS/Pz8EBwcDKVSCUtLy1osiYhIO+dmzni94+t4vePrSM5NxqHEQziYcBBh98MQkxGDmIwYLLm4BM5mzhjiNgRDWw6Fn70f5FLeN5eIqk/n+yRNmDAB9vb2+PHHH5GZmVmbNRERPZW9qT2mtJuCzcM34/JLl7G031IMaTkERjIj3M25i9VXV+P5/c+j08ZOePv429gXvw85RTlil01EjYjOf14dOHAAnTp1wqFDh/D222/D19cXLVq0gJGRUaXLjB8/XtfNERFVysrICs97PY/nvZ5Hviofp+6eQlBiEA4nHkZmYSa239iO7Te2w0BqAH9HfwxqOQiDXAfBycxJ7NKJqAHTOSRt3bpV87qkpATh4eFPXYYhiYjqmrHcWHPjSpVahfMp53H49mEcSjiEW9m3cOLuCZy4ewIfh36MttZt8YzrM3jG9Rl0tu3MB/ASUTk6hyQGHiJq6ORSOXo69ERPh574tMenuKG8geDEYBy5fQQRKRGa85h+uvQTrI2s0d+5Pwa6DkQ/536wNLQUu3wiEpnOIen555+vzTqIiOpca8vWaG3ZGrM7zUZGQQZO3D2BI7eP4Pid48goyNAclpNJZOjWohsGuAxAf5f+aGfdjlfLEekhXvJBRHrJ2sga41qPw7jW41CsLsb5lPM4evsojt4+ilhlrOYRKd9EfAN7E3sEOgdigOsABDgGwMLQQuzyiage1FpIKioqQnJyMgoKCmBkZAR7e3sYGBjU1uqJiOqMQqpAL4de6OXQC5/0+AR3Ht7BsTvHcOzOMYTeD0VyXjI2x27G5tjNkElk6GrXFYEugejv3B8dbDpAKtH5QmEiasBqHJIuXbqEXbt24fr161Cr1ZrpUqkUbdq0wZgxY9CpU6eaboaIqN64NHPBlHZTMKXdFBSoCnAu+RyO3TmGE3dP4IbyBsJTwhGeEo7vzn8HayNr9HXqi37O/dDXqS/sTe3FLp+IakmNQtKff/6J7du3/7MyuRzm5ubIzs6GSqVCdHQ0oqOj8dxzz2HChAk1LpaIqL4ZyY3Qz7kf+jn3AwDceXin9Aq5Oydw+v5pZBRkYNfNXdh1cxcAoI1VG/Rz7ocxPmPgaegJY5mxeMUTUY3oHJIuXbqE7du3QyqV4plnnsHw4cPh4PDPwyaTkpJw4MABHDlyBNu3b4eXlxd8fX1ro2YiItG4NHPBy21fxsttX0axuhgXUi7g5N2TOHn3JKLSo3At8xquZV7D/678DwZSA3S3746+Tn3Rx6kPOjTvwNsMEDUiOoekgwcPAgBmzZqFvn37Vpjv4OCA6dOnw9PTE8uWLcPBgwcZkoioSVFIFZpbDHzY/UNkFGTg9L3TOH3vNEKSQnAn+w5C74ci9H4ovon4BpaGlvB38EeAUwACHAPgYeHBq+aIGjCdQ9KNGzfQvHlzrQHpUX379sXmzZtx48YNXTdFRNQoWBtZY3Sr0RjTegzs7e0Rci0Ep+6eQsi9EITeD4WyUFn6gN6EAwAAB1MH9HbsjQDHAAQ4BcDB1OEpWyCi+qRzSCooKICdnV2VxlpYWOD27du6boqIqNGRSCRobdkarSxaYVr7aVCpVYhKj9LsabqQcgFJuUnYFrcN2+K2AQA8LDzg7+CP3o694e/oDxtjG5G7INJvOockKysr3L9/X3PJf2UKCgpw7949WFlZ6bopIqJGTy6Vo4tdF3Sx64J3Or+DfFU+IpIjEHI/BCH3QnDlwRXEZ8UjPiseG69tBAB4W3nD38EfvRxLb09gbWQtchdE+kXnkNSpUyccOXIE//vf//DGG29ALq+4KpVKhV9++QWFhYU8H4mI6BHGcmP0de6Lvs6lpyxkFWbhXPI5zTlMMRkxuJ55Hdczr2NN9BoApVfO9XLopTkPinuaiOqWziFp7NixCAsLQ1hYGKKjozFw4EA4OztrbgFw9+5dHD16FEqlEiYmJhgzZkwtlk1E1LRYGFpgcMvBGNxyMAAgoyADZ5POIux+GM4kndFcNXct85omNHlaeqKnQ0/0cuiFHvY9eI8molqmc0iysbHBRx99hCVLluDBgwfl7pf0+Lh3330XNjb8i4eIqKqsjawx3H04hrsPBwA8yH+As8lncTbpLM4knUFMRgzilHGIU8ZhQ8wGAICbuRt62veEn4Mfetj3QMtmLXn1HFEN1Ohmkp6enli6dClCQkJw+fJlJCUlac5RcnBwQKdOnRAQEMDHkxAR1VBz4+YY4T4CI9xHACjd03Qu6RzOJp/FueRz+OvBX0jITkBCdgI2x24GANib2MPPvjQwdbfvjjZWbXifJqJqqPFjSQwMDDBgwAAMGDCgNuohIqIqsDayxjD3YRjmPgwAkF2UjYjkCM2DeS+nXUZyXjL2xO/Bnvg9AABzA3N0a9EN3Vt0R3f77vC19YWxnHcEJ6pMrT3gloiIxGNuYI6BrgMx0HUgACBflY/I1EicSz6HiOQInE89j+yibM2De4HSm2F2sOlQGpr+/rA1sRWzDaIGhSGJiKgJMpYbw9/RH/6O/gAAlVqFmIwYhCeH41zyOZxPOY+UvBREpkYiMjUSK6+sBAC0bNYS3Vp0Q7cW3dC1RVceoiO9VqWQtHDhQgCAra0tZs+eXW5aVUkkEnz22WfVLI+IiGqDXCpHR5uO6GjTEdM7TIcgCLjz8A4iUiIQnhyOC6kXcC3jGhIfJiLxYSK23yi9GMdMYQZfW19NaOpi1wWWhpbiNkNUT6oUkqKjowEAjo6OFaYREVHjI5FI4GruCldzVzzn+RyA0vOaIlMjcT7lPCJSIhCZGomc4pzSG17eD9Es29qyNbrYdUFXu67o2qIrvCy9IJfxwAQ1PVX6rp4/fz4AlLtKrWwaERE1DeYG5ujn3A/9nPsBAErUJbieeR3nU87jQuoFnE85j4TsBNxQ3sAN5Q38GfsnAMBUYQpfW1/09egLTxNPdLbtDDuTqj22iqghq1JIateuXZWm1ZVDhw5hz549UCqVcHZ2xtSpU9G2bVutYzMzM7F+/XrEx8cjOTkZw4YNw9SpUyuMO3v2LLZs2YKUlBS0aNECkyZNgp+fXx13QkTUeMikMrRr3g7tmrfDK+1eAVB664GLqRdxIeUCLqRewOW0y8gpztHcKbyMk5kTOtt2Rme7zuhs2xk+tj68ko4aHZ33j6anp0OhUMDCwuKpY7OyslBcXKzTDSXDwsKwdu1azJgxA97e3jhy5Ai+/vprLFmyROv6iouLYW5ujnHjxmH//v1a1xkbG4ulS5di4sSJ8PPzQ3h4OJYsWYLPP/8cnp6e1a6RiEhfWBtZ4xnXZ/CM6zMASvc2xSnjEJkWiWsPryEkIQTXM6/jXs493Mu5h3239gEAZBIZvK280dmuM3xtfeFr6wsvKy/IpTxMRw2Xzt+db7zxBtq0aVOlE7iXLl2KmJgYbN68udrb2bdvHwYMGICBA0sva506dSouX76M4OBgTJ48ucJ4Ozs7TJs2DQBw/Phxrevcv38/fHx8MHbsWAClj1iJjo7G/v37MWfOnGrXSESkr2RSGdpYt0Hb5m3h4OCApKQkPCx8iMvplzVXzkWmRSIlLwXRGdGIzojG79d+B1B6BV6H5h3ga+sLH1sftLJoBXcLd5gbmIvcFVGpeovwgiBUexmVSoX4+PgKz33z8fHB9evXda4lNjYWI0aMKDetU6dOOHDgQKXLFBcXo7i4WPNeIpHA2NhY81pXZcvq26MD9LFv9qw/9LHvR3tuZtgMAU4BCHAK0MxPyk3CpdRLiEwrDU5lh+kiUiIQkRJRbl3NjZrDzcINVoZW9dpDdUkggaGRIQoLCiGg+r/jGqv67Lu1ZWt81lO8K+PrJSTl5eVBoVBUe7ns7Gyo1eoKh/QsLCygVCp1rkepVMLS0rLcNEtLyyeuc+fOndi2bZvmvbu7OxYtWgRb29q58Zq9vX4+mFIf+2bP+kMf+66sZwc4oEvrLpr3akGN2AexCL8Xjoh7EbicchlxGXFIzknGg4IHeFDwoL5KpgYsV50LBwcH0bZfpyGpuLgY0dHRuH37do1+WGj7a6y2/0ITBOGJ6xw7dixGjhxZYftpaWlQqVQ6b1cikcDe3h7Jyck67W1rrPSxb/asHz0D+tm3Lj1bwAKD7AZhkN0gzbScohzEZ8fjVtYt5Bbn1lW5tUIikcDC3AJZ2Vl683UG6rdvG2MbJCUl1eo65XJ5lXdwVDkkbd26tdyeFAC4du0aJk6cWKXle/fuXdVNaZibm0MqlVbYw5OVlVWlE8Yro22v0dPWqVAoKt0bVhvfJIIg6NV/sjL62Dd71h/62HdNezZVmKJj847o2LxjLVZVNyQSieY8LH36Otd332L+20qrOlCXIg0MDODs7IwJEyZoTpKuDrlcDg8PD0RFRZWbHhUVBW9v72qvr4yXlxeuXLlSYZ1eXl46r5OIiIialirvSZowYQImTJigeT9x4sQqX91WEyNHjsRPP/0EDw8PeHl54ciRI0hPT8egQaW7Zzdt2oSMjAy8+eabmmUSEhIAAAUFBcjOzkZCQgLkcjmcnZ0BAMOHD8f8+fOxa9cudO/eHREREbhy5Qo+//zzOu2FiIiIGg+dz0kaP368Tvc9qi5/f388fPgQ27dvR2ZmJlxcXDBv3jzN8cTMzEykp6eXW2bu3Lma1/Hx8QgJCYGtrS2WLVsGAPD29sacOXOwefNmbNmyBfb29pgzZw7vkUREREQaEkGfDqTWgbS0tHK3BqguHtPWn77Zs370DOhn3+xZP3oGGn/fCoWiyiduV/mcJCIiIiJ9UuNbAMTExOD06dNITExETk4OSkpKtI6TSCT46aefaro5IiIionpRo5C0atUqHD58uLZqISIiImowdA5Jp06dwuHDh+Hs7Ixp06bh999/R3x8PH788Uc8ePAAiYmJ2L9/P7KzszFlyhR06tSpNusmIiIiqlM6n5N07NgxAMA777yDDh06aG60aG9vj/bt22P48OH473//i86dO2PNmjXIzs6unYqJiIiI6oHOISkxMRE2NjZwdXUF8M9jOh49010mk+H//u//IJVKsWPHjhqWSkRERFR/dA5JRUVF5R7jYWBgAADIzS3/rB0TExM4OzsjNjZW100RERER1TudQ5KlpWW5QGRpaQkAuHv3boWx2dnZyMvL03VTRERERPVO55Dk6OiIjIwMzeG1Nm3aAAB2794NlUqlGXfq1Cmkp6ejRYsWNSyViIiIqP7ofHVbly5dEBUVhZiYGLRr1w69e/fGn3/+iYsXL2LOnDnw8PBAVlYWrl27BgCaZ60RERERNQY6h6RevXohPz8fMpkMAGBkZIR///vfWLJkCVJSUpCWlgYAkEqlGDFiBIYNG1Y7FRMRERHVA51DkqWlJcaNG1dumru7O5YuXYobN24gLS0NBgYG8PT01JyvRERERNRY1PixJI+TSqXw8vKCl5dXba+aiIiIqN7ofOJ2UFAQsrKyarMWIiIiogZD5z1Ja9aswbp169ChQwf07t0bPXr0gLGxcW3WRkRERCQanUNS9+7dcenSJURFRSEqKgqrVq1C586dERAQgC5dumgeU0JERETUGOkckj744APk5+fj3LlzCA0NxdWrVxEeHo7w8HAYGxvDz88P/v7+8PHxgVSq81E9IiIiIlHU6MRtY2NjBAYGIjAwENnZ2Thz5gxCQ0Nx/fp1nDx5EidPnoS5uTl69eqF3r17w9vbu7bqJiIiIqpTtXZ1m7m5OYYMGYIhQ4bgwYMHCAkJQVhYGBISEnDo0CEEBwdj8+bNtbU5IiIiojpVJ8fBmjdvjtGjR+O1116Dr68vAGgeX0JERETUGNT6fZLu3buH0NBQhIaGIjk5WTPd2dm5tjdFREREVGdqJSSlp6drglFiYqJmuo2NDfz9/REQEICWLVvWxqaIiIiI6oXOISk7OxthYWEIDQ1FbGysZnqzZs3Qs2dPBAQEoE2bNrVSJBEREVF90zkkzZw5E2q1GkDpw227deuGgIAAdOrUiZf8ExERUaOnc0iSSCTo2rUrAgIC0K1bNxgYGNRmXURERESi0jkk/frrrzA1Na3NWoiIiIgaDJ2PizEgERERUVPGk4eIiIiItKjS4baJEycCAJycnPDDDz+Um1ZVEomEd9wmIiKiRqNae5Jqctds3nGbiIiIGpMq7UnasmVLlaYRERERNRU8J4mIiIhIC51D0smTJ3Hp0qUqjb18+TJOnjyp66aIiIiI6p3OIWn58uXYuXNnlcbu2rULy5cv13VTRERERPWuXg638aRtIiIiamzqJSQplUoYGRnVx6aIiIiIakWVH0uSnp6O1NTUctPy8vIQHR1d6TJFRUWIjo5GUlISWrdurXuVRERERPWsyiHp+PHj2LZtW7lpt2/fxsKFC6u0/IgRI6pXGREREZGIqhySbG1t0a5dO8376OhomJiYwM3NrdJlDAwM0KJFC/j7+6NNmzY1KpSIiIioPlU5JAUGBiIwMFDzfuLEiXB1dcX8+fProi4iIiIiUVU5JD1u/vz5MDExqc1aiIiIiBoMnUPSo4feiIiIiJoanW8BEB0djYULF+Lw4cNPHBccHIyFCxfi2rVrum6KiIiIqN7pHJKOHTuG6OhoeHl5PXGcl5cXoqOjcfz4cV03RURERFTvdA5JcXFxMDMzQ8uWLZ84zs3NDWZmZrh+/bqumyIiIiKqdzqHpIyMDNjZ2VVprJ2dHTIyMnTdFBEREVG90zkkyeVy5OfnV2lsfn4+JBKJrpsiIiIiqnc6hyRHR0ckJSXh/v37Txx3//59JCUlwdHRUddNEREREdU7nUNSjx49AADLli1Dbm6u1jG5ublYtmwZAKBnz566boqIiIio3ul8n6ShQ4fi+PHjuHHjBt59910MGDAArVu3hqmpKXJzcxEXF4fjx48jKysLjo6OGDZsWG3WTURERFSndA5JBgYG+Pjjj7F48WLcunULO3fu1DrOw8MD77//PgwMDHQukoiIiKi+6RySAMDGxgZff/01wsPDERERgXv37iE/Px9GRkZwcXFB9+7d0b17d0ilOh/VIyIiIhJFjUISAEilUvTs2ZPnHBEREVGTUue7eDIyMrB792588MEHdb0pIiIiolpT4z1J2hQUFODs2bM4ffo0/vrrLwiCUBebISIiIqoztRaS1Go1oqKicOrUKURERKCoqEgzz83NDX369KmtTRERERHVuRqHpFu3buHUqVMIDQ1FVlbWPyuWyzFy5Ej06dMHzs7ONd0MERERUb3SKSQ9ePAAp0+fxunTp3H37l3NdFNTU/Ts2RNHjx6FmZkZJk2aVGuFEhEREdWnKoeksvOMTp06hejoaM15RgYGBujSpQv69OkDX19fyOVyHD16tM4KJiIiIqoPVQ5Jr732muY8I6lUio4dOyIgIAA9evSAkZFRnRVIREREJIYqh6SygGRqaopXX30VvXv3hkQiqbPCiIiIiMRU5fsklZ18nZubi59++gmzZs3C+vXrER8fX2fFEREREYmlynuS/vOf/yAhIUFzJVtmZib279+P/fv3w97eHn369EFAQADs7e3rsl4iIiKielGtq9vc3Nzg5uaGl156CVeuXMHJkycRERGB5ORkbN26FVu3boWHh0etF3no0CHs2bMHSqUSzs7OmDp1Ktq2bVvp+OjoaKxbtw53796FlZUVRo0ahcGDB2vmnzhxAsuXL6+w3MaNG/kgXiIiIgKg4y0ApFIpOnXqhE6dOlW4u3bZ4besrCx8/vnn6Nu3L3r06AFjY2OdCgwLC8PatWsxY8YMeHt748iRI/j666+xZMkS2NjYVBifmpqKb775BgMHDsRbb72F69evY9WqVTA3Ny/3fDljY2P8+OOP5ZZlQCIiIqIyNb6ZpJGREQIDAxEYGIiMjAzN/ZPu3LmDv/76C3/99RdWr16Nrl27Ys6cOdVe/759+zBgwAAMHDgQADB16lRcvnwZwcHBmDx5coXxwcHBsLGxwdSpUwGUnkt18+ZN7N27t1xIkkgksLS01KVlIiIi0gO1+uw2a2trjB49GqNHj0ZCQgJOnjyJsLAwKJVKnDlzptohSaVSIT4+HmPGjCk33cfHB9evX9e6TFxcHHx8fMpN8/X1xfHjx6FSqSCXl7ZcUFCA2bNnQ61Ww83NDRMnToS7u3ultRQXF6O4uFjzXiKRaPaO1eQqv7Jl9e1KQX3smz3rD33smz3rD33qu04ecAv8c/7Syy+/rHmmW3VlZ2dDrVbDwsKi3HQLCwsolUqtyyiVSq3jS0pK8PDhQ1hZWcHR0RGzZ8+Gq6sr8vPzceDAAXz66af4/vvv4eDgoHW9O3fuxLZt2zTv3d3dsWjRItja2la7L2309YR3feybPesPfeybPesPfei7zkJSGalUCl9fX/j6+uq8Dm1p9UkJ9vF5ZXcHL5vu5eUFLy8vzXxvb298+OGHOHjwIF599VWt6xw7dixGjhxZYRtpaWlQqVRV7ER7rfb29khOTtbUqQ/0sW/2rB89A/rZN3vWj56Bxt+3XC6v8g6OOg9JNWFubg6pVFphr1FWVlaFvUVlLC0tK4zPzs6GTCaDmZmZ1mWkUilatWqF5OTkSmtRKBRQKBRa59XGN4kgCI3ym62m9LFv9qw/9LFv9qw/9KHvKt9MUgxyuRweHh6IiooqNz0qKgre3t5al/H09Kww/vLly/Dw8NCcj/Q4QRCQmJjIE7mJiIhIo0GHJAAYOXIkjh49imPHjuHu3btYu3Yt0tPTMWjQIADApk2b8PPPP2vGDx48GOnp6Zr7JB07dgzHjh3Ds88+qxmzdetWXLp0CSkpKUhISMCKFSuQkJBQ7l5KREREpN8a9OE2APD398fDhw+xfft2ZGZmwsXFBfPmzdMcT8zMzER6erpmvJ2dHebNm4d169bh0KFDsLKywrRp08pd/p+bm4uVK1dCqVTCxMQE7u7uWLhwIVq3bl3v/REREVHDJBGa+gHFOpaWllbu1gDVJZFI4ODggKSkpCZ/bPdR+tg3e9aPngH97Js960fPQOPvW6FQVPnE7QZ/uI2IiIhIDAxJRERERFowJBERERFpwZBEREREpAVDEhEREZEWDElEREREWjAkEREREWnBkERERESkBUMSERERkRYMSURERERaMCQRERERacGQRERERKQFQxIRERGRFgxJRERERFowJBERERFpwZBEREREpAVDEhEREZEWDElEREREWjAkEREREWnBkERERESkBUMSERERkRYMSQ1VYaHYFRAREek1hqQGxiA8HDbDh8PqjTfELoWIiEivycUugMpTm5nB4PJlCDExkCiVECwtxS6JiIhIL3FPUgOjatcOxW3aQFJUBOMDB8Quh4iISG8xJDVA+WPHAgCMd+wQuRIiIiL9xZDUAOWPGQMAMDh7FtJ798QthoiISE8xJDVAJc7OKOzRAxJBgMnu3WKXQ0REpJcYkhooHnIjIiISF0NSA5U/ciQEhQKKmBjIr10TuxwiIiK9w5DUQAlWVijo3x8AYLxzp8jVEBER6R+GpAZMc8ht505ArRa5GiIiIv3CkNSAFQwaBLWZGeT37sEgIkLscoiIiPQKQ1JDZmyMgmHDSl/yBG4iIqJ6xZDUwOWPGwcAMN63DygqErkaIiIi/cGQ1MAV9u6NEjs7SJVKGAUFiV0OERGR3mBIauhkMuRNmAAAsJw3D7Lbt0UuiIiISD8wJDUCD999F0W+vpAqlbB+9VVI8vLELomIiKjJY0hqDIyMkPHrryixsYEiJgaW778PCILYVRERETVpDEmNhNrREZm//gpBLofxnj0wW7FC7JKIiIiaNIakRqTIzw9Zn38OAGj2zTcwPHFC3IKIiIiaMIakRibvlVeQO3kyJGo1rF5/HUa7d4tdEhERUZPEkNTYSCTI+vJLFAYEQJqbC+vZs2Exdy6Qny92ZURERE0KQ1JjZGiIB7//jodvvw1BIoHp77/D9tlnIY+LE7syIiKiJoMhqbGSy/Hwww+RsWmT5qo3m2HDYPrLL5BwrxIREVGNMSQ1coV9+yLt8GEU9u4NaX4+LL74Anb+/jBdtYqH4IiIiGqAIakJUNvZ4cEff0C5eDFULi6QpabCYv58tAgIgOnq1ZBkZYldIhERUaPDkNRUyGTImzQJqadOQbloEVSOjpAlJ8Pis89g37kzLGfPLr1lQEmJ2JUSERE1CgxJTY2BAfJeegmpISFQfv01itu0gaSwECa7d6P5iy+ihZ8fzD/7DIanTgGFhWJXS0RE1GDJxS6A6oihIfKmTEHeK69AcfUqjP/8EyY7dkCWnAyz1athtno11CYmKOzTB4X9+6OwVy+UtGoFSCRiV05ERNQgMCQ1dRIJijt2RHHHjsj+5BMYHT8OwyNHYHTsGGQpKTA+dAjGhw4BAEqsrVHk54ei7t1R1LUrVO3bQzAxEbkBIiIicTAk6RNDQxQMHYqCoUORpVZD8ddfMDx6FIanTsHg0iXIMjJgHBQE46AgAIAglULVqlVpyGrfHqq2bVHs6Qm1gwP3OBERUZPHkKSvpFLNHqacOXOAwkIorlyBQUQEDMLDYXD5MmQpKVDExUERFwfs2KFZVG1mBpWnZ+mHmxtUbm4o8fCAqmVLCObm4vVERERUixiSqJShIYq7dUNxt27InTULACBNSYHi6lXNhzw2FvJbtyDNyYFBZCQMIiMrrEZtaQmViwtKnJ3/+XB0RImDA0ocHKC2tQVksvrujoiIqNoYkqhS6hYtUNiiBQoHDvxnYlER5LduQR4XV/qRmAhZQgLkCQmQpaVBqlTCQKkErlzRuk5BJoPa1hYlLVoALi6wsLBAia0tSmxtobaxgdrGBiV/fxbMzQEpL8AkIiJxMCRR9RgYQOXtDZW3d4VZkpwcyO7cKf24dw/yO3cgu3sXsuRkSJOSIEtJgaSkBLLkZMiSk4HLl/Gk08IFmQxqKyuora1LP6ysoLa0hNrKCoKlZelrCwuoLSxK31tYQG1uDqFZM+6tIiKiGmNIolojmJlB1bYtVG3bah9QUgJpWhpkKSmQpabCurAQD2NjIU1JgfTBA0jT0yFLTy99nZ1dGqj+nlZdajOz0sBkbg51s2YQmjWDYGZW+trMDGozMwimphCaNYPa1BTC3+/VZmYQTExK55maQjA2ZuAiItJTDElUf2QyqO3toba3h0oiARwckJOUBEEQKo4tLIQ0MxPSjIzSjwcPIFUqS6c98lmSlQVpdjakWVmQKJWQFhQAAKQ5OZDm5AD379e4bLWRUWlwevTD2Lj049HXj34YGf3z+e8PGBsDzs6Q5+RAbWgIlM0zNCydL+d/RyKihoQ/lalhMjTUBKpqKSqC9OHD0vBU9jknB5KHD0s/Z2eXfv77Q5qTA0luruZD+shriVoNAKXBq6AAyMioldZsK5kuyGSlgcnQEPg7OAmGhhAMDErfl30YGAAGBhAMDLS+17xWKEqXe/S1QlH6+tExj36Wy8tPUyh4XhgR6S2GJGpaDAygbt4caN4cNXpKnSCU7s3Ky4MkL680NJW9LvvIz4ckPx/Svz9L8vNLpxcUQJKfDxQUQPr3Z8nfH4riYpTk5kJSWKj5KCMpKYEkLw/Iy6vxP0NtEqTS8gGqLGgpFBDk8n8+l81/5DMUCqBZM1iqVKXLPz7u7/ePvtasUyarOL1s2mOfy41/fJ5MpvW1IJNp1scgSETaMCQRaSORAEZGUBsZAdbWtbRKCRwcHJD66CFGtRooLCwNUY8EJ0lBQen0so+iotJAVfZay3v8PU1SXFz6+tHpxcX/vP77PYqLy49VqUrX99jhT4laXRr0atC7cQ2WrQ+CRPJPAJNKS18/Gq6k0n9C2uOvy8JW2fiy5U1MYKVSPXGMZvqj7/+updy6ZLLSuh4dVzZPKv2n5rJtlfXz6HJlyz7yGlLpP72XzX9kWc38ysaXbVsqheTvfxPJgwf/bK9szGPrgETCG9JSo8CQRCQmqRQoO49J7FrKlJSUBieVqmKYUqlK36tU5d+XTXvss6SkBBYmJsh+8AAoLgZUKqBsvWWfS0oqfv57HFQqzWtJcTGgVpe+Lyn5Z17Z+LLl1erSeY+NQUmJ5hDq4ySC8M/2avGf0qgW19VYVPUAuSY4PR6kHp326Pu/g5Xw2JgqTft73eWmAeW3U7b9x8c+Ml14rBbIZICpKSzy87Wvo+z9I9vSOv3xbTw6/tF6yrb76Niyadq2/fiHtuUe3/4TliubL5FKAVtbGGRklBsvVLZMWU9a5kEqLf3Z9/j0snmGhqX31xMJQxIRlSeTlQY3oMbBTSKRwMLBAbmVnaBf39TqfwLW32GqXMh6dNrfwarC2MfXURbAysb/PcaqWTMoHzzQLAe1+p8xanW5ZSvMe/x12dhH3/89TbMeQfinjrLX2uaVLVvZuv4eW+794/O1jS/rqYokj2wHQK2G0/qmr0+4bF4P2yjq2hXpe/bUw5a0axQh6dChQ9izZw+USiWcnZ0xdepUtK3sMnMA0dHRWLduHe7evQsrKyuMGjUKgwcPLjfm7Nmz2LJlC1JSUtCiRQtMmjQJfn5+dd0KEYmp7K9zhaJcAKzt+Cb5++rN/IYSDutB2eHkpHv3IDwSviSPhCjNtMfDVdnrsgD26Bhtyz1h2hPHPBLwIAil231kXNkYyZOmlS3z9/LmpqbIzs4uv71Ht/X4Oh6fDlSsu2x82b/JY9MrrOuR6RX6fazeKi3zd00VtvXIsgqZDKqyPbeVLFfu30JLPeVq0laXIJRemCKiBh+SwsLCsHbtWsyYMQPe3t44cuQIvv76ayxZsgQ2NjYVxqempuKbb77BwIED8dZbb+H69etYtWoVzM3N0bNnTwBAbGwsli5diokTJ8LPzw/h4eFYsmQJPv/8c3h6etZ3i0RETUfZIZO/aYuITSU2SiQSmDekPaX1pCwQp+lB3w3+ko59+/ZhwIABGDhwoGYvko2NDYKDg7WODw4Oho2NDaZOnQpnZ2cMHDgQ/fv3x969ezVj9u/fDx8fH4wdOxZOTk4YO3YsOnTogP3799dXW0RERNTANeg9SSqVCvHx8RgzZky56T4+Prh+/brWZeLi4uDj41Numq+vL44fPw6VSgW5XI7Y2FiMGDGi3JhOnTrhwIEDldZSXFyM4uJizXuJRAJjY2PNa12VLVuTdTRG+tg3e9Yf+tg3e9Yf+tR3gw5J2dnZUKvVsLCwKDfdwsICSqVS6zJKpVLr+JKSEjx8+BBWVlZQKpWwtLQsN8bS0rLSdQLAzp07sW3bNs17d3d3LFq0CLa1dNa9fXVvmthE6GPf7Fl/6GPf7Fl/6EPfDTokldGWVp+UYB+fV3bM9EnLCILwxPljx47FyJEjK2wjLS0NKpWq0uWeRiKRwN7eHsnJyU3+2O6j9LFv9qwfPQP62Td71o+egcbft1wur/IOjgYdkszNzSGVSivs4cnKyqqwt6iMtj1C2dnZkMlkMDMzq3TMk9YJAAqFAgqFQuu82vgmEQShUX6z1ZQ+9s2e9Yc+9s2e9Yc+9N2gT9yWy+Xw8PBAVFRUuelRUVHw9vbWuoynp2eF8ZcvX4aHhwfkfz9A1MvLC1euXKmwTi8vr1qsnoiIiBqzBh2SAGDkyJE4evQojh07hrt372Lt2rVIT0/HoEGDAACbNm3Czz//rBk/ePBgpKena+6TdOzYMRw7dgzPPvusZszw4cNx+fJl7Nq1C/fu3cOuXbtw5cqVCidzExERkf5q0IfbAMDf3x8PHz7E9u3bkZmZCRcXF8ybN09zPDEzMxPp6ema8XZ2dpg3bx7WrVuHQ4cOwcrKCtOmTdPcIwkAvL29MWfOHGzevBlbtmyBvb095syZw3skERERkYZEaOoHFOtYWlpauVsDVJfmLrV6cFOuR+lj3+xZP3oG9LNv9qwfPQONv2+FQlHlE7cb/OE2IiIiIjEwJBERERFpwZBEREREpAVDEhEREZEWDElEREREWjT4WwA0dGU3qGwo62ls9LFv9qw/9LFv9qw/Gmvf1ambtwAgIiIi0oKH20SWn5+PDz/8EPn5+WKXUq/0sW/2rD/0sW/2rD/0qW+GJJEJgoBbt241yhty1YQ+9s2e9Yc+9s2e9Yc+9c2QRERERKQFQxIRERGRFgxJIlMoFBg/fjwUCoXYpdQrfeybPesPfeybPesPfeqbV7cRERERacE9SURERERaMCQRERERacGQRERERKQFQxIRERGRFo3zwStNyKFDh7Bnzx4olUo4Oztj6tSpaNu2rdhl1YmdO3ciPDwc9+7dg4GBAby8vPDSSy/B0dFR7NLqzc6dO/HHH39g+PDhmDp1qtjl1KmMjAxs3LgRly5dQlFRERwcHDBr1ix4eHiIXVqdKCkpwdatW3H69GkolUpYWVkhMDAQ48aNg1TadP4ejY6Oxp49e3Dr1i1kZmbigw8+gJ+fn2a+IAjYunUrjh49ipycHHh6emL69OlwcXERseqaeVLPKpUKmzdvRmRkJFJTU2FiYoKOHTti8uTJsLa2Frly3T3t6/yolStX4siRI5gyZQpGjBhRz5XWrabzP7cRCgsLw9q1azFu3DgsWrQIbdu2xddff4309HSxS6sT0dHRGDJkCL766it88sknUKvV+PLLL1FQUCB2afXixo0bOHLkCFq2bCl2KXUuJycHn376KeRyOT766CP88MMPeOWVV2BiYiJ2aXVm9+7dOHz4MKZPn44lS5bgpZdewp49exAUFCR2abWqsLAQbm5uePXVV7XO3717N/bv349XX30V33zzDSwtLfHll1826kdYPKnnoqIi3Lp1C8899xwWLVqE999/H0lJSfjuu+9EqLT2PO3rXCY8PBxxcXGwsrKqp8rqF/ckiWjfvn0YMGAABg4cCACYOnUqLl++jODgYEyePFnk6mrfxx9/XO797NmzMWPGDMTHx6Ndu3YiVVU/CgoK8NNPP2HmzJnYsWOH2OXUud27d6N58+aYPXu2ZpqdnZ2IFdW92NhYdOvWDV26dAFQ2m9ISAhu3rwpcmW1q3PnzujcubPWeYIg4MCBAxg7dix69OgBAHjjjTfw2muvISQkBIMGDarPUmvNk3o2MTHBp59+Wm7atGnT8NFHHyE9PR02Njb1UWKte1LPZTIyMvDbb7/h448/xrfffltPldUv7kkSiUqlQnx8PDp16lRuuo+PD65fvy5SVfUrLy8PAGBmZiZyJXVv1apV6Ny5M3x8fMQupV6cP38eHh4e+OGHHzBjxgzMnTsXR44cEbusOtWmTRtcvXoV9+/fBwAkJCTg+vXrT/1F05SkpqZCqVSW+7mmUCjQrl07vfm5BpT+bJNIJE16z6larcZPP/2EUaNGNepDqU/DPUkiyc7OhlqthoWFRbnpFhYWUCqV4hRVjwRBwLp169CmTRu4urqKXU6dCg0Nxa1bt/DNN9+IXUq9SU1NxeHDhzFixAiMHTsWN27cwJo1a6BQKNCvXz+xy6sTo0ePRl5eHt59911IpVKo1Wq88MILCAgIELu0elP2s0vbz7WmehrB44qKirBp0yb07t27SYek3bt3QyaTYdiwYWKXUqcYkkQmkUiqNK2pWb16NW7fvo3PP/9c7FLqVHp6OtauXYuPP/4YBgYGYpdTb9RqNVq1aqU5bOzu7o47d+4gODi4yYaksLAwnD59Gm+//TZcXFyQkJCAtWvXak7g1ieP/wzTlwc7qFQqLF26FIIgYMaMGWKXU2fi4+Nx4MABLFq0qMn/vmJIEom5uTmkUmmFvUZZWVkV/gpran777TdcuHABCxcuRPPmzcUup07Fx8cjKysL//73vzXT1Go1YmJiEBQUhE2bNjWpK5/KWFlZwdnZudw0Z2dnnDt3TqSK6t7GjRsxevRo9O7dGwDg6uqKtLQ07Nq1S29CkqWlJQBoru4rk52d3eR/rqlUKixZsgRpaWn47LPPmvRepJiYGGRnZ5c751CtVmP9+vU4cOAAli1bJmJ1tYshSSRyuRweHh6Iiooqd1llVFQUunfvLmJldUcQBPz2228IDw/HggULmvyJvADQsWNHLF68uNy0FStWwNHREaNHj26SAQkAvL29NefmlLl//z5sbW1FqqjuFRYWVvh6SqVSvdmLApSerG5paYmoqCi4u7sDKA0P0dHRePHFF0Wuru6UBaTk5GTMnz8fzZo1E7ukOtW3b1907Nix3LSvvvoKffv2Rf/+/UWqqm4wJIlo5MiR+Omnn+Dh4QEvLy8cOXIE6enpjfYKkKdZvXo1QkJCMHfuXBgbG2v2opmYmDTZQ1HGxsYVzrkyNDREs2bNmvS5WCNGjMCnn36KHTt2wN/fHzdu3MDRo0fx+uuvi11anenatSt27NgBGxsbODs7IyEhAfv27WtyvzQKCgqQnJyseZ+amoqEhASYmZnBxsYGw4cPx86dO+Hg4AB7e3vs3LkThoaGjfrcrCf1bGVlhR9++AG3bt3Chx9+CLVarfnZZmZmBrm8cf6afdrX+fEgKJfLYWlp2eTueycR9OnPnAao7GaSmZmZcHFxwZQpU5rs5fATJkzQOn327Nl6czgCABYsWAA3N7cmfzPJCxcuYNOmTUhOToadnR1GjBiBZ555Ruyy6kx+fj62bNmC8PBwZGVlwdraGr1798b48eMb7S9Kbf766y8sXLiwwvR+/frhjTfe0NxM8siRI8jNzUXr1q0xffr0Rv1HwZN6fv755/Hmm29qXW7+/Plo3759XZdXJ572dX7cG2+8geHDhze5m0kyJBERERFp0TRPiCAiIiKqIYYkIiIiIi0YkoiIiIi0YEgiIiIi0oIhiYiIiEgLhiQiIiIiLRiSiIiIiLRgSCIiIiLSgiGJiIiISAuGJCLSO7dv38bEiROxcuVKUevIy8vDtGnT8Omnn4paBxFp13QeKEREeuPGjRs4ceIEYmJikJGRgYKCApiYmMDBwQFt2rSBv78/PDw8Kl3+999/h1QqxdixY2u9NrVajbNnzyIkJATx8fHIzs6GgYEBLCws4OTkBB8fH/Tq1QsWFhYwMTHBsGHDsG3bNkRERKB79+61Xg8R6Y4hiYgajcLCQvzyyy8IDQ0FAMhkMtjb28PY2Bg5OTm4ceMGYmNjsWfPHnTu3Bnz5s2rsI6YmBhERkYiMDAQtra2tVpfZmYmfvjhB1y/fh0A0KxZM7i4uEClUuH+/ftISkrC+fPn4ejoCB8fHwDA8OHDsXfvXmzatAndunWDRCKp1ZqISHcMSUTUKKhUKnz11Ve4du0arKys8MILL6BXr14wMjLSjMnNzUVERAT27NmDq1eval1PUFAQgNKnmdemoqIifPHFF7h79y46duyIF198sdzerKKiIly6dAlBQUFwd3fXTDczM0PXrl0RFhaGq1evomPHjrVaFxHpjiGJiBqFrVu3agLSV199BRsbmwpjTE1NERgYiD59+mD37t0V5mdnZyMiIgJWVlZo27ZtrdYXFBSEu3fvomXLlvjoo48gk8nKzTcwMICfnx/8/PwqLOvv74+wsDAcPXqUIYmoAeGJ20TU4OXm5uLgwYMAgGnTpmkNSI+SyWQYN25chenh4eFQqVTo3LkzpNKKP/5SU1MxYcIEzJo1q9J1T5s2DRMmTEBubm656efPnwcA9OrVq0JAehpfX1/IZDJERESguLi4WssSUd1hSCKiBi8yMhIFBQWwtLTUuiemqqKjowEArVu31jr/9u3bAICWLVtqnZ+amorc3FzY2trC1NS03LzMzEwAQH5+frXrMjAwgKurK4qLi3Hz5s1qL09EdYMhiYgavLITob28vLTuAaqq2NhYAKj0yrfExEQAgJub2xPnawtRdnZ2AEoPu+3ZswdKpbJatbVq1QoAcO3atWotR0R1h+ckEVGDl5GRAQA1uhpNEAQ8ePAAAGBpaal1TFkIevTE6kclJCQA0B6Sxo0bh+joaBQWFmLjxo34/fff4erqivbt28PPzw/t2rV7Yn1lNaWlpVWhGyKqDwxJRNTgFRQUAAAMDQ21zg8NDcWPP/5YYfrs2bMRGBgIoPS8ppKSEgClV5Rp87Q9SU8KSe3bt8e3336L3bt34/z58ygoKEBiYiISExNx4MABeHh44O2334ajo6PWdZfVlJ2drXU+EdU/hiQiavDKLvMvLCzUOt/c3Bze3t6a93fu3EFeXl65MY+eEC2XV/zRV1hYiOTkZBgbG2sOnT3uaSGqZcuWePvtt1FcXIzr168jKioKZ8+eRXJyMuLj4/Gf//wH3333ndYTuw0MDACU3iqAiBoGhiQiavCsra0BVH4oqmPHjuUunf/iiy9w5cqVcmMe3XuUl5dXYW/SnTt3IAgC3NzctN7QMS8vD2lpaTAyMkKLFi2eWK9CoUCHDh3QoUMHvPDCC1i7di2CgoJw584dJCQkaM4/elROTg6A0htQElHDwBO3iajB8/LyAlB6ArdardZpHQqFAsbGxgD+CSSPetKhNAC4efMmBEFAy5Ytq3VXbKlUiuHDh2vel50X9biymszNzau8biKqWwxJRNTgde7cGUZGRsjKykJ4eLjO6yk7THbv3r0K88ou/6/snKELFy4AqDxEPYlKpdK8Ltsr9ri7d+8CqPzKOyKqfwxJRNTgmZmZYejQoQCANWvWID09Xaf1tGnTBgC03ouo7Hwjbfc5evDgAU6ePAmgYkiqyonWwcHBAAAbG5tKQ1BZTWU1EpH4GJKIqFGYMGECvLy8kJmZiY8++gjHjh3TXPVWRqVS4ezZs7h//77WdXTq1AnAP/ddelTZnqTDhw8jOTlZMz0+Ph7ffvut5g7bVlZW5U4C//PPP/Hxxx/jzJkzFU4sT01NxfLlyxEUFASJRILp06drvc9TcnIysrKy4OTk9NS7iRNR/ZEIgiCIXQQRUVUUFBRgxYoVOHPmDIDSx4/Y29vD2NgYDx8+hFKp1ASVTp064fXXXy93byVBEPDOO+8gNTUVv/zyi+beROnp6Zg9ezZsbW1RUFCguat2Xl4eHj58iFatWiEjIwOZmZlo1qwZhgwZggkTJgAAPv74Y8TFxZWrx8jICBkZGVAqlRAEAaamppg5cyZ69uypta8dO3Zg8+bNeOmllzBq1Ki6+ucjomri1W1E1GgYGRnh3XffxciRI3HixAnExMQgIyMDycnJMDExgaurK7y9vREQEKD1sJZEIsHAgQPx+++/IywsTHNCddlJ261atcKzzz6LtWvXIiEhAWZmZhg8eDAmT56MY8eOYcuWLbCysoKvr69mne+++y7OnTuHv/76CykpKVAqlZp62rRpA19fXwwcOPCJJ2SHhoZCJpOhX79+tfrvRUQ1wz1JRKRX8vLy8NZbb8HMzAxLliyBVCrV7Ml5/vnn8fzzz9drPVevXsXnn3+OwYMHY8aMGfW6bSJ6Mp6TRER6xcTEBM899xySkpIQFhYG4J89SS4uLvVez/bt22FkZITx48fX+7aJ6Ml4uI2I9M7gwYORl5enuedS2Unbrq6u9VpHXl4e2rVrh2HDhlX6PDkiEg8PtxGRXisqKsLLL78MuVyODRs2aL36jIj0E38aEJFeu337NgRBgLOzMwMSEZXDPUlEREREWvDPJiIiIiItGJKIiIiItGBIIiIiItKCIYmIiIhIC4YkIiIiIi0YkoiIiIi0YEgiIiIi0oIhiYiIiEgLhiQiIiIiLRiSiIiIiLRgSCIiIiLS4v8BLp2UDVytMeIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get state dependent mean and standard deviation of Activation Energy\n", + "PAR_TempMean=[]\n", + "PAR_TempStd=np.true_divide((PAR_GMax*0.0001),PAR_READStd)\n", + "\n", + "def f(x):\n", + " for i in range(0,len(x)):\n", + " DUM_A= min(np.append(max(np.append(-0.045*np.log(x[i])+0.0844,0.10)),0.23))\n", + " PAR_TempMean.append(DUM_A)\n", + "\n", + "PAR_D=f(x)\n", + "fig = plt.subplots()\n", + "plt.title('State dependent $E_{a}$')\n", + "plt.plot(PAR_G,PAR_TempMean,color=\"green\",label=\"Mean\")\n", + "plt.plot(PAR_G,PAR_TempStd,color=\"red\",label=\"SD\")\n", + "plt.xlabel('G($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Activation Energy', fontsize=16)\n", + "leg = plt.legend();\n", + "\n", + "# Modify the reference matrix conductance values using the Activation Energies\n", + "PAR_T=350;\n", + "PAR_MatrixTS2D=np.zeros((PAR_NumWL,PAR_NumWL))\n", + "for i in range(0,PAR_NumWL):\n", + " for j in range(0,PAR_NumWL):\n", + " DUM_C=PAR_MatrixRef2D[i][j]\n", + " DUM_DIndex= np.argmin(abs(abs(DUM_C)-PAR_G))\n", + " DUM_Factor= PAR_DriftMean[DUM_DIndex]+PAR_DriftStd[DUM_DIndex]*np.random.normal(0, 1, 1);\n", + " DUM_E= np.divide(DUM_C,np.exp(-DUM_Factor/(8.6e-5*300)))\n", + " PAR_MatrixTS2D[i][j]= DUM_E*np.exp(-DUM_Factor/(8.6e-5*PAR_T))\n", + "\n", + "PAR_MatrixTS=PAR_MatrixTS2D.reshape(PAR_NumPCM)\n", + "fig = plt.subplots()\n", + "plt.title(\"Conductance distribution\")\n", + "plt.hist(PAR_MatrixTS,bins=100,edgecolor=\"green\", color=\"green\")\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Counts', fontsize=16)\n", + "plt.ylim([0, 3500])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 2-3 initialzes variables. Line 3 approximates the relationship between G and standard deviation of $E_{a}$\n", + "
\n", + "Lines 5-8 is a function that establishes the relationship between G and mean of $E_{a}$\n", + "
\n", + "Lines 10-17 creates a plot of the G and bipolar asymmetry relationship\n", + "
\n", + "Lines 20-21 initialzes variables. PAR_T is ambient temperature \n", + "
\n", + "Lines 22-28 associates an $E_{a}$ with every element in our reference conductance matrix\n", + "
\n", + "Lines 30-36 creates a histogram plot of the temperature influenced matrix elements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1.4: We inject the non-ideality of bi-polar asymmetry into all conductance states\n", + "\n", + "Definition: 'When phase-change materials make contact with metallic electrodes, interfacial barriers can form, the size of which is dictated by both phase-change materials and electrode properties (work functions). If the barriers at the interfaces with the bottom electrode and top electrode were to differ, the current flow becomes polarity dependent'.\n", + "
\n", + "
\n", + "Mathematically bipolar asymmetry follows the relation $\\alpha_{i,j}= \\frac{I_{i,j (pos)}}{I_{i,j(neg)}}$, where the current under a positive polarity read signal differs from the negative polarity read signal by some factor $\\alpha$. To simulate bipolar asymmetry, we first have to define the state-dependent (conductance) mean and standard deviation of $\\alpha$.\n", + "
\n", + "
\n", + "For further reading refer to [Adv. Mater. 2022, 2201238](https://doi.org/10.1002/adma.202201238)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 3500.0)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get state dependent mean and standard deviation of α\n", + "x=np.arange(0.01,1,0.01)\n", + "PAR_BPMean=[]\n", + "PAR_BPStd=np.true_divide((PAR_GMax*0.0003),PAR_READStd)\n", + "\n", + "def f(x):\n", + " for i in range(0,len(x)):\n", + " if i<6:\n", + " DUM_A= np.polyval(np.poly1d([0.2555, -0.6312, 1.1144]),PAR_G[i])\n", + " elif i>5:\n", + " DUM_A= np.polyval(np.poly1d([-2.1240e-05, 0.0013, -0.0138, 0.7681]),PAR_G[i])\n", + " PAR_BPMean.append(DUM_A)\n", + "\n", + "PAR_D=f(x)\n", + "fig = plt.subplots()\n", + "plt.title('State dependent bipolar asymmetry')\n", + "plt.plot(PAR_G,PAR_BPMean,color=\"green\",label='Mean')\n", + "plt.plot(PAR_G,PAR_BPStd,color=\"red\",label='SD')\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('$I_{neg}/I_{pos}$', fontsize=16)\n", + "leg = plt.legend();\n", + "\n", + "# Modify the conductance reference matrix using α\n", + "PAR_IN=np.concatenate([0.2*np.array(np.ones(128)),-0.2*np.array(np.ones(128))])\n", + "# Shuffle the Inputs\n", + "np.random.shuffle(PAR_IN)\n", + "PAR_MatrixBP2D=np.zeros((PAR_NumWL,PAR_NumWL))\n", + "for i in range(0,len(PAR_IN)):\n", + " if PAR_IN[i]<0:\n", + " for j in range(0,len(PAR_IN)):\n", + " DUM_C=PAR_MatrixRef2D[j][i]\n", + " DUM_DIndex= np.argmin(abs(abs(DUM_C)-PAR_G))\n", + " DUM_Factor= PAR_BPMean[DUM_DIndex]+(PAR_BPStd[DUM_DIndex]*np.random.normal(0, 1, 1));\n", + " PAR_MatrixBP2D[j][i]= DUM_C*np.divide(1,DUM_Factor)\n", + " else:\n", + " PAR_MatrixBP2D[:,i]=PAR_MatrixRef2D[:,i]\n", + "\n", + "fig = plt.subplots()\n", + "plt.title('Conductance distribution')\n", + "PAR_MatrixBP=PAR_MatrixBP2D.reshape(PAR_NumPCM)\n", + "plt.hist(PAR_MatrixBP,bins=100,edgecolor=\"green\",color=\"green\")\n", + "plt.xlabel('G ($\\mu S$)', fontsize=16)\n", + "plt.ylabel('Counts', fontsize=16)\n", + "plt.ylim([0,3500])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 2-4 initializes variables. Line 3 approximates the relationship between G and standard deviation of $\\alpha$\n", + "
\n", + "Lines 6-12 describe a function that establishes the relationship between G and mean of $\\alpha$\n", + "
\n", + "Lines 14-21 creates a plot of the G and bipolar asymmetry relationship\n", + "
\n", + "Lines 24-27 creates an input vector that has randomly placed + and - 0.2 V read signal\n", + "
\n", + "Lines 28-36 associates a mean and DD drift coefficient with every element in our reference conductance matrix\n", + "
\n", + "Lines 38-40 creates a histogram plot of the bi-polar asymmetry influenced matrix elements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 2: Now that we have seen the different non-idealities and their state dependence, it is time we see how they contribute to the computational imprecisions \n", + "\n", + "To do this we perfrom matrix vector operations (MAC) with our 256 by 256 crossbar, first without non-idealities and then introducing the non-idealities one by one. We then compare the with and without currents using a normalized MAC error ($\\frac{||\\text{I}-\\bar{\\text{I}}||}{||\\text{I}||}$, where $I$ is net current on columns of the crossbar without non-idealities, and $\\bar{I}$ is with non-idealities. We want the MAC error to be small." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.35)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Intitialize an Input Vector. Each element in the vector can be +200 mV or -200 mV\n", + "\n", + "# MAC without non-idealities\n", + "MAC_I= np.dot(PAR_MatrixRef2D,PAR_IN)\n", + "\n", + "# MAC with READ noise\n", + "MAC_IbarRead= np.dot(PAR_MatrixRead2D,PAR_IN)\n", + "\n", + "# MAC with Resistance Drift\n", + "MAC_IbarRD= np.dot(PAR_MatrixRD2D,PAR_IN)\n", + "\n", + "# MAC with Temperature Fluctuations\n", + "MAC_IbarTemp= np.dot(PAR_MatrixTS2D,PAR_IN)\n", + "\n", + "# MAC with Bipolar Noise\n", + "MAC_IbarBP= np.dot(PAR_MatrixBP2D,PAR_IN)\n", + "\n", + "\n", + "## Lets estimate the errors and plot them\n", + "RelNormError_Read = np.divide(np.linalg.norm(MAC_I-MAC_IbarRead),np.linalg.norm(MAC_I))\n", + "RelNormError_Drift = np.divide(np.linalg.norm(MAC_I-MAC_IbarRD),np.linalg.norm(MAC_I))\n", + "RelNormError_Temp = np.divide(np.linalg.norm(MAC_I-MAC_IbarTemp),np.linalg.norm(MAC_I))\n", + "RelNormError_BP = np.divide(np.linalg.norm(MAC_I-MAC_IbarBP),np.linalg.norm(MAC_I))\n", + "\n", + "fig = plt.subplots()\n", + "plt.title('MVM Error')\n", + "x = ['Read','Drift', 'Temperature', 'Bipolar']\n", + "y= [RelNormError_Read,RelNormError_Drift,RelNormError_Temp,RelNormError_BP]\n", + "plt.barh(x,y,color=['green','black','blue','red'],alpha=0.5)\n", + "plt.xlabel('MVM Error', fontsize=18)\n", + "plt.ylabel('Non-Ideality', fontsize=18)\n", + "plt.xlim([0, 0.35])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 3-16 are the dot product bewteen the input vector and the matrix without and with non-idealities. The output is a vector whose each element represents the accumulted current on every column\n", + "
\n", + "Lines 20-23 computes the normalized MAC error under different non-idealities \n", + "
\n", + "Lines 25-30 creates a bar chat plot skteching the different MAC error for different non-idealites\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 3: We want these non-idealities to minimally affect our computational operations. There are software tricks we could use to realize this. \n", + "\n", + "One such is the global compensation scheme. In this scheme, we correct for the output currents on the bit lines using a correction factor ($\\beta$). The correction factor is estimated by comparing the MAC operations at a given time instance ($I(t,T)$) against a reference MAC operation ($I_{REF}$); such that $\\beta=\\frac{I_{REF}}{I(t,T)}$. Under resistance drift, the currents decrease with time, thus by using $\\beta\\times I(t,T)$ we can compensate for drift. Similar corrections can be used for correcting the ambient temperature fluctuations. We commonly refer to these schemes as GDC (global drift corrections). \n", + "\n", + "Such approaches, however, are inadequate for bipolar asymmetry corrections. This is because the non-ideality does not change in time, instead has an unfavorable input dependency. We can however compensate for the non-ideality by changing the amplitude of the input read voltages. The main idea lies in the fact that the one type of bias polarity (-ve in this case), can be adjusted relative to the other such that the currents produced by either are similar ($\\text{I}\\!\\simeq \\!\\bar{\\text{I}}$). Here, $V_{\\text{-ve}}=\\beta\\times V_{\\text{+ve}}$, where $\\beta$ is estimated using hardware in the loop.\n", + "\n", + "Note that while the software schemes can be used, an ideal approach would be making physical devices that should these non-idealities, minimally. One such is the projected memory devices (see [Adv. Funct. Mater. 2021, 31, 2106547](https://doi.org/10.1002/adfm.202106547), [Nature Communications. 2015 6, 8181](https://www.nature.com/articles/ncomms9181))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.35)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# GDC for Temperature fluctuation correction\n", + "PAR_FactoTS= np.divide(np.sum([MAC_I[1:20]]),np.sum([MAC_IbarTemp[1:20]]))\n", + "MAC_ITSCorr = PAR_FactoTS*MAC_IbarTemp\n", + "\n", + "# GDC for Resistance drift correction\n", + "PAR_IFactoRD= np.divide(np.sum([MAC_I[1:20]]),np.sum([MAC_IbarRD[1:20]]))\n", + "MAC_IRDCorr = PAR_IFactoRD*MAC_IbarRD\n", + "\n", + "# Bipolar asymmetry corrections\n", + "PAR_FactoBPCorr=-0.1474\n", + "PAR_INc=PAR_IN\n", + "for n, i in enumerate(PAR_INc):\n", + " if i < 0:\n", + " PAR_INc[n] = PAR_FactoBPCorr\n", + "MAC_IBPCorr = np.dot(PAR_MatrixBP2D,PAR_INc)\n", + "\n", + "## Lets estimate the errors and plot them\n", + "RelNormError_Read = np.divide(np.linalg.norm(MAC_I-MAC_IbarRead),np.linalg.norm(MAC_I))\n", + "RelNormError_Drift = np.divide(np.linalg.norm(MAC_I-MAC_IRDCorr),np.linalg.norm(MAC_I))\n", + "RelNormError_Temp = np.divide(np.linalg.norm(MAC_I-MAC_ITSCorr),np.linalg.norm(MAC_I))\n", + "RelNormError_BP = np.divide(np.linalg.norm(MAC_I-MAC_IBPCorr),np.linalg.norm(MAC_I))\n", + "\n", + "fig = plt.subplots()\n", + "plt.title('Corrected MAC Error')\n", + "x = ['Read','c-Drift', 'c-Temperature', 'c-Bipolar']\n", + "y= [RelNormError_Read,RelNormError_Drift,RelNormError_Temp,RelNormError_BP]\n", + "plt.barh(x,y,color=['green','black','blue','red'],alpha=0.5)\n", + "plt.xlabel('MVM Error', fontsize=18)\n", + "plt.ylabel('Non-Ideality', fontsize=18)\n", + "plt.xlim([0, 0.35])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lines 1-3 computes the matrix elements for corrected (using GDC) temperature non-ideality\n", + "
\n", + "Lines 6-7 computes the matrix elements error for corrected (using GDC) resistance drift non-ideality\n", + "
\n", + "Lines 9-15 computes the matrix elements error for corrected (read voltage modulation) bi-polar asymmetry non-ideality\n", + "
\n", + "Lines 18-21 computes the normalized MAC error under different non-idealities \n", + "
\n", + "Lines 23-28 creates a bar chat plot skteching the different MAC error for different non-idealites" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Buidng AIHWKit library functions for non-idealities\n", + "
\n", + "If you made it so far, kudos to you for keeping up!\n", + "
\n", + "
\n", + "In the above, we defined the various non-idealities using user defined equations. These equations, however, can be casted into library functions and used in various DNN models.\n", + "

\n", + "As a first step create a class comprising definations for various non-idealities, for example as below" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "from aihwkit.inference.noise.pcm import PCMLikeNoiseModel\n", + "\n", + "class MyPCMNoiseModel(PCMLikeNoiseModel):\n", + " def generate_drift_coefficients(self, G_target, t_inference):\n", + " # define drift coefficients coefficients\n", + " def apply_programming_noise_to_conductance(self, G_target):\n", + " # define programming noise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "a device specification can be then called using the constructor, as shown below" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "my_noise = MyPCMNoiseModel()\n", + "noise_weights = my_noise.generate_drift_coefficients(G_target = weight, t_inference=3600.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "or use that directly to generate tiles / or modules e.g." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "from aihwkit.simulator.tiles.inference import InferenceTile\n", + "from aihwkit.simulator.config import InferenceRPUConfig\n", + "\n", + "rpu_config = InferenceRPUConfig(noise_model=MyPCMNoiseModel())\n", + "analog_tile = InferenceTile(50, 50, rpu_config=rpu_config)\n", + "analog_tile.set_weights(randn(50,50))\n", + "analog_tile.program_weights() # applied noise model\n", + "analog_tile.forward(x) # forward pass with applied programming noise + other non-idealities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or just using a linear module instead of an InferenceTile (a module could have multiple tiles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "from aihwkit.nn import AnalogLinear\n", + "\n", + "rpu_config = InferenceRPUConfig(noise_model=MyPCMNoiseModel())\n", + "linear = AnalogLinear(50, 50, rpu_config=rpu_config)\n", + "linear.drift_analog_weights(t_inference=100.0)\n", + "y = linear(x)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From fd3e438e43404050599f8282bd1f38ff612dfca3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pablo=20Carmona=20Gonz=C3=A1lez?= Date: Mon, 20 Jan 2025 12:15:46 +0100 Subject: [PATCH 14/14] feat: update example and check HALF option training works MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Pablo Carmona González --- ...sion_training.py => 34_half_precision_training.py} | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) rename examples/{31_half_precision_training.py => 34_half_precision_training.py} (82%) diff --git a/examples/31_half_precision_training.py b/examples/34_half_precision_training.py similarity index 82% rename from examples/31_half_precision_training.py rename to examples/34_half_precision_training.py index 69ae9eb6..203a8157 100644 --- a/examples/31_half_precision_training.py +++ b/examples/34_half_precision_training.py @@ -4,13 +4,7 @@ # (C) Copyright 2020, 2021, 2022, 2023, 2024 IBM. All Rights Reserved. # -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. +# Licensed under the MIT license. See LICENSE file in the project root for details. """aihwkit example 31: Using half precision training. @@ -24,7 +18,7 @@ import torch.nn as nn import torch.nn.functional as F from torchvision import datasets, transforms -from aihwkit.simulator.configs import InferenceRPUConfig, TorchInferenceRPUConfig +from aihwkit.simulator.configs import TorchInferenceRPUConfig from aihwkit.nn.conversion import convert_to_analog from aihwkit.optim import AnalogSGD from aihwkit.simulator.parameters.enums import RPUDataType @@ -61,6 +55,7 @@ def forward(self, x): if __name__ == "__main__": model = Net() rpu_config = TorchInferenceRPUConfig() + rpu_config.runtime.data_type = RPUDataType.HALF model = convert_to_analog(model, rpu_config) nll_loss = torch.nn.NLLLoss() transform = transforms.Compose(