diff --git a/cli_tool/create_dataset_train_val.py b/cli_tool/create_dataset_train_val.py new file mode 100644 index 0000000..6836b2d --- /dev/null +++ b/cli_tool/create_dataset_train_val.py @@ -0,0 +1,29 @@ +from utils import tools +import argparse +import importlib +if __name__ == "__main__": + tools = importlib.reload(tools) + + parser = argparse.ArgumentParser(description='Optional app description') + # Optional argument + parser.add_argument('--extension', type=str, help='File extension') + parser.add_argument('--per_class', type=int, help='number of samples in per class') + parser.add_argument('--number_of_samples', type=int, help='number of asmples in whole dataset') + parser.add_argument('--path_to_csv', type=str, help='Path to csv with scalled results (example: --path_to_csv "./path/to/result0-100000.csv")') + parser.add_argument('--path_to_data_source', type=str, help='Path to ./public_youtube1120_mp3') + parser.add_argument('--path_to_data_destination', type=str, help='Path to dir with /train, /val subdirs with folders for every emotions') + + args = parser.parse_args() + + if not '.csv' in args.path_to_csv: + print("Unexpected arg: {}".format(args.path_to_csv)) + exit(1) + + if args.extension not in ['.png', '.txt', '.wav']: + print("Invalid format argument: {}, must be .png, .txt or .wav".format(args.extension)) + exit(1) + print(args.path_to_csv) + print(args.path_to_data_source) + print(args.path_to_data_destination) + + tools.get_train_val(args.path_to_csv, args.path_to_data_source, args.path_to_data_destination, args.number_of_samples, args.per_class, args.extension) \ No newline at end of file diff --git a/cli_tool/model_pytorch.py b/cli_tool/model_pytorch.py new file mode 100644 index 0000000..5ac668d --- /dev/null +++ b/cli_tool/model_pytorch.py @@ -0,0 +1,173 @@ +# License: BSD +# Author: Sasank Chilamkurthy + +from __future__ import print_function, division + +import torch +import torch.nn as nn +import torch.optim as optim +from torch.optim import lr_scheduler +import numpy as np +import torchvision +from torchvision import datasets, models, transforms +import matplotlib.pyplot as plt +import time +import os +import copy +from utils import tools +import argparse +import importlib + +plt.ion() # interactive mode + +def train_model(model, criterion, optimizer, scheduler, num_epochs=25): + since = time.time() + + best_model_wts = copy.deepcopy(model.state_dict()) + best_acc = 0.0 + + for epoch in range(num_epochs): + print('Epoch {}/{}'.format(epoch, num_epochs - 1)) + print('-' * 10) + + # Each epoch has a training and validation phase + for phase in ['train', 'val']: + if phase == 'train': + model.train() # Set model to training mode + else: + model.eval() # Set model to evaluate mode + + running_loss = 0.0 + running_corrects = 0 + + # Iterate over data. + for inputs, labels in dataloaders[phase]: + inputs = inputs.to(device) + labels = labels.to(device) + + # zero the parameter gradients + optimizer.zero_grad() + + # forward + # track history if only in train + with torch.set_grad_enabled(phase == 'train'): + outputs = model(inputs) + _, preds = torch.max(outputs, 1) + loss = criterion(outputs, labels) + + # backward + optimize only if in training phase + if phase == 'train': + loss.backward() + optimizer.step() + + # statistics + running_loss += loss.item() * inputs.size(0) + running_corrects += torch.sum(preds == labels.data) + if phase == 'train': + scheduler.step() + + epoch_loss = running_loss / dataset_sizes[phase] + epoch_acc = running_corrects.double() / dataset_sizes[phase] + + print('{} Loss: {:.4f} Acc: {:.4f}'.format( + phase, epoch_loss, epoch_acc)) + + # deep copy the model + if phase == 'val' and epoch_acc > best_acc: + best_acc = epoch_acc + best_model_wts = copy.deepcopy(model.state_dict()) + + print() + + time_elapsed = time.time() - since + print('Training complete in {:.0f}m {:.0f}s'.format( + time_elapsed // 60, time_elapsed % 60)) + print('Best val Acc: {:4f}'.format(best_acc)) + + # load best model weights + model.load_state_dict(best_model_wts) + return model + +def visualize_model(model, num_images=6): + was_training = model.training + model.eval() + images_so_far = 0 + fig = plt.figure() + + with torch.no_grad(): + for i, (inputs, labels) in enumerate(dataloaders['val']): + inputs = inputs.to(device) + labels = labels.to(device) + + outputs = model(inputs) + _, preds = torch.max(outputs, 1) + + for j in range(inputs.size()[0]): + images_so_far += 1 + ax = plt.subplot(num_images//2, 2, images_so_far) + ax.axis('off') + ax.set_title('predicted: {}'.format(class_names[preds[j]])) + imshow(inputs.cpu().data[j]) + + if images_so_far == num_images: + model.train(mode=was_training) + return + model.train(mode=was_training) + +if __name__ == "__main__": + tools = importlib.reload(tools) + + parser = argparse.ArgumentParser(description='Optional app description') + # Optional argument + parser.add_argument('--path_to_dataset', type=str, help='Path to ./train_val_data') + + args = parser.parse_args() + + print(args.path_to_dataset) + + # Data augmentation and normalization for training + # Just normalization for validation + data_transforms = { + 'train': transforms.Compose([ + transforms.RandomResizedCrop(224), + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ]), + 'val': transforms.Compose([ + transforms.Resize(256), + transforms.CenterCrop(224), + transforms.ToTensor(), + transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ]), + } + + data_dir = args.path_to_dataset + image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), + data_transforms[x]) + for x in ['train', 'val']} + dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=16, + shuffle=True, num_workers=4) + for x in ['train', 'val']} + dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} + class_names = image_datasets['train'].classes + + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + + model_ft = models.resnet18(pretrained=False) + num_ftrs = model_ft.fc.in_features + # Here the size of each output sample is set to 2. + # Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)). + model_ft.fc = nn.Linear(num_ftrs, len(class_names)) + + model_ft = model_ft.to(device) + + criterion = nn.CrossEntropyLoss() + + # Observe that all parameters are being optimized + optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) + + # Decay LR by a factor of 0.1 every 7 epochs + exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=3, gamma=0.1) + + model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler, num_epochs=25) diff --git a/examples/dataset_preprocessing.ipynb b/examples/dataset_preprocessing.ipynb new file mode 100644 index 0000000..a9da8d8 --- /dev/null +++ b/examples/dataset_preprocessing.ipynb @@ -0,0 +1,410 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import collections\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os, sys\n", + "import re\n", + "\n", + "from argparse import Namespace" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "args = Namespace(\n", + " raw_train_dataset_csv=\"data/yelp/raw_train.csv\",\n", + " raw_test_dataset_csv=\"data/yelp/raw_test.csv\",\n", + " custom_dataset_csv=\"data/scalling_result400000-500000.csv\",\n", + " path_to_custom_dataset=\"..\\\\..\\\\..\\\\..\\\\RussianNLP\\\\public_youtube1120_mp3\\\\\",\n", + " preprocessed_dataset=\"./data/like_yelp_custom_ds.csv\",\n", + " proportion_subset_of_train=0.1,\n", + " train_proportion=0.7,\n", + " val_proportion=0.15,\n", + " test_proportion=0.15,\n", + " output_munged_csv=\"data/yelp/reviews_with_splits_lite.csv\",\n", + " seed=1337\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345pathemotions
00.1711950.5297800.1622590.0952350.0405690.000963.\\public_youtube1120\\4\\88\\5ac360108ae3.txtneutral
10.0474680.8185320.0486820.0775430.0072520.000523.\\public_youtube1120\\4\\88\\5ac5f00a00e8.txtneutral
20.1352180.4849330.2468280.1225210.0091970.001304.\\public_youtube1120\\4\\88\\5aeff595b96e.txtnegative
30.1015490.5747610.0896270.1360400.0238550.074168.\\public_youtube1120\\4\\88\\5bdbd9882ce0.txtneutral
40.1833790.4300830.1820020.2007660.0035710.000199.\\public_youtube1120\\4\\88\\5bef40e49a15.txtskip
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 \\\n", + "0 0.171195 0.529780 0.162259 0.095235 0.040569 0.000963 \n", + "1 0.047468 0.818532 0.048682 0.077543 0.007252 0.000523 \n", + "2 0.135218 0.484933 0.246828 0.122521 0.009197 0.001304 \n", + "3 0.101549 0.574761 0.089627 0.136040 0.023855 0.074168 \n", + "4 0.183379 0.430083 0.182002 0.200766 0.003571 0.000199 \n", + "\n", + " path emotions \n", + "0 .\\public_youtube1120\\4\\88\\5ac360108ae3.txt neutral \n", + "1 .\\public_youtube1120\\4\\88\\5ac5f00a00e8.txt neutral \n", + "2 .\\public_youtube1120\\4\\88\\5aeff595b96e.txt negative \n", + "3 .\\public_youtube1120\\4\\88\\5bdbd9882ce0.txt neutral \n", + "4 .\\public_youtube1120\\4\\88\\5bef40e49a15.txt skip " + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def load_custom_dataset(data_path):\n", + " df = pd.read_csv(data_path, index_col=0)\n", + " df = df.loc[:, ~df.columns.str.contains('^Unnamed')]\n", + " return df\n", + "\n", + "cp_train_reviews = load_custom_dataset(args.custom_dataset_csv)\n", + "cp_train_reviews.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "# Delete left columns\n", + "col_for_delete = [str(i) for i in range(6)]\n", + "cp_train_reviews = cp_train_reviews.drop(columns=col_for_delete)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " text = text.lower()\n", + " text = re.sub(r\"([.,!?])\", r\" \\1 \", text)\n", + " text = re.sub(r\"[^а-яёЁА-Яa-zA-Z.,!?]+\", r\" \", text)\n", + " return text\n", + "\n", + "def text_by_path(path):\n", + " path = path[1:]\n", + " path = \"\\\\\\\\\".join(path.split(\"\\\\\"))\n", + " try:\n", + " with open(args.path_to_custom_dataset + path, 'r', encoding=\"utf-8\") as file:\n", + " text = file.read()\n", + " except FileNotFoundError:\n", + " return -1\n", + " else:\n", + " return preprocess_text(text)\n", + " \n", + "cp_train_reviews.path = cp_train_reviews.path.apply(lambda x: text_by_path(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [], + "source": [ + "cp_train_reviews['split'] = \"\"\n", + "item_list = []\n", + "np.random.seed(args.seed)\n", + "\n", + "np.random.shuffle(cp_train_reviews.values)\n", + " \n", + "n_total = len(cp_train_reviews)\n", + "n_train = int(args.train_proportion * n_total)\n", + "n_val = int(args.val_proportion * n_total)\n", + "n_test = int(args.test_proportion * n_total)\n", + " \n", + "# Give data point a split attribute\n", + "for _ in range(n_train):\n", + " item_list.append('train')\n", + "\n", + "for _ in range(n_train, n_train+n_val):\n", + " item_list.append('val')\n", + "\n", + "for _ in range(n_train+n_val, n_train+n_val+n_test):\n", + " item_list.append('test')" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "cp_train_reviews['split'] = item_list" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pathemotionssplit
0здрасте варвара степановнаskiptrain
1надо было еще и голову отбить напрочьpositivetrain
2слушай а может нам развестисьneutraltrain
3это ресепшен передалneutraltrain
4теперь не найтиneutraltrain
\n", + "
" + ], + "text/plain": [ + " path emotions split\n", + "0 здрасте варвара степановна skip train\n", + "1 надо было еще и голову отбить напрочь positive train\n", + "2 слушай а может нам развестись neutral train\n", + "3 это ресепшен передал neutral train\n", + "4 теперь не найти neutral train" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cp_train_reviews.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train 70000\n", + "test 15000\n", + "val 15000\n", + "Name: split, dtype: int64" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cp_train_reviews.split.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cp_train_reviews.to_csv(args.preprocessed_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "final_reviews.to_csv(args.output_munged_csv, index=False)" + ] + } + ], + "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.6.10" + }, + "toc": { + "colors": { + "hover_highlight": "#DAA520", + "running_highlight": "#FF0000", + "selected_highlight": "#FFD700" + }, + "moveMenuLeft": true, + "nav_menu": { + "height": "12px", + "width": "252px" + }, + "navigate_menu": true, + "number_sections": true, + "sideBar": true, + "threshold": "5", + "toc_cell": false, + "toc_section_display": "block", + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/noise_reduce.ipynb b/examples/noise_reduce.ipynb new file mode 100644 index 0000000..8a07301 --- /dev/null +++ b/examples/noise_reduce.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Miniconda3\\lib\\site-packages\\librosa\\core\\audio.py:161: UserWarning: PySoundFile failed. Trying audioread instead.\n", + " warnings.warn('PySoundFile failed. Trying audioread instead.')\n" + ] + } + ], + "source": [ + "import noisereduce as nr\n", + "import librosa\n", + "import numpy as np\n", + "from scipy import signal\n", + "import matplotlib.pyplot as plt\n", + "import IPython\n", + "# load data\n", + "audio, samplerate = librosa.load(r\"D:\\localNLP\\RussianNLP\\public_youtube1120_mp3\\public_youtube1120\\1\\0a\\00d183e9796b.mp3\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def log_specgram(audio, sample_rate, window_size=20,\n", + " step_size=10, eps=1e-10):\n", + " nperseg = int(round(window_size * sample_rate / 1e3))\n", + " noverlap = int(round(step_size * sample_rate / 1e3))\n", + " freqs, times, spec = signal.spectrogram(audio,\n", + " fs=sample_rate,\n", + " window='hann',\n", + " nperseg=nperseg,\n", + " noverlap=noverlap,\n", + " detrend=False)\n", + " return freqs, times, np.log(spec.T.astype(np.float32) + eps)\n", + "\n", + "def draw_spec(samples, sample_rate):\n", + " freqs, times, spectrogram = log_specgram(samples, sample_rate)\n", + " fig = plt.figure(figsize=(14, 8))\n", + " ax1 = fig.add_subplot(211)\n", + " ax1.set_title('Raw wave of ')\n", + " ax1.set_ylabel('Amplitude')\n", + " ax1.plot(np.linspace(0, sample_rate/len(samples), sample_rate), samples)\n", + "\n", + " ax2 = fig.add_subplot(212)\n", + " ax2.imshow(spectrogram.T, aspect='auto', origin='lower', \n", + " extent=[times.min(), times.max(), freqs.min(), freqs.max()])\n", + " ax2.set_yticks(freqs[::16])\n", + " ax2.set_xticks(times[::16])\n", + " ax2.set_title('Spectrogram of ')\n", + " ax2.set_ylabel('Freqs in Hz')\n", + " ax2.set_xlabel('Seconds')\n", + "draw_spec(audio, len(audio))\n", + "IPython.display.Audio(data=audio, rate=samplerate)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAHwCAYAAABUjaU8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3wU1doH8N/ZTYckQAi9hN5EqnSki4Dl2pWrXr12r+W1XuzlXpGrXrteFLFj7wqi0ntHeicBAoQSIAkJKZs97x+zszu7O9tnSza/7+eDbpmdOWkz85zznOcIKSWIiIiIiIjIGKZoN4CIiIiIiCieMMgiIiIiIiIyEIMsIiIiIiIiAzHIIiIiIiIiMhCDLCIiIiIiIgMxyCIiIiIiIjIQgywiIqIYIIT4txDiuBCiINptISKi0Aiuk0VEROEmhMgD0BhANYDTAGYDuEtKeTqa7YoVQoiWAHYCaC2lPBrt9hARUWg4kkVERJFyoZSyLoCeAHoBeCTK7YklrQEUMsAiIooPDLKIiCiipJQFAH6DEmwBAIQQE4QQ64UQxUKIA0KIpzXvfSSEeMD2uLkQQgoh7rQ9by+EOCGEEK7HEULsE0L0sT2+1va5rrbnNwshfrA97ieEWC6EOCWEOCyEeFMIkWR7b6oQ4iWX/f4ohLjf9riZEOJbIcQxIUSuEOIeT1+3ECJTCPGxbdt9QojHhRAmIcRoAH8AaCaEOC2E+DCY7ysREcUOBllERBRRQogWAMYB2K15uRTA9QDqAZgA4A4hxF9s7y0EMNz2eBiAvbb/A8C5ABZL/dx37efO1fncQtvjagD3AWgIYCCAUQDutL33GYCr1CBOCFEfwHkAvhBCmAD8DGADgOa2z/2fEGKshy/9DQCZANra2nE9gBullHNs349DUsq6UsobPHyeiIhqCAZZREQUKT8IIUoAHABwFMBT6htSygVSyk1SSquUciOAz+EIiBYCGGoLas4F8AKAwbb3hsERLLlaqNnHUADPa57bPyelXCulXCGltEgp8wC8o9luMQBp+zwAXA5guZTyEIBzAGRLKZ+VUlZKKfcCmAbgateGCCHMAK4C8IiUssR2nP8CuM7bN4yIiGomBllERBQpf5FSpkMZXeoMZeQIACCE6C+EmG9LpSsCcLv6vpRyD5RiGT2hBDu/ADgkhOgE30HWUCFEEwBmAF8CGCyEyIEyovSn7dgdhRC/CCEKhBDFACZrji0BfAHgGts+JwKYYXvcGkqK3yn1H4BHoRT4cNUQQBKAfZrX9kEZASMiojjDIIuIiCJKSrkQwIcAtHOdPgPwE4CWUspMAFMBaOdZLYQyipQkpTxoe349gPqwBUs6x9kNoAzAPQAWSSlLABQAuBXAEiml1bbp/wBsB9BBSpkBJVDSHvtzAJcLIVoD6A/gW9vrBwDkSinraf6lSynH6zTnOIAqKIGZqhWAg3ptJyKimo1BFhERRcOrAMYIIdTiF+kATkgpy4UQ/aCMGGktBHAXgEW25wsA3A0lWKr2chz1c+po1wKX5+qxiwGcFkJ0BnCHdgdSyvUAjgF4D8BvUspTtrdWASgWQvxTCJEqhDALIc4SQpzj2ghbG78C8JwQIt0WsN0P4FMvbSciohqKQRYREUWclPIYgI8BPGF76U4Az9rmbD0JJSDRWgglGFKDrCUA0jTPPXH9nOtzAHgQSlBXAmVO1Zc6+/kcwGgoI27q11AN4EIoaYy5UEar3oOSiqjnbigFPvba2v8ZgPd9tJ+IiGogLkZMRERERERkII5kERERERERGYhBFhERERERkYEYZBERERERERmIQRYREREREZGBGGQREREREREZKCHaDYi0hg0bypycnGg3g4iIiIiIYtTatWuPSymzg/18rQuycnJysGbNmmg3g4iIiIiIYpQQYl8on2e6IBERERERkYEYZBERERERERmIQRYREREREZGBGGQREREREREZiEEWERERERGRgRhkERERERERGYhBFhERERERRdyJ0kqMe20x9heWRbsphmOQRUREREREEffLxkPYdrgY0xbvjXZTDMcgi4iIiIiIyEAMsoiIiIiIiAzEIIuIiIiIiCJOymi3IHwYZBERERERUdQIEe0WGI9BFhERERERkYEYZBERERERUcTJOM4XZJBFRERERERkIAZZREREREQUcSIeJ2PZMMgiIiIiIqKIY7ogERERERFRGMTjeFZCtBtARERERES1RzyPYKk4kkVERERERBHT5pFZePaXrdFuRlgxyCIiIiIiooj6YGke4nk8i0EWERERERFFTTxWGWSQRUREREREUROPc7QYZBERERERUUTEY0Clh0EWERERERGF1TM/b8G/PBS7YLogERERERFRgD5YmofpS3Kj3YyIYZBFREREREQRUUuyBRlkERERERFR5MVzwMUgi4iIiIiIyEAMsoiIiIiIiAzEIIuIiIiIiCIijjMEnTDIIiIiIiIiMlBMB1lCiPOFEDuEELuFEJN03v+rEGKj7d8yIUSPaLSTiIiIiIhIFbNBlhDCDOAtAOMAdAVwjRCiq8tmuQCGSSnPBvAvAO9GtpVERERERBSMeE4djNkgC0A/ALullHullJUAvgBwsXYDKeUyKeVJ29MVAFpEuI1ERERERGQjpcSnK/ahrNKC0goLNh8scnvflRCRal3kJES7AV40B3BA8zwfQH8v298E4NewtoiIiIiIiDxasPMYHv9hM7YdLsbBU2ewYMcxbH12bLSbFXGxHGTpxbS6o4pCiBFQgqwhHt6/FcCtANCqVSuj2kdERERERBplFdUAgJNllVi3T0k4q7LEc2KgvlhOF8wH0FLzvAWAQ64bCSHOBvAegIullIV6O5JSviul7Cul7JudnR2WxhIRERERkXfacEsvdTBexHKQtRpAByFEGyFEEoCrAfyk3UAI0QrAdwCuk1LujEIbiYiIiIjIRmrCqPgNoXyL2XRBKaVFCHEXgN8AmAG8L6XcIoS43fb+VABPAsgC8LZQZsxZpJR9o9VmIiIiIiIChHbmj4fCFiIeK17YxGyQBQBSylkAZrm8NlXz+GYAN0e6XURERERE5Jn0YxyL6YJERCGwWiWW7Tke7WYQERFRmLw+dxd+2uBWPsGNXlwlPA111WAMsogo7KYvycXEaSsxb/uRaDeFiIiIwuDlP3bins/X258HEjj5M+pV0zDIIqKw23u8FABwuKg8yi0hIiKicIrjDMCAMMgiIiIiIiJjBZAByHRBIqIY8eeBU8iZNBNHijk6RkREFHMkdGu4x2NqoB4GWUQUUYdOnYGl2hryfj5cmgsAWLqbBTWIiIhiWRxXaveIQRZRLdJ/8hxcN32lofvMP1mGk6WVfm17vKQSg6bMw+RZ2w07vpTAzxsOGRK4ERERkUFqYWClxSCLqBY5UlyBxbuMHfkZ8p/5GDRlntdt1B6sk2VKMLZg59GQj6suYPjzxkO4+/P1mLY4N+R9EhERUXjVlsIYDLKIKGRnqqr92s6eLmDACVZdwLDwtBK4cW4WERFR9NWSGMonBllEFDHhqB5UG/O8iYiIKLYlRLsBRBT/1NQANSAKpZdrX2Eppi3ei6pqZS/VVvaZERERxQpt32dtvkIzyCKigBWdqcLWQ8UY2C4roM/ZswVDSMh++qctmL/jGBqlJwMAthwqBgD8svEQEs0CNw9ti8YZKUHvn4iIiIKnd4WvjUknTBckooDd8tEaXDNtBU5XWPza3siUvvIqpYrg0ZIKp9ePn67EtMW5ePDrDcYdjIiIiCgIDLKIKGDbC5TRI09l039YfxDbDhd7/Hww41iPfb8JOZNm2isUemKprs3JCURERNEVTL9qPM6vZrogEQVMLZ/uKevv/778EwDw3Z2DsPlgkeZz8Po5b2as3A8A2F5QEviHiYiIKCL0LvG1sfuTQRYRBczfHqdL314GAJjYv5Xtc7bgLIjTbVKCCZUWK7LTk3HMJVWQiIiIYpdTMQydW4B9haURa0ukMF2QiILmb6hkRBZAy/qpTvtq1SDNgL0SERGRkYK55s/ZdtTwdkQbgywiClioVQKD+ZhwGT4zm/RP4wdPnQmmSURERGSA2pgaqIfpgkQUMNeAxxf1hBvMnKxv1ubjuZlbcbKsCgBQaSu24SnA23+iLKC2ERERUeQEM2WgJmKQRURBC/Q0KWxjYIGMNj3xw2acqaq2Pz9TWR3UsYmIiCj84rBQYFCYLkhEAQvnCXRfYSnmbjvi9ro6Bys9RekbCmE9YyIiIqKw4kgWEQXN30BHLyhbtuc4Ekwm9GvTwOn1ES8tgFUCn98yAHO2HfGYVuAt3eDXTYdRLy0JA9tl+ddAIiIiIgMxyCKigNnnVgWYtKedyjVx2koAQN6UCQCAL1fvx8q9J2C17fK2T9aguNyCJLPrgLv3NboA4I4Z65z2TURERLFBe/2O56wUBllEFAR7lGWYf367yel5cbnFdgjlIFbbmTiQ4hmnKyw4WlyOttl1jWsoERERBSSOYymPOCeLiFBVbcWlby/F8j2Ffm2vV1zwZGklXpi9HdVWz6fSYOZyqbtTg6pA9nHNuysw8r8LgzgqERERUfAYZBERDp06g3X7T+HhbzcE9Lm3F+yxP372l614e8Ee/LHVvWhFKNRS7dJtJMt3v9img0WGtoWIiIiME+CKMDUKgywigkn4nuek58NlefbHlRZl/aoq2zpWWqGcRNWRLKt9JCu8Z+Qlu47DqhmN23WkBP/8ZiNyJs0M63HjhZQSv246rPt7QEREtZPTPCwPrxfZ1sOMFwyyiCjgRYL1whyTSXnVqrMT9SVTCNGWa5GNcOR3z9l6BNdOX4npS3Ltr415ZRG+XHMAgJISSe6qrRL/98V6bD5YhD+2HsEdM9bhzXm7o90sIiKqQZ74cXO0m2AoBllEBCE8B0j627u/ZouxvO7DiBEt14CwbcM6we/UptJiRf7JMhwuLgcA5BWW6m7H0Rl9+SfL8MOfh3DnjHUotAWiBUXlUW4VERFFVYC9oaUVlvC0I0oYZBGRXwGSll7KntkW/ejFIcdKKgAAe4/rBy/+8GcOVrAe/X4Thvxnftyd4KMpnvPsiYhIUVBUjiW7jvve0Klse+2oNcggi6gWKDpThcLTFR7fF36sPeWLPV1Qp7rg77ZiGDM3HnZ772RpJXL9CL5c2xboGl3eLNhxFABwprI6oM+dKK1EzqSZ+HZtvmFtqelqybWTiIgAXPDGElw7faX+m7W8s43rZBHVAuc8N8demEKPyYBlrwIdDVONenkhTvgx1ykW793V4PDTlftwWZ8WUW5N9DhPaHauAklERPHruJcOXH8u3EZ2mMYajmQR1QLeAiwAjrWFQ5qTpc7rCqRl8CvAUvarlnKH0/+jaXXeCQCBf83xSgjtz4VRFhERKbTBVN7xMsfrcXz9DDnIEkKkCSGeEEJMsz3vIIS4IPSmAUKI84UQO4QQu4UQk3Te7yyEWC6EqBBCPGjEMYlqo0BLuHurLlgdpjOmaxqi/WkY7uVnrNyPE6WVOFWmHwCeLK3EgRNlmPLrdgDA6fL4KjsbLCkdHZdCANsLitHvuTneezqJiCg+ebg+f7fekWIfz52URoxkfQCgAsBA2/N8AP8OdadCCDOAtwCMA9AVwDVCiK4um50AcA+Al0I9HlFtZgq4uqD7mTPc4xa+WnZ2i0wAQLdmGX7tr8JSjZxJM/HG3F267z/542YMnjJP971zX5iPoS/M9+s4tcmxkgp7pC4AvLtoL46WVGDBjmPRbRgRUQ1TYan2nYUS6zxcuLW3Gv+ZvT0ybYkCI4KsdlLKFwBUAYCU8gyMud/qB2C3lHKvlLISwBcALtZuIKU8KqVcrR6biIKj/sHGco+Se/znuJnXSkrw77RWVqEUuZi+NFf3/V82Hkaph0IYJS5VCGP42xZRZ6oc368ZK/ejoqbfIBARRZCU0p623+nx2eg/eU6UW2ScWL6/CBcjgqxKIUQqbPcZQoh2UEa2QtUcwAHN83zbawETQtwqhFgjhFhz7Bh7VIlcqec+b3OypJR4/tdtOHCizOM24aS2Tc3rdqyb5XsUrtigdL5nft5qyH7ixarcEzha4rwelvanoFdNkoiI9D3z81a0eWSW/fnJsho+hqDpBX3w6w32xyzh7r+nAMwG0FIIMQPAXAAPG7BfvdGwoH4qUsp3pZR9pZR9s7OzQ2wWUfxS/8CumLoMz8/a5vTe9oISvLNwL+6YsdbrZ8PFtRdMSv2RLD3qqFWoZm7SDxpKymvn+lpXvrMcF7+51Ok1S7X+b4K2hzYanpu5FR96GLUkotrrgjcW45PledFuBgDgw2V5uq9/vmp/2Bd4f27mVox4aYGxO9Wc8udtP2p/XFtGtUIOsqSUfwC4FMANAD4H0FdKuSDU/UIZuWqped4CwCED9ktEHqj3wKvzTuKdRXud3lNHik6VVelWF1y6W1mM0Nt6XKFwLajheo6OZseYuthybXTY5cLvaUHnV/7YiTaPzEKFxZiAN1DTFufiaY5EEpGLzQeL8cSPW6LdDI8KT1fgke824W/vrwrrcaYtzvVrzUojxHPZdq2ggywhRG/1H4DWAA5DCYJa2V4L1WoAHYQQbYQQSQCuBvCTAfslohDknzyjG2TtK1TSCF+do19IImQupdvVaoOulRH1gq1IrNn025aC8B8kBliqrV4nY1dV67/30fJ9AIwbVSQiilfaUf9q27XuhIdqt7FONy2tdsRYIY1k/df27y0AKwG8C2Ca7fHroTZMSmkBcBeA3wBsA/CVlHKLEOJ2IcTtACCEaCKEyAdwP4DHhRD5Qgj/SosRkZtYzpN27fkKpKmRWLFpy6HiCBwl+jo+/is6Pv6rx/dfn7fb7bXPV+2H2RRYBUsionBYtPMYcibNxEk/12gMt0qLFS/M3u6UBeC8wLszT9kCsUrvjF9brgIJwX5QSjkCAIQQXwC4VUq5yfb8LACGrFklpZwFYJbLa1M1jwugpBESUQgCDa5EFBaadc3hVm/W1VGqSJ20V+WeiNCRYpNeLr2v7/3afSfRsG4SgPCto0ZE5I93banwWw4VY0iHhlFuDfDF6v14e8Eep3Orp7Pkb1sKcNsna/HDPwajZ8t6EWlfSDzcKni6DMzVzNuKB0YUvuisBlgAIKXcDKCnAfslIrJzVBdUGHWzfqqsCsdPVzrt25sr31luyHFrGxHggtdEROGgdszFyqi6mn6tna/qqeNzyS5l7vPG/FNOr1utEhYPqdpRJT3FWbHxvQ83I4KsbUKI94QQw4UQw4QQ06Ck9xFRDFu2+zhyJs3EnmOnkX/yTLSb45P7SJbzc9cgzEnkB97IhUkdcawd11YiinESsZEiL3QmDeu1SsBzwYi7P1+P9o95TuMO1P1f/YlpLsWvgqXX4s9XHdB5Nf4YEWTdCGALgHsB/B+ArbbXiCiG/bRBKda5KvcELnlbKcPtafHdWGQv4e5PVYsIXEcLT1dgy6Gi8B8oCk6WVmL30dMh7UMtUBKP6YJWa3TL0xOR/xyj6tKts85SbUVZZfTnPPk6nQgAszYdxj8+WwfA8/Iiwfpu3UE8N8uA8ZJa3sFpRAn3cinlK1LKS2z/XpFShreYPxHZSSmx+aDzzf2eY6dxykclooOnlNGrr9ccCHjNikhU6/NFrbjkT1P0vrzbPnVf7+v9JcGvozRj5X5MeH0JLnl7Kd5e4F78oSYb//pijH55ocf3/fkZqEHW0t3Ho75mlpGqqq1o++gs/Gf2Dt33l+w6zkWZiWKIdlTdNWXwtk/WouuTv0WhVa7FLnyfH++csS72zy0e0wVrh5CDLCFErhBir+s/IxpHRL69+NsOXPDGEvyw/iAApVd91H8Xouezf3j9nDoysW7/Ka/bxSr3dEHP25aUW3DNuyuQp1kDRK+AxWkDqjat338KL3i44a6pXNfCcjXbj/L1JtvV5uFvNuKWj9egzSOzvH+ghlBL1n+4TD9Av3b6SntvMxFFn3rTb5XS3lmnikbhBV8lzvWubTWlmu2KvYUoqWHVEI1kRLpgXwDn2P4NhVK+/VMD9ktEfii0FW04blsEuKzKkfL31ZoDOHCizPBjRrNnylMw5a3nb972I1i+txAPfr0hTK0KzNGS8ticpBykKb9u97mNSTP8OWdb6Dcy5VXV+GzlfkgpMW/7EYx4aYHb+l1Ldh3Hsj3HQz6WN+rXZY2fHydRrRFrA+reskS0732xumbMaSqMkTL50WJEumCh5t9BKeWrAEYa0DYi8kNGqrISg9ojV6bpNXr4m424KsBqeCv3Fjo9v/mjNfhi1X6n12LpuqS2Rbo9cNiQr6RTrtl3MjKNgvtI2Y6CEny95gBOV1jQ77m5eOqnLRFrSyzwdO+wbM9xzN7s/0LOOwpKYLVKvDpnFx79fhNmbSrAEz9sQe7xUhwpdh5xu3b6SkyctjKEVusrOlOFNXnKz1f9dYvHuWZE8Ug7jzdWKgy60jZr4U6lU+pIcYVuUHjddOPPcaHadrhmjLSFmxHpgr01//raFgpON6BtROSHRLPyZ6ymLbkWrzjkIdXL07XlqndX2B8fKS7HnG1HMOm7TTHU4+e6KLHzc735ZdXVkW/8le8sd7rQjH11ER76ZqM9CP5ty5GItylUocyj8lSgZOK0lbhdZ36cnvX7T2Lsq4vw3pK99pHbUpdJ6j/+edDnTceMlfvw/fp8v46p5/L/LcPlU5ejwlJtb4dr2hERxSbteSxWgyytf/3iKECx80iJ2/uLd4V3tD4Yby/YE+0mxISgFyPW+K/msQVALoArDdgvEflBDbJKKix4+fcdGN21sc/PvL8kF2eqfFcSPFOpXbfD8Xo00wXVNa080Usb1L42bdFeDGibZXi79JzUKz5Sg2cBa+OIy/+3LKDPGvFl77elvm4+WIwEs7Dv11FpErj3iz997uex7zcDAC7p5f9a9uVV1TAJgaQEE3bZ5jOuyj1hD7KIKHb9sfUI6iSbMaid8+LDsZrmW+khnfzACe/LrZworUSDOknhaBIFwYg5WTdJKUfY/o2RUt4KoHYnYRJFUFKC8mf83uJcvD5vt18V8p79ZSuKzlSFu2kRsb1A6dnzki3o9Npzs7bhwjeXhL9hnsRYx2lZpQWvz90FS7UV5VXVmLPVvxG2QFMvy0JYHuCPrUdQeLrC3ussBLDJlgKq7Szwq5x/kDo/MRvnveJcYdEq3X/fSisseH9JLqxhGtl6Z+EerM5zL9pSabHq9nITEXDLx2vsqcOxli6od9rqP3mO/bF25M3XKa73v7wXvKLIMiLI+sbP14goDBJtPfpqulJJuXGVfKTT4+hfjLxRL0S+KuHVVtVWiSW7jsNqldhyqAgdHpuFw0Vn8NqcXXj5j534dl0+np+1DTd/vAZr953AJyv2IWfSTKc0uKkLg08BKSgO7udyusKCWz5egyveWW4PaExCoEX9VABAZmpi0G0KVF6hcxGZBJNwC7Imz9qGZ3/ZGlSVsvKqalz1znKv6609/+t2XDF1OQ6eOoM9x07j3i/WY9K3G/H0z1tw3iuLUMDffyK/xUKQpae8yjGSFc7OIyPFy7IcRgo6XVAI0RlANwCZQohLNW9lAEgJtWFE5B+zybmvxFOaQTCW7o69XG9f9Kr2VcVSJT9/1k6WElICJpPAnK1H8NgPm7Do4RFITjAHfdiv1xzApO82Yfrf+mLu9qOoqpaYt/2ovWx9pcWKfbZ0vKIzVZg8U5kHUK4ZKXrxt8iXpt9jS83be6zUKaCpk2xEtrsykldlkchMCzxYM5uEW9fDWtsIXzC/cxvzi7Ay9wSe/mkLvr59kNdtB0+Z5/S8UXoyAKC4vApNMnkJJvJHLBWs+WTFPt3XIx28BJvlEkPfypgRykhWJwAXAKgH4ELNv94Abgm9aUTkD9e0pAqLcQGFdt0o54USY4/aJt3CF7HYYC/fxf8t3IO2j85CSXkVnv55C44UV+BIUeBzf6SU9pv+DfnKemgFxeVIsK3GaanWjE8Kx6iMgHAs2BnwUf13xo8UQpNOL+6KvYX2dgkhNKmigbf23BcWoMezvwf8OQBoWDfJ7Zhq+qoliHRBdV/7Ct2XXRjx0gLc9OFqj589WsK5YUSBkDrpvo73InfRUM9wnornuBazMsKWQ0U4XWFBcXkVZqzc5/T1Brvsi1GjgvFURCjoIEtK+aOU8kYAF0gpb9T8u0dKGdiMaCLy29SFezDsxfn25643c5EYtdG7CYw627fBojOTOdEUpXSLIK8Vn9tK5p8orfSZg+99Pwdw2f+W4fctBfaUE9froCOw0jRXOFJUwnnBG/If59GY3UdP28uwf7ZyPzYfLEKDusok7nppifb2HS4qt5d9v+fz9fb1sTbme06z8ySUwhWuaTzlVdVonZUGAPZ0Rm+klHhu5lZsPqi0W/361ICp2irxyHebsPvoaeQeL/UrBZG9yUT+8xQYqKe92ZsLnEbzo+1UWehzqautEhNeX4KbPlyNx77fjMe+34x1+0Nf3sSoU8/rc3cZtKfoCyVd8GEp5QsAJgohrnF9X0p5T0gtIyJd6sKv1VYJs0m4XSRcF2QNhfYGO9bv3dT2aXPZVeZoBVk6hId8QatVoqTC4jTHSLutv3Pilu05jonTVmLlo6Ow25Zqt/9EmX1PUkqXFjiKSdir9MExwTqcQZbrQpWjX1YKS+RNmYBHv98EAFg6SVl2McUlVVLbLnU/d85YZ38tEj3RUjr/XXR+YjZ6tKyHfYVlfgU7pZXVmLY4F+8tycWVfVpiZJdGTu/vKCjB56v2Y70BN0CAMjJdUVWNrLrJhuyPqCaaZ+usMJn0Mx8A5fyxKvckbv90LW4YlIOnL+oWwRZ65k9VYF822rIaVuaeQEaKEga8OW93yPs16pS76WDgnWWxKpR0QbVw/xoAa3X+EVEYldnWB7JUO26SAWODLO0cnEe+22TYfsMh93ipx/f0Us6iRQ2Wjp+udAoE/vvHDvR45neccin7rgZa/l7APrXl9btWoFO/B9rdPPXTFnuhhMe+32zPxX9ljqMnMdrVqtTvUUFxub2Eu3+fC1eLXA+kf2BPPeTnv7oI7y5yLiAiJfDlmgNuPbjqr20gX4u3YHzkS+kjWOwAACAASURBVAvQ599zPL5PVJtI6Z5ur7JK2M/F+Scjl7kRifOW9tpQbCuUNX/HMftrS4Kci21Ucax4KqARSrrgz7b/f6T3z7gmEpEedcSm2pYep56XjCx8oVWTV3A3GVFHNRh6sZ3m+rFm30m0e3QWDpwowy8bDwMATpZVOa9JFuDcqATbF6vMt3Iv/fv2/D2o0txYaC+uarrdhgOnDK1SGQrt9yKQNJJQL9NFZ6rw4NcbnOYl6h3F9cZCfbbn6Gmnm4WcSTMxZ+sRbC8oweRZymi0682EdnTusv8tw75CpePgQAA3edrRz9+2FKCk3JFexHlbREC77DoAgJREs8fOkEhW04216oFqtkyg4ig2MkzQtx5CiJ+FED95+mdkI4nI3ZnKapRVWtyqIxk5khUvUhONqUQXMAm8MXeXU0+o9qf1xaoDqLZK/LalwGlulOp4aYXT8x//PIicSTNR6nLjv2DHUeRMmonDRWfsi/Rq5+YJ4bj1Ligux2cr94f+tUVIsJOpPc2j6Pec55GcdxftwaDn58JqlXh7wW58szYfnyzXr/gFAKNfXoTVec6pfGqgOum7TZg8a5vTe0/9tMVrm9WiGYBSpfD2T5X0x0DWGHv4mw3ImTQTecdLcdsna3HlOyv8/mw4HC464yNQJYqsemnKPE8pvaULOt6LtSAo3sVTrBbKncdLhrWCiAI26buNWLanELee29bpdQZZ7lKTojOUdcvHa1BaWY2Zmw7bX9PGDGoVJ206ozI3Snl86dvLkGMrpCClxFvzlbz5AyfL0LlJhv0zaiCw+aD+aOO/ftmKK/q0CP0LihDtCM83a/OD2ke3p37Tfd3baI46wlRuqcbhU0oa5eJdx3DH8HYeP/PLxkMe35u22HlhcNd7tXBMd9tgC/LUiezRHoEe+Pw8tM2ug3kPDI9qO4hUUpPS62nOqVJ5UHnPXMOCrPKqaqQkBr/cR7Dmbgt8bUA98TQiFkq64EL1H4DlAE4COAFgue01IgqjZXsKAQBFLtWGwpUuWJM1sPVcNq/nu+KbkdTSu9rJyto0lFW23HiT8Jyeovainq6wOKUCas3foVzcVuedsHcDPvTNRhw4cca+zddBBivRoL3vecOACdnBHP+nDUrwpP6deRLIkgn5Jx0/j5xJM/G8y0iXke7/aoNf220vKA7bHAi1E2HvsdKYqtBGtZt6fpHwPP9HQtq3i1q6eZB8VQoMVxATSqXWeBXyr44QYgKAPQBeB/AmgN1CiHGh7peI/HPCpVBCPPUCGUVNqezcJD0qx9f+TPR6ToXLGlVaatrfRW8u9VjOXd3lu4v2OqXXzdl2JPhGR5g2vdHoioZHbWXh/eWtYqfr2l6uf29tG9bx+zjaEc5oWLr7OM5/dTE+WxWe9NGhLziWmuj8xGwcLjrjZWui8Dv/1UWaNRWlj3RBtahUzRrJ2nrI++h1uG4RjFonK55uYYyIz/8LYISUcriUchiAEQBeMWC/ROQH12p08bSQn1HUkZ9ojfJpLz561yGTJkXQ9XquHf1Q37NKiW2HizH8xfluI5k//Ok5fS2W9XzGsSBwhcXYUY9+k+fqvr7ZQ6lg14pj2t+bLk/O9nqsfQFUQPRU2cxoV05djr3HTru9vtdWkXOLj5uyYOgdb7mPUUGicNteUOIYvZKer5dKAOZY0iKcjI7h1LRyQBkxdy1kYUQsJKXEHpe/cbV4kxH7jhdGBFlHpZTafI69AIxJzCQin064rDWktxhvbffOor0AgF1H3G/8IkEbKOld1L9em2//uX2wNM/jRUY7yvX63F3IKywLutxurCnVjBB1f/p3L1sa54I3lui+bpVAr1b17M8PnvR/BCaQTo7SAApahGJV3gm89LtjOYbFu45h9uYCzdppxh/zQp3vra/USyKjHCkut6fjunZEqr/v2kDKlYSjc0ydM7spvwirck/obh+KQArbBGPqwj2+NwrQJyv2YdR/FzqlJq7dZ8x6fvHEiJJbW4QQswB8BeX38goAq4UQlwKAlPI7A45BVOs9/sMm1E1OdHvd9QRdVR0/vUBGKwgwbSwc9C7qakU6AHh/aa7b+yq1/cqkbOW1GpbJUiNUWyWGtG+I9fuVRTtv/nh1lFsUuh2ayoXXTV8FAHjukrNsrxh7zth9tEQ3gPxmbT4u7dUcX6w+gPk7juKcnAaYt/0obhycg/5tlMcvXN7D7XP7CkvRKD0FqUneJ/MXl1fhv7/twCPju0Rl4j+Fl5QS+SfPICnBhESzCQ3qKHNtS8qrYLUCmWmJqLZK7DxSgnGvLQagnFsfm9DFaT/qOVh7HnU7ltXxnrqW/YVvKh0HeVMmGPp1VRlcrOqkS3YDoIyad35yNi7r3RytGvif0uzJhgPKNWvPUeM7Lo1KO4wFRgRZKQCOABhme34MQAMAF0I5czPIIgrB0z9tQUZqIj5doT9vIpCJ9xR9wa5BAgDHbJXxtBchbYBGxnAdSTxSVPMndO855r5Y91drlGIo2o6abYeL8dSPW/DR3/v5DGo8eW+x546Cie+ttD+et11JevlgaR4+WJoHQKlQtubx0U7zYIa9uACD22dhxs0DPO63vKoaZ9tGQHMLy/Dx3/sF1fZok1KiuNyCU2WVmL/9KIZ2zEa77LpO26zffxKXvL3M6bVvbh+IvjkNItnUiHt7wR68+JtjRFYNdno9+wcsVom8KRPwxrxdeFWzmPryvYV4wKUIjLbwhbd1shyFL8LbkxXu/QPAK3N2otJixeerDqB780y/P3f8dAVGvLQA71zbB4PaN7S/rmZeaFMTjRJHMVboQZaU8kYjGkJE+j5cluf1fZZs91+S2RT16ou/bzWmGIVajTAcqSC1XbWUThf6aP/OhMuGA8pI3Y9/HsKLl/eA2STwzM9bsCrvBNbvP+l0U+Wv0xUWfLH6QNBtKiytxP1fbcArV/UE4JjEv3R3ITblF6F7C+UGsbyqGiv2FmJw+4ZINJvw9RrHMRftPIbjpyvQsG5y0O2IJCklvl9/0K+KkLed29ae/qx1+dTluHdUB/zf6A41rlCDLxWWalz1zgr8aft9VX2yPA8//HkIFk2K7iadTqcdR0qcnqudKJsOFiE73fE78ua8XZpt3NMFa5KcSTPxwmVn259ry6tv8jAXVc+1761ESbkFr87d5XQ+UNdqzCv0fw6qvxhkaQgh2gC4G0COdn9SyotC3TcR+cbSyP6Ll5vlS95ehkHtsqLdjLhVG2vHdHz8VzTJSEFSgjJVuzzI4iOeiokE4vv1B/HX/q3QN6cBxr++2P76I99vxC93DwWgVCsElKDjwbGd8MSPzgs9f7g0Dw+O7RRyW8JNSolxry12WojaG70AS/Xa3F14be4uzHtgGNo0rBMXwZbVKtHpcf1iM64/cwD2xdi9Ub/Xr8/d5fT6S7/vtD8uOlOFCtu11ciBptIKC8wmgZREM+6csRazNhWgU+PwVL19+NuN9sfBVvZ0/b18a/5ujO3WOKyBJ9MFnf0AYDqAnwHExx0MUQ1iqY13hITle1lEwEhP/+S4YYtU1b9Yo52zePsn67DzucBXY7n63RWGtOXyqctxw6Acp9c2HyxGUVkVev3LURjlnUV7dQOPN+fvxhV9W6B1Vh1Yqq0oKC5Hi/pphrTNSLM3F/gdYPlr5H+VpUrvHtke/ze6I8wRSEczWnlVNeZvP4o7Zqzz+zMfLs3F2n2nfG/oh+EvLbA/NjKgUBdJf/7S7pi1qQCA+0hbOOjN0wrEqtwT+MtbS/HngVN46fcd6Nu6vkEtcxdPZ18jgqxyKeXrBuyHiIj8FEedfTFBm5ZrsUqPi0PXFpXVVtz4wSr8Y0R7VFqsmLFqP968pldER0f0UqUnvrfC75HGYS8ucHreJCMFKx4dFXrDDFJhqQ4oiAjUG/N24415u4Mu1KBWyvQWpFmqrXhu1jbsPFKCtKQE3Dg4B4PaNcS87Ufw9w/XAAC6Ns3ALee2QUFRBf4zW5mTOv1vfTGqS2OP+7186jJsPhjY0gJP/7w1oO39JYTzOn5GeOS7TYbuLxLUdE0pgdV54askGE8l3EWoX4wQYiKADgB+B2CfHSylDN+ZIwR9+/aVa9asiXYziPxitUq0fXRWtJtBVOsMbJvF0UIXO/59PpITPBfDqLRY0fHxXyPYosA1zUzB23/tjfSURDSrl4K0JCP6moPT7tFZEVnXMDnBhFWPjkZmWiJKyqvsSyR8e8cg9NGMSBSXV6H3s39g+g3noHm9FIx+eRHqpSXizuHtsHR3IW4e2gaHTp3BP781NkD4/JYBOCenPk6UVuLUmSqc98oiQ/cfDq9e1RN/6dU84M/lTJoZhtbEl76t6+ObOwZFuxkAACHEWill32A/b8TZpTuA6wCMhCNdUNqeE1GQjpVU1Mg0D6J4sCKXAZar8kqr1yDrgjcWe3wvVhwuKneqzPfzXUNgNgm0za4T0bLv83ccjdjC8RUWK3o8+zu+vHUArtKkc172v2V4+6+9Me6sJgCAV//YBYtV4uXfd2CDrYDEqbIqTJ6ljD4t3HksLO27ZpoxKaaR9Pyv2wIOsoweDYtX8TOOZUyQdQmAtlLKSp9bEpHfznluDprXS412M4hqpSSzicsjuKiwVANQ1iJqZxthz31+PIQQqLRYsTNKi32HQl37aGy3xnj5yp544ofN+G79Qfv7H954DiSAWz5aAyGAadf3xfBOjUI6ptUqceMHkV977Sqd+XJ32tIVL+7ZDD/+eQgA7AEWeVZpseLF37bjnlEdUHSmCgICL/+xA4+O74L0FPf1LAHHEhzkHQtfONsAoB6Ao742DJQQ4nwArwEwA3hPSjnF5X1he388gDIAN8RqmqKe8qpqfLM2H+d1a4zcY6V4d9Fe3DemIwqKyjG6qyNX2WqVWH/gJJrVS0VGSiLqJEcvvYEiQ514f/BUcBWBiCg0DLDcfbH6ABbsOIp1+x3FBXYdPY2OjdNjPk3Ql9+2HLEXJdC6wSUYUp8P65iN16/uhcw0/Rtqb656d3lwjQwjNcAi/5wsq8Jb8/fgrfnKEhpjujbGH1uPoE/rBri8TwtMW7QX/do0wI6CEvRv2wCts+rgyR83R7nVFGlGzMlaAOBsAKvhmJMlpZQXh7hfM4CdAMYAyLft/xop5VbNNuOhlI8fD6A/gNeklP297TeW5mQFm5u78KHhqJeWhIyUBAghcLrCgtREM1PL4gRztomoJsmbMqFWn7eSEkx46YoeGNYh22fQNXfbEdz0UWzcg1DktGlYB7nH3RcEJ3c9W9bDD/8YHO1mAIiNOVlPadsDYAiAawzYbz8Au6WUewFACPEFgIsBaMvHXAzgY6lEiiuEEPWEEE2llIcNOH7Mcq2Y5Gpi/1bIO16KZXsKcffI9shISURltRUD2mZh15ESXNK7OcorrbBYrUgwm5CWZEai2QQpZVysqxGLft10GDkN66B9o7pIMAkUllYiOcGEaqtEZbUVc7cdRa9W9dC5SUa0m0pEFJDaHGABSurYPZ+vd3v9+oGtUVVtxXndmiDBJPDqnF1Yuy98VdkodjHA8l88VRcMOciSUi4UQvQEMBHAlQByAUwNdb8AmgPQLhufD2W0ytc2zQHEfJAVzgmvn63cb3/8xrzdbu9PilDp0Et7NYeE8gej/F/JtZUAIAEJCSmV1y1WCbMJEAhPkCeE8s9qBaqlhEk4jqW2qaraav+5JKsLclZZcaaqGtVWifppiUhJNONkWSXW7TsVloVtP7mpn+H7JCKiyPt4+T4AwOerDvjYkohU8RNihRBkCSE6ArgayqhVIYAvoaQfjjCobXp3267fe3+2gRDiVgC3AkCrVq1Cb5kB9p8oi3YTwm5V3gkluIGAEMqCfgIAhPKDE7bn6nvh7LxQJ1IKAZhNJqfFRtXBu0SzCWaT0tbC01ZIACmJJpRXWXGspBxllUmQEshITQxLgAUA101fFZb9EhEREcU6Fr5QbAewGMCFUsrdACCEuM+QVinyAbTUPG8BwHVmpj/bQEr5LoB3AWVOloFtDFqkq8yM794ERWeq0L9NFlrUT8V36w7i5qFtcLrCgj6t68NsEqiqlmheLxVllRYkJ5hhsSrleplG6JnVKm2jZMr3R9qDOWF//6PlebikV3NkpiZCCIHZmwvQsXFdfLUmH4lmgbHdmuDY6YqoVJsiIqLwurBHM5yTUx9P/rgl2k0hoggKuvCFEOISKCNZgwDMBvAFlAqAbQxpmBAJUApfjAJwEErhi4lSyi2abSYAuAuOwhevSym95lvFSuGLskoLuj7pXsnIH89e3A15x8vw/tJcZKQkoLjcgot6NMOzF3fDN2vzcdOQNjhSXIHUJDPSkxNwvLQCjdJTDP4KyGiVFiuSbGmKu4+exg/rD+LN+e7pnkREFFv6t2mAj/7eDyYh7OdxPS/+tt1ekY5qrlGdGyE7PRlfrD6A87s1wTX9W+Fv7zMTxQjdmmVg5j1Do90MAFEsfCGl/B7A90KIOgD+AuA+AI2FEP8D8L2U8vdg923bv0UIcReA36CUcH9fSrlFCHG77f2pAGZBCbB2QynhfmMox4yktKQETL22D27/dC3O7ZiN3UdK0Kt1fdw5vB0mvL4Eky/pjke/V+ZOqY8/uOEcDOuYDZNJoKraij6t62N89yZOo0w3D20LAGiS6QiqGGDVDNoLc/tGdTGgbRaDLCKKCZ2bpGN7QYnTa7ueG4fpS3JRUFSOD5flRadhUXJ2i0x8eGM/ZKQkIMHsOahy9dDYzgyy4sD0G87B2wuU63O9tEQM65htf2/v5PFoa1tH7r7RHZGWZMZbC3bjVFlVVNpa08RRtqAhhS9KAcwAMEMI0QDAFQAmAQgpyLLtexaUQEr72lTNYwngH6EeJ1oaZSQDAM5pXR8f/90xALfx6fOQkZKIHi0zYamW6NGyHkZ0zkbTTMfCtIlmEyac3TTibabISU0yR7sJREQAgAydBVYTzSbcPqwdAOD2Ye1QVW3F0BfmR7ppIWmUnoyjLun7M27uj2/X5eO7dcqixE0yUvDpzf3QvlG6Ice8a0R7dqDFgZQE/Wu0ySSw6KERKDpThe4tMgEAt5zbFue/usito4LcxVGMZUgJdzsp5QkA79j+kQ+9W9XHj/8YjO7NM51eVy9m3Zo5XtcGWFQ7pDHIIqIY8eIVZ+OdRXvRo0Um/vmte4VabfZETZH7/HhUWKwoLK1E83qpKC6vQp2kBJhNAoPbN8TLV/YMy3HvGhn5IKt5vVRc1rs5XrdVHP7prsG46M2lTtusenQULpu6DB/e2A/fr6vZ6errnxiDXv/6w7D9Tbm0O44UV+CVOTvt1YeTE91HMJvXU+7VWmWlub1376gOuGPGOsPaFGmZqYkoOhP+0TiWcCfD9GhZL9pNoBjFIIuIYkXrrDqYfEl3SCl1g6xIu2lIG0xfkhvSPoQQSEk022+M9UbrwiEl0YyuTTOw9XBxRI639vHRyKqrZM7cf14n++t5Uybgke824vNVB/Da1T3RKCMFix8eCQB4cGwnfLM2HwXF5QCUgLTNI0pi0Z3D22Foh2x8unIfZm4MbcWcdtl18NIVPdC5SQY25J/C1kPFePaXrb4/6IPZ7JhG0ad1fSSYBFbmngh6f52bZiA73XnE03XJmcUPj/D6OzSue83OPvr5riG44I3FKC63hPU48TTaxyCLKEYxXZCoZmnfqC52Hz0d7WaElRBKKlSdZP3z078u7oYnQqyipxdA/X7fuai0WHHBG0vw+jW9cFGPZhjQNgu3fOy7kNXjE7rgb4NysKOgBKfKqtA2uw4qLOFZhsNfH954DvpNnhvWY7x8ZQ9c2ruF122ev/RsPH/p2brv/X7/uSitsKBeahKEEPjl7iFolJFsn+c9sF0Wru1fiJs+Wo2FD41AdnoyDp06g8NFZ9CndQMAgKXaihd+24F3F+0FAFzcsxkm9muF7i0ykZbkfAs6oG0WBrTNwg2DcnDnjHWYvaUgoK/3tmFt8c5C5ThmzVz1L24dgOdmbgs4yNL+HiYnmJBom3un/u7YVv20LwPTsoH76FU8WPzwCOw+dhqtstJwTf9WeGfhXvzz/M74z+zt0W5azGOQRRSj0pMj06tKNdO4s5rg182B3YSQZ/eP6YiX/9gZ0j4yU2vH36xeKpTKiESfJy7o6hZkdWyszIfKmzLB/trZLZxT7fVc0aeFvSDUWc19bx8pjTJSkJ2eHLblXP6471x0aBzaHLKMlESnkRm979/AdlnY+uz59ufN6qWiWT3H9IYEswmPju+CR8d38fu4JpPA1Ov64I5P1/p9jhvfvYlTW80mR5BlDnIJGu3vYVKCye13u9rqvGRLrOnTuj7W7jsJQClc89iELvh4+T78sfVIQPtp2SDNHkBaqpWvOYBaL7Uav01EMUo7ktWvTQPUS6sdN3Dkn1eu6ok/nxyDHf8+3/fG5FPRmSqsfmw0gOCDpaQ4ufOobzvXzP6/obj6nJb48R+DI96GxQ+PsD9uaEt1c1U/Lcnnfp67pLthbTLanPuHGb7P167uib2Tx4ccYMWC/13bBxueOs/ndn8f3AZv/7WP01webZBlMoUeBCUnmGC1OodZIzs3QpLZhIn9Wvm9n7tHtgcAfHDDOSG3yZdnLupmf5xVNwlDO2TjlasCm2d4mctIqPotdk2VJH3xcUUginNf3TYQfz7p+2JDtUPzeqlISTSjXloSkhPM+Pr2gdFuUo23Ju8EUmwT2esEmaqrNxG+Jvr81gH48tYB6NwkA1MuOzugucNGzWtq2SANuc+Px5ZnxmLN46N1t0lKMLkFKnlTJmDv5PH47s5B2Dt5vNc1q6ItMzURd41o73WbOfefi/O7NfH4/qtX9cTu58Yhb8oE5E2ZgIt7NjckqIgVmamJ+OQmz8ufXtOvJZ68sCsAYKzm++Q6euWpmMK//nKW/XFKogkf2So9d3IJUpMSTPaRqz6t6wMAWtRPw87nxgU0QvrAeZ2QN2UCRnRuhPVPjMF5XRv7/dlAZNVJshfoAICW9ZWRqEB/NZrVcy5o0za7jrK/BizG5g+mCxLFMG1qjDcmAVjjpyAP+eB6w3BOToMotSR+7DhSgvSURDwyrjPGdG2Mmz5ag9zjpQHto6aOZDWsm4yTZZX2m8jM1ER0bpIR1L5CDWpuGdrG/lgIgTrJ3m9T2jeqi09v6o9rp6/Ei5crc4tMJoHereqH1I5IeXBsJ90qfs9c1A1X92uJ5AQzpl7XB9VWiYLicpgEkJxgRkqiyW1OU7wa2iEbH/+9H663LfY79do+2HPsNCosVtx2blv7dtrRO9dAUz1jPjCmIwa0y8IVU5cDAK4b0BpP/LAZgJLqqH7MNQMw2WxGg7rKyGm/Nsacb+vXScK71/fFkP/MQ/7JM4bsU7V00kgcOFHm9nqgvzOuMdlf+7dCh0Z1DfsexLva8RdKFKeSzCZUVluRlGBCeVV0J3KTf/KmTEDOpJlBfVaI+Fqo0VWkSgSrzu2YjUU7jzm9dptt3af5Dw4P+OeUGMOjJt6sfHQUAKCdbQHVxAgEi22z62DvMfcg9p5RHQLe15AODf3ukIpFeyePxzM/b8GeY6Xo0TITo7o0dgsSzSZhr4JYG53bMRtbnx2L/JNn7PPzgpGUYHL7fMO6yTh+ugJPX9gNJlt05TrPKjnRhN6t6uOzW/rXiE6tlETn0XhtZ0W/nAZYlednERCX74MQAv3bZoXcPm/SfXSs1CTx85UQ1ULpKQkoLK1EcoKZQVaMm3nPEI83r09e0BXtGtXF32w9tZ7Y8+E9TLSe2L8VOjVOx1M/hVbdLVpaNUjDpoNFETveJb2a2YOstg3rhry/iqrqgLYf2qEhFu86HvJxQ6XOX1n3xBis2FvocQ6UPwa2zUK9tEScKvMeLM+4uT8ufnMpTpZVoqra0XPgenNYG5hMAs9cfJbvDWu5tKQEnwFW9+aZOP8s9/RK9dxpEsJjylydZLO9cqDrJuoo9aB2DQNqczRp53U/cF5H++PsdP//vr1lF47v3gSzNhlffOnZv3TzvVENwSCLqAZTgyzXFJ1Es3C6caHo0y4urtWvTQP8fUgbbMw/5XMf6shlm4Z13N7T9uTX1CArkgGWqnvzTGw6WIS7RnqfG+OPhS6jYr58clN/r6Nl0//WF9+szY9YFckGdZIwPsS1fOrXScKfT56H37cU4NZP1upuM7F/KzTNTMWySSMhoYyclZRXoaTcEpFRNIpfP989xOv7QnjupBJCeKxEWBPnubWon4Y3rumFwe0bOqUJZtX1XTBG5a1w4stX9sSVfQtxwwerQ2mmG1OMVmsMBs9mRDVY3RTlxOk6F4Q3KrGlaWaKx/fUy0mnJukY3D4LD4zpaJ987aph3SRM/1tfvPXX3n4d94ZBOfbHn93c39/mRp3ZgBuaXq3qYUh7pdf54fM7edxu6nV9MOHsphjZuVHIx/RV7U778/DHqC6NUTdMqTMTzlaCqYt6NAvL/s9zKdagnYQ/2VbxL8HsWHsoPSXRqfQ3kZHUNa30R7JsZcmFsAdTkbzPNzqouKKPoyLghT2aoUEd5/PSI+Pcy+lvfmas7r70OvRUKYlmDO/UCA+M6ehxm2DEU0o878SIaqAmGcpNe4JJ+RN2rWoWyxW1oq1xRvCpUMGok2R2q46l9/NJTjBjxs0DcPeoDkhPcdxYPz7BcUH857jOGNWlsc8S440zktG5STqe1pTwHdTekeZyv8EXRaOov9dv+xlEemMSQrfq16W9mzs9b14vFW9N7G1Imtp9Yzp6/dt7+qJu9kpxkSiSMaCt57kjanB1WR/vi9WGYuPT5+GFy5RiFKO6NEL7RnX9WtuKyGjqjbvZJDyWHzebPKcShpNardAoo7p47zBKDaB66lgvlS1V7RqFnmodr3gnRlQD/fCPwfj0JsfIBEey/DfurNDSoQK15dnz0b6R8zyCyZq1eyaN6+z2GfWGuofrYwAAIABJREFUoGfLeuhlmwDfs2U9XNyzudu2embdMxQ/eFnbSFtc4KUrevi1z0jo0lT5PiWaRcijWQKO3mstbclsI3pMv71jEHJsi/OaTQI7/z3O6/bXD2oNIDIlkJMS3G+m1OIJY7s1wfJHRmJYx+ywHT8jJREX9miGUZ0b4ZFxXTDn/mH46S7v6VxE4WQSnkepTELYUwkjOZJl9LHOD+Aa99bE3rh5SBuPy1b40zajR57iKFuQQRZRTdQkMwVDOjhGJlzTDRJqYP54pJzXLTzrkgRDG0Q5U65awssNgTdZdZP9Hpm5XDOS8ZRtvRkAWOthbSIjjAlgbRijK01p52P4u8D3WC+/M31a17dPxvcn7afwdCUAYI9OZb0FDw43tIKc2ppEs8Dtw9phxSOjMOueoVjw4HAAQNPM8Ad6qUlmTL/hHLRskBb2YxF5osYBQgi3v1N7UQyT+9/w0kkj8XMcdwx0bZaBxy/o6nmeWhQWHWa6IBHFlASz84kwniaOGi0WqkOpee6X9dYfmbJXETToWOO7+075AIAbBzvWKPK1PlEoKi3ulTBHd3EEMlI6vvbv7hxkf/2nuxyjc9r5Tdog6MtbBwDwHJxq1xjzdxHRd67rax8B69bM8/pR/vRtbC8o9vheTsM6aBjApHRf1MWVr+zbEpPGdUaTzBRkpiUix8s8C6J45KjM6vnv1CwETpUpnSCbDyp/p83rpaJ7mFNcoxHIqBrpVBrUpjz7NZKlkzFACgZZRDXIS1f0wO22dXy0XHuhXIMucvbmxF5RPX6f1vUx/8HhuHZAa933tb2uoZr/4HC8/dc+9ucpif6d9rWH/r/Rga9d5Gp4J0daWlW1e5BVN9mMyZd2x1V9W2JoB8e2jTVFQ85uUc/+WDvfzFfKo+tNjL8lyrU3Y+r347yuTbDooREetnc+jjrHzFtbXLneroRy+5KcYMafT47BMxfFT0lkouA4/pJcz6vqOyaTwAGDFwWOVd1tHUy+OtP8uQJZDY6x4iloYwl3ohrkcg+T1K0uZzkjqrPFA73FZgHggrOb4a7P1kehRQ7eqjbVt6WxdW3qGDUx4rKz6rFRSDYraYSX9mqO1lme26ANGLTtCNaQ9g2xYIfys9D7/Uwwm9A0MxX/uVwplGCx/U4n+1HERdtWtTqYESknG546D4dOlQMAth5Serbnbj+Ce12CzpO23m+LH3cbgcbNv28Jvny7EEA9HxUPiWoDR3aA5+IWJiHQqpaktX57xyDdzi6VSSjBkz8dfTKe8vsMxpEsohrM0/mPc7IU0f42fGFLXQtU+0bp+Ob2gXj8gi6GJpI0SlfSxQDg5at6ugULWtr1YgIZUfOnFLr2mnxxT6XKXXeX1L3HJ3RBUoIJyTrFG1w5BVm2h1YpdSNTqfmvL+kpiejURJlvtXSPsmjwxnz3tbxW550EAMx2Wc9Kr0e2Zf3AbuL6tcnSfV0vzcfV4xO6+tyGqDbxtk6WWQj731W77Mil1PZv47kKaLgkJZi8jmKpGTPRuIRGM33SaAyyiGow9eZyYDvlRmyU7QbXbPL9p10bRrui/RWGssZR35wGSE4wI9t20R/UTv9m2wjvXd8Xs+4Zan+enpLgFMAH8n28c7h7Oivg+cYmIyXR9r7z6zcPbeuzUp9j307PACi9sOqolrbTQRvgBXIxL6/y3Our3w79EUC18Io6Qqf+fP/9l7N09+mpw0SvFPpt57Z1ep7tRyBGFK/mPjAM396hzOn0NtiijsSYTLCv1XbB2eFZP07PFX3Dt4xCsB4+vzPypkzwaxFmve/tiE7BVy2Np3RBBllENZh6+jureSb2TB6PEQEsqLr5af3FB+PVL3cPwfs39I3oMY3IomhRPw2LHx6BB8/zvKBuqEZ3bYyutoIO8x4YhvkPDocQAh/ceA5WPTYKejG7pxRCfwa9jJ4zqD2mek8gpcSdw9vh+oGtce2A1mir6ZlWKzq6ri/nzcC2SpCrLdDh1g6X529M7I3Xru7p0lbnrR6y/VzV8vWu+9DecPx+37n45/lKyf+kBBM+v2UA/qdZU+yR8V2QN2WCz6+FqDZol13XvgaV+nfk7cxjNglkpiZi27Pn495Roc9D9ZcQAisfHYV+URjR0urZ0jbnNcDrll5QlMBlZAAwyCKq0dT7tUSTsq5QIKNTfgx21XiFpZX2x2c1z8TIzpEt394405iRhJYN0iI28tg2u669MMSITo3QKD0loBEfbWB505A2utto13W76pyW9mMFS5suqJaur18nCekpiXj24rNcFt+UeO3qnvjl7iH2UTR/fHZLf7xxTS+89zfPgbprgFk3OcHtxkn9MarbXtG3BZb8cwT6tG7g9EaDOu5zqTo2Trcvpp1kNmFguyyM6x7Zdd+IajJvnUDqeSQ1yezXCI6RGmek4KvbBuq+52kuttGCTW/X60yMdhZJrKgFt1lE8UvtFVcXH9bOo3lgTEe0D3Eldn+rsHniT9GCcNKbPxMpW54Zi0bp7tXlaiSdK6Y/I1YPjdUffRuuCajOap6JvCkTvK6jtOihEfjslv4e39cGWZ2bpOPffzkLr1zpPIL03F+6o2vTDLRskIa0pAS/y7erhBC4sEfgKUSuAaprsCyEQAvNPC31XTWYc72BUcvfJ0X5b4uoJvEnqyBWlz7p2Di063i46QZZsfmtjDiepYlqMPtio7YbLkdlNYm7R3XApR7WYVI+6/ssqJ3TEcgCsqperer53ihOhXOdqUg7dMq9rLH2IjrurCa6r2tpF9ntYLtp6NtabyFmd62y0jyub5aZmuhSal3g2gGtUd9lJGhguyzMuneoX4U0jFQn2fl4/o4Kqjcurvcv489uisHts3CPl3Smi4IIBonimX1ZDC9/f7EwTfnvtrUK/SkgdP3A1n5v6w+1szbQOWJ68eut5+rPza1tGGQR1WBqz5s6guU6SX5wiAvvpmsChWBGpa7p1yqg7b+6baB9onJNFu3ceqOpC3MCjmIe2qBJ+9gT7a+muuRAML2dU6/tg7cmKvOQFj88AgsfGm4f0fWnHeGk16Ob7pKS6Jgbov/FO74nUnefGSmJmHHzAKfRL1evXd0Tuc+P96vNRLWBdERZboxYj9AoaoEjbYu05wrtqFYT2xqCHRunG5JObjYJbHlmLJ69WL8Ijydq4ZDzNB2x7bODH32Lp4rw8dPVSlQLqfOq1Bs3tSfKajtLlVVWe/xsoNeVYC5E/qZfZKQk4PlLz0a/Ng1wUjOPqqaacmn3aDfBUNpyxrcPa4uXft+Jttl1ARwBEPjvkj+9yp6crxk106YYTru+r1sZ+HCaec+QoNagSk4wo2HdJDwyrksYWqWIpZtGolhS0/8yPJ0zs+ok4WhJRcj7DyYDQw2KMlITYTYJVFtlzf9GG4QjWUQ1mHrCVU9yibaqbdVWdTUg47qEfJ0zM1LcT85+VZozCWx8eiwmnK1M4DcbXHkOAFpnRXaBybYh9OLFov62tZq6Ns2w38Brf0qnyqoC2p99YVADf9Rjuja29+xGQrdmmUGNnJlNAmseH4PL/JzM/o8RTLshCqdrByhpd7Ga4q09T04a39nrtm9O7BXm1rjzVblxQi0uzsMgi6gG216gpHGVVlgAOOZm2WIsdGvquWdfe0L87k79FL1AgjS93vNgRirUlMfUROPmzujty9PXTO7U8uf3jOpgTw3RsgYYy7eorwQn3sqh10RGdGlk11WrByq/s2q5eSIKnj0Q0LlO3Te6A/ZOHm+vTBrLtFVY9dLq+raOfKr64PbKtISr+7W0Xx+Ec75jrcUgi6gG++LWAWhYN8m+PpZaGlsdyfK3AllvzY2cp8VP7xvTMeD2qcfvl+P/iV/9GsaHufcrkPLd/hhl0OTjWFQnOQF5UyY4peppL6La3xl/Cku0bJCGP58cg5uH6pd4r+nuHdUBd49sH9RnX7y8ByZf0h1nNddfh4yIgqCOnuu8JYSIeMl2T9JshXKy6jpSkdVOrqcv7Gp/bXB7x+L00c4OblE/DXlTJjiWoYDrnLLaKzbHRonIL+0bpWPN42PszxNdgqxgTr5X9G2Jz1ftB6D0lP1671AcOnUGbRrW8fFJd12bZeDLWwegc9MM9Hjmd78+k2A2Yf0TY1A3JQHfrssP+Jh6wl1itkfLeph+wznImTTTuJ3GKL3vZbtGjt+Njo3T/dpPMPOZaopgOiRUmWmJmNg/sIIxRORdTamlMLBtFqZc2h0X9miGr9Yo179uzTKx/JGRaJKhpEMvnTQSWXWScKqsCl+tOYCJ/VrhO4OulUbRjhgGOkc02kGjkRhkEcUR1zlZ3k5W6onPtQNP+xkhgC5NM9ClaWC96nsmj0elxYrUJLPHeSuX9m6O79YdxL06pahdy2+Hg5Hn8Ti6JvikV7TCU3l1raEdssPUotgRrqpY2enJ6NzEv+CViNzpprHFICEErrZV5c1OT8axkgoIAE0z3au5Nsk0Y+FDIwAA485qig+X5bktGRFpeqfAGP+WhxWDLKI4oo5kqYKZE+VN66w07Css031Pe/EymwRSk7yf7O8b3RHbD5fgr7ZJx540zkjGkWKlatLKR0dBSiUNsfe//vC73QPbZbm9lqWz0HKS2YTKaqvXfbXLroM9x0qdXqspvaRG0CtaYfUjuvD1+xAPwnUDt/qx0eHZMVEtoXYqxlN5cK3HJ3TB3SPbuy0ZES2hnAqNvm+JJgZZRHFEXctKXTPD6Ju+To3Tsa+wDHWSzCj1Uh7eHy0bpGHWvUO9brP6sdFITTKj6EwVkswmp8WR86ZM8Cs9b8GDw+2FFrTS9SpJ+fH9mvvAcLfjxs8lwbeyKqXISkqiGYlmgapq57uWWO8pDiezhy++ZYNUXN67ZdiO++WtA5x6uonImTpv1GL13okWS/55fmc8+PUGZKb5DpwSzCbdjsNocc2ICfazNR2DLKI4kmAbyVLXz3Id2dJSz2PBVHgb3qkRZm46HPDnAqUGVXU9lNbt07o+UhJNWLq70OM+cgKYS5ZsNqHSEvhFWE25nHXPUGSkxvdp9abBbbD5YBGu6dcKv20pwMb8orjtHfbXlX1b4Ks1+ejeQr+a5+KHR4b1+P3buo/UEpFDglkNsv6fvTuPk6us8j/+OdXd6U5n3xOyB0ggQdZAREFWBcQBcXCAUcQFEB1k3H7jODijM47j7jCOjoqKoiLuKKCOIg4CsqOyBrJAQkL2nezprvP7494mRdJ1nkqqq9fv+/XKK9X13LW76t57nuU8Pedidf4xEzi/wqkeuot2xz93/mF0G93yacDMhgM/BKYAi4C/cff17Sx3HfA6YJW779sU1SK9UNvFrHQS4OljBmIYT6984SXLFgr24gDaPbcxcmAjazbvKDuOpppMTEdMHMojSzbs9/qlfvquLA17NQknzHbfGMYNbeKFlZv3eRttv++ZB/T+jHCjBzdxw6UvB3Z/3sp1F6zrJhm7au39r57B/FWbueDY2rVWicj+a0vcNKobtfb0ZtV0+etNk6l3yyAL+Efgdnf/lJn9Y/7zh9pZ7tvAl4DvdOKxiXRbbQ+1w0oyt/32fScB7Qci5ZJS3PUPp7Bg1WZm7RE0tD1KnzFrDLc8sqzddUcOjJNW/OidL2f7rtp02XjbK6fwrT8uevHn4yus4W+v29u+6EX3hH3TNs6h5K3SeCtqSe1Nxg5p4qZ3v7KrD0NEyrj0hGlMHzOIk6b3/gQ83cFLuwvu2w1yUFN3DU32XXe9A54LXJ+/vh54fXsLufudwLrOOiiR7m7CsP5cdepBfPHC9md9f83MdNfAtqQVL5swpGyLVbmH5+vffhy3vOeEcPuN9XUM6V+bwbkf/atZLPrU2S/+XGnXvU++4XBGDWqkvlDZJfFfz5n1kp9700DdfdE3z1pEeppCwTh5xugXH/h/9u5XcNc/nNLFR9U3tDeBfTnnHzOBk3tRINxdg6wx7r4cIP+/987yKdKBzIz3v2YGk0Y071W26FNn85U3H1N23bZWq0JQ65S6Vp40fVSXDMDvV1/Yq9UN4uCn9FTOP2YCD159esWTN1/yiinM/8RZu/fTR6ONtvMu/Vz01d+FiPQcR08axsThe98npWudd9R4dRfsCGb2O2BsO0VX12BflwOXA0yapEkeRdpz3lHjeWLZpnAczeC8Gb+xwmCks8z797PSC5VRerZvOX4yf6lwvFhpa14vuifsk7bTrrSmcuLw/lx+4rTaHZCIiHS5vnpP3FOXBVnuXnbiDzNbaWbj3H25mY0DVlW5r2uBawFmz57dc1LLiHSitqxL9UGQ9bFzZzF97CBe1UMmlj1i4tB9Wr6xfv/mcopa/3oza2dMVqTWWfZERKT7Onj0QOav2vfkUj1V96qO3u1m4JL89SXAL7rwWER6jSgUaM2DrChz4OCmBq446cD9yi543NThXHRc52RfO/HgkUCc7a/tDM6YtbtB3RPhwvcvndP+tvpmjEX/hiwo7aOnLyIi7Sjtqn/05GEvvk5NSt/bpgPprkHWp4BXm9l84NX5z5jZAWb2q7aFzOxG4F5ghpktNbN3dMnRivQCrRW0ZFXjR+88nk++4fCabHtPx+QX9TGDy6frLRSM+//pNK658Mh2y9tLzlF6s3jJtvpolPWFvzmCK085iKMntf97ERGRvqf0ljh9zKAXX7/l+CmdfzBdqFsGWe6+1t1Pc/eD8//X5e8vc/fXlix3kbuPc/cGd5/g7t/suqMW6dnOPfIAmvvV8ddH96zJD9tz1akHc9v7XsUhY+N5q8YMbnpJF8HSWrTmRI2bZHNmffCMGVXNmyYiIr1L6R2h9L6amlw51Zukp+mWQZaI1EbU4DJ5xACe/LczmZJP2lipA0ft2/KdoVAwDi6pPauV/7zgiGx/fbQlS0REJJIKnA4aPXD3sr0rxlKQJSLV+c472h+n1BOVXt8PnzAkufyIAVl3xL4y6W6kVt1MRUSkZ9mXNOyl2Wl7WYzVddkFRaTrHDK241p52pIf9CaThjfznxccycx/+U243CsPGsk7T5rGpScoLfmPrjiem/70PPUF48GrT6fY26okRUSkIqUh1sDGvhtq9N0zF+mDzIwbL3s5MzowyOpN2mrUDp8whOZ+uy+P9QV7McV9qbqC8eGzDu204+vOjp407MUEGKMGlU84IiIifcfhE9qfSuU/znsZ/3TTY518NJ1LfVxE+pjjDxzB8AH9Omx7vamTWNvYqraub/9x3st418kHhhM0i4iIyG6V9BYcO2TvyrhKJ7bvKdSSJSKSO/Owsbz1FVO46rSDAfjbOZMAuO7uZ4HeNyi3M7zjhKlMHtHc1YchIiKdZJ/GZNXwOLqaWrJERHINdQU+ds6svVr6lDxw//3z62b2ublRREQEDi7JHLinGfkUK68/cvyL7/W2gEstWSJSld52URQREZHqzP/EWeFwgvFD+7PoU2ezaM0WvnDbPADGDWnqnIPrJAqyRERERESkw0RTm5QbF35I3rrVWyjIEpGq9IWedGfMGssv/rJMCTBERETK+MkVx3Pro8vDZX73/lcxfMDupBdtvWF649hdBVkiUpWBTfUUDP6pF6cy/+z5R/BPrz2UfvUaxioiItKe2VOGM3vK8L3e/8R5h/Hw4vUAHDS6/SlkemMVpoIsEalKQ12BZz55dlcfRk31qy8wZnDv6isuIiLSGd40ZzJvmjO53bJBTVko8vJpIzrzkDqFgiwREREREel0Iwc2cvsHTmLiMHUXFBERERER6RAHjiqf6r0n0wADERERERGRDqQgS0REREREpAMpyBIREREREelACrJEREREREQ6kIIsERERERGRDqQgS0REREREpAMpyBIREREREelAmidLRPbLg1efzuYdLV19GCIiIiLdjoIsEdkvowY1MmpQY1cfhoiIiEi3o+6CIiIiIiIiHUhBloiIiIiISAdSkCUiIiIiItKBFGSJiIiIiIh0IAVZIiIiIiIiHUhBloiIiIiISAdSkCUiIiIiItKBzN27+hg6lZmtBhZ39XGUGAms6eqDkB5HnxvZH/rcyP7Q50b2hz43sj+60+dmsruP2t+V+1yQ1d2Y2UPuPrurj0N6Fn1uZH/ocyP7Q58b2R/63Mj+6E2fG3UXFBERERER6UAKskRERERERDqQgqyud21XH4D0SPrcyP7Q50b2hz43sj/0uZH90Ws+NxqTJSIiIiIi0oHUkiUiIiIiItKBFGR1AjM708yeNrMFZvaP7ZSbmX0xL3/UzI7uiuOU7qWCz82b8s/Lo2Z2j5kd0RXHKd1L6nNTstyxZtZqZud35vFJ91TJ58bMTjazv5jZE2b2h84+Rul+KrhPDTGzW8zskfxz87auOE7pXszsOjNbZWaPlynvFc/FCrJqzMzqgC8DZwEzgYvMbOYei50FHJz/uxz4SqcepHQ7FX5ungVOcvfDgY/Ti/oxy/6p8HPTttyngd907hFKd1TJ58bMhgL/A5zj7rOAN3b6gUq3UuH15u+AJ939COBk4PNm1q9TD1S6o28DZwblveK5WEFW7R0HLHD3Z9x9J/AD4Nw9ljkX+I5n7gOGmtm4zj5Q6VaSnxt3v8fd1+c/3gdM6ORjlO6nkusNwHuAnwKrOvPgpNuq5HPzt8DP3P05AHfXZ0cq+dw4MMjMDBgIrANaOvcwpbtx9zvJPgvl9IrnYgVZtTceWFLy89L8vX1dRvqWff1MvAP4dU2PSHqC5OfGzMYD5wFf7cTjku6tkuvNdGCYmd1hZg+b2Vs67eiku6rkc/Ml4FBgGfAY8PfuXuycw5MerFc8F9d39QH0AdbOe3umdKxkGelbKv5MmNkpZEHWCTU9IukJKvncXAN8yN1bs8plkYo+N/XAMcBpQH/gXjO7z93n1frgpNuq5HNzBvAX4FTgQOA2M7vL3TfV+uCkR+sVz8UKsmpvKTCx5OcJZDU6+7qM9C0VfSbM7HDgG8BZ7r62k45Nuq9KPjezgR/kAdZI4LVm1uLuP++cQ5RuqNL71Bp33wJsMbM7gSMABVl9VyWfm7cBn/JsvqAFZvYscAjwQOccovRQveK5WN0Fa+9B4GAzm5oP9rwQuHmPZW4G3pJnU3k5sNHdl3f2gUq3kvzcmNkk4GfAxapNllzyc+PuU919irtPAX4CvFsBVp9XyX3qF8CJZlZvZs3AHGBuJx+ndC+VfG6eI2v9xMzGADOAZzr1KKUn6hXPxWrJqjF3bzGzK8myeNUB17n7E2Z2RV7+VeBXwGuBBcBWspof6cMq/Nz8CzAC+J+8VaLF3Wd31TFL16vwcyPyEpV8btx9rpn9L/AoUAS+4e7tpl+WvqHC683HgW+b2WNkXcA+5O5ruuygpVswsxvJsk2ONLOlwEeBBuhdz8WWteCKiIiIiIhIR1B3QRERERERkQ6kIEtERERERKQDKcgSERERERHpQAqyREREREREOpCCLBERERERkQ6kIEtERERERKQDKcgSERERERHpQAqyREREegAzm2FmfzazF8zsqq4+HhERKU9BloiIVM3MTjCze8xso5mtM7M/mtmxNd7nIjM7vZb76Gb+AbjD3Qe5+xe7+mBERKQ8BVkiIlIVMxsM3Ar8NzAcGA/8K7Cji4+rvjtvbz9MBp7o4mMQEZEKKMgSEZFqTQdw9xvdvdXdt7n7b939UQAze2vesvXfeUvXU2Z2WtvKZjbEzL5pZsvN7Hkz+3czqyspv8zM5ubd5J40s6PN7LvAJOAWM9tsZv9gZlPMzM3sHWb2HPD7fP1zzOwJM9tgZneY2aEl2z66pAvej83sh2b273nZyWa21Mw+ZGYrgG+Z2TAzu9XMVpvZ+vz1hJLt3ZEf/z35cd1iZiPM7AYz22RmD5rZlHK/yHLHama/B04BvpRvd3r1fzYREakVBVkiIlKteUCrmV1vZmeZ2bB2lpkDPAOMBD4K/MzMhudl1wMtwEHAUcBrgEsBzOyNwMeAtwCDgXOAte5+MfAc8FfuPtDdP1Oyr5OAQ4Ez8mDkRuC9wCjgV2SBWT8z6wfcBHybrAXuRuC8PY57bF42Gbic7L75rfznScA24Et7rHMhcDFZi96BwL35OsOBufn57yU6Vnc/FbgLuDI/33ntbUNERLoHBVkiIlIVd98EnAA48HVgtZndbGZjShZbBVzj7rvc/YfA08DZ+TJnAe919y3uvgr4T7JABbJg6zPu/qBnFrj74sQhfSzf1jbgAuCX7n6bu+8CPgf0B14BvByoB76YH9fPgAf22FYR+Ki778hb6Na6+0/dfau7vwB8giyoK/Utd1/o7huBXwML3f137t4C/JgskGxPdKwiItKDdHX/chER6QXcfS7wVgAzOwT4HnANcFG+yPPu7iWrLAYOIGsRagCWm1lbWQFYkr+eCCzcx8NZUvL6gHxfbcdZNLMlZK1Mre0cV+m6AKvdfXvbD2bWTBYEngm0tdgNMrM6d2/Nf15Zsv62dn4eWOa4o2MVEZEeRC1ZIiLSodz9KbIueIeVvD3eSqIosq52y8iCmh3ASHcfmv8b7O6z8uWWkHW5a3dXFby/jCyQAyA/honA88Dydo5rYmIfHwBmAHPcfTDwqrZNlzmWfREdq4iI9CAKskREpCpmdoiZfaAtAYSZTSRrwbqvZLHRwFVm1pCPszoU+JW7Lwd+C3zezAabWcHMDjSzti543wA+aGbHWOYgM2sLRFYC0xKH9yOybomnmVkDWZC0A7iHbKxUK3ClmdWb2bnAcYntDSJrjdqQjylrd3zVfoqOVUREehAFWSIiUq0XyBJb3G9mW8iCq8fJgoQ29wMHA2vIxjGd7+5r87K3AP2AJ4H1wE+AcQDu/uN8+e/n+/k5WQIJgE8CH8kz8X2wvQNz96eBN5Oll18D/BVZsoyd7r4TeAPwDmBDvtytxKnnryEbJ7UmP8//TfxuKhYda0ftQ0REOoe9tCu6iIhIxzKztwKXuvsJXX0sKWZ2P/BVd//EresmAAAgAElEQVRWVx+LiIj0XGrJEhGRPsvMTjKzsXl3wUuAw+nA1ikREemblF1QRET6shlkY6EGkmUxPD8fJyYiIrLf1F1QRERERESkA6m7oIiIiIiISAdSkCUiIiIiItKB+tyYrH7W6E0M6OrDEBERERGRbmo7W9jpO/Z7ovmaBVn5ZJTfAcYCReBad/8vM/s4cG7+3irgre6+zMxGkM2NcizwbXe/smRbFwH/BDiwDHizu6/JJ6S8DhgFrMvfXxodVxMDmGOndfDZioiIiIhIb3G/317V+rXsLtgCfMDdDwVeDvydmc0EPuvuh7v7kWSTPv5Lvvx24J+Bl0woaWb1wH8Bp7j74cCjQFsA9jngO/n7/0Y2MaWIiIiIiEiXqVmQ5e7L3f1P+esXgLnAeHffVLLYALLWKdx9i7vfTRZslbL83wAzM2AwWWsWwEygLcz8P7IWMhERERERkS7TKYkvzGwKcBRwf/7zJ8xsCfAmdrdktcvddwHvAh4jC65mAt/Mix8B/jp/fR4wKO92KCIiIiIi0iVqHmSZ2UDgp8B721qx3P1qd58I3MDurn/l1m8gC7KOAg4g6y744bz4g8BJZvZn4CTgebJuintu43Ize8jMHtrFjo45MRERERERkXbUNMjKA6SfAje4+8/aWeT77G6JKudIAHdf6NnMyT8CXpG/t8zd3+DuRwFX5+9t3HMD7n6tu89299kNNO7/CYmIiIiIiCTULMjKx099E5jr7l8oef/gksXOAZ5KbOp5YKaZjcp/fjXZ+C7MbKSZtZ3Dh8kyDYqIiIiIiHSZWs6TdR5wMbDDzN4JrAUuB67JU68XgQ3AqQBmdhxwN1ngZ2Z2IfAqd3/SzG4FlmRxG0uBOfk+Tge+bmaN+bZOqOH5iIiIiIiIJNWyu+C9wDHu3gSMBrYCi8jGYA1w9/5k82i9NV/+caDZ3euBCWRB2Lw8kcUZwMR8W38k70IIDCfritgPuAr4eA3PR0REREREJKkrUrj/1t3bklPcRxZQ4e5bS95vIk/tDkwD5rn76vzn37F7HNe5wPX5658Ap+XdFEVERERERLpEl6RwL/F24Ncly80xsyfI0rVfkQddC4BDzGxKPjHx64GJ+SrjgSUA+bIbAaVwFxERERGRLtMlKdzz968mS7d+Q9t77n6/u88CjgU+bGZN7r6eLIX7D4G7yLoctrV4tddq5Xu+oRTuIiIiIiLSWbokhbuZXQK8DnhTnpb9Jdx9LrAFOCz/+RZ3n+PuxwNPA/PzRZeSt2rlrVxDgHXtbE8p3EVEREREpFN0RQr3M4EPAee4+9aS96fmgRJ59sEZZK1WmNno/P9hwLuBb+Sr3Qxckr8+H/h9e0GbiIiIiIhIZ6llS1ZbCvcrzGybmS01s9cC3wIOBlaZ2dNm9tV8+dcDO81sG1mSjEfdfU1edpOZbQeWA8+5+7z8/e8CZ5vZTrLA679reD4iIiIiIiJJXZHC/VSyboB/IOsueEW+/E3Ak+7e392b3f1MgDyF+0R2p3Bfb2an5eu8GfhlnsL9UrL08CIiIiIiIl2mK1K4z3X3p/dhU0rhLiIiIiIiPUZXp3Df01Qz+7OZ/cHMTszfqzqFu7ILioiIiIhIZ6mv9Q7KpXBvx3JgkruvNbNjgJ+b2Sx3X29mbSnci8A9ZK1bUGEKd3e/FrgWYLANV2IMERERERGpmS5J4d4ed9/h7mvz1w8DC4Hp+c9VpXAXERERERHpLDVryTKzicCDQD9ggpm1uvt/mdlwslap44Avm9mZeWvVFUBbEox+wKFAc76ty4D3AA3AcKCtK+GvgO/mw7AcuE8p3EVEREREpCvVsrvg0cAY4LH850/nadjPJAuw6oCZwMNk3f9WkwVRLfnyK939zjy74DVkrVatwFNkrVfzyAIrK/lfRERERESkS9UsyHL3X1AS+JjZL4BnyAKrQ9x9uZmNA+7Il/8pWddCzOw/2D22ahpwr7ufnpddTJZd8HbgbODN7n5v3l1whZmZWrNERERERKSrdEV2wTHuvhyyNO9kc2jt6QLgxvx11dkFRUREREREOkvNg6x9yC7YtvwcYKu7Pw7g7uuBtuyCd5FNaNzWpbCi7IJK4S4iIiIiIp2lK7ILrsy7CZL/v2qP1S5kdysWUH12QXe/1t1nu/vsBho75uRERERERETaUbMgy7KUf98E5rr7F0qKbgYuyV9fAvyiZJ0C8EbgB3tsa3T+/zDg3cA32tnW+cDvNR5LRERERES6Ui2zC95Clphih5mdnL/3deBk4FAz+wjwEPAGM+sHfA04CRgGTCJLkoGZXQB8zcyagM3Ale4+z8xeBVwKHGFm55KNzbqwhucjIiIiIiKSVMvugp8BjgEWuPuR7n4k8Fbgg+4+ELgKuMvd1wGXAbj7NGAq8HkzK+Tp2z8LHOzuTcAvyVK9AzxH1or1PeA97n6cuz9Tw/MRERERERFJqlmQ5e53svf4qBnAnfnr28hSsUOW1v32fL1VwAZgNln69nnu3hZY/a5tHXdf5O6PAsVanYOIiIiIiMi+6pQU7iUeB87JX7+R3anYHwHONbN6M5tK1gI2kTh9u4iIiIiISLfT2UHW24G/M7OHgUHAzvz968gyBT4EXAPcA7Qk0rdXTCncRURERESks9Qy8cVe3P0p4DUAZjadLDFG20TC72tbzszuIU/T7u63kCXRwMwuB1r3Y7/XAtcCDLbhyj4oIiIiIiI106ktWSWp2AvAR4Cv5j83m9mA/PWryVqxntxjnT3Tt4uIiIiIiHQ7tZwnayGwEJhlZkvN7B3AB8xsG7ANOB74Sb74dGC1mRXJug5eXLKpm8xsO7AceM7d5+Xbv9zMdpJlGPyWmT1Rq3MRERERERGpVC1bst4GHAs84e4T3P2bwKnAme7eCHwS+H/5svPJuhG+G/iFuy8GyFO4TwQm5inc15vZafk6vyXLQPhd4G3uPquG5yIiIiIiIlKRbpHC3d23uPvdwPY9llcKdxERERER6VG6Swr3cjokhbuyC4qIiIiISGfpLinc29VRKdzd/Vp3n+3usxto3OeDFhERERERqVS3SOGeWKfqFO4iIiIiIiKdpWZBlpldR9Y1cGDJe6eQJbxoAiYAX8nfP45sHqvhQLOZ3e7uN+VllwHvARry8hPz998PXAqMBY42swfbEmaIiIiIiIh0lVp2F5wEONBYksL9K2TBVTPwe/KAiWys1lCygKw/8BMze1meXfAaoDHf1lPsHpO1FRiSl00DHq3huYiIiIiIiFSkltkFT2fvFO6LgQ+4+3TgJmBZvuxWd5/i7sOBw4A1wFyy4Oled5/h7jPJJiJuyy74VXcf7+4DyIK1x2t1LiIiIiIiIpXq1DFZwHuB35jZ58gCvFe0FZjZHLKJiCcDF7t7i5m9mF0QWEqWXbBfO9t9B/Dr2h66iIiIiIhIWmdnF3wX8D53nwi8D/hmW4G7359PKHws8GEza6oku6CZvZlsUuLPltupUriLiIiIiEhn6ewg6xLgZ/nrHwPH7bmAu88FtpB1G8Tdb3H3Oe5+PPA0ML9tWTM7HbgaOMfdy0ZPSuEuIiIiIiKdpbODrGXASfnrU8kDJjObmk82jJlNBmaQtVphZqPz/4cB7yYbl4WZHQV8jSzAWtV5pyAiIiIiIlJezYIsM1sILARmlWQXXAb8ysy2Ab9id3r31wM78/fnAo+6+5q87CYz2w4sB55z93n5+z8kG7/1qJm9YGa31epcREREREREKlXLlqy3sUd2QXc/zd2b3b0/8CXghnzZm4An3b1/Xn4mQJ7CfSIw0d2bgPVmdlq+zjuBwfm2/gFYV8NzERERERERqUgtU7jfSZnAx8wM+BvgxsRmpgHz3H11/vPv2J3C/f/cfWv+/n1k82+JiIiIiIh0qc4ek9XmRGClu88veW+qmf3ZzP5gZm2TFL+Ywj0fs/V6dk9GXEop3EVEREREpFvo7Hmy2lzES1uxlgOT3H2tmR0D/NzMZrn7ejNrS+FeBO4ha916UUkK95Mow8wuBy4HaKK5Q09ERERERESkVKcHWXmL1BuAY9rey9Ov78hfP5wnzZgOPOTutwC35OteDrSWbKsthftJqRTuwLUAg224d/Q5iYiIiIiItOmK7oKnA0+5+9K2N8xslJnV5a+nAQcDz+Q/K4W7iIiIiIj0GJ2dwh3gY8AMM3vCzD6Tv3c1sDlP4f44MA6YlJcphbuIiIiIiPQYnZrC3cxOATYDk919FvA5AHd/b56+vT8wB1jk7n9RCncREREREelpOjuF+7uAT7WNnyrTza80KYZSuIuIiIiISI/S2WOypgMnmtn9ear2Y9tZ5gJ2B1kdksLdzC43s4fM7KFdlM2PISIiIiIiUrXOzi5YDwwDXk7WlfBHZjbN3R3AzOYAW939cYCOSuGu7IIiIiIiItJZOjvIWgr8LA+qHjCzIjASaOsOeCEvnT+LjkjhLiIiIiIi0llqFmSZ2XXAOcDAkrdbgJvN7BmgERgMrDGzfmTp2N8MLDCze9z9jnw7lwHvARqA4cCJ+fufAD5IlsHwZ2Z2ubs/WavzERERERERqUQtx2RNAhxoLEnh/mdgPllwtw24IG/VugwYCzxM1u3v82ZWyLMLXkMWkDnwFLvHZL0C2ADsBA4A7qjhuYiIiIiIiFSkZi1Z7n66mU0BbnX3wwDM7GPAje7+uT0Wnwnc4O7fy5fbQDbOyoF73f30/P2LybIL3u7up7StbGYXAW+p1bmIiIiIiIhUqrOzCwJcaWaPmtl1ZjYsf+8R4FwzqzezqcAxZC1WYXZBM/u7fNLjzwBXde5piIiIiIiI7K2zg6yvAAcCRwLLgc/n719HlhTjIbLugfcALe6+nmxurR8CdwGLyMZ1AeDuX3b3A4EPAR8pt1OlcBcRERERkc7SqdkF3X1l22sz+zpwa/5+C/C+krJ7yMZuhdkFS/yALIArt1+lcJfeoVAXlxfb+3r0DfXjxoblW45ub4q93Qq74ktD0wPzw3IbNjQsb3l2cVguIiIinatuxPCyZbYh8cyV0KlBlpmNc/fl+Y/nAY/n7zcD5u5bzOzVZK1YT+Zlo919Vd618N3A3+TvH+zubU89Z5MHZSLdmllYXGhuDst9R9wS6x5vP7Hy/q8LyXPD4oZzKyR+N0MGh+XLzpsWlu8aFBYzdEEcoBaPnx6WF3YVw/LG5SvD8uL27WG5iIhIt1Plvb9ueFxBydD43s/GzWHxjsMnheXFlvL3bn+oX7zvhFqmcF8ITAEKZrYU+ChwlZnNJOvyt5MsaAKYDtxjZk3A88AJJZu6ycyOyV//1t3n5a+/ZmavIEuOsQO4eB8Obr/OCaj+QVT6tsTnp7hlSycdSDsSrWSFfg1huSfOrTA4vlCmLoQbpyUudomv9ZBTVoTlA8+IA9jnbp8clg+bHwdZ/ceMCst9xaqw3PrF5+/btsXlxcS1qw+3goqISPvqp8b3vuKqNWG5jRsd76AhEYq0JO5NiXuX18UPB2tm9C+/6yeqG1VVy5astwGbge+UZBecCHy3neyC84HXAIcBh7n74nz5EWSJLia6+2ozu97MTnP324HXu/umfLlzgL8j71aYFEXVetCQvsrjIMFb43ISLVG+dWtY3vRMfKHePjzuDrhzUHwxXH9XvP6y8S1hed3QOEhpjWNQ2LkrLLZE5U9xc1xbl6ot1LVNRKQXSjUcJCpA68bEQVDLmCFh+c7pcQViv/VxBWbdxriCkHUb4vJEBWLT4nj9IQ3DypbV7ayuYaWWKdzvzFO4V7LsFuBuMztoj6JpwDx3X53//Dt2p3DfVLLcALIWrcroYUNkb4kLsbfEQUKhf/naIABL1VYlDFwcB2l1C5+P9/9XM8Ly7QfEN6qDfvhCWL51QtzVs3V1HER6a3xdSnUlTSkmgly10ouI9EBVXrtbV68Ny1Ojkvol1t9x1tHx+vWJCsIRA8Liuk1xELdtcjxWYN2M8jWkLQ9W0fONTh6TlbvSzN5ClknwA3kGwXJeTOFOln3w9cCLfWbM7O+A9+fvnVrJzq1QoNBc/g9W3JYYF6EATXqrapNqFOOWLhsUX+h2jY37Za8/NA4y1v1tPGaKEfF3e/CDcZA4/28HhuWTf5VoqTosMaZr286wnOVxd8JUkJZs6SLRUpmiIE1EZN9V2RJV7fbrBsf3Nh9TPjEEQMthcVKppmWJCtLliQrIXfG9tXXtunj/T8dd7cetLl8B+9zm6u6LySArnwD45+7+Qsl7r3P3W/djf18BPk7W6vRxshTuby+3sLuvN7O2FO5FstTu00rKvwx82cz+liyF+yVlzuFy4HKAJprjQEpBlPRRhabGeIG6RBCWuBBSnxjztT3urpc0Iq7NKrbEQUb9lvhG1rA5vlHtHBpfTvs/Htf2eUvi/BMtganumLq2iYh0Q7WuoEpsv3XjprC88GwcaPSbl+jlMjbujug7EhWM9YlQJRVEjo+HCmwd3lS2LDWeK6WSlqz/Bj5gZhe5+9z8vX8jT7++L8qlcE+s06Ep3IcURng0gL+4PX4QscQfO/mgJNJDFV+Iu8vVHTQ1LG8dFteWFRYsDcu3vSbuF97QGH/3diUudztetzEsH3NdfPz9NsU3mq1HxLV9jWvifuk277m4PJEYI0XXLhER2UuiAtUP23Okzx7lGxMVgHVxBWiqpSoVRLYsiu+djSPK97KxIPNgJSoJsp4F3gH8xMw+5u4/JpnHC8zsOuAcYGDJe+PcfbmZfRD4LHBT/v5xZEHQcKDZzG5397ayy4D3AA15+Yn5+/9Mls69lay74JJKTtjdKUZpsBMRcbJLjkgPVRgcd+ez5rg7XaqlpbUpLi/OjDMYDVgeX0hXrUscX2P83d26KM5+uP2E+NowZF7cUjfm98vC8l3j4u6S9ZMOCMtTiTUKW+PukqkgywYkxoTtitdvWRIH0SIi0gVSWY9T04s89HhYXPVTczUZwUmPZy6sKD9qyXZVd/SVBFnu7n8ys5OAG81sDulxcACTyLoFNpakcD/ZzI4FxgPbgH/Ol30cGEoWkDWSBXRHAsuAa8jGY7UCT5FlG5wHHAAU8vdbgLi9M2eFAoWB5WukU7X1Ir1Vy4p4HqdUBiJWxd3hCkPiIKhuU3wh3zA9Xn/IE/HlbNP01FwecXEh0RuyLlGeCoLqN8QtWcWF8WTGdYnJkIsvJLITFhLzmCW6k6aCqGQvAKWYFxHpdqwh7iVR6F++ux2kK/BSjRep+UGrtXPamPL73lBd6opK1l4O4O5rzOwM4NNkqdZD7n56nrDi1rYU7sA3zewnwAXAL4CV+bJbyebUwsymAvcBc4GjgHvd/fS87GJ2Zxd8V9u+zOwi4C0VnAteLFYXSNV6gKJIF6mbFWff88RD/rZTXxaWW6LV3YfFD/F12+Pv3saZ8YW8aWSiO54lvruPxC1d20bGq7eOiwcP7xoSn3/T1vI3AkjPVZJKTJLKPlhtBZS6I4qI9Dy+Kx4z1Zoo72qpCr5+S8pXENvOGrdkufvZJa+LwP/L/+2zfD6r5939kT3nhMlbyK4DJgMXu3uLmXV4dkEs/oUnHwQUREkv5Yk0qltPPzws7788nkh55Zx4TNWOEWExzSvi796kU+MU7lt3xbVx67fGLWVbRscX2zH3xkFgqrtkw7pEd74N8ZgxGxCnuW1dkwjCdG0TEZFeJvVcv/XQ8hWYxbU1askys1sI5p5y93P2ZUdm1gxcTTbpcHvbux+YZWaHAteb2a9rlV1QpLuqGxy3llhi3FTL8/G4n0Jj+daS1oGJ7IKJRtztY+PvVmpSv6Hz4vIVJ8TlOzbGQdzmlXHiCmtK1Fil5vpNZCGKassAtsyMMyA1DJwWltc98GRcfnC8PitWx+WJyaZTE0K2bqqoR7eIiMhu1fYgS2RGbvzfh8rvuphI2pEQhWifa9sH8HXg0qr2BAcCU4G2VqwJwJ/M7Dh3X9G2kLvPNbMtZF0SH+ro7IKDbbhX1W2l2rmERAKtm+PWIEvM41Y3JA7SWoPWkLrNcb/nAavih+QVp8fd2eoS3ap3Do4vpPVb4vIBjXGXhc2F+EJcaIi70zWOjcc0DVkQ13htPST+/fR/Pu6OV9gYfzZ2HXNIWF6XCPJ8dNyUuHPisLC84YGn4/0nKhAUhImIdIFEEJNKHJEar+vbE9OrpKYfqbKXxZ495/a046zZ5Xd99z1V7bvsU4G7/6HttZltLv15f7j7Y8CLI+fNbBEwOx/rNRVYkncRnAzMABbly41291VmNgx4N1lGQczsYHefn2/ubGA+FbBCgUL/4AOTGreQyrIiUo1EkO6J8tYNVfSNXhCnOd18+qywfPjc+EK6cWqipSwxZmvibfG5PTM6TvwwdmKcBnbrjrg74ab1iVZwiytv+q2Pfz8ticQgNigeXGytiV9gIk2uD4z337A6vhFaorYwzOoqIiJdI5VdMBEEFRKJK4qJpE+17qqealjpt778s4W1VHdslXY23Oe9mNlCsmQWhZLsglOAc8kep8bk/9aQjbX6vJntyPd1p7u3DSC4ycyOyV//1t3n5a+vNLPTgeZ8uxdUdCLFIsUoqlZLlPRRlsgQNHD+hrDcE9npBtWnWqriC+HS0+IxRxAHYaOa45agZ7bF5z/i7jgIa3h+VVhOIgjyLfGNLDVhZN2IOLFG6/ryaWoBfJESU4iIyEsV+iemR0lUsBVSFXCJHjp4KmtWHKJYYjLiDdPLV6C2Pp0YJ5AQjckqvWPX5S1JLz4luXtidjDeBmwGvtOWXdDMBrv7P+evryKb/+oKsvmy3lGShbDtGEaQpWyf6O6rzex6MzvN3W939783s0HAL8myFD5T0RmbhTWuqZYCkV7LEheTZXGK911HHRiWtzZVMvNDeZ6oEho7Lg4iFq2Pu7sVi3EQuO7o+EI/YOW4uPzeBWE5I+PjS/32PNHKnkyRrsypIiKyh+K2ODNvNNYbsvlp4x0knrurnCerdcGzYfnQUeXHutdtr91kxA+TtSq1nd2fSsqckgQU7XH3O/OsgKXvlVbFDiDdQjYNmOfubSOyf0eewj3/+ePAZ4APJrZTehDJdJQiXaXuoKlhuScCnWTf5kBqVvVUd7CG+58Ky/tNjCfTtcRkuWPr4tqo9eviMU8jn4q/92veHbd0Tftx3OWh3+rEeLpEv/bi8yvi8sTfNpWmVq30IiKyl1QQc2w8a9OOwYl5tFrjR/36F+J7c2FhnDk4NY/W1lPj4193aPl7564FNWrJcvf4aW8/mdknyOa02gicUlI01cz+TDap8Efc/S6gbAp3MzuKrIXrVjOrPMgS6c7Wxl3ywq6uVUoFUakJAwuD4+x9SYnxkJvHN4Tl9VvjC/m6Q+Ibwban4+2vnRnfiMZ9L26pKqYmZNyZqPxJJN1J/X1ERKQXSiVkSyi+Mp6eZdfgRFKnUXF53Y743rxrWtwSNmZNnFW5OCKuwG269YGwvHHM8WXLrMrbanUJ4PeDu18NXG1mHwauJBurtRyY5O5r8/FXPzezWeVSuJtZAfhP4K2V7FMp3KWnsCHxxaSuXxwItK6OM8iF+04kRqgbGY/5Ka5PjNmaFHen2zU+MY/WsESK9E3xhbxue1w+cEm8/ZGPJloJE9n5iokuCyIiIvusyl4Kdfc+FpcfMSMsH/BI4t4/JK6AXXFi/Gyx/KzxYfnoB+PMvC9c8PKwfMCq8r+/ul2dk/iiFr5PNp7qo+6+A9gB4O4P50kzplM+hfsgshTvd+SpGccCN5vZOe6+V8L7PVO41/rERPZXy6I4w19txQFcsqUl0RJmiX7ZTU8vj/d/9JSwfO2xcUtR3Qvx8dUlxt6uaIoraCb9JO5umUqDm2qJ8l2JxBTqDigi0vekuvslxlunsu+1DI2TQq07bFJYXp+o4Bz0fOLelZoGa3X5qWkAhi5YEpavvGBm2bLWftWNB+vUIGuPtOvnAE/l748C1rl7q5lNAw4mT2TRXgp3d98IjCzZ7h3AB9sLsPb5GBviLkUazyW9VSrNqrXG80RZQ3w52Tk8kSL8ibi7nddNCctfNiO+kD7++OSwvHVA3F1xyPw4SGsZHbfE1SeyL7I1HlxcfCH+/SczNCkIExHpfVKJJTxx7U90N2y4M27pGpZ4Lk49V3PYwWFxsX91oYoNje/NI792b9myhR6PtU6p6MjNrI4s3fqLy7t7WOVeJoX7h/J5sIrABuDUfPGrgXfmrVIONAGTgHWUT+Hetp/zgZOAQ4FkkGWFAoXm8qmgPZXPX5MRSx9VSKR4Tz3kNy6PU5Db6JFheTFxtZq/alS8/SHxjaC5OS5f/ao4SBx+QzwZrye6gnri95ca3Ktrj4iI7CU12XBiMmGbEHf1Lw6Je2kUNiQClUXL4vUTQxlaExWQdQfESbM2v3FO2bLibfeF66Ykgywzew9ZgLSS3dOFOhCPlGs/hfsS4Pf5pMOfJhtT9SF3fy/w3nyZlwG/cPe/RCnc82UHAVcB9wNzKz7roEZZLVXSZ6UmOt5cXY0Oz8eZET3REtbaHNfWeWt8Izl26uKw/KHFcZeHfsvj7pTbX31EWD7gz3FLW6qlSoktRERknyVaulL3luL8ymZIKid15yrMisd8FQfGLWF1CxLZBzfH46kH3fRw2bJCS+1bsv4emOHu+zSivkwK99+W/HgfcH47q14E3Ji/7vAU7u6ORxnaNFeM9GZBS2wyu2CqS0AihXgqSKtP1DY1bIq/m0dOisezPb8l7jJQ3Bmff+vIuN9688J4ni4a4xtF6vefGvOW6lcvIiJ9UCozbWK8b92QwWG5DRsab39tfG9sfXJ+WJ66N7Ymnk3qZhwUlm84o/wcn62/vDtcN6WSIGsJWbr1jvZ2sqyBe7oAODd/3SEp3F+SXdAGhFnUPJVJRN0FpScLZk73lnhMUiqISj3k142Ku/N5/7jLwrZx8fH9+Zbyg1cBtk6LuwLPOnhpWP7EwjjDUW8ndZIAACAASURBVHFgfPwsiluykolFUpNFq4JIRET2VOVzaeuGRAiQKq9WopdL8t63Jk5KNeLu8vfe+s2JIUQJlQRZz5Bl8fsleQZAAHf/wv7u1MyuBlqAG/Z4fw6w1d0fz/fRISnc98wumBrgH2+sutmfRbpSVCPkxUSXghq3lFhLfCNoXhYHGSNOj/t1L1sbt2Q9uzZOI9u8INFlYVkcpLUkagsL/eMxX8nsg6kgTUREpIdJjkdOsIZEV/8Dy1cAF9dUl3SjkrWfy//1y/9VxcwuAV4HnOa+V9XqhezuKghAR6Rw3+MA4gfNfTmZdjeglizpvsJAKZkGtro0scVEbVfdwHjwbH1imqq1t8UTEtrQ+Ns9+rg4SFt8SKKlKpEYJFVBU9wan2AyQ5OIiEhvU2UvjdR456anV5QtK2yvcUuWu//r/mzYzK4jS9M+sOS9TwAfIAvWZpJnAzSzfsDXgDcDC8zsHne/Iy+7DHgP2SQ+w4ETS1O459kFf0yWQCOdXdAMCzKp+AvxpGYiPVrU3TURBBQa4yCjuD3OjlcYnui3nZhoefPE6qpAfEJ8fIsWjU5sIFG8Pg4irV8iSEoltki1oqs7oHRniQel5JjQREu7uuqL9FJV3tsKI+NeKtsPKn/vL26In0tSygZZZnaNu7/XzG6hnccLdz8nse1J+XqNJSnc3wysJ2uJusHM/s/drwAuI2uNepgsMPu1mR0LDAOuIRuP1Uo2r9ZEYF5+jG3ZBSuPjNxhV/nINDnuRBd66cmq+Hx6a+IhP/EQ1bomzp2z7ZXlB58CWOKr19IcH98BI+IgaHV9PCt9811x+bY58eDaxtsfCcuT3TFT40FFurNUhjMlbhGRGmhZEvdSaQwqeAs7q7suRRHFd/P/P7c/G3b30/OEFbe2pXAHvgntTh48E7jB3b+Xl28AZpMFafe6++n5+xdTPrtgZSncCwUsGvuQGNfgW6pMYy3SQ3lLdc3mhebEXBqJpDPDnoi3v+nAOAjZsDUe89TUGJ9f88o4QO332z+F5VW3M6kCp0upAk5EpAfqwmtv2buGuz+c//+HTjiOR4BzzewHZC1Vx+T//54OyC64l6DbTVFBlEj7qmyyTyVmaH5wUbyB2VPC4k1T42b9bVvj7nq+Nu4O2XJwPOZsaCIFfevqNfH+UzGsHtK7VHKeMnXXjCVaYqudQkJEpF2pXiDRUIXUeLCE6tJmdJzrgEPJxmgtJssi2NJR2QVfksKdZopbtpVfOPXH0LgIkfalxlwkxiT5uBFh+aqj4yCq2C/+7r3ywIVh+f0NU8Ly7cW4JS68UJONBw2l0tQmLtfVZmCSBF3bq1IIxkIDbD8xnoKh/1/iefBaV67a52MSkT4g8dxum4LGlWJ1GcW7RZDl7i3A+9p+NrN7gPl5WdXZBUtTuA+pG+kWPAz5FtWWSR9V5cD0QmLCQh8fJ5bwhnj7O0YkLpRj48QWK7fGxzdmaDy0c81j8Zis1a8aF5aP+Gk8Js23JLILpiYr7mqaQ7BvS7VUDYq/PzuGxo8jTWPiwesoyBKR9qTGgzYFFcCd2ZKVtyANdPdNVe117+02A+buW8zs1WStWE/mZaPdfZWZDQPeDfxNaXbBfJk7eOkYr7Lci6rxlb6rigtGqrtU67p4VncS5cVXHRmWN66Lu+v1PzgOUp5dHT+kHT0xnudq83FxS9zIr8bdAYvbghZ0oG5YPI9XKghLdjesNQVRfVuqtnhA3BLcvCqu4LRd+nyJyH5IVQBtDu6ttW7JMrPvA1eQtSA9DAwxsy+4+2cT6y0EpgCFkuyChwDvzff7GzN7yN3PAKYD95hZE/A8cELJpm4ys2Py179197bMgm8FPpsvfxBwLnlK+JBXMEBZpFYSX/b6yRPC8taly+Ptpx50oqQvQdZNgGKVlROFgXFNdt2KuCVp59BEd6N18fZ9Z/y7X70tXv+FuXGQNmZCYkzJ2njW+dZEuUi3lqgtbnl2cVhe/1xcyeGpKRBERNqTGuZTiCpwa9+SNdPdN5nZm4BfAR8iC7bCIAt4G7AZ+E5bdkEzOxT4BtmcWKUtT/OB15B1ATzM3Rfny48gS4Ax0d1Xm9n1Znaau7dlF/yhu19Z6cl2CHWJkWokPh8ti+MHjeTnK9FSFc4Dl/hsJ+fJSgVhqRqh5XF3n+ZlcXfDwYdtCMsHNMQ15SteGBSW129NdKdM1LRbfWLMVmJMl5LySI9WZQr3Lk/xnrg+1o1IdGdMXB9Tk5F3+fmL9FIty8pXXnuxxpMRAw1m1kCW2e9L7r7LLDVjDbj7nXlWwNL35sLeA8DdfQtwt5ntOdHMNGCeu6/Of/4dL03hvn+iqDbVnUpBlNRStZ+vagbnJ/btrdUFYb4zvljZ9LgVry4ecsWWHXFN94yhcRA3b2E8pspGxr+fYr/E5bSQCIATv59CU1O8/8Rk0FKdupFxYpbihngetsKBU+Id1Mffr9Yn58Xrd/PEHKnPbyERpLSuSmXnrPF46sT1sXX16rBcRLpI4toYTS9j2+JhCimVBFlfAxaRpVm/08wmAx06JiuwgDIp3HN/bWavIpuc+H3uvqSirUa/8FRLVarlUEGYdGdRJULqIS3R5F7ckQiiUt19EvvfMiEut+3x9p/+3KywfPgl8Zix1ttGhuU7RsfzcDVvSKR4X/J8WO4t1fUN7/OqzH656eR4suldzfHNuGFr/PcbuCjRUtnNg6iUVCVA8fl4wlARkf1hiQrgapNbRJJBlrt/EfhiyVuLzeyUmh3RS/fdbgr3vPgW4EZ332FmVwDXA6e2t509U7iHFCRJb1ZFBUOqu0pqsta60aPC8i1T48QPw5+MHzI3HBSXH/DeBWH5Q89MDssHnRoHYU13xhfq1mUrwvLU74/UPELqThRLdVdLdOca8JP7O/Jo9t5/TbcuItJHJZJ22cAB5Qu313hMlpm9v8z7ALj7F6o6goQyKdxx99J8yF8HPh1s48UU7oMLwz35MBMdjyaklBpKfTZTSVvqx8SBTJQBsDBpfLhumIEHaFmxMi5fEo83G5DoLrVzTtydb+eKuALlzy0Tw/KGxjhI2bQ+3v7YfnF3pbop8f5bn46DQBEREelYvj2oYKsyUV4l0cZs4Fjg5vznvwLuBCrrmlel9lK45++Pc/e20WrnAHM7ZIepuWhSQZZIJNVlKdUaNDRu7Un2PZ54QPnCRJDjw+N917VUN2Zhx+R4zMuOIfHvLpWYonVlPCaEnfH6I5+OVy9sTXT3Whu3hCUDbLVUSXdWZXfMXa88LCxvWhiPqWxdFlfy1HzMloh0S8mM4sG91atsOKkkyBoJHO3uLwCY2ceAH7v7pdFKZVK47yRrdeoH/NHM7nb308zsOOBuoJCtahcCr8rnymo3hTvwdTM7E9gFtBC0ZO1xZGDl+84n59BKjdlyBWESSHxhi4nkB74mntA2pdBaflyI1cVjSlID+8Mmd0inr9+cmCenJe5XXZdo1m9aFZdvnR231K0ZGmf/G5mYQMIa4vWTN4JUv3G1oksXSmXPTHnujDgIa1wXtwRP/k7i2rkzvr4UN8ZDzQuD4uyjqTGrrYnrp4jUSOK7GV4bOiHImkQWHLXZSRY8pbSXwv0zwMfc/VNm9o/AsHzZx4Fmd28xs3FkSTbmJVK4/wRYtK8p3K1gFPqXr9FubUmka0zl29eDkFShkEjjnZrQM5WhzqM04APiICnVklJMzPNUNzJOHGGr44eQXYMHx+UD4+/m8CfDYjYfEQeZ/VbFl8uWwYnsaY/GY7JEerJUV/r6sXF333H3xOuvnRl//3YeGCeWqf9TnJ0xVcmRSrGe7OWi6V9EukRVFUC7aj9P1neBB8zsJrKxuecB30mt1F4Kd7IJg0/OX18P3AF8yN1Lr15N7B4DXJsU7oH6KZPC8tSEiiJVOWRaWJxqurbFiQxdY8uP2bKtcfavlhMPD8sb5yay4w2Lg6QNh8UpnAuJRubGtXGQtOHAeP2G5+KWsl2T4gPYeGCcXXDk6jg7Xev8Z8PyJD2k9WipDFjJXhZdLTUH4NL4+jBwYPz9GfiHuLvgqvNnhuUj7ol/f5ZKLLMr0V03VQGrClaRLmENcagTddW31hoHWe7+CTP7NXBi/tbb3P3P+7m/MW3jqNx9uZm9OLuomc0BrgMmAxfnrVodksL9JdkFCwMhaMlKTgarliqpIVuSaO0YlhiTNTIOVIqLyn++Uxeiuj/EYx44IK5J9sa4Nql+W/zdGfR8/JCzcnziIenAeMxUy9r4Ia9uZfwQXL898d1PzJNVl+huWdwWB8Hex4Msa0hMEZD4/afmeVv7+ngKgF2JxLX1iWnMhj+WmBnl4Sfi8h6u9eln4gUSQczI7/4pLE/1AihGE7WLSPeVHA8aP3sUt2wrW5bsxp9QaZq9ZmCTu3/LzEaZ2VR3r7La9aXc/X5glpkdClxvZr/uqBTupdkFh9SPdIKHldSDZro2q28/6EhC4mJQnBZn+Cus3xxvPpEBMNz34XFLy9pZcRAw+uY4O16xXxwE7RoQt0S19I9/d7uGJGqSVyeCqK3x/lsHJMZcNCbGtA2MuxP65tQ8SZonK5LM/JqYZ6yYuJkOWBaP6ek/P25paXkursCrdoB1t5ech6+6e2eqpa/btwSKyP5JXFtaN8XPTfVBBbGt2P9s5FBZCvePkmUYnAF8C2gAvge8cj/2t7ItK2A+9mqvu5K7zzWzLcBhwEMdkcL9JQp12OBgAOuK+CG10BTXdib7bUv3VuOWymhmcYCtY+NAYO2p8eBrSzyHj723/Ofz+ZPiY2ttis992MwJYfnW0XFLw/bhicQV6+P9T54RtwIOaIgfkheujseMFbfHl8vhj1b3EFc4NNGdcG4ixXtfr+CpsiUvlX2u4XcPh+XK/Sgi0gUSz211qR5A0fpVzlNcSYh2HnAU8CcAd19mZok0O2XdDFxiZtuADwP1ZvZe4BdkiTLeAWwApgMHAQ+Z2Xjg34HjyFqxLoMshTuwFvgS8Dqgn5n9tbv/ND4ED9M1RpkHoYIgSt0Je7Ya/32KUeIJYMeQ+PM3eFEcRTWtjx/1to8uX0nQvCo+952DE03yLfH6OwbH5/bClLCYzZMT362HgvT0QEsiMUb9yLg/19C745aoFw6Kg8imtXFSkoZ7E5k51JIlIrUSPbvouUV6sNZUUq6oF0SQkbkSlQRZO93dzcwBzCyRpzljZjeSJbkYWZLC/VPAL8mCtnvI5ry6MT+OK8jSse8A3ujuP8839QuygGsZ8PfA+8zs+8BVZEGZA0+SzaEVT8RD1t2vZWX5bh11Q+LB+a0bU9kHdTHq0VJ9e1ODoxNdluqGDwvL1x2WGDeSmOql34b4QX/IovLHt35W/NltnBCPWdi+IG4J23RwWEzrmEQK9w2JftVD4u/m0AfjVuiNc1LdGeO/zfAnE8efuFgXxo0Jy4uLngvLq5b47Bf6x62sasXv3QpNcSVDcXtcSWGz43mw1h4e192O+uXCeP+JB6mq55lLZAdMDjXo7t0V9ewiPVQqe2Bhajz9gy8Punp3Qgr3H5nZ14ChZnYZ8Hay7nkhd7+ovffN7PPAGW3zbJnZH8jmx/ofYLO7f26PVe4HrnH37+XLXwDMdvcPm9mbgUPcPTGYoWT/hULYZSuVAjvV0pUNHQvoQta9Jf4+yRt14kE1VaPSsClef+JtcaCz9YD4QbhxXfnP96Bn4nVfGBlfyNYcHl9O6hPf0rpFcRA05v74u7n4DYkU7Jvjv2398nj/W8fH3+1dc+Pzb1oVByEtqSCqxteO1GSxTIszr/JEPFtzavvd/iG0t0uNF00EUUmPxCnUmyYeFa8/NK4A9dXVzSGYlOiO6jv6eHdd6btq3YMrVfmdqOBoGRVX4Gx8+eiyZS233haum1JJdsHPmdmrgU1k47L+xd2r2evjwCfyObC2Aa8FHiLr+nelmb0l//kD7r6ebM6sc83sB2RzZh0DTDSztiv2x83sZGAhcKW7hynQvFiMu2ypu1/flvoyJ2pMUllsLDEmK9VStfjs+GLRlGjLHfRA+Qf5F86bEq7rG+OH5LrEM1hLIvva4Gfi79aK4xNBzJL4b7djaLz/XUPjALqwPQ7imtYkfgGPxEFI/ZjyF3qAlhWJ7I4pqZaqAyeH5Rtnxr/A1iPnhOWDFsW/n7oH54blKanJZlOtyKkKkF6vxve21Ji35pvuD8sVwoh0U7V+Lk5sv7itfHZAgPqn4grMEU+Uv7rUb6qucil8ajGzOuA37n46UF04l8sTW3w6395msiCqBfgK8HGy7n8fBz5P1mp2HXAoWeC1mKybYUt+7BOAP7r7+83s/cDngIvbOY/dKdyJn/SSta2JG7mCsB4u1ZKVeFBIldcluhum0jyPfCzefmFXfPwrz55atmzKrfG2l74zbkma9Mm4JnnBO+OWkA1nx01d/e8eGJY3JFqqWhLd/WxnqhUxfswrbIov9AyLH/J9V6IVvUqprq5bDoyDqJam+Pcz8g+J7Hnr48mmU9n9Ut+taluRk1QBJyKyl2ieKagg82vi2lkYlEj4lbg2+4S4K/6yU8vfm3fe8Jtw3RRLTm5qdjPZvFXxHXJ/D8DsP4Cl7v4/Je9NAW519706cZvZPcClwFyyIG2QuxfNbCLwv+4eTmYypGGUHz/0DWXLkzdi3WilCvVj4y/70gvjGXN3xXEG/VLf0uDjW781/uxuOCQuH/1gvOv1hySSyjTE2x+cmEZnUzyPMwPiuVBpiLO8MmRh3N2vfm51Y6ZSXVGT8/hUeW0qDIiH27YcFQ+q2zU4bsXt/3z8C/Yn4zE33hIHocl++Yl5yFrXr4/3/8oj4+3vSHQlTnSXSwaRIiI9UerelFo9NRY+ce9sPeXoeAfBrfGhh77Mpk1L9/sEKhmTtR14zMxuA16sanb3q/Z3p2Y22t1Xmdkk4A3A8W2p3fNFziPrVoiZNZMFg1vybost7v5kXnYLWXKN3wOnkSXACHlLa3U1mgqiurcqv8zJv29i8HPdiHgyYB8UP+htOiQ15isRiCyKj2/lK4NxRY3xmCMrxPveNjIe0zRgabz+1rHx3257/KtNdjcc/u0HwvJU0puWQ+KWuNaN8WSy9ZPjFPetqTFZVQZRqdrG7SccGpb3fy6O4Bvmxi2ZOw+fEpb3GxzXILQmWsJSqh3zZX/8S7z9qrYuItI9WWKi9sKgxLU78cyd6kGWCrJIlDc8EHfVb5k9vXxhJyS++GX+ryPdm6dmd+BesrFZfzaztmp+B9rqrceTpXJvJMs+eGnJdj4C3GVmw8m6EL4/tWOrr6Nu2IjyCyQygKVqO6WLdXEQ7InB4YXN8cWgsC1u7fFhcW3+tlFxbf7AheW3v3lmoitk4lfbvLq6pC/Dno4fgvstjOfBWvna8l0hATa8+biwfNBz8f4tMZlt3WFxS09x4ZKwPJm9b3sqSEj8/hM3ouZH4+5+2w+NJ8re9PJ4nrHh374vLPeBiWbaVOKBRIr7wtDEXCnKjihVqHWXKZGukqqgak2Up74bKYVobluguCnu5eGHTAnLl72i/L1311OpZHexsmduZpPc/Tl3v76qPey93fFk2QSHufs2M/sRcKG7TylZ5vNAW7Xla4CfufvbzGw08Gsz+7Fnd9SLgW+6+0fMrAAk6rqzC11xQ1AjmoqYpW9LPOilunSlysfcPyUsH/pY3OVq9Zy4RmjtUcGDaGvcUjJwXmK8YmIm5ELiGaPh0bg/4Px/DHsCM/jZePvbh8Xnt3l8nKJ6zIPxjaRhbeIEJ4wLi31xHOSk5smqGxkHOZ4IItafNCUs3zg1vtlM/sb8ePsXxYkxBj+TCHLuezQsTmZHHBa3VLI6OQOI9GXJpEjVPUhWnWJepEZS0y9sGxvnOhj40OKwvHVN3AvCh8cVZIXEc/sLE+IeRNFQgcRjTVJ0Vfg5cDSAmf3U3f+6ul3ttd/+ZrYLaCabA4t8X0Y2f9ap+VszgdsB8i6GG4DZwANkiTEOycuKwJrUjq2ujkLQLUiDo6WmEt0NBz0TJ39YfE7QCgvsHJYYdzO8fGvVqF/GXQLqEimKB/9/9t47Xq6zvBZez7RT5vSmo6N2VK1mW1ZxxabYYGPAgMEBQjAXQzoEkpsQCEnI/ZF8Xwo3X8gluSmXJBACptnY4IIL4G7Lkot619HR6b23mT3v98eMzLGu9lrH2jqec6S9fj/9JM07e2bP3u9+36esZz17+ELZc1UtHT/6B9yJqtrLf1vfBv7sFZFWGADgFfHPP/5+fu/W/U9+fWxC1NwIdT8lke71iOVPrD2l3+HqbiVXX0rH+2/g9YQTVdxJS7ZxI7VgOb8+XhvPdCIWBtBCBIBSOAsqcR8iRJ6geuCNLOFOSnErD5CNbuFU+8JHBui4jXJRKccUwwF4CVGKUOv/bGeCxU6okzX9rERJ+czhnGs1sy8DaEaWJviQc+6haW+5FkCnc+5UWPScSrjDy8CNkgkRtBltGI0KQRAVdSdHb+HjbiVfTCofFA2BJ/wX06FGPvcL+rmREV/O1fNMJHrSpUJ4Yw030lNV/NmzjFB2HBNOWqvoxVHDKQ2xPn7v3FEe7WP9/YAZ0AmdaJRdx51gN8iNyKoneCbIjfAsrKppUyurEr7w9vNMW4gQIUJciFACeGXbOdXdFfEAbWoZ37sK16/ixxfztT1awe2mom5eZlHzsv/ntwnRYAVmNTiffweCmVUCeDeA5QAGAHzPzH7lVLNhAB8C8O1ph5xzCXc6oWa5GW2YybrAEeeUpmUP8Ce640oeUYqImsLJOv9xE3TBsWX8s2Pjoo9Vv5BAn+BO0OQingla9ICoOWrj0bbOK4KJkrRfy49f+l+CjlbINyqXEk6kCAApdT2MB4vE97yFRyurd3KWgJq7TvRCkTVXgm6pKCvh2h4iRIjzEbLmqouzJJQyavkwDzAqqvf4pgY6nuzhAbzhJbw9Se/b/feW1M5gfEFmFV1qZkPIZrSKcv9G7v/OOScI7r64AcBx51w3AJjZXQCuBvBNM4shqza45dSbnXNpAL976v85CffDyDYvHgNwd27oewA+fqYvdM79C4B/AYDyaI1j3OlIEU+bOhEtzgRUsAoxtyGLm5WUqKCj9q3lER0n7DxFySps8x/PJLiROFUt1Pt280xEz2V8yYgP8x+3+mv82vVeyeXxh5dzYYnCXv77ip7k17b8m0/T8YyQSM+ImqmIUHhShfXeCN/ooqu5cEj3FTxTmezk3z+ymjtBxUU8WomXDtDh9BouzDFWz69fyT1cvTAirs/oKn59SnZw9UivWxgyIUsiRIgQZwNZTyjaX5RzlsbYFZzslnyBZ8IyYu1LPsn3Loi9r7iLO1kju/0zbUqMTMHXYnTOzRaBvRnAlTlp9nFkpdd35MZuAHDAOfdKBfg5l3B3Geq1ZwS3M8SFDWnoKIl3QRcc4gJ1SNWIup4pviAU1fkb8pXFPJMxOsmjTT2buRFd9yRfSNtu4HS1oUv4ePkxnumIDvPfZ01tdBwL6/jxogdaulMUhRm/d1LYYYpTImJLuRMyeDGv9xsWpPHeq3nEL97JN/IqoS5YWHcZHR9axgMgAxv5+a1q4zWBkb1cWSXZzYMA6VX8+ltPwHrgECFCzEsEDd4qKOXa3tt4vW33FdyJKewQVPrreIBq+b187463BlsbY2P8/Gt3+e+dLeOzL+F+rjEAoBpAH7I0xCiAXWZ2KYBvAEjlnKcPO+eGcI4l3OH4hDVB51KUkzDaeJ5DRISUITu6gRviyXW8RcDEFDdUJ8f4+Pigf6Z2apIfmyjgRnzvNj73+zZyI97Es2Ued2DLX+TFs141j8ZFakSPMzoKZFitJ4DhD3B1vfIDPBOIKX59XTnfSPndA1pv4htRUQUPQBXu4ZnK5d/lTna6gp9/ZPteOl6wdT0/PiUUplo4XVDJFEdFr5jIbt5sORM2Iw4R4oLErNuNgkoem+S7W7KZuwoZQUIQ7T0xUcvt7sgY37uxh9fbxvu4bZDZRqLbs6guOCtwzh0EUA8AZhYF0Arg+7k/tznnHjOzOwD8AYA/wTmWcEf2i/3PLy1MkZB3P7+h6ipENkH26mHtAQAU7+DZlKFf55SjdIovlksX8ohP82F/J2/jKp7SP9LLJcIrdvGVVi3E43X82Vr4M17TNHoRz3QVH+MOrFfOjfCpWu4EFA1xXvhUCZ97U9X8883j1yfRyjeSySV8bhU2841uql/c3xr+bBz7M07XK/8xL46u7lpCx62LO6kLfsw1kVSvFRVtTreKTGiIECFCnAEquK97rAXzBJT6nseXbkw08gDU+i/xANbYGr5392zhAby6o7zMx1vfSMf71vn/QG+XsBkF8pHJmo7rARx1zp0ws4sAPJ57/WEAP0HWyTqnEu4wo7QbqR4ois9DJ22OQ11/ocCmnDRPOFmxxTzTNXCcG8KRWu6ktb7EezEVrvA3JHcdX0yPNWFkL3lcdHVv5XS58W1cAtyGeaao6GfcSUSpyGQN8HtbOCyEIwSGeLkd4PhGGxWJDm8Vz5JWHBV9vjZzJ/SDy1+m498+uIWOx3by6x8XlI5MOXfCJmuF+mJM9IF7kfcpS7e103FFFZaGULg3hAhxfkKqVvPgrhKWMFGvmxHKrk7Elr1CvjZVP833rvYbuV1Su5OfX91RoczbyIUxFNW7YKU/VdwCJhnz7WR9EL9QEtwD4BYA9wC4DVm5duAcSLi/Sl0wUkJVtjJCRjjs2n6BQ9xfya0Wi52SEfc6ecQmU88N6RihdLkGHiCIj/Jza3sLTyRXHOHRqIlKoQ4onj3Vpya2gEfLkOafrzJBXgHP9GXifO6ki/lOl+Y+BJKd3IgfF5SMkZPcif5667X8BEr4/Km/nmd6umJ8oxxYxWv+UiX8+norOO8/ubKRji96gGcax1bx+V/w4At03KIiYqoCgKHoUogQcxOz3GMt6LNf/YM9dLxqijt5xkSzbAAAIABJREFUmc1r6XhsfxMdd0JZFsIJNcFAyqziyrezibw5WWaWQNap+nzupTsA/L2Z/SmAewGcuquBJdxfpS4YJ13HEDpRIYJBzR+lTil7NXUJyhmpuQKA1Gp/QzPazqNhhb38uxc+xelWmbhYKEUmx4mFXkXzlBOlZGoLRDNbJwI0Jau5sELDI5wOma7imTRLiT5Yx7iT03Y9V7a4eC3PFO7d2UjHR57g0czGp/jv77qaO7E1u3jI8WQJfzZKW/j1G7yUf3/ZIVFTl+ReckSMpzs43TFEiBBzEyr4KgMoYu8LGvzFcs6w6bmcBxir9otmwUv52h8ZFJmqYr522yQP8EXb+d5eWuJve0SnZk/CfbbxdgAvnMo8OecOIFt/BTNbA+AdudcDS7i/Cg5Axn9CRqt5NFJJcIdO2AUO1WdNRGzi3E9BStR/ekKGveRZ/2h8dEoc2yaosiIQHxnnxxeN8o2ENhGHpvKqmhtFyfBaOV1M9WmKjfHrO7Serz3l21vpuFfDv1/J7JYd4Jmsrscb6Xj8Ij4Bxt/OnZCjy7kTs+K7vOas+WZuCMQb+P0fauQPV8NXd9LxkXdsouMlx+gwXEpQzRUdUdSLhggRIj+QwhazLHyhvt/tPkjHq3cJu1bQITMqk8c/XdfSq8NVD0mm/JsJ1o34dXeycrVX3wGwDMBwrv/WnwIYRlYdcB2ABwD8U+795QC+CmATgGIAI865fWZWimy265CZjQBYCUCQ5gGXySBD+sUoQyvEBY6ADUlVzV5GPJHF7fzzC4b4eMdV/uOFXTzTNFXOT668gEfi4yN8KU0M8CyfqY1I1LwoXrrKhEUb6ul4uon3QYoIG7j0qHACC4UCk1AfLHxkFx1PX8Jrqrpv4vendLsQBvk+d2KSHfzzI338+pQ1CSdTKFQlO4JFLJMn+PxCRijTiiBCJCGERyZCJytEiBBngaDJgXwnFwRdMLJiGR1P1xBl2JeeOpszegV5URc0s6sBnARwKYD9yGajfh1ZJ2oCQDeAf88d8jvI0grbALQAqDKziHNu2Mw2AfhPABXI5qj+SH2/gRcZOiETLREWN5/fUPdPOGGRYu6IlLTx+TNZLrIFVYLS96T/50cnuZE+VcYXsrLdXEFIGZk2xnnpaZKBBnSzXivk456g+6l7772R93Eq7hQS95dwJ6HmCUGpEHTG1DUb6XhJi4g2xrkTpYqney5VClb8/lRM8UxXfJzPr6H13AkZW8S3w4nKzXS8cIBfv4pj3EnODAt1Q9UnLUSIECHORwQULMscO0HH46P+PTBNBC8V8kIXdM6NAag2s7chpy6IrIP0R2b2cwBfde6Vq1oP4Ledc98EADN7FDl1wdxx15nZamQbEv9gBt8drMhQKkiFTtQFDZXJEgWqpU08NV0pZKqdcCRcgf/87b2UC1OUH+fnnmniNTvRWm4kq67tig4lI/nquVfKkS28pikuarriaxrpuIvyPktO0B3H13A6YOGT++l49J0X0/HJWu7EpMr49at/lj8bxW1CuETM/Wgpn1+VL/HtrqiH/76KZzld0wknSdVjKmTGg9FWJBV+NVcXjYk+YkEl7C3GM3UhyyREiBBnA0XlRwEJYEXmt4T7dHVBP5xRXRBZCfdT+BCA70xzzPxhoggwoIR7iBAMWliFD2cquPiBV8gf6USTv7hA1R6eioiOCCOxiBenKich7428JdVTtW8Q5/8yd3KK9vC1R5HZEg/xmiEr5050xR4u4V7xEp+7KhPp1fGNLtLMJf7VZle0gzthvRsuouOqV0xG1eMqBasjnE5qRTxTCCX8so63QBhZxp345MNcYSytnLyAxfeR1Y10PHOIF7Xlff0Icd5CzV1FNY/U8QCQEnbIHOIS5IEDEAHLIPIOFSAVa7eR1jsuHezaziV1QT/4qQtOxwdxBlXBad/1Cwn3aCmi9f79ZNItPFoZtAAvxAUOsVjFm7iCmFIYi4todWqNf7R6fAFf6OOjfCNJHOUp+WidkFBXkf6ARl7eEdCJCwrVww1iPFrGnTSlnmf7uaHgBc3UiD5oS/7rKB1Xz5ZTDUNF8bh0QlRNYGUFHR9t4AGY5E+5k2+i5iui6L6kNQoAuElurBz+aDUdT7ZyQ7XhQX7/vMNKeWSOrx8h8gZV02OiEX36uNgbRQAohIB4dqMqk9Xg7xPYUaFaLDBn1AX9QNQFT/3/UgAx55xvGPdVEu7RGqd6YYUIkTeIxSJGAgQAAEEXjJ/0p/xER7mRai3CiBFUSBnAUAiNoNmFoEJbNVfvCywjHPD+eoKuF40H3O5Eva1UsBIBkEwDD0J4+47Q8YIHRCZQZMpUll3S7MW4MiRLmnkAc3AdP7+JGv+6CgBY/jf8+qiauPMeQQLI5/narBz0qGAJqACKt58/27LWPyjO8/unWALpfYd8x5wLRvPOp5P1IWiqIMysGIA550bN7K0A0s65fa/1c07BZTLBFtPzfDKGyC9UtFdlOzIiGs+K562b1xR5U0JiWuFCf3aUKIrYiJWRKxthCyM6WsbpZANbubpiNMXvb+nzIlOn1mVZ/CzGxfWZvHkbHU8XcTpt31ruZKVL+fkpmeTK44KOq+6/en5V7UFACXlFeaot47+vZhe//oMr+fERESQI6mQFff6Ciiq5Ky+h4xML+Poy2Oh//tX7+L5UtI8LO8t6vYC/fdb3FiV6pFgCIYJB3H8pCiSezehq/3pmO/EE/2yBvDhZZrYQwHsBbDazzyLbiPh3Abwnd05Pmdkzzrk3AVgEYIeZFQBIAfhE7jNKATyBLJXwmJn9NoBvOuc+w7+cL4ZhM+IQs4lIITcEJrbxuorouFBIW8g3UqZOWDDI53b5CyKTdYQbUSqaF7Rr/ZyH6hUSRJAHwemGrLUFAJTezWu+5Nq5mDe8VBulqodVEudjWzjlp/gEZzicvJnT2bxifn+TIlOjauKsRAij9HBhiqioC4FQp0yf4MI2Cqp9ReT5vfx4oS5aSZRTASAdVBlWNTsXwjYR0Szc+vn8ywhDfnAZj9aP13AnlTXjLugSPQpVewyR5VUS3EoZ9oLPQp7vCCgo5sTehlJCdQ9YIpSvTNZfIqsY+H9ytVnFAD7hnPslADCz3wGwPvfetwG4yzn3MTOrA/CAmX3POTeMbO8s5I7ZCeAu9cUWiyFa479Zer18owsVjkJQqGijMIQnKkWBbQUfr3imhY5nKv0NNWvzF8UAADfGa2ZUzY4nFjolb58Z4xv9XEe0UtDtFBTdTkFkGsa3cnXC3g3cCao8xOd28lleE6WcLFPPlmj0XfTT3XRcZWob9oqaq6CZHn40MgE3+8kNDXS8sInvfer5lKJRQhhkYAOnK1c/woM4adZQ9BxAzU8vYE1eUJTe+SwfD/DZs0xW0/vm6BzvAacyLerZCIP7swplO0THiZMmgjsK+WhGXAbgOgD/DQCcc1PINhWejiR+obO2HsCjufd2mdkAchLu0z5zNYA6ZDNbHBkHRyLGrIcWALj0PFdhCTGrUDLEMiLHD0f1z7hCWcc7ebSe9TJKDPPC+sQw32pLd3AHLyaEEYLW9HhDc7vW0hsYoOMRkamIiOvndXInOVLOzSwX5Wtb9V4eYCp8jKvTubiY3CnRqDtgpg9ObHfCCZIIeryC2luEk1e4k9eVpNcsoeN2iBsq6vmcqOfzd1L04ZMQ2RDVS0dBZorn+97PHIWAv03NDdneI8LvbdD2AQqSChpUeXaOQzFwMoqFMsvPhglRIuXkZsqJaE97sHUpH5msFcg1G86JVuwE8OlczdVfALgdwCCAN+fef04l3F0mg8w42awDeq155w6HmF0IQ0ZlOpWCV6qYz5+Od3AnasHPRHE3aco3+q4t9NjkUe7EyI0u6LMxz5U9VSQ8Iyg3alwVXysZ2+RuTjdquZVnIopqN9Hxyrt20XFliKiNVEaDFWVpvkeThZOX2sjXjsQx7qSnxdqnMl0uJrIV4vZ03cwzrWVNvM9X4lmurqii3TKTPt/3/lk8P/Vsp9s7+AfM9tovs+RzPJM2ywgc4JplSLtLBLcjHYRqHdBBzoeTFQOwGcCnnHPPmdlXAHwOwJ84574A4Atm9nkAnwTwRZxrCfdICW1MJnuhKMz1hTREMASMVqvi8+o9fCOPTPHvb7uRqw8WDPgrcKVFoik+zCWa48W8mW30kOgTJCS40yd5pmyuY7ZrzmTxtTIkRK+Whp9zOllG9AGDiIbOdrTXTZ7fhlJsEacDum5RlyDUF6OVXAZZ9qJJ871xaBs35Mp28PkzupAHsAqKRR8y0UIiIvoAZkbF9b2AoQIkSnTFiR5xQaECYN0f3UzHy4+JLP8Orh5oYm2UVNgL3e5UdE1xfVMrF/qOuWHBwBDIh5PVAqDFOfdc7v/fR9bJmo5vAbgPwBfPuYR7cYNzC/yldCMsywUtExziAodUweEP7OBK7unEJvliuuhH3BHpvN5ffGDBz3kk2yvnRkpkD6+5gTBynIoUB6x5yTtmO9IdNNororXpCu4EJ5ZxulmmmwszzHqmc7YNkVk+/1iDvyEA6JpJr40rwEWEzLEJJ0NlsqJTnG5cXs6f/6Ft/Pql9/LzrxI1e1HV50sZ+vmef/mECuCITENUtDfw+mbXyVKiOlMV/Pe1vpE7act7eZbVpCgKp5rLAJ5qz6Fqxua6FoESlRIByPgx/99vk8FUlV93J8s512FmJ83sIufcQQDXA9hnZqudc6ecp1sAHADOvYQ7UmlYp3/EzVS0S9V9XMgLbQj9sItoZ5WgVCluuhMRm5pvvuA/KIyoaLuQsVVOkogUW9A+RnMds+0kiJqU2ALeh2lkHR8fq+Ubce0uoTC2hGdacJgLG6iaGuUkZC5ZRcejQzzAdvJmXjeiSr7G67iR7+L8/i58gs+P8r0804h+kYlUxeEqSCKckILnD9Pxmr/lyqreVv79w2u5MdT7rrV0vOpuXlOo5m/HzbzFQXxMtDg4yQ394pe5uuP4Bq7emejn83t0qX9NaGKQn1vBi7zezxNzT2VBJYKunSJA1/A3z/CPv4rL5/dexqnc1bv52hmUBaGUV2VN1RxHJMkDJCYCQOMX+zvBmWdEFlbAZlDGdM5hZm0AKgAYgAlk67SeArAaWSrgFIBPOuf+MydqsQPAKxLuzrnvnC7hDqAWM5BwL7Mqd0XkBt9xVdegaraUgtqcj7aHmF2IiNLYu7fS8dg4N9SmSlUvGf/vz4hEUbJNNEqeEBLLu/hG23oDl8hefC9vZuyEk5Y5wbN8kZW8ZkVu1GkRjRTjEFn0zDDfiLGan7+d4JmM0TespuMDK/n1TfF9Dot/xtfG2L4mOq7okNFa7iQ6EeBQdRcH/+5SOh4r506G18/rAsr38gew/nFuiEaEBLismZztTLHK8ivRIGEoSplwSUkTEvMi26Ik8BW8Nl6XpNQ1ez94GR1PJfnxiWH/9a3sBF+bYi9wOlxEZAm9PqHqPM+dgBABodoriAAbMmevj/nsxP0YzPSeNU0kX6HjKQBLnXOvdD81s+8CGHHOffm0955bCfdoFNFyfxU1FXGR3OLQiZrTkCpBSvgk4P2NruPR9LbrVEROpPULRK8rUjYzdi034tMDXP2u7gEezRy+gjsBYw383Jtv45HaYpFpSy7l6oljC7gRV9QjorldnK41uJbT7Sof8u86D8wg0zclKC+blvPjBTye6ETlIf5sxHpEpksFuIaEMIhwwiKNnLLjmrgTvua3nuefH7CZtIKUeA/06ci7OqKiJOWbspTvFhIqHF75HzzbMpuQczMsswgRBIohJJ7NiKj3Tm31DzC6539Gj1WYD/yccyvhHjGqNKJuhlL4CpFnKPU/UVwvez2JzUJFY1NVQl2ihkfsivbwiE1SOBo9m/y3w8woDyBU9fOtdHSzUJ9r505IZEo4cTuVTCwfnqjh98Yr4A7u4HJ+/Oh1fDxdxE8w4q2h44khbgQPLeXLuSrOTgzxSP5kFX+22tfyZysT45mmwn7++xLNIhNZxoUZXKvIFKj2HSmx0YtMSIgQIUKEmHuIP7PPd8wmuN2ikC8nywF4yMwcgH/OCVMAwCfN7HZk6YH/3TnXj3Mg4f4qdUFLwo0SrzdAWjHEHICKxgonTEZERLRaUUqiLZzykxnzV/8DgIx4Yos7uaFX0uzvSNXdxY3ksQb+5QV93AmKtfHfXnGIO1n9a7gTWLuTB0DKOwXvXVAS0hU8lVNxjF+fwlbuoKcquQMd38Nrlgp6uPBERKg7Tm3mWVYVrnYT/Nmqepx//+RqXtOiiuOnhET54HL+7Nbe7b/RAoAJ4QQp86zqRkRNXbSKZ2JlH7lFvKbMK+JBgujzQj1S/P6xd3KFtoyQeC97gs9/b5abEYc4jxGwmbCCokvStkII6ZJBkWE2P4DIJRf5Dx7g+4ZCvmqyGpxzbTn638MAPgXgIIAeZB2wLwFY6Jy7w8xiAP4G2b5ZJwDEkXXM7pn2efsAfIQpDJ5CeaLOXV3zS77jrowbet5hToma8wpYIeY0Iht5cXakR3DXRcNZkIa1RlobAIAb5E5CRtQjKrpPrJFnwtSzkT7BC8Pzre6n6j3VRquM2Ogirj6XPslrchSVtfty7uT0bhVemGjkvvZLXBhBOVEQtzfRxeen9XIFr3RXDx3PXMOL3xOH+fWfWiXUA2PcCWu/SshAb+JBhprvcye/YkewXkZ9V3AnunszP76Cs2lR+4wQ/jjO1wdJBwz39rNGdAEPHkLsW4HtLgHVbDdSz8/fa+HPtqxJE1TosAxFQATPY3VCtIjY/c80fR2DE+3zqybLOdeW+7vLzO4GcLlz7vFT42b2rwB+nHtPYAn3V3854EREUpz82R97Lo4PcV4js+cAH1cf0NF59l+u+izNMtJNPNMRGLP97InPD9rHKrCTqdDBJfwrjnCqa/UuUTMjlDEzwomPPvYiHY8t5jV7bpzTPtI9XGLetm6k49FndtNxbxMPoMT7uJHffAs3FFKXcCcy/hIPIJa/zNeOVEMlHU8nuTmRGOGrV8MlfP51jXMnLTbGM30VKlN3jAvroI4L86Tq+PW1FP/98Vae6VfPt2zWHaSmLaDwwNAbeD1ocbsQ1ugSNP6AexfrnQoAJ2/l9ZylLVx5sriN/77EUR7ASJPgKADthAXMos97J09k+Sca/de2THuwLObr7mSZWRJABMAYgBeQpf79spndA+BUqHIpcnFJMysH8FVkRS6KkRXH2Jcb+xCArwBwZvYggF+ZLqZxRkQMRppuqmh94Jqt0MkKESLEmZDntUHJKEee4OOBz15EI6OruKE2sZQ7AfFBQWcVVODuDXztj67myqAqU+OVcEMmPsivcP2d/PwLekWmpo9n8iIiE1S0mGfiMmXcSR/6Gm+kPvlmfn1Sl/Hzb3qBO6mLHufzS9EZFV06MqIy1SKEJgxl78oNdDzexW2bsZX+z894NTcVK/dwZcvSB3gAQlFtM0KQSvVoy6gAiwhOLvku//1db+UsjK53iVrqlhV0vOEB0Z6iiT+bUtDLiR5yqlY9qKq27C/KAwiRVY3888f4szdZ4X9/XTRY/8l8ZLIWALgbQA2AJIAO59yDZvZhAFFk9+o+/EIp8HeQ7ZvVhmwj4yoziyDrqH0FWWftJgB3APgkgD+j3+7ApZYF9zV0okLMJqT6oar7CEJpOd+jWSHmNFQz2EwzzzSkNnAjOjrBn62IUP/rvUw8W9Vi75jiTmThSVFz+CKvmSzdJbLYqkWAqgtJ83rPTDv/fhMS9sWi5nHdn/BM9+Hf58Ix6QX8+g0t49e/uEusf2luqNoIN/QzIpOq0HEVN8S9Aj5e0uw/v53YGqLtPLbtRA9GE/uaotPNtvJkWsjrV32dj9ckheDVMp6F946IHoKzTFWVTpRw0kwEsKKKjlnDnTzr5QGEgW08ANR+rf/1ST1ND5XIRzPiY2b2DgBfB/AXAH4v9/pHAMCyzSCaAfxr7pB6AL/tnPtmbvxRZNUFX0Q22/XG3PvLAPBmDciqy3mEWy8fVjWZQ4QgUE7U8K2iT9YYX8yKOni0Ol3qb0hMVHM6TfmzXN3NE5QG9WxJB1MoQ857BF1bggZ4RCZp8iYuXDCykN+/kg5+/yKTfG6P1/H5GRHqf9FRMf+Ek7f2L7mhoyTkFYJKvOf76ZDnL8Yjgg6qQjwrPpc/CXNAZ3Jn+/6ohrlKvCHI+prvuTfrEAFGVdOlery5E4KqGhCKgRUp4+OTazhV10twL7ywQzhpXaJReqG4fvWcKpwq5udX0O2/91rAyZ0vdcG/A/BZAGe6s9cC6HTOnaq7OqO6oHNuu5n9JoDdAEaRrdP6bfnNzsmIXIgQZw1hKKuNTHG3o+N87ro430iHF/tHlIq7+bmllnEJ7rj47ZluEe08350ohTxnwU00a03u4sXdhQ9zJ1v1+cpM8ExQoRAlSq9vpONeUlBOBvlGnBbqdaouxU3lt89TiPMcqg/Zhb6+BoCiy7mlvCarZ6ugMo+J/pY/5aJAqp5VqWZPreBU3ejPeQAkchUX/bFxvvall3DbYqqcO1mxMe4E93MmLeKz2MYtHzVZ7wTQ5ZzbaWZvOsNbPgTg29P+/28A1iEr634CwNMA0mYWB/CbAC4DcAzA/wLweQB/fobv/IWEe6QE0Sr/Ce8kpSKYZn6I8xwBDeXEcW7IZUTdTLSSR3SqD/jPX0sKula/UF/Lc7POuY6gjbAVnS4opUMZYVMrOaVj4G28LsETfdyLevn5JVtEcfz+YMIpGWWEBmyIGSJEiPkJSdMXyp+FA6KesIgfb4JuGBFrlwm7IDLJj2/+06voeMlJvjbWbOcBtPGFPEBV3CaotuL6R0ReZWK1/97iCoPZdPnIZF0D4BYzuxlAIYAyM/umc+5XcnLttyKbrQJA1QU35caP5l7/LoDPnekLc324/gUAymM1DikyoVQ/BGVEC8qNMnTyHc0OMcsQ82NquZC6FeMq0zXS6J8NSCXFRtHHFZaKH9lFxxWdaNbr0fKMoJFkb4gXlweF4s0nDvJMVu0eUbOjJP5VLxiVKVV0KDV/FAL20lEKZur6O9HsePQKLtzQv0Y0q27i16f4rufouKQkiSABRN1O+lgTPz6UUA9xlojWcOXI9Bq+98V6eM1Yz0bu5EzUcrtwoor3QKzZxZ2QVCl/9otaeCpn+Ve56nH7B7hyKoR4RHEz3xtSlXxtKDjJ6YbVu7gTV/4d/wBZf0ew3rn5qMn6PLIZJ+QyWb/vnPuV3PANAA44514p/jCzYmT7eY2a2VsBpJ1z+8ysAcB6M6t1znUDeCsA0S0RQMZR2kZQQ0hRblw6XOgvaAhud+wF0QxGpP1VxKusxf+Rl07OmIgmBWmNgJDOkm8oJ0cpcM06gtKhAspQR1SvFaJaCwCjK7mhVXyCO9GdV3PKUf9m9fxwJ23h0/z+K3VHDAsnmglOAWh9N6dcLXiWO6mxQ1xhzesXNXMBhX0u+JrSeQxVTxnr5c8e+vmz23inqDddxdeWsVq+dsX6+d48vIyvPSfeyemQyXoeQCr4CV+bR1byz4+P8Gdvspx//2gDDz4n2/na13Kjfw/IqY75J+FeCOBxAAXIilWkcq9fCuAbAFJm9iMAH3bODQFYBGCHmRXk3vsJINtry8zuA3DSzByAYWSzZOoEaLbK4pz7CUEXDBfSEEEQmHIUoHj+fM8khbiwEWsQzX6HeTR67CKhgCUoP61v4uPOuCFUtJgbctUPCkNmlD+fE7XcSSzp5IaoK+WZqr4reN2HovQcvp1n+hBZSYcrdvG9vWYP39sTRzmV2wnlYW+Q379oBb//3gCna0freF2Lmt8T1673HSvayUVfem/myo6V33mBjkdKeb2lp5QXFYNIONDKbvMOCk01lUUVNP8C0Si+UEiYZ0a53VC+h//+om4uuDVRzbPUzvjaUnJIrB2ilrzpw/zZX/HvdBgdV/C1rWa3/+LTPDH/6IKTAN7inBvJ1VU9aWZXIltTdZtz7jEzuwPAHwD4EwBvA3CXc+5jZlYH4AEz+x6yEu63AFjsnOsxs78G8GEoCXcTtA6hAoOUEB5Qhmgokx2CILZQqPj08bS4d6X/RgkAE9X+i7V5fDExMTVLXuYbBaKiGW2J4J2Pil4nqpnxHH/2VDNRqVAlDAUlvJC5bhMdZ3MHAEYW8o2y8iDPlBQd5cIomR7Rp0sEwDI1PBMSEdd3qJGPD4tET6ZUeBEpPj/jj/Hzj4tmv1VPCwWzSSHMIYIwGOHHV/9UBChFlr6klV/gjiv4/Jt4E6dEHblEOJlHl9Hxxf/wMh1XThQEC0YFsUaubKTjmbj6fP+hgQ9eRA8tP87ntgzgiVp42Wg5KBU4KMS9iai9TVCJU4s5nTEuAiCqfUPbxfz6ji/gv6/hSZGlJpkiAJioFT0AH+Dj8R4egFj6H1wZufWXV/mOpXfMsz5ZzjkH4FRIJZ774wBchGyGCwAeBvATZJ2s9QAezR3bZWYDeLWEe9LMejFDCXdEY7BqkvpVwhfyYeIRmcywkDEJeeXzGyKiphTW+q9rpOMlzTwaDMHY67jc35AzxfYTPkpkGxc+UIiLFnTV+/hGLio+4Ip4NMyGeTTQa+e9UFRNiopER4R6nhPRykgj5+175ZwO13Y1H09dwulgRc/yOxAf4ka419JOx2VNk5BRxgSfP+kTfCOu+RfuxNcJuqGs9xWGojIkJd2Tf3veoQzx4h9y9crVuxsDfb8r5vMj0i8yVSLIkRkVwjQBUXz/S4GOZ/MrqWrJBZTddL5D2X1q7Yod42tjZiGnG0JQmafKg92fnov5szu+SAhzpLnd27WNj4/XcCcuE+fjNbv8184mofyokBcJdzOLAtgJYBWAf3DOPWdme5DNTN0D4DZk5dqBcyzh7mIReFXMmOGGTqSaR6NcM4/mK0NMRZsjojhYFUdLOlrAtPuFDtmLRNzfoh5+/2J9fKM++hFOGfFgZUliAAAgAElEQVSK/BeMZCv3okaX8Xvf+AhfSAtP8CxcupY/G5kEv7aeaBgpKSmqz5G4t14//31S3l9Fcwu5k+gdOkrHFZ2o4Qn++zpS3IkaW8g3o65t/P6WLuSZNFUcHWkSmdQ+fn9VJksJt4TqgsEQWBhGNWwNiGBuxuxjthvyhjh7REWAKLNUCFp18L3FOjidUj1b0UnuhMTE0rboMb42t/yeoCs+xPeG4TfzE1j4NZ4lP/lO7oT2rfXfW72X51kmCwCccx6ATWZWAeBuM9sI4A4Af29mfwrgXgCnVoxzK+GOYrgX/ZVSolUipa+kMgt42tUT3FyVqfKUAldQhE5UMKjO54JbPbRU6FyLXlWlJ/jhI0v8F4yRRj63Sxt4NG5whagpKOIL3WCjiGR38WtbsYwrQNmYqFcz1WtE0CkVpUUYQapPlDFVVOiaI6+OF2+nSrmTMbKen3/jEp5pGDi5iI4rZAr5/DCxNqc2cbpZwSHupGOIz4+MqMkJWQjzG6rhrBPCP5Gk6qMmShFEgC5wPXiAZugRoYyZEb8tuqqRjpugsjqlXKrWVhUcFc+uKSq8CqDt5wGC1KbVdDwyJZolC9XhiTpxfA2/fkfWCgbPBL8+U/znwRvje1PXNZyOufRb3DBqvZVQgYP5WHlrRgwAcM4NmNnPAdzknPsysvVXMLM1AN6Re8+5lXAvWuiiK0mBrFgMUvU8IpFoEg05hZEtZYxDzCoUZSVSzB9mSkUF4ARdcLwu2BOt0v6u0T/is2UJp0vtauFG8tQifu7pIv7bK46JTFi3cJL6RB8vMS4DDEGpvErdTmRSlHIkYnyji7bzmqeCl/n4omJeHN12GVeHyyzl12fhd3gmzsp4tBPi+iSEzG9GOFGKzhfUiVIS7tFF3IlWVPeRrZzO27ueP5+pMv77ygRZv/aHXAYadbzuxAk6qTJko4KOqzLVHb/E65IGruJ7d7xA9KHr505c2X5+fxZ9Q4gri5qvDBHmUPsiIsHqXdW9hXg2rFJQifkwPCE8oZAJmEWMNvJnM9LKg/NeK79+vR/aRscLO/ncqHmU262FXXzut13HWRBLv3aQjne+jwur1N3L947J9TwAW3HU3+6PTs4zuqCZ1QJI5RysImRl2//KzOpyNVcRAH8M4J9y7z+3Eu7OUUfKRHF9vFtQhjq5k5X3As0QFFJlSNXUqYawYrOJD/Oaq7FF/IFPDPHFcqzPf7MaqecbWWqYL7Ql4tLUvSQK34UTkioRXd+VE6KyyApBMxGqma0KsCjlSNmomgcAomu5OluqWEQjG3iAqqCF37/xrSv48T/jfdhUzZYUNRKIkCb2AOBEplEJlygnYWwNz2K3X8238+rLuQR/bZSvTT0j3FAaSfFMdsH13FDyEvz5r+wSCnOi5knSgcX6s/B+HoSq/x6nNCk6sGoRkFG2RUCqOgsAqyx7bAkPsEytXEfHezcK5UiBmKibqd0u6HYi+BmpFX20TvD2AaoMI9PN57aiIqvgffWPeYAjfRvvc3Xy7XQYNsmztCVCk+rkHTyAUdwuMoni2U20cWXP7pv86Zrp7fOPLrgMwGM5Z8oAPOOc+7GZ/buZ/TKABICvAzglysgk3H+MrIQ7ALQAuEJ9uZucgnfM/45HRcNEU71ahBOlHmY3GTphcxrK0HaiD9biYJSp2IhoiCoYI/EBf0O5ZUBQZcVaUyOa0cae59EqtZEXqD5Fii4z3+laYqNWa5cS3jARQKhq4kZm+RHO+ejeLKKh7Zxup5xQr5NLbGdWc0Mw3i7W5lKRxa7iTqIy4ltv4k7c1GX8+iyq5r//xD6eCWu8jz8/1UKdLrmTR5OdCBKMvJEbWqqZdWCI9UEa0gGROS5+n3j+laOjKHOo8G8BMHoxdzIGG4WyYw2/tnUvcKpl+R6hLHqCK2cGFR2xUSFqo1gOIriqAixKGVcyoMp4e4f6B/jcXvAkX/ta3s735qJufv+rH+Bp8K5b/NX/AMAJ9caJJaLH3rj/+UlBMIF8OFk7ASw4g4T7XwP4SwD/DOCr7hckWD8J90oANyIrgtFtZl9HlkL4KPvyTGUSwzf6p04rfsKTYa6cU1YUJUEVp4fIMwLw0gHN7fZEQ9fECKcNjHIBORR18fMv3OhvaE9O8eWg8ft8oRxeyiP1iUv4Qhlr4tdG9QKRNTFK1EVBKWyJjVDNDfX5MssqjNCoEN2BCACl1vG52XEl3+hS4uutWQiXJLkTKYVNRF0CREPLgY3cCfIKhAKWaCg6upzf3+RLQrl2D6ebXfQIV59TNUWqpjAt1k41/5U6nhJ9Sl/O21f0reOGcmG/MPSf5YZoRmSSZaY6YBBIqY86UdcUIZRAL86N6MrDfO6W3CdEj6r4s+1IYByYwbUNCNmnS0BRgSffdDEdj6QEg6WPs0Qwxe/PiVv4/R1dKrL0ig5q/Nkf+YQoyhLouYa3vkl28LV/lLAJM6JMXmHOSLg75/YDZ0z7+Um4OwCHclRBAHgEwPsgnKzo0DgqHtjnO+6tb6Tnbzt52lUVt0pDTxly8z0aP88hC2RFJjO2lHODRxYLBTrR9G9oI99IL6vyr7sZnOJzt/l6noVb/X94JL1/K6c7VR7k557ayhfi+HaRKRPRTEWnUzUN3mp+b1PF3AmND/PfHz0sOBcC3pBwQsVGGXmSG5ENTwULUGRiog+YEg5R0WqR6fLE2lq6l3+8QqUwtFQ0Whlq6vhZV8dTLA+VaRZOmidaAESe20PHa3aI4nwVIBN00FlX9xPPp6dqToVtwYJUZd8WNUsqOCmotvFxMXfjguoraunl7A9YTyuPF6JJqtmzElxTVOW0EM5IF/PzW/ywyMK/mQ5jqkJ8/s/4s3P8o/z4VDlfG8fruKdUQHxoxQ5SmDMS7uTtZ5RwB/BTAGvNrBFZquB7kKUanun7XlEXLCiqwOh1/vzT2Lgwkrdw7ioGeURBxdKlIRR0sZjvCBgtjVRzqVJV3J7aIApUBd1zXNQVja/ltAFVPF17P48IHtnnv9gOb+ALXYnIko2s45SS0uOimfB63uwzsauJjnsBJbSlBLuCiGSrxVY9uXknEqtnTzhJiiqdEc2EAyPPa2NQUaPzXhQpaCZHOXHKUA307XMAQZWBSQDYosLJEPtuSqztw8tEACHCA3wZYVglO4SoUtfstl+YrOVZ/tEFfG2sfZw7uekGlWXnF2hSqAu+788fouOtk/z7B1L89z+ykNfsLarje/N4pRAU284zdfU3+WepT9wfLHgyZyTcnXN+YagzSrg75/pzfbK+g6zn8TSAM5LiX6UuWLjQJQ/5u62umXN7lZSninbJTJXC+e5EBYSkVHXx4uGoirjtFbSFRl73MCwk2jc1cm5yyzCvm1rxa7xuZizt//0HOzhdKuLxc58s4wt58ig3Ep2Q6FZ0GGXkz3qk+XxvJK4yFeL6urSINs/36xMixHwGcdKk2SL23cgTL9Lx8ifzu3YG/nTBUCpeyp3E4j3BlEtjnVzUZUDQ6RY1cqr+N/4XV764+uMv0PEtpU10/GeFXBTnmgXH6Pj9TZwqnBGeTsdP/OswUkPB+IJzRsIdwBmdLCLhDufcjwD8KPf6r2EmwV6XgZHUtOpDJTMlQuHMiWht4F4X5ztmWeFNLZaqD1rkEHfCag/xr39xK8+UbruE1/TFRJVmy6B/AejUAI8mlozya1fSJtSrRE1AqkZIcK8QWcRBRYdTdBlON1M1YbGFXBly8CpeUFdyQkRTX+J0yKBOpGpPoKLVSt3PW8ADBNF2UdPSryT4xf0NuLaHa3OIELOEeR5gMUUlb+GZqPGbNtPx5FGeyXFxIYo0xa9v8Ze4MEbrf+Nr37P/xM//uffyTGbG49fvh/dfxY8XbNKiS/n121LvH5zuvCcYw8JUZuZcw8wuBfBVADXIBhAKAHwaWWXAdyObjdoD4NacgmB57v2bABQDGHHOXZr7rF8F8Clk67qqAFzrnKNmbHlhvbtq6e3+bxgWTe1ILwkAyCiZZVWTFTYDnt8ImM1IvY33IpqsEA1ZPf75kbT/eHxEyMs/9jL/bCGsoCSEFSTdbBV3YiJj/PunFnBhgfareOF9ZJvo05UWlI1xvlOUPc+/v+IIzxQlhkRD0EG+drnDvG7gvKezBYRqZqt7DXEnckIUzw8vEc2+u/nzX/LYYToun+/l4vkU7VPSx0Wn9RAh8gUVnBV7lwzwBGxEPfGuy+n4aB3//t6tfG1IVPG9I7GD763VQpn4xHvoMCLjQiK/kK+dNdv9jz9wz/+H0e6TZ11wnI9MVjWAWgBTue8vB3AMQBmAjyHrMK0H8ByytVe/A+AWAG3I1l5V5eTfKwH8Xe41D8CB3Pt5rsDzgH7/1Krqui6juUIBS3Z1D52seY2g0XAvITrHK90UJbPc7v/9JopzVUNKVdOkjpc95FRAaCcPgLgiLuwRP8GvXeMJLtyBO/lw5/WcSrqglc+NggdZ6SoCB2gyc53uqJo5C2EIiOJ5xULwRCZNNQvOlAgnvY9L6B/9NZ7JTa8UAT6IZrgv8OejoL+Rjsee020qGbrezCXIa0SfKNVLKIQAe77Es68CCJPXbaTjUVELHz/AafBeD2+kHnjtChgcV615ZntlLbxvJx1PCpZI2Qley554grMsIqsa6Xi6gq896/+c39+Ot/MAzuAablf1X++/dqZ/GqzEJx/qgj8F8AonyszuAbDIOfctAN/KvfZ5AKfuej2A33bOfTM39ih+oS74jHPuhtzrH8EM1AVTlYXoeL9/Pw6liV/SLqJ9e7mClSMOHgB4g8JQCp2wOY2glKKiBzm3OakU8ARljAqrKAlxJUEuMOt0K9XsN6AR5k4qBSuO6q8F7LMz28++uH7RdVyhanwZpwNams+vkUWi5q8ymHrhWL2guzaLAEWnMJREIkpJvFc9yJ2Iqr2C8vNT/vkFB3i9sXIilYJZRhXu7OWGWNUe8fwGbK9xvkNmK+r5+l3SRu6vuLUdV3FTcrKWPzuF7aKH3iV87YlO8vYgEbH1FPWI8+vhAQxVE5Up58H3jjfwtXPhnfzZUXCCCm8ii6wE4YZv2UTHK55vp+Ouige4Wt/DnUATW2NUkCymBkkATlAZFfJak5VTBrwM2awVzOwvANwOYBDAKVHIwOqC0xHvm0D9nf4S7qphn6IDZgRlKiMafoY4vyGzQVdxys9EiVDRqeXjRT3+u01GZMFKd4qGjzW8JicywGum0kJ0RvHeTWSqFN1KKUuaaPY7sXk5P15QOROdgqp8gIuiOJGJjDXw4mevnjvwI4v5RhidEO0FlvPlue9ifn8S9dxJVnRM18Gj7YPr+fdXHhHzg1BxAd3LJjPADbXyH+3ix4sgQuAQR0B1SdUCQTlxYYCRI7mfO+nJx3ivJ4/YJoqhseIIN4IHN3EWwChfmmQPs4p7dtNxxSCKiP6nqOJOUO/VPIvddaUIYJFmuAAwcAN3Mit2iWbNYm3x+jgLJVbF9/aSp3kpAep5vXL0GX7/Gvbz75eCYys4XZGpO3ZPBOyd+nrXZL3yxWYlAB4D8BfOubtOG/s8gELn3BfNLAbgb5B1uk4gSyf8Z+fcPWb2LgB/jGnqgs65957hu16RcI+XVG5Z99E/8T2vZBdfyKOTYiMdEHURzTztmVGUCFXzFYJDcafFZmKFnJJkCSFjLRqmjq7ji5GSmo008YgRWMPJbr4JR8Rvl5kice1VI29F1fVEllghWskX8q5b/TPgADCwlq8Ny+/lAZyJKu6ElD3PKTPKSUy382a/KgCgxtNCtGVkKXdyCvtEtFTUFBUMiExZA58/Rb3CydolMj0HRa8b4QQr4RIlTJIRAULlpMSW8+L0/ssFHVL4WCraXPU4Fw1Kt3MFtMAIe1TmDRbna1++lWFjyzgdre8qTnUdbeBp7uGLuN1Y2MIfrgU7xPFdPMAzupQHEBMDPAAyXsvPr+IFwfAq5rZF/0bhZMX4/RtezscXP+p/fZ5/4R8wNNw6r2qyYGZxAD8A8F+nO1g5fAvAfQC+eC7UBadLuJdZlav7x6d9z01tZFbMo+WqM3ioT5VnKO60Gg+42JtI209dyRfrSIobqn3XcEM3Tab3wqe4zGxkWBhxL4uaDGXEqCyfarYZMNLtiT5XFUf47y8Y4BtNdJRvhMln/TPsAJAOKCyh6iZsMTeix1fyPmheITckJqr4eO8lfB9L1Qi6ptgGk4e5k6UMoeqfcxaCp5woVXOoMkUNPAAzeilvwRAbF+qLo3x36rhW1GyW87Ux1sTnX2KYN/NOKnVIkWlO1/NshKJ8eS2C8jTbjsB5jLl+7RTdrvIFHjyfqOLP5rIf8u/v5QrlKGoWDKkTnCWS9IRybwt3khIqwJrgTrTV8z5WlT94iY6nruQXKNnJ1/6JWv/zy8QED1zgdXeyzMwAfA3Afufc3057fbVz7pR80S3IClnAzIqRzbiNmtlbke2RtS83Vuec6zKzSgC/BeCX5PcnEogt9o/YqUySiqbL75/t4v8QcxqqOL+wjxs6iV6eyVx0F89WjFzm70gNrOJGUN1jnFLgXXUJHY8N8Giat5+rlykEfbZMbATxXr6RpJJcBlepG1o934jTJ7kMsHJiZRb8CM/EJI7xTINycouCZjLV/a3nlKTJBv75iW7RXiPJA2xKwj6jml1H+fzzxP0p6+IBvsmtnHKUaOZBhqJWHoSJH+TXZ8HznC4cPSqcGNECAoISZiITFjSIEcIfKlOlIHvsyQ8Qwh1iX1ZU3onLz9ii9RWUN/HzH1jFA3S1u/jcV2tbYYoHaLq28b1r/B18bVNZ6mQbv/41P+Y1Z82/yyXii3r45ysqeslSf9Es76Vgwdt8ZLKuAfARAJ6Z/TqAgwD+CMCXzWw1ssmeKQCfzL1/EYAdZlYAIAXgE9M+624z25L790NKvh0A4HlwA1yFjEHRxRRCJ+rChjfE5178oR10XM0OlSktbPGPaAmBafnZxvsFwgtYuK6cIGXkKrpWehXPInZeySPlk5X888tqeCao5nlu5EaKxB0SEtlD63kkf6KC35+yE8KIFTVnXhF3slJJHjEcXSCUN5W44LC4P4JyUrydBzBQyxW40MgLT2xSGJIJvl1PlYiat/X8AqU3cyeqrIkbKko0KlXCDcmYcGK9bhEAVeuLBYtIz3UoFk6kTNWL+zvBSoJ8YisXnmh9I5+bBRdzlkI8GszQTXl87Skt5A52bRHPZLWIANzEcX7tC4Q4Yu8Gfv2q9okARA/fW2r/rYmOqwCmaj+hyiRUKcHSr/BMlncZb2Y8tkD0r20m9cgjwRIr+VAXfNLM3ghgBMA3nHObAMDMLke2B9aXTzvkbQDucs59zMzqADxgZt9DVsJ9CYAlzrluM/u6mV3vnKPqgi6ToU1HLSo28go+WSKd3BAKa6pCXLAIGEBQfZi8Tk5pUDBhxDXs4k6WCsA40cw4E1B9MdLKI/Vlx7m6Ycm4WJsC0jFFyY508kuVhLsQPrFl3ImQqONOctc1fDyjdlvxeExUCzplqaDzNfJMkh0VQYRR4YQ38/lbdETUGwsFttmuSZvzUE6kEPaR9fdsfCHPsrP+iwBQ2sS/uj/JA2SuigcgYoViPMavTXsHF/1JLOJzZ3yUO0GlTdyuLO5Syqv8+Jig+iphi8EPX0HHFZU6McDvf9U+oV748lE63v5xrl6Y5ksHJur5/Vu6xn/vbP5hsCxqXmqynHOP51QBZ4L1yMmy56iBA/iFhPsh59yplfsRzEDCPVNZjKEb/VOP5ft5WjhdIeoaLuPF8dEXeVo0dMLmNkzQCpQjoGgTnb/KmxGraH1xp4g2k7WmfD+PJtqYcHIEnSwqFJokPP7bvAFx/ooXLoyYwXdx5UclijO0jEfE1EZb0szXhvEKQXcUG3H8GV4ThqgIII3yaG/QRt2K0qNqlobX8kxTUQe/vhYwSDBRE8xJWrCdGwpd7xPKtye5JbLoGf75kZRIVYn762IiIiyEQyLV/P5ZkVgcRbR9qoEb+vEBMT9OCmEZkUmaXMad9Jio6ez9M35+NzRw26OA6Jx3T/G5saef13MO9vC1v+wp7kCXPMFN1dKneQBJ1VQp0SBll60u4PdeNuoWa4vQPtQQz2b5t57n4+rzBVU91shrvoavX0fHVeukri382XYRfn07nvWfv6lRFR7kyKuE+xnwSTO7HcAOAP/dOdePcyzhHh2ZQuUz/pSpTKlQWTnI6yKcMASDRqtD5BeRMs5dzgg6oGpYOrCZL8blu4STdpOo+yGLzeBKYYR2imhVHb82EDUXXe9aSccrjnInL/ESN9JkpqmEb/SpIqFgtIQv9DWCVz+wmt/bZJuIhjYLGvRxIcGvalKCUpkFXStazQ0xJXwSKeGZrN713MhPX8Hv/4Ln+Npedpzf3/gI36yHGoWh8AmRCerlppBXyY305ncK4Y8dSj6QD49Xcye4WtF5m7ghLRvBC3GF6GGRKV3KhTnSIlsQEZnshHISe/n8H9jN189H7+TiAiWt/tdnrJ7f+/IfvEjHl28R7T0meXA7MiTaH4i1YbaFNZQTFa3h1141U46W871VSdQrLYG+9/Bm0SNL+LNReTBYlriok+89qXI+/6p38fPr2sbXttQKfyfaFcyzZsQE/xvAl5DNUH0JwP8EcAeAfwOwDlnH6wSyUu1p51y/mf0mgO9gmoT7mT54uoR7QWEFJlb5p76jEyKapxqLC5WViOijpaLxYc1WQKjie6FQZaJuILOGU5I8UfdRtYAbylOFfLF+30a+2d1311W+Y+Nr+EKXbONOQP9abqTWdvFrW/MSV0jq3sKfndoRbgSlSkXDy/3cCRlZKjIRZXwxblrDjy/kXy8zKUMXCSP7YqGuJttT8ABRYSufu9bPx1Uz3JgIUKQL+XbWeDdfvAc3cMpQcauou1jA14b+dfz+N97DDc3jmzhVXW0Npfv5/F/8r3voeNcHNtDxZAffO0t282h/pkPQfQMqw0qIC5g+EayZuGSp7BMl5WLvWvFFPn9Upp6dX3lQUSHRR0lZNfkmeioGS2QZ33tGL+JZyo4reU1bqah3rt7NqcCxTlHzJpRH65/ja//wYr62lB8VdMEX+NxPvZGvPYkRfv7VL/NnJ0Hont0D80xd0A/OuVdIkWb2rwB+nHv9nEq4l8dqXcFO/6aeppoJC5UZxLnHLdPGqjjX5Xu5medQMuJCXGBkIy9eV8X7Y6J4f0oUv//tr32Njt8/wBX+7vvVv/Yde8v9v0ePTXyQ1/x4jm/iGz7ZRMef7+F9ejL38Ghez6XcCB1upMOIb+MKURP1fKN5x1ZuSGzv4pSJSdFIumOMOwHJNj63C3v52lH8FKcTqWcDoqFnpo6ff2oDN1TwGL++o5fzAEfXLdzJzyS4qVdygg4jNsavb8OT/P4ce59QpzRuSJWVckNmUrQfcY1c+GWyXDQrbxYsjjIehEGX2PsC0k3nPZSTOSnGA3y1m+sMnFmeG4pqnq7he09BDw9gLvsx//4p0UOx42q+9kYn+fklRZlB/6f52tPfK/p/NvBnv3IBp+K3Xi/uXxGf+8lyThf9yEVP+o617AvWf3POOFlmttA5125mvwvgswCKzOzbyEqzJwH8O7IZrSSA9twxdQA+DuBXATTk3ssRjcBY6lVQFlQvGQzyyajSwuf9RpFviOvrdXFKTvFj3JBRKjzeu0QfK8Ed/qfWN9Hx6gK+mHzq+G2+Y7EhHu3pfZY7mDHRKmPff/JzO/lZ/vn13XwjUMXXTojaKPW8VJlwgib4RtfTy8cLDwsJ/b38/Dq38gBP/1phiLyBRwvTxWJtquGGRHEJHx8RvUzwfi7jizjfaAvL+QS1Q9xQGFnGDQXVB6x2B8/kFfZyQ2q8kV8fvjIBXonY2yaEeqS4/UPLRCN2J2Sm20X1uurFc6E7YfMZStRG1WMKOp2JAJET6omqR+CYCJAN8FJ9TNVyJ9Ym+LO/7su8HrrrrVx5VpgVQBNnQVQs447IgKhHTif5uIm9I36Cz4+xYX5/Hqj03/sGU7vpsQomFWdmATnn6U0AagB0Avhi7v9bAawE8BCyjtNXAGxHVuI9DWAXsrRBc879oZndB+B6AMcB/COAzwBY45x/uqekaom7+K2f9j23xBDfqAt6+FYWaRK9PgR3NjPCnbRwo5hlKDphpVBBWiJkmk/w+XHsn3k0f1KoGC14lBs6nW8gjkoBn/tVzwhhhTE+NwsGuJNU9BMu0zp+E1cYKtnDM21uSDRsrOE1aUc/wvswTdXxjbJil6jJWcmvz8rvc7pRrF8Yoe08gGBibo9eJH5/uaBkDPL5lRZZ4JKjIoCV5Ne37Xf52ltbyoMAgz/kmZ6CoWAKYXFRmz/aoCTy+Xj1Gt5Hq6aYn8Dxxxrp+GQ1v79lh/j8aPgJf35tmJ+f180DmCoAJmsSFcK9+YKFErQ6/sUtdLxgI6fzjR/gTk7dTiEKleBObM9ldBhrtnAn7tBOztJIDPK1T9V7910lGGCTfG2pWcyv76dW/dR37H/cuhvH94ycdf+ZfKkLfugML3/NzBYBeBbA7QCGABQj61h1A3hTLtO1EMDPAfwhgCcBPOmc+38BwMzeCeByAM/4fXd0dAoV2/3FK4a28I008fABOg4RUQmdqDkOQcnw+kXqWIxP3sSj8elmvliUtYoCTpFtWP/X/nUP+z7LZXrH38adlOJv8Uh092V8uVn4Ge6gnmzjTszCQn58UbdQ73pyFx1f/kMeDR1bxDMd5vHzr3+CX9/IAF87Ug3cSex8K1dwGl0snOQVPBPTUMHHVa+a1ibuxMGJPkCj/PMjRwVd7gk+fxt2t9DxdD03hEpPiACOaFY9tIpnQssPiJqcFLcTvDJe77kUfP6pZtuRIR4EcEK8ID0sgiSCam9rOR04OsIDqGkh7BMd4U6a288La2ZbnCHE2UM2U97IG31nxOEjQ2JtqhYS7QV8bal+jK9d/Wt5pi/AF38AABdPSURBVKtlkAfgilbytX+kh6+tU4IlUlvHP7+7S5QStPPz/3/G3u471j7OHUyFOUMXBADnXKuZfRlAM7Lsh4eccw+Z2QLnXHvuPe05miCQbVT87LSPaMm95oupqgSaP+A/oUpP8IhA6i08mo5HX6DDsrN4KOE+p6GaMiop2EQ/30gzcb7YlrTwz5+o5IbG0Y/6BxFuuIzXvKQd/+yntnKFosr93IhvfAdvmHjFxU10/Nvpy+l41XP82as0Xs/WtVm0bxBlCzW7uRE2vojTqfjMANJJIXMs5s6i+4V6XZnoQ5XiG+n4ar7R1ZTx+VV5kBvp0TGeqerZzL9/cDm/fuZxdbzCTn5+wyu5kziyhF/f8Xq+N6ULRbNp0Wer/LjoBSTokCVt/PkauobX5HkFPIuv+ox54gEZX8GfvzVLuSE3PMWdzK6DPEiw4m5Ox40+y1soRIQo0+Sly+l4oodnAq3VPwCn+iwFrnkSTowU1hDqeZFGMbfKRQ+2OP/8rm383nj13K4rSoq9oZ8HWAZW82fTi3MnKjrB14aiu/jaUv0Mz0L3XcGdoKrn+PGjF/EA0IpxPj/aruEsh8kJ/+vnUueJ8AUAmFklgHcDWA5gAMD3zOxX2CFneO3/etqnqwsWFpRj4ZP+i40nFKoK9/GIQEZxh0XDTCgpzvneUHGew6WEJS3uT7yJLybLHhCLoShu7l/DHYFFj/kv5k96l9JjY5fxSPPvv/ceOl54K3cwH+zlxa93PuWvjAgAFfuFhLMoKlHRtLR4dFkPMgA48XEhDNDHv/+9V3NhikUF/P6sEr1cyiLcEJhy/PpOOL6RdaT5Rh0Fvz6NCe4Ephy/fo8Orafj9zx0JR3PxPjvi67gTty4SNQVCDu2dgcfr9wt+sQJCX8k+O9LCtGn6GJBpxQS89ETgi4o+lyll/FM/LCoqest4Wtv5SH+fCSjfH2LDQo6ohBXyAxyJzDxHGfZqB6O+Wwvo7J4QftTeod5FjFSyPfNeA1nQYzfLERdMtyJqf5P7qR1XClUiffztbN8H18barfzvbH5Xfz3T72Ns0gqD/P72/IufvzIJfz+RruEMEkFt6uLq/0DZJFEMJt7TjlZAG4AcPxUg2EzuwvA1QA6pwljLARwKuTSgmzPrFNYDOD/4gJOVxcsqVrixhb6P1Bluzmv24lMk2qYqI4Pnai5jYgwRMbfzOmAHRfx44eX88XSCYG3ZffyxaRvvf9mddH1vOv6byz6OR2PCCN5SYwbaTcv5fJtn7F30PGnkrxPDNLcSBtvFdEuUXOSPMmdkPgh7qUVbeE1M/uH+EbUnuBG7PeGOPG+o4lvpHVP899XIOpZXZQbCi038vlTepDfn5FL+drqRPH4pVdxQ+zyyiY6PiY4QXcf5ZnS1Av8/lXv4c92y9t4pqioizu5itJUcVg0Wn+eBwGshfeY9IIa+e08iFC6XQiriL1XZlvSot56lksB5rwCIEG0lkcgvOV87Zuo42vrlMiSpwv42mRClDizklNNr195mI6Pr+FrW8sRTnUdGuCGQd96vjaUCEZc3Q4RIIicdckSAGDh0zxLnH5J7M2V/Ab1bhABpKf9M22RAbFuCORF+MIPZnYFsn2xtiFLF/wPZIUulgLodc79pZl9DkCVc+6zZrYBwLeQrcNqAPAogNVM+KIsuchdufHXfc9hqpJHTApf5IagE7xx1RDVUxLxIWYVsh/GCl7gObiRO9mTYrEf4SrmMBERK+TBfhQM+i9GJS082jRZJSL5E3yhm6jii1WqmP+2Ib7PYOnD/PwL9vA+N143d3JiDaJm7AP85gk2HVLlwsGu4xtdYbH4/XFuhKmaqbEREU0e4kZoZIzP/UyRUI+s4r+/NMmdrHSGf//EOD9/b0oIewiFq8gGnolIFvL719vH6aRKYauwhz9fiWFuC1Qe5IZkdJBff2sWTpZo5B4ixKxBqBvaZp4FP/gbPJNVtk8EiJbwtU8pe1YcEJmuffzZdaJ/Z8/F3IktO8H3lslyvvaOLhR20Qr++QXV/Petr+cBmETUP8DyyB13oW9/9/wSvvCDc+45M/s+gBeQVRN8EdkMVAmA75rZx5Gt17ot9/69ZvYigFOezTeZg5X7FiBz9h2cM0s5JSHawR8mr1M0XAwRCCrtH1nAI2bjq/n97fxNbkgsruCUnG0V/GG/tZJzgu545mN0fPk/cDpr563+TQ+bb+JGWsl6XjP15kU8Wqeg+mT1HeX3rm8dP/+y4kY6XtDL2zN0bOQb6YLneE1ORhQnj9aLLGmtKI6O8vHIEN+pq0Qz2cXHRbPhFA8wZY7xcGn6DbymL9HGo52Dl3Lefv8aIYywgdes3HIxr1m8+Ar+7KUE3fL4JJ/fxyt4pvFwOT9+ZJSvjam9gvLkxPyL8PHYJiEDfZBf/+hJvncqlogn6HaREu7EhqJV+YPMIgq6YaRY1FxN8ADOVDWf27UNnI736294go4rqvX+UU7FfXwlj0CODKt6VL42FvbxuV344+fpeFL0ny0XAZbIJbz1zfhi/vlNy3iz5/Jj/lnolKg1VZhTmazXCjOLAjgE4K3IUgefB/Ah55xvBWlJ5RJ36Vv8JdxLHuJd700Un6pMVbqZb8ThQs2hFlsTvZCwppEOT9Xy+9v+m3wx/sLFD9DxzQU8m/LyJG+o+oX7PkDHY6M84BJb77+Y3bycF14vEkUjYx6f+6VRbgTVxvhCu3O0kY7f+wCvqYkP8WsTF+JlI0uFhHYxD96s/d/cSbV+/vu9Hp5pU4aEgswkBO1DJI6Pio0Yqt41yQ2h0fVcuGKqlDtBU2X8/EcX8vGJRZxOVr+Uz48FxdzIVz3ySuOi5k4oSwyluJO2r4df36GDPMu/YLuoK3n8OB3vu4EbmoUDPIhQdFKwUJpEJk6pH4Z7e/4QcO3yRBlA7wYRwOD+O2KifUNsgp+fEoVRmaaCPm7XTCqGV5cQJernP9DF+Nrbv0UEkER7jLEGvrYklvif34nP/jMmjraeH5mss8DlAI44544BgJndiaxwhq+1GJnKINlCitxqebTQjYq064h4WhTChoocTqTVVzTS8VQZXwwLOrghM9HJo7H/UXk1HX+qjPP5Dg7yTFpxG19MljzADfGJhf6r/b5jPJO0L8MLw5EWNTnj/NnxVnMFKPP43F8xKZQDjvBMSkY0O10QMJoauNpSrA2zTrcKuvYoQybg+dsAvz8FQmI9OsGjyZk4H08LOqgV8LVrcJQ7iT1CYSwaCzbD0mlu6HjD/PdHxkRDUfH9Q6Jh6egHeDR6vFYYogXC3MmouhXuJDIqNgDEJvn5lf2MMwG8Xu6EX9BQdD+hPqh6qMVO8Gs/dgNnQbiV3C4cFf0vE+382RPCvyht4dfHieB0JCXsrv08AJJWjcQFKkV7hzLxbKTfwp3koaX+dlFU9PhSmO9O1iIA01MDLQCuoEeMjcM979/B2akCzG5uJCu6mjI01MOuoKROJUSvkdkW5lC/X/0+b98hOp5YxNPumUouNdp4D//+jibuiPSM8fHhRj4/YiLY37ONGwLJDv+IVvP7xbUR9Z+lzXwhLuwTkeTHhYRxHaeDQSk/ClEaNfeUExBdxSWUx1cKhaZyIcF+TPQpOs4j7W5c1MwIURdVLxrZxOsWBi/iz1b5QUEZ6eXjrkzIKGf4szXaIJwsIdxR+yL//PgIf4CSz4hMyUqe5Y4e48dPXtJIxyMef36jY2L+HGii497FoqhSwMX53pRo4qJVmUq+eKr5KRL1qNzL52fm5f3881UQIyIcBSE+IG0DtveL4Gbeg7/i+9VvV6IhJhrZL32IO+iJk3xuDGzhWeDiDtGIflj0aBNOaM9WPvdjY/z6pm7kysDF7TzAOlnNH67BZXxtrjwk6pVf5gHWRLW/aJYSPVGY73TB2wDc6Jz7RO7/HwFwuXPuU6e97xUJdwAbAXBOYIjzHTUA+I4c4nxHOAdChHMgRDgHLmyE9z+EmgPLnHOiAYc/5nsm6zVLuJvZDufc1tfn9ELMRYRzIEQ4B0KEcyBEOAcubIT3P8Rsz4FgZMP843kAq81suZklAHwQwL15PqcQIUKECBEiRIgQIUJcwJjXmSznXNrMPgngJwCiAP7NObc3z6cVIkSIECFChAgRIkSICxjz2skCAOfc/QDufw2H/MtsnUuIeYNwDoQI50CIcA6ECOfAhY3w/oeY1Tkwr4UvQoQIESJEiBAhQoQIEWKuYb7XZIUIESJEiBAhQoQIESLEnMK8c7LM7CYzO2hmR8zsc2cYNzP7+9z4LjPbPG3s38ysy8z2nHZMlZk9bGaHc39XThv7fO6zDprZjbP760LMBDOYA2vN7BkzmzSz35/2+kVm9tK0P0Nm9pnc2BnngJm91cx2mtnu3N9vef1+aQg/zGAOvDv3/L9kZjvM7A251wvNbLuZvWxme83sf0w7xm8ONJrZ+LR580+v3y8N4Qc1B6a9b5uZeWb2/mmvfdrM9uTmwGemve43Bz582tqRMbNNs/sLQyjMZA6Y2Zty92yvmT027fWm3Lr+kpntmPb6bbn3Zsxs62mfFdoDcwgz2AfKzexH09b7j00b87MHz3j/Q1tgbmIGc6DSzO7O2QPbzWxj7nVmD/rNgdduCzjn5s0fZMUtjgJYASAB4GUA6097z80AHkC2wfyVAJ6bNnYdgM0A9px2zF8D+Fzu358D8Fe5f6/PfUcBgOW5747m+zpcyH9mOAfqAGwD8BcAfp98TgeyPRDYHLgMQEPu3xsBtOb7Glzof2Y4B0rwCzr0JQAO5P5tAEpy/44DeA7AlWIONJ6+ZoR/5v4cmPa+nyJbt/v+3GuneiUWI1uX/AiA1WwOnPaZFwM4lu9rcKH/meE6UAFgH4Cluf/XTRtrAlBzhs9dB+AiAD8HsHXa66E9MIf+zPD+/9G0dbwWQB+ARO7/fvag3/0PbYE59meGc+BvAHwx9++1AB71+Zzp9qDfHHjNtsB8y2RdDuCIc+6Yc24KwJ0A3n3ae94N4Bsui2cBVJjZQgBwzj2O7EN2Ot4N4Ou5f38dwHumvX6nc27SOXccwJHcOYTIH+QccM51OeeeB5Ain3M9gKPOuRO5/59xDjjnXnTOneq9thdAoZnx9uQhZhszmQMjLrcqAkgCcLnXnXNuJPd6PPfn1Pv81oEQcw8z2QsA4FMAfgCga9pr6wA865wbc86lATwG4L25sZnMgQ8B+HbwnxAiIGYyB34ZwF3OuWYguzeoD3XO7XfOHTzDUGgPzC3M5P47AKVmZsgG3voApAF/e9Dv/oe2wJzETObAegCPAoBz7gCARjNbcNp7XmUPkjXgNWO+OVmLAJyc9v+W3Guv9T2nY4Fzrh0Acn/XBfisELOLc3VPPohXG0p+c2A63gfgRefc5Fl8X4hzhxnNATN7r5kdAHAfgDumvR41s5eQNbwfds49lxtic2C5mb1oZo+Z2bXn9ueEOAvIOWBmi5B1nk6ndOwBcJ2ZVZtZMbLsh1NN7WeyDnwAoZM1FzCTdWANgEoz+3mO4nX7tDEH4KHc6792jr4vxOuHmdyPryIbVGkDsBvAp51zmXPw3aEtMDcwkznwMoBbAcDMLgewDMDi095zuj3I8Jpsgfkm4W5neO10ecSZvOdcfl+I1xeB74llG1ffAuDzr+GYDQD+CsDbXst3hZgVzGgOOOfuBnC3mV0H4EsAbsi97gHYZGYVufGNzrk9px8/De3I0o16zWwLgB+a2Qbn3FDgXxLibDGTOfB3AP7QOedlA9m5Nzm338z+CsDDAEaQ3YTTM/pSsysAjIn5EuL1wUzmQAzAFmQj1UUAnjGzZ51zhwBc45xrM7M6AA+b2YFcdiPI94V4/TCT+3EjgJcAvAXASmTv8xNB1u7QFphTmMkc+EsAX8kFVncDeBHT1vvXaA++ZltgvmWyWvCLiCOQ9UbbzuI9p6PzFKUw9/cpSsHZfFaI2cW5uCdvB/CCc65z2mt+cwBmthjA3QBud84dPauzDnEu8ZrmQM5wWmlmNae9PoAs5/qm3EtnnAM5elBv7t87keWArzknvyTE2WImc2ArgDvNrAnA+wH8o5mdogF/zTm32Tl3HbKUocO5Y3zXgRxeS8QzxOxipvbAg865UedcD4DHAVwKAKeoXzkK4d3Q1L/QHphbmMn9+BiydFHnnDsC4DiydTlnhdAWmHOQc8A5N+Sc+5hzbhOA25GtzTs+7S1nsgfPiLOxBeabk/U8gNVmtjznfX4QwL2nvedeALdbFlcCGDxF/yC4F8BHc//+KIB7pr3+QTMrMLPlAFYD2H4ufkiIs8ZM5oDCmWoqzjgHctmO+wB83jn31FmfdYhzCTkHzGxVjocPyyqMJgD0mllt7p7CzIqQzW4dyB3mNwdqzSya+/cKZNeBY7P4+0JoyDngnFvunGt0zjUC+D6A33LO/RAActkLmNlSZKkkp9YDv70AZhYBcBuyvP8Q+cdM9oJ7AFxrZrEcNfQKAPvNLGlmpQBgZklksxIqOxnaA3MLM7n/zchmMZGrw7kIZ7l2h7bAnMRMbIGK3BgAfALA46dlnmZcY3tWtsBrUcmYC3+Q5c8fQtaD/ELutd8A8Bu5fxuAf8iN78arlUG+jWy6L4WsB/zx3OvVyBbGHc79XTXtmC/kPusggLfn+/eHf2Y0B+pz93cIwEDu32W5sWIAvQDKT/vMM84BAH8MYBRZysGpP3Wvx+8M/wSaA3+IbHHySwCeAfCG3OuXIEsX2IWsUfWnM5gD78t91ssAXvj/27u/FyuLOI7j7w8VhVgUKGR1UW2hZBeRhBhRSwVZGP0gkKBuuqggEG/sxuhaCfobCooIoiVKwpJYy5WyX7vrWgsGEYgkehVRu9D27eKMdAhXV3jYPSfeL3hgz/PM88zMeWb3me+Z2TnAoytdf7cLt4H/pH2Dtrpge/0FvVXnpoAHLtQG2rFRegtmrHjd3ZbeBoBd7V7PADvbvpvbvZ9qv9u7+9I/0Z4Z88ApYH/fMfsDA7Qt4TlwHfAJvb7gDPBM37mL9QfPef/tCwzmtoQ2sKX9PZ8F3geu6Tt3sf7gYm3govsCZ5c4liRJkiR1YNimC0qSJEnSQDPIkiRJkqQOGWRJkiRJUocMsiRJkiSpQwZZkiRJktQhgyxJ0tBJsjvJsSTTSSaTbF7m/EeTfLSceUqShselK10ASZIuRpItwDbgzqqaT7KG3hdOS5I0EBzJkiQNm3XAmaqaB6iqM1V1MsmmJAeTfJtkf5J1AEluSXIgyVSS75KMpOe1JDNJjibZ3tKOJhlP8l6S2SRvJ0k7trXtOwQ8ebYwSe5ro2mTSb5PcuXyvyWSpEHilxFLkoZKktXAIWAVcAB4FzgMHAQeq6rTLWh6qKqeS/IVsKeqxpJcQe8DxoeBF4GtwBrga2AzsB74ANgInAQmgF3AN8Bx4H7gp5bnqqraluTDdv2JVra5qvprOd4LSdJgciRLkjRUqup3YBPwPHCaXsDzAnA78GmSSeAV4IY2qnR9VY21c+eq6g/gHuCdqlqoqlP0ArS7WhZHqupEVf0NTAI3AhuAn6vqePU+nXyrr0gTwOtJdgBXG2BJkvyfLEnS0KmqBWAcGE9yFHgJOFZVW/rTJblqkUvkPJef7/t5gX+fleec+lFVe5LsAx4BvkzyYFXNXrgWkqT/K0eyJElDJcn6JLf27boD+BFY2xbFIMllSTZW1W/AiSSPt/2XJ1kFfA5sT3JJkrXAvcCR82Q7C9yUZKS9frqvPCNVdbSq9tKbVriho6pKkoaUQZYkadisBt5M8kOSaeA24FXgKWBvkil60/zubumfBXa0tIeBa4ExYBqYAj4DXq6qXxfLsKrm6E1P3NcWvvil7/DOtoDGFPAn8HF3VZUkDSMXvpAkSZKkDjmSJUmSJEkdMsiSJEmSpA4ZZEmSJElShwyyJEmSJKlDBlmSJEmS1CGDLEmSJEnqkEGWJEmSJHXIIEuSJEmSOvQPxls9/4zOGxEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# select section of data that is noise\n", + "noisy_part = audio[15000:len(audio)]\n", + "# perform noise reduction\n", + "reduced_noise = nr.reduce_noise(audio_clip=audio, noise_clip=noisy_part, verbose=False)\n", + "draw_spec(reduced_noise, len(reduced_noise))\n", + "IPython.display.Audio(data=reduced_noise, rate=samplerate)" + ] + } + ], + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/perceptron_binary_classification.ipynb b/examples/perceptron_binary_classification.ipynb new file mode 100644 index 0000000..42a6ea4 --- /dev/null +++ b/examples/perceptron_binary_classification.ipynb @@ -0,0 +1,1267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from argparse import Namespace\n", + "from collections import Counter\n", + "import json\n", + "import os\n", + "import re\n", + "import string\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from tqdm import tqdm_notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Vectorization classes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Vocabulary" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class Vocabulary(object):\n", + " \"\"\"Class to process text and extract vocabulary for mapping\"\"\"\n", + "\n", + " def __init__(self, token_to_idx=None, add_unk=True, unk_token=\"\"):\n", + " \"\"\"\n", + " Args:\n", + " token_to_idx (dict): a pre-existing map of tokens to indices\n", + " add_unk (bool): a flag that indicates whether to add the UNK token\n", + " unk_token (str): the UNK token to add into the Vocabulary\n", + " \"\"\"\n", + "\n", + " if token_to_idx is None:\n", + " token_to_idx = {}\n", + " self._token_to_idx = token_to_idx\n", + "\n", + " self._idx_to_token = {idx: token \n", + " for token, idx in self._token_to_idx.items()}\n", + " \n", + " self._add_unk = add_unk\n", + " self._unk_token = unk_token\n", + " \n", + " self.unk_index = -1\n", + " if add_unk:\n", + " self.unk_index = self.add_token(unk_token) \n", + " \n", + " \n", + " def to_serializable(self):\n", + " \"\"\" returns a dictionary that can be serialized \"\"\"\n", + " return {'token_to_idx': self._token_to_idx, \n", + " 'add_unk': self._add_unk, \n", + " 'unk_token': self._unk_token}\n", + "\n", + " @classmethod\n", + " def from_serializable(cls, contents):\n", + " \"\"\" instantiates the Vocabulary from a serialized dictionary \"\"\"\n", + " return cls(**contents)\n", + "\n", + " def add_token(self, token):\n", + " \"\"\"Update mapping dicts based on the token.\n", + "\n", + " Args:\n", + " token (str): the item to add into the Vocabulary\n", + " Returns:\n", + " index (int): the integer corresponding to the token\n", + " \"\"\"\n", + " if token in self._token_to_idx:\n", + " index = self._token_to_idx[token]\n", + " else:\n", + " index = len(self._token_to_idx)\n", + " self._token_to_idx[token] = index\n", + " self._idx_to_token[index] = token\n", + " return index\n", + " \n", + " def add_many(self, tokens):\n", + " \"\"\"Add a list of tokens into the Vocabulary\n", + " \n", + " Args:\n", + " tokens (list): a list of string tokens\n", + " Returns:\n", + " indices (list): a list of indices corresponding to the tokens\n", + " \"\"\"\n", + " return [self.add_token(token) for token in tokens]\n", + "\n", + " def lookup_token(self, token):\n", + " \"\"\"Retrieve the index associated with the token \n", + " or the UNK index if token isn't present.\n", + " \n", + " Args:\n", + " token (str): the token to look up \n", + " Returns:\n", + " index (int): the index corresponding to the token\n", + " Notes:\n", + " `unk_index` needs to be >=0 (having been added into the Vocabulary) \n", + " for the UNK functionality \n", + " \"\"\"\n", + " if self.unk_index >= 0:\n", + " return self._token_to_idx.get(token, self.unk_index)\n", + " else:\n", + " return self._token_to_idx[token]\n", + "\n", + " def lookup_index(self, index):\n", + " \"\"\"Return the token associated with the index\n", + " \n", + " Args: \n", + " index (int): the index to look up\n", + " Returns:\n", + " token (str): the token corresponding to the index\n", + " Raises:\n", + " KeyError: if the index is not in the Vocabulary\n", + " \"\"\"\n", + " if index not in self._idx_to_token:\n", + " raise KeyError(\"the index (%d) is not in the Vocabulary\" % index)\n", + " return self._idx_to_token[index]\n", + "\n", + " def __str__(self):\n", + " return \"\" % len(self)\n", + "\n", + " def __len__(self):\n", + " return len(self._token_to_idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Vectorizer" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class ReviewVectorizer(object):\n", + " \"\"\" The Vectorizer which coordinates the Vocabularies and puts them to use\"\"\"\n", + " def __init__(self, review_vocab, rating_vocab):\n", + " \"\"\"\n", + " Args:\n", + " review_vocab (Vocabulary): maps words to integers\n", + " rating_vocab (Vocabulary): maps class labels to integers\n", + " \"\"\"\n", + " self.review_vocab = review_vocab\n", + " self.rating_vocab = rating_vocab\n", + "\n", + " def vectorize(self, review):\n", + " \"\"\"Create a collapsed one-hit vector for the review\n", + " \n", + " Args:\n", + " review (str): the review \n", + " Returns:\n", + " one_hot (np.ndarray): the collapsed one-hot encoding \n", + " \"\"\"\n", + " one_hot = np.zeros(len(self.review_vocab), dtype=np.float32)\n", + " \n", + " for token in review.split(\" \"):\n", + " if token not in string.punctuation:\n", + " one_hot[self.review_vocab.lookup_token(token)] = 1\n", + "\n", + " return one_hot\n", + "\n", + " @classmethod\n", + " def from_dataframe(cls, review_df, cutoff=25):\n", + " \"\"\"Instantiate the vectorizer from the dataset dataframe\n", + " \n", + " Args:\n", + " review_df (pandas.DataFrame): the review dataset\n", + " cutoff (int): the parameter for frequency-based filtering\n", + " Returns:\n", + " an instance of the ReviewVectorizer\n", + " \"\"\"\n", + " review_vocab = Vocabulary(add_unk=True)\n", + " rating_vocab = Vocabulary(add_unk=False)\n", + " \n", + " # Add ratings\n", + " for rating in sorted(set(review_df.rating)):\n", + " rating_vocab.add_token(rating)\n", + "\n", + " # Add top words if count > provided count\n", + " word_counts = Counter()\n", + " for review in review_df.review:\n", + " for word in review.split(\" \"):\n", + " if word not in string.punctuation:\n", + " word_counts[word] += 1\n", + " \n", + " for word, count in word_counts.items():\n", + " if count > cutoff:\n", + " review_vocab.add_token(word)\n", + "\n", + " return cls(review_vocab, rating_vocab)\n", + "\n", + " @classmethod\n", + " def from_serializable(cls, contents):\n", + " \"\"\"Instantiate a ReviewVectorizer from a serializable dictionary\n", + " \n", + " Args:\n", + " contents (dict): the serializable dictionary\n", + " Returns:\n", + " an instance of the ReviewVectorizer class\n", + " \"\"\"\n", + " review_vocab = Vocabulary.from_serializable(contents['review_vocab'])\n", + " rating_vocab = Vocabulary.from_serializable(contents['rating_vocab'])\n", + "\n", + " return cls(review_vocab=review_vocab, rating_vocab=rating_vocab)\n", + "\n", + " def to_serializable(self):\n", + " \"\"\"Create the serializable dictionary for caching\n", + " \n", + " Returns:\n", + " contents (dict): the serializable dictionary\n", + " \"\"\"\n", + " return {'review_vocab': self.review_vocab.to_serializable(),\n", + " 'rating_vocab': self.rating_vocab.to_serializable()}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [ + 65 + ] + }, + "outputs": [], + "source": [ + "class ReviewDataset(Dataset):\n", + " def __init__(self, review_df, vectorizer):\n", + " \"\"\"\n", + " Args:\n", + " review_df (pandas.DataFrame): the dataset\n", + " vectorizer (ReviewVectorizer): vectorizer instantiated from dataset\n", + " \"\"\"\n", + " self.review_df = review_df\n", + " self._vectorizer = vectorizer\n", + "\n", + " self.train_df = self.review_df[self.review_df.split=='train']\n", + " self.train_size = len(self.train_df)\n", + "\n", + " self.val_df = self.review_df[self.review_df.split=='val']\n", + " self.validation_size = len(self.val_df)\n", + "\n", + " self.test_df = self.review_df[self.review_df.split=='test']\n", + " self.test_size = len(self.test_df)\n", + "\n", + " self._lookup_dict = {'train': (self.train_df, self.train_size),\n", + " 'val': (self.val_df, self.validation_size),\n", + " 'test': (self.test_df, self.test_size)}\n", + "\n", + " self.set_split('train')\n", + "\n", + " @classmethod\n", + " def load_dataset_and_make_vectorizer(cls, review_csv):\n", + " \"\"\"Load dataset and make a new vectorizer from scratch\n", + " \n", + " Args:\n", + " review_csv (str): location of the dataset\n", + " Returns:\n", + " an instance of ReviewDataset\n", + " \"\"\"\n", + " review_df = pd.read_csv(review_csv)\n", + " train_review_df = review_df[review_df.split=='train']\n", + " return cls(review_df, ReviewVectorizer.from_dataframe(train_review_df))\n", + " \n", + " @classmethod\n", + " def load_dataset_and_load_vectorizer(cls, review_csv, vectorizer_filepath):\n", + " \"\"\"Load dataset and the corresponding vectorizer. \n", + " Used in the case in the vectorizer has been cached for re-use\n", + " \n", + " Args:\n", + " review_csv (str): location of the dataset\n", + " vectorizer_filepath (str): location of the saved vectorizer\n", + " Returns:\n", + " an instance of ReviewDataset\n", + " \"\"\"\n", + " review_df = pd.read_csv(review_csv)\n", + " vectorizer = cls.load_vectorizer_only(vectorizer_filepath)\n", + " return cls(review_df, vectorizer)\n", + "\n", + " @staticmethod\n", + " def load_vectorizer_only(vectorizer_filepath):\n", + " \"\"\"a static method for loading the vectorizer from file\n", + " \n", + " Args:\n", + " vectorizer_filepath (str): the location of the serialized vectorizer\n", + " Returns:\n", + " an instance of ReviewVectorizer\n", + " \"\"\"\n", + " with open(vectorizer_filepath) as fp:\n", + " return ReviewVectorizer.from_serializable(json.load(fp))\n", + "\n", + " def save_vectorizer(self, vectorizer_filepath):\n", + " \"\"\"saves the vectorizer to disk using json\n", + " \n", + " Args:\n", + " vectorizer_filepath (str): the location to save the vectorizer\n", + " \"\"\"\n", + " with open(vectorizer_filepath, \"w\") as fp:\n", + " json.dump(self._vectorizer.to_serializable(), fp)\n", + "\n", + " def get_vectorizer(self):\n", + " \"\"\" returns the vectorizer \"\"\"\n", + " return self._vectorizer\n", + "\n", + " def set_split(self, split=\"train\"):\n", + " \"\"\" selects the splits in the dataset using a column in the dataframe \n", + " \n", + " Args:\n", + " split (str): one of \"train\", \"val\", or \"test\"\n", + " \"\"\"\n", + " self._target_split = split\n", + " self._target_df, self._target_size = self._lookup_dict[split]\n", + "\n", + " def __len__(self):\n", + " return self._target_size\n", + "\n", + " def __getitem__(self, index):\n", + " \"\"\"the primary entry point method for PyTorch datasets\n", + " \n", + " Args:\n", + " index (int): the index to the data point \n", + " Returns:\n", + " a dictionary holding the data point's features (x_data) and label (y_target)\n", + " \"\"\"\n", + " row = self._target_df.iloc[index]\n", + "\n", + " review_vector = \\\n", + " self._vectorizer.vectorize(row.review)\n", + "\n", + " rating_index = \\\n", + " self._vectorizer.rating_vocab.lookup_token(row.rating)\n", + "\n", + " return {'x_data': review_vector,\n", + " 'y_target': rating_index}\n", + "\n", + " def get_num_batches(self, batch_size):\n", + " \"\"\"Given a batch size, return the number of batches in the dataset\n", + " \n", + " Args:\n", + " batch_size (int)\n", + " Returns:\n", + " number of batches in the dataset\n", + " \"\"\"\n", + " return len(self) // batch_size \n", + " \n", + "def generate_batches(dataset, batch_size, shuffle=True,\n", + " drop_last=True, device=\"cpu\"):\n", + " \"\"\"\n", + " A generator function which wraps the PyTorch DataLoader. It will \n", + " ensure each tensor is on the write device location.\n", + " \"\"\"\n", + " dataloader = DataLoader(dataset=dataset, batch_size=batch_size,\n", + " shuffle=shuffle, drop_last=drop_last)\n", + "\n", + " for data_dict in dataloader:\n", + " out_data_dict = {}\n", + " for name, tensor in data_dict.items():\n", + " out_data_dict[name] = data_dict[name].to(device)\n", + " yield out_data_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Model: ReviewClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class ReviewClassifier(nn.Module):\n", + " \"\"\" a simple perceptron based classifier \"\"\"\n", + " def __init__(self, num_features):\n", + " \"\"\"\n", + " Args:\n", + " num_features (int): the size of the input feature vector\n", + " \"\"\"\n", + " super(ReviewClassifier, self).__init__()\n", + " self.fc1 = nn.Linear(in_features=num_features, \n", + " out_features=1)\n", + "\n", + " def forward(self, x_in, apply_sigmoid=False):\n", + " \"\"\"The forward pass of the classifier\n", + " \n", + " Args:\n", + " x_in (torch.Tensor): an input data tensor. \n", + " x_in.shape should be (batch, num_features)\n", + " apply_sigmoid (bool): a flag for the sigmoid activation\n", + " should be false if used with the Cross Entropy losses\n", + " Returns:\n", + " the resulting tensor. tensor.shape should be (batch,)\n", + " \"\"\"\n", + " y_out = self.fc1(x_in).squeeze()\n", + " if apply_sigmoid:\n", + " y_out = torch.sigmoid(y_out)\n", + " return y_out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training Routine" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Helper functions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "def make_train_state(args):\n", + " return {'stop_early': False,\n", + " 'early_stopping_step': 0,\n", + " 'early_stopping_best_val': 1e8,\n", + " 'learning_rate': args.learning_rate,\n", + " 'epoch_index': 0,\n", + " 'train_loss': [],\n", + " 'train_acc': [],\n", + " 'val_loss': [],\n", + " 'val_acc': [],\n", + " 'test_loss': -1,\n", + " 'test_acc': -1,\n", + " 'model_filename': args.model_state_file}\n", + "\n", + "def update_train_state(args, model, train_state):\n", + " \"\"\"Handle the training state updates.\n", + "\n", + " Components:\n", + " - Early Stopping: Prevent overfitting.\n", + " - Model Checkpoint: Model is saved if the model is better\n", + "\n", + " :param args: main arguments\n", + " :param model: model to train\n", + " :param train_state: a dictionary representing the training state values\n", + " :returns:\n", + " a new train_state\n", + " \"\"\"\n", + "\n", + " # Save one model at least\n", + " if train_state['epoch_index'] == 0:\n", + " torch.save(model.state_dict(), train_state['model_filename'])\n", + " train_state['stop_early'] = False\n", + "\n", + " # Save model if performance improved\n", + " elif train_state['epoch_index'] >= 1:\n", + " loss_tm1, loss_t = train_state['val_loss'][-2:]\n", + "\n", + " # If loss worsened\n", + " if loss_t >= train_state['early_stopping_best_val']:\n", + " # Update step\n", + " train_state['early_stopping_step'] += 1\n", + " # Loss decreased\n", + " else:\n", + " # Save the best model\n", + " if loss_t < train_state['early_stopping_best_val']:\n", + " torch.save(model.state_dict(), train_state['model_filename'])\n", + "\n", + " # Reset early stopping step\n", + " train_state['early_stopping_step'] = 0\n", + "\n", + " # Stop early ?\n", + " train_state['stop_early'] = \\\n", + " train_state['early_stopping_step'] >= args.early_stopping_criteria\n", + "\n", + " return train_state\n", + "\n", + "def compute_accuracy(y_pred, y_target):\n", + " y_target = y_target.cpu()\n", + " y_pred_indices = (torch.sigmoid(y_pred)>0.5).cpu().long()#.max(dim=1)[1]\n", + " n_correct = torch.eq(y_pred_indices, y_target).sum().item()\n", + " return n_correct / len(y_pred_indices) * 100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### General utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def set_seed_everywhere(seed, cuda):\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " if cuda:\n", + " torch.cuda.manual_seed_all(seed)\n", + "\n", + "def handle_dirs(dirpath):\n", + " if not os.path.exists(dirpath):\n", + " os.makedirs(dirpath)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Settings and some prep work" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expanded filepaths: \n", + "\tmodel_storage/ch3/yelp/vectorizer.json\n", + "\tmodel_storage/ch3/yelp/model.pth\n", + "Using CUDA: False\n" + ] + } + ], + "source": [ + "args = Namespace(\n", + " # Data and Path information\n", + " frequency_cutoff=25,\n", + " model_state_file='model.pth',\n", + " review_csv='../data/custom_ds_binary.csv',\n", + " initial_csv='../data/like_yelp_custom_ds.csv',\n", + " # review_csv='data/yelp/reviews_with_splits_full.csv',\n", + " save_dir='model_storage/ch3/yelp/',\n", + " vectorizer_file='vectorizer.json',\n", + " # No Model hyper parameters\n", + " # Training hyper parameters\n", + " batch_size=128,\n", + " early_stopping_criteria=5,\n", + " learning_rate=0.001,\n", + " num_epochs=100,\n", + " seed=1337,\n", + " # Runtime options\n", + " catch_keyboard_interrupt=True,\n", + " cuda=True,\n", + " expand_filepaths_to_save_dir=True,\n", + " reload_from_files=False,\n", + ")\n", + "\n", + "if args.expand_filepaths_to_save_dir:\n", + " args.vectorizer_file = os.path.join(args.save_dir,\n", + " args.vectorizer_file)\n", + "\n", + " args.model_state_file = os.path.join(args.save_dir,\n", + " args.model_state_file)\n", + " \n", + " print(\"Expanded filepaths: \")\n", + " print(\"\\t{}\".format(args.vectorizer_file))\n", + " print(\"\\t{}\".format(args.model_state_file))\n", + " \n", + "# Check CUDA\n", + "if not torch.cuda.is_available():\n", + " args.cuda = False\n", + "\n", + "print(\"Using CUDA: {}\".format(args.cuda))\n", + "\n", + "args.device = torch.device(\"cuda\" if args.cuda else \"cpu\")\n", + "\n", + "# Set seed for reproducibility\n", + "set_seed_everywhere(args.seed, args.cuda)\n", + "\n", + "# handle dirs\n", + "handle_dirs(args.save_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom dataset preparation" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'negative', 'positive'} Index(['review', 'rating', 'split'], dtype='object')\n" + ] + } + ], + "source": [ + "initial_df = pd.read_csv(args.initial_csv, index_col=0)\n", + "initial_df.emotions = initial_df.emotions.replace(['skip', 'unknown', 'speech', 'neutral'], 0)\n", + "initial_df.emotions = initial_df.emotions.replace('negative', 1)\n", + "initial_df.emotions = initial_df.emotions.replace('positive', 2)\n", + "initial_df.emotions = initial_df.emotions.replace(1, 'positive')\n", + "initial_df.emotions = initial_df.emotions.replace(2, 'negative')\n", + "initial_df = initial_df[initial_df.emotions != 0]\n", + "initial_df = initial_df.rename(columns={\"emotions\":\"rating\", \"path\":\"review\"})\n", + "print(set(initial_df.rating), initial_df.columns)\n", + "initial_df.to_csv(args.review_csv, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "train 11878\n", + "test 2595\n", + "val 2580\n", + "Name: split, dtype: int64" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_df.split.value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initializations" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading dataset and creating vectorizer\n" + ] + } + ], + "source": [ + "if args.reload_from_files:\n", + " # training from a checkpoint\n", + " print(\"Loading dataset and vectorizer\")\n", + " dataset = ReviewDataset.load_dataset_and_load_vectorizer(args.review_csv,\n", + " args.vectorizer_file)\n", + "else:\n", + " print(\"Loading dataset and creating vectorizer\")\n", + " # create dataset and vectorizer\n", + " dataset = ReviewDataset.load_dataset_and_make_vectorizer(args.review_csv)\n", + " dataset.save_vectorizer(args.vectorizer_file) \n", + "vectorizer = dataset.get_vectorizer()\n", + "\n", + "classifier = ReviewClassifier(num_features=len(vectorizer.review_vocab))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "code_folding": [ + 30 + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Miniconda3\\lib\\site-packages\\ipykernel_launcher.py:13: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n", + "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n", + " del sys.path[0]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c601c3162f704562a27dd363d5da6ebe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='training routine', style=ProgressStyle(description_width=…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Miniconda3\\lib\\site-packages\\ipykernel_launcher.py:19: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n", + "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4d021abddb81458d9acd9b62e279a43b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='split=train', max=92.0, style=ProgressStyle(description_w…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Miniconda3\\lib\\site-packages\\ipykernel_launcher.py:24: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n", + "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6a47cfa4f9fb401ab28d9a567bc8ad9d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='split=val', max=20.0, style=ProgressStyle(description_wid…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "classifier = classifier.to(args.device)\n", + "\n", + "loss_func = nn.BCEWithLogitsLoss()\n", + "optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)\n", + "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,\n", + " mode='min', factor=0.5,\n", + " patience=1)\n", + "\n", + "train_state = make_train_state(args)\n", + "\n", + "epoch_bar = tqdm.notebook.tqdm(desc='training routine', \n", + " total=args.num_epochs,\n", + " position=0)\n", + "\n", + "dataset.set_split('train')\n", + "train_bar = tqdm.notebook.tqdm(desc='split=train',\n", + " total=dataset.get_num_batches(args.batch_size), \n", + " position=1, \n", + " leave=True)\n", + "dataset.set_split('val')\n", + "val_bar = tqdm.notebook.tqdm(desc='split=val',\n", + " total=dataset.get_num_batches(args.batch_size), \n", + " position=1, \n", + " leave=True)\n", + "\n", + "try:\n", + " for epoch_index in range(args.num_epochs):\n", + " train_state['epoch_index'] = epoch_index\n", + "\n", + " # Iterate over training dataset\n", + "\n", + " # setup: batch generator, set loss and acc to 0, set train mode on\n", + " dataset.set_split('train')\n", + " batch_generator = generate_batches(dataset, \n", + " batch_size=args.batch_size, \n", + " device=args.device)\n", + " running_loss = 0.0\n", + " running_acc = 0.0\n", + " classifier.train()\n", + "\n", + " for batch_index, batch_dict in enumerate(batch_generator):\n", + " # the training routine is these 5 steps:\n", + "\n", + " # --------------------------------------\n", + " # step 1. zero the gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # step 2. compute the output\n", + " y_pred = classifier(x_in=batch_dict['x_data'].float())\n", + "\n", + " # step 3. compute the loss\n", + " loss = loss_func(y_pred, batch_dict['y_target'].float())\n", + " loss_t = loss.item()\n", + " running_loss += (loss_t - running_loss) / (batch_index + 1)\n", + "\n", + " # step 4. use loss to produce gradients\n", + " loss.backward()\n", + "\n", + " # step 5. use optimizer to take gradient step\n", + " optimizer.step()\n", + " # -----------------------------------------\n", + " # compute the accuracy\n", + " acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n", + " running_acc += (acc_t - running_acc) / (batch_index + 1)\n", + "\n", + " # update bar\n", + " train_bar.set_postfix(loss=running_loss, \n", + " acc=running_acc, \n", + " epoch=epoch_index)\n", + " train_bar.update()\n", + "\n", + " train_state['train_loss'].append(running_loss)\n", + " train_state['train_acc'].append(running_acc)\n", + "\n", + " # Iterate over val dataset\n", + "\n", + " # setup: batch generator, set loss and acc to 0; set eval mode on\n", + " dataset.set_split('val')\n", + " batch_generator = generate_batches(dataset, \n", + " batch_size=args.batch_size, \n", + " device=args.device)\n", + " running_loss = 0.\n", + " running_acc = 0.\n", + " classifier.eval()\n", + "\n", + " for batch_index, batch_dict in enumerate(batch_generator):\n", + "\n", + " # compute the output\n", + " y_pred = classifier(x_in=batch_dict['x_data'].float())\n", + "\n", + " # step 3. compute the loss\n", + " loss = loss_func(y_pred, batch_dict['y_target'].float())\n", + " loss_t = loss.item()\n", + " running_loss += (loss_t - running_loss) / (batch_index + 1)\n", + "\n", + " # compute the accuracy\n", + " acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n", + " running_acc += (acc_t - running_acc) / (batch_index + 1)\n", + " \n", + " val_bar.set_postfix(loss=running_loss, \n", + " acc=running_acc, \n", + " epoch=epoch_index)\n", + " val_bar.update()\n", + "\n", + " train_state['val_loss'].append(running_loss)\n", + " train_state['val_acc'].append(running_acc)\n", + "\n", + " train_state = update_train_state(args=args, model=classifier,\n", + " train_state=train_state)\n", + "\n", + " scheduler.step(train_state['val_loss'][-1])\n", + "\n", + " train_bar.n = 0\n", + " val_bar.n = 0\n", + " epoch_bar.update()\n", + "\n", + " if train_state['stop_early']:\n", + " break\n", + "\n", + " train_bar.n = 0\n", + " val_bar.n = 0\n", + " epoch_bar.update()\n", + "except KeyboardInterrupt:\n", + " print(\"Exiting loop\")" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the loss & accuracy on the test set using the best available model\n", + "\n", + "classifier.load_state_dict(torch.load(train_state['model_filename']))\n", + "classifier = classifier.to(args.device)\n", + "\n", + "dataset.set_split('test')\n", + "batch_generator = generate_batches(dataset, \n", + " batch_size=args.batch_size, \n", + " device=args.device)\n", + "running_loss = 0.\n", + "running_acc = 0.\n", + "classifier.eval()\n", + "\n", + "for batch_index, batch_dict in enumerate(batch_generator):\n", + " # compute the output\n", + " y_pred = classifier(x_in=batch_dict['x_data'].float())\n", + "\n", + " # compute the loss\n", + " loss = loss_func(y_pred, batch_dict['y_target'].float())\n", + " loss_t = loss.item()\n", + " running_loss += (loss_t - running_loss) / (batch_index + 1)\n", + "\n", + " # compute the accuracy\n", + " acc_t = compute_accuracy(y_pred, batch_dict['y_target'])\n", + " running_acc += (acc_t - running_acc) / (batch_index + 1)\n", + "\n", + "train_state['test_loss'] = running_loss\n", + "train_state['test_acc'] = running_acc" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "def draw(train_state):\n", + " plt.title('Accuracy')\n", + " train_acc = plt.plot(train_state['train_acc'], 'r-', label='train')\n", + " val_acc = plt.plot(train_state['val_acc'], 'g-', label='val')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + " plt.title('Loss')\n", + " train_loss = plt.plot(train_state['train_loss'], 'r-', label='train')\n", + " val_loss = plt.plot(train_state['val_loss'], 'g-', label='val')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "draw(train_state)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test loss: 0.419\n", + "Test Accuracy: 81.37\n" + ] + } + ], + "source": [ + "print(\"Test loss: {:.3f}\".format(train_state['test_loss']))\n", + "print(\"Test Accuracy: {:.2f}\".format(train_state['test_acc']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " text = text.lower()\n", + " text = re.sub(r\"([.,!?])\", r\" \\1 \", text)\n", + " text = re.sub(r\"[^a-zA-Z.,!?]+\", r\" \", text)\n", + " return text" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "def predict_rating(review, classifier, vectorizer, decision_threshold=0.5):\n", + " \"\"\"Predict the rating of a review\n", + " \n", + " Args:\n", + " review (str): the text of the review\n", + " classifier (ReviewClassifier): the trained model\n", + " vectorizer (ReviewVectorizer): the corresponding vectorizer\n", + " decision_threshold (float): The numerical boundary which separates the rating classes\n", + " \"\"\"\n", + " review = preprocess_text(review)\n", + " \n", + " vectorized_review = torch.tensor(vectorizer.vectorize(review))\n", + " result = classifier(vectorized_review.view(1, -1))\n", + " \n", + " probability_value = F.sigmoid(result).item()\n", + " index = 1\n", + " if probability_value < decision_threshold:\n", + " index = 0\n", + "\n", + " return vectorizer.rating_vocab.lookup_index(index), probability_value" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "спасибо здорово ура -> positive, 0.7316314578056335\n" + ] + } + ], + "source": [ + "test_review = \"спасибо здорово ура\"\n", + "\n", + "classifier = classifier.cpu()\n", + "prediction, prob_val = predict_rating(test_review, classifier, vectorizer, decision_threshold=0.5)\n", + "print(\"{} -> {}, {}\".format(test_review, prediction, prob_val))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Interpretability" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 287])" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "classifier.fc1.weight.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Influential words in Positive Reviews:\n", + "--------------------------------------\n", + "спасибо\n", + "хорошо\n", + "здорово\n", + "молодец\n", + "хороший\n", + "прекрасно\n", + "моя\n", + "отлично\n", + "очень\n", + "красивая\n", + "наконец\n", + "послушай\n", + "приятно\n", + "здравствуй\n", + "красиво\n", + "круто\n", + "ух\n", + "люблю\n", + "хорошая\n", + "замечательно\n", + "====\n", + "\n", + "\n", + "\n", + "Influential words in Negative Reviews:\n", + "--------------------------------------\n", + "простите\n", + "чёрт\n", + "опять\n", + "тварь\n", + "плохо\n", + "убили\n", + "извините\n", + "или\n", + "больно\n", + "отсюда\n", + "сволочь\n", + "виноват\n", + "не\n", + "господи\n", + "понимаю\n", + "хватит\n", + "неужели\n", + "дура\n", + "пошёл\n", + "нет\n" + ] + } + ], + "source": [ + "# Sort weights\n", + "fc1_weights = classifier.fc1.weight.detach()[0]\n", + "_, indices = torch.sort(fc1_weights, dim=0, descending=True)\n", + "indices = indices.numpy().tolist()\n", + "\n", + "# Top 20 words\n", + "print(\"Influential words in Positive Reviews:\")\n", + "print(\"--------------------------------------\")\n", + "for i in range(20):\n", + " print(vectorizer.review_vocab.lookup_index(indices[i]))\n", + " \n", + "print(\"====\\n\\n\\n\")\n", + "\n", + "# Top 20 negative words\n", + "print(\"Influential words in Negative Reviews:\")\n", + "print(\"--------------------------------------\")\n", + "indices.reverse()\n", + "for i in range(20):\n", + " print(vectorizer.review_vocab.lookup_index(indices[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### End" + ] + } + ], + "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.6.10" + }, + "toc": { + "colors": { + "hover_highlight": "#DAA520", + "running_highlight": "#FF0000", + "selected_highlight": "#FFD700" + }, + "moveMenuLeft": true, + "nav_menu": { + "height": "156px", + "width": "252px" + }, + "navigate_menu": true, + "number_sections": true, + "sideBar": true, + "threshold": "5", + "toc_cell": false, + "toc_section_display": "block", + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/pipeline_savee.ipynb b/examples/pipeline_savee.ipynb new file mode 100644 index 0000000..3eb5ffe --- /dev/null +++ b/examples/pipeline_savee.ipynb @@ -0,0 +1,1006 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "pipeline_savee.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "eaf8ecacaa264fc380dda461d51a29df": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_fffff34d42cd43eb8c659978cddac851", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_281b46e642ad4a5b9b272e6b22e2d482", + "IPY_MODEL_a71d37be9476473cabcc86792c291a3a" + ] + } + }, + "fffff34d42cd43eb8c659978cddac851": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "281b46e642ad4a5b9b272e6b22e2d482": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_0756c72e80174516827f1e984158b712", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 30, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 30, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_973cdb4101994b39ad4af557ad0b59c1" + } + }, + "a71d37be9476473cabcc86792c291a3a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_4c424168a0844f19818d74b14e46d3b8", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 30/30 [01:15<00:00, 2.53s/it]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_e607bfa7d8d64f9083caf2c563b7c38d" + } + }, + "0756c72e80174516827f1e984158b712": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "973cdb4101994b39ad4af557ad0b59c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "4c424168a0844f19818d74b14e46d3b8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "e607bfa7d8d64f9083caf2c563b7c38d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "code", + "metadata": { + "id": "hQmkwkRYwr4n", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 121 + }, + "outputId": "b734ca03-c6e4-4989-ef56-a015470141b4" + }, + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/gdrive')" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n", + "\n", + "Enter your authorization code:\n", + "··········\n", + "Mounted at /content/gdrive\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KooDZLtyw3eZ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import sys\n", + "!pip install torchaudio comet-ml==3.0.2 torchvision==0.6.0" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "JGagcnq9yPyQ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "451222f3-5ebd-4cf0-de7b-3a3885fc8ca7" + }, + "source": [ + "import torch\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "device" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "device(type='cuda')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "diI0EknxyTe1", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import torch.backends.cudnn as cudnn\n", + "from torch.optim import lr_scheduler\n", + "from torchvision import datasets, transforms, models\n", + "from torch.utils.data import Dataset\n", + "import torchaudio\n", + "import librosa\n", + "import pandas as pd\n", + "import numpy as np\n", + "import time\n", + "import os\n", + "from tqdm.notebook import tqdm\n", + "import copy" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "8vbMK9dEyeBq", + "colab_type": "code", + "colab": {} + }, + "source": [ + "path_to_data = \"/content/gdrive/My Drive/Research/savee_png\"" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "0jn78MUgyfo-", + "colab_type": "code", + "colab": {} + }, + "source": [ + "data_transform_augmentations = transforms.Compose([\n", + " transforms.Resize((224, 224)), # Вообще в официальном туториале говорится, что надо минимум 224 размер, но я оставил как у нас было и вроде работает\n", + " transforms.RandomApply([\n", + " transforms.RandomResizedCrop((224,224)),\n", + " ],0.6), \n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),])\n", + "\n", + "data_transform = transforms.Compose([\n", + " transforms.Resize((224, 224)), # Вообще в официальном туториале говорится, что надо минимум 224 размер, но я оставил как у нас было и вроде работает\n", + " #transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),])\n", + "\n", + "tranforms = {'augmentation' : data_transform_augmentations, 'original' : data_transform}" + ], + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1HsmnNGvJ8NV", + "colab_type": "code", + "colab": {} + }, + "source": [ + "dataset = datasets.ImageFolder(root=path_to_data,\n", + " transform=tranforms['augmentation'])" + ], + "execution_count": 42, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "5rUqmK2qoGuw", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 134 + }, + "outputId": "03ed6fbe-bdec-4fc0-a6fd-1eee8cf2005a" + }, + "source": [ + "dataset.class_to_idx" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'anger': 0,\n", + " 'disgust': 1,\n", + " 'fear': 2,\n", + " 'happiness': 3,\n", + " 'neutral': 4,\n", + " 'sadness': 5,\n", + " 'surprise': 6}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5UXoRYj3LN5C", + "colab_type": "code", + "colab": {} + }, + "source": [ + "n = len(dataset.samples)\n", + "dataset_sizes = {'train' : int(n*0.75), 'val' : int(n*0.25)}\n", + "train_set, val_set = torch.utils.data.random_split(dataset, [dataset_sizes['train'], dataset_sizes['val']])\n", + "loader_train = torch.utils.data.DataLoader(train_set,\n", + " batch_size=16, shuffle=True,\n", + " num_workers=4)\n", + "loader_val = torch.utils.data.DataLoader(val_set,\n", + " batch_size=16, shuffle=True,\n", + " num_workers=4)\n", + "dataloaders = {'train' : loader_train, 'val' : loader_val}" + ], + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "upsOSXscW9jj", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def train_model(model, criterion, optimizer, scheduler, path_model, num_epochs=10):\n", + " since = time.time()\n", + "\n", + " best_model_wts = copy.deepcopy(model.state_dict())\n", + " best_acc = 0.0\n", + "\n", + " for epoch in tqdm(range(num_epochs)):\n", + " print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n", + " print('-' * 10)\n", + "\n", + " # Each epoch has a training and validation phase\n", + " for phase in ['train', 'val']:\n", + " if phase == 'train':\n", + " model.train() # Set model to training mode\n", + " else:\n", + " model.eval() # Set model to evaluate mode\n", + "\n", + " current_loss = 0.0\n", + " current_corrects = 0\n", + "\n", + " # Here's where the training happens\n", + " print('Iterating through data...')\n", + "\n", + " for inputs, labels in dataloaders[phase]:\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " # We need to zero the gradients, don't forget it\n", + " optimizer.zero_grad()\n", + "\n", + " # Time to carry out the forward training poss\n", + " # We only need to log the loss stats if we are in training phase\n", + " with torch.set_grad_enabled(phase == 'train'):\n", + " outputs = model(inputs).to(device)\n", + " _, preds = torch.max(outputs, 1)\n", + " loss = criterion(outputs, labels)\n", + "\n", + " # backward + optimize only if in training phase\n", + " if phase == 'train':\n", + " loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + " # We want variables to hold the loss statistics\n", + " current_loss += loss.item() * inputs.size(0)\n", + " current_corrects += torch.sum(preds == labels.data)\n", + "\n", + " epoch_loss = current_loss / dataset_sizes[phase]\n", + " epoch_acc = current_corrects.double() / dataset_sizes[phase]\n", + "\n", + " train_state[phase + '_acc'].append(epoch_acc)\n", + " train_state[phase + '_loss'].append(epoch_loss)\n", + "\n", + " print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n", + " phase, epoch_loss, epoch_acc))\n", + " # Make a copy of the model if the accuracy on the validation set has improved\n", + " if phase == 'val' and epoch_acc > best_acc:\n", + " best_acc = epoch_acc\n", + " best_model_wts = copy.deepcopy(model.state_dict())\n", + " best_model_path = path_model + 'best_model_' + str(round(best_acc.item(), 3)) + '.pth' \n", + "\n", + " torch.save(best_model_wts, best_model_path)\n", + " print()\n", + "\n", + " time_since = time.time() - since\n", + " print('Training complete in {:.0f}m {:.0f}s'.format(\n", + " time_since // 60, time_since % 60))\n", + " print('Best val Acc: {:4f}'.format(best_acc))\n", + "\n", + " # Now we'll load in the best model weights and return it\n", + " model.load_state_dict(best_model_wts)\n", + " return model, best_acc" + ], + "execution_count": 39, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "tfOWkWboXk3r", + "colab_type": "code", + "colab": {} + }, + "source": [ + "model = models.resnet18(pretrained=True)\n", + "num_classes = len(dataset.class_to_idx)\n", + "# replace the last layer (resnet)\n", + "num_features = model.fc.in_features\n", + "model.fc = nn.Linear(num_features, num_classes)\n", + "\n", + "# model.classifier = nn.Linear(1024, num_classes) #densenet121\n", + "# model.classifier[6] = nn.Linear(4096,num_classes) #alexnet\n", + "# model.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1)) #squeezenet1_0\n", + "\n", + "criterion = nn.CrossEntropyLoss()\n", + "# Observe that all parameters are being optimized\n", + "optimizer_ft = optim.Adam(model.parameters(), lr=0.001)\n", + "# Decay LR by a factor of 0.1 every 7 epochs\n", + "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)" + ], + "execution_count": 44, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "voNuePBPXhvm", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "eaf8ecacaa264fc380dda461d51a29df", + "fffff34d42cd43eb8c659978cddac851", + "281b46e642ad4a5b9b272e6b22e2d482", + "a71d37be9476473cabcc86792c291a3a", + "0756c72e80174516827f1e984158b712", + "973cdb4101994b39ad4af557ad0b59c1", + "4c424168a0844f19818d74b14e46d3b8", + "e607bfa7d8d64f9083caf2c563b7c38d" + ] + }, + "outputId": "8827ad55-6d0a-4b13-e2c8-1359b3aed7a4" + }, + "source": [ + "train_state = {'train_loss' : [], 'train_acc' : [], 'val_loss' : [], 'val_acc' : []}\n", + "if torch.cuda.is_available():\n", + " model.cuda()\n", + "model_name = 'best_model_0.633.pth'\n", + "best_mod_path = '/content/gdrive/My Drive/Research/SAVEE_experiments/weights/'\n", + "#model.load_state_dict(torch.load(best_mod_path + model_name, map_location=device))\n", + "model_ret, best_acc = train_model(model, criterion, optimizer_ft, exp_lr_scheduler, best_mod_path, num_epochs=30)\n", + "# save model\n", + "best_model_path = best_mod_path + 'res_net_model_full_' + str(round(best_acc.item(), 3)) + '.pth'\n", + "if best_acc.item() > 0.6:\n", + " torch.save(model_ret.state_dict(), best_model_path)" + ], + "execution_count": 45, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eaf8ecacaa264fc380dda461d51a29df", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=30.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Epoch 0/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 1.6130 Acc: 0.4111\n", + "Iterating through data...\n", + "val Loss: 3.0617 Acc: 0.4333\n", + "\n", + "Epoch 1/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.6087 Acc: 0.7778\n", + "Iterating through data...\n", + "val Loss: 1.3046 Acc: 0.5667\n", + "\n", + "Epoch 2/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2836 Acc: 0.9222\n", + "Iterating through data...\n", + "val Loss: 1.1358 Acc: 0.5667\n", + "\n", + "Epoch 3/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2273 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 1.0855 Acc: 0.6000\n", + "\n", + "Epoch 4/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.3324 Acc: 0.9111\n", + "Iterating through data...\n", + "val Loss: 1.0383 Acc: 0.5667\n", + "\n", + "Epoch 5/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2574 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.9772 Acc: 0.6333\n", + "\n", + "Epoch 6/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2135 Acc: 0.9889\n", + "Iterating through data...\n", + "val Loss: 0.9227 Acc: 0.6333\n", + "\n", + "Epoch 7/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2418 Acc: 0.9444\n", + "Iterating through data...\n", + "val Loss: 0.8747 Acc: 0.6667\n", + "\n", + "Epoch 8/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2325 Acc: 0.9667\n", + "Iterating through data...\n", + "val Loss: 0.8670 Acc: 0.6667\n", + "\n", + "Epoch 9/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2574 Acc: 0.9333\n", + "Iterating through data...\n", + "val Loss: 0.8543 Acc: 0.6667\n", + "\n", + "Epoch 10/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2310 Acc: 0.9444\n", + "Iterating through data...\n", + "val Loss: 0.8454 Acc: 0.6667\n", + "\n", + "Epoch 11/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2247 Acc: 0.9444\n", + "Iterating through data...\n", + "val Loss: 0.8323 Acc: 0.6667\n", + "\n", + "Epoch 12/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2268 Acc: 0.9778\n", + "Iterating through data...\n", + "val Loss: 0.8318 Acc: 0.6667\n", + "\n", + "Epoch 13/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2608 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8168 Acc: 0.6667\n", + "\n", + "Epoch 14/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2427 Acc: 0.9333\n", + "Iterating through data...\n", + "val Loss: 0.8311 Acc: 0.6667\n", + "\n", + "Epoch 15/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2740 Acc: 0.9333\n", + "Iterating through data...\n", + "val Loss: 0.8170 Acc: 0.7000\n", + "\n", + "Epoch 16/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2656 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8134 Acc: 0.7000\n", + "\n", + "Epoch 17/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2344 Acc: 0.9333\n", + "Iterating through data...\n", + "val Loss: 0.8191 Acc: 0.7000\n", + "\n", + "Epoch 18/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2574 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8219 Acc: 0.7000\n", + "\n", + "Epoch 19/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2935 Acc: 0.9222\n", + "Iterating through data...\n", + "val Loss: 0.8129 Acc: 0.7000\n", + "\n", + "Epoch 20/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2271 Acc: 0.9778\n", + "Iterating through data...\n", + "val Loss: 0.8200 Acc: 0.7000\n", + "\n", + "Epoch 21/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2395 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8308 Acc: 0.7000\n", + "\n", + "Epoch 22/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2237 Acc: 0.9667\n", + "Iterating through data...\n", + "val Loss: 0.8352 Acc: 0.7000\n", + "\n", + "Epoch 23/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2194 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8253 Acc: 0.7000\n", + "\n", + "Epoch 24/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2569 Acc: 0.9667\n", + "Iterating through data...\n", + "val Loss: 0.8287 Acc: 0.7000\n", + "\n", + "Epoch 25/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2410 Acc: 0.9667\n", + "Iterating through data...\n", + "val Loss: 0.8137 Acc: 0.7000\n", + "\n", + "Epoch 26/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2763 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8275 Acc: 0.7000\n", + "\n", + "Epoch 27/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2340 Acc: 0.9444\n", + "Iterating through data...\n", + "val Loss: 0.8303 Acc: 0.6667\n", + "\n", + "Epoch 28/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.2493 Acc: 0.9333\n", + "Iterating through data...\n", + "val Loss: 0.8422 Acc: 0.6667\n", + "\n", + "Epoch 29/29\n", + "----------\n", + "Iterating through data...\n", + "train Loss: 0.1945 Acc: 0.9556\n", + "Iterating through data...\n", + "val Loss: 0.8424 Acc: 0.7000\n", + "\n", + "\n", + "Training complete in 1m 11s\n", + "Best val Acc: 0.700000\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gOpg2nd4Ph6a", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "outputId": "bb903b56-55b2-4257-960d-a235dab1461f" + }, + "source": [ + "from matplotlib import pyplot as plt\n", + "def draw(train_state):\n", + " plt.title('Accuracy')\n", + " train_acc = plt.plot(train_state['train_acc'], 'r-', label='train')\n", + " val_acc = plt.plot(train_state['val_acc'], 'g-', label='val')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + " plt.title('Loss')\n", + " train_loss = plt.plot(train_state['train_loss'], 'r-', label='train')\n", + " val_loss = plt.plot(train_state['val_loss'], 'g-', label='val')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "draw(train_state)" + ], + "execution_count": 46, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zv3YA36HvjEw", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# load model\n", + "best_model = models.resnet18(pretrained=True)\n", + "# replace the last layer\n", + "num_features = model.fc.in_features\n", + "best_model.fc = nn.Linear(num_features, 11)\n", + "best_model.load_state_dict(torch.load(best_model_path))\n", + "best_model.eval()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "YfWN5TV4xGQW", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# helper function\n", + "from PIL import Image\n", + "def pil_loader(path):\n", + " # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)\n", + " with open(path, 'rb') as f:\n", + " img = Image.open(f)\n", + " return img.convert('RGB')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "IQJQVw814oIC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 202 + }, + "outputId": "ea307e69-2fe9-4d43-fa13-4c916a27e5de" + }, + "source": [ + "data_dir = '/content/gdrive/My Drive/Research/truncted_dataset/'\n", + "classes = os.listdir(data_dir)\n", + "classes" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['yes',\n", + " 'up',\n", + " 'go',\n", + " 'on',\n", + " 'off',\n", + " 'left',\n", + " 'right',\n", + " 'down',\n", + " 'unknown',\n", + " 'no',\n", + " '_background_noise_']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 79 + } + ] + } + ] +} \ No newline at end of file diff --git a/examples/savee_foldering_to_img.ipynb b/examples/savee_foldering_to_img.ipynb new file mode 100644 index 0000000..3da39ec --- /dev/null +++ b/examples/savee_foldering_to_img.ipynb @@ -0,0 +1,32 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/model/tokenizer.py b/model/tokenizer.py new file mode 100644 index 0000000..f006082 --- /dev/null +++ b/model/tokenizer.py @@ -0,0 +1,68 @@ +# for work from Google Collab +# from google.colab import drive +# drive.mount('/MyDrv') +# !cp "/MyDrv/My Drive/research/public_youtube1120_mp3.csv" "." + +# requirements +# !{sys.executable} -m pip install dostoevsky==0.1.2 +# !{sys.executable} -m pip install folium==0.2.1 +# !dostoevsky download vk-embeddings cnn-social-network-model +import sys +import csv +import numpy as np +import pandas as pd +from dostoevsky.tokenization import UDBaselineTokenizer, BaselineTokenizer +from dostoevsky.word_vectors import SocialNetworkWordVectores, Word2VecContainer +from dostoevsky.models import SocialNetworkModel, BaseModel +from keras.preprocessing.sequence import pad_sequences + +class DostoevskyTokenizer(): + def __init__(self): + self.filename = None + + def init_tokenizer(self): + tokenizer = BaselineTokenizer() + word_vectors_container = SocialNetworkWordVectores() + + self.model = SocialNetworkModel( + tokenizer=tokenizer, + word_vectors_container=word_vectors_container, + lemmatize=False, + ) + def predict(self, sentences): + X = pad_sequences([ + self.model.word_vectors_container.get_word_vectors( + self.model.tokenizer.split(sentence, lemmatize = self.model.lemmatize) + ) for sentence in sentences + ], maxlen = self.model.sentence_length, dtype='float32') + + Y = self.model.model.predict(X) + + return Y + def load_main_file(self, filename, nrows = None): + self.filename = filename + self.nrows = nrows + self.main_df = pd.read_csv(filename, encoding='Windows-1251', nrows=nrows) + self.text = np.array(self.main_df.text.tolist()) + self.path = np.array(self.main_df.path.tolist()) + + def get_files_with_predict(self, path_to_save="", start=0, step=10, bound=100000): + if self.filename == None: + print("Error! Please set filename by .load_main_file(filename, nrows=None)") + return 1 + pred = [] + print(i) + for i in range(0, self.nrows, step): + sentences = self.text[i:i+step] + + Y = self.model.predict(sentences) + + if i + 1 % bound == 0 and i != 0: + name_to_save = path_to_save + "result" + str(i - bound) + "-" + str(i) + ".csv" + + df_to_save = pd.DataFrame(pred) + df_to_save['path'] = path[i-BOUND:i] + df_to_save.to_csv(name_to_save, index=True) + pred = [] + for y in Y: + pred.append(y) \ No newline at end of file diff --git a/pipeline.ipynb b/pipeline.ipynb new file mode 100644 index 0000000..b044704 --- /dev/null +++ b/pipeline.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "unable to import 'smart_open.gcs', disabling that module\n", + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "from importlib import reload\n", + "from os import listdir\n", + "from os.path import isfile, join\n", + "from model.tokenizer import DostoevskyTokenizer" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "PATH_TO_DATASET = \"..\\..\\..\\public_youtube1120_mp3\\public_youtube1120\\\\\"\n", + "PATH_TO_CSV = \"..\\..\\..\\\\public_youtube1120_mp3.csv\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.walker import get_csv_for_dataset\n", + "get_csv_for_dataset(PATH_TO_DATASET, PATH_TO_CSV, verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [], + "source": [ + "PATH_TO_RESULT = '..results\\\\'\n", + "FOLDER_NAME_IN = 'results_by100kstep\\\\'\n", + "FOLDER_NAME_OUT = 'results_after_scalling\\\\'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = DostoevskyTokenizer()\n", + "model.load_main_file(PATH_TO_CSV)\n", + "model.init_tokenizer()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.get_files_with_predict(path_to_save=FOLDER_NAME_IN)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result_files = [f for f in listdir(PATH_TO_RESULT + FOLDER_NAME_IN) if isfile(join(PATH_TO_RESULT + FOLDER_NAME_IN, f))]" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['result0-100000.csv',\n", + " 'result100000-200000.csv',\n", + " 'result200000-300000.csv',\n", + " 'result300000-400000.csv',\n", + " 'result400000-500000.csv',\n", + " 'result500000-600000.csv',\n", + " 'result600000-700000.csv',\n", + " 'result700000-800000.csv',\n", + " 'result800000-900000.csv',\n", + " 'result900000-1000000.csv']" + ] + }, + "execution_count": 154, + "output_type": "execute_result", + "metadata": {} + } + ], + "source": [ + "result_files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Number of samples with neutral emotions" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [], + "source": [ + "# df_res[df_res.emotions == 'neutral2'].emotions.count()" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "neutral emot. in result0-100000.csv before scalling: 90440, after: 75898, delta: 14542\n", + "neutral emot. in result100000-200000.csv before scalling: 90331, after: 75790, delta: 14541\n", + "neutral emot. in result200000-300000.csv before scalling: 90382, after: 75953, delta: 14429\n", + "neutral emot. in result300000-400000.csv before scalling: 90331, after: 75661, delta: 14670\n", + "neutral emot. in result400000-500000.csv before scalling: 90392, after: 75801, delta: 14591\n", + "neutral emot. in result500000-600000.csv before scalling: 90471, after: 75975, delta: 14496\n", + "neutral emot. in result600000-700000.csv before scalling: 90325, after: 75687, delta: 14638\n", + "neutral emot. in result700000-800000.csv before scalling: 90501, after: 75948, delta: 14553\n", + "neutral emot. in result800000-900000.csv before scalling: 90576, after: 75935, delta: 14641\n", + "neutral emot. in result900000-1000000.csv before scalling: 90301, after: 75633, delta: 14668\n" + ] + } + ], + "source": [ + "labels = [\n", + " 'positive',\n", + " 'neutral',\n", + " 'negative',\n", + " 'skip',\n", + " 'speech',\n", + " 'unknown',\n", + " ]\n", + "\n", + "def f(x):\n", + " global count_neut_before\n", + " index_first_max = int(x.nlargest(1).idxmin())\n", + " index_second_max = int(x.nlargest(2).idxmin())\n", + " if labels[index_first_max] == 'neutral':\n", + " count_neut_before = count_neut_before + 1\n", + " if x[index_second_max]/x[index_first_max] > x[index_first_max]:\n", + " t = x[index_second_max]\n", + " x[index_second_max] = x[index_first_max]\n", + " x[index_first_max] = t\n", + " return index_second_max\n", + " else:\n", + " return index_first_max\n", + " return index_first_max\n", + " #print('x: ', x, 'imax:', typeindex_first_max))\n", + "\n", + "for csv_name in result_files:\n", + " count_neut_before = 0\n", + " df_res = pd.read_csv(PATH_TO_RESULT + FOLDER_NAME_IN + csv_name)\n", + " df_res['emotions'] = df_res[['0', '1', '2', '3', '4', '5']].T.apply(lambda x: f(x))\n", + " df_res['emotions'] = df_res['emotions'].T.apply(lambda x: labels[int(x)])\n", + " count_neut_after = df_res[df_res.emotions == 'neutral'].emotions.count()\n", + " print(\"neutral emot. in {} before scalling: {}, after: {}, delta: {}\".format(csv_name, count_neut_before, count_neut_after, count_neut_before - count_neut_after))\n", + " df_res.to_csv(PATH_TO_RESULT + FOLDER_NAME_OUT + 'scalling_' + csv_name, encoding='Windows-1251')" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
neutralspeechskipnegativepositiveunknown
count904050116061016040317297404127
std0.1442630.2060070.1567010.1585620.1128350.0527393
25%0.5315480.5098730.3610250.4044090.3870190.51033
50%0.6424970.7365930.4225810.4928070.4459750.51033
75%0.746410.8834180.5249530.6244610.5315990.51033
\n", + "
" + ] + }, + "output_type": "execute_result", + "metadata": {} + } + ], + "source": [ + "from utils import tools\n", + "import importlib\n", + "tools = importlib.reload(tools)\n", + "PATH_TO_CSV_INITIAL = '..\\\\results\\\\results_by100kstep\\\\'\n", + "PATH_TO_CSV_SCALLED = '..\\\\results_after_scalling\\\\'\n", + "\n", + "tools.get_stat_from_initial_results(PATH_TO_CSVs)" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
neutralspeechskipnegativepositiveunknown
count7582811415645271993347175011208
std0.1167960.2475940.09568430.1667780.1181620.142757
25%0.5897920.3822310.3419210.26340.278460.201188
50%0.6747120.6174360.40150.3387350.340750.232169
75%0.7656490.8574640.443520.457450.4243720.51033
\n", + "
" + ] + }, + "output_type": "execute_result", + "metadata": {} + } + ], + "source": [ + "tools.get_stat_from_initial_results(PATH_TO_CSV_SCALLED)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['results_after_scallingscalling_result0-100000.csv',\n", + " 'results_after_scallingscalling_result100000-200000.csv',\n", + " 'results_after_scallingscalling_result200000-300000.csv',\n", + " 'results_after_scallingscalling_result300000-400000.csv',\n", + " 'results_after_scallingscalling_result400000-500000.csv',\n", + " 'results_after_scallingscalling_result500000-600000.csv',\n", + " 'results_after_scallingscalling_result600000-700000.csv',\n", + " 'results_after_scallingscalling_result700000-800000.csv',\n", + " 'results_after_scallingscalling_result800000-900000.csv',\n", + " 'results_after_scallingscalling_result900000-1000000.csv']" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_files_after_scalling = [f for f in listdir(PATH_TO_CSV_SCALLED) if isfile(join(PATH_TO_CSV_SCALLED, f))]\n", + "result_files_after_scalling" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\positive already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\neutral already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\negative already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\skip already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\speech already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\train\\unknown already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\positive already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\neutral already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\negative already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\skip already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\speech already exist\n", + "Directory ..\\..\\dataset_based_p_y1120_mp3\\val\\unknown already exist\n" + ] + } + ], + "source": [ + "import os\n", + "from shutil import copy\n", + "import importlib\n", + "tools = importlib.reload(tools)\n", + "\n", + "PATH_TO_DATASET_SOURCE = \"..\\..\\public_youtube1120_mp3\\\\\"\n", + "PATH_TO_DATASET_DESTINATION = \"..\\..\\dataset_based_p_y1120_mp3\"\n", + " \n", + "tools.get_train_val(PATH_TO_CSV_SCALLED + result_files_after_scalling[5], PATH_TO_DATASET_SOURCE, PATH_TO_DATASET_DESTINATION)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'results_after_scallingscalling_result700000-800000.csv'" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_res = pd.read_csv(PATH_TO_CSV_SCALLED + result_files_after_scalling[7])\n", + "result_files_after_scalling[7]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3.0 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/predicting_by_dostoevskiy.ipynb b/predicting_by_dostoevskiy.ipynb deleted file mode 100644 index effc064..0000000 --- a/predicting_by_dostoevskiy.ipynb +++ /dev/null @@ -1,196 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 51 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 9242, - "status": "ok", - "timestamp": 1564919874738, - "user": { - "displayName": "Илья Седунов", - "photoUrl": "https://lh4.googleusercontent.com/-UBRHOz7qPx8/AAAAAAAAAAI/AAAAAAAAAAc/j8CqTG4PkU8/s64/photo.jpg", - "userId": "17123457789087244305" - }, - "user_tz": -180 - }, - "id": "WpbUOIWQVuxX", - "outputId": "11c90dc8-a8ec-4ee6-b867-7625a80a60c3" - }, - "outputs": [], - "source": [ - "from google.colab import drive\n", - "drive.mount('/MyDrv')\n", - "!ls\n", - "!cp \"/MyDrv/My Drive/Research/public_youtube1120_mp3.csv\" \"../\"\n", - "!cp \"/MyDrv/My Drive/Research/asr_public_phone_calls_2.csv\" \"../\"\n", - "#!cp \"/MyDrv/My Drive/Research/train.json\" \"../\"\n", - "#!cp \"/MyDrv/My Drive/Research/test.json\" \"../\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 870 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 5505, - "status": "ok", - "timestamp": 1564919884952, - "user": { - "displayName": "Илья Седунов", - "photoUrl": "https://lh4.googleusercontent.com/-UBRHOz7qPx8/AAAAAAAAAAI/AAAAAAAAAAc/j8CqTG4PkU8/s64/photo.jpg", - "userId": "17123457789087244305" - }, - "user_tz": -180 - }, - "id": "po3-xV6yWMRE", - "outputId": "e47ec917-cac0-476f-e78a-b489b2d5b332" - }, - "outputs": [], - "source": [ - "import sys\n", - "!{sys.executable} -m pip install dostoevsky==0.1.2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "U_HDDFfAY0XO" - }, - "outputs": [], - "source": [ - "!dostoevsky download vk-embeddings cnn-social-network-model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 88 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 138489, - "status": "ok", - "timestamp": 1564931200704, - "user": { - "displayName": "Илья Седунов", - "photoUrl": "https://lh4.googleusercontent.com/-UBRHOz7qPx8/AAAAAAAAAAI/AAAAAAAAAAc/j8CqTG4PkU8/s64/photo.jpg", - "userId": "17123457789087244305" - }, - "user_tz": -180 - }, - "id": "CISQwpjBYgUX", - "outputId": "1d78dd20-3e17-420c-e811-310228bc8e64" - }, - "outputs": [], - "source": [ - "from dostoevsky.tokenization import UDBaselineTokenizer, BaselineTokenizer\n", - "from dostoevsky.word_vectors import SocialNetworkWordVectores, Word2VecContainer\n", - "from dostoevsky.models import SocialNetworkModel, BaseModel\n", - "\n", - "tokenizer = BaselineTokenizer()\n", - "\n", - "word_vectors_container = SocialNetworkWordVectores()\n", - "\n", - "model = SocialNetworkModel(\n", - " tokenizer=tokenizer,\n", - " word_vectors_container=word_vectors_container,\n", - " lemmatize=False,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "v4arvfuWXHgT" - }, - "outputs": [], - "source": [ - "import csv\n", - "import pandas as pd\n", - "\n", - "df = pd.read_csv('../asr_public_phone_calls_2.csv', encoding='Windows-1251')\n", - "saved_column = df.text.tolist()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "3hXN190davQU" - }, - "outputs": [], - "source": [ - "STEP = 200\n", - "ret = []\n", - "for i in range(int(len(saved_column)) - 1):\n", - " samples = saved_column[(i * STEP) : ((i+1) * STEP)]\n", - " pred = model.predict(samples)\n", - " #print(i, samples, pred)\n", - " ret.append(pred[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "9WgrsTK3fcxD" - }, - "outputs": [], - "source": [ - "len(ret)" - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "dostoevsky.ipynb", - "provenance": [], - "version": "0.3.2" - }, - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/utils/make_spectogram_pipeline.py b/utils/make_spectogram_pipeline.py new file mode 100644 index 0000000..1641a27 --- /dev/null +++ b/utils/make_spectogram_pipeline.py @@ -0,0 +1,132 @@ +#!/usr/bin/env python +# coding: utf-8 + +# ## The letters 'a', 'd', 'f', 'h', 'n', 'sa' and 'su' represent +# 'anger', 'disgust', 'fear', 'happiness', 'neutral', 'sadness' and 'surprise' emotion classes respectively. + +# In[1]: + + +import numpy +from matplotlib import mlab +import matplotlib.pyplot as pyplot +import scipy.io.wavfile +from collections import defaultdict +from scipy import misc +import subprocess + + +# In[2]: + + +def get_wave_data(wave_filename): + sample_rate, wave_data = scipy.io.wavfile.read(wave_filename) + #assert sample_rate == SAMPLE_RATE, sample_rate + if isinstance(wave_data[0], numpy.ndarray): # стерео + wave_data = wave_data.mean(1) + return wave_data +def show_specgram(wave_data): + fig = pyplot.figure() + ax = fig.add_axes((0.1, 0.1, 0.8, 0.8)) + ax.specgram(wave_data, NFFT=WINDOW_SIZE, noverlap=WINDOW_SIZE - WINDOW_STEP, Fs=SAMPLE_RATE) + pyplot.show() + + +# In[3]: + + +SAMPLE_RATE = 9000 # Hz +WINDOW_SIZE = 2048 # размер окна, в котором делается fft +WINDOW_STEP = 512 # шаг окна +FOLDER_NAME = 'public_youtube1120/' +PATH = '/home/isedunov/pipeline/public_youtube1120/' +MP3 = '.mp3' +DOT_WAV = '.wav' +LOG_FILENAME = "log.txt" +PATH_TO_LOG = PATH + '../' + LOG_FILENAME + +log_file = open(LOG_FILENAME, 'a') + + +# In[ ]: + + +import os +from matplotlib import pyplot +import matplotlib.pyplot as plt + +PATH += FOLDER_NAME + +list_of_grand_dir = os.listdir(PATH) + +def make_base(): + for grand_folder in list_of_grand_dir: + list_of_dir = os.listdir(PATH + grand_folder) + grand_path = PATH + grand_folder + '/' + for folder in list_of_dir: + #folder = list_of_dir[3] + list_of_mp3 = os.listdir(grand_path + folder) + list_of_mp3 = list(filter(lambda x: x.endswith(MP3), list_of_mp3)) + for mp3 in list_of_mp3: + mp3_filename = grand_path + folder + '/' + mp3 + wav = mp3.split('.')[0] + DOT_WAV + wave_filename = grand_path + folder + '/' + wav + png_filename = wave_filename.split('.')[0] + '.png' + if os.path.isfile(png_filename): + log_file.write(png_filename + " : exist yet!\n") + else: + log_file.write(png_filename + '\n') + subprocess.call(['ffmpeg', '-i', mp3_filename, wave_filename]) + wave_data = get_wave_data(wave_filename) + fig = pyplot.figure() + ax = fig.add_axes((0,0,1,1)) + ax.specgram(wave_data, NFFT=WINDOW_SIZE, noverlap=WINDOW_SIZE - WINDOW_STEP, Fs=SAMPLE_RATE) + + pyplot.axis([0, 25, 0, 4000]) + pyplot.axis('off') + pyplot.savefig(png_filename) + pyplot.close(fig) + + + log_file.close() + +make_base() + +#/home/latna/jupyter/lib/python3.6/site-packages/matplotlib/pyplot.py:513: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). +# max_open_warning, RuntimeWarning) + + +# In[ ]: + + +make_base() + + +# + +# In[ ]: + + +SAMPLE_RATE = 9000 # Hz +WINDOW_SIZE = 2048 # размер окна, в котором делается fft +WINDOW_STEP = 512 # шаг окна + +PATH = '/home/isedunov/pipeline/public_youtube1120/public_youtube1120/0' +FILENAME = '000f45f0543c' +mp3 = '.mp3' +wav = '.wav' +def test(): + wave_filename = PATH + '/00/' + FILENAME + wav + mp3_filename = PATH + '/00/' + FILENAME + mp3 + subprocess.call(['ffmpeg', '-i', mp3_filename, wave_filename]) + + wave_data = get_wave_data(wave_filename) + print(wave_data) + fig = pyplot.figure() + ax = fig.add_axes((0.1, 0.1, 0.8, 0.8)) + ax.specgram(wave_data, NFFT=WINDOW_SIZE, noverlap=WINDOW_SIZE - WINDOW_STEP, Fs=SAMPLE_RATE) + pyplot.axis([0, 25, 0, 4000]) + pyplot.axis('off') + pyplot.show() + print(fig.get_size_inches()*fig.dpi) + diff --git a/utils/tools.py b/utils/tools.py new file mode 100644 index 0000000..ec92273 --- /dev/null +++ b/utils/tools.py @@ -0,0 +1,112 @@ +import numpy as np +import pandas as pd +import os +from shutil import copy +from os import listdir +from os.path import isfile, join +from PIL import Image + +labels = [ + 'positive', + 'neutral', + 'negative', + 'skip', + 'speech', + 'unknown', + ] + +def get_files(path): + return [f for f in listdir(path) if isfile(join(path, f))] + +def get_white_pix_numb(image): + w, h = image.size + pix = np.array(image) + for y in range(5, h): + for x in range(5, w): + if np.array_equal(pix[y, x], [255, 255, 255, 255]): + return x + return -1 + +def crop_images(path_to_data): + main_dirs = ['train', 'val'] + # path_to_data = "/content/gdrive/My Drive/Research/dataset_train_val_10000" + for dir_ in main_dirs: + for emotion in labels: + path_to_folder = path_to_data + '/' + dir_ + '/' + emotion + '/' + list_of_png = get_files(path_to_folder) + for png in list_of_png: + img = Image.open(path_to_folder + png) + width, height = img.size + right = get_white_pix_numb(img) + + if right == -1: + continue + + img = img.crop((0, 0, right, height)) + img.save(path_to_folder + png) + +def get_dirs_tree(path_to_destination_dataset): + dir_names = labels + for name_dir in ['/train', '/val']: + path_to_main_dirs = path_to_destination_dataset + name_dir + try: + os.makedirs(path_to_main_dirs) + except OSError: + print ("Directory %s already exist" % path_to_main_dirs) + else: + print ("Successfully created the directory %s" % path_to_main_dirs) + for name_dir_emotions in dir_names: + path_to_inner_dirs = path_to_main_dirs + "/" + name_dir_emotions + try: + os.makedirs(path_to_inner_dirs) + except OSError: + print ("Directory %s already exist" % path_to_inner_dirs) + else: + print ("Successfully created the directory %s" % path_to_inner_dirs) + + +def get_train_val(path_to_csv, path_to_dataset, path_to_destination_dataset, number_of_samples, number_of_samples_per_class, extension): + number_of_pngs = {'val' : 0, 'train' : 0, 'positive' : 0, 'neutral' : 0, 'negative' : 0, 'skip' : 0, 'speech' : 0, 'unknown' : 0,} + df = pd.read_csv(path_to_csv, encoding="Windows-1251") + df = df.loc[:, ~df.columns.str.contains('^Unnamed')] + get_dirs_tree(path_to_destination_dataset) + for index, row in df.iterrows(): + path_to_txt = path_to_dataset + row['path'][2:].replace('\\', '/') + path_to_png = path_to_txt[:-3] + extension[1:] + + if (not os.path.exists(path_to_png) or (number_of_pngs[row['emotions']]>number_of_samples_per_class)): + continue + if (number_of_pngs['train'] + number_of_pngs['val'] > number_of_samples): + break + main_dir = 'val' if index % 3 == 0 else 'train' + + number_of_pngs[main_dir]+=1 + number_of_pngs[row['emotions']]+=1 + + dest_file_path = path_to_destination_dataset + "/" + main_dir + "/" + row['emotions'] + "/" + #print(row['emotions'], dest_file_path) + copy(path_to_png, dest_file_path) + print("Number of pngs copied to dataset: ") + print(number_of_pngs) + +def get_stat_from_initial_results(path_to_files): + + result_files = [f for f in listdir(path_to_files) if isfile(join(path_to_files, f))] + stats = ['std', '25%', '50%', '75%'] + emotions = ['neutral', 'speech', 'skip', 'negative', 'positive', 'unknown'] + df_sum = pd.DataFrame(columns=emotions, index=['count', 'std', '25%', '50%', '75%']) + df_sum.loc['count'] = df_sum.loc['count'].replace(np.nan, 0) + + for file in result_files: + df = pd.read_csv(path_to_files + file, index_col=False) + df.emotions = df.emotions.str.replace('\d+', '') + df = df.loc[:, ~df.columns.str.contains('^Unnamed')] + #df.to_csv(path_to_files + file) + for emotion in emotions: + emotion_index = df[df.emotions == emotion].describe().T['mean'].idxmax() + row_value = df[df.emotions == emotion].describe()[emotion_index] + + df_sum.at['count', emotion] += row_value['count'] + for stat in stats: + df_sum.at[stat, emotion] = np.nanmean([df_sum.at[stat, emotion], row_value[stat]]) + return df_sum diff --git a/utils/walker.py b/utils/walker.py new file mode 100644 index 0000000..24361ae --- /dev/null +++ b/utils/walker.py @@ -0,0 +1,41 @@ +import os +import pandas as pd +import csv + +def get_csv_for_dataset(path_to_dir, path_to_out, verbose=False): +# PATH = 'D:\\localNLP\\RussianNLP' +# DIRNAME2 = 'public_youtube1120_mp3' +# CSV_FILE2 = 'public_youtube1120_mp3.csv' + + #file_count = sum(len(files) for _, _, files in os.walk(r'D:\\localNLP\\RussianNLP\\asr_public_phone_calls_2')) + #print("asr_public_phone_calls_2:", file_count) + + #file_count = sum(len(files) for _, _, files in os.walk(r PATH+DIRNAME2)) + #print("public_youtube1120_mp3:", file_count) + + text_list = [] + path_list = [] + os.chdir(path_to_dir) + for root, dirs, files in os.walk(".", topdown = False): + for name in files: + path_to_file = os.path.join(root, name) + if path_to_file.endswith(".txt"): + if verbose: + print(path_to_file + " text: ") + with open(path_to_file, "r", encoding='utf-8') as file: + text = file.read() + if verbose: + print(text) + text_list.append(text) + path_list.append(path_to_file) + + + text_list = [line.rstrip() for line in text_list] + #print(path_list, text_list) + + col1 = pd.Series(path_list) + col2 = pd.Series(text_list) + + df = pd.DataFrame({'path':col1.reindex(col2.index), 'text':col2}) + + df.to_csv(path_to_out, sep = ',', index = False, encoding='Windows-1251') diff --git a/walker.py b/walker.py deleted file mode 100644 index 1386429..0000000 --- a/walker.py +++ /dev/null @@ -1,42 +0,0 @@ -import os -import pandas as pd -import csv - -PATH = 'D:\\localNLP\\RussianNLP' -DIRNAME1 = 'asr_public_phone_calls_2' -DIRNAME2 = 'public_youtube1120_mp3' -CSV_FILE1 = 'asr_public_phone_calls_2.csv' -CSV_FILE2 = 'public_youtube1120_mp3.csv' - -#file_count = sum(len(files) for _, _, files in os.walk(r'D:\\localNLP\\RussianNLP\\asr_public_phone_calls_2')) -#print("asr_public_phone_calls_2:", file_count) - -#file_count = sum(len(files) for _, _, files in os.walk(r PATH+DIRNAME2)) -#print("public_youtube1120_mp3:", file_count) - -text_list = [] -path_list = [] -os.chdir(PATH + "\\" + DIRNAME2) -for root, dirs, files in os.walk(".", topdown = False): - for name in files: - path_to_file = os.path.join(root, name) - path_list.append(path_to_file) - if path_to_file.endswith(".txt"): - print(path_to_file + " text: ") - with open(path_to_file, "r", encoding='utf-8') as file: - text = file.read() - print(text) - text_list.append(text) - - -text_list = [line.rstrip() for line in text_list] -#print(path_list, text_list) - -col1 = pd.Series(path_list) -col2 = pd.Series(text_list) - -df = pd.DataFrame({'path':col1.reindex(col2.index), 'text':col2}) - -df.to_csv(PATH + "\\" + CSV_FILE2, sep = ',', index = False, encoding='Windows-1251') - - \ No newline at end of file