From 02ebbf5d331ea0bebace6a69943a56958da395bb Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Wed, 8 Apr 2020 00:24:56 +0530 Subject: [PATCH 01/17] add rnn from scratch article and updated gitignore --- .gitignore | 1 - .../original_code/RNN_from_Scratch.ipynb | 469 ++++++++++++++++++ 2 files changed, 469 insertions(+), 1 deletion(-) create mode 100644 RNN_From_Scratch/original_code/RNN_from_Scratch.ipynb diff --git a/.gitignore b/.gitignore index d49850b..462a618 100644 --- a/.gitignore +++ b/.gitignore @@ -2,5 +2,4 @@ *.pyc *.DS_Store .ipynb* -*.ipynb ourfirstscraper/tmp/ diff --git a/RNN_From_Scratch/original_code/RNN_from_Scratch.ipynb b/RNN_From_Scratch/original_code/RNN_from_Scratch.ipynb new file mode 100644 index 0000000..c4c6d8c --- /dev/null +++ b/RNN_From_Scratch/original_code/RNN_from_Scratch.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "sin_wave = np.array([math.sin(x) for x in np.arange(200)])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(sin_wave[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X = []\n", + "Y = []\n", + "\n", + "seq_len = 50\n", + "num_records = len(sin_wave) - seq_len\n", + "\n", + "for i in range(num_records - 50):\n", + " X.append(sin_wave[i:i+seq_len])\n", + " Y.append(sin_wave[i+seq_len])\n", + " \n", + "X = np.array(X)\n", + "X = np.expand_dims(X, axis=2)\n", + "\n", + "Y = np.array(Y)\n", + "Y = np.expand_dims(Y, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((100, 50, 1), (100, 1))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, Y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X_val = []\n", + "Y_val = []\n", + "\n", + "for i in range(num_records - 50, num_records):\n", + " X_val.append(sin_wave[i:i+seq_len])\n", + " Y_val.append(sin_wave[i+seq_len])\n", + " \n", + "X_val = np.array(X_val)\n", + "X_val = np.expand_dims(X_val, axis=2)\n", + "\n", + "Y_val = np.array(Y_val)\n", + "Y_val = np.expand_dims(Y_val, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = 0.0001 \n", + "nepoch = 20 \n", + "T = 50 # length of sequence\n", + "hidden_dim = 100 \n", + "output_dim = 1\n", + "\n", + "bptt_truncate = 5\n", + "min_clip_value = -10\n", + "max_clip_value = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "U = np.random.uniform(0, 1, (hidden_dim, T))\n", + "W = np.random.uniform(0, 1, (hidden_dim, hidden_dim))\n", + "V = np.random.uniform(0, 1, (output_dim, hidden_dim))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(x):\n", + " return 1 / (1 + np.exp(-x))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 , Loss: [[119715.7418754]] , Val Loss: [[59855.94392368]]\n", + "Epoch: 2 , Loss: [[75789.1000677]] , Val Loss: [[37893.00879389]]\n", + "Epoch: 3 , Loss: [[41862.45825993]] , Val Loss: [[20930.07366407]]\n", + "Epoch: 4 , Loss: [[17935.81632193]] , Val Loss: [[8967.13846899]]\n", + "Epoch: 5 , Loss: [[4015.89003719]] , Val Loss: [[2007.56198805]]\n", + "Epoch: 6 , Loss: [[41.95169859]] , Val Loss: [[20.89456954]]\n", + "Epoch: 7 , Loss: [[37.0608089]] , Val Loss: [[18.48214072]]\n", + "Epoch: 8 , Loss: [[37.25436272]] , Val Loss: [[18.58168268]]\n", + "Epoch: 9 , Loss: [[36.85413961]] , Val Loss: [[18.392885]]\n", + "Epoch: 10 , Loss: [[37.1764098]] , Val Loss: [[18.54467588]]\n", + "Epoch: 11 , Loss: [[37.21189539]] , Val Loss: [[18.57069531]]\n", + "Epoch: 12 , Loss: [[37.67377584]] , Val Loss: [[18.79091271]]\n", + "Epoch: 13 , Loss: [[37.54230402]] , Val Loss: [[18.73419709]]\n", + "Epoch: 14 , Loss: [[36.86531879]] , Val Loss: [[18.39623121]]\n", + "Epoch: 15 , Loss: [[37.40558225]] , Val Loss: [[18.66507984]]\n", + "Epoch: 16 , Loss: [[38.05540892]] , Val Loss: [[18.98248901]]\n", + "Epoch: 17 , Loss: [[37.49398354]] , Val Loss: [[18.70305351]]\n", + "Epoch: 18 , Loss: [[37.77387432]] , Val Loss: [[18.85192273]]\n", + "Epoch: 19 , Loss: [[37.87011851]] , Val Loss: [[18.89336484]]\n", + "Epoch: 20 , Loss: [[37.97060963]] , Val Loss: [[18.94031102]]\n" + ] + } + ], + "source": [ + "for epoch in range(nepoch):\n", + " # check loss on train\n", + " loss = 0.0\n", + " \n", + " # do a forward pass to get prediction\n", + " for i in range(Y.shape[0]):\n", + " x, y = X[i], Y[i] # get input, output values of each record\n", + " prev_s = np.zeros((hidden_dim, 1)) # here, prev-s is the value of the previous activation of hidden layer; which is initialized as all zeroes\n", + " for t in range(T):\n", + " new_input = np.zeros(x.shape) # we then do a forward pass for every timestep in the sequence\n", + " new_input[t] = x[t] # for this, we define a single input for that timestep\n", + " mulu = np.dot(U, new_input)\n", + " mulw = np.dot(W, prev_s)\n", + " add = mulw + mulu\n", + " s = sigmoid(add)\n", + " mulv = np.dot(V, s)\n", + " prev_s = s\n", + "\n", + " # calculate error \n", + " loss_per_record = (y - mulv)**2 / 2\n", + " loss += loss_per_record\n", + " loss = loss / float(y.shape[0])\n", + " \n", + " # check loss on val\n", + " val_loss = 0.0\n", + " for i in range(Y_val.shape[0]):\n", + " x, y = X_val[i], Y_val[i]\n", + " prev_s = np.zeros((hidden_dim, 1))\n", + " for t in range(T):\n", + " new_input = np.zeros(x.shape)\n", + " new_input[t] = x[t]\n", + " mulu = np.dot(U, new_input)\n", + " mulw = np.dot(W, prev_s)\n", + " add = mulw + mulu\n", + " s = sigmoid(add)\n", + " mulv = np.dot(V, s)\n", + " prev_s = s\n", + "\n", + " loss_per_record = (y - mulv)**2 / 2\n", + " val_loss += loss_per_record\n", + " val_loss = val_loss / float(y.shape[0])\n", + "\n", + " print('Epoch: ', epoch + 1, ', Loss: ', loss, ', Val Loss: ', val_loss)\n", + " \n", + " # train model\n", + " for i in range(Y.shape[0]):\n", + " x, y = X[i], Y[i]\n", + " \n", + " layers = []\n", + " prev_s = np.zeros((hidden_dim, 1))\n", + " dU = np.zeros(U.shape)\n", + " dV = np.zeros(V.shape)\n", + " dW = np.zeros(W.shape)\n", + " \n", + " dU_t = np.zeros(U.shape)\n", + " dV_t = np.zeros(V.shape)\n", + " dW_t = np.zeros(W.shape)\n", + " \n", + " dU_i = np.zeros(U.shape)\n", + " dW_i = np.zeros(W.shape)\n", + " \n", + " # forward pass\n", + " for t in range(T):\n", + " new_input = np.zeros(x.shape)\n", + " new_input[t] = x[t]\n", + " mulu = np.dot(U, new_input)\n", + " mulw = np.dot(W, prev_s)\n", + " add = mulw + mulu\n", + " s = sigmoid(add)\n", + " mulv = np.dot(V, s)\n", + " layers.append({'s':s, 'prev_s':prev_s})\n", + " prev_s = s\n", + " \n", + " # derivative of pred\n", + " dmulv = (mulv - y)\n", + " \n", + " # backward pass\n", + " for t in range(T):\n", + " dV_t = np.dot(dmulv, np.transpose(layers[t]['s']))\n", + " dsv = np.dot(np.transpose(V), dmulv)\n", + " \n", + " ds = dsv\n", + " dadd = add * (1 - add) * ds\n", + " \n", + " dmulw = dadd * np.ones_like(mulw)\n", + "\n", + " dprev_s = np.dot(np.transpose(W), dmulw)\n", + "\n", + "\n", + " for i in range(t-1, max(-1, t-bptt_truncate-1), -1):\n", + " ds = dsv + dprev_s\n", + " dadd = add * (1 - add) * ds\n", + "\n", + " dmulw = dadd * np.ones_like(mulw)\n", + " dmulu = dadd * np.ones_like(mulu)\n", + "\n", + " dW_i = np.dot(W, layers[t]['prev_s'])\n", + " dprev_s = np.dot(np.transpose(W), dmulw)\n", + "\n", + " new_input = np.zeros(x.shape)\n", + " new_input[t] = x[t]\n", + " dU_i = np.dot(U, new_input)\n", + " dx = np.dot(np.transpose(U), dmulu)\n", + "\n", + " dU_t += dU_i\n", + " dW_t += dW_i\n", + " \n", + " dV += dV_t\n", + " dU += dU_t\n", + " dW += dW_t\n", + " \n", + " if dU.max() > max_clip_value:\n", + " dU[dU > max_clip_value] = max_clip_value\n", + " if dV.max() > max_clip_value:\n", + " dV[dV > max_clip_value] = max_clip_value\n", + " if dW.max() > max_clip_value:\n", + " dW[dW > max_clip_value] = max_clip_value\n", + " \n", + " \n", + " if dU.min() < min_clip_value:\n", + " dU[dU < min_clip_value] = min_clip_value\n", + " if dV.min() < min_clip_value:\n", + " dV[dV < min_clip_value] = min_clip_value\n", + " if dW.min() < min_clip_value:\n", + " dW[dW < min_clip_value] = min_clip_value\n", + " \n", + " # update\n", + " U -= learning_rate * dU\n", + " V -= learning_rate * dV\n", + " W -= learning_rate * dW" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "preds = []\n", + "for i in range(Y.shape[0]):\n", + " x, y = X[i], Y[i]\n", + " prev_s = np.zeros((hidden_dim, 1))\n", + " # Forward pass\n", + " for t in range(T):\n", + " mulu = np.dot(U, x)\n", + " mulw = np.dot(W, prev_s)\n", + " add = mulw + mulu\n", + " s = sigmoid(add)\n", + " mulv = np.dot(V, s)\n", + " prev_s = s\n", + "\n", + " preds.append(mulv)\n", + " \n", + "preds = np.array(preds)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(preds[:, 0, 0], 'g')\n", + "plt.plot(Y[:, 0], 'r')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "preds = []\n", + "for i in range(Y_val.shape[0]):\n", + " x, y = X_val[i], Y_val[i]\n", + " prev_s = np.zeros((hidden_dim, 1))\n", + " # For each time step...\n", + " for t in range(T):\n", + " mulu = np.dot(U, x)\n", + " mulw = np.dot(W, prev_s)\n", + " add = mulw + mulu\n", + " s = sigmoid(add)\n", + " mulv = np.dot(V, s)\n", + " prev_s = s\n", + "\n", + " preds.append(mulv)\n", + " \n", + "preds = np.array(preds)\n", + "\n", + "plt.plot(preds[:, 0, 0], 'g')\n", + "plt.plot(Y_val[:, 0], 'r')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.24864788978970392" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "math.sqrt(mean_squared_error(Y_val[:, 0], preds[:, 0, 0]))" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 43835555a54306d7aeda0c6a80f8e4ff9eccc389 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Wed, 8 Apr 2020 00:34:12 +0530 Subject: [PATCH 02/17] Create README.md --- RNN_From_Scratch/README.md | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 RNN_From_Scratch/README.md diff --git a/RNN_From_Scratch/README.md b/RNN_From_Scratch/README.md new file mode 100644 index 0000000..8afe04f --- /dev/null +++ b/RNN_From_Scratch/README.md @@ -0,0 +1,10 @@ +Build a Recurrent Neural Network from Scratch in Python – An Essential Read for Data Scientists +=============================================================================== + +This repository contains code for the article ["Recurrent Neural Network from Scratch"](https://www.analyticsvidhya.com/blog/2019/01/fundamentals-deep-learning-recurrent-neural-networks-scratch-python/) article published on Analytics Vidhya + +Structure: +--------- + +- original_code/ + - RNN_from_Scratch.ipynb From 0c853fad0de7004f8aa7a1a20d1c2fa0fb21091b Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Wed, 8 Apr 2020 21:37:37 +0530 Subject: [PATCH 03/17] add inception from scratch --- Inception_From_Scratch/README.md | 10 + .../Inception_v1_from_Scratch.ipynb | 321 ++++++++++++++++++ 2 files changed, 331 insertions(+) create mode 100644 Inception_From_Scratch/README.md create mode 100644 Inception_From_Scratch/original_code/Inception_v1_from_Scratch.ipynb diff --git a/Inception_From_Scratch/README.md b/Inception_From_Scratch/README.md new file mode 100644 index 0000000..ecaf44e --- /dev/null +++ b/Inception_From_Scratch/README.md @@ -0,0 +1,10 @@ +Deep Learning in the Trenches - Understanding Inception Network from Scratch +=============================================================================== + +This repository contains code for the article ["Understanding Inception Network from Scratch"](https://www.analyticsvidhya.com/blog/2018/10/understanding-inception-network-from-scratch/) article published on Analytics Vidhya + +Structure: +--------- + +- original_code/ + - Inception_v1_from_Scratch.ipynb diff --git a/Inception_From_Scratch/original_code/Inception_v1_from_Scratch.ipynb b/Inception_From_Scratch/original_code/Inception_v1_from_Scratch.ipynb new file mode 100644 index 0000000..b0fce1b --- /dev/null +++ b/Inception_From_Scratch/original_code/Inception_v1_from_Scratch.ipynb @@ -0,0 +1,321 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation of GoogLeNet in Keras " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import keras\n", + "from keras.layers.core import Layer\n", + "import keras.backend as K\n", + "import tensorflow as tf\n", + "from keras.datasets import cifar10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from keras.models import Model\n", + "from keras.layers import Conv2D, MaxPool2D, \\\n", + " Dropout, Dense, Input, concatenate, \\\n", + " GlobalAveragePooling2D, AveragePooling2D,\\\n", + " Flatten\n", + "\n", + "import cv2 \n", + "import numpy as np \n", + "from keras.datasets import cifar10 \n", + "from keras import backend as K \n", + "from keras.utils import np_utils\n", + "\n", + "import math \n", + "from keras.optimizers import SGD \n", + "from keras.callbacks import LearningRateScheduler" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_classes = 10\n", + "\n", + "def load_cifar10_data(img_rows, img_cols):\n", + "\n", + " # Load cifar10 training and validation sets\n", + " (X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\n", + "\n", + " # Resize training images\n", + " X_train = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_train[:,:,:,:]])\n", + " X_valid = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_valid[:,:,:,:]])\n", + "\n", + " # Transform targets to keras compatible format\n", + " Y_train = np_utils.to_categorical(Y_train, num_classes)\n", + " Y_valid = np_utils.to_categorical(Y_valid, num_classes)\n", + " \n", + " X_train = X_train.astype('float32')\n", + " X_valid = X_valid.astype('float32')\n", + "\n", + " # preprocess data\n", + " X_train = X_train / 255.0\n", + " X_valid = X_valid / 255.0\n", + "\n", + " return X_train, Y_train, X_valid, Y_valid" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, y_train, X_test, y_test = load_cifar10_data(224, 224)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def inception_module(x,\n", + " filters_1x1,\n", + " filters_3x3_reduce,\n", + " filters_3x3,\n", + " filters_5x5_reduce,\n", + " filters_5x5,\n", + " filters_pool_proj,\n", + " name=None):\n", + " \n", + " conv_1x1 = Conv2D(filters_1x1, (1, 1), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(x)\n", + " \n", + " conv_3x3 = Conv2D(filters_3x3_reduce, (1, 1), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(x)\n", + " conv_3x3 = Conv2D(filters_3x3, (3, 3), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(conv_3x3)\n", + "\n", + " conv_5x5 = Conv2D(filters_5x5_reduce, (1, 1), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(x)\n", + " conv_5x5 = Conv2D(filters_5x5, (5, 5), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(conv_5x5)\n", + "\n", + " pool_proj = MaxPool2D((3, 3), strides=(1, 1), padding='same')(x)\n", + " pool_proj = Conv2D(filters_pool_proj, (1, 1), padding='same', activation='relu', kernel_initializer=kernel_init, bias_initializer=bias_init)(pool_proj)\n", + "\n", + " output = concatenate([conv_1x1, conv_3x3, conv_5x5, pool_proj], axis=3, name=name)\n", + " \n", + " return output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_init = keras.initializers.glorot_uniform()\n", + "bias_init = keras.initializers.Constant(value=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "input_layer = Input(shape=(224, 224, 3))\n", + "\n", + "x = Conv2D(64, (7, 7), padding='same', strides=(2, 2), activation='relu', name='conv_1_7x7/2', kernel_initializer=kernel_init, bias_initializer=bias_init)(input_layer)\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_1_3x3/2')(x)\n", + "x = Conv2D(64, (1, 1), padding='same', strides=(1, 1), activation='relu', name='conv_2a_3x3/1')(x)\n", + "x = Conv2D(192, (3, 3), padding='same', strides=(1, 1), activation='relu', name='conv_2b_3x3/1')(x)\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_2_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=64,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=128,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=32,\n", + " filters_pool_proj=32,\n", + " name='inception_3a')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=192,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=96,\n", + " filters_pool_proj=64,\n", + " name='inception_3b')\n", + "\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_3_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=192,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=208,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=48,\n", + " filters_pool_proj=64,\n", + " name='inception_4a')\n", + "\n", + "\n", + "x1 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x1 = Conv2D(128, (1, 1), padding='same', activation='relu')(x1)\n", + "x1 = Flatten()(x1)\n", + "x1 = Dense(1024, activation='relu')(x1)\n", + "x1 = Dropout(0.7)(x1)\n", + "x1 = Dense(10, activation='softmax', name='auxilliary_output_1')(x1)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=160,\n", + " filters_3x3_reduce=112,\n", + " filters_3x3=224,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4b')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=256,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4c')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=112,\n", + " filters_3x3_reduce=144,\n", + " filters_3x3=288,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4d')\n", + "\n", + "\n", + "x2 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x2 = Conv2D(128, (1, 1), padding='same', activation='relu')(x2)\n", + "x2 = Flatten()(x2)\n", + "x2 = Dense(1024, activation='relu')(x2)\n", + "x2 = Dropout(0.7)(x2)\n", + "x2 = Dense(10, activation='softmax', name='auxilliary_output_2')(x2)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_4e')\n", + "\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_4_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_5a')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=384,\n", + " filters_3x3_reduce=192,\n", + " filters_3x3=384,\n", + " filters_5x5_reduce=48,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_5b')\n", + "\n", + "x = GlobalAveragePooling2D(name='avg_pool_5_3x3/1')(x)\n", + "\n", + "x = Dropout(0.4)(x)\n", + "\n", + "x = Dense(10, activation='softmax', name='output')(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model(input_layer, [x, x1, x2], name='inception_v1')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "epochs = 25\n", + "initial_lrate = 0.01\n", + "\n", + "def decay(epoch, steps=100):\n", + " initial_lrate = 0.01\n", + " drop = 0.96\n", + " epochs_drop = 8\n", + " lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))\n", + " return lrate\n", + "\n", + "sgd = SGD(lr=initial_lrate, momentum=0.9, nesterov=False)\n", + "\n", + "lr_sc = LearningRateScheduler(decay, verbose=1)\n", + "\n", + "model.compile(loss=['categorical_crossentropy', 'categorical_crossentropy', 'categorical_crossentropy'], loss_weights=[1, 0.3, 0.3], optimizer=sgd, metrics=['accuracy'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "history = model.fit(X_train, [y_train, y_train, y_train], validation_data=(X_test, [y_test, y_test, y_test]), epochs=epochs, batch_size=256, callbacks=[lr_sc])" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 5726057adb3155e7de5c69327efb83b35ed69c3f Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Thu, 9 Apr 2020 20:13:55 +0530 Subject: [PATCH 04/17] add object detection from scratch --- Object_Detection_From_Scratch/README.md | 10 ++++ .../Object_Detection_ImageAI_Retinanet.ipynb | 59 +++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 Object_Detection_From_Scratch/README.md create mode 100644 Object_Detection_From_Scratch/original_code/Object_Detection_ImageAI_Retinanet.ipynb diff --git a/Object_Detection_From_Scratch/README.md b/Object_Detection_From_Scratch/README.md new file mode 100644 index 0000000..ec3174f --- /dev/null +++ b/Object_Detection_From_Scratch/README.md @@ -0,0 +1,10 @@ +Understanding and Building an Object Detection Model from Scratch in Python +=============================================================================== + +This repository contains code for the article ["Understanding Object Detection from Scratch"](https://www.analyticsvidhya.com/blog/2018/06/understanding-building-object-detection-model-python/) article published on Analytics Vidhya + +Structure: +--------- + +- original_code/ + - Object_Detection_ImageAI_Retinanet.ipynb diff --git a/Object_Detection_From_Scratch/original_code/Object_Detection_ImageAI_Retinanet.ipynb b/Object_Detection_From_Scratch/original_code/Object_Detection_ImageAI_Retinanet.ipynb new file mode 100644 index 0000000..756474c --- /dev/null +++ b/Object_Detection_From_Scratch/original_code/Object_Detection_ImageAI_Retinanet.ipynb @@ -0,0 +1,59 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from imageai.Detection import ObjectDetection\n", + "import os\n", + "\n", + "execution_path = os.getcwd()\n", + "\n", + "detector = ObjectDetection()\n", + "detector.setModelTypeAsRetinaNet()\n", + "detector.setModelPath( os.path.join(execution_path , \"resnet50_coco_best_v2.0.1.h5\"))\n", + "detector.loadModel()\n", + "custom_objects = detector.CustomObjects(person=True, car=False)\n", + "detections = detector.detectCustomObjectsFromImage(input_image=os.path.join(execution_path , \"image.png\"), output_image_path=os.path.join(execution_path , \"image_new.png\"), custom_objects=custom_objects, minimum_percentage_probability=65)\n", + "\n", + "\n", + "for eachObject in detections:\n", + " print(eachObject[\"name\"] + \" : \" + eachObject[\"percentage_probability\"] )\n", + " print(\"--------------------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Image\n", + "Image(\"image_new.png\")" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From e53ce8b9648cc6e7f415cc1a86604161b9014ec1 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Thu, 9 Apr 2020 22:13:41 +0530 Subject: [PATCH 05/17] Created using Colaboratory --- Inception_v1_from_Scratch.ipynb | 582 ++++++++++++++++++++++++++++++++ 1 file changed, 582 insertions(+) create mode 100644 Inception_v1_from_Scratch.ipynb diff --git a/Inception_v1_from_Scratch.ipynb b/Inception_v1_from_Scratch.ipynb new file mode 100644 index 0000000..4519ca5 --- /dev/null +++ b/Inception_v1_from_Scratch.ipynb @@ -0,0 +1,582 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "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" + }, + "colab": { + "name": "Inception_v1_from_Scratch.ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JIuCtW728WD2", + "colab_type": "code", + "outputId": "c806e217-e60b-4e50-ef37-198106096fcd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + } + }, + "source": [ + "%tensorflow_version 1.x\n", + "\n", + "import cv2 \n", + "import math\n", + "import numpy as np \n", + "import tensorflow as tf\n", + "import keras.backend as K\n", + "\n", + "from keras.models import Model\n", + "from keras.optimizers import SGD \n", + "from keras.utils import np_utils\n", + "from keras.datasets import cifar10\n", + "from keras.layers.core import Layer\n", + "from keras.callbacks import LearningRateScheduler\n", + "from keras.initializers import glorot_uniform, Constant\n", + "from keras.preprocessing.image import ImageDataGenerator\n", + "from keras.layers import Conv2D, MaxPool2D, Dropout, Dense, Input, concatenate,\\\n", + " GlobalAveragePooling2D, AveragePooling2D, Flatten" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "m5p4szZUEQeZ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "(X_train, y_train), (X_valid, y_valid) = cifar10.load_data()\n", + "y_train = np_utils.to_categorical(y_train, 10)\n", + "y_valid = np_utils.to_categorical(y_valid, 10)\n", + "\n", + "def CustomImageDataGenerator(X, y, batch_size):\n", + " generator = ImageDataGenerator(\n", + " rescale=1/255.,\n", + " dtype='float32')\n", + " \n", + " datagen = generator.flow(X, y, batch_size=batch_size)\n", + "\n", + " while True:\n", + " X, y = datagen.__next__()\n", + " X = np.array([cv2.resize(img, (224,224)) for img in X[:,:,:,:]])\n", + " yield X, [y, y, y]" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "0ZkGA5pA8XKu", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def inception_module(x,\n", + " filters_1x1,\n", + " filters_3x3_reduce,\n", + " filters_3x3,\n", + " filters_5x5_reduce,\n", + " filters_5x5,\n", + " filters_pool_proj,\n", + " name=None):\n", + " \n", + " conv_1x1 = Conv2D(\n", + " filters=filters_1x1, \n", + " kernel_size=(1, 1), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(x)\n", + " \n", + " conv_3x3 = Conv2D(\n", + " filters=filters_3x3_reduce, \n", + " kernel_size=(1, 1), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(x)\n", + "\n", + " conv_3x3 = Conv2D(\n", + " filters=filters_3x3, \n", + " kernel_size=(3, 3), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(conv_3x3)\n", + "\n", + " conv_5x5 = Conv2D(\n", + " filters=filters_5x5_reduce, \n", + " kernel_size=(1, 1), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(x)\n", + "\n", + " conv_5x5 = Conv2D(\n", + " filters=filters_5x5, \n", + " kernel_size=(5, 5), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(conv_5x5)\n", + "\n", + " pool_proj = MaxPool2D(\n", + " pool_size=(3, 3), \n", + " strides=(1, 1), \n", + " padding='same'\n", + " )(x)\n", + "\n", + " pool_proj = Conv2D(\n", + " filters=filters_pool_proj, \n", + " kernel_size=(1, 1), \n", + " padding='same', \n", + " activation='relu', \n", + " kernel_initializer=kernel_init, \n", + " bias_initializer=bias_init\n", + " )(pool_proj)\n", + "\n", + " output = concatenate(\n", + " inputs=[conv_1x1, conv_3x3, conv_5x5, pool_proj], \n", + " axis=3, \n", + " name=name\n", + " )\n", + " \n", + " return output" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1y73xcMu8XNa", + "colab_type": "code", + "colab": {} + }, + "source": [ + "kernel_init = glorot_uniform()\n", + "bias_init = Constant(value=0.2)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "7ZYsSUO88XPu", + "colab_type": "code", + "outputId": "a9035306-623d-419d-cf0e-819e72846bdc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 332 + } + }, + "source": [ + "input_layer = Input(shape=(224, 224, 3))\n", + "\n", + "x = Conv2D(64, (7, 7), padding='same', strides=(2, 2), activation='relu', name='conv_1_7x7/2', kernel_initializer=kernel_init, bias_initializer=bias_init)(input_layer)\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_1_3x3/2')(x)\n", + "x = Conv2D(64, (1, 1), padding='same', strides=(1, 1), activation='relu', name='conv_2a_3x3/1')(x)\n", + "x = Conv2D(192, (3, 3), padding='same', strides=(1, 1), activation='relu', name='conv_2b_3x3/1')(x)\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_2_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=64,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=128,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=32,\n", + " filters_pool_proj=32,\n", + " name='inception_3a')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=192,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=96,\n", + " filters_pool_proj=64,\n", + " name='inception_3b')\n", + "\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_3_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=192,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=208,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=48,\n", + " filters_pool_proj=64,\n", + " name='inception_4a')\n", + "\n", + "\n", + "x1 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x1 = Conv2D(128, (1, 1), padding='same', activation='relu')(x1)\n", + "x1 = Flatten()(x1)\n", + "x1 = Dense(1024, activation='relu')(x1)\n", + "x1 = Dropout(0.7)(x1)\n", + "x1 = Dense(10, activation='softmax', name='auxilliary_output_1')(x1)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=160,\n", + " filters_3x3_reduce=112,\n", + " filters_3x3=224,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4b')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=256,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4c')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=112,\n", + " filters_3x3_reduce=144,\n", + " filters_3x3=288,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name='inception_4d')\n", + "\n", + "\n", + "x2 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x2 = Conv2D(128, (1, 1), padding='same', activation='relu')(x2)\n", + "x2 = Flatten()(x2)\n", + "x2 = Dense(1024, activation='relu')(x2)\n", + "x2 = Dropout(0.7)(x2)\n", + "x2 = Dense(10, activation='softmax', name='auxilliary_output_2')(x2)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_4e')\n", + "\n", + "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_4_3x3/2')(x)\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_5a')\n", + "\n", + "x = inception_module(x,\n", + " filters_1x1=384,\n", + " filters_3x3_reduce=192,\n", + " filters_3x3=384,\n", + " filters_5x5_reduce=48,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name='inception_5b')\n", + "\n", + "x = GlobalAveragePooling2D(name='avg_pool_5_3x3/1')(x)\n", + "\n", + "x = Dropout(0.4)(x)\n", + "\n", + "x = Dense(10, activation='softmax', name='output')(x)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4271: The name tf.nn.avg_pool is deprecated. Please use tf.nn.avg_pool2d instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:148: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3733: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", + "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n", + "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "K5gv4hDA8XSA", + "colab_type": "code", + "colab": {} + }, + "source": [ + "model = Model(input_layer, [x, x1, x2], name='inception_v1')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "oDaDZJCE8XUO", + "colab_type": "code", + "colab": {} + }, + "source": [ + "model.summary()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "UUAV2emp8XWL", + "colab_type": "code", + "outputId": "ccd0abe1-7985-4edf-ba9d-56f47c1d7eed", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 106 + } + }, + "source": [ + "epochs = 25\n", + "initial_lrate = 0.01\n", + "\n", + "def decay(epoch, steps=100):\n", + " initial_lrate = 0.01\n", + " drop = 0.96\n", + " epochs_drop = 8\n", + " lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))\n", + " return lrate\n", + "\n", + "sgd = SGD(lr=initial_lrate, momentum=0.9, nesterov=False)\n", + "\n", + "lr_sc = LearningRateScheduler(decay, verbose=1)\n", + "\n", + "model.compile(loss=['categorical_crossentropy', 'categorical_crossentropy', 'categorical_crossentropy'], loss_weights=[1, 0.3, 0.3], optimizer=sgd, metrics=['accuracy'])" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3576: The name tf.log is deprecated. Please use tf.math.log instead.\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FpVMejKG7TDI", + "colab_type": "code", + "outputId": "9745f1b1-ab2a-4366-ad74-2ea2195d63b2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 610 + } + }, + "source": [ + "model.fit_generator(CustomImageDataGenerator(X_train, y_train,\n", + " batch_size=256),\n", + " epochs=epochs,\n", + " steps_per_epoch=200,\n", + " use_multiprocessing=True,\n", + " workers=4,\n", + " callbacks=[lr_sc] \n", + " )" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1020: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3005: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", + "\n", + "Epoch 1/25\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n", + "\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/keras/engine/training_generator.py:49: UserWarning: Using a generator with `use_multiprocessing=True` and multiple workers may duplicate your data. Please consider using the `keras.utils.Sequence class.\n", + " UserWarning('Using a generator with `use_multiprocessing=True`'\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n", + "\n", + "\n", + "Epoch 00001: LearningRateScheduler setting learning rate to 0.01.\n", + "200/200 [==============================] - 218s 1s/step - loss: 3.7005 - output_loss: 2.3221 - auxilliary_output_1_loss: 2.2912 - auxilliary_output_2_loss: 2.3033 - output_acc: 0.1143 - auxilliary_output_1_acc: 0.1238 - auxilliary_output_2_acc: 0.1117\n", + "Epoch 2/25\n", + "\n", + "Epoch 00002: LearningRateScheduler setting learning rate to 0.01.\n", + "200/200 [==============================] - 195s 974ms/step - loss: 3.2905 - output_loss: 2.0650 - auxilliary_output_1_loss: 2.0379 - auxilliary_output_2_loss: 2.0472 - output_acc: 0.2155 - auxilliary_output_1_acc: 0.2431 - auxilliary_output_2_acc: 0.2337\n", + "Epoch 3/25\n", + "\n", + "Epoch 00003: LearningRateScheduler setting learning rate to 0.01.\n", + " 48/200 [======>.......................] - ETA: 2:28 - loss: 3.1024 - output_loss: 1.9481 - auxilliary_output_1_loss: 1.9233 - auxilliary_output_2_loss: 1.9243 - output_acc: 0.2620 - auxilliary_output_1_acc: 0.2888 - auxilliary_output_2_acc: 0.2900" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sVw564lF7TDx", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "7yzEoiwy7TD1", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "sWzukhcc7TD5", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "sfBeNW5x7TD-", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "4kkvXVHj7TEE", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file From 151b739f69dbcf15531699893c719fbd56be86a7 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Thu, 9 Apr 2020 22:49:33 +0530 Subject: [PATCH 06/17] improved inception from scratch code --- .gitignore | 1 + Inception_From_Scratch/README.md | 2 + .../Inception_v1_from_Scratch.ipynb | 575 +++++++++++++++++ Inception_v1_from_Scratch.ipynb | 582 ------------------ 4 files changed, 578 insertions(+), 582 deletions(-) create mode 100644 Inception_From_Scratch/improvements/Inception_v1_from_Scratch.ipynb delete mode 100644 Inception_v1_from_Scratch.ipynb diff --git a/.gitignore b/.gitignore index 462a618..c93aaed 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ *.DS_Store .ipynb* ourfirstscraper/tmp/ +misc/ diff --git a/Inception_From_Scratch/README.md b/Inception_From_Scratch/README.md index ecaf44e..8e1785c 100644 --- a/Inception_From_Scratch/README.md +++ b/Inception_From_Scratch/README.md @@ -8,3 +8,5 @@ Structure: - original_code/ - Inception_v1_from_Scratch.ipynb +- improvements/ + - Inception_v1_from_Scratch.ipynb diff --git a/Inception_From_Scratch/improvements/Inception_v1_from_Scratch.ipynb b/Inception_From_Scratch/improvements/Inception_v1_from_Scratch.ipynb new file mode 100644 index 0000000..c1fcb24 --- /dev/null +++ b/Inception_From_Scratch/improvements/Inception_v1_from_Scratch.ipynb @@ -0,0 +1,575 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Improvements\n", + "\n", + "1. Tested on Google Colab\n", + "2. Updated the code to use data generators to process image data on the fly\n", + "3. Code style improved" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "colab_type": "code", + "id": "JIuCtW728WD2", + "outputId": "c806e217-e60b-4e50-ef37-198106096fcd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "%tensorflow_version 1.x\n", + "\n", + "import cv2\n", + "import math\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import keras.backend as K\n", + "\n", + "from keras.models import Model\n", + "from keras.optimizers import SGD\n", + "from keras.utils import np_utils\n", + "from keras.datasets import cifar10\n", + "from keras.layers.core import Layer\n", + "from keras.callbacks import LearningRateScheduler\n", + "from keras.initializers import glorot_uniform, Constant\n", + "from keras.preprocessing.image import ImageDataGenerator\n", + "from keras.layers import (\n", + " Conv2D,\n", + " MaxPool2D,\n", + " Dropout,\n", + " Dense,\n", + " Input,\n", + " concatenate,\n", + " GlobalAveragePooling2D,\n", + " AveragePooling2D,\n", + " Flatten,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "m5p4szZUEQeZ" + }, + "outputs": [], + "source": [ + "(X_train, y_train), (X_valid, y_valid) = cifar10.load_data()\n", + "y_train = np_utils.to_categorical(y_train, 10)\n", + "y_valid = np_utils.to_categorical(y_valid, 10)\n", + "\n", + "\n", + "def CustomImageDataGenerator(X, y, batch_size):\n", + " generator = ImageDataGenerator(rescale=1 / 255.0, dtype=\"float32\")\n", + "\n", + " datagen = generator.flow(X, y, batch_size=batch_size)\n", + "\n", + " while True:\n", + " X, y = datagen.__next__()\n", + " X = np.array([cv2.resize(img, (224, 224)) for img in X[:, :, :, :]])\n", + " yield X, [y, y, y]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "0ZkGA5pA8XKu" + }, + "outputs": [], + "source": [ + "def inception_module(\n", + " x,\n", + " filters_1x1,\n", + " filters_3x3_reduce,\n", + " filters_3x3,\n", + " filters_5x5_reduce,\n", + " filters_5x5,\n", + " filters_pool_proj,\n", + " name=None,\n", + "):\n", + "\n", + " conv_1x1 = Conv2D(\n", + " filters=filters_1x1,\n", + " kernel_size=(1, 1),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(x)\n", + "\n", + " conv_3x3 = Conv2D(\n", + " filters=filters_3x3_reduce,\n", + " kernel_size=(1, 1),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(x)\n", + "\n", + " conv_3x3 = Conv2D(\n", + " filters=filters_3x3,\n", + " kernel_size=(3, 3),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(conv_3x3)\n", + "\n", + " conv_5x5 = Conv2D(\n", + " filters=filters_5x5_reduce,\n", + " kernel_size=(1, 1),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(x)\n", + "\n", + " conv_5x5 = Conv2D(\n", + " filters=filters_5x5,\n", + " kernel_size=(5, 5),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(conv_5x5)\n", + "\n", + " pool_proj = MaxPool2D(pool_size=(3, 3), strides=(1, 1), padding=\"same\")(x)\n", + "\n", + " pool_proj = Conv2D(\n", + " filters=filters_pool_proj,\n", + " kernel_size=(1, 1),\n", + " padding=\"same\",\n", + " activation=\"relu\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + " )(pool_proj)\n", + "\n", + " output = concatenate(\n", + " inputs=[conv_1x1, conv_3x3, conv_5x5, pool_proj], axis=3, name=name\n", + " )\n", + "\n", + " return output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "1y73xcMu8XNa" + }, + "outputs": [], + "source": [ + "kernel_init = glorot_uniform()\n", + "bias_init = Constant(value=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 332 + }, + "colab_type": "code", + "id": "7ZYsSUO88XPu", + "outputId": "a9035306-623d-419d-cf0e-819e72846bdc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4271: The name tf.nn.avg_pool is deprecated. Please use tf.nn.avg_pool2d instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:148: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3733: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", + "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n", + "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n" + ] + } + ], + "source": [ + "input_layer = Input(shape=(224, 224, 3))\n", + "\n", + "x = Conv2D(\n", + " 64,\n", + " (7, 7),\n", + " padding=\"same\",\n", + " strides=(2, 2),\n", + " activation=\"relu\",\n", + " name=\"conv_1_7x7/2\",\n", + " kernel_initializer=kernel_init,\n", + " bias_initializer=bias_init,\n", + ")(input_layer)\n", + "x = MaxPool2D((3, 3), padding=\"same\", strides=(2, 2), name=\"max_pool_1_3x3/2\")(x)\n", + "x = Conv2D(\n", + " 64, (1, 1), padding=\"same\", strides=(1, 1), activation=\"relu\", name=\"conv_2a_3x3/1\"\n", + ")(x)\n", + "x = Conv2D(\n", + " 192, (3, 3), padding=\"same\", strides=(1, 1), activation=\"relu\", name=\"conv_2b_3x3/1\"\n", + ")(x)\n", + "x = MaxPool2D((3, 3), padding=\"same\", strides=(2, 2), name=\"max_pool_2_3x3/2\")(x)\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=64,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=128,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=32,\n", + " filters_pool_proj=32,\n", + " name=\"inception_3a\",\n", + ")\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=192,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=96,\n", + " filters_pool_proj=64,\n", + " name=\"inception_3b\",\n", + ")\n", + "\n", + "x = MaxPool2D((3, 3), padding=\"same\", strides=(2, 2), name=\"max_pool_3_3x3/2\")(x)\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=192,\n", + " filters_3x3_reduce=96,\n", + " filters_3x3=208,\n", + " filters_5x5_reduce=16,\n", + " filters_5x5=48,\n", + " filters_pool_proj=64,\n", + " name=\"inception_4a\",\n", + ")\n", + "\n", + "\n", + "x1 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x1 = Conv2D(128, (1, 1), padding=\"same\", activation=\"relu\")(x1)\n", + "x1 = Flatten()(x1)\n", + "x1 = Dense(1024, activation=\"relu\")(x1)\n", + "x1 = Dropout(0.7)(x1)\n", + "x1 = Dense(10, activation=\"softmax\", name=\"auxilliary_output_1\")(x1)\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=160,\n", + " filters_3x3_reduce=112,\n", + " filters_3x3=224,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name=\"inception_4b\",\n", + ")\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=128,\n", + " filters_3x3_reduce=128,\n", + " filters_3x3=256,\n", + " filters_5x5_reduce=24,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name=\"inception_4c\",\n", + ")\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=112,\n", + " filters_3x3_reduce=144,\n", + " filters_3x3=288,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=64,\n", + " filters_pool_proj=64,\n", + " name=\"inception_4d\",\n", + ")\n", + "\n", + "\n", + "x2 = AveragePooling2D((5, 5), strides=3)(x)\n", + "x2 = Conv2D(128, (1, 1), padding=\"same\", activation=\"relu\")(x2)\n", + "x2 = Flatten()(x2)\n", + "x2 = Dense(1024, activation=\"relu\")(x2)\n", + "x2 = Dropout(0.7)(x2)\n", + "x2 = Dense(10, activation=\"softmax\", name=\"auxilliary_output_2\")(x2)\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name=\"inception_4e\",\n", + ")\n", + "\n", + "x = MaxPool2D((3, 3), padding=\"same\", strides=(2, 2), name=\"max_pool_4_3x3/2\")(x)\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=256,\n", + " filters_3x3_reduce=160,\n", + " filters_3x3=320,\n", + " filters_5x5_reduce=32,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name=\"inception_5a\",\n", + ")\n", + "\n", + "x = inception_module(\n", + " x,\n", + " filters_1x1=384,\n", + " filters_3x3_reduce=192,\n", + " filters_3x3=384,\n", + " filters_5x5_reduce=48,\n", + " filters_5x5=128,\n", + " filters_pool_proj=128,\n", + " name=\"inception_5b\",\n", + ")\n", + "\n", + "x = GlobalAveragePooling2D(name=\"avg_pool_5_3x3/1\")(x)\n", + "\n", + "x = Dropout(0.4)(x)\n", + "\n", + "x = Dense(10, activation=\"softmax\", name=\"output\")(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "K5gv4hDA8XSA" + }, + "outputs": [], + "source": [ + "model = Model(input_layer, [x, x1, x2], name=\"inception_v1\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "oDaDZJCE8XUO" + }, + "outputs": [], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 106 + }, + "colab_type": "code", + "id": "UUAV2emp8XWL", + "outputId": "ccd0abe1-7985-4edf-ba9d-56f47c1d7eed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3576: The name tf.log is deprecated. Please use tf.math.log instead.\n", + "\n" + ] + } + ], + "source": [ + "epochs = 25\n", + "initial_lrate = 0.01\n", + "\n", + "\n", + "def decay(epoch, steps=100):\n", + " initial_lrate = 0.01\n", + " drop = 0.96\n", + " epochs_drop = 8\n", + " lrate = initial_lrate * math.pow(drop, math.floor((1 + epoch) / epochs_drop))\n", + " return lrate\n", + "\n", + "\n", + "sgd = SGD(lr=initial_lrate, momentum=0.9, nesterov=False)\n", + "\n", + "lr_sc = LearningRateScheduler(decay, verbose=1)\n", + "\n", + "model.compile(\n", + " loss=[\n", + " \"categorical_crossentropy\",\n", + " \"categorical_crossentropy\",\n", + " \"categorical_crossentropy\",\n", + " ],\n", + " loss_weights=[1, 0.3, 0.3],\n", + " optimizer=sgd,\n", + " metrics=[\"accuracy\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 610 + }, + "colab_type": "code", + "id": "FpVMejKG7TDI", + "outputId": "9745f1b1-ab2a-4366-ad74-2ea2195d63b2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1020: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3005: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", + "\n", + "Epoch 1/25\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/keras/engine/training_generator.py:49: UserWarning: Using a generator with `use_multiprocessing=True` and multiple workers may duplicate your data. Please consider using the `keras.utils.Sequence class.\n", + " UserWarning('Using a generator with `use_multiprocessing=True`'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n", + "\n", + "\n", + "Epoch 00001: LearningRateScheduler setting learning rate to 0.01.\n", + "200/200 [==============================] - 218s 1s/step - loss: 3.7005 - output_loss: 2.3221 - auxilliary_output_1_loss: 2.2912 - auxilliary_output_2_loss: 2.3033 - output_acc: 0.1143 - auxilliary_output_1_acc: 0.1238 - auxilliary_output_2_acc: 0.1117\n", + "Epoch 2/25\n", + "\n", + "Epoch 00002: LearningRateScheduler setting learning rate to 0.01.\n", + "200/200 [==============================] - 195s 974ms/step - loss: 3.2905 - output_loss: 2.0650 - auxilliary_output_1_loss: 2.0379 - auxilliary_output_2_loss: 2.0472 - output_acc: 0.2155 - auxilliary_output_1_acc: 0.2431 - auxilliary_output_2_acc: 0.2337\n", + "Epoch 3/25\n", + "\n", + "Epoch 00003: LearningRateScheduler setting learning rate to 0.01.\n", + " 48/200 [======>.......................] - ETA: 2:28 - loss: 3.1024 - output_loss: 1.9481 - auxilliary_output_1_loss: 1.9233 - auxilliary_output_2_loss: 1.9243 - output_acc: 0.2620 - auxilliary_output_1_acc: 0.2888 - auxilliary_output_2_acc: 0.2900" + ] + } + ], + "source": [ + "model.fit_generator(\n", + " CustomImageDataGenerator(X_train, y_train, batch_size=256),\n", + " epochs=epochs,\n", + " steps_per_epoch=200,\n", + " use_multiprocessing=True,\n", + " workers=4,\n", + " callbacks=[lr_sc],\n", + ")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "include_colab_link": true, + "name": "Inception_v1_from_Scratch.ipynb", + "provenance": [] + }, + "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/Inception_v1_from_Scratch.ipynb b/Inception_v1_from_Scratch.ipynb deleted file mode 100644 index 4519ca5..0000000 --- a/Inception_v1_from_Scratch.ipynb +++ /dev/null @@ -1,582 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "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" - }, - "colab": { - "name": "Inception_v1_from_Scratch.ipynb", - "provenance": [], - "collapsed_sections": [], - "include_colab_link": true - }, - "accelerator": "GPU" - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "JIuCtW728WD2", - "colab_type": "code", - "outputId": "c806e217-e60b-4e50-ef37-198106096fcd", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 52 - } - }, - "source": [ - "%tensorflow_version 1.x\n", - "\n", - "import cv2 \n", - "import math\n", - "import numpy as np \n", - "import tensorflow as tf\n", - "import keras.backend as K\n", - "\n", - "from keras.models import Model\n", - "from keras.optimizers import SGD \n", - "from keras.utils import np_utils\n", - "from keras.datasets import cifar10\n", - "from keras.layers.core import Layer\n", - "from keras.callbacks import LearningRateScheduler\n", - "from keras.initializers import glorot_uniform, Constant\n", - "from keras.preprocessing.image import ImageDataGenerator\n", - "from keras.layers import Conv2D, MaxPool2D, Dropout, Dense, Input, concatenate,\\\n", - " GlobalAveragePooling2D, AveragePooling2D, Flatten" - ], - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "text": [ - "TensorFlow 1.x selected.\n" - ], - "name": "stdout" - }, - { - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n" - ], - "name": "stderr" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "m5p4szZUEQeZ", - "colab_type": "code", - "colab": {} - }, - "source": [ - "(X_train, y_train), (X_valid, y_valid) = cifar10.load_data()\n", - "y_train = np_utils.to_categorical(y_train, 10)\n", - "y_valid = np_utils.to_categorical(y_valid, 10)\n", - "\n", - "def CustomImageDataGenerator(X, y, batch_size):\n", - " generator = ImageDataGenerator(\n", - " rescale=1/255.,\n", - " dtype='float32')\n", - " \n", - " datagen = generator.flow(X, y, batch_size=batch_size)\n", - "\n", - " while True:\n", - " X, y = datagen.__next__()\n", - " X = np.array([cv2.resize(img, (224,224)) for img in X[:,:,:,:]])\n", - " yield X, [y, y, y]" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "0ZkGA5pA8XKu", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def inception_module(x,\n", - " filters_1x1,\n", - " filters_3x3_reduce,\n", - " filters_3x3,\n", - " filters_5x5_reduce,\n", - " filters_5x5,\n", - " filters_pool_proj,\n", - " name=None):\n", - " \n", - " conv_1x1 = Conv2D(\n", - " filters=filters_1x1, \n", - " kernel_size=(1, 1), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(x)\n", - " \n", - " conv_3x3 = Conv2D(\n", - " filters=filters_3x3_reduce, \n", - " kernel_size=(1, 1), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(x)\n", - "\n", - " conv_3x3 = Conv2D(\n", - " filters=filters_3x3, \n", - " kernel_size=(3, 3), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(conv_3x3)\n", - "\n", - " conv_5x5 = Conv2D(\n", - " filters=filters_5x5_reduce, \n", - " kernel_size=(1, 1), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(x)\n", - "\n", - " conv_5x5 = Conv2D(\n", - " filters=filters_5x5, \n", - " kernel_size=(5, 5), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(conv_5x5)\n", - "\n", - " pool_proj = MaxPool2D(\n", - " pool_size=(3, 3), \n", - " strides=(1, 1), \n", - " padding='same'\n", - " )(x)\n", - "\n", - " pool_proj = Conv2D(\n", - " filters=filters_pool_proj, \n", - " kernel_size=(1, 1), \n", - " padding='same', \n", - " activation='relu', \n", - " kernel_initializer=kernel_init, \n", - " bias_initializer=bias_init\n", - " )(pool_proj)\n", - "\n", - " output = concatenate(\n", - " inputs=[conv_1x1, conv_3x3, conv_5x5, pool_proj], \n", - " axis=3, \n", - " name=name\n", - " )\n", - " \n", - " return output" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "1y73xcMu8XNa", - "colab_type": "code", - "colab": {} - }, - "source": [ - "kernel_init = glorot_uniform()\n", - "bias_init = Constant(value=0.2)" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "7ZYsSUO88XPu", - "colab_type": "code", - "outputId": "a9035306-623d-419d-cf0e-819e72846bdc", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 332 - } - }, - "source": [ - "input_layer = Input(shape=(224, 224, 3))\n", - "\n", - "x = Conv2D(64, (7, 7), padding='same', strides=(2, 2), activation='relu', name='conv_1_7x7/2', kernel_initializer=kernel_init, bias_initializer=bias_init)(input_layer)\n", - "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_1_3x3/2')(x)\n", - "x = Conv2D(64, (1, 1), padding='same', strides=(1, 1), activation='relu', name='conv_2a_3x3/1')(x)\n", - "x = Conv2D(192, (3, 3), padding='same', strides=(1, 1), activation='relu', name='conv_2b_3x3/1')(x)\n", - "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_2_3x3/2')(x)\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=64,\n", - " filters_3x3_reduce=96,\n", - " filters_3x3=128,\n", - " filters_5x5_reduce=16,\n", - " filters_5x5=32,\n", - " filters_pool_proj=32,\n", - " name='inception_3a')\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=128,\n", - " filters_3x3_reduce=128,\n", - " filters_3x3=192,\n", - " filters_5x5_reduce=32,\n", - " filters_5x5=96,\n", - " filters_pool_proj=64,\n", - " name='inception_3b')\n", - "\n", - "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_3_3x3/2')(x)\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=192,\n", - " filters_3x3_reduce=96,\n", - " filters_3x3=208,\n", - " filters_5x5_reduce=16,\n", - " filters_5x5=48,\n", - " filters_pool_proj=64,\n", - " name='inception_4a')\n", - "\n", - "\n", - "x1 = AveragePooling2D((5, 5), strides=3)(x)\n", - "x1 = Conv2D(128, (1, 1), padding='same', activation='relu')(x1)\n", - "x1 = Flatten()(x1)\n", - "x1 = Dense(1024, activation='relu')(x1)\n", - "x1 = Dropout(0.7)(x1)\n", - "x1 = Dense(10, activation='softmax', name='auxilliary_output_1')(x1)\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=160,\n", - " filters_3x3_reduce=112,\n", - " filters_3x3=224,\n", - " filters_5x5_reduce=24,\n", - " filters_5x5=64,\n", - " filters_pool_proj=64,\n", - " name='inception_4b')\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=128,\n", - " filters_3x3_reduce=128,\n", - " filters_3x3=256,\n", - " filters_5x5_reduce=24,\n", - " filters_5x5=64,\n", - " filters_pool_proj=64,\n", - " name='inception_4c')\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=112,\n", - " filters_3x3_reduce=144,\n", - " filters_3x3=288,\n", - " filters_5x5_reduce=32,\n", - " filters_5x5=64,\n", - " filters_pool_proj=64,\n", - " name='inception_4d')\n", - "\n", - "\n", - "x2 = AveragePooling2D((5, 5), strides=3)(x)\n", - "x2 = Conv2D(128, (1, 1), padding='same', activation='relu')(x2)\n", - "x2 = Flatten()(x2)\n", - "x2 = Dense(1024, activation='relu')(x2)\n", - "x2 = Dropout(0.7)(x2)\n", - "x2 = Dense(10, activation='softmax', name='auxilliary_output_2')(x2)\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=256,\n", - " filters_3x3_reduce=160,\n", - " filters_3x3=320,\n", - " filters_5x5_reduce=32,\n", - " filters_5x5=128,\n", - " filters_pool_proj=128,\n", - " name='inception_4e')\n", - "\n", - "x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_4_3x3/2')(x)\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=256,\n", - " filters_3x3_reduce=160,\n", - " filters_3x3=320,\n", - " filters_5x5_reduce=32,\n", - " filters_5x5=128,\n", - " filters_pool_proj=128,\n", - " name='inception_5a')\n", - "\n", - "x = inception_module(x,\n", - " filters_1x1=384,\n", - " filters_3x3_reduce=192,\n", - " filters_3x3=384,\n", - " filters_5x5_reduce=48,\n", - " filters_5x5=128,\n", - " filters_pool_proj=128,\n", - " name='inception_5b')\n", - "\n", - "x = GlobalAveragePooling2D(name='avg_pool_5_3x3/1')(x)\n", - "\n", - "x = Dropout(0.4)(x)\n", - "\n", - "x = Dense(10, activation='softmax', name='output')(x)" - ], - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4271: The name tf.nn.avg_pool is deprecated. Please use tf.nn.avg_pool2d instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:148: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3733: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", - "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n", - "WARNING:tensorflow:Large dropout rate: 0.7 (>0.5). In TensorFlow 2.x, dropout() uses dropout rate instead of keep_prob. Please ensure that this is intended.\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "K5gv4hDA8XSA", - "colab_type": "code", - "colab": {} - }, - "source": [ - "model = Model(input_layer, [x, x1, x2], name='inception_v1')" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "oDaDZJCE8XUO", - "colab_type": "code", - "colab": {} - }, - "source": [ - "model.summary()" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "UUAV2emp8XWL", - "colab_type": "code", - "outputId": "ccd0abe1-7985-4edf-ba9d-56f47c1d7eed", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 106 - } - }, - "source": [ - "epochs = 25\n", - "initial_lrate = 0.01\n", - "\n", - "def decay(epoch, steps=100):\n", - " initial_lrate = 0.01\n", - " drop = 0.96\n", - " epochs_drop = 8\n", - " lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))\n", - " return lrate\n", - "\n", - "sgd = SGD(lr=initial_lrate, momentum=0.9, nesterov=False)\n", - "\n", - "lr_sc = LearningRateScheduler(decay, verbose=1)\n", - "\n", - "model.compile(loss=['categorical_crossentropy', 'categorical_crossentropy', 'categorical_crossentropy'], loss_weights=[1, 0.3, 0.3], optimizer=sgd, metrics=['accuracy'])" - ], - "execution_count": 7, - "outputs": [ - { - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3576: The name tf.log is deprecated. Please use tf.math.log instead.\n", - "\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "FpVMejKG7TDI", - "colab_type": "code", - "outputId": "9745f1b1-ab2a-4366-ad74-2ea2195d63b2", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 610 - } - }, - "source": [ - "model.fit_generator(CustomImageDataGenerator(X_train, y_train,\n", - " batch_size=256),\n", - " epochs=epochs,\n", - " steps_per_epoch=200,\n", - " use_multiprocessing=True,\n", - " workers=4,\n", - " callbacks=[lr_sc] \n", - " )" - ], - "execution_count": 0, - "outputs": [ - { - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:1020: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3005: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", - "\n", - "Epoch 1/25\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:190: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n", - "\n" - ], - "name": "stdout" - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/keras/engine/training_generator.py:49: UserWarning: Using a generator with `use_multiprocessing=True` and multiple workers may duplicate your data. Please consider using the `keras.utils.Sequence class.\n", - " UserWarning('Using a generator with `use_multiprocessing=True`'\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:197: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:207: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:216: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n", - "\n", - "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:223: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n", - "\n", - "\n", - "Epoch 00001: LearningRateScheduler setting learning rate to 0.01.\n", - "200/200 [==============================] - 218s 1s/step - loss: 3.7005 - output_loss: 2.3221 - auxilliary_output_1_loss: 2.2912 - auxilliary_output_2_loss: 2.3033 - output_acc: 0.1143 - auxilliary_output_1_acc: 0.1238 - auxilliary_output_2_acc: 0.1117\n", - "Epoch 2/25\n", - "\n", - "Epoch 00002: LearningRateScheduler setting learning rate to 0.01.\n", - "200/200 [==============================] - 195s 974ms/step - loss: 3.2905 - output_loss: 2.0650 - auxilliary_output_1_loss: 2.0379 - auxilliary_output_2_loss: 2.0472 - output_acc: 0.2155 - auxilliary_output_1_acc: 0.2431 - auxilliary_output_2_acc: 0.2337\n", - "Epoch 3/25\n", - "\n", - "Epoch 00003: LearningRateScheduler setting learning rate to 0.01.\n", - " 48/200 [======>.......................] - ETA: 2:28 - loss: 3.1024 - output_loss: 1.9481 - auxilliary_output_1_loss: 1.9233 - auxilliary_output_2_loss: 1.9243 - output_acc: 0.2620 - auxilliary_output_1_acc: 0.2888 - auxilliary_output_2_acc: 0.2900" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "sVw564lF7TDx", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "7yzEoiwy7TD1", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "sWzukhcc7TD5", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "sfBeNW5x7TD-", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "4kkvXVHj7TEE", - "colab_type": "code", - "colab": {} - }, - "source": [ - "" - ], - "execution_count": 0, - "outputs": [] - } - ] -} \ No newline at end of file From d7ef1fd4796827cd5c4212613a1115da92cf6140 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Mon, 27 Apr 2020 20:28:31 +0530 Subject: [PATCH 07/17] Created using Colaboratory --- .../Object_Detection_ImageAI_Retinanet.ipynb | 260 ++++++++++++++++++ 1 file changed, 260 insertions(+) create mode 100644 Object_Detection_From_Scratch/improvements/Object_Detection_ImageAI_Retinanet.ipynb diff --git a/Object_Detection_From_Scratch/improvements/Object_Detection_ImageAI_Retinanet.ipynb b/Object_Detection_From_Scratch/improvements/Object_Detection_ImageAI_Retinanet.ipynb new file mode 100644 index 0000000..b592353 --- /dev/null +++ b/Object_Detection_From_Scratch/improvements/Object_Detection_ImageAI_Retinanet.ipynb @@ -0,0 +1,260 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "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.7.3" + }, + "colab": { + "name": "Object_Detection_ImageAI_Retinanet.ipynb", + "provenance": [], + "include_colab_link": true + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wizi4SPlG77Z", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "outputId": "e922c653-cee0-4eb0-af7c-7b0d9cb70b56" + }, + "source": [ + "!pip install https://github.com/OlafenwaMoses/ImageAI/releases/download/2.0.1/imageai-2.0.1-py3-none-any.whl" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting imageai==2.0.1\n", + "\u001b[?25l Downloading https://github.com/OlafenwaMoses/ImageAI/releases/download/2.0.1/imageai-2.0.1-py3-none-any.whl (137kB)\n", + "\u001b[K |████████████████████████████████| 143kB 819kB/s \n", + "\u001b[?25hInstalling collected packages: imageai\n", + "Successfully installed imageai-2.0.1\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "UyNfH59fHK27", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 506 + }, + "outputId": "3b98d9f9-03de-4d27-867a-e299827f1cbf" + }, + "source": [ + "!wget https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/resnet50_coco_best_v2.0.1.h5\n", + "!wget https://cdn.analyticsvidhya.com/wp-content/uploads/2018/06/I1_2009_09_08_drive_0012_001351-768x223.png\n", + "\n", + "!mv I1_2009_09_08_drive_0012_001351-768x223.png image.png" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "--2020-04-27 14:56:51-- https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/resnet50_coco_best_v2.0.1.h5\n", + "Resolving github.com (github.com)... 140.82.112.3\n", + "Connecting to github.com (github.com)|140.82.112.3|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://github-production-release-asset-2e65be.s3.amazonaws.com/125932201/e7ab678c-6146-11e8-85cc-26bc1cd06ab0?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20200427%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20200427T145651Z&X-Amz-Expires=300&X-Amz-Signature=944991495826ac4faa0676f53dedf6b9b34027551909a1c2cfdd159b09d5583f&X-Amz-SignedHeaders=host&actor_id=0&repo_id=125932201&response-content-disposition=attachment%3B%20filename%3Dresnet50_coco_best_v2.0.1.h5&response-content-type=application%2Foctet-stream [following]\n", + "--2020-04-27 14:56:51-- https://github-production-release-asset-2e65be.s3.amazonaws.com/125932201/e7ab678c-6146-11e8-85cc-26bc1cd06ab0?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20200427%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20200427T145651Z&X-Amz-Expires=300&X-Amz-Signature=944991495826ac4faa0676f53dedf6b9b34027551909a1c2cfdd159b09d5583f&X-Amz-SignedHeaders=host&actor_id=0&repo_id=125932201&response-content-disposition=attachment%3B%20filename%3Dresnet50_coco_best_v2.0.1.h5&response-content-type=application%2Foctet-stream\n", + "Resolving github-production-release-asset-2e65be.s3.amazonaws.com (github-production-release-asset-2e65be.s3.amazonaws.com)... 52.216.179.163\n", + "Connecting to github-production-release-asset-2e65be.s3.amazonaws.com (github-production-release-asset-2e65be.s3.amazonaws.com)|52.216.179.163|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 152661008 (146M) [application/octet-stream]\n", + "Saving to: ‘resnet50_coco_best_v2.0.1.h5’\n", + "\n", + "resnet50_coco_best_ 100%[===================>] 145.59M 44.5MB/s in 3.5s \n", + "\n", + "2020-04-27 14:56:55 (42.1 MB/s) - ‘resnet50_coco_best_v2.0.1.h5’ saved [152661008/152661008]\n", + "\n", + "--2020-04-27 14:56:57-- https://cdn.analyticsvidhya.com/wp-content/uploads/2018/06/I1_2009_09_08_drive_0012_001351-768x223.png\n", + "Resolving cdn.analyticsvidhya.com (cdn.analyticsvidhya.com)... 104.26.15.185, 104.26.14.185, 2606:4700:20::681a:fb9, ...\n", + "Connecting to cdn.analyticsvidhya.com (cdn.analyticsvidhya.com)|104.26.15.185|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 186458 (182K) [image/png]\n", + "Saving to: ‘I1_2009_09_08_drive_0012_001351-768x223.png’\n", + "\n", + "I1_2009_09_08_drive 100%[===================>] 182.09K --.-KB/s in 0.02s \n", + "\n", + "2020-04-27 14:56:59 (11.0 MB/s) - ‘I1_2009_09_08_drive_0012_001351-768x223.png’ saved [186458/186458]\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Q-cKlNMEHVIt", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "838ab874-62a3-43b6-958f-c15cdb791ce0" + }, + "source": [ + "%tensorflow_version 1.x\n", + "from imageai.Detection import ObjectDetection\n", + "import os" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "_CV0F896GjFV", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 402 + }, + "outputId": "b140958c-717e-4cde-df78-b09f0e02c821" + }, + "source": [ + "execution_path = os.getcwd()\n", + "\n", + "detector = ObjectDetection()\n", + "detector.setModelTypeAsRetinaNet()\n", + "detector.setModelPath( os.path.join(execution_path , \"resnet50_coco_best_v2.0.1.h5\"))\n", + "detector.loadModel()\n", + "custom_objects = detector.CustomObjects(person=True, car=False)\n", + "detections = detector.detectCustomObjectsFromImage(input_image=os.path.join(execution_path , \"image.png\"), output_image_path=os.path.join(execution_path , \"updated_image.png\"), custom_objects=custom_objects, minimum_percentage_probability=65)\n", + "\n", + "\n", + "for eachObject in detections:\n", + " print(eachObject[\"name\"] + \" : \" + eachObject[\"percentage_probability\"] )\n", + " print(\"--------------------------------\")" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "If using Keras pass *_constraint arguments to layers.\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4070: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", + "\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/imageai/Detection/keras_retinanet/backend/tensorflow_backend.py:22: The name tf.image.resize_images is deprecated. Please use tf.image.resize instead.\n", + "\n", + "tracking anchors\n", + "tracking anchors\n", + "tracking anchors\n", + "tracking anchors\n", + "tracking anchors\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/imageai/Detection/keras_retinanet/backend/tensorflow_backend.py:46: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", + "\n", + "person : 75.89704990386963\n", + "--------------------------------\n", + "person : 67.26259589195251\n", + "--------------------------------\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "B_TxxOthGjFf", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 240 + }, + "outputId": "9dc83a8d-946f-4534-f347-2ba198ba639e" + }, + "source": [ + "from IPython.display import Image\n", + "Image(\"updated_image.png\")" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lao-RXN0G5ZU", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file From 4ec1f2fa9c98be902c1c48bd0966ddeb0cc388bd Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Mon, 27 Apr 2020 21:00:14 +0530 Subject: [PATCH 08/17] Update README.md --- Object_Detection_From_Scratch/README.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/Object_Detection_From_Scratch/README.md b/Object_Detection_From_Scratch/README.md index ec3174f..07a9477 100644 --- a/Object_Detection_From_Scratch/README.md +++ b/Object_Detection_From_Scratch/README.md @@ -8,3 +8,13 @@ Structure: - original_code/ - Object_Detection_ImageAI_Retinanet.ipynb +- improvements/ + - Object_Detection_ImageAI_Retinanet.ipynb + + +**Notes** - + +Improvements are as follows + +1. Get the code up and running on Google Colab +2. Programmatically download the required pretrained model and test image From 22f0e6be2c56af4d7ad52ab18cd01abcd1dc7712 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Sun, 3 May 2020 17:22:53 +0530 Subject: [PATCH 09/17] add article case study ICLR2020 --- Case_study_preferred_tools_ICLR2020/README.md | 10 + .../Case_study_preferred_tools_ICLR2020.ipynb | 500 ++++++++++++++++++ 2 files changed, 510 insertions(+) create mode 100644 Case_study_preferred_tools_ICLR2020/README.md create mode 100644 Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb diff --git a/Case_study_preferred_tools_ICLR2020/README.md b/Case_study_preferred_tools_ICLR2020/README.md new file mode 100644 index 0000000..1c6c8c7 --- /dev/null +++ b/Case_study_preferred_tools_ICLR2020/README.md @@ -0,0 +1,10 @@ +Case Study on preferred tools by Research Community in ICLR 2020 +=============================================================================== + +This repository contains code for the article "Key Insights from ICLR 2020 with a Case Study on preferred tool by Research Community - PyTorch or TensorFlow?" published on Analytics Vidhya + +Structure: +--------- + +- original_code/ + - Case_study_preferred_tools_ICLR2020.ipynb diff --git a/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb b/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb new file mode 100644 index 0000000..f69a4cc --- /dev/null +++ b/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb @@ -0,0 +1,500 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install openreview-py\n", + "!pip install pipreqs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import re\n", + "import sys\n", + "import requests\n", + "import openreview\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from random import choice\n", + "from wordcloud import WordCloud\n", + "from urllib.parse import urlparse" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client = openreview.Client(baseurl=\"https://openreview.net\")\n", + "\n", + "blind_notes = {\n", + " note.id: note\n", + " for note in openreview.tools.iterget_notes(\n", + " client,\n", + " invitation=\"ICLR.cc/2020/Conference/-/Blind_Submission\",\n", + " details=\"original\",\n", + " )\n", + "}\n", + "\n", + "all_decision_notes = openreview.tools.iterget_notes(\n", + " client, invitation=\"ICLR.cc/2020/Conference/Paper.*/-/Decision\"\n", + ")\n", + "\n", + "accepted_submissions = [\n", + " blind_notes[decision_note.forum]\n", + " for decision_note in all_decision_notes\n", + " if \"Accept\" in decision_note.content[\"decision\"]\n", + "]\n", + "\n", + "len(accepted_submissions)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_present = 0\n", + "code_links = []\n", + "for note in accepted_submissions:\n", + " try:\n", + " code_links.append(note.content[\"code\"])\n", + " # print(\"code found\")\n", + " code_present += 1\n", + " except:\n", + " print(\"Unexpected error:\", sys.exc_info()[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_present" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "urlparse(choice(code_links))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_links_df = pd.DataFrame({\"links\": code_links})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_links_df[\"domains\"] = code_links_df.links.apply(lambda x: urlparse(x)[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_links_df.domains.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "temp_link = \"\"\n", + "\n", + "\n", + "def clean_github_link(link):\n", + " link = link.strip()\n", + " if not link[-4:] == \".git\":\n", + " return link + \".git\"\n", + " else:\n", + " return link\n", + "\n", + "\n", + "github_repo_links = (\n", + " code_links_df.loc[code_links_df.domains == \"github.com\"]\n", + " .links.apply(clean_github_link)\n", + " .values\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# takes about 24 minutes to download\n", + "for link in github_repo_links:\n", + " !git clone $link --depth 1 --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "code_links_df.loc[code_links_df.domains == \"github.com\"].links.apply(\n", + " lambda x: urlparse(x)[2].split(\"/\")[1]\n", + ").value_counts().head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = \".\"\n", + "dirlist = [item for item in os.listdir(root) if os.path.isdir(os.path.join(root, item))]\n", + "print(dirlist)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dirlist.remove('.config')\n", + "dirlist.remove('sample_data')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(dirlist)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# takes about 10 minutes to run\n", + "for repo in dirlist:\n", + " path = \"/content/\" + repo\n", + " if os.path.exists(path + \"/requirements.txt\"):\n", + " pass\n", + " else:\n", + " !pipreqs $path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "has_req_cnt = no_req_cnt = 0\n", + "for repo in dirlist:\n", + " path = \"/content/\" + repo\n", + " if os.path.exists(path + \"/requirements.txt\"):\n", + " has_req_cnt += 1\n", + " else:\n", + " no_req_cnt += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "has_req_cnt, no_req_cnt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"/content/\" + dirlist[4] + \"/\" + \"requirements.txt\", \"r\") as f:\n", + " tools = f.readlines()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_repo_names = []\n", + "all_tool_names = []\n", + "for repo in dirlist:\n", + " try:\n", + " repo_name = repo\n", + " with open(\"/content/\" + repo + \"/\" + \"requirements.txt\", \"r\") as f:\n", + " tools = f.readlines()\n", + " tool_names = \",\".join(tools).lower()\n", + "\n", + " all_repo_names.append(repo_name)\n", + " all_tool_names.append(tool_names)\n", + " except:\n", + " print(\"Unexpected error for \", repo, sys.exc_info()[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools = pd.DataFrame(\n", + " {\"all_repo_names\": all_repo_names, \"all_tool_names\": all_tool_names}\n", + ")\n", + "all_tools.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.to_csv(\"all_tools.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools = pd.read_csv(\"all_tools.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def cleaner(tool_list):\n", + " cleaned_list = \"\"\n", + " try:\n", + " cleaned_list = []\n", + " for tool in tool_list:\n", + " cleaned_tool = re.findall(\"^\\w+\", tool)\n", + " if not cleaned_tool:\n", + " pass\n", + " else:\n", + " cleaned_list.append(cleaned_tool[0])\n", + " cleaned_list = \",\".join(cleaned_list)\n", + " return cleaned_list\n", + " except:\n", + " tool_list = \",\".join(tool_list)\n", + " \"unclean_list\".join(tool_list)\n", + " return tool_list\n", + "\n", + "\n", + "all_tools[\"all_tool_names_cleaned\"] = all_tools.all_tool_names.str.split(\",\").apply(\n", + " cleaner\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.all_tool_names_cleaned.str.contains(\"torch\").sum()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def give_score(tool_name, offset=0):\n", + " num = all_tools.all_tool_names_cleaned.str.contains(tool_name).sum()\n", + " num += offset\n", + " print(\n", + " \"Count of {} is {} and total usage is {}%\".format(\n", + " tool_name, num, round((num / all_tools.shape[0]) * 100, 4)\n", + " )\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "give_score(\"torch\")\n", + "print()\n", + "give_score(\"tensorflow\", offset=12)\n", + "print()\n", + "give_score(\"keras\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "give_score(\"transformers\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "give_score(\"tensorboard\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "give_score(\"gym\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "give_score(\"networkx\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().unique().shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[:50]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[\n", + " :10\n", + "].plot(kind=\"bar\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tool_string = \",\".join(all_tools.all_tool_names_cleaned)\n", + "\n", + "wordcloud = WordCloud(background_color=\"white\", max_words=100)\n", + "wordcloud.generate(all_tool_string)\n", + "\n", + "plt.figure(figsize=(10, 20))\n", + "plt.imshow(wordcloud)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From c34f1e0a5818f6754e1d5d4358208640d3fd0467 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Sun, 3 May 2020 18:22:29 +0530 Subject: [PATCH 10/17] check code on colab --- .../Case_study_preferred_tools_ICLR2020.ipynb | 1843 ++++++++++++----- 1 file changed, 1345 insertions(+), 498 deletions(-) diff --git a/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb b/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb index f69a4cc..73e211c 100644 --- a/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb +++ b/Case_study_preferred_tools_ICLR2020/original_code/Case_study_preferred_tools_ICLR2020.ipynb @@ -1,500 +1,1347 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install openreview-py\n", - "!pip install pipreqs" - ] + "nbformat": 4, + "nbformat_minor": 0, + "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.7.3" + }, + "colab": { + "name": "Case_study_preferred_tools_ICLR2020.ipynb", + "provenance": [], + "include_colab_link": true + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import re\n", - "import sys\n", - "import requests\n", - "import openreview\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from random import choice\n", - "from wordcloud import WordCloud\n", - "from urllib.parse import urlparse" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "client = openreview.Client(baseurl=\"https://openreview.net\")\n", - "\n", - "blind_notes = {\n", - " note.id: note\n", - " for note in openreview.tools.iterget_notes(\n", - " client,\n", - " invitation=\"ICLR.cc/2020/Conference/-/Blind_Submission\",\n", - " details=\"original\",\n", - " )\n", - "}\n", - "\n", - "all_decision_notes = openreview.tools.iterget_notes(\n", - " client, invitation=\"ICLR.cc/2020/Conference/Paper.*/-/Decision\"\n", - ")\n", - "\n", - "accepted_submissions = [\n", - " blind_notes[decision_note.forum]\n", - " for decision_note in all_decision_notes\n", - " if \"Accept\" in decision_note.content[\"decision\"]\n", - "]\n", - "\n", - "len(accepted_submissions)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_present = 0\n", - "code_links = []\n", - "for note in accepted_submissions:\n", - " try:\n", - " code_links.append(note.content[\"code\"])\n", - " # print(\"code found\")\n", - " code_present += 1\n", - " except:\n", - " print(\"Unexpected error:\", sys.exc_info()[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_present" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "urlparse(choice(code_links))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_links_df = pd.DataFrame({\"links\": code_links})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_links_df[\"domains\"] = code_links_df.links.apply(lambda x: urlparse(x)[1])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_links_df.domains.value_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "temp_link = \"\"\n", - "\n", - "\n", - "def clean_github_link(link):\n", - " link = link.strip()\n", - " if not link[-4:] == \".git\":\n", - " return link + \".git\"\n", - " else:\n", - " return link\n", - "\n", - "\n", - "github_repo_links = (\n", - " code_links_df.loc[code_links_df.domains == \"github.com\"]\n", - " .links.apply(clean_github_link)\n", - " .values\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# takes about 24 minutes to download\n", - "for link in github_repo_links:\n", - " !git clone $link --depth 1 --quiet" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "code_links_df.loc[code_links_df.domains == \"github.com\"].links.apply(\n", - " lambda x: urlparse(x)[2].split(\"/\")[1]\n", - ").value_counts().head(10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "root = \".\"\n", - "dirlist = [item for item in os.listdir(root) if os.path.isdir(os.path.join(root, item))]\n", - "print(dirlist)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dirlist.remove('.config')\n", - "dirlist.remove('sample_data')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "len(dirlist)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# takes about 10 minutes to run\n", - "for repo in dirlist:\n", - " path = \"/content/\" + repo\n", - " if os.path.exists(path + \"/requirements.txt\"):\n", - " pass\n", - " else:\n", - " !pipreqs $path" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "has_req_cnt = no_req_cnt = 0\n", - "for repo in dirlist:\n", - " path = \"/content/\" + repo\n", - " if os.path.exists(path + \"/requirements.txt\"):\n", - " has_req_cnt += 1\n", - " else:\n", - " no_req_cnt += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "has_req_cnt, no_req_cnt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"/content/\" + dirlist[4] + \"/\" + \"requirements.txt\", \"r\") as f:\n", - " tools = f.readlines()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_repo_names = []\n", - "all_tool_names = []\n", - "for repo in dirlist:\n", - " try:\n", - " repo_name = repo\n", - " with open(\"/content/\" + repo + \"/\" + \"requirements.txt\", \"r\") as f:\n", - " tools = f.readlines()\n", - " tool_names = \",\".join(tools).lower()\n", - "\n", - " all_repo_names.append(repo_name)\n", - " all_tool_names.append(tool_names)\n", - " except:\n", - " print(\"Unexpected error for \", repo, sys.exc_info()[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools = pd.DataFrame(\n", - " {\"all_repo_names\": all_repo_names, \"all_tool_names\": all_tool_names}\n", - ")\n", - "all_tools.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.to_csv(\"all_tools.csv\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools = pd.read_csv(\"all_tools.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def cleaner(tool_list):\n", - " cleaned_list = \"\"\n", - " try:\n", - " cleaned_list = []\n", - " for tool in tool_list:\n", - " cleaned_tool = re.findall(\"^\\w+\", tool)\n", - " if not cleaned_tool:\n", - " pass\n", - " else:\n", - " cleaned_list.append(cleaned_tool[0])\n", - " cleaned_list = \",\".join(cleaned_list)\n", - " return cleaned_list\n", - " except:\n", - " tool_list = \",\".join(tool_list)\n", - " \"unclean_list\".join(tool_list)\n", - " return tool_list\n", - "\n", - "\n", - "all_tools[\"all_tool_names_cleaned\"] = all_tools.all_tool_names.str.split(\",\").apply(\n", - " cleaner\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.all_tool_names_cleaned.str.contains(\"torch\").sum()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def give_score(tool_name, offset=0):\n", - " num = all_tools.all_tool_names_cleaned.str.contains(tool_name).sum()\n", - " num += offset\n", - " print(\n", - " \"Count of {} is {} and total usage is {}%\".format(\n", - " tool_name, num, round((num / all_tools.shape[0]) * 100, 4)\n", - " )\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "give_score(\"torch\")\n", - "print()\n", - "give_score(\"tensorflow\", offset=12)\n", - "print()\n", - "give_score(\"keras\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "give_score(\"transformers\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "give_score(\"tensorboard\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "give_score(\"gym\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "give_score(\"networkx\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().unique().shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[:50]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[\n", - " :10\n", - "].plot(kind=\"bar\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "all_tool_string = \",\".join(all_tools.all_tool_names_cleaned)\n", - "\n", - "wordcloud = WordCloud(background_color=\"white\", max_words=100)\n", - "wordcloud.generate(all_tool_string)\n", - "\n", - "plt.figure(figsize=(10, 20))\n", - "plt.imshow(wordcloud)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - } - ], - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hK-SsrOGZjBd", + "colab_type": "code", + "colab": {} + }, + "source": [ + "!pip install openreview-py\n", + "!pip install pipreqs" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "QRo-6UJ2ZjBm", + "colab_type": "code", + "colab": {} + }, + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import re\n", + "import sys\n", + "import requests\n", + "import openreview\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from random import choice\n", + "from wordcloud import WordCloud\n", + "from urllib.parse import urlparse" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "N7DCgCBEZjBw", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "0b119d2c-1196-4bfb-d4fc-3458e425ac2f" + }, + "source": [ + "client = openreview.Client(baseurl=\"https://openreview.net\")\n", + "\n", + "blind_notes = {\n", + " note.id: note\n", + " for note in openreview.tools.iterget_notes(\n", + " client,\n", + " invitation=\"ICLR.cc/2020/Conference/-/Blind_Submission\",\n", + " details=\"original\",\n", + " )\n", + "}\n", + "\n", + "all_decision_notes = openreview.tools.iterget_notes(\n", + " client, invitation=\"ICLR.cc/2020/Conference/Paper.*/-/Decision\"\n", + ")\n", + "\n", + "accepted_submissions = [\n", + " blind_notes[decision_note.forum]\n", + " for decision_note in all_decision_notes\n", + " if \"Accept\" in decision_note.content[\"decision\"]\n", + "]\n", + "\n", + "len(accepted_submissions)" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "687" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 2 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4VZY4_AXZjB3", + "colab_type": "code", + "colab": {} + }, + "source": [ + "code_present = 0\n", + "code_links = []\n", + "for note in accepted_submissions:\n", + " try:\n", + " code_links.append(note.content[\"code\"])\n", + " # print(\"code found\")\n", + " code_present += 1\n", + " except:\n", + " print(\"Unexpected error:\", sys.exc_info()[0])" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "UZhxqcAPZjB8", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "b079815c-b786-42b7-e0b8-71f0252623cc" + }, + "source": [ + "code_present" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "344" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "l3pZyZctZjCC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 54 + }, + "outputId": "911be15a-2ec1-4bdd-f4ae-69aa79bb4fd9" + }, + "source": [ + "urlparse(choice(code_links))" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ParseResult(scheme='https', netloc='drive.google.com', path='/drive/folders/1kIOc4SlAJllUJsrr2OnZ4izIQIw2JexU', params='', query='usp=sharing', fragment='')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wym6x80tZjCJ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "code_links_df = pd.DataFrame({\"links\": code_links})" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "12Is5bPeZjCN", + "colab_type": "code", + "colab": {} + }, + "source": [ + "code_links_df[\"domains\"] = code_links_df.links.apply(lambda x: urlparse(x)[1])" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "54IYMqW_ZjCR", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 503 + }, + "outputId": "af66e02d-1009-4e54-fcf1-6c8da0dbb767" + }, + "source": [ + "code_links_df.domains.value_counts()" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "github.com 268\n", + "drive.google.com 28\n", + "www.dropbox.com 9\n", + "anonymous.4open.science 8\n", + "bit.ly 5\n", + "storage.googleapis.com 3\n", + "s000.tinyupload.com 2\n", + "sites.google.com 2\n", + "docs.google.com 1\n", + "nikaashpuri.github.io 1\n", + "nitishgupta.github.io 1\n", + "clevrer.csail.mit.edu 1\n", + "wgrathwohl.github.io 1\n", + "dap.csail.mit.edu 1\n", + "www.robots.ox.ac.uk 1\n", + "www.daml.in.tum.de 1\n", + "automated-discovery.github.io 1\n", + "rohitgirdhar.github.io 1\n", + "danijar.com 1\n", + "www.github.com 1\n", + "anonfile.com 1\n", + "goo.gl 1\n", + "toiaydcdyywlhzvlob.github.io 1\n", + "whyu.me 1\n", + "www.sendspace.com 1\n", + "mega.nz 1\n", + "www.cs.cmu.edu 1\n", + "Name: domains, dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "fnF84fCIZjCW", + "colab_type": "code", + "colab": {} + }, + "source": [ + "temp_link = \"\"\n", + "\n", + "\n", + "def clean_github_link(link):\n", + " link = link.strip()\n", + " if not link[-4:] == \".git\":\n", + " return link + \".git\"\n", + " else:\n", + " return link\n", + "\n", + "\n", + "github_repo_links = (\n", + " code_links_df.loc[code_links_df.domains == \"github.com\"]\n", + " .links.apply(clean_github_link)\n", + " .values\n", + ")" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "KokWVr08ZjCc", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 764 + }, + "outputId": "46858585-9ff6-4bd7-c7eb-a3e5ff61e7f0" + }, + "source": [ + "# takes about 24 minutes to download\n", + "for link in github_repo_links:\n", + " !git clone $link --depth 1 --quiet" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "text": [ + "fatal: repository 'https://github.com/tensorflow/addons/blob/master/tensorflow_addons/optimizers/lamb.py.git/' not found\n", + "fatal: repository 'https://github.com/carloderamo/shared/tree/master.git/' not found\n", + "Cloning into 'proxsgd'...\n", + "remote: Enumerating objects: 59, done.\u001b[K\n", + "remote: Counting objects: 100% (59/59), done.\u001b[K\n", + "remote: Compressing objects: 100% (45/45), done.\u001b[K\n", + "remote: Total 59 (delta 19), reused 33 (delta 12), pack-reused 0\u001b[K\n", + "Unpacking objects: 100% (59/59), done.\n", + "/bin/bash: https://github.com/cc-hpc-itwm/proxsgd.git: No such file or directory\n", + "fatal: repository 'https://github.com/suraj-nair-1/google-research/tree/master/hierarchical_foresight.git/' not found\n", + "fatal: repository 'https://github.com/google-research/google-research/tree/master/cfq.git/' not found\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/hangg7/deformable-kernels/.git/' not found\n", + "fatal: repository 'https://github.com/google-research/google-research/tree/master/meta_learning_without_memorization.git/' not found\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/GRAM-nets.git/' not found\n", + "fatal: could not read Username for 'https://github.com': No such device or address\n", + "remote: Not Found\n", + "fatal: repository 'http://github.com/AvigdorZ.git/' not found\n", + "fatal: repository 'https://github.com/google-research/language/tree/master/language/bert_extraction.git/' not found\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/anonymous-sushi-armadillo.git/' not found\n", + "fatal: repository 'https://github.com/NeurEXT/NEXT-learning-to-plan/blob/master/main.ipynb.git/' not found\n", + "fatal: repository 'https://github.com/tensorflow/federated/tree/master/tensorflow_federated/python/research/gans.git/' not found\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/snap-stanford/pretrain-gnns/.git/' not found\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/PKU-AI-Edge/DGN/.git/' not found\n", + "fatal: repository 'https://github.com/google-research/google-research/tree/master/weak_disentangle.git/' not found\n", + "fatal: repository 'https://github.com/google/trax/tree/master/trax/models/reformer.git/' not found\n", + "Cloning into 'neural-tangent-kernel-UCI'...\n", + "remote: Enumerating objects: 38, done.\u001b[K\n", + "remote: Counting objects: 100% (38/38), done.\u001b[K\n", + "remote: Compressing objects: 100% (30/30), done.\u001b[K\n", + "remote: Total 38 (delta 16), reused 19 (delta 6), pack-reused 0\u001b[K\n", + "Unpacking objects: 100% (38/38), done.\n", + "/bin/bash: https://drive.google.com/open?id=1SdgWmhEcnm4qyaM9xrkN01VF9tj40WZS.git: No such file or directory\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/nathandelara/Spectral-Embedding-of-Regularized-Block-Models/.git/' not found\n", + "fatal: could not read Username for 'https://github.com': No such device or address\n", + "remote: Not Found\n", + "fatal: repository 'https://github.com/deepsphere.git/' not found\n", + "fatal: could not read Username for 'https://github.com': No such device or address\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mkyBz3bKZjCh", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 208 + }, + "outputId": "74c479f3-e31c-453a-f341-99ab4d5d1bb6" + }, + "source": [ + "code_links_df.loc[code_links_df.domains == \"github.com\"].links.apply(\n", + " lambda x: urlparse(x)[2].split(\"/\")[1]\n", + ").value_counts().head(10)" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "google-research 10\n", + "facebookresearch 4\n", + "TAMU-VITA 3\n", + "TonghanWang 2\n", + "JHL-HUST 2\n", + "automl 2\n", + "epfml 2\n", + "eth-sri 2\n", + "haebeom-lee 2\n", + "tensorflow 2\n", + "Name: links, dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4CLEHCpLZjCm", + "colab_type": "code", + "colab": {} + }, + "source": [ + "root = \".\"\n", + "dirlist = [item for item in os.listdir(root) if os.path.isdir(os.path.join(root, item))]\n", + "print(dirlist)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "U90rMdkjZjCs", + "colab_type": "code", + "colab": {} + }, + "source": [ + "dirlist.remove('.config')\n", + "dirlist.remove('sample_data')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "_seGdc8cZjCx", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "f8592b2b-9f92-42ee-eb92-6abb34870035" + }, + "source": [ + "len(dirlist)" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "247" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QLx3abB8ZjC2", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# takes about 10 minutes to run\n", + "for repo in dirlist:\n", + " path = \"/content/\" + repo\n", + " if os.path.exists(path + \"/requirements.txt\"):\n", + " pass\n", + " else:\n", + " !pipreqs $path" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "sLrWrQI0ZjC6", + "colab_type": "code", + "colab": {} + }, + "source": [ + "has_req_cnt = no_req_cnt = 0\n", + "for repo in dirlist:\n", + " path = \"/content/\" + repo\n", + " if os.path.exists(path + \"/requirements.txt\"):\n", + " has_req_cnt += 1\n", + " else:\n", + " no_req_cnt += 1" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ODsvh3LrZjC-", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "99a85edf-ad25-4c1b-e770-c43f879c03c8" + }, + "source": [ + "has_req_cnt, no_req_cnt" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(237, 10)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "79lFy7-vZjDG", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 191 + }, + "outputId": "f610a4f9-c393-477a-bb77-3bed4114c899" + }, + "source": [ + "all_repo_names = []\n", + "all_tool_names = []\n", + "for repo in dirlist:\n", + " try:\n", + " repo_name = repo\n", + " with open(\"/content/\" + repo + \"/\" + \"requirements.txt\", \"r\") as f:\n", + " tools = f.readlines()\n", + " tool_names = \",\".join(tools).lower()\n", + "\n", + " all_repo_names.append(repo_name)\n", + " all_tool_names.append(tool_names)\n", + " except:\n", + " print(\"Unexpected error for \", repo, sys.exc_info()[0])" + ], + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Unexpected error for SI-NI-FGSM \n", + "Unexpected error for space2vec \n", + "Unexpected error for synthfeedback \n", + "Unexpected error for QCNN \n", + "Unexpected error for GraN-DAG \n", + "Unexpected error for GLISTA \n", + "Unexpected error for ACMC_ICLR \n", + "Unexpected error for PCMC-Net \n", + "Unexpected error for pcl2pcl-gan-pub \n", + "Unexpected error for NAS-Benchmark \n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GDSgeOqvZjDJ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "outputId": "01f1ceab-0ef8-4896-9f4b-5d7d59b73b3c" + }, + "source": [ + "all_tools = pd.DataFrame(\n", + " {\"all_repo_names\": all_repo_names, \"all_tool_names\": all_tool_names}\n", + ")\n", + "all_tools.head()" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "execute_result", + "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", + "
all_repo_namesall_tool_names
0KP2D\\n
1CN-DPMipdb\\n,jupyterlab\\n,matplotlib\\n,numpy\\n,pyyam...
2GLADnumpy==1.18.3\\n,pandas==1.0.3\\n,matplotlib==3....
3bert_score# pytorch\\n,torch>=1.0.0\\n,# progress bars in ...
4delay_stabilitytorchvision==0.6.0+cu101\\n,bokeh==1.4.0\\n,six=...
\n", + "
" + ], + "text/plain": [ + " all_repo_names all_tool_names\n", + "0 KP2D \\n\n", + "1 CN-DPM ipdb\\n,jupyterlab\\n,matplotlib\\n,numpy\\n,pyyam...\n", + "2 GLAD numpy==1.18.3\\n,pandas==1.0.3\\n,matplotlib==3....\n", + "3 bert_score # pytorch\\n,torch>=1.0.0\\n,# progress bars in ...\n", + "4 delay_stability torchvision==0.6.0+cu101\\n,bokeh==1.4.0\\n,six=..." + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 19 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "P1OBuccpZjDR", + "colab_type": "code", + "colab": {} + }, + "source": [ + "all_tools.to_csv(\"all_tools.csv\", index=False)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "i0Ee8N1TZjDV", + "colab_type": "code", + "colab": {} + }, + "source": [ + "all_tools = pd.read_csv(\"all_tools.csv\")" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "DGNMEVu3ZjDZ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "outputId": "e4970e86-fd07-4af8-f364-c08e7f6e9e91" + }, + "source": [ + "all_tools.head()" + ], + "execution_count": 23, + "outputs": [ + { + "output_type": "execute_result", + "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", + "
all_repo_namesall_tool_names
0KP2D\\n
1CN-DPMipdb\\n,jupyterlab\\n,matplotlib\\n,numpy\\n,pyyam...
2GLADnumpy==1.18.3\\n,pandas==1.0.3\\n,matplotlib==3....
3bert_score# pytorch\\n,torch>=1.0.0\\n,# progress bars in ...
4delay_stabilitytorchvision==0.6.0+cu101\\n,bokeh==1.4.0\\n,six=...
\n", + "
" + ], + "text/plain": [ + " all_repo_names all_tool_names\n", + "0 KP2D \\n\n", + "1 CN-DPM ipdb\\n,jupyterlab\\n,matplotlib\\n,numpy\\n,pyyam...\n", + "2 GLAD numpy==1.18.3\\n,pandas==1.0.3\\n,matplotlib==3....\n", + "3 bert_score # pytorch\\n,torch>=1.0.0\\n,# progress bars in ...\n", + "4 delay_stability torchvision==0.6.0+cu101\\n,bokeh==1.4.0\\n,six=..." + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 23 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RagMLwxNZjDd", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "637c271e-6aa0-41b8-d5bf-813b7dd77f86" + }, + "source": [ + "all_tools.shape" + ], + "execution_count": 24, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(237, 2)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 24 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nI-_BeqlZjDg", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def cleaner(tool_list):\n", + " cleaned_list = \"\"\n", + " try:\n", + " cleaned_list = []\n", + " for tool in tool_list:\n", + " cleaned_tool = re.findall(\"^\\w+\", tool)\n", + " if not cleaned_tool:\n", + " pass\n", + " else:\n", + " cleaned_list.append(cleaned_tool[0])\n", + " cleaned_list = \",\".join(cleaned_list)\n", + " return cleaned_list\n", + " except:\n", + " tool_list = \",\".join(tool_list)\n", + " \"unclean_list\".join(tool_list)\n", + " return tool_list\n", + "\n", + "\n", + "all_tools[\"all_tool_names_cleaned\"] = all_tools.all_tool_names.str.split(\",\").apply(\n", + " cleaner\n", + ")" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "3rAuLEv_ZjDk", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "outputId": "b7cefaa4-fce9-4bbd-c912-8c0997f3acb3" + }, + "source": [ + "all_tools.head()" + ], + "execution_count": 26, + "outputs": [ + { + "output_type": "execute_result", + "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", + "
all_repo_namesall_tool_namesall_tool_names_cleaned
0KP2D\\n
1CN-DPMipdb\\n,jupyterlab\\n,matplotlib\\n,numpy\\n,pyyam...ipdb,jupyterlab,matplotlib,numpy,pyyaml,tensor...
2GLADnumpy==1.18.3\\n,pandas==1.0.3\\n,matplotlib==3....numpy,pandas,matplotlib,scipy,torch,networkx,s...
3bert_score# pytorch\\n,torch>=1.0.0\\n,# progress bars in ...torch,tqdm,transformers,matplotlib,pandas,numpy
4delay_stabilitytorchvision==0.6.0+cu101\\n,bokeh==1.4.0\\n,six=...torchvision,bokeh,six,torch,numpy,scipy,pandas...
\n", + "
" + ], + "text/plain": [ + " all_repo_names ... all_tool_names_cleaned\n", + "0 KP2D ... \n", + "1 CN-DPM ... ipdb,jupyterlab,matplotlib,numpy,pyyaml,tensor...\n", + "2 GLAD ... numpy,pandas,matplotlib,scipy,torch,networkx,s...\n", + "3 bert_score ... torch,tqdm,transformers,matplotlib,pandas,numpy\n", + "4 delay_stability ... torchvision,bokeh,six,torch,numpy,scipy,pandas...\n", + "\n", + "[5 rows x 3 columns]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "P03pWqboZjDo", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "0a257769-dc35-4df2-e20f-7e5ada034eb6" + }, + "source": [ + "all_tools.all_tool_names_cleaned.str.contains(\"torch\").sum()" + ], + "execution_count": 27, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "154" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CWgrgRdyZjDs", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def give_score(tool_name, offset=0):\n", + " num = all_tools.all_tool_names_cleaned.str.contains(tool_name).sum()\n", + " num += offset\n", + " print(\n", + " \"Count of {} is {} and total usage is {}%\".format(\n", + " tool_name, num, round((num / all_tools.shape[0]) * 100, 4)\n", + " )\n", + " )" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1FedkNKSZjDu", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "outputId": "24984407-aa28-45da-8cac-49a8c78ea135" + }, + "source": [ + "give_score(\"torch\")\n", + "print()\n", + "give_score(\"tensorflow\", offset=12)\n", + "print()\n", + "give_score(\"keras\")" + ], + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Count of torch is 154 and total usage is 64.9789%\n", + "\n", + "Count of tensorflow is 95 and total usage is 40.0844%\n", + "\n", + "Count of keras is 23 and total usage is 9.7046%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "OqvzE1BcZjDx", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "1f6048fa-466a-4e9e-9961-9ee1d0d8e16d" + }, + "source": [ + "give_score(\"transformers\")" + ], + "execution_count": 30, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Count of transformers is 8 and total usage is 3.3755%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HAavc6raZjD1", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "17ca19b8-af2c-4636-f340-eda3f9664cbc" + }, + "source": [ + "give_score(\"tensorboard\")" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Count of tensorboard is 56 and total usage is 23.6287%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1ff44m1lZjD4", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "82c73d9f-a11f-4dc9-a35d-e6cdfd35482e" + }, + "source": [ + "give_score(\"gym\")" + ], + "execution_count": 32, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Count of gym is 24 and total usage is 10.1266%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "oA9wUHMwZjD6", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "0615eabc-71b9-4465-f0b6-886eb0e5fd28" + }, + "source": [ + "give_score(\"networkx\")" + ], + "execution_count": 33, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Count of networkx is 25 and total usage is 10.5485%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nwuwREqTZjD-", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "8e70a8f1-fcd5-4614-e1f4-fb11c69dbcd7" + }, + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().unique().shape" + ], + "execution_count": 34, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(687,)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GTxaa5PrZjEB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 903 + }, + "outputId": "a9bdf247-bc29-4972-a6d7-a1080338341d" + }, + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[:50]" + ], + "execution_count": 35, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "numpy 206\n", + "torch 156\n", + "matplotlib 114\n", + "scipy 110\n", + "tensorflow 92\n", + "tqdm 89\n", + "torchvision 86\n", + "pillow 70\n", + "pandas 65\n", + "scikit_learn 48\n", + "keras 39\n", + "tensorboardx 39\n", + "scikit 31\n", + "seaborn 30\n", + "pyyaml 28\n", + "six 27\n", + "h5py 27\n", + "requests 27\n", + "tensorboard 25\n", + "gym 25\n", + "networkx 25\n", + "python 23\n", + "absl 23\n", + "pytest 22\n", + "imageio 20\n", + "protobuf 19\n", + "opencv_python 19\n", + "ipython 18\n", + "jupyter 15\n", + "nltk 14\n", + "joblib 14\n", + "mkl 14\n", + "opencv 13\n", + "certifi 13\n", + " 13\n", + "urllib3 13\n", + "pyparsing 13\n", + "cloudpickle 12\n", + "termcolor 12\n", + "click 12\n", + "cycler 12\n", + "mock 12\n", + "kiwisolver 11\n", + "chardet 11\n", + "xorg 11\n", + "idna 11\n", + "pytz 11\n", + "future 11\n", + "absl_py 10\n", + "boto3 9\n", + "dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zCKA7u-oZjEE", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 329 + }, + "outputId": "71d4ad24-2bd3-4c75-e05d-71f1cea7cf11" + }, + "source": [ + "all_tools.all_tool_names_cleaned.str.split(\",\", expand=True).stack().value_counts()[\n", + " :10\n", + "].plot(kind=\"bar\")" + ], + "execution_count": 36, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 36 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RNNkyCZZZjEH", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 310 + }, + "outputId": "c079be69-5091-4af5-ba38-948bde1cb0cd" + }, + "source": [ + "all_tool_string = \",\".join(all_tools.all_tool_names_cleaned)\n", + "\n", + "wordcloud = WordCloud(background_color=\"white\", max_words=100)\n", + "wordcloud.generate(all_tool_string)\n", + "\n", + "plt.figure(figsize=(10, 20))\n", + "plt.imshow(wordcloud)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ], + "execution_count": 37, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAElCAYAAADgPjhUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOy9Z5BlyXmm92Tmsdeb8tVV7c1Mz2C8AQbEwBEESZDgglxySSq0oeBGKILaXwytpFVI2tVSq2BIsVr+WAZ3yV2CHiuAELA0GIAGwGAw3vVMe2+qqsvX9fcen/pxblV3T1V1V/dMDwzrjZiprjonT36ZJ0/mm59LobVmG9vYxja2sY1tbOOHGfJ7LcA2trGNbWxjG9vYxt3GNuHZxja2sY1tbGMbP/TYJjzb2MY2trGNbWzjhx7bhGcb29jGNraxjW380GOb8GxjG9vYxja2sY0femwTnm1sYxvb2MY2tvFDD+MW17dj1rexjW1sYxvb2MYPCsRmF25FeLZxE8x2m8x0GljSYGe+TNFytlzWi0PeWJzmfHOFQTfLpycO3UVJt/HDDD+OCOOEII4o2g5KSsI45q3FOaQQFCybfeXq91rMTaG1xosjwiQhThJKtoMQm85ZdwWttocUgmzWvmt1zC00Wal1WF5p88iDO8m41m2V11rTbHlYlsJ1bq/s7WBqZoV6o0ur5fH4I7sxDHVb5cMw5rsvnWVyR5XBgRyFvLulcr4f8fzL59iza4BqJUc+t/X59G5Aa82ZlWUypsl4voAAhBDEOsGPYmpej4xhUnbT9k016yx1u9S8Hgerg5Rsh4xp0osimr6PFIKhbPa25Wj6HleaDRa7HUayOYazOcqOy8VGjVqvRzPwuac6SNF2sA0DL4qoex62oai6mfe4V36wsU14bgENoDW9OCRKEgTgKBNDSpqBx6VWDUcZ5EwLJQS2MjCERAiB1pogifHjCABTKhxlIIQg0Zqa3+P1pWkmcqUtEZ44SUi0RgN+EiERWEphCEmk02umVIi+3LFO0BqUFCixdeul1hpNQJy0AIGpvj8XS60TtA6IdBMpbAxZ/F6LdEfQWhMlCZpri79jpONICoEfRxhSIoVEALHW/XcEUghWej1agY8XR2gga6aL4eVGDSkkFcdlMJPFVgpDKgyZjoUwjol0QhDHZAwTJdPnh0kCpOMniON0TEu5Vm6zNlxfLoxjHMNcK+PHEZZUyD6Rifpjk34bFrodelH6jUkhyPTLJmh6YUhyXYJU1zAxlNp8G3ebfR/HCYtLLQxD3VXC02z1mJ2rc2V6hfvvHb8twrMq59x8g3Ipc1cJT63eZWa2ztJSi0cf2nXb5bXWrKx0GKzmieJky+USnbC80mZ0uHhb5TaqH6AVBHTDgARwDQNbGVhKsdzrkmiNEoK8ZWNISRDHtMOARGsspTD738mJpUWKto2pFDnTwlaKKEmYbTepex4DmSwlx8GLIy416lxupKSn7GSwpMJSirl2i6bv4xjGpoRnVebFbpdYp+tMxky/gaVel+OLC8x32gTV9Ht0DZPztRWutpo0fL//fRtIIZhtN2l4PiXH2SY878A24bkVtCbSCafrCyz7XQwhOVQaZsDJ9i9relHIifo8s70W+woDDNgZJOnCdLXb5FJrhThJGM7kOVQawhSKjGHxkzvv5WhtDvMmC8n16EQBnTAgQXOhuYyjTCbzZQadLEteh24UMpYpYCsDP45ohT5hElOy3LVFcGtICKJpGt5zCGEwlPuvuD4j9yqZeydWd+WbZe8WAja6dLNyN9vpa0L8aJpa7+u45l7KmR//vpTzVtDAspdOwr0o5Hy9xoFylYqTvrfLjTpVN0PesrGUoul7BHFMrDWuYfDy7BQXGzUADlYG2F+usiNfAiBIYhZ7XV66OsWuQonBTJayk+5IV7wei70OU80GDw+PUbBtTKlY9rqpNsH3uNxssLtYZiiTpXgTzUusk7Vydc9jpt3kcHWIkuMiheBSvcZYvrBGrOqeR9QnSLZSfOvKBWpeDykE91aHuG9wmMFMFj+KeGthLiVz6e6D+4dGGMrk7ri/1/pda5Ik1Zq88vpF8jmHifHyu37u7dR/PTbrW601UZTQbPX4zotnuO+ecQYH8u+HiGv1b4TNvi/TVHzupx/e8nNW4dgmP/fZR95RBu7Es0IDr81O89rcVYI45vDgELuKZXYVS3zh+FF6UUjOtPjErj0MZrJcatZ5YfoK7SBgZ6HESC7HUDbLM+fPYCnFmZUlHhoZY1exRBBF/MXZ0+zIF7CUItYFLtVrvDwzzeVmnYLtsNTrULRtLCX5i7OnGcpm2Fm8+diKtebLp49R9zwMKXlweJSBTIbpZpNvX7lIyXGpuBkKtkMvCnlh+gorXi+tr9ulZDv4cSrbWC7Pvsr350b1e4ltwnMLJFrjxxFX2nVsZbAcdPnShbf5l498CoBQJ7y+OM3jQxP4UcRXLh7lnz3wMfKmTd3v8tsnXuCJwUkGnCyLvTYHioN3LMtUu86p+gLHanM8MrCDK0GdL188yj9/6OMs9jrMdpucbSzxoeGdTLXrfHfuIh8d20fefHe7Vq01QTyNEAZKZJHkiZMGUVLDj6ZxzQMoWUCJdCEN4zkS3ev/ewHLGMdSY2gt8aNLREmNOGnhWgdRooAS6S4kTBaJ4mXCeB5TjWCpEQxVug05Y/xoCiUzSJFBkiVKVojiJcJkGdc8iJJ5BNZam7QO0SSE8SKuuR9DltFa4IXniJIGmgDH3I8hS2vlwmSOIJ4nTpqYchjbmFhrw50g0Zq3FuY4V1umF0c8NrKD3z/2JocqA/zUvkNcaTW42KhRtB2eHJvgmYtnyVs2hweGkELQjUL8OCZvWrjKxJTXTBDHl+aRQvLxyT18/tibPDm2g09M7mWx1+GbVy7gRRH3DQzzH956hSfHJnl0ZJw3565yZHEOWxk8OjLGf3z7NT4+uYenJ3bjGMaGC7MXRbw5d5XjywvkLJuD5QF+840X+MyeQxweGOJKs8HlZp0d+SIHKgN8+cxx7qkOMpkvIYBOGBAlSdoGw0y1pKTGeMcwiJKEVhTwzIXTVN3Me0J4Gs0es3MN/uZbx7lweQnbMpidb3DfPePs2jmAa5t89Wtv0usFRFFKzj77kw9SreTodgP+8D+/yPhoiSRJaHd89u4e5J4Do+TzLm8dm+Lo8Wk8L8S0DO49OIppKjw/5Mz5Of74/32RKEoIo5gf/+R9TE5UNzX9LC23uTy1zPMvneP0+XlmZuqcPjvH4UPj7N87TKvt8c1nT9Lt+URRgutYfObTH6BSznJleoW/+PpbTI5X6PYCoihm964BHvrAJGEYc+rMHK+/dRmtIeNaHNg3jGEomq0eJ8/O8p/+6Dk63QDbNvnERw5xdbYOAnI5h8ce2oXWmpnZOr//p8/zq7/yMbq9gLePTfP8y+f41McPc9+94wz1ydnJ07O89uYl2h2fMIqplLJ86PG9TE5UuTK9zLETV3nhlXP81Kcf4NCBUaqV9B0fOTrFkaNTa+9hdKTIj3xwPwtLLS5cXGRmtoZSkkbTY2gwzxOP7qaVi/GiiIOVAT44PoljGMx12vztxQsUbJsdhQIA//nEUf7R4ftp+T4LnQ6/+sjjZE1rTaO5u1xmR67Ap/fuJ2taWErhRRFPT+7m2OI87TBACcGeUoUHhkcYzeUZyeV5aHiUnJVuMp/euYuzK8vUPW/TsVj3PU4vL1F1MzwyMs6eUhnHMFFSkDNtFrsddhSK7ClVGMvlkULw0PAY3ShkOJvj4ZEx3P538tHJ3ZxYXqDp++/6G/lhwzbhuRVEOulGSUKQ+Cx5HS63a4R9E4REUHUyjGTyaJ2y9LrfxZKpOaIV+Cz7XVzDZNjNI96FIn7VPOYog+FMfs2eXPO72Moga1q8ujDFQwNjtEKf6U6DnGndsADeLhIdEMZzdINTWMYIysiT6A7d4ARRUkcKm5b/Cq65F8fcj8CgHbxBnDSw1Bix7mLoKn0jG2GyTBTX0EQ0es+StR7ENQ+gCen4b5HoNlLkiJIVDLl1shPrHkE8Szc8QcY8hFQZEt2h4x8hIURi0PSeJ2c/iKVGof+7EAaGrJLoHlqHfTkTgniBRHf7cn6TovM0phpG64CW9wogUDJDlKxgMXLH/buKXhQiBORMi/FcHiUEvb4tfiiT5cTSAitejyfGJrjabrIjXyRv2dhSkTUs8pZF2XYZyeXIW/baKCtYNhnT6k+SqWmpEXicq69gCMlQJstYvoASknYQsNBNNYWGkBQtm7FcujB4cUQnDHCMjaeMRGu6UYgpJUXbZjSXfg/tMKAbhgzncrw6O40Ugr2lClOtBgfKA+QsC0um5gJDKkq2w2g2j2uYCASGVAxmcnTCGgudNgcrg+St98bsZBiKTMaiXMpSWO6QzVpM7qhQLmbw/ZBGs0ez5TE+UkRKieeFHDsxw+F7xjAMxYVLi0zuKFMu5aiUswxUchiGotXqcfT4NNVKFtM0MA1FtZLD88N0jogTRkdKfe1Sj9Pn5imVspsSHssyyGZtyqUM+azD4ECOHWNlSkWXVqvH4nKLVttjckdljUS9efQKjz+8m07X5+LlJQ7sHSafcxBSUC3n0DolUsdPXWXHWBnDkNiWSbWSo9P1U5NpotkxXqHV8vD9kFNnZimXs3Q6PrNzDR55cCfNZo+l5TY6SbUwrmNSrWTxvBA/iIiieE1bulLrcOHSEvcfHkdJSaHgkslYCCnIuDaVSpZe71o50Mwvtlhe6eD5ITsnqnS7AUIIjhydIpdzqDW61Bs9Hn5gksXlNlprTp2ZJXMoDwIKts1gJoMQgvlOmxWvS86yyZoWppSM5vOYUiIEWEoy4Gaw+2Nca42jDLKWRdlxUUIghMCQgrxlkfQ1hEIIbCM1M2Uti4JtkzFNrL75a/V7jPXmZrooSaj7HhkzrWsgc8305RgGGdOiYNnkTJOMaQKpyUuKVJZV85dGk7dttOYGM/D7gVgnJDohShJU3xwvhUADYRIRJQmOMlNXi+vKKSGQCIIkxlLGbblf3C5+IAnPNdXo6k+xbtcZ6witEwxp3VAu1hGaGABT3topbpXECCFoBR41v9c3J6Q+CIaU3FMa4kBxkCCJmcgWWfF7FCyHjGEx4GSo+V1ypsWh8vCaD8OdwlIGh0pD7CsMkDUszmWXWOx12JkvYSvFnzbeoBX4dKOAdugz4KS23TuDJk7adMOTdIPjSGEjzUP40QxN/yUS3aXgfJha9xkS/REstQMl8zR6zxLGS5TcT6Bkvv8kgJgorhMnLaTMsNT5MlI4uOY+tPZoet9FoCi6HyVOOmjCLcqZEMXLdIOTdIMTOMYkAoUfz1H3nsWUA2Ssgyx3v4ohixiyghSKWvdrGGqAnP0ohsinPjSkmqIoWe7LnbDY/gKueQBTDZJoj3rvb3HNA2SsDxAnbbSO77B/b8RINk/ZcdlbqrCzUMLs+xscqg7y+vxV5totelFIK/CRwFB/Uqy4Ln4cUXUz7CyUyZgmXpT6je3qm6P2lCpM5IvYymDF63FqeZF7qoPsLJbZV6qwp1RBCLjabgKwp1RmLJdnT7HMRL6IISWt0L+lT8DO/v37ShV25kskWtMOAw4PDPGX509hSEkvimj5Pq5hMJjJorWm6mYI44SK47KrWEL1zbymlAxnc1xsrDDbafGPDz9ENZN5T/x3clkby1Q88uBOkkRTreT41McPA3Du4gJXppfJZiw+/MH95PMuy8ttfvcPv0OplGHHWJlGs8fOiSr79wxTKqX90un6XL6yzLETM/xPv/YTjI2W1r75M+fnWVpu4zoWH3nqALZpcHW+wZe+8iqHDoyyY2xjk0ex4KKUJIkTut2AB+6f4IOP7wXg7ePTzC00yWZtPvnRe4mThNm5Bp//k+9yYO8wYRTTbHkc2DvM6GiRXDad81ptj4WlFifPzPJ//C8/QzZjr82hbx+fxlCSbNbmRz92L+22z5XpZf78a0f4Rz/7BDOzNV5+7SJxnDA732BhscnB/SNYlkGx4JLPO3z3pXO4jnlDO7q9gGarxxOP7KFQcLFtA8tMN2OjI0XyOZvnXzqHY18rd/HyIq12j0opy0986n5q9S6nzszxF18/wo9+/DAIyGYtPv3J+5hbaHL6zCzPvnCGh/bux7QVSkr8OEYKseY3poRACsiaJj8ysTPV3EhFwVpvspV9s50XpX51QmviJPVXi3T/vyTecJHWWpNoTRjHhEmCShLCJF7z8dzo3lXS4kURSoi172ArSPqyBXFMlKTEY7P67gbCJKIbBfhxiN3XNJtS9ecAj14cMOAU6EZ+6qfU71u7T3KaQY8Bp4CU69fz9wo/kIQHwEs6RDrdieSN9bbK8+1XaQTzPFr57FrnJcQcb3yTmd4ppFB8evSf3rKeS60V3lq+SivyeXp0L14ccqI2jxKpa7DWmm4SpQ7FSeqDYUuFKSQF0+Z/e/hTXO02eGtllv/11a/z7576B5TtrUUtbIREa9pRsMake1GIowwsaYAh2Jmv8O2r5zCVwRPDO/ty3hmCaJZeeIZecIzJ8r/qL/g+De85gniGRHdpeN8ijBbwoxm86DxZ60GUzGPICoO5X4A1w0T6nxAGie7gB5eJkyYJAQBS5DBUiTBepO2/RjX3OQxZ2ZKcfnSFMF5GyaPsqvwGUjhEyTJN7zmiZIk4qRMmC0TxCl54CVMN4pr3oGSRnPUwg9mf78uXTi5CCIQwCeN5wnieWLdJCEm1OjkMWSGMF+kFJ6hkfxolbz/yYsN2xDG9KCV5XhyhpMQ2DEypGMpkqXk9vnjqKPtKVfaUrvWNQIAQJBts6AwhMTbQ8OUsizCJ8fr1dcIQWxlrGhxTri+3lQ1jLwwJ4hgNdONUa2X3HbDHc0Wagcd/OXeCx0bGbzBLCURft7YeXz17AikEH5vcw2hfnX+30Wz2qNU67BgrY1kGjm0wOJBneblNrxcihcC2FIMDeYpF94ZyzZbHxHgFyzLWETPbMpgYr2AaCsNUZBwTz49I7tBJd6XWptcL2DFWQimB66aaoMXFFmEYo6TEsQ2GhwpkM9c0YysrHcIgZmKsjFLrx0cmYzMxWu6308C2UjnzeYdswybRmkajx/GTMywtt/kHn3n4lk7YD9w/QT7v8rt/8B1s22DnRJWf/okH+2Rr/f1aw8JCEykFoyNpQEK5lMF1TRaXWiSJplTIkO07cDu2gWEqgiDmsdFxvjN7mW9dvsiR2Vn2lCsMZbP86O69/P7bb5K1TAbcLPsrVYr25hvfPaUy080mv/3GK3xs524KtkMr8Pnbi+e4UKux3OtiSMkHxyfXlW0GPnPtNn9+7hRTjQZ526bsujw5NrFOU1p2XJ4c28Fvvvoir1ydZtDNcqA6wMMjozft0+tR9zymWw2eOX+GS/U644UCrmnwwfFJjPfhmznXmuNo/QqusjBlOm+5yqIT+3hxgNaaw6VJXlo6TTcKGHaKzHl1TJEGMyz6TT438SQTmQEcZd66wjvAXSU8sY4I4m4/qqiDn3QpmkNY0kUJIyULcYNe3MSPu2SMIjkj3X0HcTdVHwobKRSdqI4lXaRQJDricucIUeIjhaJi7aBij2NJB601S/4VDGFRscZvkEcimczeTyNcoBs3ttSGNALL5pXFK2tRUmESr+mWYp1woblMFCdoNI3AY9DNoaTkarfJ83MXCXXCitelbDtIAd0woBb0eHNphnONJSxl8FdXTvLB4Z3kjNQxdTMEccTJxkLad2FIK/QZyeTJGCZmonhqZBdfPH+EiVyZz+46jHwX6kEpHJTMo2QOL7pEuuAXkMLENfejRI6s/QEi55OYagBTDQMgMJDCRIhrwyvRHh3/CFG8hKEq5OyHaQevIbFApMbBsvsTa/49i+0vUnY/Sc5e7/y4Xk4XQxZRskAvPItj7CQlVyYZ8zCWMYpj7CV2P4Vt7MCQ1TU5hTBukDNK6nSDk8RJA9vYScY8TMt/FYGRciItGcj9HHHSJEoaLLT/kMHcL/XrfHe42m5yvhbSiyKmW00OVQcZzeURwIHyAH4c86VTR/nvHn6SycK1iLQBN0PN6/HsVOr4e3hgiL2rhGiDec6SisdHd/DK7Azn6zXOriwx12kxns8zmS9xtdW84zZcbNSY7bSYaTdZ7nXJGCZDbhYhBA8NjfDK3AzfunKR//6xDzOQuaYtGs3lObW8yLNXZmn4Ho+OjDOYybDY7fLq3AyOUrQDn6Vuh4eGRxnJ5d+VqXYNAqSUxHFMFF/T1GUzNoW8w9JymyiKCcOYZqtHPu9gWWm9om/iuH436roWjmOyvNLum2XWvwAp1//tVlxS9OUM45g4uUaOCnmXTsdnaaVNkmg8L6Td8SkUXJQhV5sI75Azm7VRSrK80umbo8Q76hMIdd3cIa79qJSzHNo/wrGTM8wvpGOlXM6i1MZzzWq1xYLLgb1DZNyHuXh5Cd+PeOOtKzzxyG4cZ/0CJ0RKcFbqXWq1DgCdjk8QRBQLqTO8ECD6/Xm9u0DGNHlyfIL9lSq2MlIzk2HiGAY/d89hlEgjXEu2Q9aycAyDaiaD8Y538/DIGAcqA/hxxHi+gCkVVdflM/sO0Q4D8pbFQCaLAA5WB9gVRbimiSklUpiM5HL85L6DdMPU3Duay28YpKKkJGfZ/Oyhw6BJZXMcsqaJrRQfHJ8ga1pkrWv9dN/g0FrgghSCrGkyUSjymX2H6IQBGdNkKJO97Q1CLzxLy3+NlvcyGeseMtY9FJ2P3LJcGtUZotFM2HmUkMx7dew+eYl1wuX2An4cYkpFxrApmhmUkBhCUTQz5A0X4wfVpBXriHZUw086hIlPpAOCuMuAPYmj8mg0y/4UftIh0QmJjnFVnkTHtKM0pDZjFDFxqAWzFK0hTGGTELPiTxPrCEPa2DJLyUoX23Rn2SRMfJS4sXlCSMrWGI7K0YtbW2qDa5gMuTlyhk0QxwgB+wpVLKlwDZOKnSFvpmGJAhjNFChaDlIIwsRjxe/1X67JvaVhDKFISElTI/CoOtm1EPcoSejFIb34RlOOgP7zUqIVJQnNIM3rMJLJU7AcLGUgRMyufIV2GKDR7MgW35XqXwgbQ1VxjJ340RWksHGkg6kG0GiUyGDIMkoU1whHKu81bckqtI4J4gXCZAmTAaTIIbARQvZNlAGGLJBqzQJ6wQly1q3JDpA6KBsZLDVKLzyDklmUzGOqQbSOULKAqcoYsoSpBpB952qB3EDOgDBeIIyXMWQVqbIIrFQDoRMgwZCp6SFOWnT8Y1QznXfRy9eQOsin+T3Kjsugm6HQ91cZcDMMuhkWuh2Grou0gnR3ONif2FqBjxeFSAFVN7Nm4xewlr8ja1qUXZcTS4trZtqy4zLgZqm6LlUnk07ApoUQfVOb7W7JNBolCb0wpOF5DGVyVJzMmvPmaK5A1lxguddlPF8ga16bvIcyWebaLRDQ8D3COPX9CJOYrGH2Q+oljcAjSOItaZu2AikErmsSxQnNZo+pmRUK+dTcUi5luXRlmatzDeqNHvVGlx1jZQr9/DAb+ePZtkk2Y2OaBnPzTcIwRkpBNmMTBKmZ8U7U9VJKXNckDGJWah1mrtbI513yOYdWzmH6ap2Z2TpRlFCrd9g5WcWxTdptf0NJXdfCdS0MQzI1U8N1DJSSuK615qC9mZTFgsueXQO8dWyanhcyUMnh2AZJomm1fZZX2nS7AbV6h6WlNq5jks3aa2SsUs4yO1vH6wW0Wh5hFBO0IhaWWnR7Piu1DsWCi2UZVCs5Wm2fpeU2UzM1ms0erZbHzokqSvVNNRsIakjJzlyJyUKRuB+CvtrvDwyNpOk9tO6TJkHWtBjM3KipFUIwni/0TUUJhrxmGtrItPvO8oqUuNxMg7QK2SdgG8lmKdhZXK89G8ndGKlnGwa2YdwwN9wJwniZTnCEle6fE+smUjhbIjxSCExpULIy5Aynv0ZIBKmPTqrF1QzYBWxpMmgXcaSFFAJDShxpkTXsd7VJvxXuKuEJki5Xe6eZ6h6lYu+gak/w/NIXeGrwFxlx9hMnIW/WnqFqT7DDvYduXCfW48Q6ZNY7gxImw84eskaZ851X2c1D5I0BlDAJtY9AYggTU9r9xSsd+7bMcLHzBu2oxt7cY++qDVUnS8XOcLgygkSsOWIBDAK78hU+NXGQMFn1C7q268waFv/k0BOESYwQAue6BSNn2uzKV/jl/u9aaxI0F5srzHTX77BdZVDz00RXHxvby6ODE5Qsdy3PyapfkwTuKQ+xO18lY7y7XB1KZjFUgcHsLzJV/9do3UPJHHn7KeZbv0c7fIV28DpJ4lFyP07J/ThgstEMJITCMkZoes/T0UfphqeJk2bf/yUmjBdZ6vx/RPEyQjiYamhLpiIhBErmcc29FJyPcKX2L1DSJmPeT8F+ipne/0UneIuGeBatPQZzv0jWup/Nhr4QNqYaodb9Ol50ASWLJNpDk6C1Txgvs9D+IzQxAoVtjCHEe+NEe7AyQNl2eWJsop9351rYrxBptMYjI+OUbBfrurE0nM0xmMnyyMgYkDrSKyn56OSeG57/uQOHb/j95w/dR6ITwiTBkmptMv/YzhvL/cND9225DY8MjzGeL3B4YLjvDHqtDVIIBt3sWgTLqslMCMGOfJHRXJ4f3b0PWPWzkOwulvnfP/yJLdd/u1BKMjZSIgxjzl9Y5OLlJZ7+8EEO7B1m/95hXnzlAv/lr44QhilZ+a9/8UOMDBVoNHsbPs91TIYG83zoib38xTNH8PwI1zW5/95xioXM+k9D3PBjU9iWwehwiU7X58WXz3PsxAxPf/gg9x4cQynFm29N8SdffJkoislkLH75559gcCDP0nJ7w+dlMxYT42Uee3gXf/CF59PxlbW599AYpWJmnVDiun9UKzksU/Hb/+nbPP7Ibg4dSM0uvV7AiVNX+e5LZzl/YYFmq8e58wvcc3CURx/axdvHp/nmd07iOhZ+EDEyVOBDT+wjjmKOnpjhpdcvcOHiIt1uwNnz8xzcP8zHP3IvjabH6bNz/N4ffZcwitk5UeFnPvMQV+cafZHEDXJe35eplWADLZsQ11RPt4AUAnkTrft7jduR7fsJGeUwnqnw4cF7ONuepWcKGc8AACAASURBVBf53FvYwYXOPAFp/rrHq/vJGc4G5vI0r9hqcse7BXGL3Ajvah/VjlY433qNhJhBeydla5SXl7/CROYwVXuCojnE3879DkJIiuYg+/MfJG9U6cVNLnWO3EB4Xlr+M3ZnH6JsjZFVJY41/g4lTLKqxET2PpSw+gsExDrkzdrXWAqm+PTIP13Xga8sf4VaMMuPjf7qltqxlXwZ1y9M7/zbaumbqRZXCc+l1gqznXcSHoFjGDQCj24U4iqDx4YmKJjXnOxO1Rc4U1/k1cUpPrXjAHsKVcazd5aILx18YT+0XKBEnihZRggTKVwEBnHSINE+mqgfrp5DipSgREkNARiqct0zU8IQJXUgQQiLRAcYsogUGTQxcdJYCxMXwkSJPEpuvlvROkETkSQdhLCQwiVKlpAigxA2AkWUrFz3TANDFNcISpQsIoSLIfPXPTMm0UHaXlTf5yjAVNU0LJ2YKK4Bq7t1EyWLSHHn5DJKEv764lmEEJQclydHd/SfLYiShOenL3N0aZ4wifnkzr3sLw+s8wHYak6Xd+K9mmhagc+3Ll/ANgzGcgXuGxhak6Md+LwyO8Orc9MMZrI8MbqDQ9XBdY6ed9qGd4PVOuuNHlGUbkwyGQvLTAlgs9UjSfRaPphCwcVQkjjRLC+3qVZymOaNk3ccJ/S8EM8L0VojZOoHo/oOqVGUkMumTsJxnFBvdinkHGx7c7+FVTlXah2SRCOlIONaWJZBnGg6bY84Sd3uhRAU8qmjcxBGNBo9BgdyyHeYUqIoxvNDer0wNe31/XWkkuhEE8UJhXzqJhBGqQasXMqkDtSJZmGxieOYOLaJ45horfGDKI208kOUkhiGwrIUjm3iB9FalJXWGsOQ5LIOUgr8IEoju/wQZSgMJbEsRca18f2QnheS9NtnGIpsxiaKY+IojfjJZW2SRBMEEZ2uT6Wc29B0uI1bo+m9xHL3Kyy1v0TR/ShF52mG8//4luWCJCJKYlxlESYRCRopJGES9cevwDWsVNuzgdP2Kt6D737TB9x1p2UhBAoDQ1hr/jgpNBLJruyDBEkPTcLlzhH25h6H69RfGp0m/0v8vklBIIWBEiaq/9MQ1yIMhABDWEjx3mRiXW3DndyzJtNW6wFKlovcoIQhFUXLTb3upcSWN+ZDKZg249kiYZKatd6NY7QQAoF1wyJuqoEb5VHlPuGI+8Tg2t7KVOudjYWQCOFi9p957f7VPpIIWQGSlJxg3rLfhZCpnOp6OYduuMdUA2gd95/5TjlvvDd9pkLi9EPX0zr6V9IfejXz9GpM18Z5aW4HUsDuUhmBwDVvbLcgVZUfrKT9P5EvbugDcKcypO/63cOSir3lCoaU66JdDKkYzmY5PDBE1cmwI1/ccIy/38dJXF9nubRx9Fm5tLGWUUoYGd54Q6GUJJe1yW0ha7OUisHqrZMIrplSKuvzDykFVnljOR3bxBnamEgZhiJnqLXIrZvVbVvyhmSHSglGR0rr7nMda9Ms0KtEZSNkXGtTp+dV89s78U6imTptb3zvNu4+LNkPngGs65yOV/92M7xf3/5dJzxaayLtEyQ9Qu0TJwFKKJQw0cDu3MN0owa1cJYXFv+UEWcfOaOKISz8pEeY+ATSI4i7JNfFcEhUqo7XPqH2MVb9LNDEOiDWIYmOibSPWjOzaGIdEuuIhIgw8VDCTBfb77EKMV14BFUnS9W5/aifsWyRsWyRRwZ33AXpNkZKOG7P3irE5qrhlFxstBS+OwihEGxdJZ2OhY3vv9m1O4UUknuq68kXpM6M9w4Mce/Axte/X2AbBocHhje85vSvbXZ9G9vYxjbeD7wvYenT3RPM9s7iqBztaAVXFcmoAo1wnjdrz5DoCImiaI5gCBtHZRl29/Kt+c8z1T2Gq3I0okUinTrzCgSDzk7OtF5irnmWmd4pHir/OK7K04nqHGt8k+nucbpRgxeXvsShwodxVJ5I+xxvfJvp7jF6cZsXl77E4eJHyZsDWOLdOXptYxvb2MY2trGN71+8L4RnzD1I3hygaA6T6JiyNZr63xglDheeJmE1HFRQMAdRwiRnVHii+jkEEikUBxKfsjWKo1KVbtEc5mD+Q0xm7sdWWRyVRwmTjFHiUOHD7Mx8gEiH5IwKeXMgDYMnu3Yt0RFZo7KmTdrGNraxjW38/UCctPCiS8w2fouMdS9Z60EKzodoei/QC0/hRzNEyQpCWBiyhGWMUXI+iakGUXKz5JuaOOnghRfohscJonnCZJk4aZCavxVKZrCNSVxzP655AEvtWJ80N+kSxFeZqf8bHHMvWet+Su4nafmv0gvP9POOLQEJUjgYqkTWepiMdS+2sYNVl5B10ukETUjTexEvvLB2zI8QFkrkcczdlJyPobWXpuHYVNeemvO98ApBPEMvPIsfXSFO2mnGekAJFyULWGqUgvNhLGP4ppnzUx+emG54Ei+8RC88TRSvkNBD6xgp3DTyVlawjHEy1v1YanAtse1WcZcJTxppkTcHqFjjVO0JJNeiQUwcBp1d/RehU/PS6jXhMJ65p98Rep3ZyVZZqtJF981cq8+1hGLAnoRNzOeD9s5Nr/0gIwpjwjCi0/HxemH/95gojEgS3Xe81Omn0M9dYfSTnxmGwrYN3IyF5ZjYtpne8wMYKbCN9UgSTRzH1JY7eL0AzwsJ/Kg/HkAqieOY2H3/h2I5c9vZTrVOHXtbzR69rk+3E+D1grVxp5REGRLTVFi2SaGYJpAzTPUDMc5WnSp73YBeL8D3QnwvJAgikjg9yTxJdN/5O+1Tw1AYhsSwDDIZK/2+LAPT+oHN93pLfC8cz+8EST/9RK33dcJkBQ2YapCm9xzd4Dh+PJMGUQCGLGIb4yiyZO0HsY0dKLnelypO2vjRDA3vOTrBEYJojjBZJNEd0AJEmpvHNnYRRLNESYOSk0fJLEJc83nROiSKV6j1vk42ug+tAxxzT1+2k/jRFaKkhtb+WtBElLT6mek1tppcx1W0Tkh0l154mqb3HL3gFL3wPAldpLBRIo8fXUQKlyTpgk6P9tgIWmvipEYnOJJmt++TlER30DpgNQeakjksNQ4IsvYH0rMMRW69wzIajU8vOEPTf4leeJpucLxPoLw0MAYTJTOYsopt7EQKN5X7+4nwCARKmkiMvqPxO/PiiNS3YgO/jlWGerMPRor1eVS+n3H9ZLBZcJxY+1//903a/86JpdXssbTY4uTRKS6dW2B5qU1tuc3SQhPfDwmDCN+PMA2F6kdOlCpZiuUspUqW8R0V9h0aZXyyythEBds2Now8u9tYa5feWjK2a/9+/yfWrcr6znd6w7VbyL2lMbMa2rxJ9GAcxTQbXb71jWOcPzPL1MUl5q7W0xwxSpDN2kzuGmTnnkH2HBjhRz5xD45jIdXW+nWV7ERhzNE3LnP+zCynj89w6dwC3W5AHCdkMhbFUpbKQI7RiTIf/Mghdu8bpjKQY9UH+716h1t5L6vv5GZ1vrPv4zjh8oVFLp6bZ/ryMlOXl5ifrdNp+/S6Pl43REqBMiS2Y1Kp5iiWM1QHCxy8d5w9B4YZGSszMHRtkn4/I9FW23Er3Gw83fL5QJwkKZGWcmsVrqt/C+9kK/PDjf/bNNI7jBdoeS/gheeodb+GlA5K5LGNCfzoKkE8jx9dpuW9xkjhv6Xkfoqsdd86Wb3wAk3vu8w0/u/+XxRCWNjGKAITrX2CeJ62/xpt/3XM7tcwqwNkrfsx1MbHigTxIm3/deKkyVL3KwhUX7ZxwniJWLfwo0v47Uv0ghMUnKcYL/6zdDNzfcQwEX40zZXar9MLT/cjcA0cYzdCGGgCmv6LtP0j2MYObHNi83dASDt4k/nW79MJjvT7wernOxtCYhLECwTRbNpv/ssMZH+Wgew/JGc/usEDE8J4ian6v6YbnCDWbQQGtjHRz82WHiwdRFfxuUwneBspsxiqim2Mr3/eTXBXw9JTp+EgTTy0AeH5+watNaeOTfOtbxzjpefObHiPUpKRsRK//pu/dC2x1gaI44TFuQanjs3wnW8eZ3a6RqPWJQgiojBOtTpxQhyn58fo62YI0Z8EpBJIKVH9Sdo0DSzbIJt3ePjxPTz8xF4mdw8wNHJn4e13gtpKm4tn5/ntf/MNfP/mZ2kNDhX43C8/yYOP7iGbe//VdvWVDr/9b57h8sUlup3NTya2LYNSOcu//H9+gUzWBgQJEXILEV5Jolmab/CFz3+X118+v+E9P/Vzj/Hw43vYe3D9IabHjlzh+JEr/PVfHqFR7xL2x8fquFjV5K1q+yzLoFzN8emfeZh7P7CDA/eM3bIf5mfrXDg7zxf/8HkWZhv0ugFhmNazSoakFP3/Uk2P45gMj5XYc2CEn/2lJxkeLb1nmo/aSpvjb03xp//xO7Tb60+oFkC+6PLZn3+CH/3MA5s+J0k0gR/y2gvnOHV8hqNvXmZxvpn2YZQQR2k/Jv2DNvV135cQ19orlcS0FKapyOYc9uwf5qmPpYRvcvfge9LmmyFJNK+9eI7n/u4Eb71+6Zb3P/XRQzzw6C6e/JGDW3p+nCR4UUQvitaS9J1YnGd/dWAtIaYUgk4Y0AlDBjNZ6p5HohMKlo15XY6b65P7bQSvF3DktUv8zm/+NXEU33SByuZsdu4e5H/4V59LN9fXPXY1ud7ZxV8BDJRwMGSFkeKvkjEPYaohBJJE92j7r7PSfYaG920sNUrefoxd1d/oR5Je23An2sMLLzDf+r2+Jmg3trEjzSZPSjqipMHV+r+lG54ijJdSglL6tTUCBRDFDXrhaU4t/AJpEIeBEi6D+V8mZz+Ga+5HoNDE+NElGt5zzDc/D2gccw/7Bn4LyxhHimvRd/XeszS977DQ+iOkzFBwnmIg9wu4xj4Esi9bjbnGv6cbnu4fHdSj6H58XVh6eu5Xl8X2Fwjiq2Sse8lYH0CJTD84RBDrFt3gBAutP6ITvIVtTJCzH2VX5Tdu6DMAL7xIO3iTS8v/HEPmyTlPMJL/FUw1vBZsoknPN/SjaXrhWYrOj2AbO/sRs+vwvQlLl0L9UDoDa63ptnoYpoF9myGQgR/RqHWYv1rf8Prqx95s9NKcH+8IvYyimJWlNifenmLq0hIXz85z5tRVmvUevre1wzZXc4rEkSbunxKVwkcIQb3WQcn05/hEhQP3jnPvByZwXHPT9PHvFZI4TY8/P1u/dXu0xuuF67Rd7xfiJGFlqc1Cf5e/GSzbIAwj4iSmGc7hxQ0EkrK9E1PcKgtrai6pr7Q3HTPzV+usLLfZe93foijm7MlZXnruDKeOTjM3U1vLoHvD03U6noMgIggiuh2fbtfn5edO06h1kEKwa98QhrFeC6u1ZmZqhbdevcjRNy9z+cIivY7fz5dyI1bNqpBAkJqGgiCi1w1wMxYf/7H7GRotUSi++/kiiTW9bsD8XJ12cz3hAajXOqwstfC9EMteTzzrtQ5L803eev0Sp4/PcHV6hZkrKzcltqtY7dO19gJeP09hq9EjCCLiKOHi2Xl27x/mgUd3k82l2ZnvBoSA6kAeNNSW2msZnzfDyaPTVAZyPP7UgS2ZtntRxPGFeUBQdBwqrksviphttegEIa5p0AtDOmFINwyo93o0fZ9Eawq2jWuaFGx7SxmJ52cbTF1aYnZ6ZcNxdj0mdw/ibnJO141Is7FnrfvJWQ9hGWMYMr/mV6KJ0US0g1eIkhp+dBkvPI9j7kVc5x8hhY2lRihnPo1lTGLKal9z00+zomMMWaXg/giJ9gjiOXrRudSEtClipMhim7vIOx/CNfdjqWskeZXUrHT+kjBeJE6aeNElDDWIFM6aS4gXnqPjv4UmIGd9iLz9GBnzHkw50M+LFGPICkX34/3DSzfeXEE6npRwydmPkeg2lhrFMnYghLlmmUl0qrEquk/TDU8SJsv944nWI9FdoriGxkfJCWw1jtM/uuiG9BZJCUNWsNQwtjF5R2cY/v1WudwBdH83tzxbJ1t0b5vwbOX5YRCxstjCzVg3EJ4wiGi3PM6cnOVrX3mDKxcWqa1snEn13dQf+BHnTs9x7swc5UqOhx5fplzNMjRSJJtz7upptj/M0MQ0w6vUgisoYZE3hzHlrSf5W6FR71C7LqNuHCd0Oz4vP3+GF751kpmpldt6XuBHvPHyBRbn08RyI+MlMhkbeR3ZTRJNGEacfHuK5755krdeu3jLBeid6LR9Op1FZqaWGRwqcD/prvz9GF9eL6TT9ui0PSw79cdYJc5eL2Dq8jIn357iK3/6Is1Gb0OyeCcIw5j5q3Xmr9YpVbJM7hqgVMmxY7JKoejeNf+eyT2DDI+WyOUdVjbJvryKyxcX2bl3CM8Lcd1bH+LYDQPenJslY1ns7R/SGWvN1XaLhU6HnG1R9zx6YYgfRSw6XbpBemhwwXGwlGJnsUTBvrWWdurSEtOXl7Y01kbGS+y/ZzWf1s3vtdQoRfejuOaeNX+adAymZh9Dlplr/nuCeI4wWaYTHMcyJpA3ZFkXGKpCyf3khnWkOb5cCs5TeOE5mv7zBNFsmsD1HSao62GoCnn7CXLWQ+scpk1VRclHsYwxEt0h0SFeeJmsdU1zqXWAH12iG54EoOA8Rc569AbitCpbyf0EYbJE3fsmWm+8WVjNn5azN9eOpuRvlKL7MeZbnydK6oTxPKsHbt+YoDfu+x+l2f2lzPY1O7qvhRZr15TM9h2z7ww/OA4w3yeIwpjaQoNnv/gCZ167cFfqCMOYyxcX12k4jh25wp/9yYv8n//zl3j79YvvOdlZBw215Tbf+vpRfv1//CJf+cLLLM7f+cGSf6+hIUy6OKpI2ZrElvmb5iS6HSwtNJm7Wlv7ff5qnVe+e5Yv/cHzt012rsfUpSX+6He/zdtvXGF56cax1mr2OHl0mt/5zb+5I7KzBg1RmPDHv/ssz3z1DZbex/FVW+kwc+XG/omihD/7kxf5nX/7DX7vt/6OleXOe0Z23on6Soejb17mX/zaF/jyn7zI0SNX7ko9AIYh2XtohMc+tP+W93bbPjNXlnnz5QvEWzjFXQORTuj4PvVej4VOm0u1Gk3fpxn4HJmdXTuLylQKJQSGUuRth0PVQZa7XbphuKWz2o4ducyJt6e20mT2HRzh0Q/u29K9phoi7zzOxjm2JFJkyNlPYMpB4qRNJ3jzJoTgVnUNI9ecbcP+Yr+51s1Sw5TcTyHFZuRT4hi7ULIIxMTJClqvPi+hF10giOdT52kEOfsRXGv9OEiP6SliGxO45iG2njJ3Y4g+6Un7NEkz3uvUsfqG9hkjuOZBQNIJjlLrfoPF9h+njtlszWqxVXzfaHg6jS5f+XdfpzpaRipJu95hx/5RJu8ZpzRY4LtffZXmcpvAC0iShKd/9gkqI2XiOOFv//g5wiDEtAwyBZflq3UmDo5RHi6yMLXEY596ADtj0651+MYfPstjP/YAQ5MDvPxXb9BYbhP6IULAR37uScrDRbyOz/NffZVe2yPqH/735E8+gmkbNJaavPqNtznx0lkWplZYuLLMvgd3MXFojKAX8NJfvUG35RGHEYZp8MRPPszgRAX3FtlMr0ccJcxOrxD46QnccZzwnb85zivPn+XE0SniuzQBbwatYWWpzfPfPsnifIP/5lc/saXd6OqxBWESEesEV1l/bzVDGs1KcBmpPIK4Q5B0iHV6svC7zXVcW+mwvNha086dPDbNM199Y0uL1a0QhTHPfPV19GcfpjqYR4j0bxfPzvPlP3mBbndjE9btotcNOH1ihq//+Rv88j95ekMT2nuNVqPHwlwdmERrmJla4cVnT/OdvznB0mKzf4r43YXW4Hshz3/7ZPrNeyEPPrYb5z3UHK9+c5O7Bug84vHXf/nmLX2JlxdavPHKeR790N5bvgtTSgYzWe4fGqbiZshaJj918BCmSrPde1HE6aUl2mGq1UlPiEh9fRq+t6YVutncEMcJjXqX6cvLLMzdghQLmNw9wMhYmWJ5sxDyGyGlgyGrbLTIryaFtYxRpHSJ4iZhvNA/B/BGaB31/X7ewI+vEkbz/Ugtr7/gp9e96OL1pdaOd9mwOcLBMsa4mX5C9o/SSbUi18ulCePFvpOyWjvKR7AxeRJCIEUGSw3QvcW8lOgeYbxMNziOF14gSurEukWiuyT9tmrt9cPyr7X0nU9Vsohr7mMg+3M0et8miKZZbH+RpvcyjrkHx9hNzn4I29jZP2rozufL7xvCE/oRR587xf0fPkShmiOJEpIkwe/6NJZaXD4xhZNxSJIEr+tz4e0rhEGMaRtcOHqFgbEyiWsReCFn37iAYSh0opk5O8cDT9+LaZt4XZ+zb1xk5z3j2K7FpRPT/P/svXmQZNl13ve7974198zK2qu6qvee3mbBLEAPMAOAMwQIgCS4QQiKFEXKEZYsKxQWKYYcjrBJ20FZEQ7ZYct2yGEraFKQRcIiSBAkRGyDwWAwM5jB7L3vXd21V+W+ve36j5dV3T1da3d2zwJ8f3R0Zb7lvpdvOfec73yfm3IJgwC/43P+jUvsf3h3PJbvn2JwR3/ctm0ZXfJlzKdo1dvx+MKIMAyJogi0pl5u8Pb3TzE4ORATjmXXCXybz80wjFhcqBH4Ie2WR2mpzo9ePM+p49eYvbY2j+Nuw+sETE8t02p6HH9zikNHxyn0pRA3+NWEOqLsNVn26kTdAMePQjqRTxCFZEyXITeHo348dY9iEmRAoNtd7anevFDrtTbVSpMo0sxOl7l0bp7zZ2dvp0HmFmgNZ09Oc/iBHZRLY+QLSeZnq1w8N8ept64RBrc+9G8HYRgxP1vh7dev0Kx3SKTsux70NBodlpdip/uFuQrnTs3wyg/OcW1q6Z5OKqJIM3utjNcJKBTTDI8V6B/MdAnuvUOukGR0Rx/prEuj1tkwIK5VW1w4M0u76WEYakPu3kpJaiKbI9G1Rklb8dhXJj3ldpuU5xFEEbZh4IexRU7CNElvgb8ThvEksFyKpRU2ghCCiV0D9PWnN/Qnu2kdDOQGvn0gUCKJwEDrkDCqr0qirI4xquGHS7T8k9Q6L+MFM/jhIhHNbhASdT0F/a6nYIzNu1GNbvv1+r+BEHK1bqdXbW9ixO3iQaxpJxMIYdxCHL4RUpgosT4/RuuIICrR9s/SDi5R996g41/uavB43cBOs5rVYeNnhBR2zB9yniSK4mDQD+epdV7AC6bomJcIoyoJ6z5MNYilBlEyu+ExrIf3TMATRRFLMyV23DfKoWP76RuORYrmLi9w9cwM7UaHT//dT5AfyrF4bYn/9w/+nP0zZUb3DCGl4Om/8wRu0uHiW1c4/fL57o++NpamSygl6TQ7fP4ffgon6bAwtci/+4OvkCmkSOVTXHxril/8Rz/D2L5h3PR1b6D8QBYpJYapuO+xPRz7ubjNTmvN1bOzXDx+lS/8zs8xtLMfJ2nfVkYjCEJmppbxOj6L8zVefO403/vWcTqdjcmGN0GsHQfr1X+2D98LWZqv8W//z+/yD/7Jp8lkE5jWDRyjKOC15Yt8b/4k7dBjZ2qAit+iHXoEOiJrunxx8nHG3MKPXaZHCMGAs5+GcYlAt7FIoIRxx9kdiF9O5eW4A+vF505z6vhVWo1bXwo3nvLtBEOlpQbnz8wy9tYUx548wCsvnOPVly5QXccx/J3X3lb3VSk1OXtyhumrJUZ3FEhn7m7DQ63SZH6mjNbw0nNneOWFc7z+ysXNV+xivUv4dgPN5cU6X/sPrzAyluf+h3eudt316l5Jphz6hzLsPTDMqbenaazRwbaCWrXF+TOzLC7UMExjwy7IlGXz4bG125hXvNoeHtle+/A74XsBr798kdp619wNkELwwCM7GRheX+juHaMEJGh5/c+1lhIWCAlERLrNyoN0VaPJv0Ct8wOmK/8rkW6v6tsk7cMYshAbLHc5OLXOy9Q7L29xdAp1B1w/rb1u0CGQ2Osf4CoUQqz9e68YS9c7rzJX+79oeG8Q6Q6GzGKpEWxjLG5NF3FgpXXEfP2PiPRGxOyYn1NIfpakfT9N7zil5jcot75FO7hIKzhLufVNbLWDlPMwfcmfJ20fA719rt97JuBBgOVa9A3nyQ1kVj+uLde5dnaGMz+6wJf+4Cs4yTjLkx/OAZrqUo2hnQNYtomTtBmcKN6UdViBRhPpCNCUF6p4bY/Tr1zgD3/vy1i2iY40AzuKJNIJBsaL/NZ//7f45h9/j8APyfSl+OX/4rMk0hs/gEf3DPKbv/8F/vJffxO0JjeQ5Zf+8WdwUw7K3PpsNehyeK5cXKRcavCnf/T8pp0VQghsx2B0Rx9jE33kckkyORcnYSNFPItsNT3qtTbLi7XVTIDfbR3eKsIw4urlJZ75xlvUai2eeOrQ6nedMOCFxTP80o7HSBgWx8tXyVtJ9mdGKNoZvnTp+wRRSKQ16scs4EFDJ6pjqxT9ch85axxjnYfK7Wy72ehw5sQ0z37zONM38HYMQ5IrJDl4dJyR8QKOE5cVr04t8fZrl1mcr+J7m2dpLpyexbIMDh7ZwYvPnebEWzfzKIQA2zY5/NAEA0NZCsU0jm1SWq4zP1vhRy+dp930Ni1/BUHI8989ySc+deSuBzyl5QYXz83x6g/P862/foMLZ+Y2XkHA0HCO4bE8xYEM6YxLIuVg2QaWpfA7AbVqi0q5ybUry1w8P0er6RGF24uA/uT/eZ75uSqWYzI+sWbb7W0jkbD55GfuZ3a6vGHAA3Fp/fnvnOTxTxxg9/7hno5ju+i0fZ5/5hSV5Y1fnFJJEkmbhx7dTbF/q6J0Gk2Axl+31APEnB0ddtX/EzdMVjShrrJQ/7eUW88Q6Rb5xKfJOh8n43wUKdzYc7BrXBxGVSLd3nLAc6cQwrle7qLD5jPekIi1s2iaDl44y5XSf0cQLaBkhrzzJEPp38KQhZhnJOLWdK0DQl1lsfHlTQOeFVhqCNMpkrYfYyT7D2l6J2j4b1Nu/g1eOEep+XWq7ecZ4oROkwAAIABJREFUz/2XpOwPYRvr6wWthfdMwCOII3Op5E3pU8sxSeaSpPMp9j+ym0LXoTeVTRAGIa16m2a1FZeXun9DfOFLJfHaPjrS+G2f2lIdrcFOWCSzCTKFFAc/vI90Pq4fJ7MufSN5nITFriM7CIOIxatLVJZqnHvtEjuP7sB2LZSSqxocq+MXAjflsOvoDgI/YOHqEo1KizOvXmDPA5NktuCIvIJIaxr1Dt/79glazQ61SmvNWaNUEts22HdwhOGRPH39afqHMuTySZyEheNYmJbqth3G3V+ddkCz2aFaaTE/U+Hq5ViE7uK5uTio2sKzOQwjzpycIZ1xeeTxvTjOdYXsCI1rWOSsJCNunlbo0WenSZvOakJ2o+zbBxYClLAIoirtsIpAkbPGehb0lJcbfONrr7MwW6HT9hFC0Nef4v4PTTKxa4DxnUWyuQSGEV8Pu/YNMj7Rx4Uzc7zywjka9faGmYlSqcGFs3O89P3TzM9W6LSukwmz+QSDQ1kePraXHTuLZLKJ1ZJUq9mhUm4yuqPAc98+weJ8bUO5gSjUXDgzyyNbJJveCVpNj5lrZb71tTfiktIakwqlBJO7BxkYzjI8mmdwOEc2nyCZcrAdE8syMIxYWygMItptn3bLo1JqMjtTZn62wvSVZU4dv9rVJdp8XLVqi7Mnp3nh2dOM/OqHUUbvzI1Ny2DvgWFy+SQLs9UNJ1JRpDn59lUOHBlj5179rqmvN+ptFuarLMxvPF6Iu/wmdw+QStu3SHpsBK09gqiCuQ6PB60JohKR9kAYGCrHdYJzRCe4jBfOEkYVhLDIOp8gZT+EpYbgBpcArTURd7nZ5CYIDJlBCgtNSBjV4oyPDtdtmoi0RxjV1vwuiKp0/Mv40QLoEFMNUkh8BtvYEQd2N+oSRS1Cvb0mhLjcZiC0jZQuQpiYagBbjVBpP0fLP0cnuEKl9SymGnr/BjzASrfbTUhkEhRH8hRHC9z32B6GJgfibJBtUporM3NhnupSjepSDa/jszxTJoo0pm1iOSateptaqYFSkqXpEmhNKpekOFqgOFrg0Ef2kh/MIQSYtonZ5evYrsXhj+5n6tQ0p18+z9TpaQYn+3GTNpZj4Hd8mtUW1aU6dsJCGQqEwHYtjjxxHxfevMKFNy8zdWqa0b3D2wp40DFn5gfPnrpBz+NmmJZBKmVTHMxw7MkDHDw6zuh4gURqa2U0rTWdts9br17mxFtXaTU7zM1U8L1gSyTUqUuL5PJJSssNBoeyKBWnF3NWAgGYwmAkUaAVdkgZDgKBrcy74IW+OW7MYL2bpTQlTJpRk6o/TTNcJmkWMXrkc1IpN3jmb94i8CNE9/7YvW+Ipz57P/sPjZJM3ZoS339ohBNvXmV6apkLZ2c37EaqV9sE/hLPfeck5eXG6ovbNBWj4wUOPzjBL//aR3C6E4IbEQQhB4+MM9PVAlpPTwjil+zUxUXqtTZRpJFrZGt7hRV7iGe/efyWa14qgWUa5ApJHnhkkgOHxzh0/w7yfaktjUnrOKN65dIib796mdJyrHzeam2e8YkizZWLi4Sh5qc/dz+pjIu5jZf3RjAMyfhEkf6BDDNXSxu2qEeR5vzpWZYW4mer7WyND9NrVCstpqeWqVWamwaMmYzL/oOjWJaxrWsnJuDOY8rCLd/FZZwQL5gl0i0kJqbsXw0YYgHAy4RRFU2EEkkyzoe7L+NbxxBE5S6J+F5AdDMvLqAJolrXsqGDEjcTulc0eyLdIghLrDX7DaMKnXAKrb1u6/kgOfdJ1np5R8QWGbfDoYhLoTa2MY5tjJF2Hulmqgw6wSWqnRfIuk92t7313/m9FfCsgb6RPHbC4s3nTvHV/+ObdJoeQgoe+MQhDh3bx87D4zzzJz/gy//yrzAtAzftEAYhA+N9jOweZObiPP/un/85ibRDMpNARzA00c/EoTFOvHiWP/kf/xK/HaBMxQOfOMi+h3bhd3y+9AdfwU7YRGGElIK//V/9AvmBLJZrMbpnmEa1xff//GXe+O4JnvjFxxg7MMLybIkv/8uv4SQcAj/Ackx+9Z99nkzhVt+VrWAj4uTRhyZ45NgenvrsAyRT17uftvNCtx2Th4/t4f6HJ/nUzz3I//LPv8aFc3OUFjefgQR+yNxMme/+zdt8/m89SiJpk1AWvzD2KGnTxVEmWfN6SaId+tyfmyBrJVC3QTa7M+hud8C7qMKgwY/aNPQCJe8KhrQZjx5euwv2djbfbe8GSKQcRncU+N3f/wXchI1Ua18TmWyCIw/u4O//9qf4/X/6p1RKjQ330W7FqsMrEAIOHB7j577wCMc+fmBdYqtSkkIxxa/82uM8+823+fIf/2CD49DMzVYoLdVp1Nt3vawFrBngDwzl2HffMP/JP3qafF/qJq7aViCEwE1Y7D84wt4Dwxz7xAH+7Esv8vIL55i9Vtp0/Vq1xeUL83zja2/wsU/ex8j4rS/i24UQ8OBju/CDiOefObnhspVyk/OnZxgZy3P0Q5M9G8N2MHVxgR+9cH5L2bHiYIaP/dTBbWV3ALxwnlr7xVUV45sREukm1c5LBOESljFCyn7oJiXjMIpNLgUGpsyz/qtVd807L21rfLcPgWPuwlQDKJEk1HXq3qtI6ZC0jt6ydKSbeME0Te8EawUqWgdEUQvQKJFCiQzrBRxBuEy59SyR3lyscyvIOk8SRlVKra/jh/OEq4KNWw963jMBTyqX5D//n/8u4/tvlrKPS0UuT/3tj9JZmR0JSOdTpHIJDFPxy//kc+gwIghC2vU2X/lX/xGpJMWxAr/5335htUymDEWn5dE/1oebsnnq1z5Gp+mhozhdmy6kSGRcdKT5jd/7FaSU8YtSCIYmB7C6pRvDMvjCb3+OwA9RhiI/mMVJ2mSLaX7jv/kVpJLoSCOVYGCiiOX0rispkbR57GP7ePqz9zM+WSSRsLqy6dubCd+kYGkaFPpS/OpvPcH3v3OCb3/9TaqVzWcg1XKT1146z2d/4SFI2ighGXAyqO7MpxMFXKovxBkHaXA0v4Ok4fQ8yxJEHdphRKRDLGkT6gANWNKhGVZpBFVaQZ3RxG6EFnHFXvuYwsbXHn7UwZYuXhSXQ22VIIg8VNcOpRFUcYwkhjBXj23bEGAKmz57N6ZMUPWmu15w25uhbAW79w3x5NOHcFwLqda/NoQQOK7Fjp393Hd4lHNnZresg7PC2fncLz3M3vtGVoOdtfa18tnojgLjk7FVycJcZcMX2HLXB+5eBDzvxI6dRT7+9GEeeXwv+b7UbRucrqwjZax0/OnPP8TkngH+/R8+x/JCfVPZAK8T8Ow332LXvkH6BrbecbSVMd13dJzSUoMXnj21aUb34rl5coXkPQ94VrLbM9dKnHzr6qbL5wpJhkfzjE/2bVsRvhNcZrn5VVL2g7HQoMp3MzsBTe845dZ3CKNSN6sxQsp++AbRQYmlxpDSRePjhwu0/QtIYd9gfRDhh7Hh5nLzq7SDy9s7GXcAgUHCOkgnmKLSfobl5l8T6TaG7MNSwwgh0ToO6uZrX6Lafg69DodHyTSWGgEEQVTBC6dpeeexzYmuTlCcJWp03qTW+SHLzb/oErzXx0qZSmDimvswVO4mQccVonS18zwN701AYBmjNxi4vg8zPKZtcuDRtev2hqkY3jW47rqTB2PlxU7Lo7xQRUqJkAInYbPngcl11xvZYJsbrSeUYPLQrbVDJ2GTzm9f7nqrSKYchsfyPPKRPew9MEwmtzWNic0gpcC0FHsODLO4UOXyxQVe++GFTWdUnbbP9NVlmk2PZMrBMBWOsgiikKrf4lJjgbIXR+GmVPhOBkdZmLK37cYVf4mWF1/0aSNPLSgRaJ+UyhES0Axq1IISKS+HpWwiHVL2F0kbefyogxd16HfGaIY1/MjDCCtEUYQhTZQwqAVlinIEYwvCaBtBo1HCxJQuSpqA6Hm4Y1oGQyM57js8tiXuh2HE/k6TewZZXqxvOeCxHZP+gQx7DgyTL2ysobKCRNIm35dicDjH4nx1Q7J8vdamWt4a0bFXEFJgWQYPPLyTQw/sYOeeQQzzzvkzcUOByfhkH1IKjj44wUvfP7spbyoMI65dWWbm6jJjO/oYHl3bYPJ2UOxPMzCcJVdIUupyG9fD/GyFKxcX8ToB5jZLRXeKSrnJ4kKNpYW1OSU3YmAoy+Bwbs3y7UZYISqHUY1K63t0zGuYqojA6HpCHafWeYFI+yTM3SSsg5iqn5XXp0BiGUOYsogSKUJdp9Z5gSAqYXf1c1ZKZvXOj9DE5SAt3Lte2hJdorRj7CZlP0i98wqd4DL1zquYsohj7iYmGPsEUYla5yX8qISlRvDCW4NMJZLdYy0QRBX8cI5K+7skokOrQcqKMGPLP4cQEiUSGwY9fjhP0ztBEJXwwmsYMo8Uie729Cr3KM6MnUdgkLSOYqoi2316vmcCnl5BiDggQXDLA/WdL5f3W2v0+GQfDz66i0/+zJGejz2e7ZscPDqOYSre+NGlTbVIfD9kabHO8kKNVMoh3fVBakc+5+qzfPnyC9yfn4z5DKHHs/MVfn3nE+xQxR6OX3OpcRJDR1jSZcSd5GLjBLWgRL89yoA9ThB5eFGby82T5M0BfO1xuvYjhpzJVQJ1vzNGLShT9uapB2VcmUTJ2BumHTXJGHkS6vZKk91hEuoO7WCZuj+PJror1O1sLsHoeB+79t1qJLoehIBD949z7coSZ05Ob20/+SRHHpqkbyC9LZG8bC7B3gPDcZfXBpmFWqVFeXnjEluvYZmKQjHFL//6MQq3UcbaDLZtMjpe4Iu/+QTnTs3Qbnmbqji3Wz6nj0+TzSUYGokDnl7cOsmUw+Bwjv2HRnn5+bMbjmN+roKTsCgtN+jrTyN7PGHZCOfPzDJ7rUxrE+0diDlpu/atP4ldD0qmVwmwM9X/DSXTKJlBiQxeeJVQN9G6gxA2Wfcp8u5TSHH9mhdC4XYDIS+coeG9yWz1X3c1Y0YRwsILpwmiEmFUZTD9G7GPlnfyHQKEdw9J+36UTFNufZeWf4pq+zmq7edxjF3EvJ02fjiHIXM41l7SzqPM1/74lu0YKo8j9pCwjtDw3qQdXOZq+V+QsA4hhRv3gQWXCKIythqmkPxZyq1n8IJr644tCJfjVvTWfwRihWZDpjFlP5qISHfww1ki7SGQKJmmP/kFHHP7jQ0fqIBH2YrEQIpHf+8Y2Xwfy16NVujhSJOK32CmXWJ/epTZdgk/CnmocPc7QXqFQjHFk08f5pOfPnJX99PXn+aQOc6uvYNbM0vUmnNnZkmk7NWA52J9nnbo87mxh3kwP4kpFBW/yZcuPhe7KesIo0e2CgAhIVp7hGHA1eZ5vKiFKSwkBvWgTKhDZNfFd8mbW/1eCdVl92gaQZlyZ55mWCNj9JE0MoTapxO1kSiEkHfGARJgSpc2EGofhY28C5yiA4dHGR7bfiZgz4FhfvTi+oaB70Rff5pHP7p32+KAqbTD2GQfUogN5chqtbi9+15ibLLIZ3/xQ+TyyW1zQLYKyzYYHS/w1Gfv55UXz/PGK5c2XefNH13CMCRPPHV402W3g6GRHJ/41BFe++GFjQMvHQeg3/3G23zq5x4gf5ucxO1Ca3j5+bNMXVrYdFkpBUcfisnl20WkWyTtI4xmf5ul+lFqnVdoBxdoBWeRGNhqBMfYzUD613HNvRiquOZ2BlJ/h4zzJKXmX1Ftfx8/WqTln+h2Gg2SsT9C1n2SnPtT1Dovsoy+ZwGPwOw6qf8rFht/RsN7k6Z3nE54NS69yTx591P0p38VKWy8YI4FvrTmtpRIM9n3P1BufouG9xr1ziu0/Qtd/S0Lx9hBf/KLJO2jpO1HCKIKNe0TRmtnjxP2UaR0kcKiFVwgCJcIdYWWfw6EXCWJx67sh8k6H8U1D6x6nm0HH6iApx60uNJcwE9ERIbGjwLm2iV2JodQUuFHwarKr6+3IeL3LkNKwYOP7GJiVz+pzJ2bTW4EpSR2N9NTq7S25A69tFC9yS08adiUvQaX6vNMJosoISl7TVphPEuTPc5OOTJB2uojaxaRQhHoeD+uSnWDFN1VRRWEOiDUAX7UoRaU8aMOAoEhLIbdSUIdYisXU9pUvEU6UQsh4vVi3s/t87FiK4mo+3/vFqXWXmBgOEsml9h2FiCZsmNdmaS96W8uRLz8+ERx2+UN2zHJF1KbZvjaLY9mszdkx63AcU0GBrMcun/HbXN2tgIhBFLB4QcnWFyocfyNKQJ/Yx2karnJwlyV+dkKxYH0tvkp6yGZcti5d5BsPkkY1vE3aPlutzzefu0yTzx1kFx+faPLXiGKIjqdgIvn5jc1OzUMyeiOPgrF9G2pU8cqxApTFsi4T+CYu/HDJUJdR2CgZBJD9uGaBzBUdl1PKyVTOMYEOfdpXHMfoa6jdQeQKJnBlAUccxeGzJEwDyMSNknzKK6x+6bJlJQOljHGWPZ3AY1t7mRDlWUkWfcpXPM+It3CNe/rKjPfsIwQoE1M1U/WfRLX3I/vPLl6jFK6WGoI19wHSAzZx2jud7pdUu+kbwhMWSBtP4JtjJOyP7Taxi6EwpB5bGMnlhpEihR591MkzEPdLJnBO8tQpiwgzP30JT+PH5WIomas2qxDEAKB6tpdDMQt6uYEQtyeqO8HKuBpBG2uNOdohR5+FOLrkIV2hZ3JISSCUEeYMj7kSEerJa/3emnLMBQPPbaL4dH8PfEYMpRi/8ERjr8xBRu0EENcJiwtNWjd8HLKmUmWVJ3ZVpmp5jISQT1oYykTQ6guWbd3SBs5+u0ig+7E6mcC0SW7xV5VqzoYK4UkDefqr9NCxj45yiFt5lHi+i0RRD6NsLr6MIo2kUjfEFrTieqEXfO8UHfuih5RsT9DeptBsRAC2zZJJG1SaWfTgMcwFKmUw8BQZtsBj2kZZLKJTUvvXjug3eqtceBGyGQTDAxn2bGzvyclo82wa+8g50/Pkk47lDYp3bXbPpVSg+mry+QLyZ4FPI5rMTSSY2AoS7vpUdkg4PE6AedOz1KrtCgOZLDukqv7CgI/olZpMXN1mdomDRSGabBr7xDZXOK2xqW7lg9CGCStIySt28uiC6EwVJa0epg0D2+4rGNO4piTwNO3fCeFjW2MMJz9B1veb9b52BaWE4C5pWM0VYFh8z/dYDsGrrUXl83NaDPOsQ2/VzKFkqk7ckHfKj5QAU9sfCZphh2aYRvTN7jWXmS6VaQetLjaWmC6ucTV5iLtyCNCvyu6MNuBZRnk+5I88vjee9axogzJ3vtGSKW38OLUt2Z48laS+zKjZEyHFxfPIYCsmeDv73mahNFrHy3BztQhks6tY41nNeusJQR7Ug9suOV+e5R++84k8Veg0cy1TiJ1i+A2XZa3gsHhHNnbJLMnkhaFvhTzs5UNlysOZujrT29qHrsWLMsgnXE3nWR0Ov6mnkm9xKH7xzlwaPSeBDurJOadRR55fA/f+qs3N+2UqlZavPbSefYeGMaye/fYVkry0U/cx7NBtGEJMQwjSkt1Tr51FdMy2LV3+1yZ7aBSbvLyD87R3II6t+uaPPFTB2/7ul/pLPoJPvj4QAU8fVaGx/oO4EUBCWVjSEXeSpExE4Q6ZDI5SNZMkrOS74tgByDfl+SBR3ZhWcY9eRhDXELrH8ySSjmYpsLfJOVeq7bpdG6YjQtwDJOxRB+fGo671gyhSBjWXdLg2bj1+h1LrvvdZuveGQR99i4MxyciJGMO46hMT7y0bkSukLxt00nHtVZ5WBuh0Jcim99aZ9Y7YRiKxAa+TCvw/XBTVd1eYmL3AKMTvSTTbwwhBP0DGQ4/MMG3//otNnvhNpsdzpyc2fRe3N4Y4nE8+Nguzpyc5vTxq4SbiCK+/dpl0hn3rgc81XKTV186v2GZDWJOVLaQ5MDRsZ6brd5NhJFPoD183cGRaQx555IDQeQRdrfpquxN2eq7AT/qEOr4OBIqi+wBL9OP2oTaJ9Q+CZW7LYPQjfCBCnhsZWJJY7UbSwhB0rg+88+Y8cvXNd4/N0Yq7bJz72Dsvn4PS2+OY2K7sfL0Zg/ZTtu/iYdQ9Zr4OlzV5ZFC4kcBlxsLDLt5HGX1nMfzXodA4Bo5tKziRXeHjCtlLHZ3O5kXiIORrajpJlPObb9cpIolEDb79cMwumeO5UJAcSBDoe/ekHFXkM64jO7owzAlYRRtGPN4nYC5mfKqEnqvWsOFgP6BDP2DGfJ9KRbnN27/vnJpkZ17S3Q6fncS1vv72PMCqpUmly/Mb3oNZLIuw6N5srnEPW2X11p3OXkxP9ALm5jSwZBxs4SvW7HppzAQSCLC2CmdCIGiGZZoBMv4UYe02Y+j0rjdLtBQh3HDRNjAlgmUtFaDlzio8elEDQxhY0gLUzhEBNSDJZphmSDyyJg+jkrhqBWZlDX8JbVe5TtGOsSPWlgqgRImEoUXNVHSRBKbHMf6ZvHvIYWk5s/TjuoEkUdkBTgyhaXc7jjjoMWLWjgqjRLGakAUB0oeftTGkDamcFDCJCKg4s/hhQ1CHRBZEY5KYUp73WPYLj5QAQ9cd+f9oCCdddl33zBqHbXcuwEh4rZ+xzVxEuamnI5OxycMrnOiLjcXqfltbGlwJLcDU0Ij6PD16df52bGHGXXzPZkNvK8gwBQu9XCGsn+Vuj/PROoxZI+yPEKAYUrchHXb/AplyC2VS1IZZ0P37I0ghIg5KJscchTqTbMNvYJhKvoHMxSK9zbgSXUDHtuxCPxoQyFCrxMwN12i3YrvNdmjlnkhBImkzfhkkT37hzcPeC4uMHV5iWqltQ1zzu2hUW2zOFdl6tLSpssOjxW478gYUm5ffPVO0Q5r3SYIn2Vviow5SNLIk1A5av4ipnRwVQZD2Hhhk0B3iHSEKW0WO5eZaZ0CNHlrjLw1guPsB8CLmjSDMkveFfqsHSRUDkfF57oT1WkEyyx7U6SMIimjj6w5jBe1mO+cZ6F9EdD02RMUrDEctWuDI9C0giqaED9qU/anKdg7SKgslkxQDeZJqCy2TKKE1eUgBoDGEDbT7VNUvFlA0w5rFO0J8nKse27qNMMSZX+GAXsPrspgyTgYaoVl6sESVX+ejDlIxhwkoXJ0wibXmsepB/Hv3o7q9Ns7yVlbl9jYDB+4gOeDBKkk2VyC3XuHkD0iKm4Htm3ibEElOvBDwigiQrPQrnKxPs9yp44pFZ3I784G2pypzdAK7h0v4z0FDX7URKvY4qIdVQl178oTylBksnc2y1VKbokUn8642xZ3W4EQbClbGUURUXT3MzyGqZjYOUAiad/TDAHE58KyFLv3DXL+zNymQotRpLl6ZQk3YdE/mOnpWPYfGiPwI1587syGy2kN01PLfP87J/jZX37krjRRHH9zirffmNrSsrv2DvLYR/f1fAxbwWz7DEudy1T9Ofakj3G88k2UMDjW/2tU/Bm8qIUUBntTx7hQ/yGdqMFE8kFEJPCjNn7UXs1gGMICNPVgmcuNV5lvn2d36jHeKP01STPPA/nPxY0WtReYaZ3mvuwn6IRxlidrQhh5+GGbIOpgqySmtFGbtG1HREy3j7PQvkCoAyaTH+KlxX/PsLuf+7KfpNS5xiKXcVWGicSDnKh8m6SRZ9DZh5Ai3p/2sGUCUzpIYaAJqQclTla+gx+1GUsc4cXFLzGRfIhd6UdBa94ofZ1Qe+xMPUIzKOOqDKgsofbwohah9rFVvM1el+V68hbVWnN5qcQbUzO8dP4K0Rqyna9fmeHfPPcKf/HqCf7itRM8d+YStVZnzWV/ghjZnEsml8DsIUlxOzBMtSXTwijSq0qthlRoDV4UUPPblLwGZa+BHwUcK+4jZyV63qX1vkDXLR3i9LFE9ZS/I6W4ybX+drehjM1/G9s2bzuLtGq3oMSGnDSt9YZKzL2CkoJCMYV5F1vR14MQYpUv52zRmLO8XL+pI7JXKPQlGZvoo1BMbXoNLC/WOP761E1Z3V7iysUFrlzcXHunrz/NwFDurmWaNkNEiCkdstYwBWuMlNGHIWzq/hJZcwitYaF9kYiIVlihEzZIqBy2SuGoNAmVJWn0kTWHSBqxBcVSZ4qKP0cjLLPYuUQ9WKARLFP3l5BCIVFEOqDkXcNS7mrmx5LJuCxmZFezPgkjt+kxhDrAURly1jAFe4ykkQcEraBMwR6nHVRZ7kyhiWgEy0Q6iI9BJnFVmoTKkTL6yFnDuCpDpCMW2xepB0vUg6XuMcT/bwSluFwmJH7UpuRdI2HksKQbm0vLJK7KXN+mOYKteutc0LM3z2y5xtnZRd6+NrfmTXBufomvv3WGE9PznJxe4NJiiU4Q3JOH2vsVmWyCdMa55/ydFaiuB9lm0JEGHbd/O9IkZTgkDQdLGSghUUKSMGweLe4hayV+7Pg7K7hOwOu9f5bsdv7cyXWy8gLeDJZt3JkKsehqMW021nvwaJBSxkKD90DuYS0IEQdcWyklaqBSatJq9j5Lmkw5FAcyjIzlNw1mq5UWF87O0Wp6m/qBbQdaa7xOwPTVZWY2M1gVMDJWoH8wQ2oLXX+3rh5bHtjGThxjZ9cqYvuwVJKsOUTaHCRl9GHJBK2wStocQAmDerBIO6wSRF7sC2lksFUCeyVAURlSRh8JIwtALZjHj1pIJJ2oiSldTOHgRS2UMEgYOVJmX7ecFkLX69FSLrZK4so0Tnebrlox9tz43CSMHBlziLQxQNIooIRBJ2yQM0cItU89WFot30lh4hppLJXAVilclcZVWVJGEVsliYio+HNEXZ07L2riqHSsjxZ1UMIkZfThqDSdsI7W8fUjhMRSCRyVXN1m2ixiycSWjmGruGepA9c0GMtn+N3PPPFj+8LbLgrFFLm76M3Vawhi0cEP9+/FiwL8KKRop98X3XB3HRo6YR1lmNgqTcW/eme6Pu+AkLER6L0IjG3buOs6LPcKUkmKg+me20hsef9SMjiU21qGR8PCfJV67e7IGiRTNk9b2nQwAAAgAElEQVT+9GHmZ6sbBlWdts/iXIUTb15l38FhigO9Ka+FQcSl8/Ncm1qmtInYoBSCRz+6l7EdfRsutx6UzJGyP8yR4e/c1voriHSAr+O29ri7KOiWk4xutiLPicp3sFWSjHm9s2013tc3B4ymsCnak4y4B9mbfvyW/e1KPcZE8kOUvKu8vPRlstYwj/f/erzNWOoYtiloGkYegYizhkHkYQobQ9oooUgaBTphgxPVb9NnjZMzh68fw/WzcNNnprQZdu8jbRbZkbhZ+kMIOJr7DF7UpOLP8r35/5uD2ac4mP3k9S2snpfez3h6+tQqNVucuDbP//6dF6m1PbKuw8cP7GSyGEvdWyp+qKyKwGnNm1OznF9YZmq5gmVIqq0OQ5kUnzy4m5PTCygpyLgOD0+OEmnNyel5/uxHJ/idT3+UhN1rTZf3FjLZBMmtaOG8A20vwA9DgjDEsUyUlEgRC/EZdzFbtLJdV1mYwqAjfE5VppECHGUxmezvdWLj/QMBtkrTFjWkUAy5R1ZJfL1AbAB7b6QLDEO9axmRXkNKQSrjotS7lOGRglxfcsuddbVKi0777ggyuq7FI8f28s2vvcHyYm1Du4kwjHjp+2fI9yV7FvD4fsArL5yjUtpYiDHmPhkcfWiSwZHNyzZrb6M3N0ojWKbizdIO61T8WRIqS9YcRmKQt0YJCXhu/t/wSN+vMOhetzJayYqcqDzDkneFfnsXO1OPMJY8wuXGq1xpvk7FnyXUAXlrmD3pY7TDGjOt0yx1rsSmnNLsZnFiJI08rbDK6er3KHnXGHT2siO5sdYYQMmbxovOUQsWqPgzqxkfEAy5+9DAK8v/Hz81+J+Rv0GXLG320w7rnKp+j7I3w0jiIIPOXiaSD3Ky+gwLnQvMt88Tap/RxCGGnQO0wxqX6q/SCEoIAa6RxZbX9ZOy5iBz7Rqnat+j7M8ynriffmdnT34r6HHAE0YaPwzJJ10iDX4YcmJ6nqFsGq3j71+7PE2kNUnbYmd/nmqrw3y1zmylxv3jQ3hBSNPzOXFtHqUky40mC7UGD0+OUmm2WW60qLc7t8R+S4s1EIJUt3uk2U23FgrJ1RtXKUkYRqtlmk4noF5vx47RSRvLuvd1/I1gOya2vX19hmulKm3PR2uNY5nYhsI2DbIJ5y4UU26F1pqq3+R8fY66H89GDamoB212pQZukgr4cULcwBoS6RBT2IiuynNPsMXup15AKom4xwTfuwUhYv0heQ+7IN+5/0TS3nIA2W55PdXiuRFKSfqKaYZGciwv1jbs2IoizYUzs5SW6vh+gGne2atEa43vh5w9NX2TiOlasG2TgaEsff0pHPfO9WvuBEqYXU5OEkOOk1A5TBk/30zpkFBxQOZ0eTsrsGSCtDlAwR7DVdnV1mtXZciaQ6uEZE20WtaJ7S9cXJVBCRPHTZK9IeNiyxQZc4C8PY7T7Q7bCkxpI4TElkn67V3kzOHV8dgyLltBHJxYNwQnrsqQMQcp2OM4Ko0hLASShJEjb43e0G4eYXStICQKWyaIVIgSCttNkjavlxMTRo6sOUTeGsOR6Z6Tlnu6NUNJskmHLz56Pwu1BmfmFvnqayc5tmcCKQVBFPGnL79FveOxo5DlVz/8AJHWSCHIuDZfePQoU0tlTs0s8J2T5/nHTz/OD85f5szsAhqYKlVodHyOjg+h5M3ckrPn5pBCMLmziJSSq1eXabU8Hnhggnq9jVIS1zVpNDxc10JKQalU59zZOVIph4nJIoVCipWa6HsBjnN75NC3rsxQbXZwTAPHNLBNg3zS4ejEyF0Y5a1ohR4XG/N8Zeol7s9PEnXd0r+/UObXdz5BQt2eD8r7GhqCqE0QtQiiNl7UXK1f9wJxW3pvidDr7ktujevzfoCQovs8eHeI9AJBMulsiSwO0Gx07pogo5ACyzbYe2CEaqW1acBz/swM87MVGvUOufydvUqiSNNu+5x46yr16sZWEqmMy4EjY9sKFO8WUkaRgrWDyeSDKGEihFy1tIk1dwRD7l4SKt/txIrhqBS2TJLvW8mYxG31CpOxxBFG3cME2ot1fEQ8MUoYWcbVEcbcQ0SEKGHd1ADiGhkclabPnljZ4haOQJC3x0moLGOJw7Hmjlix5YnQOsQQNkPOXhyZuikASRh5XJVj0N3b3ZJcPYa96ceJdBQbJQuzKxcjSBg5dqc/jNbhTYHQCpJGgYTKMZI4uLrNXqKnAU/GsdlRyMWzJtPANhQtz8MyFE8f3MPH9+8EITh+dZbLS2X+9OW3ODQySMq2V3k9xXSSVLnKXLWBa5mkbRvHNKi02rwxNYOlFE8d2rNaHltBrdqmWm1RKjc4dmwvlmmwMF/lq199laWlOkNDOQ4fHuXZ756iUEhRLKYZHctTKjVYXKyztFzn2LG9OI75rt9EK7Ad87Zk5IMwouPHhPDDO4a4vFBisdbEvksO0O/Ehfo8rdDjZ7tu6YZQVP0Wf3Th2bvilv6+gIhnUg0d0I6qqNDqLYeHe5fhEWLln/c/Vmwe3q0AbsWI1dhGwON37q4C9aMf3Uu74/P6yxs7eYeh5uRbV8lkXT75M0fvaJ/zM2VOvX2NarlFtAkRuq8/zRNPH3rXeWRKmGihu6J6JjfefJcbrzLfOU/Vn+PB/OfJmANrbkOy/nPQWMOoOA4qJHKDV/dG27x1H3GQpoRx0zYjAi7UX2amdQqB4EOFX1q3Y2q9/a2YMq9/DOtBbOsYtoOeXjFSiNXMS8yrFrFLiY6zP2Y3kLAMdVP3TzvwqbbjNGa949HxA7IJGyUFI/lMt8Q1R6XZZiCTIpdwbnneajR+ENJodKjXO5TLTarVFrZtMjSYxbYNrl0rEYaxvocfhFQq8fdSCpJJG98P3/Wb6EZIJW9r5plxbbIJh5F8ho4fkEs6OObdUUVdc/+mS9Vvcro6w4hbQAlB2WvSvEtu6etCayBAax8IQCRAdwANwoGoCsICYYNugTAQKOKrV4GQ9CyC0LFbuhc26IR10uZQ92Pdm6xMlwT5wQhD7i0MQyIEhFFEEMTPBqXiZ5lSEq3BD0JaHb87aYhb6i3ToOMFq9pCvh/G3LkgnnAUc0k0sU1GOrFOVlN097/FgCsII6IeZgbXQnEgw/BonoHhLAuzFTZqpL1yaYFCMcUnPh0HPLd7ay/MVzl94hp6E+0lN2FR7E8zuWugZyaqt4uiPYnWIVIYNxkUAxSscVyVxotapI3i2i/+DU7WVq1ytvv9jZBIBp09gMCQNzc8CBRFexJXZRBIUkbfmkHIu30M20XP3+5rDdULAsrNNi3fRwpBqdkmCCP6U0mkFLT9gHKzxVylzrVShWqrw1g+i5SSgUyKIIx47co0YaRxTBPHvLVum0w6+H6IlGK1VdKyDAqFFI5j4vkh9Xqbvr6482mF65PPJzHNmMPzXtNolkLcFleimE6Scm12DuQ5eXWeYjpByrl3dhpZM8GSqlPxGlxrLiOAZuCRMh1M2Xu39PWgAaIK4KF1iBBNdBSn6YUsoKN5wEIIF61LCJlDYwEByGL3eujdNaG1JhQBkfa7qdpeX2/vrev3/QBBTFwWCDw/pFRt4gchphFrUNmmQRhFtDo+1XqbhGOtaoclHItqo40UAsc28PyQMIwIwpBmJ1id4HX8gFTCXvfXUcbWGwmiMOJu6zGm0g7FgTTjE0WW5msbtp4vzFa4cmmRdsu7LVmEFb2lpYUaF8/ObRhcAeTySfoHsz0jSr9zLCtZ1/iKkEQE3b9kdwIfEXWtH+IgQK7KTYQ6WC1TuypN0siviv9FhPhRh0gH3eBIrerqrHXO4rEEqyMRSEIddEtD8Vhiu4qQUIcxD4fr11Go/VXJl0gH1y0ihCDUPpGOuYQJlUPeYPuwAikkeWuEvHVvaBD3CvcknTFTqXFmdoEfnLuCbRhEOmJnf4Ff+8iDHL82R8cPuFaq8j994/tUWm0m+vJ88bGjOKZB0jIxpOQPn/8RH90zwe7+/Jr7OHZsz01/j47evJzWt84+eulJczcgpOB2YoMHd16/SI/s6J0s91aRt5IcyI6QNh1eXDwLQM5M8Pd2fZLEPfYxC70fgLAQskjkvUQULoJQSOMA6BroDlp30NEM0noMIVLo8DLK/SKIHkoCiFizwxV5WqqEHzZvaUm94128dy/l9wXml2s8+9p5kq6FoeJOtKRj0uz4dDyfVsfHNBSVeotW2yfh2iyUapiGIp9OkEk6FDIJkm7sFff2+Rk0YJsGo/3ZdX4ggVJqy1nPIAg3Lfn0AoPDOR7/xH289drlDQOeWrXN7LUSp49f48DhURx3+52znbbP9JVlTry5ubryoQd2cODI2Lb3sTVo6sHSCj2YhJGj6i8gkKucm1ZYpRmUKfnXGHL246g0lohJyo1gqcvN09T9RdJmPwV7HIGiESxRD5ap+QsoYZE08qSMPlLG2m31sWLxUjwSYeOoNBV/FlM62DKBJRM0gzKNYJlqsMCoexBbJlczSTV/nkB7aB1R9Rco2hMxOVgrqv48jWC5KwRokTH7SRh5UkbhLp3X9w56FvAcGhti31A/YRQhhSDl2BwaG+SfffZJiqkku/oLfGzfzlVClG0aZNw4zVtMJ3lwxzA//9BBokhjGQaFpIsScUksiCJans+ugT529q/9o6xs98a/V6C17j5rRPe7+LOVYOeDRqB9t49HiFiAcNjJcSg7jgAShkXSsO+5BpMQDkL2IYzdhMEFpBwg1tuUgAKZQpBDqDHARusO4ABhHJD0iGuktabsTWG4FllrjE5UI7oXyno/waaIohWSaVwyarQ8xgdzZFMuZ6cWSTomSkgMKcmmXAyl6LgBtmUwkI/9t7TW5NMJChkXKSUXppcYLmSoNNpcW9i4LBQTRLeGFZ+7u42+YpoHH91JOu1SCRsbtqjXq22ef+YkO3YWbyvgOf7GFFevLG2p++y+w6PsPzhyl4J7gSUcztVfoBGUOJz7aU5VnyFvjbEnfYyyN82V5us0gwpD7l5eL/0lA/Zu9qQ/jBIWJyvPsOxdZTxxBClMEhTQQDNc5mzteTphg9HEIU5UvsNY4uhNmja3QmIKh+OVb6GE2bWu+AYTyYcYcQ9S9q5xrvYCCEGfvYMfLv0pu1KPMuoeQgmT10p/Sah9hpx9q51SERHtsMLJyncwpUPRnuTtyrc4mPnkTRpBH2T0JOARQpCyLbhh8m4oQUpZ8edA0rboSyVuWk9rjSDW50k7NqP57OoLUWvNdLnGYr3BXKXOjr4chaSLa63fhridmuF2goIbH0jihnVXPr/xs58gtpVY6tQ5W5shiOKHWD1o0ww99qWHSZu905/ZDEKNgsiCSCKN3YCBxkMHV2OOjsgiZBEh04BG67icBTeTENfDdpTCIx1hYGDJ2JG41y2XP8H2oVlRCo9tJhKOxXAxTcq1UVKSSzlEkY7tQKRkIJciysZlGKUklmmA1oRRRMKxSXW955p9Hv25FAnHxOxyhNYdg9ZsWsvpQop7Y5JpWga5fGw3EQQhlQ18vtptjzMn43byTC6x7aaPi+fmWJivbngKpBTkCkn6h7LkCndPjNWQNqZ0CHXAudoPMIWDo9IIoORdI9IBjkp1syUaL2rQCEpkzEHaYQ0vapEy+jGlvdqGHkQe7bAe+1zJFJ2oQaQDDLl+cLgi4GdJl2ZY5nz9RdyukacmYtm7ihASR6VJG0UiHdIOa7TCMimjn2ZQwZA2aaMfo7uduFPUoxXWkCJ+DrXDGrEZ6Lvb3n+v8K4/cZWUKCkx3kFA08Dp2QVevzLDTLnKp4/sJ5dwt5whWHkRbVV3RrOSCYqZGzeup4kJjSvfG10icRhFhFpjKhVbK/wk6AGgEbQ5V5/lP1x5iYPZMWI3XZ+FTpW/t/uTpAznnpwrIQTCPHT9b+tDQIQOl4jCabQ2EGogLm+JVLcWv41x6Zt9xDaDJR2UiInbWWsMQ773eGM/jojCeOJimQb9+SSPHZ5kbqnKUqXBnvEiU3NlopbGMmB8ME86YcWBDqzyeeQ7Msr9hdTqL7uPja6q2BV+q9eQUvKelOFXhCwPPbCDarW1ccDT8jl7aoZyqUGhmMJIbS3g0VqjI83p49PMzZQ3XNYwFDv3DNDXnyaRvDtlcSEEpnDot3fhRx1eXPwSPzPyTynaO9Fas9C5QN4eI2+O0GdN0GePA4KyP0PGHOgGGH1Mph5a3WakQyCK28ulxFJJbJnEku6qXs/aY5GYwmXI3ceVxuu8uvwVfn7svyZjDhJqn/nOeQadveSsEXLmMH32OJEOqfjz3YDLIWsOMnHDWILIQxNhCAtTuqtjMaWLIW8+p1prvCgk0nr1GhcCDKFu6ZB+P+FdD3ge2TXGwzqeYd14GwvgiX07eXzvRNzlJSVqGzd62w9o+j5LzSYDqRS2EZPDgjDCCwIirXEtE0sp6p7HUqNJveMxks2Qsi3q7Q5J28YPQ9q+jxCCC0vLaA0Pjo3Q8n2myhWuVap8aGyEnOtgG+/66XxPYKqxhNaaL0x8hAfyk5hSUfGa/PHF7wG8y23pAmQf0vlM9++V8tb2odEEQbilLI8Qgow5SqKbAeg1IfonuD1orfH8AB1p+vMpnnxwD0oKxgfyjPXHEhsTQwXoZnPfOTFb7xd857Ns/f3HYoJb9aQyLXXPupOUknz8U4eZurTAxbNzGy4bBhGv/OAcUai5/+HJLW3f90PKyw3OnLjGwmxlw2Vtx+TJpw+TL6S2OvzbxrJ3lWXvKoPOPirebKyXY41hSpcoisnHAJ7uYAoLsyvwJ1lpT78OgSRrDmMIm3Lw/7P3nkGSZfl13+/eZ9NnVlaW766uaj/d0+PNzrpZB+wCCxAACQJcUIRISBGSSIVCITH0SYqQQhKlCEbomxghylCMoFmBBEACWJgFFliHnR3XMzvd0zPtqru8TZ/5/Lv68LKqXXVVVne1waBPRMdMZd58777MZ879m3OWmW2/y4sDf+OutTu3Y82doR1WGbKOsO5dRxcmtpbHEKnEEiJOuk6D2MWWuRtzETrytgiyJgyKxihSaLSCVRa75/lM5dfJbFO744QB/9M7f8aPV2dZ6iSNHnnT4m8fe46///Rre/o+Hyc80ie0EAJ9hzSUrgn0e3wYCZEIHV6r1al2HVJ6IsC31GiBSCJLlq6TMnToqUIHccyFlVW6QUC14zBRzJOzLPKWxVghhxSSTuCz3u5wdmGRlu8ndhcrq5wYrlBOp5Noz19RBHHI5dYKVb/Nhtdm1W1gayaaELQDh27oJV0xjzQStpkS2IeHhkpu2v2mtYLYIbipxcaQdq8N/gkeFZRKimbjOBFA3VRcvrnmb6cz5X7T5Shw3aBvwmPZJvpD0tMSAgYrOcYmBhgZK7K8uHMU5sK5eYZGC30Tnm7b48IH87husGOES9MkmazF8dMTZLIPrulBqZiav4AbNbFlhqnS11lwPkTzDTJ6mbHUCVbcS8x1F2kEK7SCVQatQxTNUXaO4Sm6UZ1msIxEEhMzkjqGIY/0hAXv/GykQur+Il7cIadXmM6+xFz3AyyZYci2GU+fYqF7jnqwxLo3SyesUrYO3lXv5+a5dMIqXtzZEhecSJ9Bl2NbHWXJOPCikG4Y0AmTqLQmBX68N+0wpRRVz2HN6dDwHcYyBbqBT0o3OJAt8HF9jZRuYEiNmWaV4XSOkpWiZKV4Y+U6k9kSQ+ksq06b5U4bKQQlyyZG0Ql8wlgxYKcYTecwtd3pzCc2JLH5UK11HTqej6FJDE1jttbA0CS2rpO3k5CiretkTQMvDFlqtqh2HequS4xiPJ+nYFtIIYlUTDcIWGm3ubi2AUKRsyzmG00OloqUUn+1i1BDFTPfreLHAU7ks+Y2me9uIEjUlzWRtKQ/rLb0Bw2lIPCT6EA/g92oAaG2pcJaMMa2VFSf4NFAqUThN37Qvd532z8Kz/H77ryybWOr3f1BQwhBJmszMl5i/GB5V8Izd22dlcU6juNj99Gi3u16fPzhAoG/80PUThmUyllGxooPVCdNofBjB11Y5I1hDqSfYcW9QqxiFBED5gGq/hytYJ1muIohrcQgVE/sIzJ6CSO279hmJ6wiSNJlhrRpBEtk9BIFY5S0Vth+LirGj7tYMkNKK3AgfYaF7vle27ygbB5g2fmIbtQgDtcwe+NSetKun9MrW7YWm4iJ6IY1pNAwhI0uDWr+AkVznIxWIqU/mDqeZafFutOhGwSUrDSrTpu0bjBgp1joNLF1A0vT2XC7ZA2LjG6ilOJSfZ2cYVOy01xv1lnoNNGlpB0ktcBOlHjK2bq+lXbbDZ9YwmNokpShY+uJjka147DhOJhSEsYJ+TkyOMC784voqRRDuRJvzy+iaxrjhTxHK2WcIKCSTXNooMT1Wp25eoPVdoeNThdQaFKigHYv0qP9Va/hUeDFyUlYNDM8X57eeiuj2zxdOkjmIbelPyhs6od02l5fq3OFYt2/jCY9/LhLoBxOFn6GjBx8CLN9grtBxYpO2+07wrLv+1fQbLoEYX8r50zOxrwHf737wdETo3Q7Hu+8cWXHcdX1NnPXN5i5tMKJ0xO7Fmo36w5v/uASnrezGerYwTJnXjyEaer3VL90ewT2bkQsMfU9xkjq2NZrL5X/+i1jnip8GaViIkI0biV1Z0pfu2ObofI43/g24+nTnC7+FEVjnPONbxOpgHVv5g438U3o0mQ0dYLR1Imt117ruaJv4rmBv5bo6RDdMZdXBv/mHdt0oybnGn/MifwXKJojZPQBPqj/MW7UourPMa6fuuMz9wsFvL06z6mBYT43OgVAM3Bp+h7nN1bwopClbgsBfOPoje/iZgLTDX2+vzTDgWyRSMVcam5QMGwmc0VGM3nG0rm+o6qfWMKz2u6w2u6ga5IXD4yTMpIIzpuz8xwuD1BKp5irNzhaKVNOpxnL5/jS0emeKBRbhctWTyNjopBnIJ0m7LXdR3G81Z2lSCI9t/t7/VWDpel8bujkjmPS2ifD4V6pRBOl3ervYSmQjNpP4xhzNIMlDFJo/NXojHicEceK2sbObdcPEipW1NZb+H3aReQLqYdumDlxaBA/iMgXU7RbLnF099X00kKNN75/kWNPjSHl3SNR62st5mc3WF6oEe3y3R88NMiLrxy+p1b0pu/yB9c/5lJznYJp80x5lNdGJtF3mNvuEGh9PjolOsP2Uda96yw5H2PJDJ2wymjqBBVrevcN7DoTidZnhFgXNsP2URadD1lwzmEIm3a4wXT2ZQasg/c9l7thPJ1nodVgqd3kWLHCZLbEtVaVf3PlHP/g9KdYczssdJr81tVzTOcHyBqJfMlMq0bJSiOBqfwAoYpJ6wYHc0VWu20MqWH3kca6GZ9YwmNqGnnbYrJUZCCdSiI9SnF4cIDRXI6MaeAEAWnTIGuaGJpGQbtx6tzebm7qOqau36KXIXjSmn4zpJDkH2LL+aNEEIS4TkAYRP112Ah6raAZ0nqZlFZ40qX1GCCOY1rNLlGfEZb9hlKKRr1D0KchaC6fwrYfLuGxLINiMc2hw8Nc/HAR1/HvOrZR63Dl4jKBn7Tx3y0is7pUZ3Guuqv2TiZrURnKMzqxveDsbnDCkB+tzHK1ucFoOk8llaWfDPROSO7z/V23UkiK5liSuoy6aEInqw9QNEexZHr3DezjXDShUzLHiVRApAIkOlm9TE6vJG3rDwACOJgr0fRdgjgirRtb2tG2ppM3bXSpYUqNmueQMyxSeiLc+Ux5lPFMnrxpc7w4iBtF2LrOgJUirRsM2ulPHuHZLKwKYx9dmndIYN8NpXSKUvrWH1EXgtMjNwSWjgzeWinfT2fF7a9vtrE/wf5hL99nEq5++LVTnhvQajr96/AoCJWLLm1yYpiSNbmjAeATPBzEsaJe7RA+IsITx4mtQl8RHgHFgQyp9MONkkopSGcsnn1xirmejcTdUK91uPLxMt2Oi65L5G01N5vXy+zMOteu7Nz5BYmv1/Bokcrw9rUuOyFWim7o86Pl61S9Ln4cU3Md+pd5vH9IoVEyxymZ47sPfsDQpfnQ5yKE4FhxkLgXGJCwlcI6NTCEpWkULJuRdJa49/5m4OAXp09vbedArkjU0+2TQnAgW7xzZ33gsc/BOFGThe4F/vX1/4ZV9+qjns4TPGAIAaLP1GAcg+eG++3Q0BfqtS6Lc9W+9VMQYMkcbtRk1f2Yq63v4fV8vZ7g0SEMIuaureO5O9eRPCjEcczszDrdjrfrWAEMjxXJFR5+FDWbT/Glr50hX0jtmFqKI4XT8Xjj+5dYX7vL+a3g43PznH9vdsd9CgGf+txxJg9X7mnONbfL9VadVad9S3fkEzx83NwXa0jJwVyRX5g6jXVThGa3u/5+uA8+9oRnU/Q9VMFDZeZP8GgghEjMFPsYq1SM6/p9V+jvJ1qNLqu7aIfcAgWhCnDCOq1gmWawRKQezUP2CW4gjhXNhkOr6eJ07x65eDD7jvH9iOVeZ9NukJqkMlQgm3v4hEfTJMWBNIcOD+0abQmjmHPvXadR69zxXhwr5mY3WF9r0WnvTPI0TXLy6QMMj9zban7FaXO1WX3y1HgMIHoK4UIIcqZF3rQxblrY3vz+btu4H+w5ph7GPkHs0g6rbKYSFIq8MYQhLDRpbI3zY4duVO9ZSAik0MgbQz1RJJl0uYQ1/NghVH6vDkZiyBQ5vdxzlL6BdrBBVc4n+UehkdIK2Fp2yyU2UkEyt6CKIgYEujDIGmV0YW652nbDBqHy0IWJG7V7rrMKW8tiazl0YRCpkGawhiJGCo0w9gGFLk2y+mBvew83meV2fTw3QMUxhqUDAhUrMnkbr1dPoumyFx5XCCnIFdJ0Wi5RGJEvZfC9kMBP/m26G0dhRKvhUBjIYFrGQ9P52A5CCnRd9kXl41jhOUF/beH7jFbTYW1lD4QHQMUImbgrB7Hbc1buVwv8CR4UfC+kUe/SbrsPNV3k+xGtpkOj0SXcpZZF01Eg2f8AACAASURBVCTpjEUun8KyHn4qVEqBnTKZnK6wsdbakezHUczM5RUa9eS4br6fxFHM/LV1mg1nx/odXZfkCinGDpTIFe+N4K27XebaO7fSP8HDh609umaNPV857XCDJecib2/8NhFBz8Y+4vWh36BiT5ETSZttM1hl2b3E+7Vv4ccemtDJ6EU+P/Qb5Iwysucwe6H5XRadC2x4s4k+gEwxljrBq4N/E1tuqmoqFBHnGt9O2hnDVVJantPFL3M4+0riL6IU3bDJsnuJN9d/k0Al+ywYw7w6+KuUzLEtFcprnXdYda9SMseZab9NJ6wRqoCjuVc5mvs0JXOMZrDG99b+H8LYx9ZybHhzPS2GcV6rfIOSOf7Qu2zmrqwyf3UVt+szcrCMEOA5AS98/jjzM2tsLDcoDGRYmt0gDCPstMlrXznNhXev0ap1+cIvPM/KXJWV+SqrizUmj41imBr1jTY//MMP+KlffpmxQ2UGKvmHelw3Q9Mktm3SDwmIIkWj3iV6yOFqpRRrK00uf7zc/4cE6NKmYh8jrQ+w7l5ECu0J3XlMsDC7wchYkcrQwzv369U2Vy8u91X4btkGBybLWLaOfEhKy9vhmRenaNS7nNshHRXHiplLq6ws1mk1HUrlTYNVCMKI99+5RqN+Z/TnZmRzKZ46c5DiQAZrj234m3VCi50mH9fW9vTZJ/hkY8+EZ92b5aPm93i18isUjGFMmSKMA7JGCb1HKCJCLjS/Szds8JWRf4AuLZrBCuveLD9e/yYvlP8aQ/ZhAI7kXuFI9uUtAbaLrb/Ai9pcbr7BicLngcSPpOGv8Fzp5xhLncDSMnxQ/zYb3jxe1OG50s/hx10WnQu8vfHbfG7o75LWC4TK52r7bT5ufp8he5rj+c9sHYcXd7nSfpMXB36JnF5GCg1dGljyhjHdhjtL2TrIU4UvMGBOsOB8SN1f5P3aH/GpwV8lre+9kO5+0G27+H7IZ3/2Gd76swv4XkhhIMOV8wu06l08N2B5LgnhWikz8Zy5LQp17u2r+G5AJp9i9tIyp16aYqIwxMT0EONTg+SL9985cD8wTJ18Md1XC6rvBVy/utZ3h8t+QKmkyHVxvsbC7MYePghB3MUPVmkFy0lU8cFN8wn2iIsfLlIayPL0c5MPbZ8rSw3OvnW1rwhlJmfz1JmDGI8w+gpw5PgIC9c3KA9m2Vhv7zj2ysVlBofzvPb5G1oyoR/x3lszNGp39+YCKJYzvPb6iXvWHHKjkOvtGhfqq/f0+SdgS57lk4Q9Ex5T2mT0ImvuDAAFY5icMYQhbSQShcIJmzT8ZRrBKovOR2jSoBs2aAWrtKMaobrxgPKjLk7UxI8dpNBpBWsEsYsh7V5aKvEd0oRB3qhQNEcxZZpBc5IV9zJVbwFI0lSJ8yuUzFFSeoFIBQzbhzlf/84dLYASSVorkDcq5I0KAokiRiC3aiuEkKS0PGXzAHljKJHkjjqsudd6ipcPF4Ef4rQ9NlaahEFEKm1SGS1y/u0Zhg8MMDiSZ3WhjucE6LoklbVpN7o0a12atQ7NagchBVKTvVRYCjttIUhCzZ4TEGYitIek5LoddD0J3etG4n22UxdUGEasLTfwvZA4ih/ayvfa1VXWV5t9a6cAvbZ0jViFhMpDoD1pSX+MsLRQY2mxhusGWNb2cv/7BaUUQRCxsdZi5uJKX51+qZTJ1NHhR5puhiTSVB7KMX10hFr1CvEOZG1lqX7LosB1faobHaob7R2vHcPQKBTTTB8dTtLb20ApRahiWr5H0/do+C6twKUTBLQDj6rX5b21RdrBjdqomtvl7bV5dCnR+1R7//qhEwxY6XvSWOsEPg3f5XqrRtVz6IY+XhihUFsaMpVUhvFsgaKZomglWY+od1y/c/V80tkkBJam8wtTp7D36NcYK8WG22Gl22bD67LhdnHDkKjX6ZHSDQqmTdFKMZEtULHTWxpFss8OZKUUNc/ho/raVkTt1MAwE9kCo+kcndBnvt1gvt1g1WmDEFhSp2jZPF0eIW9Y2D2VZwW0fJf5TpPL9XU6oU8Yx5iaxnAqy0g6x6H8AJbU7uka3TPhyRmDjKVOcrb2+7SCdSr2FJMZA90Y6tXIJFLa3ahBzV/gfONPtz4rEKT0QkKMeu3mq94Ma+4MjWAZQ6Zo+avo0iKjl9iM8wohsbUcaa2IrWVRSlG2DrDqXaEdJBdUJ6wSxC45s4KlZRKPEgQj9hHeDP9tr+bopgOXFgPGAUyZ3mp13/I16l3DpkwlEuBm0spuazksLYsXd+m/PWf/EEeKbsfj6oUFdFOjPFJgdLLMv/2n32V0cpDxqQrV1Ra+G2CnTSzboFnr0G46dJoOtfUWA5U8TscjDELGDg2Szlo4HY8oimg3uqQyJlbq0YkDappGKmVi2wZO19+xtiEMIlZXGnTaLkEQYT1gwqOUIo4U59+fY2UXmf3toEkTUMQqRKI/ITyPEVZ6ujCNWpfKcP/KrfeKdstlZbHO1Usru95KhBBkczZHToyg32Uxkih/Jwrwd8o0CIRIb9Uw3g+EEJQrOU4/d5Czb88Q7+CttLRQZ+7aBnGsEAI6LZflhWpSU7iDWGc6Y1Gu5JicruyorOyEAddaNa42q1xr1ZjrdWQtdJosdpqEt7VvrjhtVuYv86fzl/s+3ucqY+RNG63P/p5N8upEAUvdFlcaG/zJ/GUuNdZZddo0PBelFGnDpGTZnB4Y5dOjkxwtDGLKMrZuEMYxK90W/8Pbf0JM0tVUslL89MFjfROeTULohAEXamucXV/k4/oaH1ZXqHoOYe93K1tpDuVKTBXKfHb0EM8OjpE3k0yNLmXf18GK0+b3r33Ev7h0FoDfOPkSr49NM5zOsthp8oOla3x3cYafbCwihKBg2hzOlfn1ky9ytFBmWNOQCNwoYr7T5LsLV/l3M+dZdTo4YUDetHh2cIwXhyZIGybj6fwtLez9Ys+Ep2iMUSiMMJV9gfnueZacj/mtuf+e14d/gyF7mqxeRqFIaXkmM8/y1bH/4rYtCCSSUHk0g3XOVn+PY/nXeK3yDQxpc6HxZ9T9Ze68aNVtf21zUe/hASIQuxYe68JCE9t9RY8mGWGlDYZGi3z2a88gpMBpe6wt1Tn10iGGxopJB8TVVZ56/hBOx+ODH1/hZ3/tNb7+tyugFFJKDh4ZTm6OsULqGkIk+fJf+U++iNT7P8EfJKQUjB8sE/gR9W06PTahVFJwevatGUBw8umJBzqvMIxpNRy+8wcf7K1DC0CBH3WIZVJM76v2I4kSPsH2iMKY+esb/P5vv803/u5nsR8w6f+zP/yA99+Z2VV4D6BcyTFxsMzkocoOOYaYVvMfEcfroG7v+NIplP4xQuxPfdLYxACf+/IpvvnPf0gUxneNUK0s1rheStOodcgX06wuN/jgveu7RrROPXOQ089O7kh2FPBhdYV/cek9/uD6x71e3htCsI8KMQovDPnffvID3lyZ43xtJdGguW1e3Shgw+1wpVnld699yHg2zxfHj/APnv4UXhQy32ne13H4UcQ7awv8f1d+wh/NfowfJ3Vi6rYnZzdsMN9p8hcr1/mXl87yhbFpvjRxlC9NHCFn2Bj3qEi93G0x265zxBnkH/7Ft7jWqtH0va291z2XuVaDd9YX+DvHX+BvHD7NwWyRf335Pb6/OMN3F2d6HmYJHCfg23OX+PHKLL937QL/5+t/naKdwuhTl28TeyY8kQoIlYcts0k9jczQCtZoB+tk9QHyei9FJCRO1KLmL1Eyx9CEhlIKL+5iSJtYxQSxs2VkZsgknFfzl2gEyxSNka19xiqmGzZphet0wwa2lmPVvYpCbUVf8maFqj9Pw1/BiVoINCLlM9c9T9YYIGfc6Vm0+8O9fxXLh4HRg2UKA1m0XphX0yWmZfDcp49RKGfRDY1XvvgUQkChnGF8qoKma7fcOAS9NFHvPNm0xtB6ofJHTXgSHR44MFlmfbW5I+HZxPtvX6NQSHPs5BhSu//Wxe2gFKwuNfjzP/qARq2za1fNHZ9HUfWuEdMgjF0eFWl+grujut7ize9f5PWvnGJ4tEgma+/+oT0i8EOqG23eeeMK1670V1B75MQox0+PI3bxkRJYGMYZdP0QQtycwpcIsX/HYhgauUKKE6fGuXpphXp1+2tUKXC6PlcvLnPq2YPUNtpc7SOFd/j4CEeOj+x6HZuaTslKMZa5k8jFKOqec0tKy5CStG6SN/tXODe1/tObYRwz167zb658wJ8vXGWl2yLcpqFC9lL1mwQtRrHSbfOdhSvkTYvxTIEwvrcaP6UUQRzzzSs/4a3VOd5enceNwm3CA8m9PhEEVETJZHhvfYluFDLbrmNIuWXCvVdsuF0+rK3Q9F3mOw06QdLlvGnZBMlv1A583l2bx9I0Xh+b5vuLM/xkY4lIxXf8QpvjZ9t1vrc0w0tDExzM7U2Be8+Ex4la1INFDGEDgpgIW8shhd5rIxfYWpa8MUSsIpadS/hRF01ogECTJnm9ghBJy7glM3hxl3X3OooYN2oSqVvzuwLQpE4zWGXNu4YlU1T9OQxhkzcSUSpby5HRi6RkjjV3BlvLEamQde8aJXOMojm610N97FAoZcj0NDiESGpx7LRJoZTZuhkeODxEvdrGMHVyhe2Lf2+/gB81ybkdQghGJwa4eGGpr/Hz19e5PrPG6nKdkbHSvnLUzZvz+mqLq5eWeffHV3CdoH+F5RtbIlIBmpCYMo0u7a206xM8HnC6PvOzG1z4YAEpk8WEvo9RzyiKabdcLnwwz+zMWl9kXtMlk1ODTE73Ib4nQAgLIfIImbv1jX2UXJOaxLINjp4YTRYldyE8kCiSz1/f4MjJMZoNh+WF+t1TeCKpVRoZLzG0i/aOAAqmzfFiBS+6sx4oiGPe31ii3bhRQ5TWTSazRY6XKn0/yHOGSX+qYLDudrhYX+c7C1e41qoR9NJGupCU7TQ5wyJrmliajlJJrY4bhTR9l3bgM9eu8/3FGQ4XymSNezNZDuKI2XaDHy5d44PqMkvdpK5V9upmhtIZ8oaNqWkYUhLGCj+O8KKQhuey4XW4UF2h4Tk8VRrGi+4tCr3hdlEoZlt1cobFUCpLxkhc0Je6ra1jjlTMtVYNKQQZ3eRqs4ofRRwtlClaKWKlcMKA660aThhu1W29v7HEVH7gwROeVfcKZ2u/RyNYRSLRpUFKy/PcwNcpGMOJcBwGp/JfZNm9xNna7xLELrGKMYTFmdJPY2ZfIG8MUrYOULLGWOie50rrDUwtxYB5gJI5xs3RFU0ajKSOseRcZK7zAc1wjZTstaXnXgaSepuR1FGeL/8cb6x/kyB2kUIjZ1T41OCv3ian3d8JvN0osYfP7zeslMnNl4FlG1i3+eoYpk7lHoW6HhdIKTh+apyfvHutr/Hrqy3OnZ0lm7P5xt/7HJrYn4fUJqlRseLP//gc77xxmXPvz93TtgSSQfswup0IaA6YU/c9vyfYfwR+xL/6v77HL37jVfLFNKWBRPLifs6nzfPIdQJmZ9b5f//Jd6httHftzhIi8c46fnqCYyfHdt9PXMcPZ/C9HyLEzSk5nXzxHyFE7q6f3Ss0TfLKZ49x5eIyszPrdx3nOgGXP17m+VcPU11vsThfvetYXZNMTlcYGy9RKmfuOg6SRdHhQpnDhTK/xnO3vKeUoh14/K9nv8uVmwjPaCbP1yZP8PdOvniLwu/9YvP3/eHSNf5s4SoXajc6wwSQt2x+dvIELw8f4MWhCUpWCoHAi0KutWr8cOk6764t8CcLl3h3fZEL9TXMe0glKaVo+C7fvPQ+76wtsO7eIKIp3eBAtsB/cOx5XhuZpJLKkNFNIqWS9FOrzp8vXuV3Zs6x4Xapeg6X6usE9yhjP9Oqcq2VRJD+s9Ov8tnRKc6URwhVzP9x/k3+Yvkab68lDUeLnSarTpsrjSrdMOCZwVF+/fgLfGZsCj+KuNas8t+++cdcaqzTDQMiFfPjlTleHT6452tzz7/6wcwZhu0jW/UHm0ZgKT2P5MaPlDeHyOglJtKntvJ2AoEp0xhy87EteW3wG8QqZNOCc2vVKwSGtNAxseyj/Mzof4noiRXGREgkpkyhyxuh2pRW4ED6aSrjUyhUz/lcYstcL8KU4Ej2VaYyLyCFvpVKuxmaMCiYw/zM+H+NIW/cOIrmKDl9kIPpM6T1v9yk4nGGEIKjx0cZP1CmUErv2sIKcH1mjepGm1Ta4tXPHuPAoTtTmHuF6wZU11r81r96g7NvzuxdaPBmCDBllm40SytYoukvMpZ+Bkvbv4fQE+wPNjba/PvffItzZ6/zt//j1xk/OHBfNT1KwcZqk2/9zru888YVVpYaOxbtbsKyDb7+N17i4KFBTHO3W7VAahMY5gvo+vSt5EYIhNhfdWYpBUdPjDI5PcT1q2usrTS3Hec6PpcvLnPpwuJdx2zCMHU+/YWTlAazO4573BCTkIbvLFzhu4s37I9sTWckneV/efVnmMwVKZg2lqZvRYwsTedwfoDxTJ7Xx6f58sRh/sd3vkPDd/HCvUttNHyXS411fvPKT2gFN1SsS5bN3zn+Al+aOMJUbgBb19F6BeyaEIyks5TtNCdLQ7w4NM4fz13id66eT+p+7vE7CeOYASvNmfIIv3z4DEOpLKamYQK/evQZhtNZ3t9YJujtI4hjVpw2v3LkDJ8ZPcRro5OYPVPRyVyJ3zj5Ev/4ve8x266jgJnmBjXPIYzjPRVX75nwGNLeliTcDk3oaJqOqd39QhOCXbVsErMwjaws7ziO3rhEvHDn+SVz2mleAg2dnHHrPvs5pifYH5iWzviBAaaODPPeWzO7jg+DiGa9y1s/vETghxw+PsL00RFK5cxdO1u23U4Y4XR95q6tszC7wfWra3xw9joba3tsQ98GsQpRKiJSAd2oRqyiLWL+BI8P4iimut4iCmP+8N+f5akzE4yODzA6USKfT+1aSwO9Lpkwol7rsrxQ4+ybV3nvrRkWZjf6Iju2bTA4lOeZFyYplNJ97RNiVFwniuaAG/dAIQS6fpj99IoWQmBaBuMHBpicrtyVzARhRHW9xcJcdccUnhAJwTt+aozsA6idepCI4phzGyssdZq9WpUEE9kCLw1NcKw4SM607igAFiQ1QqamY0gNTQjOlEe5UFtlxdlZ42g7LHaafFRbo+G7W0RFE4JXhyc5Ux5lKjdAzrwzVaYLDb3XJn96YITVbpuL9XU+2OivpOBuyBomp8rDlOzULd1lg3aa0XSOkVSWhW5zyxpIKcXJ0hDHixXS+o0Fhq3rHCsOkrppG34c0w18OqFPwez/fHli1/wEjx1ET/HqwFSFk09P8JN3ru2o97GJKIp5/51rrK81uXpphS99TXHkxAh2ykTTJFKKrW0LkpV30s6bqMNGUYzr+KyvtXjjex9z7r1ZLn64uG0njZACTZNYlo7j+MTRLvNTEG/5wQlC5RDzxNDwUUKITTKgEQTRLXVZvheyttLgd3/zTeavr3Py6Qmee3maA5OD6EbSCHDr+ZQU/6s46ciJIkW76XDt6hrvvzPDH/7Ou7hO0Nd5DJAvpjk0PcSJ0xN9ig0qlOoQRquIaB4hLG6UBUhM6wu91/YXBw4NcmRljLd/dGXb96MwplnvMndtndrG3R/iuqGRzVocPjZCKr3/83yQCOOYd1bnqXrOFtEQwOF8mS9PHKVopXatGUrpBpO5Iq8OT9IO/HsiPNdbNc5tLN8SlTGkxlcOHN0iXTtBCMFYJs+pgRFeadc5X10mug/5laxhcqo0jHGbHIKp6eRNm4lsgWWnRdxzQTc1jcP5MgeytwZBdCkZz+Qx5a10pRsGtALvCeF5gk8GTpyeIJ2x+NNv/YTqepsw7K+AbmG2yuJclR/++QXKgzlGxkocmBxkZKJIOmNhWjqGrtFuubiOj+MkqauZK6tbRZibraR3i+kOVnIcnKrw5Z85w7/8v7/P3LW71zEAIMDQ0rhApHw0LOTj7937iUYma1MayHD89Djv/OgKtW2Kb5WCs29e5exbM3zzn/2A0YkSYwfKDI8UGBopks3bGIaGpks8N6TV7NKodbl+dY1LFxbptL07yNRuMEydFz91mF/8W6/uSVk5DK+iyTK6cRLL/ipSFmHL/ubBnGvHnhpHAb/9r36E74XbFiTHseIH3/mQnbje2MQAZ54/RDpt9RnNenwQxDHfW5phzblx/uQMixOlIT43Nt13/FYg+OmDR7nervH22vye53GpscFbN33OlBolK8UXx49saev0g6l8ia8dPM4/++gdInXv0hlp3WQqP7CtaGNKNxjPFHh3fRGI0aXGdH6AvHVnJEwiyBoWlq6jC7mlr+TGId1wbwbMezcPjWKCKMIPQnRdS1QrpSRSyQo5jGMsXccNQ1AK2zDo+j66JjE1DScIMXUN2WuJk0KgSYn+CP1hnuDxhK5LypUsv/Crr/Bb//IN1ld3rgG4GUqBihT1WgfXCVhZqmPbBpoukVIiRKKrE8cxURjj+yHdjofnhbumHOyUwXMvTfGp109QGcrfUTi+/YQSVXGpaZgyTSesPtHhecRQSpFKm/z833wZzw346PwCa8t3nmOq17Ibxoq15Satpsu1y6tYto6ua4hepCeOY8IgIgginI5Pu+UQRfGeNEqFgK/+/LO8+KkjW67k/dUnSLLZv0+sGijVwXW/hVAaQhbQ9UPoxkkS8rO/91nD1CgOZHj6+UOcO3sd19n+ARTtEgEdGS/x9POTvXqjvzyEJ4wjuqHPcreFG9049ulCmeF0Fn2PxzLcq6fJ6ibt8HY9pe2hlMKLQmpel/WbSFfBtDlWrGBq/faZJcgYJqPpHAXTou65dwg49otNwcTtoluaENi6sTUvTQgG7DSGuFNBefNvQyRcI+zdn6NYbdv2vxP2THg6ns96s0MYxZiGhqlrmLqOLiUtx6PedSimU1uNTAJ3yyBRAV4Q9oqMkr/TpknWNtG1+xf6CoMIz/WprjTJ5FOkMlZimeAGSCkwLZ04VoRBRBwrLNsg8BNbAqXAShloukYcK5y2i5U2tzQT3K5PFEYIKcnkbDzHR9M1TEvHzlh/qS7SvyyQUpDOWDz74hTvvnmVOI6p7uLfczsCPyLwHVpNZ1/mpGmSI8dHOXnmACdOT6BitWVF0M8qXggNTZqYWron4/AEjwpRFIOAw8dGePq5SaIoptv26LS9u37GdQNcd2+ryn5h2QbDowWee3maQ0eG9uTcLgDTfI4oWiWK54mjFaJ4DRGvo1QbRYiUZaQoImRx3+5XmibJZC1Onhrn0oeLdyU8O8EwNQYreSanK9vKaCgVA5v/9H1RjN4v+HFEO/Dphv4t6Z+RdI6Cae/pexZCkNZNcoZFzrT6JjwA7cCnHfg4N7Xopw2D8Uweyd5IpCE1MoZJwUzRCQPC8N4IjyYlGd3ctkZRCIF+U+RHCkHWMNF2iO7J28iwUop4j2Rsz4RnsdrkjYuzZGwDQ0sIT8o0qBSyzKxU+XB+hamhAQ4MFtGk4PpanSMjZeodh5VGm5Sp0/UCojhG1zQmB0tMVopk7PsnPN2Oy+LMOt/+5hucevkwh06O4nV9lmY3sGyDylgRzwmob7QIg4iRA4OsL9fxHJ8oiBifrpDOpQj8kMsfzHHg8DC6qROFEXOXV2k1Oklh3bOTLMyskS2kqIyVmH5qfPfJPcE9wbIMDh8f4ae+/ixvfP8i3/mDnzyyuWha4vP1t37jc0wfGaI0kHSTpDMWhqntXNQswNKyxKKOQGPYfgpDpp4ULD9CJFE9HyklP/3zzzF2YIBGrctH5xeI7vEmf68QUlAZzvNLv/Ypnnt5OjH+3QOSR62G1EaQ2hCadpjA/xFhcBHf+y6u8/sY5vOY5ouY1uv7Ovds1ubVzx3n2996n0Z9947K21EsZRg7UGJyeuiW128sIAKU8kE5CFkEHp31ze3oBAErTvuOaryRVJbCHtJINyNnWgyls1saOrtBActOm85t6Z20bjKWuTebFCEEI5ksNa+Ls8e00SY0IckY5l3lXW7mNoJEh0fuQGbFbd5eastts3/smfDEShFEEW1XcXR0kJRh8NHiKuutLm3HwzZ0bFPnwGABQ9NYbbQ5PFJmbr3OWqtDy/VxveQLzNgaBytFStn96XrKZFMcPDLMgaPDTBweojSY4/vfeo9Xv3SaZr3L+TevkB/IUhktUhrKMzRW4vrFRUqVPE+9OM0Pfu8sQxMDpLI2hcEcs5eXCYMIw9B5/Rde4N3vfcTKXJXL5+b59FfPsDxX5eL7s0ydHHsS4XnAeOUzRxkeLTI2UeI3//kP8f3t6wUeFPKFFMdOjfOLv/oqT52ZwLrJxXlotEhlOM/C7N01RlDgRR182SGIu3hx6x4u1yfYT8SRIvBDXMfHtHROPzvJf/Xflfln/+RP+fj8IitLe/dLuxdYtsFXfvYZnn9lmudfOdxfivQOKDzvzwiDj4iiWQQpDOtFTPvLpLVfRxHiOr+P6/zRvhMeyzaYPDzE1JFhAj8xRd0LXv70UQ4dHtr+zbhKHM2gonmEHEEYJ0E8PoQn6EV4bq/1y5kWtnZvTu+WppHR93KMik7gEdwmEmhKjYJ5b4sqgSBnWFtGonv/fEJo+q5fEklk6UE/Rffulq5pFNMppoZLGJpGFMeMlvKUMiniOCFDpWyKYjqFJgXHxiqkTIPhYjbpt4+iXo2EwDI0ihkbc5/cuaUmMCydMIhwHR+366PrGhsrjeT/DY04ijEsnVTGQjc1pJToho6dNgmDiPpGu2emmeTjlVIgYHl2g27bQymFpkvWlup0Ws6eWp6f4N5hp0xGx4s8/8ph6tUOH3+4wNJCjXbTfaD71XXJgUODnH5ukmNPjTF1dAjbNpA3hWNLAxnyxfTOhAeQQhKrkCB2COIu6j4KAp9gfxDHCsfxMUw9iQIP53n9p05TGS5w6aMlPvpgniB4MOQ6lTYplbO8/OmjQ2D7iwAAIABJREFUPP/yNJOHK3tKY90OFdeQsoQmKwiZQ9OnkXIQqQ0ACk0bR6nd1Z33iqTTTXLk+AjNendPhEdIwZETowyNFLZNZyE0UC4qrgEpUPcnDbHfiFSMv43Ss6lp9+SwDoky816EBxWJd1Z0W3pHCoGp3RuJECSE6V6tJaQQd6Sgdt3nHgjSvWLPhCdlGYyUcjw3Ncbsep2W4zE1NMDEQAGjZ0Z5M46PJZLolXyWwVxmq57nQUREhBBJAaGU+G6A5wYUB3Ns9ATjioM5UGDaBoaZnFCZnI3du8nYaRPfCwiDiFTGxE5biV+VbbA4s0bgh9gZi+JgjrXFGgCFcpbHyW/rk4xCKUOukCKdMcn8ocVP3r3O3LX1pNA4jPpu+e0HpqljmBrZnM0zLx7iSz/zDAcmB7d9IBUHMhSKOyvDIhIdp4TwdAlit2fk90SH51Fi0+8pm026rUwrEb+rDBeojBSobbRp1Dq4bkDg763bajsIAZquYdsGQyMFpo+N8PO//BLlSu6+DUvjuI2uT6Ebp5CyRFKgHBHHbVA+UpbQ9eP3tY+dcOypcVaWGnz4k7m+CKIQAtPUmT46TLlyN2NTneT+GpHU8DxeHnRxz5X8dmhC9m1JcTtkrzh3Lwh7ml63bkegC3nPjyfjPghPkn56/O5reyY84wN5xgeSk3NqaGDPO3zQX4GmSX7h730eIZMvffLoyNZNaotkbf5HCF776jNbf3/pl1/pbUUl15a8aXCsNplaT8Plpm0+fr/rJxZCCA4dHuLX/9Mv0mp0eeeNK3z32+e5PrPG8sL9pyA2H0gvfOowz7xwiKefn2TqyPCOzs0jY0lKa0coCGKXLnW6UZ2iOcmTE+fRQylFp+0yUL5V3ffoyVGmjw3zhZ8+zff+5EPOvTfL+2/P0Kh17ivaY6dMjpwY5Stff5ajJ0Y5dLiyT4s/RRReTwqUlY9hPoeUBaLwGq7zW/jeO0kNj/XqPuxrezzz4hTLi3V++J0LdDp3L/zeRCZrcfTkGEMjRdKZu5A91UbICppZQOhP8bhdM7qQ2PLOx+h2EZd+oVBbYnz9wpLGlnryJiKl8KLons/XaFOa4xOEPROe+7k4H1adi9TEjf1ttofdZf83az5svq0Ut7qJKwU3bfNm/47bt6mU2lq597ZwS5X81NFhfuXXP8NXvv7srscxOlEiX0hvOereXm1/t9djFW/tfa8V+jfjKz/7DC+9dgSnu3O3gGFoiWnnQ8DmsUgJ2VyKZ1+a5uD0EM16h+p6m5nLq6yvtWjUO9Q22rSbLp4b4Hvhlo6PEALdSFbZ6YxFNmdTHsoxPFpkcCjP2IEBhkcL5AtpcvnUDYG5u+DYyTGGR4u8+tlj274vpUgcptMFml4eS2b7dkwXQlAazPFr/9Hn+dm//uJdx2m6Ri5v0yDgg5kZZusNXp86hAK6QcBCs8lYLk8QR3R8Hy8MKaczpAwdTUpW2m1EWeflr51k+Okh1jodpBBUMhn8KKLlefhRxFAmS6uo8VZ9maszLcZyOaQQhHHMSrvNSC5HSjfQpODSxgZF2yZjmkRxTM1xMDSNvGHxK//wS6y12jRdj7bv88XpafL2jSJPw9TJ5R+8ormKFZ4b3hEdFCIRlszmbF797DFOnTnAT/3cs1y/vMLyUoON1SZrKw1qtQ6eE+B5yTkmpEiMR02dXN4mk7XJF9McmBxkdKLE4FCekbEi5UqOTNa6JTV6vwiCD9DiMUAS+O+QyvwtlHKIokWy+f+cMLhE4L+NaX1+3/Z5M5L7QJEzL0zyxg8u7eoVlsuneOHVw1j2Do7kIgNqmTiaRcQNpHEKxONj66NLjZR+Z61ONwzw79F404+iPenLCARp3UAXt6bBwjjacinfKxSKbujfc0v644pPnPDgtqSmjwe+Ugov9olUhEBga1YiuqRETzMoTirIFUQqQhN6T1k1RgptyyYAYN2rYkmLtJ6iGzpk9Qy61IhVTCZvkclXmDyapPo2xediYmIV9/y/RG8fyQkcqJBW0MbSTCxpIoWGUjFe7ONELnkji1TJdsJeXUgYh3ixT8HIEccxcY+ExSpGExqG1JHILeXf7UKX4wfLjB/c3dLjYSHwQ5yux8ZyE6frEfhhr84qkSQwgKxtoA/nqVRycJw7CE+37dFudFma3QBNQhAm//wQggj8EOUFjIwUkzqvPoTfCqUMhVKGg1N3d7RWSuFGDXRpY2uFRHW5rzZ2gW0bHDkxuutYpRQLzSYtz2ep1UIBK+02Vcdhw3FAgRuFOEHAYCbDRrebEBDLZLHZZCSXY7hcws1LRrgReVBAGEVIIThQKPLj+Tm6cUAZmG82e+dssrZYabdJ6To5y6ba7eIEASnDQAiBH4ZkTQthCSrHBhhkACcIuVKt8swzU5TT6V2Pcb+h4Eat3m3YVGEeGikwOJRnMoqpVHKsLNXZWGuxutKkXuvgOT6eF/YID1uEJ5u3yfYIz8TBhPCUylnyhQdF5GKEzCBlAc9/D6W6KAKU8tCNp4nCJeL46u6buQcIkZwD6bTJwGDu5nXmtpBSkM3ZHD0xuss1JlGqg4qWUXEdoU8jeHwIjym15Jy+7YBbvneLLs9e4EUhnWD3CNnNyJoWpnbr9+hHEc2bbCb2AqWSY9irzs3jjodGeO52Q3lcoFCs+1XcyEUXGqP2CJ2oi0RiSB0v8rC1RMK6E3bIGlkiFRGqEEtaeLFHFCdk40cbbzGeGmMqM8nl9lWOZqfJ6hm82MPWrOQEVL2iMmkSK4UXe7iRhykNNKnRDbuktTQKhRt7XGheZMiuULHKpDQbL/bY8GosOEsczx3F7ukYJcTIohG0WHXXOF04gRu5+HFAjMKJHDJ6mpJRxJTGVk2VFI8391VK0Wp0mb20wrd/6x3mr65SXW0mKYZIoZsaqbTF8ESJp16Y4sRzB/nsV8/csZ2Zj5Y4+xeX+Kf/8+/iAy1gBbhZGF8IwT/+5t/n4OEhsvv2cFI0giV0YZI3R+mE63fk3PcDo7kcG12Hlucxns/z9sICi60W4/k8C60mXhhiSI1fOnWKP7l8harjULDKOEFCwCRwpVrlq0eP4kcR3758mcF0molCgfF8nrFcjg9XV0gZBp8+eJB/8d77BHFMKZ3il556in934QJKKaYHNAqWzVqnw1KrRSmV4kSlwlAmQ86y+N61a3x68iADqRSz9fqjy/f3BFN3+ykSKwmNycNDTN6to+gRwzBOYlqfwTBfIvDfBRX1inw1QIIw991E9GYk0W36SqGYls7AYJannjmwi5q0h4prqGgh6c5Sm5HRezlf9v96SxsGQ6nMHefvitOi6Xt3llPsNLve2Hbgs+72394vgKFUhvRtkaZuGLDYbfXsc/p3Fd/MHKw6nURA+BOEh/aUSwT/QjZWmmTzKeyUiXlP7ZcPBgpFM0iMzPzY58PmRWp+HVOaZPUMKc3G1ix0kTjNNpudpN5DaEQqpGwOkNHTmNJkyEqISd7IIoTgQvMiALrUcSIXgcCQOkP2IAdT47TCDu/Xz2FJC9EbN2IPcbF1lUAF6EKjHtRxIocNb4OJ1BjvNc7hRC4paXOh+RGHMpPkjAxzziKn8ycI9KC36hJUgzqNoEVaswFBx11nrruArdmMp0YpGLvUnzwGeP9Hl3nrzz/iT377HVzHJwpjVBxvpSLCKMJzA1r1LkNjJdyjw9tux0qZlAZzTB0fpd1ycLs+nuPftzFoP7C0NG4UoSvFqH0aU+7/w0cKgReFrHc7XK/XKdo2sVI4QcCxcpmq49Bwb6weVa/oMmdZ1ByHludTTqV4b2kJpRSD6TRCCAxN2zIA9KOI9W6XP7p0mbSZiIXpUvJHly4hSKT2P1heIW0aBCreih5amoYhk1LOYsrm4/V1orhXZ/BIi1E/KXUKEtf5Q1znD4Aunfb/DkQo5RH4Z4nCa8Rx/2rle4FSiiiMWbi+wY9/8PGuDQTHT41z6tmDu1tnCBtpPI2QZaLgw75b0rd7uCuVpHn2E6bUEl+oTIGlbnNL+O9cdYUXKxN7pmZ132XNabO6Ry+trGExlMownMpu+XBtuF3Ori8QxDHWHpqJvSik6nZZ6jTvOUr1uOKhEZ5mrcPS7Abf+Z13ef6zxzh0bISxycGHtftdIRCktRT1oIkTuUghKZh5JBJNaFiahSWtJBLk1WAzGSTAEDoZPU3eyBGrmLSehObbYYdm0OpV64teCspBExqCFFk9gyaSVJcTuYQqwpAGOjols8CKu4YX+Xgk7Y9e7KNCxYq3ihO6RCoiljGdyOltV1Lz67TC9ta+ncilGbTohB0GrQGqXm3rWKtBnWG7ckex2+OEzdXJe39xmfPvXqNZ66DpkkPHRhg+MMBAJY+mSeIoJggiWrUOJ549yOjk9qm4fCnN9Mkx/tp/+JmkI89PJAzOvT3DlfMLNLbxU9ofCFJaCUOkUcSYMo0U+r5GNjZv8uP5PC9PTFC0bQ6Xy4wFST1BJZOhks3iBSECOFIewI8iSqkUacNA9aKONxdNbm6zYNukjWSBcmp4GCcIsPVk/rKXzoh6VjFRnNjPbMpWxCSOxwOpFJauI4Xg9NAwsVJEKmaikCdlPD6Ln7+cEFj2l4jjKkq5SJnrKRSHKOUSRYsIWcLQxh7YDBbmqiwv1mk1dpeKODhVYerI0O5RB+WjomXi8GrPG0ynnwhP4j5+633Nj8PESXwfC3FFrxPqaHGQVujhOAnhafouC50mVxsbHC70VxaggAu1VZa7rT2Zdm4K8g2ncxzKD2wRHj8OqXkOlxvrTOUHKFr9LbDW3S7naysEKvrELAU28dAIT2OjzaVzC3zrX79BJpfktR8nwgOQM3K0ww4SQckoYGkWSsVEKiKrZ7E1Gy/yWFFrZPU0sVLExGT0NAUjT87I4UYuOT2DROJGLlEcYetpNCHx4xBDGphSJ6XZZLQ0MYqwpy2hCQ1bs8jqGYpGkYyeIVAhQRyS0pKTVQhBJ+yS0pP0miVNEIIYRRCHRCrCjdwkxaYigjjYqkvK6zmqXo3/n733jrEry+/8PufGl2PVqxxYgTk0O7BznO7RaKKyV4OxhZV2JcOyBWthYHcN28AubHgNY7XGarGyZe0KsiSvpJmRNCPJM+qZntTd04lkMzRTkZVzvVcvxxv9x331WFWsRA6bTc70FyAJvnvuufmc3/mF71eVFMJqiOVGBoFo5Qrdj3BdL3fn8tkppseWQHhK0ocf2cfRU/sYGOlAUWVsy6FeNViey9HVnyDREd2yv1DETyjiZ2CdB6hebSArMumF/Idm8Agh8MmRVjL8h4nucJiusJdHkQisJb17RYfrJ5ihhFdlud6Ts+aNWTN4tsrtOtTe3gpfrFFM7Pb/zTjQ3rbjMX5c4T0LC9u1vNwnJESTnwlcJBQQnpyCi4sklKbhArJQsd21AgKBg9UMVUgoQkNoj6G4DSQshBTHdi1c10C4Zeq1b4KUQigDOFhI7g6JwneI6Yk0i/M5DGNnb6msSPT2J+kb3MP471q4zhKOfR1ZfXzPciyq5HkTFUlq5aHULYuVerlVfXS3rl+RJA4nOhgvrrYEROu2xVwlz4XVJQYicRSkHY/nuC6mY/N+ZoGFPTIsb0ZXIMJoNMk7yzOAtwCpmAbnMouEVJ2wqu/IDeQ2FyCL1SJn0wu3XSn2IOCeGTzpxQLXzs/sLcD7EUAgSKgxEmqsxY2yHUfKaHio9fvmNkE5wGhoqPX/Xv/NFdX6fg3H5FrpBuAlGKf0Nh5OnEAT3kpXCMGx6KFb9lt/vpv7BRgM9rV+PxI5CECX7+bkntBiZI0cS/UVDoSGCSsby3HvN5iGxdxEmlym1CKPfPnnHuW5T59g+Mitkh6jx3rv4Cj3J2fEj4LNV7PbNLHZ6NjL3djcZrf/77b/TwIst0HemGOlfgNV8hNS2/FJIVaNaSynQVzrQSBRs0s07BLtvhEqVgZF0uj0HWa+esGrIBMqWWOGul0mIMfpDz7CTOUMbfoQbb4hiuYyy7WruEBc7wPlGRZrlyiW3+RwNExU60IVvrt6be/9cIzrVxd2bCNJgt6+JAND7Xur7JQiCKkNSWpvaoI5e/pWBRDT/XT4QsxXvTBepl7hneVZVutVZH8Q3xbVVXcCTZL5zMBBTq/McqOw2vr99Mo8y9Uyp1K9tO1yvKplMlvK82fXz7N8hwbP0WQHtuvwp2Pvt2YK07H5Py+9jSIJYrqPdv/O4/1cucibi9P8+fXzt+VlelBwzwyebLrI5NWF+9XeWVeRctN42Pzv5u3btdkKm/vVJJWh4EBrm+u6qMJb3bXaCbHl+aw/9k7btzuHiBrBJ/tQhIwq3d+hBMd2KBVqOE2FXCEJugeSBMK3J8z3k4Tt1Ib32v5O9rndY+61zY8bDKfCbPUcuhTEdGsUjDlkfRBVaDjCJNOYIKEN4mBiujUUSUMICcOpkWlMYLkGhl3BdV0Gg08wWzmLLGn45Qiua+PiYLsG89WLdPj241diqMKHg0PVygESEa0T+S7KM1imTT5XYerGCpmVnXOEVNXjuIonQ3t6/o5xDtcpgEjgOsvgGuxmKq/12xuMcjiRahk8luOQb9T4nfM/4NmufRxLdtIXiqHLN8V/65ZJxTKpWSZls8FQNIlP3nmalISgOxjhiY5+apbF6fQcADXbZLZc4H9891u80DPE4UQHB2JthFSPfsF2HTK1Clfzaa7m0nx/YYJ0rdwS0iybexcPBYhpfoYjCV7pHeXt5RmKZgMXyDZq/KfrFziXWeTTAwc5kuggqvnwyQoOXvgtU6twKbfMN6avcb2QoW5bhFSNumX9WJWmf+gGj+u61GsGxVyF7C4fw/2A3YyGO/UE3GKsCEFY3d27cjfPZ62tJqlo97mhs4a192ctCVIAgSYr7sf4GA8avLCBgUsACRkhJGpWHts1m1QTFdZrrDXsMqrkw7VtVupjRLRObNekvk6LzQu7WzScCg27jGFXsNwGlmtguyayUNGkALK0Js7ocjcTtRsNi5mpDPl8lUZ953CWoikcONJDKLJX75LjqbtLMRzLAbH3casnFOVwooPvLUxgOU5LguG9lTkcYLlWpjcYxdc0eBzXpWaZVC2Thm3RcCw6A+FdDR5P5VzlaLKTotHgeiFDyWjguB6Xzen0HLIkWKqWmC7lCDcNHst1WK1XuV7IMFFY5XxmgZCqEdP86LLMpdzKnq8VPDmLhC/As937mCrnMEsONdvEdGwmiqsUjTo+RWWhUvQMHkXBdl1KRoPVepVr+TRn0nNevp8vQH84zo3CKtnG7QvC3q+4qwbPWjKY6zSDL66L60J6IU9mqUAx5904x3FaWlXNPdlstXsEXruT5m04ZvN4Gzu6yRGxHVngeji248Uu3eY5rGNS3v0YokVeuOfzbtZxbtnvDtew12O4bvNYd+HerO/TcW6W8sqKdJOgEa8ib+fjiS2Zix3HWXe+3m+mYVErNzZUfQhJwnbcde/PxmNIkrQjM/K9wF7uvfdubf3OrCVrO3bT0JN2uG/r3tm1fjaQb25u69zsUxJiA/nmx/hwIUsqEbUL06mhSQGCSoLl2pjnyUF4OTy4yEJFkXzkjFm6/IcRSEzk/poXO34LXQqy2phkvnqBml1Al0NUrFVKVhpNDuKTw4TVFOn6DRRJJ6H3064P47gWhlOlYq0SVlJIdyF3z3VdqpU6Z96+sStBqSQL/H6VYw8P7JmLSFKGQPhB6F4Okth7RenBeDuSgD8Ze59Co47VJGSdrxSZn7zM15vtNEnGxW0ZRQCyEEQ0Hy/3jpDw7Y0f6vGOfsKqzpn0HB9kl6nbFi5QMht8e+4G35670ep7La9uPWQheCLRSV84hibdvsEDENF8/NzwUS6sLmLaNlOlHC5rOUUF/nTsfWCNisQz8tYPTQLoD8U5nuzkue59/MnY+x8bPNvChXrN4Jt/8S4r81myKyWWZldZWSxQK9/M3P+bP/4h3/jzd7YV3uzoTfDEy0f4mV95Bn9Q37LNGizLZmU+x9uvXWbq2iKz4yvkVsvguCiKTLQtxP5jfYwe7eX4EyMkOyJbi9Q18fU/+SHvfvcKE5fn+dlffY7jjw+z/1gfU2NLnH1jjMmrC0yNLVEuVL1yXV2hu7+Ngw8PMHKkh4ef2Y8s773q6cr7U0xeXeTK2Wlmx1eolDyiPFwXX0AjGPZ5ZdSHuhnc30nfcIp9eyChA08N+oP3JryE3+tLzNxYoVKsI4SnJ9bZn2T/sV6GD3Xz6PMH90SyZ5k2V8/N8Oe/9xozN1aItYX4l3/wa8SSIWzLYXZihXdeu8zU2BJzE2mKuYrHauzXaOuKMnqslwPH+zj14uFb+v72X55m8toii9Or5FfLVIo1ahWDWrXRGkyNhsX/8c+/jKzcatRIssTggS7+s994kRNPjuzpHn1YaNRNrpyd5v03x5ifTLM4k6VUrKEoErpfo6M3zrHHhhg52suRRwY33Ps1g+97f3OOP/rX36BRN/nULz3OYy8c5Mij+2451lf/ww84/f2rTF9fAuDZT5/gs196iv4t+GJe/cp7fP2P3yS7UuRz//nTPPTUCEceubXPj/HhwCeFGQ493cpFEUKmTR9e1+JmorLj2khCpm4XsF2T3sBDaJKfgDJEQhtoTlRus1JO4an2f4iEjCRk2twhHLwFgSwUBDK9wYfoDhzzEpz3mPy7GyzLYTVT4nuvXqJa3pksr7s30TR2AijKHo8vQrjWOI414SVzS1EEezNAgorGgVg7v/P0Z/m3F95kLJ+htAWhn3GXStV1SeZIooN/+8wX+J3zr/N+Zp7x4q2CwlvlxqT8IZ7qHOC3jj3F1Xya1xcn7+gcBBCQVf7pyRd4Z3mWvxi/wBuLk7cc093mPF7sGebFnmFe6RtlqVoipN4/yvR3A3fdw9Oom7z17UuUchVq1QblQo1qpbGBZrzRFPbcDoGQj3rN2LV8cGE6w8yNFd557RIz4yvkV8sUs+XW5ChJEqVCjWq5wdxEmusfzPHi507SNZAkEt9a7LFRMygXqhSyFVYW8szcWMYyLL71l2eYn0yTTRcprJZpNLzSXlmRqFUMivkKM9eXWZnP8eLnT+IP+rb1Mji2Q6VU5/VvXuDK+9OszOVIL+Yp5CqYTSFM1wVVk8mvKqyulFhdKTJ+eZ6+4RS//Jsv4w/qyPLW/duWzcJ0hstnpjnzxhgr8zkKq2UK2XKrgkJWZKrlOvlMicmri0xfX+a5z5wg3h7GH9jFyDRtyoUa2XSRRsPEth0ySwXmJ9N856/PMjO+TD5TppD3aPclyZNyKOYqyLJELLl1KG9+MsP4pQUWpjPUayZmU8h1M6dHtbx12askCcqFKuZWnp97AM8j43D9g3mufzDH+bdusDSzSjFfpVSoYjSs1r0oF2qU8lUmrixw/eIcL33hJOFYAE1XW7lbkiSQZIlirkJmqUB2kwr1mhcovZBjbjLdqjBbXSqwMpejbyi1Ti7FxTRs8tkyS7Or1CoGmq4SCN3dxNWPsTOEkJDXhWW8KkmlVZCwvhhCFp5wphAyPilMT+B4MyylINZ5Z1qharHOEBA0vUU3t8uorWPfrST9xbks49eWKearntd3B6Q6oxx7aABZ3rvcjWtP4TgrQB3ctZL0vUESAp+scjCW4oujD3GjsMpYIcNUMUvBqFOxzJbSuSwkVEkmoKiENZ1ok1snoOx9whdCoEoybf4gX9h3mEPxdsYKGa7l0qzUK5RNg5plAi5a81hdwQhDkSSD4Tgn27vpDIS5XlildoeEfy0aCd3H8WQnsiQYDMeYLuVZqZVZrJaoWSa26yKAoKKS9AVp8wcZiSZ5qnOAkWiShO7Hdd1dw3kPGu6uwYMXzsinS1iWjSRJROJBfAGNarlBrSkoF4z4POJBfet4bHt3jEgssK2r3XVdapUGE1cWOPv6GK9+5T1kRUbVZHSfp3K+1s4ybRam0syNr3DpzCTxthCyIuELbH/8NWSXC0yqMkuzWb7/d+dQVBlVUwhG/ASF50GxLZtCtkw2XWR2fIWV+SzHTg3R0SO3VNg3o1Y1WJ7P8dpfnmFqbIlGzUD3q/j8GoGg3nppbdsL/dVrBlNjS8xOrJBdKfHz/+gFT1l5G4dMLlNm7MIs3/36WS6+O9G6N/6QTkj2BkXHcTDqJlPXlpgeW+LGpXm6+hKMHO2lsz+5p3CiYzvUKw3qlQbpxTzvv3ndu0+ajKzI+P0afr+G43hstuVijWK+uu1KcM2w0XS19Wwcx8VomBRzFWzLAQHxZBhVV27xpEmSoK0zhu7/6PKTVpeLXHx3nLdfu8zlM1NouoLaNCzCUU/Kw7FdGnWDsQuzTF1dYuzCHIOjHew71EWiPYIkeyFCf1CnrTPK8nyOcrFGIXsrGZnRsCjmK5TyFSRJ4DgulVKd9EK+GS+9+Qzr1UbzOzQQAqKJINH4/V2l9+OIrYyNrXL81p6dLBR8coSYEtm2/V6OczcrEddCtjNTGcauLOxK3KmqnkTH6KHu20pWd+wVcCuAhIvFTcX0vfWhSBIdgRCfHjjIXKXA++kFzqTnWKqWyBv1ptaUV8bukxViup92f5B2X5ChSJLgbXo4JCHQZJlnu/exP9bGdCnHDxammChmWa1XPPZlXAKKSlTzcTCe4rFUH/sicfZFPJoIx3UwnB+NCFWVZPrCMbpDEXqCES6uLrUMvnyjjuXYCAEJPUBfKMa+SJwnOwfZH23Dpyi4rktc99MTjDIYjuMC4WZ+0VbQJJmkL8BA2Ku8UyRBaoeKMFWSSehe+7pttQwvRdo+ytDpDzEQjlFtGoNxXwB9h/Zb4a4aPJIkiLeF+N2v/7c3f3Rh7OIs3/rqe3zrq6cB+NQvneKRZw9weBtX+loOwnahIddxeeObF/jO185y/i1PFGDfSAejR3s5+cwoHb0JbzKuGsxOrPCtL7/H4uwqlVKdP/o3f08xX+WZTx3n0MmBHa/n6vujinBdAAAgAElEQVTTfPDeJI2aQSDs48lXjnLgRB9DB7sRkqCwWmFhOsNf/uEPyKVLVMsNrpyb4bW/OsupFw9x9LGtr+/quWl++K1LXD47BXgG3sNPj/L4Jw4TTYTwB3VcxyW7UiSzUmRuYoX33xgjEPIxsL+TeNvOk9SXf/+7XHhngqlriwAMH+hk9EgPp146TFtnFNeFWqXOhXfGefu1Ky3P1O/9y6/xyi88xs//2vNEk1t7wDY8BxdMw+b82+Oce+sGb337EslUhEefP0DfcIqOHu8DLuWrZNNFLr4zwYGH+hnaJiT3K//kUzjORoXeWqXBpdOT/N//69+yPJdF0xT+y//p84wc6SO5hUK5JAnkvbrL7zJs2+EP//U3uPr+NEuzniv74EP9jB7r4/jjw7R3x7AMi2KhxuUzk3z3a+97nrHpNL/zz/6CL/3WJ3n208db3sdQ1E/fcIorZ6fJpYueEbMOju0yP5mmmKviOC7hWIBSvkohW2b6xtIta+HFmVWK2TIIj3E6mYrs+i59jI8euhT+qE9hS9SqBmffHufN71zetW3/UDtDo530Dd6eNp+sHsCxF3HtBbDHwW1wJ9ISPllhJJJkJJLkF4eP3da+d4qUP0TKH+KxVN/ujdfBaeYT3Q1ICI4mOjma6LztfXVZ4V+cemVPbYciCX77xDP89oln9tR+MBznN48+yW8efXLP5/O/P/WZLX+/HQP6rho8a4mrqra+W7eZb3FzEpJkqeUt2b6vrX83DW9F+40/f4e5iTS+gMbJp0b56X/wBD372ghG/Gia0kqsHRjtYPhQN+997wp/88c/pFptcPaNMUzD4uCJ/lYi7VYoFWuoqkKsLcyv/w+fp3dfO9FE0POuAF19SQYPdtK7r50/+/evceXcNJZpc/7tG/Tsa9vW4FmezzF2wSOH6h/t4MQTw/zMrzxLKObFtiXZEylNdccwTZuTT47w4udO4rqeBs3avd6MarnO5TNTfPDeJIszGWRF4rlPn+DJV44wfLiHcDSAqsmeJ8526ehNcuDEAFfOTvEXv/9dKqU6F9+dQPOpfPG/fnnbkNl6uK7LX/3h6wRCOo8+t59f/McvEmsLofs1tObztW0H07B44hOH8Qf1bfOyZEVC2jRLm4aFrMjr3geBLHseq63eH9H6694ilykxdmGWy6cnyWXKBEI6T71yjJd+9mG6+70yelVTcJverr6hdoYP9XDm9Wu8+tX3KBVqvPXaJRp1k5/7tecACIb9dA+0ISRBbrVMZqmw4ZiO4zB9fZlKuU44GuDRFw7y5jcvUsxVmZtM3xISXp7LUcxXkWWJnsF2fEHtJ5MM5wHD/Vi+b5k23/zaWW5cW6Ra2b18+rmXj3DwaM/tX4uIAhlAIKmPIqQod/LSfhT38E6P2axz+EjPYS/7nVme53o+w+Vsmn/y8NMbmJxrlknDtjFsi6QvgNwkgFyuljiz4lWjvdQ3vEPvd3ZOu+GuB+jWVyqB9+CEJDa8o2uK4HdSSVMt15m5scLC1Cq1SoNYIsQjzx1g5GgP8bYtVkIRP4GQj1y6RO9QOzcuzZNu5uaU8lWCET+ysl0ujEMs6WfoUBeHTg4QiQVumWSDYS8817OvncXZVTJLBZbncxRyFWzLboUn1sOom1SKXh5KIOQj0R6he0vW0Zvu1I7m+eyU11SvGVw6PUV2pYhp2ARDOief3s/o0T46+xK3tA+Gfeg+z33Zu6+duYk0K/M5rpydplqqEwjpyNsklq9HejHH8ceHefiZA4we70WR5Tuq/Nn87gC3htYEzcqmO3t/PiwUcxUun5mikK3gOA7hWJhHntvP0MFuoolbvWWhiB9FkSkVqlw6PcnM+ApzEyuEIn6q5To+v4Y/oNHWGUUIqJYbFPNVbNtp3RPHcVmZz9GoGvgCGsOHu3n/jTHqNZNcuoRl2hsq1nIZzwspSRJtndFWvtCHAcd1mKosk9QjRFXv+mu2QcWqUTSrDAY7miXSG2G7DtOVJdr1GGE1sKE/23WwXNsT2L2P5VB+3FGrGqxmSpw/PUl6ueiJr24DWZEIR/yM7O+kfQuP7E7wFi8aQooBFkJqA+HjYyv9w4frutSb+U2W41AxDQKqhi7L6M28Hl1WcFyXG/lVTMdp7Wc6DnPlIoVGHcO2MSMOUd2HLsvUbYvlaom65uUIlU0DWXiM2Kq0Mxv13cADN2rkMmXOvj5GvWYgSRKxZJhP/MwjW04qa/AFNLoGkpx8Zj+SLFEp1ZuhhAymuXOstGewjSdfOUosGdraoyAJQhE/gwc66W/KFRRWy5QLtR0p1lsGgevlqXiJyu6OBo2seJ6xrYXxXKqlOm9/5zLVch1dV0ikIjz1U0dI9cS27TOaCNE/kuLUC4fw+TVymRI3Ls2RXizsmFi+Hv6AztHH9vHKzz+KotyZsfMgw3Vdsisl3v3uFUzTxh/USXXHefpTx4jEt68oSaQiDB/q5pHnDiDLEstzOSauLJBZKmBZNoGQj87ehCcnUqpRzFWwGlZr9efYDnOTaaqVBv6Azv5jfUQTIRzbIbviMVOvETbiQnoxT7lQQ1YkugaSu+Y6tUrjXaf55+b7ud22tT+Wa/P9lXPMVzOt/vJGmWvFWb67fBbbdTa0X/tjOCbfXX6f5Xpuw3EMx6Js1sgZJRq20SyndT9i0dGfPDiOw2q6xMWz05x9Z4JsZmeRS59fY3h/J4OjKRJbLUh3ghAgFCSlD1k7iaT0Ie4yO/TH2BoukK3XSFcrzJcLnM8sMVvKU2zUW9/k0bYOHmrvagkCr+1XNhu8v7LA6/OTvL00w8XMEivVyoYvdU2vb6FSIlOvULVuj2TxTvHAGTyF1TIX3hnHNm3au2IMHuxE9+++Ug2EfXQPtLVWu426yfiVBYzGzpN6R2+ch5/ev6s3IZYMbfAwGXWTanHraqL27hjDhz3JibGLs7z+jfN85Q++TyHbTMy9A9QqDbLpEjPXlzAaFm1dMR56ehRN2/3ehKMBHv/E4VaStWlYXHjnxt50pQRNMdgudN+DQWZ4t1Ep1cgseV5Dx3boG0px9NTQtrQL69HWFeOx5w+28o6q5Qbn3rpOrWoQbL6zmk/1VNBrBnNTaaymkW7bDjcuzVMu1ND9Kv0jKQYPdBFvD2NbNhNXFqiUvHfQBeanMhSyZU989UAngeDOk0fdMVioZXgrc4kL+QlmqsutbbbrULHqnMmOcS53gxulOdZYTHJGiQ8KkxyPDdGub61pBrBqFJmvZShaFRxcMo0CV4rTPBQfIaHd/JYqdp1rpRm+ufQu311+n3eyVxgrze56bz/G3ccH52b5//7qDH/wu9/aUzVkqiPCL//DZwmH98a78zHuD1iOw+nlef7j5dP86bXzBBSV/+uD9/j7mRtUre3nTM8zZFM1DRq2jS4rBBQFdYOGl6DQqPPu8hx/O3mF+XKxRcb4YeOBqjlbY91dmc/hOA6FXIWxC7P83r/82q5Ozmq5zupKEcvyPlLH9jwia8RuW0HTFYJhH+EdVulrUDflJLmuu62rt28oxcPP7Of9N69TK3sVTj989QPSi3m6B9ro7Euw72AXyVRk10qyNZSLNXLpUqvSyfMyxFpEfzueu6aQ6om3wleO47I8l6VR293qFkCqK0Yo4r8vcw3uBfKrFYq5Suveh6J+2jo99/1u98Qf0Gjvjrdy3CzTYmk2h2VYCEmgaDLJVBTb8og604sFugfasCSbWqVBPlNCUWXCsQC6XyPVHWNhKk0u7XFg9exrJ+IGcB2HbLpIpVxHVWQ6exI7GqiGY7FUy/LW6mUGAikMx6RkegRklmMzV0vzXvYqKT2OQGC7DqKZSyqEQELibH6MgOyj3bfOwyg842uulmGhlsF2bE4lD9FSXUdwNnedqBoioUdax6s3w2G6rDXv6508qY8aa+PB3Vhnus3+JD7sEE+tZlDIVbl8fob3fniDyRvLu3LuAPTva+Pw8T56B5N74vj6GPcPXFws16HdHyKoqgxHE7T7A8hCUDQaBLbRBRNCENV04j4/lusQ0/0MRBLEdV/rLc01aqzWqhSNBk909TEQid0zAeEHyuBxbBej7pUouy5UijUqxRqz47fPSOm6Xl87hZB0n1cqvpakvBMkWdpQVea5+7fuO9Udw3UHGDrYzcJ0hnKx5pUojy0xMNLB4MFO6lWDgdEOIvEg/oBOIKzvaLys5XisQfOpxJKhPU0MiiITjQdR1hiTHZdcuryr6rEHQSQR2rYE/ycB5UKNcummN88f1InEdq9yA1B1hUg84Bk8wsvTyqVL2JbTzFOSSHZEKGTLWKbN6nKhmctlNkv868SSYSLxIIoi09YZJRTx4zgOy/M5GnUD13ExDYtSvopRN/HFtGYOz/afv+M65M0ylwtTdPuSyELGaWrq1G2D5XqOi/kJPtX1eIu1de3dVIVMUNa5XprnUGTgln4bjslkeZGiWcEna+hNmRNVUvBLGmOlOR5O7G/tsz5h3SdpBGUffunerAj3Cm8cWSuZhpuGiAPNcmq3qXQuRLC5fU3iQbT+XePX2difWPfH9H53HVzqCBHAG8alZvv1wYWN4e9qxSPwdN1mIUmTZXs9S7zrelWwa2z4hmGRz1ZYnM/z+neucP70JJU9GDuKIjG8v5PDx/uIJz6uBHxQkQqEaPMF6AqGSfmDaJJMdQeNL0kIgqpGWNMxHJu4z09nMIQuK5hNgseqaZCueSX6Xzr4EAlf4J4tlh8og6dRMzboKv0oaHlgdujKF9BRd5gU7hS6X6NvKMV//7tf4tUvv8f5d8Y59+Z1jLrJ9Q/muP7BHN/6ymlSPTGGDvXwxEuHeO6zD6H7tg9PNeom9crNgUhVZYIhP3ta/QlQVBnNpyKrEq7rUirWtpZu2AL+oLZjxd2PO+rVBo11tPq6b++EfkIIVFVB96vUa40WX9EaiZuQBH0jKZbns1RLDRamvLyzetFgemwJx4G2zigdPR7/Rc++tmZIy2Hq2jLVUgOjYbE8n6dR81zRvoBGR29ix/J9XVIJKj5Cqp9rpRmOxYbpC3g5avO1DDWrwbHoEI/E96NJmxL5FT8DoU50Sb1l5Vax6sxUl5mvpvmFvuc5GR9tbQsrAQaCnWiSwlpWgBCCiBKkTYvR6UuQ1COMhHqIa/djqXYV12ng6T8FAA3XKeM4aVy3iGOnAQlVOwkiBFhembXwN8utJYS8Vlxg4LoNcKsgfAihgaviOHO4bhnHqeDYcyjqUSQpBSIAbhmEAsjg1hBSnPWFD2feHufM2+MYhkWiLUQgqOMP6Oi6gqrKSLLk8X5VDcqlOquZEuPXllicy5LP7V1eQAhBqjPKs584zGNPj+6+w8e4b6EIsSkctTfqR9H01jpbyOqEVJ02X5CornMuvcihRIqByPZ5pncTD9QstTlBsXeonX0Hu3n+Myduuy9VV+jsSRDcQcROkj8cnSEhBEhepc4nfvYRHn3hICvzOU7/4Bo3Ls0zP5n2uGtWSlRK40xeXeSd717h6Z86xvHHh5uVO5tJxbjFz78bU/X682m1vQNb8oGMLtxFbPa8tTS09rivtxNb3ntJEvTua+fK2WkKqxWWZlexTZtSrsrMjWVc16W9K0ZXn8dv0j3QRqwtjGM7zNxYolZp0KibLExlsC2bSCxAV39y9/daQH+gg/9i8JOt3JoL+XF+Y/hzKJLnOajZHifKlkb4NpevSgphJUBY8bNqFBkvLzAS7tn1HjVlx3Cao8D9Fz61aNRexatBVUHoTaNnbbJwcZwCrlvBbTSaH42EQMJxCgihI0ltqNJjgA/bmsA0LyKhg9C8aiVxMw/GdQ0cO4PpXkQI3QslouK6dVy3gRABVP0RJKnd2w7ks2UmbywzP5tFUWSPyXuTZqELLeoEy7Jp1E1MY+/M5ZIkCIZ9fOnXX2DkYNee8tg+xoMFx3VZrpY5l17kfGaR2XKBL1+/yMOpbg4lUoRVnZ5ghEKjzt9MXGG6mOexjl4OJ9sBCKoaBxMBXu4f5k+vnsd0HWRJ0BOMfOjf9QNl8MiKvCFspOle2ObwI4O33ZckCTRd3TW2fDfZSTf0KwSyIpNIRYjEgyRTEVygoyfO4swqC1MZluaylPJVlueyGHWDYMiHEILnP/MQkrxx0JcVaYOCuGM7zQq03SfeNZFK23JwHRchCVRN3sCdtPPF3ObF/5hBUeUN5fvOBmHcnbHmaVyr0vM8PnLLeBWSoK0ziu5XsSybXKaMbTvUKg1WlwvgusSSIRIpz+MRivoJRXxoPpVivkqt0qBaqZNNF3Ecl1DETyIVaVb3b//gDNuiYtXIG2UqVp2iWaVkeav8sOLHJ2tU7DpXi7MokowmKewLdmG7NmWrzko9R8mqslBbZaqyRJcv0ZRLkAgqPg5HBzEck+nqMh2+OIokU7HqLNWzlK0a87U0CS1Mhy+OKqlokkpQ8TNbWUETCjW7QW+g/Q6f2IcBF8fx+GKE8CNJnTh2GiEFEVIC117F072SARvXKTf3Ep4nBwkXG9c1EELHdWu4dhpH+BByO8IVOE4eSekF18B1K3jK4S4uDXCquMjgWri4zT5MvHCaZ/CYlkOtZlAq1D60u9CWijB6qIsDR3qIxAIfKXWE63oh1HrNRNeV1ni2WYS51d5xyWU92SDXcbxUBiGwLRvTsAkEdRRFwnYcSoUawZAPx3EwDRvLdvD5VNRmFe3ifI5gSCeeDG1gz39QIAuJ/nAMCQhr3vszGmsjrOmENR1VkonoOgPhGC/2DtEZDBNUtBZdRMLnpy8c5UC8naQ/gF/xvLZhVedQoh2/otIdjDASS9LmC6DdJmPyneKBMng0zaPpl2ThTdC2jWM7LW2mB+2lWoOiykTiQZ546TDuC4do1Awun53iB9+4wPileSavLZLLlHnnO5dJLxZ44iWvokqsIwbUfOqGPBrL8pJa9+JnWMvxMA0L23ZQZYVAUP/IGIsfNPj82oYSb6NhUd9FOXoNjt28903NMEkWBEI3ddgkIejoTeAP6limTWa5gGU5VMt1VubzuHjl7e3NBPVA0Ec4GiAcC5BeyFNq6sJllgrYtkMo6vfCX7t8KhW7znR1mTfTHxBQdEzHok3zKq7afTGyRoma1eB7K+cAiGlBegPt1OwGs9UVzubGKJgVrhZncIHnUydwcdEljYQW4fn2E3x7+QyT5QWGQ934ZZ3Z6jLn8+OUrAqXCtPYrsvT7UeJSQohxU+7HuO1pTNkjDzDoZ77zOAB3GbOjRBIch+2fRZcP5KUxLImEZIPiCJJMRzbwXVr4FpIchtCRJCkGF6ODjTlHXExkaUEoOCYc0jSMRw7A26luV/Ua2fbuG4dJB+SCCFJCQQSrmvdswRvVZMZPdTFZ3/+Mbp743tfMH1ocLFMh5VMiba2MJrqEZiq23idHNdlemKFbLqEadq0d8aQZUGtalAp1+npS+ILaBgNk+tXFukdaPNy44o1TMMi0RYmGNLRdIXvfvMifYNtnHh0kMAuAtj3IxRJ4rGOjZ7XzUSBT/kHeKpra7WCNn+QhC/A8TaP4VkSAllIpAIhUoGbOV2/OHr0Lp/5znigDB7RdJf2DKaYn1whs1RsufUfVGPnFgjQAxonnhzhyGNDTI8t8cY3LvDX/88blAo1FqbTnP7+VU4+s59w7Gb1WDIVpXvgJnlhuVBjbjy9QbR1OzTqJnMT6RYnkSxL9I92EAg9eB/qR4GOvgSp7psx6HymxMJ0Zoc9bqJSqjE/mW5V9Gm6wsD+jlZ1npAEPfvaCEcD4MLqUpF61SCXKTM7uYKiyKR64nT23aTsj7WF2Xegi8xinuV5j89mccYLacWSYfpGUrt6LuNqiHB0iAPhfmzXQRHSBp2b0XAvvzn6M5iO7Q1mkowmFHRJIxoLcjg6wD/o/0RroJOFDKpLhx7nkcQoqlB4pfNRXNdt9itIahGOx4b55f6XkYVAau4ngKgaJKz6+aeHvugJbn7kk+lmSMhKD7J6CElKYJmXkdUjSFIbktyF7O9mY/Lx+qRkedM2gRBhZGUIzfcSljWO65RRtCeQ5QFkeR/wCBsrtBxuJi1Lm/79cCGEV/jwy7/6HCceGeTQ0d77YjyuNUxWsxV+8PZ1BnoThII6uqZy+EDXlizyruOyslhgfiaLYXiGp6opxBJB+vf10dEdI71YoFpuEE+EmB5fwTQtVE3hU194mDNv3WB5sc7TLx1iYKid3oEk3VsQvv6kQADKfUYQek8MHlmWNrg2LdPes8t/PYTwDJ6hQ10szWZo1LyBf+raEt2DbXuqprrfsTZQyIoXJunoS/DoCwf52//3LcyG5wlYXSnecv80n0I45qdrIEl6IU8xV2H8ygKWZW9LVriGWqXBtfMzmI01JXWJwQNdHytp7xE+v0Y0EaKrP8nyXJb0UqGZUOwg7cIeWshVGLs42yII1HSVwQNdGyqoFMXzAEYTQVZXiqQX82SWC9TKDdq7ogTDvg0htVDER0dvHIQgnykjCUEuXcaxvZBWqnt3D48QAgUvhOy4LlLTAFmDLASSpKJISpM53fvdSzaWkYWMdstYJ/CGAe9cVbFx+JGEDGy1X3O7KxFQ1ozwj35C3QgJRT2BkBIIoSMrIwh0hPA1n//a2LT+vNcvRjZejyR3NEn2fMhyD65kNnNxNhcurK/K2rqvDxM+v0aqI8JzLx/hsadGSHVG7xvPsCJ7Hp3JmQz5QhVdV9BUhaV0ccN8dOrkIOGQDxeXSrlOW0cEWZEoFetEYn5kWUL3qciyRC5bZmXJ07RzHAfLcjDNBtevLFCvm+g+FUWRaNRNyqU6xXyN6B5oTX4ccT8YvZtxTwweVVM2DMi1yk3l9NtFKOJn+HAP737nMrWqQblQ5crZacKxAOqmXIrNWEsk9dzJ3HNuCNd1PWblpljKVrITm+EPaHT2JVofqOu4NOrmLSXviiITCPkY3N9JIVuhUqqzMJ1hdblIW0d027JxT5usyrULsxgNq9VPd3/yJ7rU/HawxoPTP9pBejFPMVtmYWaV1ZWip+y+TQWb0bDIrhS5/sE8juOgagqhaIDugbbWPmsJ0eGon2gyxOpKkZWFHLmVEqbhEUz6AtqGATwQ8tHWFUPgCbeCSyFXwXVdAmGdePveKpzWKi22S8MQQiDfw8l17XzuRwghISs33fuyvLVA7qa9tt0iSVGQos2+9+IluLfPQVYkIlE/7R1RhkY7eP6TR+jqid9X1ZqKLKGpXgVasVRDlIXHBL8ph+eho72Al6/pD+i0d0bx+TWmbiwTCvsJBPXWAmRt3NV9KpFYgHKxRrlcp5Cr4vOrRKJeibU/qCHJ0h6pPTYioun0hqIciqdwcVGFTETTke9DA+JBwz15O2OJ4IY45sJ0hrmpvbn8N6O9O8bznz3B1/7odYyGxy3yn/79t0l2RlBO9G+tp7UJpUIVy7Rp67w3pXDrYRoWjbqJbdlEk7vzU1SKdaauLbU8ALIiEU16nDmbEYoGePnnHmXiyiLLc1kySwW++Wfv8MLnHmKk+VFvhjfhzvH9vzuHaVikuuMcON5H92DbxxUWt4FUT5xP/OwjXHxnnGq5weLMKn/3J2/xmS8+SapZMr4ZK/NZrpyd5o1vXsC2HHpG2tl/vJfugeQthnCyI0pHb4KJKwtcOzdDejGPJEns299FcBOLbTQRpH84hRCCXKZEpVTz2ssSkViQVNe9f+8/xo8PdJ9CIhnmc7/4KCdPDdE7kGwaEvfXhCwEtCVD/Hf/1Sc5fW6KYqmOJAn2D3VsWCCEm4zjiirzqZ95uPX7kRN9m/oTHDnRDydoFXeMX1vi2qV5Hn92/wbP1ic/e7K50+17Op7t2sezXfu2uJ776/4+iLgnBk84HqS9O0ZXf5LFmVXGLs5RqxiomsKRhwfwBz2RSqNuUinXkWRBLBGivTu+oSoLQFEVYskQv/CPX+D1b1zg8pkp8qtl/sP/9nf0D3dw6OEB9h3oRA9oKLKMaVoUshUKuQqrSwXGLs4RSwYZGO3kF3/9xXtx+RtQLtZ49Svv8cNvfcDIkR76RzpJdkRo64wSblY1OI5LpVRnbnyFiSsLvP/mGI26iaZ7yu0nnhzFv4UsgD+gceKJYU69cJAPTk8yeW2Rb//VaRZmMowe7eXY48NegneTsfr6xTnOvjHG5NVFLMNC96kcOzXEZ7745H2QcHgv4eKwSZjVXSuA3hui8SAnHh/m1IuHuXpumpX5HK9+5T1Wl4sMH+lm/7E+4u1hLMumWqozcXmBN1/9gLnJNJZh4wtoPPnJIzz9U8e2HNgSqUiLa+fq+RnqlQayLDFwoPMWaoVILEjvvvamPlcWIQT1SoPeoRTRZPAnTuvsY3g4eqIPXVeYvL5MdrVMqVCnkK9QLTcwTRvTsjHqJo7joCgyuk/FH9QJhnTCET99A20MDLWTavI+xRNB/AHtvjR2oGkguC6qIrN/uAPDsHBcaE+GNvBDrV/Y7XYdaxQea99QR3fMm79kacP2NYfbndyX7bQS50tFrqTT5Go1fuHwkS3b5Wo1vnrlEl84cIj24N7ITwFWKhW+fu0Kv3D4CDHfjy4D8s7cHNdWM1xJp/nnzz5LRL8/0iM+dINHCM+N2NXfxrFTQ6QXc9SrBktzWU5//yqZhRyaX0OWJI9QrWoQiQc49NAAyY7oLQaPJHlEbUce3UcxV8VxXK5fnGVpNku9YlCt1JmfSqPpKpIkYVs2lVKdSqlOIVtmfjJD71A7seRHQ1xmWw7ZdInJa4vUqwYrC3kvPyMeJBDSEZLHdFyveduW57LMT2WQFImB/Z0ceXQf8bYQinqrQSLJEsGwn4eeHkXIEo2ayeJMhvFLC5TyVfKrZUIRPy4uZsNibiLNxNVF8pkSuk/j5NOjHHtsiJ597Q8odf/2cByHXKbc4jiyLRvLcrAth0bdYOz87DrdKZe3X7vM9Q/mW4rxsuIxacuKzPFTQ/gC2obwqaLKhCJ+Tuus168AACAASURBVL14qDnQwtJclqvnp8llSizN5ghH/di2Q6NmsDC9yvjleWqVBv6gxqPPH+TQQwMtPp3NiMQCLe9lPlPGtmwkWaKjN35L7pqiyl61VixAo2a0KsASqTDB8P0nAeK6LqvlKrIk4ddU9B9xAtV9Kj39CV75zAnqtZ218gJBnfaOCKr24XkzXdelXDe4vpzBtG0eH+7/0I61E9o7osiKTFsqQqlQo9qsPmrUTCzLxrYdTMNqKV7XbZvJXJ4DA50M97SR6ojS0RUjGg8QjQf2JFuzGbbrkG6kCcpBdFlDFjK2ayPwmJ9Nx0QRCiCwXS8cVHfqGI5JTI1iuRYgUIWC7dpIQkZCYLkWslAAF8u10KWbzPRCQMCvIcsSjYbVDDPdPO+gvHty901hZy+oumbw+Pwaiiy1PDlraQu7RRjdJiHfGrv1Tabt7Y0kw7bJ1+tkqh49RNlo4LqgyTKaLFNsNMhUqyjr8gZd16XQaOBXFGQhyNbrJPx+bMehbllEdJ1Co062Vm0SDG48ds00qVkWpUaDoKoS0DQCqtraVrcsyoZBMhBAk2WU5kI5outossxcsYDdLJxxXIdio4FfVZuCo4KGbTcZ3AV+RaFh29RMk4ppkPD70WSl1Wep0cBupoNUTJOoTyegarclS3HPAq6D+ztx3RO8+70rVMsNysUaZ1+/xpkfXGu1WXvYA6OdhCMBDj0yyFaKHUISjB7tRZYlEu1hlmezVCt18qtlsuki5354Y2P7Zr9CEkiyhCSLHWn1P0wISaAoEpKQWJjOMD+Z3paoTkievpAkS0TjQR559gBPffIoPr+240Dz+EuHicQCmHWT/GqJbLpIZrnApdOTG1gvpeb90HSVRCrMZ7/0FIP7O4nEfvyS7BzbZW58hW999TTjl+dp1A1qFQOjYWI0rI1J4C58+fe/h6J4+mi+gFd2runeird3KEV7V/SWfDEhCZ77zIlmkjjkVkssz+VYnFnl7JtjN/NKBa3n6g/qtHVG+blffY7ugTZCka1XV9FEiGSHpy1VLXuGWSjqp6s/iX9T2askS6i6Qnt3jNnxlVaJfKorTjh6f4o4Tqzk8GkKPfEIuvKjnWMo7OPwsT4OH+vbvfE9gGfQVfjbc1cp1RsfmcETT4aIJ0MM7+/ctW22UmViOcvvf+9dHnryAC8cGror52C7NtfL4/T6uolpMfyyj6pdQxEKilApWyX8svf8a83fM8YqBbPI4cgBSlYFAQTkAIZjoEoqspCpWBUCchAXh5pdo03XNuR7SZLwWMzLdcrlOms2huu6DPQnb1lYr2FtXF4jY3QdryJY0WRwPQkNRdFabV3HxTJtZFVqLXwQ3DSWxE3eM8d2UHUFx3ZwHAfX8ao0XW4aTduN87brslLxxJ3jPj+qLJOuVlgqlxhJJNDlpi6i6zJbKNAVDqPLMtcyGU52ddGwLJbKJQ61p1guV0hXKgwnEmjyemkTyNZqrFQqzBcLdIUjdIXD+BUFx3XJ1WtkqlUWSyUOtqdI+HyENO9eHGpvx3RsXh2/ORdbjstCqURHMEhQ09BlhVy9hu04KJKETwmRrdXIVCsslcvsTyZJ+gOtPpfKZWqmiSQESxVvu09Rd+UUW497NusnUmEi8QD/83/8R7z59x9w/YM5pq4tUshWWtouwbCfVHeMfQe76BtJbfsSrmHwQCe9Q+08/tIh3n7tMhNXFpi8usjS7Cq1moll2qiqTCwZItYWItUT59ipYQ4+1EfXuhLue4lEKsxP/dIpRo/18f4bY8xPZchnyxRzFeoVo1Vi7w9qtHXH6OxNMHK4hxc+f5JYIoQvuAddL0lw+OFBRo728sxPH+f8Wze4cXmeqWtLlAtVhCTQfRpdfQlGj/UxcrSHJ18+QiDs2/WeP6hwXZdirsL8VJrp68vArZTnm2FZtsdnVG00PV5esmajZrRyqjZDkgRPvXKEk0+N8uIXTvL2a5eZvr7c8iwpqow/oNPRE+foqSEOHO/j+BMjBCO+HUnaEh1hOvoSyE36f92vEW+PkGyPbCl/IisSw4d7yKZLnudKQM9QO7E95Lh9FHjt8g06okGi/hHiQf99mpr8o2Gt6PwnGa7rUDCK1O0G4UaILn8n766eJqAEadOSKJLMaiNHySpRNEt8vvtTKELxPEBIZBoZVo0sRbNMUAlgOCZ1u07WyDEYHCCkBFGETEKLb6gqLBbrTM2ucvHyHADVukm12iCTK/Pbv/EyPV235tmtGTDVcp1yroqqK8zdWMK2bI4+uZ9que4tLjQFWW5K8uQqXDk9wf6TA6iaCi5ofpVKoYYkCxIdUVYX82QWcpTyVU48e4B61SCfLjJzbZFHXjrSNJosolt8qwJoWBanF+Y5s7BATzjC5w4cQAA+RcGwbf7o/Dn+xQsvEdZ1LMfhL69c4lRPHyFN4395/fv8u09/llytymsT44wm2/CrClXT5E8vXuBfvZxoeXDKhsFfX73CQrnEZ0b3k61VCWsadjDIeC7Lq+M3qBoGT/b18+/efYsne/v56ZFRfMrWZoXlOFxbXWU8m6UrHOZkZxdfvvQBw/EEB5Jt2E6JP7/0AULAo13d/M5bP+SnR0Z5bmCQgKrye6ffoWHZPNHrXYvlOLftYbxnBs8as3BnX4JnPnWM448PUSrUMBtmiypeVWV8Ad0jR+u9NX9nMyRJQtUE0WSIh5/Zz8jRXsqFKtWyp0nkOG6TUVnxhECDOom2MNFEEP82JeynXjzE4P4uivkK/oBGz+DeyM2Gj/QQS4Y48JC3eusbShGN3xpDFULQ1hnDF9Dp6I1TLdUxGhZGw8S2bk6iiiLhC+pNIcoAiVQEVVP2lFsjhEDIAl1X2Xewi2giyENPjbaStcGjCgiEdCLxIJF4kGDY70lp7PICybLEwGgHX/xvXqGQ81Zbhx4eaJE//qgw6ibVcp1oIoRosmEPHeri1/7ZZ6k181ZGj/YQuk1PhSxL7D/exy//5svkMiWMhslrf/E2/fu7OPbU/t07aEIIT/x1KxX79ZQC/qDO0KFuwlGvkqNSqmMaFpLkfQf+gFctFU0ECYZ9G+j9tz5/md597fz2v/ol3GaFnz+gtygHGnaJlfo1EvoQrmtTE2Ue/3wvXQ8bVCs1/HKckaMhpLYMi9U8fiWGInQst0HZWiEktyOEjItLzc4RlJPocghd/vAMpHK9wUqxwg9vTHN+ZpGgrpIuVogG/Oxrj9OfjHGoOwVAsdZgpVjme1cnMCwv1KErCp88OkoyFMCnquSqNd4cmyJTrhLx66SLFSzHwa+pfObEQRIhP7qi4Lou15dXubaYZjqTw2lWTvbEIzw10k9nLIwsSRiWxWQ6x3sTc+SrdVxckqEAD/V3M5xKoDVDbzOrec7PLNIRCTGXK5ApVambJqOdbQy3Jxjp8MKUDpAuVfnyuxfIlKoIAWGfzudOHiagqSjNSXMqneP68irXlzPYrkvU76M3HuGp/QP4FMXLyTItfnh9msl0lnLDQBICn6pwoq+Lo72d+DWv3WK+yHuTc3REwiwVSqwUy9QMk+FUksH2OEd6PH20xXyJ2WyeN8em0RUZTZGRJRm7qelmOw6VhslX37tIMhzk2f2DxAI+riysMJ8rUq4bfOLIMBH/7rkaLi4Nx8A1y7gsYbsOuqQR/P/Ze+9guc70vPN38jmdc/dNuAkX4QIgCIIACQ5zmMyJmiB5FMaSZyWt5LK966p1bXmr5NrateXVbrnW9q5WKtnSSBM00kgT5JnhcDjMHIIgiJzjzan7du4+ef84fRu4iJcEGCY8VSxedPf5zunu09/3fu/7vM8jh5huzSAKIjElSlSOYnk2VafGsl2m4TZZtis0nRaGZBCRwpiCiSSIhCSDlJrA9V2KVgnvCv5dLKozMpgh0Zk3XNejXGnx3CunEAShKyFxJc4cvIjn+YSiBolsFEmWqBbrHHrpZLdbTVZkQjGDZq1Fo9KiVmpw8vXzKKqMZqhsvGuY5cUqjWqT2fOLRJNh2k2LRqXJidfPMTDWgx7S8FyPA88d72ZwH/zEThRVQbxsHayaJhcrZVquw57+AYYTyW5JJ2UY9ESj16wWLDUbmK7DpkyGqWqFtuMQ1wMH87QRIh+JXHWcJsuokoTrepwqFrkjnyeu6ziex5H5eQrhCIm0zoZ0hqF4Ah+fi5UyG9PXTiYoosjWbI5nL5yn5dhszxdYaDRYn0oT0zUOzM2x1Gzg+T5HFhcotZrMN+rMN+oMJwI19mQkxJ6BARRRImUYgdLUe7GkBSs+KwYjm29fWl0QgkWxbzjLjR151obhjT0Mb1xLS+lqZHsSZHsSbNpxbeVJuPTFhKM64ajeJaG+XRBEgWQmuqbOtbVClERSuRi7c7HbNuYKXMelXm2yMFEkmgghiRKyInU/21tBwHdJke9P4TouzXqboy8cY/P2AZ741N23NLbv+3i+3w2wgzK+TygeYiCmIwoiqhwsHiucArFT719ZbAVf6CwuQYbPdVfc0gMSu+f76FGNPR/ahqbKXXmDFS6B45ssWxeRBQ1JVEH06RmXiG1I4fseITmNgIDrN2m5Lopo4Ak2ptegas3iyQ6yaCAIImVrEklTkESVt1N60vV8WrbNXKVGudnCdBzmK3XqpkXc0EhHQsEuG1iqNTg2Pc9ksYztuLi+j+t5DGeTQIbeZIyGabH33BTTy1XG+3IsN1rU2yYIApt7cxhqLgh4gOMzC5ycXWRmuYoiy920ersjvrmywL9xcYYz80UaloWAwEKlTszQCGsK69LBPbncaHFocpZcLEq52aLWNmmZNqlwiEL80m/PdlzqbZOJYoVivYFpu0iSyI7BXgZSCSJ6sGs9Oj3PmYUS06UKgiAwL9VotE3WpRMMZZMokoTn+yxU60wvV6m22oiCQMO0CWsqPYko/amgpb3aMjk0OUcuWqfWNqm22jQtm7ihk42Gu1ySiWKZAxOznJkvEjM0NEVGEaVuFtTvfCZn5ossVOsUYhHG+3Kcnityam6JqK7hrEHkVBBEEko8sL9ABB9Saoq0miKuxFg0lwjLITRRQxWVrvikJir4+KiCQlgOE1OihKUwlmdh+zaaqBKRIzTdFjWnflUmTVFloqKA1smG+j4YhoqqyJ2S07Wvd3FmGQjKzwgCjuPSqLVYXqqiKIHciqxIaCGVVt0MDK4bJvVKA1mRCMcMRu9YR7VYo7RQCWQeZBHbtLEth/mJIoV1WXzfx2rbLM0s06y1kVUJz726bcJyXWqmiem6fHRsI7lwuLuuhBSVmKavEuUUhIAbU+3wX7bm8kzXaohAJhQcG1ZVYpq2WsxTEFAkid5ojJZjY7kBV8d0ncBLq9FgfSrFQDxOPhwmHQohIFBut6/73cuiyEA8TtO2MV2HUiuwODFkGUNWmG/UkQQRRQzkJ/piMUJK8JsA0CSJtGGwPnVtnuNa8J4RTbg6Kg2+xMuDtytfs9bI7lpjX+/QldfeDmLnjQwk32vE0duBmxlmrjIpvQYa1RYXj8/w2o+OMLylf9XO5q3gZudbwVqNPlfGvBKO62E6Ls22RUhTsF0Xy3ZotG0abYuQrtKbilFttlEVGU2WUGQp6Irp/BcLaZiWg+N5KLJEpd5CkSUihkbLsmmZNqbl0DBtRnvTeL5Py7TIJy4tqL4P5+ov0BO6g/7QTvYX/4qInEESNcrWBJoYISLniKoFokqBij2F73voUpySdYGoUiAkpbG9JgISknAtBt3tQzykEw/pjPfmmCxWWJdO8Eu7tjKQTnR3rb7v47guhyZn+db+Y/zRr3yEqK5Ra5nsPTfJdw+c4MGNw/QmgwB8erlC07J5bHyUrf0FTs4tsv/CDP9w4AS5WJhEyMDzfb5/6BR3DfXyiZ3jjOUzWK4LPkhiQJ5tWjbTpQp/+txr/JtPPcG2/jyGqvKN1w53M0O/+9ie7ntxPZ9XzlzkH923g/vHBjsBrr9qnqk0W3i+zyd3bqE/FefYzDzPnzjP3+8/xid3bmF9Pk212earPznI7tEB/qcnHyIVDvHsiXOcnF3kr15+g3/2wftJhAw0WeLxLev55M4tqHIQmPzpc3uptkz2npvqBjwrn+GrZyf5xM5x3r917KprMx2HF06eZ9+Faf795z5EPh7h5OwS395/vDuGLIokwwafvHsL+85P8/8+8yq/89i9vDExQ61l8vvvvw91DTIWqqjwQPa+qzogBQR8fPpDvVcdk9dz3b+z2tXZgyvH2hAdveo19XqbxWKdi1PF7mdSqbaYmC7iON51OxclWaTdsCjOltFCGnMXFynOlUlmY7SbJrIq43sKk2fmSGQCwcJWwww4Q05Axq0U6yzOLFNbbpDtTVJZqOE4LlJHE6i8VKXVMJm9uEh+IE22L0U0GUYz1KuuS1dkEoZByjA4t1xCEGBLNnfNa/d9HwHIR6JM16o0bItPj2/hz/bvJx0yeGhwKND8vmL+u/zfHx4bo+0MM1Ep83++8jLvWzfIZ8a3EFKCea7tOPhAy3ZQJRlDlq8a4/J/67JMWFUoNls8f/ECm7M58pFIJzBTuLNQoD8WZ3ff6vSFIAjIonTLCuvvmYDHcTzOnZnn6e8fJhY3+MIXH7zqNc8/c5yJi0tUlpv85u88irFGYbyJC0scPTzJ66+e51/+64+hXaMc0cVlxNJbhef5LM5X+cZXf8KZk3O02xaRiM6HPraDxz+47dZP8B6DbTmceP0cx149S7VUR5JESotVNu0cYXzXKCNb+3nh268zc26B6nIDq2Wz7b4xRu9Yh+/7vPit17lwYoa5C4t8+d99m8GNvRgRjYMvnuKz//QDTJ2Z5/tffoGPf+kxWk0Tq6Nseu7IJI1qC7Nt41gOu57YxujWAZK5GH/5h98J/NayMYpzZXoGM+QHM4xtv5SJs9o2z35zL67jEUmEWL9tHd/9r8+xbc8Ydz00zhvPH6c4WyaRi/G+j+y46n2/dPQCk4tlyvUWuUQEXZXRVYVURx+n0mhzZmqJ/mycWsukZTmENIXFch3X81HkYKcrSSIRQ2V8sMDkUoVyvUWzbWFoKrGQhq7K+D4cPDsDBJ5AuXj00qIq+AxG7gXfZ7qxn7jSh4eLiERaG6XpFBEFGVkM8jYVa5qGs4QkKAjCSlutjypGqNozeNjo0u3P5L1ZzCzXmCxWODtf5F//zQ+DrJfv07JsZFFctdxFdY1EyGBzbw5FEkmEdPqSUV45fRG7UzIWEXhsyyhHpub5v37wEg9uGOLukX4KsSgRPVi0F6p1ppYrrM+lyUbDhLSgUeD+DUN85ZUDHJteWHWNkiiwa6Sf3kQUpVPqWonXVyb7mKHjej79qTiKJFKIRblzXS//5YV9nfvC5uTcIr2JGH3JGIlQcP9s6StgOx7/cOAklhOUpG3X4/UL0xyemqPaMlElidPzS/QkYoTU1fObIAjcPdzHQDre9ZGSVoRMgZnlKgDZaJhCPIosiaSjIe4a6uXCUmnVWFv68liOy2Spwr/97rM8sXWMj981HpT3buE7frsREIU97E5JXxQF0skw/+QLD5BNR6577XfcvwnP9RAI/ArT+XjQISmL+G7Qfi6KIrblIMkBUdmxXQ6/fIpUPs7AhgKhiE4yF8NzvWsK4yqqjO/5DI/3IctykAEWxWsGYYasMBCL88vbtvGNo0cptVqEFZWwonBkcYEDc7NMlMv87fFj3FkosD1fYDSVYqnZxHQd+mNxZms1wqrCcDJFqdXijbnZ7nF/ffQodxYKbMvlsTyXVyYmmaxWkEWBmKaR0IPuq8dHRvne6VO8PjvDK5OTzNbr7BkYYH0qzVyjzr6ZaQ7OzXGxXOYrhw9xd28fm7NZoqrKzp5e9s3MdDhDT9AXjWHIMg8NDvG1I4c4sjDP3pkpLMfhwcEh7iz0dDu1bhXvmYDH9wMF4eJiresrdCVqtTalpTqlYv0qpeEbwTIdqpUW83Plm+7mjx2Zotkw2XnP6A1bBNcCQQhaZIdHgwh8ZqrE5MUiterb51b8bsL3fFp1k9J8Bc/z2bhjCNVQadZanDk0QTIbozhbxnU8Bjf2Ui3VKS/VOHPwIlvvHSOeiZLIRKlXmgyMFcj2JXFdj+JcOUgVN00qxRpzE0u06m1cxyNdiNOotFB0hcJghlq5ycJkEc/z2f34VqbPzhNJhFm3sYdwzCCZixFPBXwjURSoFutcOD7D8mKNnsEM6UICraNcvDizzNG9Zzjx+nn6RnIks9de/B03cDo3NAXXC1S8JVHAUBWW6y2apo1pO0RDOq7vY9ouC+U65Vqw41dlCUkK0rie52PaDqVak3ozUCMXBQFVkZElieV6C02RaJkOlUa7s7sVkAWdtDZKXOnF9S0st0FYzuBiISITkpOoYghVjCALAc8iLGeQRR1JUIj4FpoYRRVDCKqEIIho4u3hZd0qLNfFx8dQFbYNFLqLNUBIVRnJXlIiVmUJRZIwOou+LIookoTjXdJVEoRg4ZZEkYlimVrb4pUzE/QmYty5rodUJITjediuh6bIyJKIJAb8moimgu/TulJBV4CYrqPKUjc7dXlrMATfoyyJ3UzIynW2bQe3UxY1HRdFFlGlS7tZQ5VRZYmmZeH7BPdHo8mrZyfJRsPkYxFUWabcbGMocrcN+HJEDQ1dlq9q4fV9vxtEyZKI3FF/V0SJiK5y5c7PUBWUDq9jsdZAFAQi+ptrDQ4+rqtf/1ZVtNdynKYqxGMGfT0JqrV28Ps0VNb1p1AV+ZrzvCAERr4rLemCIKB0NstXrSOXt6L7MLChQDQeJpaMgADRy45bGevKc+qdbstuazur15+YqjGWStMTiZAJhRnPZhEFkZCioMoymVCIDekMT24UWJ9Kkw2F0WSZgVgcq8fFdl1UUeShoSHykQhhRaHtOGRDYTZlsiiixFgqTSYUQpGC+7gQiSCLIrIk0BeLM5JMIQoCmVCITZkMKSPgxfVGowzFE+iKguW65MMRtmRzhBWV0VSKhK53g5beaIyteZeGbZELRzAUBVEQSOg649kc5XYbWZLwPI+EbnTvrV19fcS0Wyuyv2cCHoEOkTasYhjqbdWBETsE3khU73IorsRKLfvF504wP1vhrt0jt1x2EkWRZCrMRz9xF0uLVd7Yd4Gv/sVLtzTmTwMEQSDXn+Txz+9h6sw8rz9zlOP7ztE7kqNWbpDKx3nw4zuZnyrx2g8Pc2zvWR765C7Gd48GTuGSyMOf2o1mqCxMFZEVqdtaHc/EWJhcotWwAlmCfBwtrDI83s+ux7eyNFPmqa+8xMy5BXY/vpV6pUluIM347vXk+lMBP6bD4QGYu7jEoRdPIgDrtw/SN5LD931Gtg4we3GRF7+7n8WpEns+tJ31d1ybnxULBQGEpii0bRtDVYgYGqlYiMVqE9fzCBsqPakoekd6f3qp0ukyCFLymqLguB6u52HZLo2WhSAIpGMhEhGDZMTA94Pj8skUrtdksVLvToyaFKE/dHX2ySfYPAiIRJXV7cgZff2qcoBAUAKMKHkEbm57cjuxcqZrbWRWCLm5WITfuP+uYIHqGHCurDMrx60s2lfhimE39mQZyiSpNNv8+MRZnjp8mkw0TCpskAjpSIKAJAqdANbvLnD2ZcHBle9AlsRVnUFXX0IQ1LiehygEWSrbDXg8ghB8/rIodjlbXqcksXJfBPoq0LRs5so1Xjh5gf/lE4+xa6QPRZJotC3qpnXNc8uidN2GB1EU8GHV+7xeF6PtdHRSTIuEoWO5DpVmu3ut79VSvW4oSLKIqslMzS4Hmk+6gtKRkLgRrhWcXPU+hdV/D49fW9l+LdpFQnAzXPVYOhQiHbokGfLI8GqpgIRe4I781ZIDMU1jMHGJA/nrd16aJzRZZkdPDzt6rs1bvae/H9f3cTxvVcCsyzIPDA4F97DnooqXtLOShsHuvn6uR6rNRyLkIxH29K+WjVAkicdGRoM50PNQO+XllXE/PLb25pLr4T0T8MiKxOatfWzY3HvbRe+GR/MMDef46Cfuuq5/lu/DcqnO/GyFxcXq7b2AnzNk+pKk8gGHIBTRQYBmtcXMuQXOHprkSOM0x187h+/7hKMGhRtIBMiKTGFdhpOvn0c1FHY+uoUT+85itmxkRcaI6qTyCRKZKIIgkO1NYpk25aUaEJhxxpJhcn1X+BH5MHN+kfJijfPHpvgX//dvdK8Z4P6P3sXf/fHTHHzhBF/4l0+S7UshXsNhGeDuDf14HaJyd3ff4YnlElFWiMiiINBoW5iWw91jfUwtVUnFQowP5pEEodtZIokin37gjmCclbmvo+kxWEgiCYGhp+/7N2xlp3MlbxYC77w0gaEq+L5PuWkyeIVwW38qTkTXKLfaHJqcZ6yQJhEKAsBKq40mS2jKm5vKSvUmhqqQj0f4zK478P2AGH10eoHxvjyFeIyW5XBmvsh8tUEmGiGkKjx78hyiKDLe6W56M6i02syUq5xbKDGYSTBTrrL/wjSbe3LEDZ2QpjDel+dPn32NqVKF5UaLVNjg4OQsZxaK7BzuR5UkTMelZdlEdZWwFmRcTMdh7/lJYrre7WxbCwTo8n3mK3VmK3Wy0TBL9SavX5judmmt4LkT5zgxu4imyPzh5z/E37x2hL986Q1Gc2lixnvX76laa3Ho6BTffeoQG0bzuJ6PZTlUqi1+6wv3U8jFbz7IzyHEzrylXCdYFgBVvL2inaIgoEtvjxDommaJlRTb3lfOMHGxyMxUiVbLQtMCs7TRDXl27xklFLqUblqcrzIzvcyB/RdYnK922/6SqTAPPrqZgXVpNF2hXmuz/7XzvLHvAu12sGsf3ZDnU5+9Z01vwLYcpiZLPPPUEUIhjV33jjK8PodlOczPVfjW3+zDbAepYN1Q+J1/+v6u6KDvB2JSJ4/P8PLzp5ibLXPy+Aytls2//YO/70aWhqHye//iAzd1Hb8duHB+kQtnFzh8cAKz7aBqMql0hIce2UwqEyHccTBfYDp3DgAAIABJREFUnK8wOVHi+NFpFuYquK6HJImkMxH2PLCRfCFGLB7sBirlJjPTy/z4qSN86GM7KBXrHDowwcJcBVWV6etP8eGP7yAUVnlj3wVeffk0Dz06ztnT88zPlikW60QiOsOjOcY29TC2sXDDz0EUhUsLced/KxoUmb4k4ajBvR/cDgT165VUrthRLLXNS+q4sipTGMpw8cQM2b4U47tHOf3GBSTZQwsFNfXyUo1GtQU+VEp1ZEUmvCLg19khXFUPFyCejjI83s+GO4d46isv88ind7NuYw+yIvH6j4/i+z7b7tvAgRdOMLChh2gyfE1zRFEUEfxLq/Tln02QCLi0S8nGw8RCGqosE48YQTdMJ1sgXnb8tYIrHx+5k0EIFpab34s3S/df+fy7tUPfNdLP+cVl/vrVgzx/4lyQgckm2VjIoEgidwz0YNkOPzhyimdPdMo9Pmwf7GF9Ls1Aeu0Llu/7fOfACSrNFrbrIQkCxXqTQiLKXYO9Qepdgnw8wqfv3srLpy/ywqnzSIJIvW2yqTfHpp61yVVcjnwsSr1t8ePj52haFrWWSdt2eHLHZvKxCJIoEtU1PrR9IwvVBn/63Gsoohh0VYV0ntyxGUNV0BWZ/lSCQiLG9w6d4oVTF5BFkVwsKA+8WWiKzM6hXkQB/uTZvSRCRqDeexkvx3ZdSvUWL52ZIKKpfOruLfSl4mxf18Pp+SJff/UQn71nG6nwe1O0dGGxhiAI3LtzhG3jfQiCQLna4tmXTnZFBX9WNchuBWvKRr3D57wVrCngcV2PWrXF0cNTzEwvU6u2ME0bWZao1dpEYnpXQ8b3fWzL5dyZeU6fmuPUidlu+UAURarVFo2G2U2dup5Ho2GyuFBlcaFKebmBadprCngsy6FaaXL4wEVOn5wjl4933Wl9z8e2HIqLNYpLNWrVFpbl8KX//vGrxmm37U52p9wVLFycrwZKlwTy82tnDL01+L5PpdziwtkFjhyaYmqyFCh2SiLFpTrpTITxLf3ouoooCbRaNqWlGhfPLbK83MDv7MRmZ5dJZYKswkrAY7ZtFuYrvPjcSUY3FGg2LGaml1maryBKgWWC53lB1mNqmZdfOEUiGWZ+tsLycoNquYkPNBsmpmkzPJIN/HOum124ejGWJJFMT4JUPo4e0oilAo0iVVe7ruyaoSLKQflq+twC8VSgDZHtTbH/2eNEYiHShQSKpuD5PkZEJzeQZn6yyNJsmakzc5TmKxhhravTc6OfjhHWOjo8Yxx59Qwz5xdQdYVUPs65I5MYEZ0t96xn/4+PsTi9TCQRprDu2i2R1/uRXvl4xNCIGEGAFw29uXr0e7VcAMGCOF+rk4tE1tStcyU29eSwHJfZco1ivUml1aZhWliuiypJDKTiCMChF/bRth1EQSCqqdiOe8nBWpYYTCdXlZsUSSJm6Izm010yrw+0LZtys03TtJFFgYih0ZOIsi6dCAJ2QSCqa+wZW8fTR89QqrXBh3Q0xFAmyfrcpfsgpCn0J2NkomH0a2WQBQFNkdlQyKApHZXaRivISMbCbOzJdnkwiiRy11AfBydmOTg5i+d5xA2dfCzClr58QIhGIB0JsbU/T7HepFRvoikyGwtZFEkkrF1q5tBVmf5UnEw0hH6NLJggCMiCwGgu6Pz7waFT+L5PJhpmIBWn0mwTMzTwA+E4VZIoxKPcMdBDWFMYy2cQRZHjM/NvqtvxnYDv+7ieT6NhUq40sSyHaEQnmQgHulewig/2C9w+WG2bdtOkttwgmYuhagqCKFJerBBLRZBkCdtyghZ8RURSZATANp1Af01XaFRbaIaKosrYpo0euXVh3DUFPM2Gyb5Xz/HGvgts3tLHF7/0MLGEQWmpTr3WxjSd7s7X83yWFqt8+5v7mJos8ej7t/LQY5sJh3U8z+fUiVkGBjMYnck+kQjz4Y/t4LEPbOWNfRf42pdvwnG5rKZXKtY5dWKWP/vjZ/n8r76PO+8aZNOWoHAYCmuMbezh3/zhZzl8YIJXXjzFM08duWKowOdr564R7rxriNMn5/jzP3mWWq3NH/3nX7upGNzthO/77Nt7ln2vnmNpocp/9/uPk0xFWFqssu/Vc/z5nz7HZ355D6lMhEhURzcUevqS7N4zytbt61BVieXlBt/8+l6e/v4hKuUm6zdcqsu6jkel3OSH3z/E9h2D/NLn76GnN8HcbAXfvxQcQRAg/c1XX+WTn9nFYx/cxuBQhud+dJy9r5zmm19/lYcf30I0ZqBcJ5UZkL0v+zdBpmZovI/TBy9y4fg0f/6/fQuAdRsKjGwd4L6P7CBdiBOO6pQWKnzl//gum3eNMLyln4GxAvXlBu2WRSoXIxw3UHWZVD7O+O5RDr98mqM/Oc2+p49gmTaPfHo347tGV1/QdS7UCGvk12V4/6/cx96nDnH8tbPc9+EdLEyV2PnoFu79wHaSuThHXjnN/OQSn/jSY2/5O34n8XYtPtczNqy0TP5q70F+9Z476Y3H3nSr/+beLJt7s3zunqCU17JtWrYTaL7Eo8QMjfWFNA+NDwekyUiYe4cHVo2Rj0f57Ufv6V4TQDoS6ogF9nQfFwWh+7ob/b41RWZrf4Gt/Te2YhjLZxjLX78sKwoCPYkYn+28t5t9FhsKGTYUMnxm9/U7OSO6yu8+du9NxxtMJ/mN+3fe/HWZJIOZJI9vGVv1+Cd2bun+3ZeM8a+efHjV85t6s2zqzfKR7RtvOP47eT+uwPN8Gk2TNw5P0G7bzC1WOXN+IQiSPZ96w6TWCHSa3snszlo+i1tdd653juuNu9bvZ63XVZxd5tyRKX7yD2/wgV9/gN6RPJqh8uNvvMqDn9xFNBlmcXqZYz85TTwTJZmLIUgiCxNLqLpC70iOA8+dYHBzL7n+NPMTS4zdOUToOtY7a8WaAh7P87FMu2sBoekKoZCG3q8GHiA+qJ2Ax7YcfvDfDiGIInfsGOSTn9mFEVIRBREfn7t3j9ySj5UoBNmCmallnn/mGIcPTvCFLz7AfQ9sIHOdLpqfBniez49+cJie3iQf+Mh2Bjtu17GYQTYX5wffPcj0VImTx2fYuXuEVDpCPBFieDSHqsldAcaHHhvnT/7T0ywX66vG9/0gI/a+Bzay5Y4BhoazSLLI0MjVrf2KInPPfcPsvGeE0fV5ZEXikSfGWS7WOH1ilqmJIsOjORRl9c2nagrb37eR8d2jSJ0abCIT5bHP7eFBM8i8ve+jd3HP++/A6ZA/FVXuBsuSLLHlnvUMbuztRvmKKiMrMv/jf/oiiiYjqzJP/uOHg06oThvoR7/4EI7tdkmXRkRH1YPd/O/+u1/u/r2CFZPVL/2bz6AZKrIisemuYYY29YIfdEv0jebRQsHuYuu96xm7c/CnKuXdbtv85Vdf4cjRaYql+s0PuAn6+5JsGCvwxV+7/6pJb3K5wly1zr3DA0Qu66IoNlpB96XjcLFUYSgdD7gqqspEqUzc0AmrKookUm2b2G6wEOmKzGsXp5lcruD5PmPZFOtSCfKxQHPIcl0W6w1ePjdBbzxGKmwQ7yj8LjdblBot5qo1NhdyRLTA3LHUbOH70DAtZipV+hIxUqFQkL34Bd5W+L7P17+xl2PHZzh3YfGWx0vEDcbWF/itf/wg4ZtkSX3Pp91R808nw8SigRK+KApEIhrbNvVh6G+v3tSq6/F9SqUGBw9Psv+Ni5y/sIjreui6QiEX42NP3kVvT4LELfoZmrZD07Spt8wu+VyVJXrS114jz51f5A/+1291hT4vh64p9PQk+Ge/9wTpNSrqZ/tTOLbL9Nk51m3sJRwzuo0nEFSN2s02sXSE2nKdylKV0e2DtJsWoiiiGRqiCMdePcO5w5N86NcfRLkN39OaIg9VkxkYzJBMhVmYq/CDfzjAyPo8vX1JkqnwquyA6/nMTi9j6Ar5fHzVcwDyW0h3Xw7fDzyOXnz2BHOzZeLxEHfsGCSZjrxrhqC3ihUzuYW5Cq1moMBZXm52n3fdoOxXq7aolIPHPdenvNxkZqrEUkfIyuyU8KqVFrbjdtofV58rV4iTvuyzutYiLkoChd4E0ZiBpgdk0iCrFAhhtVrWNaUDBFFAD2vol+nzSrJE5LJ7IHyTCF0PaejXmMQyvZdUqWOp1T+66DUsPFaQLlyt0LxivXE5SVkzVLTL7EYu//t61/Rehuf5LC83mJ0rs7hYu+XxFFkid50Nhe9D23Y4MbfI5kKWmK7h+T7T5QpL9SYt2yaiqey9MEV/Is4d/QUWaw0qrTYxXWMoneTE3CKyKJKNBuqv1XabcrOFKklYrreq1Xq+WkcQBGK6xqvnJxnLp9nam6dhWhyZmafaNgmrCq+cn2A0k2IwnWSyVGG2UsP1PKK6xivnJtjSk2dzT3aVu/Qv8PagUmkyv1Blenr5lsdqNi1SqQjeTZSdBUFAU2UGB4Ly4wpXZ2k5aKdXFIlkPIR+I12224iVTuBX9p7l8OFJTpycY3Gpiuf5KIrE0lKdaMzg3ntGuWPrALL85u9L1/OotyzeODtN07SQLyP/Rg3tugGPZTlMTZeu2Zmn60rXw2+tkBUZRZNRteD/tuVQLdaoFGuUl6qYLYul6WVsy8GxXFzHxfeChIrruBRny3iuTyQeIhQ1mJ8okh/MrJqX3wrWFCHousqGTb0MDKU5cXSG73zzdbbesY477x5kdCyPqimoqhy0N3o+y6VGEAylr78QvVW4nkezafHcM8coFOKs31hgZA1Go+9l+H4Q1FSrbeZmK1w4u4Akn1r1mpX73rGDm65SbnDuzDyvvXKG82cXA5Vex8W1XWrVNp53Se/hciSSYcKRGy/eoiCQSoe7WbuVMUQp8I6xLOemk83bAcdzcXwHTbyxW/w7Adtz8HwPVVTe9Wt5t6HJQf39pbMXeXzTenLRgCczUSpzan6JtuPwxKb1fO/8KcayTTbkM1TbJtV2m4imMpROcmBylmTYIBUxcH0Px/XwfB9Nlgipyipe0Hy1jigK7FzXxyvnJ/B8n5F0iulylcPT8ziex73D/Xz/2Gls1yMdCXGxtMz+iRlCqsqjG0d48exFNFlmOJMMtHV+gZ85iB2tnc1jPUGm0XKo1ds0WhaiKBAyVNb1p1HUt6cj6Er4ftDW/6MfH+P8+UUqlUt6bKbpUK+b/OCpI8RjBmPr80QjN/cluxKu67FUbfDC0XNYtkt/9tKGLxO7/evxjSBKIqoezNVm06JaqtOut6kW67QbFqX5CuGojqwE9hyiKBCOGdimQ2mujKRK9A7liGeiXDwxTTIfe2cCnkBAT+Y3f/tRyqUG01Mlnv7+Yb759b34ns8Hn7yTD39sB9HO7r1rz/A2aG/Wq23OnJzl4Se2cPb0PD956TQPP76F/oEU+i1+GO8eAs0NfJ9HntjCI49vZdOWqyXWpQ7BGOCv/utLzEyXCIU0/vm/+gipTtbj3JkF/uh//851zyTL4s0tG4SgPHXzlud3FucbU+wtHeazAx9EEd7dbN6hyinO16f5dP/VJPifN+Rj4SD4k6/WNFmfSxM3dO4e6uf0YhFFEpkolblvZB1//fphTi8UeWTDCPP1OvGQzlAqyOT1JWKB9kjY4I6+AiE1EDQDuKO/QCYcYue6Xg5MzRLRVGYqVV48e5GNhQzrkglGsykuliqIgsCx2aCMcudAD4VYhJ3r+nh9YgZdkSk1mr8IeH4O0GxZHD42xT88fZitm/pwXI922+Z7Tx/h1z63h/w7QIcwTZuZ2TITE8VVwc7lqNXbTEyWOHV6np038GW8HizX5eLCMo9uX08uHmGk5637Tt0qsn0pPvhrDyKIApqhEktFWL99sNPsIrB1z1gnVhC6Ir9DWwJenigJXTFHAYHBzX03aJJZO9YY8AQnkiSBWNxAUbM8+amdjKzPce7sAs/+6FiXyCqKAplslEa9zdLboGdjhFQGh7M88cE7GFg3zcnjs3ztyy/z+V+9r9vq/lZxOUl5xQjynYAgCCiyRCIZDlx8lxvounINrm3wgON4zEwHku+771tPOhNF1xVaLYvycmOV6/rPCqaa87Rdi6Fwf1frxvEcynYdy7NRRBlNVFkwi2S1FBE5hIjAfLtI021jeTY9epaQrKOIgWN2yapSd5o0nRayKJNQIoRkg5CkU3eaVO0GTbdFj55FlzRkUcL3fSaas4iIrAutFuvyfZ+KU6dq17Fdh14jiyqpSDcQo3u7IAiBnIKuKciy1OVMvT3nur43neN6WK4bCOh5HpIYqAgrkkQipFNsNnnu9Hl6YlF64tHu729Ft8iH7mS4ghX1ZFFYvaXSOh5RTsek1XLcwPm7E+AHirHSKlL9e6yx6GcWuq6gd4T+Vuwd3klMz5ZxPZ/dO4bZvqUfBIFypcmPnj+B63rvSFu643hUqy0898Y3Xdu0qdevb8J5PUwulpktVWm0LQ6dL5KIGJQbLSQpkBcwVIVNA2vXaLpVrFAHLj0A0mWNLr5/KSnSjTG6FjdXyGXcpuTJ2trSHY96vY0oBV1NoZDG0EiOaqVFqdhgvqMDA0Eaa91ghuNHp5mbLTM/VyGeCCFJgYt0q2mhG8Ek/FZuMEWRiCdCDI4EpF58+N533uDs6XkUVWbdYBDRvtkygyCApsmdGqLHcqlBIhnqluneTg2eFd2VgcEMruMxcXGJeq0dKE6LAp4bfP5GSO36gJkdH6lY3EBVgwWtVmlx8fxitzX/nYbn+bTaAb9nZSFRZBFFkVGuI/i4VjTdFk23je05rEjeWJ7DRGM2kP0HXM+l6ba6isFRJdQNamzPoeG0GIn0E1ciOJ7LRHMO0zXxfI+yXWNDdBBFVLAFh6nWPE2njeu7tFyLwXAPUSFwBK47LVpuexW5z/VdTNdmsjlH27XwfQ/TC44zJP2GCrxvByRJZHBdmmbTotCRa3BcD8/zcF2/O8l7XqD8a1sO9YZJs3ltpd5rwe8oBVfbFjOVWuB8Xq0R1bRu1qRuWbQdh4lShVrbRIvIRLTAuiMbjbDUaPGTC5Ns6ymQj17iZumKjCSKzFVrTC1XAz+rTlv55eqrKxCFwJuqZdlMl6uEVIWaaZII6cQMnflavSuituo9vNUP+F2EZTvYlouzMucKQanZ0N+75dW+viTNloWuK5imfenecz0cJ7gvPc/HcT0c26Vt2tfNgrwVrHAadV0hHgvm9ZVreOdwbfXq24Vqs81ipYHjejRMCx+f2VKtK9Owogj/XsH17DzeTqwp4Gm1LI4emsQIqcTjIZLpCPg+szPLLC1WyWQiSJ1ITlEk7n9kE0cOTXLsyBTP/OAI73t4I6GQhud6nDk9z9BIllQqjHhZNiao6AQCh75P90a80fvfsLmXVCbKwQMXeeapIywt1vj8r94XBCmdO6s7bvc8Pt4VLsYrct+pdATDUDHbFgdeP89du0aQFRHbcslko1ee/qbontdffR0+V78/URR4+LFxnv3RUV589gQbN/UyMpZDVWUaDZMjBycZHcszOJRB1WTCEZ1Wy+Ls6Xl27ByiUm5x9swcz/zwCPXam98d3A64rsfERJFa3exmFFLJMLlcjNQNiMVrgS5qLJkTvFY6yp70HchI1JwGzy3uY1NsiNnWEkeqZ9md2krdaZPVqmyLj1G0yni+hyhIfG3ie/zq0JOEY8MsW1WeX3ydgp5mJNLP8zP7yesZMlqSklXhmfm9FPQMfUaOv5v+EZ/uf5z1kQE0UcWQNA6XTzHZnOe+dCCg2HYtZttLPLvwGoOhHtJqgr+deppfWfdhBkKFbpbhnYKmKXzsozv42Ed3BAuJ41KrtWm2LFotm1qtRaNp0m7bNBoWCwsVDh6e4viJmTd1nlKzzb6L0+yfnGGuUucHR0+zMNDg3uEBfHymlivM1xpMlCosN1tkoxH6kgFZfHM+i+N6/NnL+/j4ts0MpS/xDbKRQO33WwePMVGssGdkgHtHgg6by2WeVmT4VVnifaODfPW1Q1woLvPaxSlals2GXIbhdIozC0urJpNb2TF2S/aCwJXtvFdO2Ddq932rk3ul0mJhoUql48mnKjLxmMHwcOaWm0LeDgiCwOOPbuHxR7fg+z6OEzRhtNoWjYZFrdai1bJotuzAL3G5zsWJIi+8eOrmg68R2UyUYqnO3jcukE6F8TxYLjepNdrBhlO8+ru8nViRQInHjZtWDkIh9S11aa1sXiRRYNvgJSmFlcDYeROk459VrC3D43nUam2++/f7KRXrgSKyLJFIhOgfSPO7//wDJBLBgiaKAr19ST77j+7l5PFZXnvlDE/9t4P4vo8sS+QKcX7pl+8lkQjh+/B3f/0qJ4/PMnFhiUqlSbXc4vzZBb70hT/GCKncfe8ou+4ZZfPWaxtzJJMhfvv3n+D/+49Pc+zwJN/4yit86nP38Ma+8xzYd4GDb0xQrTZpNEyaDZPf+60/Q9cVcoU4H/+lXWza3Nt1XQ9HNB55YguZbIy/+cqrfO3LL2MYKrlCjP/5Dz51XVuK66HZMPnKn7/EmVNzXfHDaqXF1/7iJb7/7TfQDZWPffpuNo730j+QYveeUYyQypFDk3ztyy9SrwVZBF1XGFiXJpkKMzQcKLx+8rO7OHRggpefP8kzPzxKPGZQ6InzW7/zGH/yn3/0rghq1Wot/sN//CHLy00s20EQBHbtHOaxR8fZfffwLY3da2SZbxeRhdXfgYfH1vgYKTVO2a6xNb6ehXaJptNGEWUkQaRq16nY9W6GyPM9HN/FkFTiSoSUEkOXVEKyju07HKycomo3sD2HolWhbjeYay8RVyL0G3kGQgVO1yeYbS91r6Ni1zhcPsW96e30GTl0UWW2vcSSVUaR5KvKX+8kBCHYiCQSIeJxo7uhWGnj9zyfYqlOo2m96YAnGwnx6MYR7h9dx5fedzeaEhhdKqKIgMB4T45dgyo7BnoRRQFdvjTlCAJEdZV7hvpJRUJolz1XiEVJhQ229uYCk01FQZUknti8HqCbMfvczm1IooAiSUiCyK/s3o7tuLh+4D1lKAqaIvPE+FhHaC7w5/mV3ds7pbE3H4j6HQ8v0QfP9zplN6GrlL36tR3LEQLvLH/FZuQWAq5X957j77+9n1Kpjk+wqdgy3seXfvNhIpH3XsBzJWRZJBrTiUR1Mml/9b3o+1QqLV7ff+G2BjzpRJgtG3uJRnROnZ1HFEWiEZ1/8oUHSHdEUD3PZ2m5TshQkSWJtmnj+T6lSoPFYp0dWwZw7EDoUlNlGi0LWRLRVJm25axKF2qqjOsF3YWxjpK8pin09yVZN5DG9bxrZrByuRgjQ1nWj7x565KN/VlGetJ4vtextrkU1gf8t/dm9u+dxJoCHk2VGR7NYlkbqNfaWKaDKAnEYgaZbIzBoWw3GFiJZAcGM+iGihFSKS83g5YzSSSRDJHLxzolIhgezREKaQwOZ7E73T+CAJIkoagSQyNZEp0bcv2GPKlUmGbT6pq+SbJIOhvlgUc2Y7ZtMrkYoiiQy8fZvLWPaNzAtl28TplFlkVkWSIaN8hkokjypZqhIAgMjWTRO6Uiy3JQFIlY3HhLhClZkdi0pY90JkK51qTYrHGqMks2FKMQSiAoAmbCZpEqhqni4EIWEptCbFb7cVoubdem5rcZHsjTiJkcqU0SVjWUvMzAtjSm5nBg9gK96SQjhTzJwTCbH+8j0xdjwazi4uIrkBoIc/8vbcKLeJxrzFOqNNgY6yUq66jSpdtg/cYCT35yJ0PDWUKh1WTOTVv6+JjnM7AufRVB3DRtypUWMzNlmk0Tt/M9Nhomtn3rJTZZlJHEa5cVdVFFE9WAxyMFaf2Wa3KxOUPbNYkpETJakteXjyEKgcFjRAkhCiINp0XZrrEzOU5SiXWMKD16jAxpNUFGS9Bv5FgX6iEihwK+lSAjXeE3FUzWHrIgoYgyiqh0phf/bd05rgWXc/CuBd/3aZvamy47CoKAJAiEVLFbblrBCl9HkSSiukYyZCB1OHKe53O+tMxEsUyp2eS+kUHC6urOu8ChXOkGQSu/z5C6+r6L6qs7Dlda4r3O+VfGDF9xXEx/czIDjudieUHWsmI1sTyXvlAC07VpOBY1u81wNBM43vsebTe45xuOSdVuMRBO4XjB77loNhgMp1f97tYC3w/E8paWaszOlmm2gvKjKAo0Gta7fp+tBZe4Gp3v+hq3nGO76LdZG0cURcJhjf6OvIUoBB1cmXQEWZKo1tvML9VQFInlakfWw/PJpaO4rk+zbXHmMg0hURQwdAVVCQKfUxcWCOlBqbbZthjpT1Ott1muttizY7hjrNqpgLxvjHjC4PTpeYqlOr4frLGpVJg996xnw1jhLb3/wPXdZaHcomnZRHSVnlRAxr44uUCt2WbXhiBL+h6tfL7tWFtbuhG0pW/YdHXn0PWQzkRJZ6JsGr+OZWoHd+0aueHzl+NaYwmCgKrKPPr+raseHx7NMTz65glaPb1JenqT7LgsI7Gy+6hVW2sm3MmyhKpK3P/QRgRBoOG0mWqU+O70fjbGehiP91O2Wyxbdao0mW6VAp5JxCQyZvDw9l5kQaJqt5luldgQLXCuvsDBykXyepxUJEJ+PMHA1gy1qRY7UyMMR3I0nDbjH+pHFWWmWyU83yMia4T6VD70a3ciKALn6gscKU+S1+Poorxq4t28pY/NW679nW3bvo5t29dd87lG06JYqlNvtG9rndrv7Iotz8Z0rQ6nxkTsGGjCpcXw0n7Gx/RMztenqToNBowCg+FeQpKBJIhIgkRUDjqLSlYVVVLYnthITAnT9kzCsk6PkWUgVGCwk5nRxIB87PoelmdjeXbnWtqoooooSIRlg6bbouG08CUf07NQRBlVfOeEzd4rEICQGgSfAR/nsoYA32eiVObo7Dye7/OZu7ZdFTDBpYDqzUIUBMTbbD5oeS5lq4Hr+0w3l2m7NnE1aKEvmnUmGiUGI2lEAVzf6762aNaZb1VJqmF8fGp2m9PVeXqM+JsOeABKpQaf856JAAAgAElEQVTlSrMb7PwCa4PtuAiCQDwaIrM10gm8PVptG1kSKddanLqwwMhAmtmFCuVaG1WRSSXC4PvYjsvJ8/OBtUeHVzk6mMXq8I32H50kl4qiKBLF5TphXWVmocLUXJl77xxa5RDw0IObiEUNVEXmzNkFPNcjEtUZGcrwwQ9sI5uJIMtvrQRuuy5TxQrFWpOeZLQb8JyeXmS6WOXusYFOsPPzGfH8dCr1vcMInNQb/D//4Slee/Xsmo7Zum0du/es58lP7Qw6ZiSNkWiO4UiOoUiOnB7nJ0unebSwFdNzeH7+GCktSo+RoGAk6NETfH/2ICFJ5aN9dyEAJatBy7X4YO+d/HD2EB4+G1O9jERyDEWyxBSD788coC+Uou3aXKgv8qG+O/n6hZeZa5X5H8Y/2i0FNB2TwXDmtnUQzc9XOH5i9raMdTlc36NsV3lp6QAnqxeYai7wreln2JHcjCFdn4SnCDJZLcW+5eOcrU+SKEdpu2a3rOD5HlPNBVzfperUmWrO81j+HgZCBXaltvFfzv89J6rn0SQVy7X5aO+DFPQMDafJjxf2cbx6jgWzxDennuae9HayWpI96e38xcXv8MbyCTRRpeW2yesZ8vq71xr6bkEUBB4cCzYNwe720gQriQIPjQ3z0PqhoDT0U7DdXGzX+MnSOWaaZZJqiJhq8OzcCR4qbCKq6KveX902eXHhDHOtKrqkkNEjPD9/krvSQ8TVUOe1b+09nzg5y/z87e9+/VnHyTNzXcPrrZt6kSSB5UqLv/3ufj72wTvAD7KKC8Uapu0iCFBvmtTqbZbKDabmKmSSYUwrKNVHwxrD/WlmFiqcvLCAqkjEojphXUWRRc5PFak3TVRVuuqbTqfCPPboOI8+svmq67zVzmDP92m0LVRZWqVd1aG6Ybtux4/t5xO/CHjWAEGAaMzgc1+4jw985M41HRON6SSS4W7qUIBOCcWkZNWJKQZRxeBsbR7P94gpIQRAESQ0MfhakkqYqt3k+YXjDIYztF0LVZS7N2swpkDdMSmaQRdKj5HAx8eQVPJGnGOVKQpGgpQW4VB5gi3xfhzfo+q0WTCrpNQwunTrOiTFUp3zFxZvexeCKIjE5Aj3pLexNb6eptMmoUaJKxEkQeKTfY8RUyKookJciZLVkqSUOK7vYUgan+h7BAEBTVK4L3MnfUaOmt3gYPkkD2TvIqFGiSlhDpdPU7Zq6KJKXyjPR3oewPaDbJ6IQF5Po4kKkhLh/uwO7kxuxPJsEkqUpBrrZnGe7H0Id6WGjkBajQfk1g6bw3EbeL6JIEiU2q8hC2Gi6kaWWi8S08Yx5F4cr4YqZRAFpXOch+M2sL0KLWeKsDKCLIYRBAXPMxGF4Nyu30YSDCyviOksEFJGCBgkLp5v4XlNFCmBKr39Adjl/IHrPvdTEOisQBElYoqOqYXRJQWJoLe9ZDZYthrMtSq4vofki0iCSFQxsD03yDZ1+BRVu0XTMZltVjpcMvVNB3vnLyzeFquQnxe4rkel2mJ6dpl6w0RVJCQpICmXK00mpkpYlks6GWbnlgEEQcDt8NpczyMe0clnogz2plAVqZtVVmQJXVPozcWJGBqW42BogSKx4wSimSudy5cHw5dkF+DtyLJossyG3gzffOUIJ6cWmS1VaVsOF+aXkUQRWboV9thPP34R8KwBK2WzsY1vnXgqCAKCD1k9RkTWkQSRHiOJ53uARG8oqC1HFaMb8GT0KJIgUHMC8nJcDRGRg6xGWosSllVEBHJ6HEMKOCzrwhnark1I1kipYYpWnb5QClEQMF074EFIGjktdltu/BXeQKXSYna2fBtGXA1REFAlhYJ0bXPGkUg/AKqoEFOCtuawfEkAcyTc39V0gaA7p2iWqTtNkmqcsKQHys2XhZGSIDIY7sX1A4KiLEhdASwJiV4je93rHQr34fpBC6wkXOIc+b6P6S7g+VbHwFLBdBfxRBPHb9J25/n/2XvPIEnS/Lzvlz7L2/bd09PjZ3Z2d9bv3p7B3eGAQwDgHagjgCMQgCQKhMhAMEIhUfqkCEkI4aP0QRQIEhDo4EgIIRDAHe5wZm/31sz62dnxPT3tfXmXlV4fsqrHdFdN27H9RGxMb3dWVlZlvu/7vH/zPGHvAK5vYrqrKGISBAV8n6a7gu/b2F6Fhj2DJIZQ/RSSGMGw55DEKKKgBlo3VGm6K5jOUkCI/CD1IQk6rmcgCvqGdRP76I6QpNAfShCRNSRBQBSChUMWRTRRJqNFaS9gsigxEEoQk4M6IUkMjtUlJXBc16Nbjqy2i8sXFktr3Vn7uDuCrjCXhmFTqQbSKtHVamCR07RIJ8MoskRIV4iE1EAbpq3RxM3oZLrVlNP2mmrPJ5GQRqTlx7aRttO95vSSKJKJh0lGQjRMi2LNwHRcEpEQyWgISXx4HQl2A/uE5x5CAH5q4Km1QTQUTq/tGDba6R2J9eNHW50dCByK3qxJej4T1D75vs/PDJ5ZO+dIONMiUUF05CDr65jGoj0cjPasSzVsF67rkS/UmZ4p7PhcuwlBENZ1dQHoksbByBDvFT7F9QJ7CNOzeCp5jP5b0k+SINGhzrcrpBZBuh0eeeNdNDmLJmUAD13KIgo6vm8TkgeQxQieb1O3pgnLo4i+jo9LwTiLLvcjIGF7JSrmJTSpF03qYbH+LTSpD13uJaKMUbMmcH0Dz7doOHNYbh5ZiJAOvYjvC/jsbWvqXrf23i+ktAgprYO0QgSeTA2v/W9YVjmTHtn4WOBIfHvib57nMT2Tp1isb+v1jyMEUUDXVSRJxPN8mk2bStVAlER0Tebnf/ppUsnwGhG4Ta5ko/PdEbnc6JG8n4FLQQBdVfjFzz9NvlJnbrWEpioMZxNkYvfWWuJBxD7huce4cyxsZmzcTTNk/TnvftbdHJPTM3lWVio0mw9HIWVI0jkeO8hYZGiNTPr4aKK6IUHaLYiCguPVAIGYchxFTCEKGrIYRxXTeL6D5a5iODO4fhOZIGIlCAq2V22l5vpQpCSe16RqXUYUVCRBRxGTxNTjGPYCjlfF8w00KUtIHkIR4+jyIBXzIo6X6H6RO8R747NIosjBvhRRXcOynTXn5oYZdI70JqPUmxZhTQkibrU6yUgIz/exbJewpmJYdmBaG9KoNU00WSaiP74WEA3DYnY2T63WvC9KxQ8rREEgGtH47IuHabb8BrPpaKCqTyDYKD/EPowbwfV8FFGkNxElGw/MeO+HTMmDiH3Ccw+xHWXJ7fx9p+fcKubni5TLjbsf+IAgUNyVUcR7+fgLRNWjrfdXkcUwIWUYARlZjBBWRhEFDfBI6c8jixEC6ioSU4+vnQNcJCGE51s4Xp2QcgBZjKGKCQQUouoRdK8fDwtFjCEgIwoaihgnoh5GFdN7+inL9SaW4+B5HookrUmTyKKA7Xo0TItctR7ocrUsJlRFYrWcx/U8wEcUREKqAviML+YoVBsMZxMcH+pFkR5PZ/Nm02Z6poCzT3a2hLbtSSyqE3JcLNulWGogikGZQiYVjLNHBbbjMpsr47ge8bC21qW1UzwqQ26f8OxjR/B9mJ0rUHqICM/9gCCIxNSjrZSSD4iExJsyD7J4U1lVl/tve+3a6/xAwu6m0i+t6FSQSnI9n5DcllPwW637N9ObMTG25zOXYdmU6gaNpo3r+yiSiK7K9CaiOJ5HzbDIVxvoioRP0LI+2pvixlI+6CCRRFzXZ6QniSgKfDq1RKHWQBAEDvdntyUU+CigadhMT+f21XK3CVmWcFyPRtNiZr6IJAqEQgqKLBGNaHvuo3WvYLseC4UyVcNkIBXfFcIjrPvh4cU+4dnHDuFz5doiKyv7rbKbQ9CSvHVrAwHPB8O2aVg2siigyTKqJNF0HEwnSBuFVGXNVDOkKjQsG0GARCh0z9q/Hdej5lrEQiqW4wbq6+k4F2aWqTctZFGg1rQIt/y2lktVIBALrNsOyUiI4WwCXVVYKFQ42JfiQE8SXX18p6ta3eTCpfn9dNY2YRgW5y/P8a2/O8+Tp4ZxHA+jafGdH1zg13/5M/fELf1eQJZE+pIx8pVGoP68GxCER4YQPhAzSK3WJF+o8fbZCebmC1QrTZqmja4pJJNhspkoTz05wuFDvUSjetdNquf5TE3nuDa+xMxMnvmFIqbpIEmBuV42G+PAgQzDwymeODmIKO59iLxWN6lUDJaWSiwtVyiVG5TLBuVyA8tysG03MPwUBGRZRJElFFUmElaJRDRSqQj9vXF6e+NkMlHSqch9D+v7PliWQ6lUZ3a28Mh3jvg+1Bsmi4slro0vkcvXKJUaFIo1LNPBbXmj6ZpCNKoRi4UY6E8wdrCH3t44/X1B7cx275uAQKXZ5M3xaVQpqDtQJYmIqtKbiOJ6HudmFtEUmaZtY1g2fYkYluMS1VROD/UR17U9NzH9zIlRLMfFBxQpEIcUBYFEOMRzRxQ8L4hQuC0l5HYHk+sF2kieD4okEQ9riILAZ06MBpYUirIpiui6HvWGxfx8ganpXCDUV2pQKNUxzaCGw3U8JDmwBNB0hXQqQl9vnJ5sjKGhFCPDGSRJvO9h/Hb9d6XSYHm5zPRMDsfZj/BsB7MLRTzP57MvHeGpVvt5qdzgOz+8eM/c0u8VBEHgo4l5DNPmrctTa1HRnkSEf/gTz27jfIFDwUabtECUF27cWGFxqczScpnFpRKVikGzaWO1CLosS2iaTCoZoa83Rk9PjAMjGQ6O9tzTsbbrhKdtDnd9YnldN4GiyDxz5kDrAwZmbYVCnamZHNcnVnj/g0nmF4rUak2azYDwJBIhMploy1zOYngozdBgEO6+dfFoy64vL5d5/8MpxseXmJ0rsLhYwrRcJElA1xSymWhwUxbT2LbL4bFeIhEVRdmdr8L3fSzLoV43qdZMSuUG+XyNUqnO8nKF5dUK5bJBpRL8Z7YK6SwrELuSJSkgPapMOKQSiQRGcr09cXp6YmQzMYaHUmQyUWJRnVgsaMHeiwem7WbcNG0Mw8IyHUzLwTAsjKaN0bAoFusUS/UNHdp9HwqFGleuLO5KNDQU1kglwxwYyWxboOvqtUXyhfptvaOCIBCJaBwczRKPh2473vM8SmWD5eUKq7kK0zN5rk8sk8/XKZcbFEsBaQ38gEDXZCIRjVhMp68vwcpKhf7+BMPDaYaHUsRiIULblM23HZelchVdCRzHY7pG2QhabAWgYdk4XuCUXGuayJKEYdlY4RCO590TZ/CeRHStdfem7nXws9rSmrr1d0DHVmCAbDyy7nd3wvM8bNtjZaVMrlAnn68xO1dgZiZPsVSnXGpQLDdahMfDdd01JXSttanq7YmTzUQZnEuxulolnY6SbM09dHnvnaLdbm5ZDpbl0GzaGE0b03SwLJt6w6ZcqnN9YoVazdywC862XHL5Ku99cGPbz9atyGZjpJIRerZhmPygov09+whrrvINQ27VjW0fDcOiUjZaGmQ7H2GiKDIykmaoZYGx5dcLAhFNZSiToFxvBr52LcKjbFN9XGhHeO5ouy9XGlQqwdx4bXyRxaUyKytVlpbLVKpG6xkOCI+iiKiqHIy1bIxsNsrCYolCoR48b6kwyUR4zzfye0B4oNGw+Pd/9DZn37tdlTiVCvNvf/8fEQ4HOVPf9zn/6SyvvX6Ft89eXxNqaqPRIjmLS2UuXJzn4/OzvPTCIX7pGy8QusPLyfN8Zmbz/O13PuW737uw5tbdhuOAaTqUKwYTk6uoqsRbZ8f5J//4Sxwe6yHVcvPe7hfeZrq+75PL1Zi4scKVa4t88OEU8wtFGo3NdTA5jgcmUDc3bD9VVZlDYz187rPHOHVikNNPDCNJQmvR2PnDctNQEmzbpdEwWVwqMTtbYDVXDRb96TyLS2WqtSam2T1sevnqIpev7o4C8+hohldeOsJ/9WufRd1meuNP/+O7vPHm1du0MiRJ5MjhPv7pb36RJ0/fbC/2/eCZuXR5nm9/5zzXr6+wmqt2PX/7mV3NVbkxuco7Z68TCin0ZGN885de5tTJoTXCDlu/Z67nYdoO2WiYoVSc928EruC6IpONhhFFEV2WCSkKiihScVzMXfAy2wrWte7e8e+6n7u0AncTMGyPOdNyKJUNvveDi5x978amxpttu9i2S71uUSjUuXHjpk9SX1+c5545yDNnRvncq8dQlJt+e7uFWw0zTdNhZbVCvlBnYaHI7Fye1dUaK6sVpmcKmKa9bm68FdVak/OfznL+09ldubYv/sRJXnnpMF/58hO7cr4HAdlMlNVCjY8vzNDXE8PzfIplg4Zh3VzQt4HV1SrnPpnh//rd73e9R5uFpsn8l7/2WX75H7y0rdcrssRgJs4//mrw+ls3FtstwgkiPIE6c5vUua7P+Pgy5z+d5bvfv0A+X8PzOhM+0/QwTYdqtcns7E35koH+BC+/eJgXnx/jhRcO0ZYJ2ivic09TWq7jMTWdZ+xgFt+H6xMr/MG/eYNcrraph+X69WWqFYPV1Qq/9U9+8jZzy7/+1jk+/GiK9z+YXEd2NoJluczM5PmX/+qH/MTnT/Bf/MILhMPb3x1NTee4MbnK2XcnOP/pHA3DxHE8bNvdlYFw87odxq8vMz2TI5uJcfRoH//1rweOv/outO1OTec4/+kcP/zRZXL5KkbDwmmFfH3vpgKp695/U8zdgut6zMzmqDestWiD63p8+NEUb749zutvXKVp2rjbTCcYhs3cfJF/8bvf59jRfp48PcI3f+klVFXeUmROkSQGk3FePjSCYdsslqo8e3CQ/kSMqKbdPJcP7RjL+HIOy3EfhXrDDfHRuSnOvjvB2fdukM/XdmW8ra5W+f4PL/H2O9f51t9+wi9+4wWOHO6jJ7s7EQ/f93nr7XEuXJrnwsU5lpfLgTrv2tgKfm5HWPexc2RSEU6fGCQZC3Hx6gKSJBKPhfjNX/s86dSjp09j2i75aoO5fJmQIjOcTZCKhu/+wg0gCgK6riCIAo7jUS43+P1/8waXLs2Ty9cwTWfba8HySoVvf/c8P377Gq+8eJhf+PpzDA+ldi3jcifuLeHxfJZXKvT1xqnWTL7/w4sUinWsTe5AXdejUKxz8fICNyZXGBlOEw6rzM0VOffJDOMTy5hbKNRy3eB6xq8vc+78DC+/eKijo3QntFNY770/ySefzjA9nSdf2ByB2y5c18MwPFZzVRzX42++fY7PvHKUo0f60FR5R+y4VjdZWCwxPZOjUbewN0EeHwVYlkO1alCtNYlGNF7/8VU+PjfDpxdmqdaaOz6/5/nUGxZT03ksyyUW0/n8546RTkWQ5c2FmkOqwhODvSTCOmFHQRYlQmqQ3lLljYfyYDKO63mE73Ajf5jh+z6VisHFSwu89vplJiZXWF2trIXPd4p2islxXKamcnzn7z7l1Mk8Lzx3iNEDmV2p9VhZrTA3X2BmtkB9lw1397ERBMIhlaGB5FpJha4rpBLhR6Z2BwIvLdN2eOvSFFXDRJZEfM9nPl8mGQnxysnRLZ9TaLXwO47LtfElPvxoiouX5snnajRNe2fX6wURTtdt8Mmns0RjIZ48Pcxzz44Gnl+7PGfdU8LjeT4rKxWKpQYrKxXeeXfitpRI+8Fr51s3QrNpMzdX4MrVxbXU2MXLC1wbX77NVE8QgrCYKApBdKLDhNJoWMzMFfjo4yleeO7gutqgzcB2PMYnlrlwYX7Li2NbJ6L9bzst1i082EazabO4WOIHr10mmQyTSkUYGkhu6f3vhNm0KZXqVCrNRyaCsxm4rk+5bFAo1LAtl9d/fI3x8SWWlssbHr/2fAk328I3c8+KpTr1RhPLdhgdzaAoEslEuHXO7s+drsgc7g2UoDVZJqprd32/zDZ3dQ8i2o9jvWEyv1Dkzbeu8dY74xjG5ibd9tgWhFtTSp2P9zyfUrnB2+9cJ5+voesq2UyUcFjdNEnthEq1SblsUNsFMr2Pu8O0bFzPR9cVTh0f2LWFNJgHHhydGs/zqDRMLk4v4fk+Y/0ZDNNiealKSFV4+cQBYGspI1EQUBWZYrHOhYtz/OBHl5ifL3Y8vr3uCgQpNc/rvP624TgeM7MF/LeuYRgWowcy9PXFEbd4rXfDvY3wuB7TMzmaTZt8IehyWbsQWSTbChmbptNVPt3zfL77vQskEiEUReSP/vRtCoXbj9d1hVBIJRrVyedrmKbdscNhYb7IG3WTX/3mK8Ri+pYns0hY5cxTI5hNmzffHt/06wQheK2mKYEmhCJhmkHhYqnc2NQCCkEI/m++/QnTM3n++X/3M1u69n3cxMpKhY/PzTA1neODD25gNDsvpJqmoOsK8Zi+tkspV4wNi7fvhGW5jF9f5j/88dt87tVjfOPvP7+bH+ORxw9+eJl335/gnbMTdz+4hSCFoaPrKrouU602aTQsmqZ913HmOB4XLy1wbXwFWRR5+qkRhof3VsBxH7uL8YllimUD23H5wmeOoeyQsLYhSWJr/lZpNKz7noJsWg6fTi3y/NFh+pIxDg8EG6TvfniVxUIVy9m6W7ooCui6zJ/8x3eZmc0z08VCSBQhHFaJxXQUWWplZYLGjs18N7NzBRoNi3y+yv/0P/zsbWUru4F7Sngcx+XK1SUmbqyuhcKeODXEU6eHeeLUEOl0kEut103m5ov82X96d60L5k7MzRc5++4N5heCSm/HcdF1hXQ6ytd//hmGBlMkkyEkSaRWMxm/vszb71zn4uX5dROc43o0DIvx68scOdK3pZxum30+eXoE03R5++z1dedXZIl4XGd4OM2RQ72k01FSqTB9vXEURUaSxLXdZ7vLrdEw10Lely8vcP3GSteJeWWlyvj4MleuLDI21oO+zW6NTCbKE6eG8Xzw77IQeJ6HZTm8/+Fkx3RCTzbG4EByjczuBD09MY4e6dt2h9bd8NG5adTL86ysVNalRg+MZBgaSnHieD+Hx3oJh1VUVUaWRXw/IOGO47KwWGJqOsfk1CoffjTddZBP3FghFtUZGUnz/LNjyPIDsk18QGHbDm+8eY0fv3WNa+NLHY9rq+g+/+xBDhzIMDSYYmgwhSwH40wUxbVWZNO0mZrJMzGxwsxsnqvXljreM8dx+E9/8R61uskrLx9mZDi97d3n4UM9iIKwJldwt89dKNS5cGl+w7+rqkw6Feb4sYEdR54gmJMH+vfWguReIx4PYZgO5RWD3WxXzGaivPD8GL/z29/AsV1sx6XZtDAMG9MMuu3axNoyHYymzdn3JqhW98YiRJElRnoSvPHpJPO5Cr4PTdthPl/BMG0UaWtkB6BaM3n/w0lqVRPjDvugcEhl5ECGM0+NMDSYorc3TiSsrqUNIeguLZcNVlernP90hvMX5iiVOm/oy5UGFy7Oc/a9CU6eGGRwh1mLW3FPCY/v+xSKgay8KAqk0xFeeH6Mp04Pc/RIH5GIhiAIGIZFb0+cS5cXuHxlgbkNwmfNps2NyVWKpTq2HbSZ9vclePaZUZ57ZpTe3jjRaOAsbpoO0aiObbvcmFrFMKz1pMfxmJsvMjiQ3FYRWzYTZWgwSW9PnNVcFVWViUY1+nrjpJIR0qkIg4NJRkczpJIR4vEQ2Uz0tgfj1u/JspxAv6U/SSoZRlYkFhdLFEsbKxpblkOx1ODi5XkGBpLbJjzxeIjDh3oIh9W7prQc16NeNzl3frYj4Umlwhw71s/RI33bup5bEY3qZLPRPSM8K6tBSrRWM4EgAqeqMkcO93HyxCAHRtIcPtTL6IEMmiavW1x836evL0FPNkZvbxzfD0hNp8mt0bCYmy/y8bkZnjo9jCgqiI+5m3EnmGag+fT+B5PMzOapVjdOBUWjOulUhENjPTz37EGGh1L09yXo64sDwm2pB9/3sW2XTCZGNh1loD9BPKZzdXyZet1ct9EKVMWLXLg4RzSq0d+XQFG2V2cwPJQmFFIZHLz7ZG4YFpNTq50JjyKRycR47rmD6NrO29L7+xNkMo9OSzoERMC0HGbmC5y7OHtbfcixQ73run43C01T0LRAy8nzfBzXw2xagQaN5WK2pAZMM9CkaRo2l64s0Gzae0J4JFEkE4uQCOu4nsfsahHb84mFNHoSkW3NnbbtsrpaxbKctdSUKAoMD6UYHExx6uQgp04O0t+XIJOOomnr60irtSbFYp1QSEFVFaZn8mvZnjvhOB7lisG5T2ZIJSP09sQ2XCe3g3tMeILoDUAiEeLE8QG+9nPPkEiEb5uIQiGVkZE0X/v5Z/B9f0PCA0FH0dR08HM0qnH69BC//quvEovpt305miZz5HAv/X1xvv/DS6ysVtZ90Z7nMTm1yskTA9v6bJGIRl9fgiefHObddyfIZKMcOdzHl75wkqNH+0gmQkib1EEQBAFNUzg4muXgaJaXXjjE0FCa733/Ah+dm+nYhVavm7z51jgvv3SERCK0rQckk46SSUd54tTQXY+1LIdCsc6f/NnZtft6++eAnmycp58a4dVXjm75Wu412kSnDUWRyaSj/Mo3X+HkiYG1WptOEASBvt44fb1xnjw9zFOnh/nDf/cmV68trku5trG4VOK11y/z9a89iyRLaOo+4bkVbdJdqRrcmFzltdcvd1woBAFGhtOcefoAf/9rz5JKRboWpApCEAkaO5hl7GAWw7BYWanwe3/wIyZurLC6ul6CwPd9Pvx4mmKpwSsvHSEe33oKXBAEDo31cGisZ1PHlysG0ajGX/7Vxxv+XdVk+noT/MTnThCL6Vu6lt2E63mB+9sDaFQZCA3W+ej8DNcnV1AUaW1z8c9+40sMbZPw3ApRFFBFCVUJremj3QnP8/mrv/mYUrFBg903W24TnpdPHmB6pcjVuVXCmsrTYwMc7NteGrYtnXArdF3l8587wQvPH+Sp0yN3PUcsqhOL6hwYyfDk6WHOfTLDn/35uywslDaM9Hiez+s/vsrISJojR3qJRXfnub5vSsuDA0l+7R9+hkikc+Hl8WP9HD82wPWJFaamc13P99WvnElg2ucAACAASURBVOb558bWojp3QhQFQiGVl186zLvvTTA9k7/t757nMz2T33Dh3iwG+hP86jdf4Zu/+BKRsEY0qqMo0o6VJEVR4POfO0Y4rDIwkOQ///XGE59p2ly5tkSt1sR1vV0Jbz+uEEWBz716lJ/+qSc589TIpslqG4oiMXawh9/8b77AO2ev8x/+5J0NtWFs26VUavCX//lDvvgTJzlxbHuE+1HH+U9n+fO/eL8j2VdkiaeeGuabv/gyJ08MoOvqlsecrisMD6f5H//7n+FvvvUJr71xhcnJ1XXHGYbF7FyBf/tHb/Irv/wKfb2Phi3BTuD7Pn/88XlGknG+ePjQ/b6cdejvjfPVL57mi6+eCCxWbt1g74JY44OGwXSC/lScF46OtNzSxV1xTBeEIIr6z37rK5w+NUS2Jcy5FfT3J/hc9BhjB7P8b7/zV0GjiL0+jVyrNXn//UkEQeAbv7A7dY73ZTsZi+r0ZGMMrLUIrj9GEARkWaInG2X0QKbr+RRF4tChXoaH0h27rNqV48NDqQ1Jlu/TsnrYfphRUSSymSj9fQlSqQjhsNraSWy98+vOa1cVmcNjPTxzZpRYTNtwF9W2e1jNVSmXH22rh73G8WP9nDg+wKGDPciytOVda1vMrCcb49jRAT77maPI8sbDzXU8Pr0wRz5XW7Ne2MdNTE/nmJzKsbBY2rDbQ1VlMtkoP/vVpxk9kCEUUrc15tpzRDym89yzo3zlS6cC/ZENzmMYFufPz7K0VOraaeW5Hrbl4DruXWvidguu57FSqzOey3N5ZZXxXJ6iYWA6Do7nsVKrsVKrMVcuM57LYbsuhm1TaZqUm01u5AvMlMrUzJvKzp7v03QcbuQLjOfyzJRKuJ6H3/59oUgmHCIVuj2y4bguxUaDa6s55ssVDNu+L92foigiyxK6plBrmNQbFrbtEg6pj1Qa2XYcJhZzzOfLVBsmuqqgKTI3lvJ8NDG/ds+2i55sjKdOj3DyeBDx3s6mWhJFwmGVocEUr758hOGhjSNPvg/zC0WuXl1c66rcKe5LhCeeCJHJxNbJ+G+EZCrC0FBnmW1RFIiENQb6k2Qy3Wtv2imHjfO1fqvWIhBR2g5BkSSRcPjurcLbRW9vHNvx6MnGsMzShppDvu+Tz9eoVI01Wfxu8DwP2/WomiYCAiFFXjN1fFwhCEHh5uHDvZv6DrshHNYYGU7xyktHePvsdep1a93A9fwgupgr1DAMu2vU83HE9RsrzHap24lFNQ4Mp3n5pSNo2vqamnb7efvX3cZ2QFQlDh/qQ9dVvvN3n7K0XFlXz2PbLtMzeWbnCqRSkQ0jy67jYjZtjFoTURAIx0OoHQjUbsH1vBYxKVK3TJqug+W6PDc0hCJJeL7PlZUcEVUJ3Osti+FEgpppUTZNDMumYBjIokDV1Dne04MIWI7DbLnCfLmC63uEFIX+aBRBkrBdl6VqDVWS0aSbS4rtutQti+lSmXy9QURVaToOB1PJXW83vuv30nJKL5YarOarQeeRKuM4HslE6JGIhrueR8OymVwuoCkyPYkIIS24H+PzOVYrNZ4aG9iRiXBfX4Knnx5hoD+xI6IoyxKxWIgXXzhELl9jZrawYbNAvhD8rd4wiYS1Levk3Yn7Qm0H+5ObrrxOJ8OMdCE8qipz7Fg/sZh+VwEpQRDo64sT3oDw+D4USw2MpoPrPrj6M9GIyquvHCUa7bwoFoq1jovDnahbNuPLef7la+/y//z4fd6dnNutS31oIUkSP/2V05w4vjvppWw2xssvHWZwINmxzbLRsJicXOVql+6jxxU/fvMaV7rYk5w8Mcjf+7lnNiyWbKNt0rvZCJqqSvT0xPjazz/btYnhzbfGN7R08H2farHO1KU5zv7tOf7uT99mcXJ1VzuENkLNspgslPh3H35EzbIpGyb/7/mLgT2AKFJoGPzvP3yd1yYmmcgXaFg2CAJz5TJvT03z++99QLlpcHU1x//xxttUTRPTcZgplflfv/caC5UqDctmpVaHlu2HJIhEVZW/vnyFd2dvfhcrtTofLyzy7z88h+15fLK0xP/99rvULRv3Hkd5qrUmH56b5v/8ve/z4blpzn4wyXdfu8S/+MPXWM3X7um17BWqhsliocL1hTxX51f5dGqJD8bneO/aLBdmlphZ2VhTbLMQRYHDh3r48hdP7gpZFQR44flDHD82QE92442lZbkUS3XOfTJDo7H9cpM27kuEJ5WKbLoTKhTWSCQ7HyvLIgdG0ptSGBYEiEZ0ZKUzm3ccB9t2kOUHL8ohCAKKInP4UC9al26MoCVyc4rTqiTRG4/wpROHmcwViKjKWtrgQRHTupcIh1VGR7MkEmG0bfp1bQRZFnn5xcO8ffY61ydWNjxmaipHJhPl2TNbV0N9FGFZDoVCjenZPIXixt2JqVSYQ4d6eerJkTUxyFvRbFpUq02uXF6gaTpk0hGeefYgcPdIT0hX+dyrx/jRG1cCRfgNIqpXri0xMJDEMKy19Jfv+3iuz+SleXLzBRrVZsshle3aGW0anh+4zocVhXQ4hCKJhGSZqKqiSlLgXK/rfHZslCOZNJIgoklBVCykKLwwPMSZwQGWqjVWanXmyhV836fcbPLM4AAvHRgmHQ7h+wGBAtBkiSPZNGFFQRJubjon8gWWqjW+evwIZwYHSeg6vudzdTXHkWx6XfprL7G4XEaWJb76pSd46tQwoihQLDX49g8+Bd9/JNzSFVlCV4N1odFqH1db3WhnDg2SjoaRdhCVGTvYw9BQmniHguztQBBg7GCW554d41t/+8mGxzSbNh98OMXRI30di8E3i/tCeMLhwAV8M1BVqav4kCSJpFPRjvURd0LT5K7FW677YPvXSJJIOh3p+nkt09m0JUQwQfqIgkAyHHrs01khXWV0JIOmyruW2w/UfQUOjfVy6fJCx+PyxRpLSzvbhT1KsCyH+YUS9brZsVi5vyUDcGd3UjttWKuZrCxXyOUCzx+1y2bnTkhSIJ3R1xtnebnMygZdW7Vak0KxzspqtaXLE/xeEECSJWRVRlFlGrXmtlPlW4EiSoQUBUkUqZomkihyZnAATZIRW8+hKkmkQiGykds3kqIgEFYVoqpGRLHQJAnHdXE8H9v1CCkyCV1bR1QkQQjIjnh7MbDpONiuR0LXiWsaEVVBlWWajrNpUdXdQrtW1LTslldZoA9j2y75Yn2tZjSdjuwo5XM/oUgSUV3jYF8aw7IJqTLpWBgBSMXCJCP6jj7bQH9iS1Y4d0N7LGSzsa51urbtMjOb3xXrmPtCeCIRbdN1CpoqE+nSMiiJIplMtGvU5rbzaUpXJu+6XkdF5gcBkiSQuIv/i2k62Jt8OCzXpdI0mc4XGUjGiWpb7255lBAOqxw/1r/p52mzEEWBw4d7SCY7t7YXiw2Wlstri/Wj4n21XRhNmytXF7tOdEcP93fskvI8n2KxzsxMHsOw72olcSeCeh6Bgwd7yOVrGxIe1/UoFetMTCwzNJhEFFs1RCL0jqSRWhuTWsW4J8W6EVUhEw7heh4T+QJj6RRfP30KTZYCwgUokshGez7P92naDrbrYnkuTddFlWVkz8ewbRq2jeW6WG5gRtuO8PgE9SNey17Fdl1kUUSTZVRZom4FrzMdF9NxCCndN517gWw6ykquwicX5lBlGdfzqFSbVKoGkzM5CqU6iiLzYvIg7LBO5H5BlSXSsRCvnDiAaTtoqkwysnvRmJGRNJn07hutZrMxxg5m16yV7oRtu8zOFTBNe8ebhvtCeKIRjegmCY8kiV0XH1ESA2G+TYYjJUlE6DLY2g7nDyoEQSQS1rpGHxzP23StgiCA53tUjCa6ItMTe3S8l7aDUEjh4Ghm08/TVjA4kKS3N04iEaZcXp+iqddNiqUG5YpBLKrvuEDvYUejbvLphTmsLunZJ58c7tjU0O6UU1UZTZNoNm3cbXTBnToxSLEQ1BFshEKxzvkLc3z21WO3/T6WjBCJhRg52s/YE8NkBzvXIu4WfKDpOFzN5TFsh4VKhU8Xl/iNl54noXfXMmnYNu/OzDFTKuN6HjXb4mAqiSbLLFarfOvyVf71ux8EgpyixD995SUcz2O5VuMH4ze4uLTKaq2O6Tr8vVMnOdXXS1zX+KOPPuG92Tls10UUBE7396FuUeZhpxAEyKSinDk9gk/wbCTiIV5+7hCSJGI07UBd/p5e1e7D830My8a0nV3XQxo9kN1xE8dGSMRDDA6mSKejlMuNdQGH9salXDEwmvaGNbibxX0hPIoioWyyPiLQELhpRHYnREEgEulOAG45G4JA17Ce5wc7lQcVghC0WHYluVsYuLlqnZVyDVmWKBlN6qaN19oJPo4RBlWV6emJI+4y4WmntaJRnWRyY8IDwW5mZbVCSO8eiXwcYNkui0tlHLez0GBvT6yjKJkgQDodwWspgouiuC1F3UwmSjLZeadcb1gsLpXX0jS+7+N7PouTK5hNG3xYmllFC6lE7yJeuVNMFopcz+X52qkTHEwlsT2PyUKRuVIFkgIxXePXnj1DT2T9wqXLMqf7eznZ20NIVvAJTGolUSQdCvH10ydbc4OAIonoiozv+/THonzu0CiHM+lg0xSNENNUZFFkJJng66dPIgviWuG0Ku2+C/bdEA6p9PcliHToohWEYDP8sKaz2hAIoslX51apGEGR71hfiuFMgnQsjKpsf8lPp8J70kEqigKyHGRqGnVzwwyL70OxWKdSMR5SwrPJPKAg0DUiI4iBYNhm2Oytz3Kn8FkQ9n5wCQ+wq8zdtINQsypJGFaQc39cIQiBunIyEd6ziS8cUkl0kWNwHZdcrsbQQArtMe5Ob/u0FYv1jl2TkiQRj4fQQ+sL+NsLaiSi4ft+y69O3JZpZCKuE43qawXJd6LZtFnNVfFumTs8z6dWbtBsWIiCQClXxTI35+q+ExQNg6VqjZO9PYwkE1SaTZaqVeq2he26hJUwXzyyXhhQIGhgOJxO89RAPwldX0tZAURUlVdGD2C77pqQXft1uqKQDoc5M7i+q1GTZV4dPYDjeUGdzH3SvGlbQKT2mHDebwiCgCpLNEyb1XKNasPEdT2alkNPvUkyFiIRDow9t1LALAgQi4UI6XtT4ymJIulUhMWFErDxOCmVG1SrzU35z3XCfSM8qrp7hU+qKnUlRfvojMO9GRJhnZLRJKwqxHT1sY3uKIpMSFcIh9U9+/zxmN5VL8q2XZaWyjxxcnBP3v9hgdG0qdaaVDuI+imKRDoVIRxSu6Yfbdul0Qi0jxoNa1utrfF4iHg8hKbJG3r/GIbF8nIZx3bxW63xvu8zemIIRZMJR3UGD/eS6t17Q87+aIx6yuK7164TVhQQAs+7r506QbxLSktqRV5kUUQRRaQOz/+thGWzI+R+Ep3HDZIokoyE+PorT+AT6Cf9f29f4I9++BELhQrPHB7iG68+yUhPkmR08/U9kiQRjepo2t5QBkkS6euNdzUFzuVqlDp4SW4W94XwyJK0Zan+ThBa53sYlmff96nXTUqlBoVinaWlMrW6iWnaGE2bRsPCtBxsy8GyXRzHXXN1tm0X1/Fw3GDnOztX2JVrqjablI0mmiSxXKnRnzAfS7IDQTpL7aLlshsIh1US8c67TM/3aWxgbvu4oV43u2pJtVXNRam7orIsBzU8hmHhOC6FYp0P3p/k6TMHUDctOyCg6wrZbJT5+dKGUR7P8ylXGq16IRlZkSjnq5iGhed6rMwVOP5sQH72cnPWG4uQCGkc7cmsRSl9HxJ6qGuh8OFMmpFkAgGBiNpZHPFuY6Md5Wp3hG32dfvYHfi+j+24nJ9aZHqlyNRyEV1V+NkXTtKTjBDRVd66NMWhYpqfevb4ps4pSSLRaFvdf2/uoygJd+0AM00Hy96c3Eon3BfCI4i7aTAXdFI8aAPKb3UslMoNCoU61WozKEgtN6hWDSrVJoVCHcOwsGwH03Iwm4EGkO14OLaL63m4ro/nebiOt/b/rrszefBb0dbfGEwlEMQgx/+4QpG3l/LYCmS5e3SzbdT3oKdV9xqm6WwYTWlDFAX00N1Vi13Xx3FcVFXGtl1EUSQW07c0/7TrOwKdnc6p8HrdIpl00XVl7f45totpWISiWtB8scfTlCpJqJJEbIv50JCiEFI21vYKuq+CtIimyGtdWW3l5jbBcT2PumlTa5r0xiOtmhhx7W+OF2zYVFkKjEYFgZD66PlY3U+4nk/VMKkawcZ1MB0nm4gw1pcmG48gCPChqiAKm4+4iaKAriktErs31y0KgWF2t3Fp286OO6jvC+G5k/3vBO0i3gcBwRwXEB3H9TCbNtevr3Dh4hw3pla5cnWJYrH+QC1mIUVBlSR6YhH64lEij7EOj6LIu5Zq7QRJErvuYnwvMIF92AI8W3mmNzP2rbsRHkHYlNioZTkYhk0iGcY0HWJRjRPbSBeKooDagRAA4AdRKeeWDk8tpGIaFqYBg2O9hO+jk/lO4LgeTdsmV66TjoaDTjDbJh7SadoOjuuhKRJNy2GpVGUuV+bZQ4PomoLSImCW69IwLepNi1Q0RN20kcR9wrPbcD2PQs1AFESODGQ5PtyD3CrGbqdajw/3kAxv/lkURaGlYr6HFy4Ige9klzexLHfHHdT3xy1deHRVfH0f3nv/Bu+9f4MPP55mZaUSaFR4/gOZptBvqdoPqcpDkRrcK8iyiLzH7bKKInXNg3ueh2FY+A+hiajt2zTdBgIiqqhheSaSICEJMrIo4+MhICJx9+/Ydtyu4WtRFDfliK7rCj09MXp64lTKjW3rKwURnjbBWj+OfQJy5d4yxkNRnUq+Rn6hxOy1RZ75wilGjvbveZRnt3F1boXJlSLVpokuyySjIfqTUaoNk49uzLNYrJKNRQhrMpbj0rBs3rk6gyIHzSlhTeH0gX5K9SazuRLPxYa5Or+C78NAat9pfjehyhKH+zMMZxJUGk3G53PoqkxvMko8HBTev3h0ZEvPoNAiI3u5aAsCwfjqEuExTXtDtfOt4P4QnkcQhhG0pr759jgXLsyxuFQK1F13eIP2Grfl2e/jdTww2OMvQRSFru3mPkGh7QMUBNwULM9isj5OWI6iCgqG2OB67SoRKUpYiqBJGlm1F1XaXKrF9/yu7uJBR52IcJcbFjjdi620VJTtBoNFQbhrutO5I9Ws6QqiJGKZVuDefocS8V7A9S1cP7AVEJDwfRfHN9GkOJ5v4/pW8K9nIQkqmpQIdv74+L6H69vIoo7ve3i+hSJG8QEff63lOaqr9CVjnJtcoNa08Akc0318ZEkkEdZJRHRUOUh5FasGVaNJsdZguVTl6vwKjusR1TU8z9/QEmQ34Ps+ju2yulSmUTNRdZl0NkYkpmM2bWzLwfehkKuiKBKJdIRIqxvPdTzqtSb5lQqarpBMRwhFNIyGhW0FGjeRqI5pOjRqJpGYhqLK911KwvN9Gk2L75+7Tq1pEtKU4DtGIBnR+cqzx7Z1jYJwt5G2MwgEY7XbY+A43o5dEPYJzw7h+z627TK/UOTS5QVe+9FlZuc2dn69E6oioSgSktz6VxIRW/VNkhgIJLZ1g4Rb0oCu67GwWNox293Heuw90RC6L9J+Sxphry9jl+H6DjlrhSFRwxKhaVVYMGbJqD24ikPF8UkqaTQ2F0r3ucu92OQiKUki7aDdjiTxtxCVbpMe65ZFta3ttde1hrbXoOmW8HwHTYrj+x6mWwb8Fhky8XwbxzORBBXwEUUF17NwfRvPt5FEvXVMg6R2GAjUbUVRJBbSSEZCJCN6UAwd0dEUCcf1ieoqYU0lGlKJh3VUScJ2XJqt70BqqS83LWftPHsJ32/pWi2WqNdMJEmkWmpw4qkDNGomlVKdRt2kVmkiSSKVUoOjTwwB0GxYzE2tUi0byIpErWpw6PgAtuVQqzYpF2qMHumjUmqwslDiyMmBXVdn3w5cz6dYM5hcyuP6PqO9KUzbYbFQJaQqfPmZow9oF65wy38bw9+KwFwH7BOeHaBdmLy4VOaP/+ws5z6Z2XTbnCSJ9PcnGBxIkclE6euLB222YZVQSCUW1dF1BVWR1zo/2vUluXyN/+W3/5LJqdxefrzHDt5dogq7Add1sbukagSxVbz3wE1I3SEIAqqo0aP3U3OqTNSuIgkyKTVNQkkyURsHQBI2tyiI0l0iYR6Ypsu9ooae52PdpX5Alm8K17mOx9WPJqlXDCKxELPXl7C61CTtFqr2PLnmRerOMgOhF5FEnYa9TNmeQURGFGQkQUVAxPQrlO0pdDFJzVnGdEsoYhTbq2N5VWy3zpnMP8L1HXwviPAcG+whG48giRI/+fRRAMoNg3euzvDqiVGiIW3ds/vkwUCfZ6wvzQtHR/b8O2jD84I6yqW5IvFkmOmJZd7/8VV++3d/neWFItcuznPxo2k+8+VT5JbLnH//Bv/8d/4BjuOyMFvgr//0LK9++QnmpvJc/mSG3/qffx5JkqiVDf78D3/ML//GF5ibyvHJezc4debAfY/uQJAKnlgq8PKJUXqTUQ4PBB5V3/3oGouFKrbjBpHKrVg0+K25cQ+vOwgcOF3nX0WRkJWdfcf7hGcH8DyfSsXgd3/vB1y/sUKlYnQ8VlEk4rEQX/jcccbGsgwNpejJxJBbkZ12/YggCoiCsBbp4bYIDw+0z9fDDsf1Oqr67tp7OF7XhVMUBEK68tDpSmmizun4GXRJRxN1nk+/EliW2GUMt8GhyFE0cfOdQ4osoXQpIPc8D9Oy71nqz3M9ml265wRAVeTbukxGTwzi+6CoEgOHeskOJvf8OmUhhC6lWvYJIrZbo+Ys0Bd6hrqzTNPJMxB+npI5he01QPDJm9dQxBBhuQdNSmC6JUJ+CknTkMUwJ4aiHO7rxfN9wi0F5VsRC2l89uRBwtqDVQMoisG8KkoCS/NFlueLGHULzwtSj3pI5ekXxzh15gDLC0UqxQaLcwUKq1UWZgs0aiaXzs1QLTeoVhrM3cgxPJalbyjFl37uDH/2B68zdqyfr//qZ5D2uLtzs1BkibG+NN/+4DKKJLFYqGBYDpdnlqk1LT68PocsSfQmohzs25zVidfKYuzlYPO5e3eqpiooO1CKhn3CsyPkCzUmJlaYmFylWm12LEru70swMJDkxPEBnn5qhP6+OJlMlEhY23JoURD2Cc9ewXHcPSeUgTltZ8IjCIEe0EMW4EEURMJyIKgoCCJRMbb2N1VU0UQNWdj8dKOqMloXnRzP97Gse9e+73k+drcUshAUSLfNQgVRQNVVjFqTwkqdaqlO1kruuWO6JsWJKwcIyT3oUhLPtwGfsNyDKMjYUgpNShJV+nF9ExDRxDiyGEYRwyhiCF0KiJkkqIiCjK5KhNTO1ywJQarrQUO5UCO/UsFxPPqGklimzeS1pbW0iCAKKJqCHlLRWvfOc/014+X+oRQHj/bheR6Nmkk8FUZVFWzbwbIczKaN63hBjRgPRppIFEBXZcKaiuO6lBtNLNsl1DLNLtebKJJEfAv3y/d9LNvZ081FkH50uto6KYqELO9HeO452pPs7GyBt965TqHQudVckSVOnhzk+WcP8pUvP4EsizseGA9SW/ujBNt2b1tE92ICcxy3a+2VIAqomvzQpbRuxa01SgklSULZemRD12XC4c4SCb7nr/lU7TV8PyCqwQ5042OElqefIkutepfgXpZyFW5cmKVeaZLujZPMxJA3LXi4dYTlLGE5e9vv0lqQeooq/e2rRZPiaz8HX+LttWV+q1T5rjVnDzBWlspMjS9h1E2ee+UIqipz4aMpQAg+nefRNGzMpo3VDARfVU1GDynEk2HCEY0XPnuMSEtOQNXkIKpfbjA7uUrfYApVlVmYyTM8lkUSdj637xxBZmCsL0W9GRSv66rMgZ5gDAb1gVtLT3meT7Npr9ku7VWBedN0unYyK+rmLak6YZ/wbBOO4zExucqP3rjakYDousJXfvIJvvZzz3BwNLsrYovB5Os/dF08DwMaDZN6w8T3964Ds1ozKRTqHf8uigLRiLarfmkPI2LREMkuvkem5bK0XMG5R95vRtNmeaXScayLokAqFb5NckDTA2FEo2biOR7j56apFOo884WT9+Sa10PYxM+djn/4EIuHiMRC/Pi7F4JOrbqJ2XTWlnujYXH+vRsszORxXRfTsBkazTB8MMvibIE//dc/4sbVRSBIj/36b/0kywtFFmYKuI7Hr/y3X2T80gJnX7vMoeP9pLJRtD3ymtosJFGgJx4h88RY582AwJZIrOt6VKtGqwtxb+ZG1/VZXa101dkJ6+qOrS32Cc82MT2TY3m5TLPFou+EokikUhG+8qVT9PbGd62gbd96YO/Q7uqoVAzicX1PdjKNhkm53LnWS5YlenpiO+soegSgKBKhkEo8HqJWW58udl2PStXAMCxs2w10QvYItZpBrdbsWGyuafKaLP6tz0xxtYLrePSOZCjnqgwf6WfgYM+eXefdsJVF7mGN6tyKVCbKsSeGCIVUIjE9iFQYFpquIiCg6yonz4xy5OQAuq6CALISpJOz/Ql+7pdfWmvHlmQJRZPJ9iUIR3V6B5PEk2GOnhokmY6QSEeQd1hfshtoP3+dvNC2C8/zqdUCG6TQDtzKO57f9SgU6l3T/clkmFhsZ5199/8OPaRYXCq3nJw33mGGQyq9PTGOHunbgmfP3eF7PoYRFN7tY/fhOB6VitHyjtn98zcMi0q1C+GRRNLp6APR8XE/IUmBB1YyGabRMNcRHr9Vw1Ovm1iWs6eEp1ptUq+vv4Y2NE0hlYoEUhK3LDTNRrAZiiUjCKJAz1CK9A6cnvexNYQiGnpYJZ2NtrSYhLVmAEEERZMZGElz6PgA0XjotjEXieo88cwojt1yh5dEECAaDxGNh+gdCFJE2b4E2cfgnvp+MA6azT0iPJ5PsdzoSngSiRDR6M5qxR7vWXUHmF8oUuzSgt7fn+D0E8OoqrKr1heu51MuN3D39rW5UAAAIABJREFUCc+ewDRtFhZLuO7uRtDa+e9KxSCXr3U8TlEkRobTe7qAPyzQNJmDBzId8/a+H2w8yl26I3cDK7kq+S5pyEhEZXgotS4iGAqrKFqgHnvkqVHi6ehD1333sEMQBGRFRpTE2757SQx88+TWfxttMARBQFEDI9hAE+3xvncrq5Wum7Xtwvd9HNdlaamMZXUmPL29cdLpyI7ea5/wbBPVShBO74RkIszIcGrX852W5TA+vkyzuS86uBdoNCwmbqx03WlsBz4wN19kNVejXjc3PCYS0Ui1tJge9xoegHBYCzYNXfL2Fy/Ns7BQ3NPruHptianpzppXqUSEkycGEaU7CE9Mp1qs89GPLvH6X7zH8kx+T69zH5vHwaN9PP/ZYzz94hihyOPrH7gVzMzkyec7E//tolRqMDdfpFo1NsyYiKJAOh0hGtXRdui9tk94tomm6dxmFHgnVE0mEtndVs12jcnMXOHBUFluuUh3W5pdz3uoCqybTZvpmfyOJczvhO/7waCuGB1TI/F4iGwmui418rhC1xQOHertmhKems6Rz9fx/d2XCfFbLuHz80VWViobHiMIEIvpjB7IrOusUzSFWCpC73A6cBxvRfm2CrGlctz5QtlPcW8RqqYQjmqEwtoDYz79oCPIauwB4Sk3WFjoHFWXZYn+vgSaKu94I7h/p7cJ23K6dojIkoim7a4TsOt6GA2L6ZncA0F41vyFuvqfuA/VZGwYFjcmVzGt7i2SW4HvBwrON26sUCp3ToNm0hEG+vdenO5hga7LHB7rIRLWOupvTE/nWVmttAqKdz8NaTRt5uYKrKxuTHhkWSKZDDN6YH0XpixLpPsSHDo9QiwV2XaaMrDH6DxVe76P7dw71el9PJ6YnSuQy9Vw7/CM2y7aaf5crsp0lwiqokiMHsh01eXaLPYJzzah6UrXCcxxPSxzd0nJ9GyOjz+ZZnGx3LV9715BkkQiXVqofR/KZeOhSr8ZTZvJqVVmZvOUK5uzCbkbfB8sy+W1NwKftU44eqSPZ84c2JX3fBQgSSKJRIgnTw8zPJTe8Jhiqc6Vq4ucfXdi1yM89YbF333vAovLZcwOY/nE8QGOHO4lHl/vEWY2LWauLfLudz5pFcxub7rVdYWQ3nnz5NgupVJjz21R9vF4Y3auwPRMjvldTCG7rs/Va0u8+c54x2PCIZXPvnqUaGxzPnzdsE94tolwSOsaam80LPKF2q5Mwu2OlEuXFnj7nes7P+EuQhQDKwSlg8fJymo10HBw3IdGMNHzfN555/queZUVS3U++XSGfK6GaW7spxQOqwwNpjhwILMr7/kooJ3We+H5MQ4d6tzOPTm1yutvXME07V2LJtq2Q7FY54c/utJVRuDM0wc4erT/NnPfNfig6gqJTIxoIoSiSttKVQoCSLJIOKxuWBNomg5Ly2Usy3mooqn7ePgwPZPnrbfHdyX67ftw4eIcU9N5yh0i36oqkUiEOHqkH30XMib7hGebiMX0rjegWmuy3Mr772Sdb4f9pmfyjF9f5sYDZBgqCIHXVywW6pi+q9eblEqNrh1tDyIuX1lkcnKVQrGzivZmYFkOq6sVPvlklnrD2jBPLQjQ2xMnm42SiO+tg/TDiENjPYwMp4l12OEVinWuXV9m4sYK9bq5o/vVrttZWa0G421yZUOSKooCsajOoUO9DPRv3JYsyRKxVITBQ71kB1No22znFVqp43g8tCFhclyXarVJvlCn0aWRYh/72ClWc1X+f/bePEiu7Drv/L395b5WVdZeBRQK+w70yubSJEWym6aojZqRKFKmZMWMZIcUIc+ENeOZcVgx9vififCEZuQZ21qsICWPJVMaihT37mZvaPSKxr4Vaq+sqszKfXn7/PEyE1VAFVAoFLqbNL6IRgOZL9+797377j33nO9859z5OfL56n3RKhzHpdm0OHtulvmFwobZWZFwwM/OSoTuu6wEPDR4toze3hjx+MZKsIuLJS5cnG9ZwlubgH1jxycq/8e/PM0bb95gZWXjlOb3AwLQ358kFl3/Xti2y+R0jjPvzgA/PmUxLlya5/U3bvD66zdahNh7I5y2j19ZqXLu/Bz/39++vWEYUpJETp4Ypac79pBAeQsEQaC/L8H4rgwH9g+su+D7Ho4yf/SnL3FjKtfhGNzrWGsfb5o2L718hb/4f1+jXl9f5FPTZPbu7WPXjm66u6K3fS8IAqFogOHdfTz2mcMceHwXsXTktuM2C11XGBpMrStI2Z4j3n5nivn54pb6/hAPsRksL1d4+8w0L75ylXy+2hlr9zo3GoZFdrHIN791hqvXFjc8dmQkxZHDQ4jbJAvwUHhwixgf6+HChbkNv69UmkxO5vj2d8/y6MkddHXd+2RXqxlcvLTAt77zLq+/cYNmc/1wyPsLgV07u1laKm0Y2z3z7gzFYp094xm6uiLbTuZ+UHjn3Rlm5wrYjssjJ0ZI38OCZdt+ds/X/uOrXLy0QHODUJbaUuR+9pnDdN/HgviTjv17+wiHNM6fn6NWN27LorNth/MX5vjTP3uZwwcHefYzh4nHg0jS5idJw7DJr1T5s6++wqXLC8zNF9c9TpJEurui/OqvPEkqFb7jOR3bwTJtX933PjJMQkGNvXt6OX9hbt2dted5/M03fKM6GtHp+S9ADO8h3h80myZ/9tVXWFoqc+zoMI+cGL2n3y8uljl3fpav/82brBRqGxZsjkUDHD82ytMf3b5SLA8Nni0iEtHp6orS1xtnfuH2idF1Pep1g5dfuYIkCYzt7GFoMIV6lzi+adrUW5lY164vce36EpcuL1Cvmx0rWpb9rA3X9d538rIgwM4d3Vy5mkUUhXV3w/W6wdx8gW99+10OHRyktzdOT7dv+Kx3L9qbBb96uYNh2DSaJpIkEgiohEP3XmX+XvrTvr5hWCznKrz08hVKpToDAwkG+hP0dMfQNPm23fZqYcHsYom335nm0uUsufzGXK5UKszhQ0OkkqE76s3cKzzPw3E8HMdpVWh3sWz/747jYll+Zfh29faVlRr5OwgiNpsW+ZUq5y/Md8afLInIitTJIlIUCbn1d1kWkWVp23ZmwaBGf1+CJ58Y4823p9ZNEzdNm6mpnN83x2X/3j7SqQiJRJBEIgQIazgw/j1yWSnUWFoqk10scX1iifMX51lZqW6oxTQ6kubQgUH6+xIbJi54nofRMFmaXWHu2iIDYz0kM3GCka2VLAkGVXbvyqCpMvVWvbdbsVKo8c670wCcOD5CbyZOKLQx19A/h4dpOq0K4A6NpkkoqKHpMoFtqgvlhwm9tWPPuTn2bNtdMxZLpfodyf3+MQ0uXVogHNb8sSf7lbRFyR93iiwiSVJnLCqKiCCI265v1e5bux+O42K3+ri6v6s/r9SaG44t1/XIZkucOz/bEkXc4F3rCCYKnc8epJTF6nnRT0apc+bdacrlBisrNXaMpkkkQsSiAVRVvq0tjaZJtWowM7PC+YtzXL22yPTsCraz/n0QBIHDh4YYGU4Rvc9yEqvx0ODZAgTBr8PS0xNj11gPC9nSui4903I4dXoCQRAolRroukI0oncGpyAIfiqpd3PyrVSaLOeqvPTKFU6dvk4utzZWKkkiiXgIURRoNC0s68GqzG4GO3d0k8nECQTUdUX1HMejWKzz1994m2Kpzr69fbj7+onHgv4E1H45vFZirdeq0GtYNJsWpXKDQqFGKKTRm4kRCmoPpICd3ir2uFpywDRtTp2+ztR0jqGhFCePj3DowKDPW9IV2vOnh9/m2dkVLl/JcunyAi+8ePmOej6yLNLXl+DJx8fQNQXpPsJZ7fFXqTQ7IR3T9I1F07IxDItGw8IwbUzTptEw/e9M/7tCob6u4d5GrW6QzZZ45dQ1NE1GVSR0TSEQUFFVGUX1a1/pmoKqSmiqQiCgIEkioiQgiX5G31ZLZiiKRDQW4JOf2M9yrkq53FjX45lfqVEo1rl6bZHsk+OMjXUzOtLFjlYVaUHw31/P9d3whmlzfWKJc+fnuHZtkTNnZ+64idB1hf37+nni8TEidzFejLrJ/PVF3vzheWzbQQuoBMP6lmpyBoMau8d7iUQDVFvlNG6FZTmcPTfH9MwKluNw9NAw3d0RwiF9rXepFSr3PA/X83l2tZpBrWawUqwzPJgklQxv2eBpj8V63cS0/ArzlulgWjZma/PSHpfNpj8Wzc64tChXGszNbZwJZJo2uXyV069PEAxpqEp77MkoqoymKQQDCqoqoyp+9XNdVzrGuCSJ6Lqy5ZI/juP6NdxsB9fxWv+2MAwL03JoGtZtfTIMq2NQlop1zA3GmOu6TE7lePmVawQCCpru90FTZf9d02RUVSagK2ia3wdNlVBVxSe3SyLhsLY+iX6LaJ+zXjdxHLezqb18Jdvhln7kqXF2jHYzMJDs1CFsX931/Pk/u1jm1VPXeO31CXK5yobEZ399lXn8sZ0MDqS2VXX+ocFzH9gznkHTZF45de2Ok+Sp09c5/cYN/sNXX2Hnjm5SqTDxWBBdVzBNC8OwqdUNJqdyFAp1qtVmZ0JaDVEU6O6O8Nv/8Ke4dHmeCxfnOf36jQfdzbsiGtXZt7eP5eUy3/neuXWP8Txf4+bb3z3Ld753DkEQSCVDBAKqn72CgG07/oTRtKjVmth2m4vhn+PggQE++8xh+nrjiOL2l1740JPjxKIBLl9e4PKVLNaqXdhCtkR2scTrb9xAEPz6Sb4B6+8+DMOmUmnQaFqr4tp3vt7B/QM88dgYTzy+674NOM/zd76/9z/9J2ZmVzANG9tp8ce8O7PI2jv9O7W3UmlSqTQ7mWtC54/bIaz6w/fKKfT3Jfgn/92zDA6sn16+GciSyJFDQ1iWw+hwiv/0n99Y9zjX9Wg2Lb7/w/P84LkLfnkBWSIc0tADviFWrRrU6ybNptkaZ3C3eyBJIj/3+RN86MldjI9n7rqg6CGNaCpMqjdOo9rEsd0tFyCXZZF4PMiHPzTO62/c4FKrivetsG2HfL7KV792iq/9+Sk0TSEWDRAKa4iC0OL72DSa/iLcbFp+SMG7qeLzK7/8BMeODt9TCPf2drj84b99jpdevnLzGsDd7vHN7zY+yDBs5ucL/NVfvwlsfiyKooCiSAwNpvil/+oxnnpy/B56dBPzC0X+3R+9wLnzs9TqZqtvd3nPVn13J76L43iceXeGd8/O+u2/w3i5+Z2AJAmoqsLwUIr/5Z/+NPF4cMOSLPeKgYEEv/kbT/M333iLiRvLZBdvelebTYvrE0tM3FhGFP01KhTUCId1ZFnC8zwKxTqGYWFZzqbmxVQqxMH9Azz15DjB4PaqYD80eO4D4bDO0GCKzz17hFdOXWMhW1r3OM/zdwVG02JyKsf8QgGlVb/FdT0c13d91ut+5ef1LF9JEjlxfIQTx0bYvSvTqS77fqM96e8a60GWRM6dn2U5tzGD/6Yh578I5Uqz42b2XF+Ntu0ivvXFcN27vyz3A8u0SafCnPylx/n3f/IiC9ki1epNj9VqI7TZtPzdW93seHd8kcW7N1BRJAb7Ezz7mcPs3p3ZNje753mdhfxB3at2/73OH3c8upMmXa02ce9Tvbo91sbHMgQDKp7n8Z3vn6daXT8za/VYc12XkuNSrTWRJLETfnA3qQTe1xvn+NFhnv7YXrq7IrepKq+9rofruJz+7lkqhSrRVJhwLIi8xbT0m333+OiH9+DYLoVCrZMFulEbPM8fp47jUCo3OgtkO7zkut66/ffcu1jIm4DneTTqfhhjs/d4K9eAzY9Fx/Hn4WqteV9UAP8cBo3WHPBA+7apc/t9s22/b47jbpsGp6JIxKIBxnZ28/M/e5JTr13n+RcvsbRUua29/v31qFT9eyMKAh601rRNvmeZGIcODfLZZ45sSHm4Hzw0eO4D/mDQOXlylKVcBdtxyeUqGz5Y1/OoVpv3dI32rmTHaDdHDw9x5PAwsViA3t44yWTYd89/ADIyEvEgwo4uDh8a4szZGfK56oZE3TYsy3nfOUirYVo2iiqxf18/R48MoV9SmJzKUanc/sz8xcLbkHC3EYJBlXQqzPFjI+zd27tuhs/9wF/I3//x0IbXKnvgKwFvD3wyssijj+xkdq7I9GyefL66oThgux0+z2Lz1xEARZXp7Y2zezzDIyd3MDSYXDdTaj1YhoUkS0STIaKpCMo2kPUHB5Ls2d1LdrFErW7QaFh3DJu2Q5vw3r9nbQ7LBwntd/Z+9Io8r7W5cR7sBuxe4boeju12jPztQCikkYiHiMWC7B5XqddNCsU6r795g2q1ue78t5XnLooC8XiQ/fsHOHxwkPFdPfeUcLBZPDR47hOKIvPoyZ24jkc6FeZvv/XOKhf5/UNVZVKpMF/51acYHUmTSvpZIf19cXq6oyiK9IEoMyFJIvFYkK98+Sn+w1df5sy7M0z9mBVLbDT8OHsopPGlX36SF1+6wg+eO8+bb09vi1EpCDA8nObo4SG+9MtPoCj3Xxvmv1REIjrHj42QSIT40UuXee75S8zOrWzrAiTJIulUiF/4uRPs39vPyHB6U78TBAFREjn60X0YDQPbcgjHgj5/5z4gCP7m5/ixEQYGEiznKkxO5qjc4ybqIR5is+jLxBkaTCJJvvDlyROjjO3sodEwuXBpftuiDLqucOL4KL/484/c06biXvHQ4NkmHDs6zI4d3Rw/NsLX/+Ytpqbz5HKVu/9wA6iqzMkToxw6MMhjj+6kpzuyZhDIskQyEWLXrh4udvR+3l+0rfSvfPkppmdWeOnlq/zwhYuUy41tMcoE2HYX52o0Ghb1ui/cFgiofOTDuzlyZIiXX73KCz+67JebuIPq7kYI6ArpdISf+enj7N3Ty0B/YsuEyYdYi+GhFD//Myf4xNP7eP5Hl3nt9HVmZlcol7duBCQSIQ7s62f/vn6e+tA48VhgS89LlEXmJpZ450eX0AMqTzx7lNH9A1tuVxu6rjA4kOR//h8/x0svX+XsudnOjns7DD5fUPShIf4QMDKSZtdYpvNvRZFIp8P87u98mjNnZzh/YY7nf3SJfL66pTUo0xPj+LERjh4Z4uTxUYJBdcuJDZvBts+6PqFT5umP7WV8V8+6x4wMpzdtwQmCQDQS4Fe++OS6Ac1IJEAgoN7TTvmJx8boSkfW3bUf2DdAeAtVzjVNIREX2DXWw6d/6iBz8wWy2RIL2SLFYr3lfjYxTacTP5faKZSKREBXiMUCRKMBYtEA/f1Jdu7oor8vQabH9+SsXuwFQWCgP8FnP3OYE8dG1tTR2bGjm6H7IIduFYLgk+cikQCDg0kef2wnyWSQhcUSuVyVfL5KqVSn2fSzhSzTwXH9eyGKQieVWVVlggHVz7zQFaLRAPFYkB2jaUZHbi/SuF2wLBvLslsZDqDrKrIsceTQEOGgxkK2xOxcgYVskUqlSa3uZ7a0uTttRVxdV9ADCslEqKWgHKG/L8HhQ4N0pSOEt7jTb8foLcvx71FQxTRsZEVCwA8RfvaZw5RaFdlVVV5VbkDg2sQiyUSYTE8U23aQJKnVb6dzTwXB91r6xTh9w9o0bWRJQpQEmoZFQFeR7uEZiJJIKKQSi22vinSHjBzW0TSFE8dGSafCLC6VmZ8vsrhYolL1M5CqNaOTHtx+9xRZQlF9MnMsFiQS1kkmQwwPpfz3LhOjuyuy5ZRfRZGIJsP0jXZRbHEePM+7b6PdzzYTSSbCHDowQDoVYXQkzY3JHKVSnXK1SWGlhmHY2LaD1UqZFgSh855pqp/to2kKkYhOMKgSCmqtsEI/3VvQDQPw3AKus4RIhI88NczwHUqleF4dz5kEFAQxiSDefqxrXcBzF/G8BrL+GW5lJ7vODTwnh6SebJ2zjOfM+ueUuhCEW4rxCgLhsMboyM1SJa7n3dNmKh4P8umfOsjxYyM+Ef0e4XkerMpiuuOx7WZv8tzRaIBwWL9nAdN0OsKXfvlJ3Naa2L7e7t29axIN2mMoFgsyvquHWDRAVzrMxI0cKytVCqU6hUKdRt3AtJxO+r0s+Sn2obBGPBYkGg2QToXZuaOHkeEU/f2Ju2Y9bgeEu7jq33+3wfsMw7Zp2DYN2yKu6wTkzcXh26TCc+dmmZrNs7JSo1CoUauZnYlXUfzFMRDwMyn6+5L09sbo60twYH8/miavSVV2XBfLdSkZTcKqiipKKNKDcf2thud52K5Lw7YxHJuIqqGI4l3TqP1Yt8vs3ArTMytMTCwxO1egVG5QqxrUG+1FyEOWRVRNRtNkwkGdRCJIPB4kHgvSm4kzMJAklQyRTIaArXt6/tnv/zU/eunyujvhwYEkJ0+M8o9+8xPr9qVcbjBxI8e58zNkF8vk8lVyuQpNw/IJuYJAUFeJRnVi8SAjw2n2jPfS35dgoDVp3M/73DQs5uaLNJsmwaBGPBbAMOxWOr2fSaXpip8q67pEwnonlVSSRL73w/OMDKXZv7ePpmH5XgvBL2wqeF5rsvOzLKq1JggCoaBKs2mjqr7GTqXaJJ2KoG2jZtBqeJ6H43kYjm9whZR7y9LwWjy5yak8Fy7Os7hUYjlXZXm53Ekltm3XT1fWFYIBla6uCP39CTI9MUaGU+wayyDL96dr0tbhqRRq5BaKXHlrkqMf2cvgJrK77nRO23YxmxamYXWeqyRLKKrMuYtzLCwUyS6WmJzKU6k0MZoWTcPPBBVFP2tO02TCYZ1QUCUS0enpjpFKhUkmQwwNpsj0RNfVUrlDy1rvk4lnT+HalxHlEQRpCEGMtTaWLj6PyAUUQMRzl3HNFwAdQd6BKO/sfOdzE12c5rdwzDfw3CW0+B8gCGLnXoCJY7yMZ19HDv06giDgOjO45ilAR5R3I8jD+Pv6m3NV28ChxX9s2jaiIKBKUocT6UErq61lANxioDie1yGut43Y9rHuqt+3z9E5r+dhOA6SKKKIImJbnmTVb9vX8zwPw/Y3YHdrG9w0Uu65bfgLvYe/3kmCgCJJnbbd8cm3+nTpcpbp6RzTsytMTuUpFGs06manLIvSet+60hEG+hP09sbZNdbN+K5eZFnabofihmd76Fe/C97MzvP1yxf46ysX+deffJZnxjaXyhiP+wv2+K62O9DbOJtAaD+hm7vs9bBUr3J2aZF/+qMf8FvHH+Vkpp99Xd331J+tYqJY4OtXLvC9G9f5J49/mKM9vaSDG5fWaEOWRUaG04wMp1tpoHfPPlidbrn23w8WruveMZMoGg1w5PAghw8Ntj5Zn7S4uv3b2fZ2do4gQD5f5cJFg9ER31taLNV59bVrxONBArpKQFcJhXwPVTCg0t0VIZOJUSjVeeGlK+i6gm07BHSF3t44N6aWKRTr1GoGwYBGoVhDVWT6+xKMjqSp1Q3qdQNFkVselQczdbiex3SpyCtzM7iuy5cOHb3nc4TDOgf2+yEpHxuTS9eMNWHzO+nNoF5uUFwuk58vUCvVsS3bH/73cZHJywu88oMLnPrhBZbminT3J9h7ZIjPffEJjh4a4vjRkdaRd37P1o7L7XjPPFzrbfBqCGIYhDRw01PuuVk8ZxHPXUFUjiKILQ+S5wENPPsarrOIIO9DkBKt3wpI+jN4noFjvnj79cy3QNAQ1RO3fOWf07UvITgLiMoeEJO4noTtuuTrdXRZRpYk6pbFmWyWkKKwK5VCl2WqponjuqSCQeqWn22kyTKS4OtJOY7Dcr1OMhjEbRklAVnGcByatk3dsqiaJslAgHQoRLnZRJNlX4+m0eBiLkdPOMxIPE5Xaw71AMtxWGk0UCV/I1u3LM4tLiKLInu7utBlmZplYdo2XaHQmraJgoAsin4duFqNRCCABzRtm2CrbYZtU7MsaqZJVNfJhMOUmk00ScIDis0ml3I5EoEAOxMJukOhTT15QRDYu6eXvXt6b8o7tDt127HwXs/rq3Ffs9Zb2XkqpsHh7l4iqnpfwmkfZLitXad3Dw6vjtV9y+J9P/Ba2aKu5+G4Xmc38N6glTLuuTiuu6l7cevuYPVg/yCifX/Xw9pwYudvD7pJayDLIqlkmOnZPIZho2kyA/0Jrl1fYiFbQpYlopEAkbBOMKgRCWvMzhcwTJuR4TSRsI7netQck1rdQNdkwhGdwYGkXyTVBa0V5kjEg4iCgCSL9PfFqVQNcrkK124ssbtlxHuex2ylTEzT0SSJG6UCw7E4rudRaDToi0SpWyYVw2C2UmEoFiOiagQV30uab9SpWxYeUGg0iOs6feFI59xu6//ZWhVJEAnIMookMVspUzFuygX0hML0RvzfVUyDkmGQrVYZjccJqxqKJFIymoCAKomEFJWlWg1VlgjKCqoksdyoU2w2KTTqKJJMUteJaTpxfetu9mAkQKVQw3M9dh8f9WtpbXHItHfS3/jaKa6emyU7W8A0LLIzK37YQIBf+91PE+qo0r7X75mAIARx3RyuPYfogajsB0/Acxaxm3+HIIQQpB6s+r9H1p/1vT+Aa51DkAYQZR279n+jBH8BQd6FICitfrT/u/WSQTzrTT+EphzpfOzh4VrvIsq7QJQxq3+IEvoyK0aSq/kSHlAzTQzHRhElFqvVjoHx6MAA+XqdbLVKzTTRZJmIphHVNObKZVRJIqDIpIMhTs/O4rh+qLBiGKiShCbLRDUN1/OYKha5vrJCJhymKxTCdBymikXy9ToNy6JmGDw2OIgmy5SaTS4uL+MBdcukYduoosRSrYYoCBiOwyP9/RQbDebKZd5eWECVZcKqSkLXmSuXkSWRgKzQFQoxMT+P6TiIgkDVMJBbbYu12lYulbhRKJAJh0kHg3iex2SxSL5Wo2IY1E2TJ4aG0CTpjuv6j9scvyWDp+12vpBbZqleZSyRIqxur0DQQ9wOXZbpCoZ4cmCIgUj0Pb3nIUVlLJGkbAzSFQyiPgDhv4e4MyRJJNbieNm2i6pKhEM6oZAfF5dlke50pMN9CgZU6g0TQRB84nQyjK4pPpfM8r07yUSIcEj6pb/UAAAgAElEQVSjKx0hGFSxTAepxfEAP8U0HNKRWrvHZDHU4d+5eFxdyTMYjRFRVU7Pz5IKBLFdl6uFPHE9wGy5zGKtium61PMmmVCYnYkUkiAwUSywUKnQFQpRMQwkUcDjJnfEcV0KzSY3igXius5AJIbrudRMk6LRxHFdFqoVHM8jEw5jODaTpSIrjQaW63I+t8RQNE4mHCZbqyIiEFZVgorKVLlITNPpCgZxUbheWKFkNBGAhWqVPan0trxffvmX+yfse56HadhcvzjPwuwKRsMPFTQbJvlsiUvvTGOZzrZwhO4draCIGAdnGbDw3DJ4FnhNPHsSvCaISQQxgefk8NwcnYVREBHEMIKQwHOyeG4Bz6sjCHeqByYgiHH//M56IowSCBEEMdI6ZxHb0alblm8UNw0M20aXZWzXRRQEGraN6TgUm02WazUatk1M9/l2TstzokoiYVVDlxWWazXslsHTsCxCqgqtUFHNNKlaJqbtMBz3NwF1y2SpVqNpWdiOczOU1FpP67ZNxWhSMUzqlkVAlnFct+OJardtqdW2qHbTg7ZUqyG3jPmAorBcr3fCU3XL6mwyJF3veKAats1wzA85NmybpWq1RVtwfKPxg5Rzv03YsoenYVmcmpthqlTk2bHddP0E3pwPGpKBIMlAkGOZvvf0uoIgMBCN8YXoQb6w9+B7eu2HuAlZlnxuU8J3g7fj9ONjGcbHMuu6iDOZWOfYnTv88GebB7CaqLl7V2bN79qTXfsaihIgEvGFNldLxj8/PcmxTIZ0IMifvPs2xzL9GI7N89OTDEbjvDQ7zVSpwKd27OLrVy4wnkzTG44SUVWem5zgjewcz+wcJ6Lq2KuzPASo2xbnc0ucnp/hYFeG3ck0puugShKqKFJ1HF6cmUKRJI70ZMjV6/xwcoKaZfHhwWH+4uJZPjw4wseGR7mQW0YRRTLhML3hCKfnZxmOxRGENAFL4QeTE4jAx4ZH+erkGcKKyr70/YWLm3WDRq1Jo9Jkea5AsidGoiuKsAV9Ecd2qZYblFZqHWOnc52GydxUbksE2u2CIAgI0hB4Jng362B5Xg3XfhtRPY4oDSNIaSRlH7hVPM9AQECSDyEouxGlYURll09mdpcRxI0NHkEQEORhHDEFwtplTEBEUo4gqocQhCSisgu8EgEpSCaS4OpkHqfFXWnaFqlgiIiqEtV1yobBcr1GyWjSH4mSCARwWzwfXZZRWt6OfL3uc4Y8v15dKhgkpmlEdZ3uUIj5ShnLdQmpKqOJBEu1GiuNJtlqFV2WcTwXw/ENEkEQ0CSJ3nCYiZUVzJYx1LQtkoEgYU0jpmlUTJNcvU6h2WAwGiMe8L15DctCk2VkUfTD3fV6W3WTZqttbS9VdzjMQjaL0Qp1jSQSrDQarDQaZKsVdFkB/DCdvAkOz48btmTw2K7Lm9l5lus1HO+DJSz1EA/xk457mYI2OvZu59jM7wQEFEkkW63StG0+NryDieIKnufRF4rw2twsU6UiS/UaL0zfYKFaJaJqXCvkOdydIagoDEfjfGHvQQQBZEHsGFiL1SoX8zku53L87mNP0hf21Y11SWYsmWSyKPLdc+/wD46cYDgWw3IcXp6ZZq5aoW6ZvDAzyXK9xlylzERx47pMHv58pssyQVmmJxwmpKqEW//dD7SAiiAI1KtNXNvl2pkpKsUah57cvaXzbbz2+F6FD2YkQQSC4DUAs7UQV0HIgKADRaDhe4Pw/OMECYT7ufde65w2CG7r2goRLcRuPcVwLMal3DKlZpNHBwZbhoLQIfL2RSK4ntcxRtpnXJ3g094wtEnAbeNAEAQkQSAVHPN73yI7dwWDJAMB9nd3dzw7AqC2kk5Cqsp4KsVwPM61fJ5stcqTQ0O3tW0gGsVx3bu2zf+LHxaWWr9tty0dDHaIy5IgkAoEiOs6u9PpTtsANPknj+K76R55nseb2XnmKmUWqhXOLi8yXS5hOg5/fOYtYpqOtOqN/Nz4HsaT6TUS7G1G/IXcErOVMnOVMk3bRpUkwqrGnlSaPakuopq2rnT7SzNT5Bp1JEHg6eEdTJWLTBQLTBYLWK6LIopEVI1P79xFTNPRb3lgrucxX61wvZBnvlJhuVHDcvzBo0oy3cEQB7q7GYjEbpvsRKBqmlwvrPBmdp7FWhXX81BEkZ5QmIPdPfSGIkRabkbDtllpNvjquTOMJVPsiCc41L12F93GTLnEC9OT1C2TR/sGOdTjH+e71yu8vbjAxdwyzip10CcHhxmJxemPbKzU23ZVXi3kmSmXmCuXqduWryArScQ1naFojN5IhLHE7Smhb2XnmSgWmCjc3LFpsszHR3YwHIsTUTdO33dcl6Zj8/r8HAvVCivNBk3bJqQoJANBRmJxjvT0oohrs2EWqhXOLGXJ1+vsS3eTDAQ4PT/LYr3mu3cFkZ5wmH2pLgaiUaLa/Ym5/bhhvR3XnTZh6x9/95Vxs79LaL6L3PE8jmX6mCwVUEWRvkiEimnSEwrRFQpxpDvD/q5uknqQTMhXCJdFEU2WO+52oDPGZVFEkyR0RWal0SCiah2S/I1CgdlymdF4gsFolJimtxYej4FIFE2S2ZvuYl+6i75wlJ5QmPlqpb3pBaBh21ithSOh6yiiSM2ymCoV+cjQKCPx+B3LR2wGoiQSCOkkuqNkp/PEuqJ09W9NLkKURAJBjXBMp1KqY65SldYCCpmBxAPVL9kqBCGEqBzCtd/FcZcRxCSeW0AUoiAmcJ0snrOA4Nl4zjyeV0EQwghCGM8t4loXce2LeE4Wx3zRz7wSwoCDa53HtS/jdr4bB8/wDQBnDg+hdZ4KiFFEMYYoiIRVlaFYnGbI7szzq8e2vIns0/W45x0DxPMItNae9meSICBx08BZbaC0M8AEUUQWRQZiUeK6TkhVb0uXv9+2Aegdfunm2vagsTyTZ3F6mclzM5iGRf/ODI8+e+yBXOueTLhL+Rxnl7Jcyue4USr4hEMPvjNxFUkQ10y8xzJ97EqkOrNxO7V5plLipZlpzi0vcq24Qr3ljktoOo/3D6LLCqPxOLF1FrLT87NcWckhCiLjyTRnFrOcnp/l7aUFmpZPQEsFAjzWP0BQUdBXdc92XeqWxdmlLK/OzXApv8x8pYLZShEMyDKD0RhBRSEdCN1m8AiCwEK1ypmlLN+6foUbxQJ2y8gaiMSwXRevx2NcTXeut9Jo8MfvvsXj/UM8NTjMwa6ezrnacFyXqVKRPz//LpbrkNADHYMHoNBs8FZ2nu9MXKVu+THmimmgSTKaJN/Z4ME38F6bm+HMYpZrhRUqptHaWcikg0FO9vZztKd3XYNnoljgldlpXp6dxnTsDpGuPxwlHQhtaPC4nkfdtpgtl/j+jetcK6yQrVWoWRZRTaMvHOFQd4a+SJSkHliz4C3Wqjw/dYMLuSU+NbqLkXicb16/wlSpiOnYyIJ/v2s7xvCAfWnttnv6fsBrLbi2e3NnaDpOZ6e4ere0+th2dgXQOV5rTTx36pPXSiN3PA9ZFBCF936xE4BUIMhUuUjTsDnQ1c3Ls1NEVJXjvf1kqxWUllFzsLsHzwNNkjrPu71rXQ+6LHdIzFPlIqokdTgL55eXWKz53EFREHDxQKCzUYrrAQ61rtfe9ARkmbJhUDYMSkaTimn4oQNBIKbpeJ5Hodng6kqeJwaG6A6G7lmf5bb7IwpoQZVoKsLizArp3jiZoc2pNd8KURTQAiqZgST1qsHKcgXXcZFkiVgixM69fb4e0/segmhZle12CEFEZR+O+Qp4y3jCIh4SgphCkFJ4TgjPtvCcBTx3BQTV184RguDmce0reG4REHGtiwhiD4KoAGbruxIg4FoXEcVunw8kBPE8E8+ewRMUEDUEIX4zMwzoCYe33MNbU9TX+34z59jos3QwRDq4uQype23bRte+l++3G+V8hZlL87z+7bdZnM5z+CP7PhgGz6N9/exLd1E1TX4weZ0XpifxPPit44+QCUfWWJ+7U2u9O5brslSv8Y++801y9RqpYJDP7hynLxJhqV5norjC//P265xbXuSjw6P8+pET6zUBw3EoGXV+/+Xn0SWfdf4bR07geB6LtSo3igV6QhGCt+jlzFXKvDI3ze+/+DxBRaE/EuUX9x6kKxTCcGzyDd+wCCoKMe2WhVwAURT507Nvkw4GOdDVzdOHjmF7Lou1Gl87/y43igUe6x/gXz39KSRBIKgo9IbDHO3p5XphhYiq8isHj9w2GPONOlOlIhfzy/z9Q8cYiSfalwRgVzLFb598nF/af4jrhRXOLGX5gzde29TzatoO//zF55gul9Blic+P76UrGMR0ffLbmwvzNGybomms+/tnx8Z5eniUlWaDN7PzfHfiGq/Pz931uobj8MbCPP/ry8+zWKtxPNPLz4zvpTcc4Wohz8XcMv/mrdNMlgp8Ye8BPjI0uub3nucxVSryR2feJKbrHOru4SMHDiMIAsv1Ol89d4aJUoGDs9P8X5/+e2s8i+8XbNelZpnMlMtkQmHCqspb2XnKpkFPKLyGd+V6HlXLZL5SIaSoDMV8rsLl/DLFpsETg0PczXwxXYeaaTJbLjMUixHXt1fUbzMQBIHxZIrleo2VFq9goVpBCEcZT6bZm+riry5d4KWZKd5YmMNwHI719PIzu/d1uBAbIaSojCdTfPHAEf63V39EsdlEkfzqyy/PTjNdLlIyDN7MznOit48nBoZ4engHf3TmLU7NzfDy7FQnzPbRoREOdPXwb995g2y1yumFWSZLRYZjviid7brMlEtMlorULIvJUpFPju7k0b6BTeturQfX8WjWTSorVbr6EgRC+n2FnURR4Jf+24/zyvfP8+oPzrM0X2JwRzcHT47w0196ksAWBFO3HZ4L2IAKggiIIIRRwr/T+tzxv2vdCEl7Bkl7pvW5g6/D07pJYh9y8EvIG8jvycEvr/udJO1C0p9tXc9rnfMhPqjYcXiYoX0DHPrwXv7d733tgV7rngye/kgMx3M7YamALON6sDOZZDgaXyOCF5SVNb72a4U8r87OMFsp8bO79/NIXz9HenpRJcnXH2g2CCkqby7M8ercDI/2DbAn1XWbsF7VNLlWyPOZHbt4YmCI/eluIprmZzG4Lk3bIqyqa4wtw/Hb+9Vz7xLXA/zi3gN8aHCYnlAYVRJxPQ/Ldfn0jjH6bjHcAPDAdlzGupIc7+3j53bvJ6KqeK32WI7DCzOTzJRLXF3JMZZIoUgSmiTz1NAIf3npPAu1KhdyS+xOptf06dzyEpfyOQQEHusfYCASXfNay4JIUFboDUdo2jaLteqmnlWbFHc5v8xYMsWxTB+fG9+DIkot74LL08M70GR5Q3E3TZKQRRFdVliMVNf1uq2H1+ZmeHF6koVqhd86/iiHujOMxOKoksSj/YNcXcnTH4nyo5kpdsQTZEJhxpPpNTHppm2zN9XFsd4+/ut9hzoet4ZtYTo2L81MM1spcWUlx4548rbw5f3A8zyajs25pSXOLy8iCAIHu3voC0foCob45rXL1EwTURAZSybZmUhSMpqcmpshqulEVvM/PKiaBhOFFbLVKkMx34v43YlrRDSNoWgM14syXSry0sw0k8UCuXqNHYkEPaEwmXDktrY5nseNQoEzS1limk+SLDQbnJ6bJdeoo4q+F6Vp2xzuySAKAq/NzVKzLXbEE4wnU8Q0nVfnplmoVrEch95whJ2JJF3BEN+/cR3bc0nqAfZ3ddMfia6bmioA48k0PaEwlusiAP/9Y0+hSVLHpf+J0Z080tePi+/Niml65/367NhuDGdtUUtREOgNR/jk6BgevnfsiwcOo0l+ui8e/DfHTtK07Y6HMapqnazBz+/eS9U08fAQBZGkHkCVJLqCIb588CiG43spTdchrgdQRYm/uXqJJweHeWZsnIFIjBdnJqlbFhPFAvvvg7gsiIDnVyYXpZbOz1a9RYIvEjewo4tP/fxJHv/4PkzDRg8ohKIB4qnw+1aXzXPruPYVXOs8nrsIXhU5+GUEMba2v54MSLRuxC0nkfCJA+t8d2d/yh0aJtNhpHwANkXbjUK2yPV3pzj97XdIdEUpr1RpVJsEIwE+/ZWP0T2URlFlzr54kblri4iiwGd+7WkAbMumWqzxf/72n/CZrzzNziMjXHvnBjfOTjOyf5ATP3UYALNpMnVhlq/+i6/zm//7l0n1JbAthxf/8hQTZ6cor1Q74dZDH9nPkacPEIzovPWDsyxOLtOsGUxdmKV/LEPPcBfnXrmMqiuMHhjiE198Cmh5pe7j3bgXbHqVEFpeCwBV9Cc0URARBI+wqhHV9E4McD0s1qqcay0e+9JdHMv0rQnHpAJBnhwY4q3sPPOVCpdXcowlUyisPafd2tnuTnWxJ9XFWHJj6fI2Co0Gs5UyN4oFTmT6ONTdw8Hunju291Z4eAzH4hzs6mHXqms2bd+V/9r8LFXLZKleYzSeRAFkSWR/Vw9/d/0KFcPgcj7HzkRyTZ8miivMVcrEdZ2haHxNqiHQIZoFRF9jQZc298jayhVOK5Rouy6SIJLQ9Q4Rjruox4uCiCjcNLrutitv41ohz41SAUkUOdnbz85EimTgpgdCkSSqlsHfXrvMVKnIjWKB8eRaV7/refRFohzs6mEskey8DJbjsD/dzTuLWZbqNZZrNYajt8jHbwOats1SvcpkqcCOeBJRELBdl+V6jXyjjiSIxDQVRZQQW3fb86DUbHZUgsHPNGrYFpbjZ2xIq0JPFcOgbvkZN5IgYji+orcmS8iitGGYqj0teJ5HsdnAdBw8z7/vqiTRFETKpkGx2WS8lV7t4VFuNslWK62MkAjFZpOy0cRphXPa5OPFeg1FFP0w7fISPaHw+gaPIBDRtA5vDWBvumvNMZlwmO5QCMt1OqTk9rPsWyccKwgCAUUhsCrMORJLrDlmTN34ne+PRFsbGAdFlDohKUkU2RFPdEKBUusdqJgGjVaoVRGlmxwIQVjzrO4FXkvQqZyvUis3/LIv22CMCIJAMKQRDGn0Dr73pWM2hCCAoICgt8pDpBGkFKuFBzvHbWSg3Om7+2nXB5PJvS0wDYul6RzvPHeOD33+ERRNwbZslmZyTF2YRRQFendmkGSJ+etZGpUmn/ySLzvRqDRZnMqxMLFIo9pEaKlwX33rBoqmcPRjBxBlkVKu0jnOtpxVoUoBLagRtBxESSQ3u0J2conFqWVGDwxSWCyRnVzGqBtYhsX89Swr2QKBkMb0pTlkRcI2baT3OAz7ngX+F2s1LuSWyYTCjMYTt3FPNFnmw0MjJPQAJcMPt9gbqN6KgsBHh0Y6Lum74UaxwGy5hOU6fGxklKGWt+FesTfVxeFbiMeSIDAcixNUFCzHJd9odFJ6FVHyFYkDIWqWyWvzs1iO0xER81paRnOVMjvjSTKh8D1L6W8EURBRJYm+SIS5SplXZ6d5fWGOsmlguS3xwFYbthvXCr4R1xeO3GbsgJ+x8NTgCIooMVMuc255ad3zjCWSHL8lBV8UBIZiccKqiu265Bp17AeQKdiw7I7k/MdHd7I7lUaTZc4vLxHXAjzSP8BP797LoZ4MUV0nFQhyvLefqmnStG8aPMu1GtcLK7y7lOVwTy+ZsB/uOtk3gON61FpqqYOxGIORGDsSST61Yxf70l3rKp22F+/ecIQjPb2UDJ+LYro289UKB7p6GInHkQTB92ZIIplQmKcGh9mT7sJ2Xc4uLXKjWCCiaowlUhzqzpAMBFmsV3l7cYG4rrMjkUCVJL43cQ3zFi/MvUIUBDRJ7hgZDxrt690qje/XARKRpZuTrCpK7EmluVEs8NzUDb5x7TILlQoRRWVkk/PLenBdj6mL8yzN5ltOC/EndukVhACSsh8l+HMooS+jhL7UIh4/1Op60KiXG8xfW+TRZ4/xhd/9e/zy//CzDI73cfbFi1w6fQ1RFNjzyBie6zE/sUiz2sR1PQqLRa68eZ1dx0ZJZGKE40H2PT7OSrZIbjZPs+7THGYuz5OdXGLvI2MEI7pfg06VOfr0Ab7wjz/Hb/yrL/Lr/+KX2HlkhHqlycVTVzpriiSLhKJBPvX3P4YW1Lhw6ipf+me/QCQZprxSpVkztqXY7b3gPcs7q5gGy/UqB7oy64YfBPy4faRFPJyrlNdNeZdEkaCiEtf1DrnzblhscQxEBIaicSJbTDdNBHRSt5ZTEECR/LozHp5v0HCzAFtQljnSk6Fumzw3dYPfOfk4QUXF8zyuF1aYKBYQBfj0zjHUTRZU3Sw0Seaff/jj/NWl87w2N8vvPfdduoIhdiVTHO/t4/Pje4lr+ranH+brvoLueDK9Lr9GFkTCikpU06jb1oZhupiur1u+QhGlTh0Yy3UfyEvTEwrx0eFRdqfSfO3cGfZ3dRNSVOqWHzLVNulpK5sGhWYTpSXcxwOqfSYg+LXVRAlN9Drv2FvZBS7mcpSMJplQ2K+RY9sc7+3jz86+w0K1ymg8wWd37eZKPseF5WW6QiE0SWZHPMHuVHpbw4UfNKiSxJGeXvZ39eD5eT14eCiitGmP5noQJYHhfX3USg2adYPRfQMoW6i4/hAPcSfoQZXuwRR9O3oIxYIYTZMTP3WYv/rX3yKaWgZAVmXGjo4gigKvfuMNHvvscbKTy7zxnTM8++sfp2eoC0EQUDSFIx/bDx68/u13eOrnH+PK69eZv77IR37hcfRW0WPbsjnzwgXOv3yJwlIJTVeZu5aleziNqt/0zGoBlXh3lER3jHRfkq7+pB/+aqmB1ysNgtEA76UX7j17A9uu5I08u53UPG6WT1j3OIROSGazu0XXu1lLR76PXabSWlA2QrsAW6etrevsSqaYr1Z4a2GB68UCiuRL2p9ZylI1TdLBAId7epG3OdNGFARGYnGe2bmbPakuLuSWmSwWyDfqfH9ygvlKmacGR9idSjMYvZOq6b3BbXmONtIGWf3s2pyU9aCIIuo6hsV74SUoNpvMVspMFgtUTRPDcUjqEqOJBC/PTFM0msxVynQHQ8R0nWKzybtLWaZKRVKBYMcgyoTCpANBwqrGa/OzDEZj6LLMO9kFJoorNB2b64UVRuMJYrrOcr3GDyavsyOeJBUIkrjFO+Z5HmXTYKpc5GJumaligYligbCqdmLhrbsE+FmADdsiW/Wrdbczk1zP558Vmw2KRoClWo2QorIzmeT88hJN2yKhB+i+j2yWHwcIgl8ocTuL8Lb5NsGQTq3YYCVbQhRFMsNposmf7Pv5EO8xWnOsKIkIoj+vyqrcqQvYnisHd/djmTbnXrnMnkd3USlUKS1X6B/vIxQLdsbsnpNjTJ6f4cJrVzn2yUMUc2WMhsHQ3n4URaZZNyhki7z2zTfZeXSU/U/uRguonP72O8iKfFtKu6zIiKKAKImIstRpsp/Mdy/FmrYH75nBI7Zc8VYrlHIr2gaR6/rxb5/YuL7myL1m5UirBM0cb/3rb7YPd9NBWA+j8QRTpSKO53J1JU864GuRvLuUxfFcUoEQY4nkttciE1opuo8PDHKop4d96W6en77Bpfwyl/I5LuWWaIuWbafBI4n+OS3XWbc4VedZe94d76koiFu639uBumVSaDTIN+q+JoaiEmuVN/i+dZ0F2w95Cfhex4ppkGtpBVUtv/SBLssMt8KnUU3njYU5ArJMQg+wVK9hOg5N2yJfrzMci5MOBik2m1xdyRNVfa7Vev33DZUmuXrdr4vTKomQDAQ6hlZEVUnqAT/lGg9ZEnFcP+VdlWTyjRqyKLVk8mWmS0UGYzF2JpKcWVyg2ZLZf89npJ8gyKrs8yxmVyivVAnHgg8NnofYVriui23aWKaN47h4rkuj2kRWJGT1phHfM9xFs9bk23/0HEvTOaqFGgiQ7kugBm5GPEb2D7I4tczMpTlys3mMuoGsyqQHfM6YWTYpLJa4ePoaH/3FJzj2iUMoqsz05Xnqpcbaxq0iIq9LSn4f5pb7MHjuzeiIqBrdQb+mTXMdToAH1CyLSivDoi8S3bZ043Qg6IuT4TFXLt9GgnzQGEukWKzVSAaCvDwzRSYUJq7rPD89yXAszv50F9E7iPhtB4KywpGeDEd6MtQsk7lKmX/4nb/lh5PXWapVeXpkx7ZdKx0IEVRLnTpHt8J2XaqmScU06QqG6NlkVd73Cu1SGn2RKE8MDPp6MeJNDsZvP/J4R2H15hhN3MY3uhX7VhF6d6du12M53J3hUHcGqyUtP1Uq8p2Ja7cdd6Kvj6OZXp4aHF7z+SdGd657XQ+wHafjxaiYJv/H6VM8u2ucsWSSgKzwL19+gYAic7g7wz9+7EOd5/ZBSPn/cYXRMCksl5m9lkXTVXYeGnq/m/QQP2EwGyb5+QJzVxYY3NOH47i889w5Ur0JeoZuzjeRZIhUXxItoHLqm2+hhzROfuow0ioahSAIJHvjxLuiiKLID776EpFkmMzIzUxFy7Rp1vxMsEA4gNIy6i+8chktqDN2dOS97P49Y0sGTzs7w68w6++Eh6IxYGO38EAkyrFML//58gWu5HP0hsIdzRnw64Z8Z+JqZ0f9aO/AtrmZx5JJRvJxFFHk7yau0heJMhCN3jE8tZ0Q8I2uDw0M89r8DGeXswQVhVy9xjM7d3Ggq2fbwzRrQmusta4DskJ3KMx4qotzy4tUNtDh2Sr2d3Wz0mzw4sykn4qfStO1SkgrW6vy0swkluMwHItzuLt3W6+/HRAEwU+SlaSOobP6Hoq3HLtt8LzOuE+HQhzq7rntkKTue3I2fV3PQ14lZqhJEh8ZHuZaIc/55UUUSeLxgaE12XDtN2Oz1/Ba3tnZG8sszhWYm8yxOFegXKzTqBoYhoVl2iAIyJKIqskEQhqBkEYiHaErEyPVE6WnL0HfSApJkh54mrXrelimzczEEvPTefKLZb/NhRpG08Y0LJp1C0H0C7fKikQkHiQc0QnHAnRn4vQOpUj1ROnui6Ooa5+JqisM7PTf7ZkrC6iasmFxz+sX50DJ0BEAACAASURBVLlydpbvff3Ne+5HtCU8+HNfeYrgNmrxeJ7HynKFb/7Fa7zz6k3Du284zcETo3z880c7hWQ9z8N1PHKLJaauLXLpzDS5xTKVUoN6tQngP/OgSjwZZnBnN72DKXbu6yMaD25ZJfrF75zl1A8vsjCTX5WBLtA3kuJjnz3CsSd23d9NWAdzkzn+7A++R36xgmPf3Lz39CfYdaCfn/3Vp7b9mhtBD2qk+pK89PXXMBoW9WoDo2rw6V97mpH9g53jBEEgFAvy5M88wnf/9AVG9g/wma887YfCbiH29+7s4dgnD/KNf/M9PvsPPsGeR8Y6x0RTYQb39NO3o4dv//Fz/ODPX0JVFboGUms8RfeC17/9Du88f95Psz8zycLEIn/4u3/K0J5+9j+xe00/7hdbMnhEAbqDIYKyTL5R5+3FBWKa7vMI8EUGu0OhNRlHmXCEw90ZvnX9CmeXF5FFkaZjE5QVmo5Nrl7nxZlJPwsnGmNXKoW8TRNeTNMZiEbZm+piqlTk9YU5JFGgL+zL0LstsnG+UWcgGiOlB9akxd4v2gbioe4efjg1wbXCCrqs4AHDsTgDG6gl+2EfF9Px08orpkGtlcbcsG2qpkHZaCKJIoooIgliJyxm2jYV0+RCbolIq0J0QJY7CsCFZoNis0FAlm8TrWvHVi3Hwfb8a5dbPBYXr1NxOGQoSKKAKkmtFPabnKXFWpVT8zO8PDPF/8/eewfJkabpfb8vfXnX1d6i4T0Gi3E7szOz5maXu3s8w9MdjyJ5XEpk8BSUI0WZP6SQiaBInYIKBnWUdMHj8UI6x7vjklxze2tmx+5iBjMYeDRce1PdVV2+Kn3qj6xuoNENoAH0mDVPxAyAzMqszKzML5/vfZ/3eRu2xa50loiqUrctrq2WeHNuhlw0wlg681jVMB8k7uda+kHpiO7cb1RRt6zUMhTloSIvd5+HIkmMpTP4QUDdtpCFxHg6u6Gabjvnt5YarlVaVEoN5qaKzN5cZmWpSmGuTKlQpVFrY7ZtbMvFdT1AdCo9ZIyIhhHVSKZjZPMJMrk4uZ4k/SM50l0JUuko+d4UkbiOtEOpzfDF7LO8WGV1pUapUGP6eoHlxQrlYoNSoUajFrZucGwXy3QQUqe6S5WIJSJhaXhcJ5dPku9Pk+mKk+9LMzDSRe9ghmQmtv5dnuvjmA6ariLd56XealisLFa48v7MQ59TNp/AiGr496hqfVQEAdiWy/zUyobjatZNkploWG4PuK5HvdLi1tVF5qeKTN9c5tbVBcrFBq26SatlA6BpMoahkUhHWV6okO/PUJgvs+fQAF29KdLZ2LoOZbtwHY9Grc2VsxuvW2m5xt7Dg+w7OkQ0pu/Y89puWhSXqlx8Z5JyqbnhmiuqzIi1eYLyQUJSZIyYTtdgDrNpEWtFicQMhvb2ke7e+F5RVJmugSy+76MZGr2j+S2vixEzyPZmsNsOya4Euf7MHftQSGTiHH/pENVSHdf2UHWV3tEuZFUJ+8ch6BnJE0tGSGTiRJIRBvf2IykSAsHu42Od79ERIvwznU+i6gon9MMomkI6nySWiqHqO2sa+YiER2I8nSEXjXJ1tcifTlwGIGNEkDveFp8e3UUsdZvwjKTSxFSVP7xykTdmp7mwXGChXqMvkWCl1WKyUuabN6/zZP8gT/T2P3an4jthKAp7s1383L6D/KO3XuOr167wzuI8LwyPkjOiOL5PxWzzXmGRX9h3kCf7B3aU8EDYc+jJgUGkM4JLK8ssNRrENY3dmRzD93jhe75P03FYbbdoOA7T1SpLnYqmUrvJXL1GptOaIaXrxDWNiFARQtBwbG6WS/zG6TfYlc4ylEzRE42hyDIVs810rcJ7Swuda53f9N2u77NqtmnYNi3HYbZWpWqZ+EHAYrPOdLWC5boYqkI+GiOiKOsC4+M9fTh+aMb4B5cvcrm0wrHuXvriCW6US0yUiry9MM9nx3ZxrLt3W15KP0lYG4J0RflAGvjJksRgMsXgY+i21siO63hM3yhw8Z1Jvv6Hp6muNh/QtTskHI7t0mqEkcWF6dKGT0TjOvuODrHv6BCfevkIg7vySNrjE56QgHi0mzZn37rOe29d58rZGVZX6vff0A/w8HFsaDftTaslSaAbKi9+6Tif+/mT64THsVxW5le5+u4teoa7kB7yZf5xhdm2KRVqnaieT7tpcePyAr/3m99lfqpI/W4tRwdtJ7z25VKDmZvLIEBRZF7+S6f4xPN7OXpqF5GYds8o2FYYHA2jTW+/enVDWLswX2ZxdpWVhQoje3aOhKyu1MNo4PLme2Z0by+7Dw7s2HdtB0KERObzX3mJWHJzRevGD4el4vmBLN3DObJ9W0s7JEmgajK9o13kB7Okum4TJyEERkznZ3/95ft+1ZHn9m/4d+6O7/rcX/3Uxs8+f4Ajzx+4/7HvEB4tpQX0xBP8jaNPcLw7TFP99rn3wuaOksRQKsWhru4NWhlZCPLRGP/s5S/xtesTvLe0wFevXaHu2EQVla5IlL994hR/YffeD0RjM5xM0bPvID2xGK/PTnNxZZnfOf8erh+gymGZ9N5sjrimbujttFOIqirj6Sx7szmur5aYqlb4wvgeuqLRe87WJ1aLfG/qFr/1/pmwcs0P1kv1v3rtKl+7MbHew+xzY7t5YXiMn90TdmKOdNyZR5JpbpZXeXthjrptoXZceLORCH/z+Ek+M7KLPXeZ/rm+z9mlBf7Zu6d5v7BIEIRib6djYPjb597ldy+c7aR9BH/rxCd4bmiE4z1hakqVJE729vObL3+Z3zl3losrBf74yiXqjkXGiDCcTPF3Tj7JXzl0jJTxMbDD/ykeGoEfYJkOv/0b3+TS2Wnmp4o4trsjFgGthsX5t29RXqmz5+AAvUPZHSnpLhVqXH5vij/5ndeZmyximy7eY3oMQSc15nikMlE0feNxRuI63UNhxErV730OQuJHxg24WTdZnC0RBDBxbpZzp2/xx7/9GmbL3tDg+IEIQsL853/yDu//4Aa7D/bzd//HX8CIqMjy9q7FyO4eVFXmD/7vV2i37A0Rl+sX50imojtKeCbOz3Lu9M1Ny42Iyv6jQxw8MbLFVh8ggvX/PRCNcpPv/r+vc+jZfew7tbXeD0Lvnbf+7Rle/OVP0jOyeTL8o4xH1vAIYDSVJqZq9MTi1G1rveomqeubTAHXNBG5SJTnh0fYm+vipdFd2J67/hIO0zupe/p+fHp0Fwfz3dQta1OvrAdBliQMITic7wkrlwaGKJvm+jFrcth4dE8mt6F/zlg6w8/vO8ixnj4O5TdHnWQhMRBP8JVjT2C6Loe6utdt7u8+f0WS+BvHnqBimri+z650hnw0ds/ZzJph3HZaOoyk0gwmb1u5a7JMNhLhPzhwmIpl0nYcLM9D6pThRhWF4VSaoURqE8FbM/f71UNH+ezovR+M8LzgSL6X/vjGWcBac9Iv7N7DJ/r7Ow7EHhFFIWUY9MUT667Pd2IwkeTn9h7gaHcPp/o2z5bC1gNx/sqhY5TNNke7e9fbGPwUHx5WlqqcO32TC+9OsbJY3dC9ew2KKhON6xgRDd3QEFLYX8p1PJoNE7Nlh7qeLSDLEtGEwfDubpTHJDuu67E4U+K1b57n6rlZ5qdLtB9geiZEWEqr6cp6GsyxvXtWeMqKxL6jw6TvqMIyojq9I3miiQh6RCORvrc4v28ox5MvyCSSEUzTxrG9MKXWSQc6totluVx6b4pmzbzndfswYFkOqysNZm4W+OH3r/L+D27QbJi337sCEqkoRkRD02RkRcZs27QaFq2O8d2dcGyPUqGG7/l8/fd/wHM/c4Teoey2NFyKJhNPRTlwfJir52Zp1G5Hl5bmyly/NI9jeyjq42nC1jRq89NFpq4XNqyTFYnxA/1k8wl04+PVt8v3fG6cnWTy4iwLN5fwPJ89T+xiYM9G3WS7YTJ1eY7Lb02wPFNECMHhT+7bEN35ccBjjSTZSJRsJLplxclWEB1isb/TFuJhsRZBeFSs9enpiz+gp8IdWPv8c0NbM3dJCHLRKJ/f9WBxnCQEPzO2e9vfvdY198QDqn+2giJJxDWd54dHH3rbNSffh7lOd2PN7faJhzz2tXN+dnDrihYhBLlI9JGryvL5BCPDOTzXD8luR58BkIwb6IpMs94mEjM+st5EAJZnYvptWm5rfVloyaCQUXMo0kdH8lzHY3mhwulXrjI/VQwt5ztQVBndUIklDJLpGMlMlHjSIBo3kCQJz/OwTZfqaoNatU27aWFbLrbpYNuhUNhzfeLJCF09SXqHso8saAXwPB+zZXPl3Aw/+N4VZq4XcJzNUR3dUNF0JfzTUFFVBUWTiUT1sPTX8bBMB9tycG0P1w3/bbVDjU8sbjC6p4d4KtRBCSHQDJWskSLb8+DUYa47SaYrwa79fTQbJlbbwWw7tOom7ZaFZTq0mxYL00WcDgH6qODaHo1ai8tnZ7jw9i2uXZyDAGJxAz2qEo3p5PvSxJMRjIiKoik0aybV1SblYp1apUWzvpG0mW2b5cUKr3/zAiN7ejv3zYMb4kqShBHROHBihJmbyxsIT6XUYH66SK3SIpWNIT1mkUqraVJYqLC8UNmwXJYldh/sJ5mNISsfjI1GEASUW+2w7YoWkqpAEoioipZP3HPS7PsBNyeXuH5ukupChZ6RPIN7+8j0pPD8cAyUhYTreJSXKtw4O4kQgt7Rbob3DyCrO1fY4/k+5VablGGg7rDJ7nbx06nxT/EThV//25/G8/zwRdK0iMZ14qkw9/3+m9cpLVU588oVnvrcYYxHrDp4XARBwK3mdc5W3uaN4ivryxWhktO7+PXxv09e/3DFkXeitFLnxqV53vrOpU3regczHD45yktfPsGBY0MoqnJPBwvHDgWnkxOLXDk7w+S1RW5cWWB5vsLeI4McfXL8scgOQKthMnNzmd/6X79Bq2ndU9i75/AA4/v7OHRylP3HR0ikIhtm60EQkqfC7CoLMyUWZ0pcfn+GS+9OoRsK4wf6yeQTm1JaDwMhQNWUDVGiOxEE8No3z1NdbdKsm4/8PTsBq+3wW//o6/he6JsmyxJPf+YAR58a58Qzu+nq2RwZcByPRrXN979+jlf+/Vmm7yKfnutz48oCb337Eo7l8tzLh7d1LEZU44W/cJTTr1zZQEZcx6NWbvLOq1d55jMHSece3QPJc30uvztNYa5Mu7mxqlVRZZ75zCFy3R9cNMQPAn7vh+d4atcQp8YGw2OKa0RODjLc9SKSsfV95wu4loaX/svPc2Twdlsk2/No2w4NyyYTjRBPR3nmyyd55ssnP7BzaFg2v/PGu/zSqSOM5D5ca5g1PPTT2W6a1MtNFqeK9AzlSOUSGDGNejkUK3qux+LUCl39GRKZ+PqMp920aFRbzN9apncoRzIbIxI3qK021sPci5MrZHqSJNIx0vkwuuDYbifctoAWUUlmYvQM51ieLxNNGEQTBooi06qbuLaL7wWk8omPdHb+owDf91ldDqtUAj9gcLybaFzHtlzMpoXvB5SWqgRBQM9glkQ6iiRL+J5PpdRgZaEMQtA3nCOeioQz0pZNEAThugAy+QS5vjSyLOH7AVbbZu5mAct00CMao3v7aNbbWG2bbE8KWZE7olIT1/GIJiL3JB2tuollOgRBQGF2FSOqke1JkszEqBTrOLZHpiuBosk4lovZsnBdD0VVqFdavP/GBK7nk84l6BnMsPfY8Pp1sdo+V85MkszGSGXj5HrDVKFtOlRXGyzNlEjnE+R6UkRiOs1aG8f28H2fxakisWSEZCZGtif5YyFSvRs3L80zfWNjWF+SBIl0lL/8dz7N3sODZPPJdbJzr2ugqDLJdJT9x4YZ3dODZTq0mha3ri7S3Z8h35d65Ou3lnp6760bfOer721JdqJxne7+DL/0H73A8HieZDpGJBZWjsny3Y7sAYoi0T0QVmXtOTzAky/up15t4To+kiRQHrMR4oO2/SD63j0OPDd08u3uT/MX/8NneeK5PWS6EkTjoS7v7vNRlPD3fulLxxgez3PxzBR/+juv49gbI25nXp/AdVyOPjVGPBl5YIWerEjke1Ps2t9Ho9pmYea2CL7dtHjr25c4/ImxxyQ8Hmdev0ZpubpheSSq0dOfYWx/H7H4/fWIluNSarSYWa1iqArpqMFILo0QYWNi03G5trQSNonVVHZ355CEoNq2mCyWOTTQQ0/q3udQbrZp2Q5xQyOua1TbJtOlCkeH+uhKxNbdlFu2w1SxzPm5JTzfpz+dpC+dYH9vKNm4323YMC3KrTYzpSrpqEEmFqE/HRI92w1J1ERhBV1RSEUMhrIpJCFYqjZYrNZ5YmSApBFKNIIgoNIKmxc7rsdcucpAJkkyohPTNObKNeK6RkzXUGWJhmXjeB6+H5CNR9ergh8G2yY8QRDQqpssz60yf7OArMpMXp4nno5y4BO7KC5WqK02aFbbKKrMzQuzxNNRjjyzF8d2WJousji5gqRI3Lo4RzIbY9/JMYoLFSrFOs1qCz2iUTpXIdWV4Ogn94KA+RsFFiZXwlYFjdA+uzvIsbpUoVnViKej9AzlmLtZwHd90vkEqSDOj3OX3MeFbYWh8omz0+tloOWVGkef3k27ZVFcqFAq1JBliYCAxZkSp148gKLJmC2bq2enEEICAoqLZU58ch+NWpviUoWV+QqaoeB7PrM3Czz7+aNouoplOpx76zqBHw6SsmoyvLuXZq1NuVjHtl26B7I0a22mry3SPZBBv0+EpVZuUipUqRTryIpMecVnYWqFJz9ziHqlRbMW9jDqG+miUqqzMFWkeyCDZgS0GxYri1UUVUbTVcy2s64/sE2HUqFGLGlQr7aYv7XCMy8fwbYcKsUGk1fmkRWZRq3NynyZo8/sYXW5RrlYp7LSwIiqlApVZEXm6c8dQpZlxI8Z+a6UGtTKzQ3LZFUm35dmeLyb3sEsyjZC4WE6UUZRZWKJcBD0fZ9o3CAS1R47wlYs1Ji5EZZI3012jIjG+MEBDp8c5fDJEdK5+0dn1rVxuoqmq6ypcfJOGs/1cBzvJ3KSle1OMLavj6NPjdM/nEO7Txnx2u+d6UowfqAf3wu4eGaSaxfnN6S3qqtNlubLzE0W2XNo4IEVekIINF1leLyblcXqBsLjOB6zt5YpF+t09SSJPIJPkef5WJbDrYlFGndVoCUzMYbGu4nG9A0mfnfD9XxWmy3OTM8RUTWcjlh+JBemekqNFhfmltZb8pi6ti6J8oMAy3VZrNTpSW5BeIKAYqPFSq1Jy3Y4OhRGcjw/wHI8Fio1BjO306qO51EzLQq1Bposk4rYWM79U6RBEOD6PvOVGteWikQ0FdHuyB9SoWv+7GqFyWKZIAjW7VGGSHWOxadtOyxUahzsv62FXarWKbdCoqZIEhfmlsgnYhwZ7KVYb1JrmyQMnaFsisliGd/3ycWj4Xj9CI/bQ8WLi4sVrp+b5t3vXUbTVS6/fZPT3zqP1baZv7nMxR/e4O0/P4+qq5x7Y4LT3zqPYzlUinWuvT/F6W+dR1Vlzr52hdPfvkC7aTF3o8D7r13lB984hxHVOPfmBGdfvYLVsrHbNhd/eIPv/evTCElgNi2slo0QsLpUZfrqArcuzgFw+fRNrp+b3qAn+Cm2RqthsjC1wtvfu0y93KLVtPj2vz5NuVhndbnOrSsLvPnNc1TLTeqVFt/6gx9SK4dh9JWFMq9//X3q5QaVYoNv/cFpKqsNiktVbl2a55WvnqFZa1MtN3nlq+9Sr7SwTJtKsc7XfvcNyit1PM+nWWsjRFjxsTy3ysTZGcymRXGpwjuvXMFsO5vEjXeiVKhy48Icb3zjHI7jsTBd5Dt//A5Wy6ZRbbE8X+byu1PYpsPSzCrvvno1tF93Qj2GYznrhEc31PWHp9WwuHlpDlmRmb1R4I1vnAvLcJeqTF5Z4O3vXkaSJaauLvLa197HbFksTpe4cmaS7//bd5FkicmrC7z1rfPhOXxIs/K1dh2O5+F22rf4d/y3tuzO/zzfx9tiuX+PdWto1Nu07grrq6rM8Hg3sbixLbJzL0iSRP9wjkxX4pFeTnfi5uUFZm4UWN2ihDjbneDZzx7kF37tOfJ96UdORSmqjB7RiCcjP5bRvAdhbG8vJ54ZZ/fB/vuSnbuxRnpe/NJxItGNxNbrRJEvvDO5pd7qXth7ZJBd+3s3vAg916ewUGFxdpVyaesmxQ+C20nFTU4s0ahtTCV29aY4dHLkgZMax/NYqNT5+vmrQPiMNazwGbJdj+limT98+zxWp6VL07LXT0ORwojP69cnmVndqB8KK2gDbhSKXJxf4lphhZimdYpTJAxV4dWJWyxUbkemPN/HcT0c10ORJXR1e/YXtutxbanIdy5fx1AVLNejZYe+cJbjcm52ka+evQwC2o5D23ZuTxSUUDT+3cs3WG221499srjK6VuzvHF9CkNVeO3aJG/dmMFyPFabLW4sl7iyuAzAe9PzXF5YxvV8HrUvxUM95ZdP30BWJD7zK0+x78QYruOyslBm4t1b2JZDz1COod09HHl2D5WVGpVinemJRaauzDM9sUh1tcE7373E4tQK6a4E01cXcF2Pwd097Do8yKGn9zB/axnbcikulakUG+hRjeOf2seTnzsChOE2SZZ44qWDvPbVM9w4N8OTnztCaalKpjvBwK7uH7sZ9U5jZb7CpXcmeennTzK8uxfX8ais1Jm/tYLreKiawolP7ePIU+N4bpimWZ5fpVU3WZwp0ayZXHlvCtfxqFeazF4v4Hs+mqHy1GcPc+zZPTRqbRanitTKTcordeqVJsee2c0nXjxAV19YwScrEiP7+ojEDf6/f/JN9h0fpt2wKC6U6RvOPfCFF00YnHxhP8ee3s1cTxKzaTF7s0DPUI5IzOD3/um3OPl8GH1aLVTpG8mjqDKyKtE7kiOTTzK4q5uh3bedrtO5OM++fIQjT4+jagq+F7BaqHHl3Ulcx+Ozv/Qk+44NE43rRBMG196fodUwyXSnePpnDnP4yXFcx0PTw0hP72AW+UPQAjmez2qrzdcuXGU0l+HUyADlVhtdlmk5DteXSzy7axgQmB3zyhsrJRRZ4uhAH03LRlcVNFmmUK8zXapgqCqH+3uQO33w7vc+970g9ODZYfO7R0UQBHz7q+9y/eL8pnWyLPGVv/d59hwaWI8s/RSPhmNPjfPJz21Pa3M30l1xPv2zJ/jzPz2D47gbPI7KxTqv/dkFXv7FT2zbPXrfkUGqpSbZfILySmMDST/z2gSSJOgffnjPr6W5Vd576zqO5W5sjikJBke7eOalgw+M7umqQtzQSUciXJgvcGSgh6NDYRHOVKlMtW3y1K4hPrV3LIyewHrKJmHo7OvtwlA3G442LJsbhRIzpQo//8Qhntszuv6cpiIGe3u70BVlfV9CCDKxKH3pBEPZFPlkjP193fRuFTm6CxFVJWHoRDWNM1PzPLdnhJFcOJZPLK2gSBJP7xrihb271ntnrR1tmFIDVZE3NRAf7coQ1zU+MTrIzGoF1/eZKq7y1PgQ3zg/waWFAp85sJuVWpPuZIyRXOaRHRweivDISpjXDrxgXZfhez6yKiNE6M3heX6YCvEDAj9AViQkWSLXmyKZiXHk2T20GyaaodI/lqe0VCEIZHRDW/+skES4bedPz/XXvxvCwcyIamiGiu/7XH13klRXnHx/5r5uph80giDAx+P06puYXhtZyAxFRuk1+okqH59+UUIK3W59LzT4EpLAczwkWSB5Yt0mXgiBJAlc10eS5fUy3b1Hhxg/PEgsYdBqmIzu72Nlvkyj1kaPqMiKjCxLSFJ4H6zd/K7jITpahzWoqrxeyTFzfQnP9Rna07stPUQQBHheEKblCGeGsiKjaqHjZyobZ+LcDM16m6HdvchyeD6SEOsaDalzLdavjSzQdTVsbSALJFng+z6SJCFJ4f0uyRJBAL67du8LZDnsDCwr4Xmv3cMfluoiCAJs1yWp60RVFT8ImK/U2NWVxVBVXN/n7ek5WpaD6/u8uHcXAVBumbw7Mx8OsJ1mpamIHrppWzYX5pc4OtiLcsdPkczENlXQOLbL9I0C0zcKGFGNrm1UJn1Q8FyPVtNiYbq0KfUWien0DWUZHu8hmYnhE1B3GpSdWlhppETp0tM4vovjuwQElJ0aipBJqQmisgECXN+laFVoeSa6pJFWE8SUSKcTvY/juxSsEn7go0kqPUaOpmviBR4JJYosZNzAw/YdvMAnIuuoH2Hl3cNCCOjuz5DrSZJIP8Dw7h5YM2wc29sbRvsni+vrbNNlZaFCo9YmGje2FYGTFZlsd4LDnxjjrW9f2hDtvzWxSO9QFtt2UR9Sa7W6XOPK2Rn8uzyG+kdy9A5lSWYefP4CQW8yzi9+4jAN06ZQa/D1c1f5tedOrpMRx/NC1/wtWirJ93B9lyVBRFOJGxoNy2K+UmU0l7ndIkaITeRAEmJDf8C1Cc0Dz0DAvt48EU2lYdpcmCswU6ry808cRJIk/CBM3SmytElfExI4actzCKPN4fve9wOCjgheVxQSho4mK/zw1gyZmEFv6vH0uQ/1hCWz8VBzsVyltFShUWnh2R6xVJTV5TqWadJqmJSWKjRrbTzXIxLXSeXi4QvPdunudF1VNZVkNha+SISPdKfRVBCGuyIJAyEErbrJynwZCMtHE5kYkiwRS0UxYjqXTt8g25MiP5B95AuxE/DxaXsmF6pnqTs1NElDEQoZLUeUjw/h0SMqqVycSrHOaqGK7we0WxaRmI4lOQSVgHqlSXm5hh8E2KaNEVGRJIFtOfheQFdvmnRXOCvIdCepV8Ly6dBN9vZ3BYCqK0SiOmbLprxcW79hM93JsM2ArpLJJ5m+XiCWMBjd17etVgKe59OotFhdrlItN7FNl0hM76QZVPpGcty4OEciHWV4b+/tzr1yWMraqLYoF+uhSL5zLoJOmfraDdNfbQAAIABJREFUOXQYSzwdod2wKK/UKS1VqZeb2JZDLGlQKzdxXbHpmD9skWkQQDpqEFEVHM+jUGswlEmhSBK2G/67ad+eRbueT800KTaaaHL4ElBkCVXO4nphzn3OcTnc37OhTV62K0Hqrkoiz/MpFqpMXJhbJ6vJdBRZ+eB7Yt0Nx/GolptUVxtYprNhXTSmM7a3l0xXHM1QsX2b2dYSTa+NLCTswCGrpWh7JjWnSdszqbstJCHRcFvsig0hIXB8lxVrlZZnIguZhttkT2IUKQDbd1hsr1C0KwRBgC6r5PUsTbdF27MICEipcVqeSdmuYsg6mqSg/ggVzQoh6OpNkUhHH9l7JpxwwOBYnoWZ0gbC43k+jXqberVFOhffFuERQpDMxDhwfJi3v391A+FZWaywPF+mutok153cVoQgCAJc16NcbDB1vbDpeR4czZPvS99Xa7h+Pn5IBIayaZYqdSaWilwvFCEIiKgqmqLQsh0KtQYRVUGWJHLxaGci41FtW5iuS7VtUmq0SEV0AoLQfsTQ2NWVxXRcJlfK9KWSSELgeB7lVhvLCbdbbbZIGjqyFLYgMlSFcit8/nVFIRO7nw1AmBaP6SqDmRSL1TqzNyqsqOHvEtM0JEnQtG2WqnUEoCkKmWgEL/AxbZdSo4nleqw221RabaJaqFNq2y6W67Fca9LoRJrX0nLZWJR01OD0rVnGujL0ph7dKgUekvAc/eRe3n99gte+eobLb4dprO7BHLsODbI0XaK0VGHm6gJL00Ua1RZ9I130j3WTH8hy+s/Oc+Y7F7l5cRbXchnY3cPP/scvcS/3LyEEI/v6mL+5zMLUCr/3G18nCALGDg3y8l/5JEZUY2R/H47p8Fv/wx/zX/3m32Ds0Idr6303TM9kvjXNrcY16m4NXTLYFduD42+2o/8o0TuUIxoz+Bf/8N9x8fQtFFXGMm0GxvJUV5sUZle5/M4kC5MryIpMvdoKq+5SEaqrTf6f/+mr3LoyjyxLuI7PX/8HX9w0+7kT2e4kQT4Uu/7Z7/8grNyRJP7a3/sCiXSUSFTj6c8e4nd/4xsMjnfz2V88haxIDyQMZtPi0ju3KMythhWCnkfvcA5VU1BUmU9+4Rj/8O/8K449u5vP/+oz66lOI6IxvLeXP/o/v4uiKQyNd/PL/8ln7/tdB54YZX5yhX//r97g6rtTuJ5HNG6w6+AA5ZXNL9YPG7IkSBgaqUgYgVhttJkrV+lNxlFkidlylYFUkr5kgqiuUm61WKjWqLRNMhGDpm1jqGqY0qrVcf0wUisR9l5TZRmlMynZc3iA5cUKUmdGto4A/vS3X+ftV65y6oV9fOkvP00qG9v0QvygtS6thsWNSwtb6vnSXXGeemk/mq7g+i4lq8qfzH+bT+VPklGTlO0aQSxg2Vrlen2ay7WbnMoeoeY2OFu+zH+x969jyDqWb1MwSySUGJOtOd6vXOW/P/jryEJiqV3kX0z+Kc91PUFUNmh5JkJA1WlQMItMNud4OneMudYS765e4lPdp/CVj1cF1oMgSYKhXXniO5AS3LW/j1sTi5tXBGHbka0iivdCV0+SZz9zkD/8v17BajvrY4hjexTmy7z35nU+/eXjSNs0s1xdDltJzN5c3rTu+NPjjG7TxbnSbnNzucQ3L1wjqmtYjhsKkIVgKJumZTuUGi3+5Ruhq34qYvDrLz1Ny7aZKlZ4/dokUysVXpOmqLYtvnxsP67noyky2ViUX3nqGN+6eI0f3pphIJMkrmvMlCq8eWOG6VKV7125RanR5i8c3UcmapCKGAxnU/zmK6c5N7vI/t48v/r08fueQ7HR4uz0PO9MzhHVNfwgIBePAYLx7hwzqxXmyzX++Ss/JAB25bP88qmjNEyLc3NLnJmaZ65c4xvnJ1io1Hh+7xhBEDBfqTJfrjFVDFN7B/u7Ge6kyvb15hHA3/ujb/BPfuWL7O3ZnuffvfBQhMeI6hx7bh/jR4ZCNbkkUHV1PVfXN9rFwHg3h5/egySJdRGbqiqcePEAe58YDdNTsoQeUVFUhSdeOkgQsD4LfPaLJwj8gEhH9f7EiwfYf3IM1/U622nokXC/XX0ZEukY/8sf/afkB7JoH7HLpem1mGzdwA0+OlOw7UBRZFK5OL/2D760TlRkWSKRiVFdbaJoMk9+5hC7DvaT7koggEQqgiRLJDMxvvLffGldqyErMolMlGhcp2+4a70ZXCwZ4S9+5VPEErdFrH/t738B1/XCMKoik8jEwpeqLDN+aID//B//CqqmYMR0fC9gabZEpXiX4FSElTK1cpNYMsJTnz3MgZOjRGL6emkwrM0eJfYcHWJwvIfIHbMwPaIyNN7Dr/3XXwrzyrqKkAT7T4yEaTcRdnbef2KU0X19xBIRJEVid0znK//tl9d7/axFMg6dGgtLdCWBqioceWqcvceHQwGv9uEYbMmSRDJicHigB4mw8u5XnzxGRFURAsZyWdROGk8Igd4ZKD0/QJEEbiekLAlBEGwsTY3r2oYQdSIdZfxAPy99+QSvfuPcBmLheT4LMyW+/W/e5czrE4zs6WVkdzfHn9nN6O4ejOgHr2dqtyymri3hbtHTKxbXGdvX16meg4iik1BizLeWIQL7k7uQRBip0yWNw6k9HEiOsWrXWLWqFMwi3UYOWYQNcwtWiRVzFdOz8QOfVbtCyalyILGLY+l9JNQwsisjMxzrQ5Fkvr7wfY6l99N0TcpOjR4jiy59NJ5PjwohCbr7Mjvye+Z7UyS2JDQBS3OrDIx2wTY7NiiqQiob5/Anxrh2cW6DL8/yYoW3vn2RF75wFHWbh33+7VtMTixtWCZJAiOqc+D4MP0j23sBpyMRDg/0MphJrbv7q7K8Hkge7crwdz/zDG6nilWTZSKqiq7IxAY0Rrsy/NwTh9AVGUNVSUV00tEIXfEoB/t7MBSFT+8f59ndI6QjBpIQpKMRxrtz/MLJQxiqgqEq6xGeRERnX2+e/+6LL6BIMob6YCrQFY/yyd2jHBvqCw0LJWmD2PnU2CD7+/LhZEmEEaQweiXzzPgwx4b6+OVTR4jqGhFVIappCCEYz+c40NfNiZF+BGLdWBHCRuVRTeWJkQFysSj6No7zftj21kIIhCyIJSNEEwaeG6ahJCmciUuyhBHRicR1uvrSKMod5bgC4qkosWQE1wmJy1o59Jrp2xrWGu+tYW27te9bG7AhNOlSNWXTPj4q2L5FwVzECz7elWJCEiiSTPdAJiQuQbBeUimEQFFkYskI2Z4U2U7aaQ2KKtM9mMVzvfVc61oTwA2hXUUm272RgOb7M3iuB4L19I/o5JiNqE7fSChOXNMQObaL2borOiYg8EO9mKrKxJMRcj0pYgljXb9VXqlTXqkxe3OZsQP99I/lN2i7JElCM1R6hjamQO8WSUdi+oZla+foef4Gh+ZofOMsd80f6sOEEAJFCBTt9m9w5yAW7SwPgmC9olOPKpuWhf9mXXe1FRRFpqs3xalP7WPq2iKF+coGh1vHdqmuutQrLdrNsNFkrdxicleeTFeCbD5B/3AOI6rtSI+su+E5HrVKa72b9xpkJRyj0tl4Z/wBQ9Y5nt6PH/j4BEzUJ+nSQ1M0IQSaUDFkHV3SUISMF/hU7Bpu4OEGHt16FtOzmG2HL0Uv8PEDD1VSiMgGceX22GRIGlHZQCBYaC/T8tqk1ASqUNdJ1o8OBNG4jrIDjrnxZOSeabFWw8J+CFfptUnP3iODFAvVDYSn1bCYnypSWW2Qke7fBmItMjR1bYlCR06xBs1QGdqVJ5WJod/D8O9uKLKELKkYqrKuV7lTN6MrMr2pGI7XQhIqklCANrIkE5HAUARd8QS+XyUIqgjiCKoYikxESxIERRJGhKTQCQILIVQUGSKaTD6RIsAhCEx8b5FAdCGLCLKqMpTdunH13RAdgpaIhCm0cKIkbUhXJwyduK6tE561sV1CDrc19A1l9b4fujxH9VAM3ZtMIHd4QRAEzJdrLFRqLNebPDk2SCKiP5L3zobf4VE2Wpvd3om1aI6mq6HAeIu8vRDikQa4rb7v44YgCDB9k0VzDu9jHuG5E3c72SpKGH3TdBWlIz7ecrtHHOgeZjtZljf1URKAokponYEmPE5pA6FZnl/l1uV5Lr19i5/7my/Qs0VlxprQ+GGxRgh/VHFn5cS9lm1nTAlTBwe4cXmecz+8yfSNwqZeU74fUJgvU5gvc/HMJMlMlIHRLg4cH+a5zx2muz9NLBkJ7zPlNgF+XHieT7Pe3mQJoGkKkZi2boYaBAGGpPF810mW7RJXa5N8p3CaJ7NHw+MPAmzfxvYcbN/BDlw0SaVoVSjbNUzX5GTmILIkM1GfBEAWMrJQMH0b27exPDsc94SCQKBJKl16lon6JIakMRYbeOxB/KOAEGHDzJ1opRBLRtDuoYMx285DW40IITj8iTFuXJ5n4vzc+j1pmQ7LixUWpovohvpA7ZHn+ty6ukhhbnXD8mhM59AToxgxbVtawzuPKxQIb7XWJwhMBBUEBgEagV9BiJAwB4GFJCVwvWk8bwlVGcN2riKEjqKMEwR1ZKkbSUri+00kKUGARxC0kUQKP2ji+yVs+zy6dgJJ6kaS0kh3BBC2AymcCd3jHG4To+1dkHBS5gcBuqKskx0In73rhSKXFpZpWjZ/9ZkT64aFj4Mdm14df2H/uhnQT6IfhR1Y1N0q8+3Zj32E537oG83TO9zVicJ8dL+jJAsGduUZGNs6ZLzeJHiL49xzJKwi++wvPoms3u2Y+1PsFBRN4a/9Z59j6gtHmTg3w7/5V2+yslS9Z5+nWrlFvTrLtQtzfO33fkj/cI6R3T089/JhTjyzO4yU7cBP5bo+jZq5KcJjxHSM6O2IXdNts2KV+XbhTTRZw/U9eo3cOgGxfJvzlQkW2sv4QUDLM+mL5NElHdOzebP4HkW7QtNrY/mhhqvHyCIJwesrZ/iTuW+DEGhC4ZeHvkBE1kmqcV7Mn+L/uP67HEru5qXuJ9m6/ubjjp2L8Gi6gqrK4W+/URJGu2VtcmJ+4JGJsER9bF8f1y7MsTR3O0LjeQGvfjP0ist03VsAa7Zsrl9eYGmuTOOuNh7JTJQXv3h02+Xy24HvF7HstxFCw/NK+N4yrreILHcjSQmEiCJQCAILhIYQWQQaBDa+vwwILPscYKMq4/h+FdebwrLeQdeOg9ABB99fxrR+iKqOo2sngI8uOyKA5/eObrlOEoJP7Rvjub2jBEEYIduJp+ShnJYJTIKgDYGJkLPc9i30EcJCCBmEAqj4fm39s5LUD/gEOAgR6TBZgZDinX07EFgEfg0hJUFohJfDh8AlwEMIPTzcwCYIwn0LkUZIMYKghRAGBD4BNkKsWfp/eANJ2V6lZBV/pMkOdMjDR+xjtF5NJeBRfkNJlsI780en6OVHDutpZVWhbyhLNKaTySeYOD/L7K0Vbl1dYmWxskl4HvhhCeqaIVyzblJaqXH+7VuM7etj39EhRvf2PhbZ9n1/ve3InVBVeUOkWJc1uvQ0z+dPsnafCQSq6ESrJZV9iTF2xQcxpLCiRJNUMloSVZIxZI24GsULfCzPRpNUJCRSaoKf6X12PcKkSDK6rCGEhAgCVEmhP9JNl57BkHfupfmhYoeGiNvPemgP4d2puwpC07979T+73z6FLBgcy3PgxMgGwhP4Plffn+HYU+M4tntP+4t2y+biO5OY7Y0p9UQ6Snd/ht6h7I5GeoXQkKUcjnudIPARUhpVSiKQEUJHSAkCv06ATeC3sJ338YMGkpRAkrK4zi0ILIQUQZaHcZz38bwCQkhIcg7PW8b3q0gijSSnEcLA9y0k6SMkPJ2I1/3W7XQs/SFfCS5BUCfwiwgRIFCBoENsbAKhdIiJQRBUCPwmBG0CJILADkmKlAN8EDqCtXyeTxBY+N4iAgshIoBKEDQhcML1UhSBDoGDH5TBb4JkQWDg+2WElCGsnQ0QcoIPi+ysDaplu8SqXXrAp3+Kn+LHD/FkhFjCoG8oSzafoGdwiWjcYPLqIs26Sbtt06y1Nzlnt5sW7abFylKV+akShflK2GfNCGffkaj2aCaiAVu+JIUQG7i8KikoQmZvYhQv8EOy0/HCCYmPQn8kz1hsMPTO6XTbjioyEVknq6VCbxEhNkRpIrLO/sSucPIjBHJHn2N69npUaTDSS4/x0Xa9fywEwY74TK2Nn/fSjD2OtUPvYIbdBwf4/tfPrUf7ggCW5soUl6rUyk2yWzT8DDo2HdcvzW2qvszmE/QOZknsuG5UR5J6EGIeSWgIKR6+BwMbkBFSDF/oCF8jCMxOiiuJJGWRpCxCLCJEZH0ZKEgiBvIQstRDEJiAhyx1IaQkkkjxk9h+6eGeNiETBFV89yq4U2E0JvDwvUkghhAqCBVEImSlQiYIwG7/GYFfJAiaSMoBZGUUSR4Aea2kL+zL5HsT4GkgIgiRxHcnwnVCD4mUiCGEhhB6aKltn8X3Fgj8JSR5HEnuR1ZGQB5gJ3/MBz10fuCxaM6z0J7dautt7eNe2Il0zOMMGjudDrrXsez0YIdgR1MFO+aps8PHBR+P33dtVn3g+AgHjo/whV86xeTVRS6+O8XVc7Ocef0arYZ5z3Yh5WKdt1+9yntvXufK+zN88Vee4sDx4Q1Vd9s+Fkmg6somLZLreLjORiIkhEBGRhYb55KSkFAlGaXz3xrZuXM7Rdy/99bd62eaC9xszHKhdp2fH/gMfUZ+2+f0cYRtP3z05V7wPH+zVkeApqn31BE+CMPjPRCERqJ3Rvxsy+XWxBK9703z/OePbNrOdb2wwfAPb2K1NxKe3Qf7OXxymyVjDwFJiiJJu1DVMTaagN2dqVi73mLD55RI74ZlhvGpOz4Hqrp77Zt2/Nh/lPCQ0wujE33RAR/fnQ6jOwQgGghpAEkewrPPI6kHQBgE3jWElELI2TAHiY+kjCDJfXfsV+3s1wB8Ar+C70+G+0UGISGrR/GdCQI8JGUU374ASEjyAEIZI8BHyHkkdR8fxI9qem0qTpm6W2XVLlG0lqm5VWpOlZK1Qt2tYfobG8vZvsWrK9/h7dW3kO8zON6NiBzheOYUpzLPktEe30yx7tao2KvMtKaYa0/TcOu0vCZtr4UfeAghEZGjxJUEGTVHt9HDeHwvGTWHIW/P/2K7+P3Zf8l08yZ2R/OwO76XPYkDnMo8u+ml1vQalO1VrjUusdCep+5UaXh17I4QVBYyETlCSsmQ0tLktC5GY7vJafkdd7ZesQqU7VUK1iIL7VkaXh3Ta2F6JpYfmslJSKiShiFHwuNSM+S1btJalrzeTa8xgPQY9+a9XvllZ5WSXWSyeYOF1gwtr4npmbS9JrJQkCUFXdLp1nvIaXnyei8HUodRhfaB6UeEEAyNd9M9kOGTnzvML/+tF5m4MMfkxCJXz89y/eL8li9L1/U489oErYbJ0afG+Utfef6hv1uWJWJxY9P9ZJkOlrU9T6yhaC99RldYwr9DJeOjsQEGIj08lTtKQon+6EZ3OrAtF997/ImAbW4tTBaEwuhHLVhRVZlULsaTL+7n7A9urJujAty4NI9uqFsSnpkby1w5O7PBxwfCKr/dhwY4+MToIx3P9iDu8ff7Lbvf8u2u/8nAQz1xgV8h8NsgNCR5kCBoEPh1fG8ZWRkCESdMKeURUg4hRQGHkIAoCKEQBA5CyiDEHYNI0CLwKyAUhJRHQiYIavjeAkJKI6QsBH5HsxNHSFkkZYQ1QiSERhC4IbESO18O7AYu71feoWgvU3dqNLw6NadKy2vR9prUnTo+mx/YgICm16DpPVzTuogcpe5UH0sP5PgOptdmpjVJwVykZBcpWgVK9gqm38byrM6L2u9Uj+gYcoQVpUDBWmDFKtBnDJLT8vRHBonI0R0pnS3bJQrWInbHjDGlpsgbvevrg8DHCzwmmzdZNOdYtgostGcp2yXaXgvTb+P4TuiILCQ0SaMkF4lZMeJKkoK1xPHUKQajI0QekaytBeqbboOqU2GhPUvBXKTqVKg6ZVbtIqZvYvsWtm/jBu5tbx6hoEkamqQTlWMU1AVicpykmqbb6GU4Mkq30YshPUqzSYFCWO3jBR6Ob3OzcY15c5aStULBWmTVKmL5Fo5vY/sWkpCQhIwqqdScCgVlkZQ6Q9kpMRQdJat1kdUevr/QA49UiPXO4vFkQKYrjqzIdPUk6RvOMTSaZ366SLFQZWWxumHbVtNi6noBPaIxN7VC72AW9SH8NyRZwohqm66vbTmYbQfbdDoRoHtff01S0aSd9fXSZQ1d1oh/hELRnUIQhClJ1318zWKrYWFbWwvd9ccgPEISGBGNQydHuHpuZgPhqZQaLM2uUi03SSQjG6pHl+ZXmb6x0VlZSILewSy57uS2TRAf4Ygf8TPbWfZTwgMPTXiKEDQRIoasHkMIge+Xca3TKNpTIUlxZ5GVPUhyL0KKIclroTbYOkRHhzitIDCQlb1Ico4g8HCsV5GVESR5AM9+HyEPhKV0UgZJSz9wvzsFx3d4rfgdls0l2ndFcT6O8AKPltdg2SzwRvF7TLduUXHK993G9VxaXpNVO7R3v1A9y2BkhNHYbp6RnqfPGESTtB33C7EDG9Nb654b4AQODbfO2+U3uV6/yrK1hQMrISnxA79z3C2KnYn75dp5smoXXXr+kQjPegmrb1IwF5lsXuet0mus2kVs33rAtmAHXudzdVYpwh23S0JJ8unuLxBXEhjawx+bEAKl8xK2PJOyU+T14neZat2k5lS33MYPQuG/7Vs03dvE+3z1LE/nnmdf4iBxJfSC+aCq2YQQyIrM0K48Q7vynHh2D0uzq7z96lUunJmkXm1vmk0Xl6qomszlszNku5IPRXgURSKWjGzS/9iWS7th0WyYpLTYT6v3HgNBENCotXCdx7fgqFVam/22OojE9MfyajIiKkdP7eLP/+QMK0vVdS1Ps26yslhhcWYVY28vsiKHflQBzE+XNjk/y5LE7oP95LqTj9xK40EIggA/aBN0Js+yCF2M73efBoGHH7j4gcndHcQloSFvQ5TsBw5B4OIHm8c3WYoiiR8tU8z74aGMByVlN7Cb8MKu+WZkUY2XAQkh4sjaWqpK3PXn3X+/Y6nUHUZ21Nv7BRlVf5E1IiNrTz30fn9ScatxjXPV9/hB6fuYnsmjSgvn2jMsmnO8W/4BvzDwl9kV20tfZGfbd5ieScOtd/7eZqJ+iW8XvsZMe/qh/YwEgqzWRZfeTVp9tFSgj4/ptfk383/AZPMGBXNxy+jdo0ASMkk1SUbLPdItKyHQJZ2W1+Bi9SzfKXyDilPG5+F1FKbf5rWV7zBRv8SytcTzXZ/FkD8cs0QhoG8oy5d/9Rle/OIxzp2+xW//799kZbG6gfRUV5t879+d5Yln9zxUV/NIVGfX3t4tq2iaDZMblxc49vQ4mvaTrWd4HARBwNJcmVbz8dvmFBbK1KutLdYIBka6SG2jOee9oKgyw7t72H1wgHbTZmHmdmFJs27y6tfPke9NrTtG18pNpq4tcfPKXYRHlXj+5SN092/PqO/R4HOr/L/RsC8T4HIo/89R5XRYfn4PtN1ZVluvMV39p3jB7fJ5gUxP7GfZ2/U/P/Bbq+YZyu03mav/zh3bC0Bif9c/Jh97+XFO6mOFh6LOYovZfUg+7xxYHs3M7e7tdmK/OwVVUngm9wINt47jb90z6VbzOitWgYpz26RKFgqj0V30R4aIytvXlKiSynB0jKj8cA+65ZnMtqd5deU7zLWntyQ7UTlGQkmSVjMYchQhwiiA5VsUrQJNt3mHFinACzxMz+T14vcoWUUOp44zFtu9Y7Njx7dCLRE+p8tvcq1+mYK1uIHsyEImpWbQJB1VaEgi9EixfJOaU13/rCQkhqIjxJT4Ix2f7dssmQu8WXyFa/XL1N3aPcmOJukYkkFUjqNKYXTED0KytJZ6uzMlKZDYHd9HRs093rUTgrf+f/beNMaOLE3Pe845sd49b+47d7JIVrH27q7qpbp7etFM94zlmWlbnrHlAWRrxoJhGLYEwTZgwz8swxAgWAP9kAeGII0lGSN59lGru6en1+ql9o1VZJEskrky97x7bCeOf8TNZF4mWczk0s3qrheoymRG3IgTce+N853ve7/3Xf0Oy+FSd3xZsGMJi6JVYsAdwpUelrS7YphtWkmTlXCFMO1dBaakrEdrvLj+Aw7njzPkjVCw7s6cb2+XIEBk/l/5ks+px6d5/JmjvPPaDFcvLm3vF4UJ85dX9y085+Ucpo8M3VQUr7HZ5q2XLnPqiQM490Hl+ecFJjXMXVmlfYNGzZ1g9tIy6yuN3RsEDI1V7kpJf0vt98SZKZr1Tk/AE3Qi3nzpMn/tP3qaalrEpIbzb8yyvtLo4ZfZjqLUl+fQidFbWGDcOxjiLMNj9vaMsGWFkvso46XfQqctknSdtfa3SNIWZo8LRt+aBP8ZhLBITYd2fIl6+AY6bcAdLKYeZDyQ33idRoRpjUg38FQfntW3Y1tImNazbVYVT/VG3MYYWskSripiyyzICHUd0yXnOrLUM+FoExGnbSLdwJBiyxyW8HDU9Qe/EoojhRPEJvPLuRnaukU7ad4Q8EiGvVFOFE9R2Qf5WCIpWiXsfZAlkzShmTQ53zjLxeZ56sl1SXWJwpFORp51huhzqlSdAXyVR3Yn6o7usOT0sxltsNklwSZpTCa4nzLTvowtHDzlMeZvlbfuXiUhTmPaSYvVcJl3G29ztfUebd3GlS45VSCncuStIlWnH1d5ONJFIAjTICOSR+u0dIswDdBpwpiX8Y32g62swnq4wtXWJd6svUot3sTs+LJnhGSbvFUgbxXJqwJ5VaBgFXGUg0CSomknWYDR1q0uebhDlIbEacx07hAlu3zHROGUlE7S5kJ8jlbSJDYxjnQpWWWKdplBd4hhdxRf5bClgyGlnbRoJHVK9gJLwQKtpNlDrg/TgIXOHLOdK3gsoL3XAAAgAElEQVTK+4kEPDth24r+4RIHT4yyulTrCXh0oqlvtEh1us2R2gsc12JwpIKXc2jWOtu+b5Ct6i++vUCnFeK61h0rhv+8IzWGteU6jXpnW0pgvzDGkKaGhZk1auutnm1SClzfodyXx/PvvoQ0fXSIhZk1lHVd6yeONYuz69TWWwyOVrBtxeXz13q4PpCV1YZGK1QHi/fZr1HgWVOAACOQwuZ2DThK5vDtKfrlp0nTNkEyTy14Gb0P6oWtqkjhorZUmoVHO36vG/D8bOG+BTx30yrb0avMNb/PXPt5Dhd/kYOl6ym1drLCfOt55lrPc7T8K0wXP9tzTkPCxfqfMJb7GEN+JhG/3HmdOG1hSZ+J/LNgrj/kgmSD1fAsC60fkZg2/e5J+txjjOae3N5HCsWYP/G+Yz5fP4tzQ0lAIKnYVcb9KYZ2EHPvB1q6yVznKl+/9uckpjcLlVM5Rv0JPj/yJQ7nj79v6aIWb7DQmeNP5v+AlbCXs3S5dYG1aJnjpdMMuSN4XV+gu0GYBqyGy3xv5Zu813yXelJDIBj2xnik/DhHCw9xqHAUyW7F5KzmrZnrXGWuM8N8Z4ZjxZOUrN3aGrdDalJeWP8BZ+uv9wStW3CVy5A7yqOVJ3ms72lKVvmWHWwGQ5zGLHRmudy6wFxnlrn2VU6VzmTlrDtElEbMdq5s/1siGXZH+fjAZzhaPMGIN3bLa0vShO+sfp23aq9xoXmudzspL2/8GF/lGPWyz/lPmt8yMT3AezdoohiTTUqJ1pnvzh6tQBzXpn+kxPBYhU4rpL5xfQJr1Nq89dIVluY2cByLQvlOyOMfApN51i3NrbOyuMnEwf232BtjSOKEd9/sNfmEjKw8NlWlWMlt2xbdDY6eGmd5YZN80aO+2QbT1dtphVx+9xrFss/oVD9vvnR5V7ZpaLTC488cQVk3Fym8VxBCMlX+L/f1GikcpHKwuwt/Jx7CkkUisbrnYyiZQ8kcjpW9h5FexRJFQq7d5pUfPNy3gCdOm2gTIRC4qkyUtonSJp6qoIRDaiLa8XK2r2mhTcyAdwqBImcNcbD0BZaD13eV0fL2CAdKX2Cp81qm7LwDod6gFl9l0HuYnDXUs82gidMWi+2XKFgjeFYVRxaxVZ4h7wz97kMoYXOx/mfMt37QE/B8EPD65su8uvkCsdlZUxf02X08N/h5TpbPMOAObavI3goFq8Sh/DF+6+Dv8JdLX+Xd5tushNmqOyWlmTT44/l/zS+PfYUD+cN3Pe4ojViPVvnh+ncJdcCAM8jx4il+YfiXyFsFHOm+byt3FoxOMeSN8kj5CVzlYe0z85SYmNdrr3C+eZbFYK5nmxKKEW+czwx+ken8Icp2BVd5t20vt4WdBbruCE+YhMQklKzyPSN9F6wiI944//Hkf56NSd46iM0E9Wye7f80ZbsPX+V5o/Zyzz5XW5c4VniIju7ccXfb3aC20aLV7C2PSCXI5V1s29q38rJA8NwvnuH73zjLK89f2P67MZm56e//7jf4/K8+ybOfP419C7XdD3F7vPbDiwgp+Bu//Zl9v3ZzrckL3znP6rUaYdDLBerrL/Ls507juPdmilKWYmSiyjOfPcVf/skrPWXSc6/NkC+4FCs5Lp1bpHlDhmdksspHPv1Qj1/fh/hg4r4FPB29RqTrCBS2LBDoNWrRDP3ecTxZoaPXudr6FhXnIABih06NFBa2LCCQ3MjdkcLCkYWb8okMGWt9I7yEp6oU7OtZlUg3CfUmjldgLTyHFbtM5D+BEk6WQcQQ6hogsN5n8njQYIyhntS4FixwLVjo2aaE5FT5DNP5www4Q7jy9jL2SiiklPQ7g5wonsKQshaubHNFtNEsdOZYDhbpc6p3TA7eHj8Gjaaj2/TZVabzhzlTeYJ+ZxAl3n8i2rY3EDY2NneiQ25Mlo05V3+LzWiDZEfd2xIWBavE09VnOJA/TL87iLOHMqPI1AWzcd3j1uat4w+5I5wpP86AO4h1G7ftrfuUs/KMe5O0ihnpeSfZeas7rpZs3DLg2XKxv3pxCSFgcLRCvrhb72Y/SFNDHCW8d36R5fneVb5tWwwMl1HqDvzQBBx9eILL717jnddm6LSud6AYk13DK89fQErBk584jpdz7ljgTic6y0TFGtez74sD/IOKxdl1cm/McuHsPNNHhvacjWlstpm7vMoL3z5Hpx2xsyAglaTUl+P4I5NY++jOez8IIaj0Fzj5+DTf+ovXegKea7PrzF1eZXSyn7Ad9ZRAK/0FBkcqDI6Wt4UsddqiFV+iEb6Bbx+g5D5GJ75EJ5kj0ZtoE6BkHkcN4Flj5O3jN+WppiYhSGaoh68R696sspIFhvN/HSnsm851DyJivU6ol2lFF9BpnbRbabBVFdcaxVNjuNZY914YjElZbP5/KOHhWsOU3afJnNJTUhNxrflvSU2AJcsMFb6MJLNnMUazGbxIqK8hkAwXvtwdwe2fEfcv4EnWaCVLKGFTdg/RSdbYCM9TtEdxZIFOssaVxtc5XPoynqrgqBJdGdo7hhQWlvBZ6rxC2ZmmnxPb2+K0TTNeYDj3GMvBG8Rpi9Hc01jCRxMQ6Rpr4TlA4Kv+bbLvg27sZzAsh4ushEvUdrSeZ6t6hyf6PsqoN467D8+eTE/G5mjxIRCCVzdf2CZAGwyNpM5CMEefM3DXAc9OjPuTHCs8xKnSo2hj0CYFI7D24Ui8X6RogjTrDmsm9Z5tnsox5I7wbP+ncZW3S433pwVHuoz7kzzW95FMPHAfwcCAO4TBoKSFSeMeUntbt9iI1hhxb14ag0wY8I0X3sOkhlNPTDMyUcWyFVJJLCv7eSubgC1kvnyQaE0UJmyuNXnntZkeQilkXJzxAwN3rMNy4NgIk0eGGBwtM3Npuadrd2O1ycvfv8DqtRrj0wMMjJTxfAdlyW7povcatkr0W7wT0/UD01oTdGJa9az0Wx0q/VwFPKtLdQzw8vfepVTJUanmsZwsI3ezErQxEIcxC7PrnH9zjpe+d36XOWgu7zIwXOboqXEs+95998vVPA89No3rOcRhsq36vTS/wcylZYbH+3qCHYCRiSrDE32UKtebTpK0yWbnBebqv0c19xlca5T1znfZDF4iSGaJ0w1s2UfeOU7ZfRzPmkDh9yzqs/uR0Ioustj4A1rRBcCQmgCDxlWjDOa+2OVJPtgBT0YtCOgkV6kHr7Dc+hqRXiI12XfCs6couY9Rdp/M+EJbgQuaufr/jSXLlNxHKbtPZ8dDo9MmVzd/lzjdxLemqOaew5YVBNnrVttfpx6+ihI+Q/kv71JVvxV+at9MKSxcVeFg8fN4aouUfHfBhSOL9LlHsITbzQ5dR94eouCMM+Q/Rpy2acRz1KLLVJwjpCYhTtskJiROm91RbGn7PNhIjebljR+zEvbWWwtWiXF/koP5I9h3qKNQtEqMeRM8Un6C1zZfJNyhQ/NO/S0kimPFh+5q/FuQSD4+8BkOFY5hgPcaq4RaY0vF8fLgfSs5bETrXGldYiNa29Xefaxwgo8NfHLfJOj7jePFkxzKH6PvDoJNR7qU7QrD7igr4VK3cytDR7epRZu3fK0xWUbme197k3Ovz6KU5PBDY0wfHWbq8BAnzkwyPt2PX/Bu2wHVagZcPDvP+Tdm+dq/fYmVpdqubqxyNc9zXzpzx67USkk+9pmTDI328Q/+239FFCY93MKN1Qaba03++9/8pzzx8WMcPjnGiUcmOXp6HD/n7MouGGPYWGmyvtpgbbnOe+cWuXh2joWZdVYWa/yN3/40T33q+H0UpnswsbZU5/d/9xuce2OWMx85xJOfPM7E9MCux2cSa1qNgG//u9f51p+9xpULSzd1Qv/450/z5CePUyjf2/voejZDo2Ueeeog59+c3Ra83Fhrcvn8NZSSu9S/n/zEMY6evLUUx0bneYJkhiCZp+CcpOp/AoHFZvAj6sHLbHZ+SJyuM5z/VfJOLwVACoeK9xSuNUSsN0jSBvON3yeIZ+7pdf8kMN/4fdY736UevIZnjVHynsCWFcCwGbzIUvNPWW7+KVOV32Yg90U8awSQ5KxDRHq155qTtE4zPtddjAlSE9GK3qHkPpYRuY2hE7+HEj6+fWBf47xvAU9mpye7k4jZ7obauV2SpevuVcru/RzSjUmBjFOUGk1qNJLMld2WBUrONJ7Vz0zjr4jSJrHuYEufPYeOPyWkGBY6c7SS3i6Hkl3mUOEYkjvnJwghyFl5jhRO8FbtNUKuBzwb0Spr0QraJHd1DrjOd6k4VZRwqEUdXliewVUWg36B4+X75znUSOosBvO72vfzqsCwN8akv1VyfXA+B5O5Awy4Q3c0pqxNN+sC3IjW2Ck1pk3SEwDdCiY1pDol1Smz7y2ztlzn3Gsz/PCbZ/FzLn7epVD2yRc8bEdlGROyCS8MY9rNkPWVOo1ah8Zmm7WVBvoGxd6xqX5OnJnioUen74i0unVvSpUcB4+P8Mu/+TG+9+/fYml+oyfoMcYQhTHvvHaVmUvLvPTd8xRKPo5rYTsWjmeT6hSdaKIoIWjHRGFMFCa0GgGtRoegHZEkaZYx2GevhjEGHWuiOCGJs4zXltVCnGiiICYONUmcEIYJ66uNXarEUZiwem2Tl773LoWSj2Wr7dKaZSscR+G4mWLx1jZlqbtypFeW5NNfepS3X51h4eoqabel+9rcOi9+9zyDoxUKRQ/Xs7Eci04rpFHrUFtrcm1unZVrNeIbrkMpmQlTfuwIJx6ZvOffuS1H9sefPcrGaqNH4XtjtcHbr15Fp2l336ykevTUOKNTt240SE0HnbY51Pd3cdUISmZigX3+s6x1vs1a+5ustv6SovMojhrAVuWdI0LJAjn7IKk1QWoiVtpfJUqW7+l130/otEOo51lrf5MkrVF0TzFV/tvYagApXMBQzT3Hevs7bHZ+wLXGH+Jb00jhYMsKnjVBpFeJ9DLZbCbRaZNOfBnXGkalOZQo0I4vU3BOAgUMKUGygGeN41o36v69P+5bwGNJHyksmsk1GvE8nWSVJN1JBhPdQKd3oNrE6DQg0BvEaZtOsk4zvoZv9YNJSUx4820YkjQg0OvEaYeOXqMVX8NTVbYCriTt0IhmCfUmqYlxZIE4bZIajTadjAPUtVrY95Prp4Cs+yZmM1onumGiyqk8w+7oXT80HOkw6o3t8gLrpB1aukFbt8mrwl2V/pSwGPaydmqBItQhm1GHvO1S1vdG9O9WaCct1qLdD5iSXaFsVyja++/4ut8YcIYoWeXb73gLCASe8nbxfrRJezhMe0E26fd+9hzPplDyKBR97G7rtyTruAqDiFYzZHOtua16e8PgKFVyHD09zsnHp+m/iZv1fuC4NpVqgSc/cZzVa3VsW7E4t96TTTImK3FtrF5XolZKZsGBb6N1io5Toii5pVnmnZTdklgTtCPOvzFLGGZBThjEhFsBT5wQdmLiMCGOE6IwobbeIo5636M4SlhfbvDaDy/i593uuB2crYDHtbLAw1bYTvb79JFhSpXctuDefqGU5OGnDmbjixJWFjfZXGuyudZk5uISxUqOQtHH87PAq90KadazADdJdt9D27Eoln0e/ehhpo8OUx28P/IIQgoOPzTKqz8sYduKuPs52Lrv29dnKapDRQZHyxTfJ9MkhY0tK/R5z2LJQtc+yeBbU8R6nVZ0jnr4erfUdbgn4BFCILC7zuUZ/1QJv3uM+/vcu1fQpk0rukAnvoKjhii6j9DnPdM1+ZYYY8jZh9C6QZRcY7XzV7SiSzhqBNup4FrDyMgi0jW06aDw0aZDkMzjqH6k8BEogmSe1ERdZekOSVpHySM4amBf471vAU/OGiHQNRZaP6SdLBHpBonp1Qa42SQZ6Tr16Crz7R/RiOcQHQtNxOHiL5GakEY8x0L7xzTjeRY7L5KYDoeKv0hKTD2aYbH9Y5rJAgvtF4jTNgeLn8OQEqVNatFl2vEKsWnhqyp5e5SlzsvUosvU4qsYkyKQFOwxHFW4X7fmniExMU3doJHUiW9oRfe7/JO75SA50mXYG93FX0lNSjtpsxQscCB3+K66jyxpMe5PbROCBYJBr4Bn2RTt+ytr3kzqLHYWdmV4xrwJynbfA8nh6ncG7yoQ2/JOu/E9S7s+Zrc/wPvfkyiIWQ9i1pf3r+NhWYqTjx3gi7/+NKcevzeu1I5r8cjThyhX87z2o0v8wf/1bTbXmrd0bofMvVvrtGcSfD9knJ/9javVCLh6cYn/5e/8i32LK+5EGMQszq6zOLtbTuFW+J3/8cuc+ehhpo8M39E5pZKceGSSfNFjcLTMH/2L57cDWGOgvtHukQO4HfoGChw+Oc5/9t98Hsezd9mC3CsIITh6aiJTcK7mWV2q33Q/P+/yyNOHKFZy7xvMutYYFf8j28HO1jmU8MnZR6h4z1IPX6cdX8KLxsnZd9/Z+iAh1pustb+LNiF55wSDub+GEO72QjsL6hwK7mlSElY736QevYqtShScE/j2FEoWSZMFwmQJzxojSRu040u4agxHZpYX7egSqQnQJiBMlrtk5j5ctT/l//sW8HiqxLD/KH3uke6kkRW5bFVAoqi4h/nY8P+EK3sf3K6qMOAVqLhHOVH5dSRWN4r2MYCn+uhzj3Oi8pUd23IYDJ5Xpuoeu75NOljCYyz3UUb8J0lJukGNQIrMPHDQe5iqe5zEhNkIheoKPj34iNKIWrxxU+sIT3n0uwN3PWFLJJ7KkbcKmdL0jrb3xMRsRBtM5e5OjVMJi6ozgCVsklTTTEJylsNq0KIVR3x06MBdHf/9EKRBj0jjFoa9UYp3oOdzP7EVqOStwp467u75+QU4juJjn3mIXN7lnVev0m69v7/YXlHpL3Ds4Qme/MQxnvmFU9ulmXuJ8ekBqoNFzjx9iG/9xWucffkq751b7OnguhO4vk3/UInxAwP7ssD4ICPz0upw/JFJjp2e4OjpCf7wn32Pxdk1mvW9qS8LkWVSPv3lR3nsY0d4+KmDuL5z/1kEAo4/MkFtvclX/82LN92lUPL5+BcfJld4//fTEsXupLt70JYq49uTAER6uVu2+dlCpsx8EWNiHFUlZx+66X6OGiBnZfSAIJ4lsOcBgW8dxlZVUhPTid/DUdWMwxOdY7z0BAJFrNdZav4paRqQiAbt+D0MKa4aJvfAcHiEQgmJLxy2CMA7uToKiW/tJl1KoUAoFC7Qm9YUsMdtNzkmW8KEWRZnKwJV0kUaGwufLWbRg8TXeD9oowl1yM3Kb0pY92RSFEIgTdbxpYQi3nGqzJKic1cik5DddberoCyFxLdsDhSrFB33vmdY9LbZZy985d+XlvK7wZaeTtau/9Pp3BBS8PCTB+kfLnH8kUmW5tapbbZp1Ts06h2CVuZ8HYUJWmtSbbqZFIOyFJaVlYoK5Rz5gredIRifHmBsup+pI8P0DRS6XKN7+95btiLfJVQ/9YnjjE72c212nYWZNTZWG7TqAY1am6ATk8QJSZKSxBqpBFJmXWhezsHzbbycS7kvT99ggUp/gaGxClOHh247Qf7MwGSZJctS5Ioexx+Z5Au/+iQLM2tcm1tn/soazUZmChsGEak2KEviuBa5gkd1sEilv8joZJUzHznExKFB+gaKt+3wu1tsHXt0qp8jJ8eR8qVdmT7Xs6lU80wdGtqD/Yi6pbmmFA6WyCoFqQnRNzHn/KDDoNGmBUJ01Zpv3uAhhYslC4BAmw66W+1xVBVLZDIzoV7KyNu6hk6buGoEKRwEisQ0iNOsIzDSywhhY8lSlxi9d9zXLq1Mj+TBCR6y9NruVaMQcldX1wcBqUmJ0l4NC9gK2+S2s/a9gC3sm5a1Qh3eNdtpayIXQqKEIGc5+Hmbou1mremwL2uBvWArSNMmuYk/WpZJscSD1V4shMzsRn5KX6mtIOTEo1Mce3iCONZcPrfIwsway4ubLM1vsLnapNXMeD1Rl5eSaoMxBsezcVwLz3cYnuhjYLjM4GiF4w9PMH10GNe7f47tW5BK4voOp588yIkzU3TaIRfemufqxSWWFzZZnF2nvtkiaEdEYULQibAs1eXCZBNhqZqnUs0zfnCQg8dGGBzJriMb+t7HL6TAdiyqg8W7KmndCbZa8O8GYZigdYrjWIxM9PGFX3uSlWs1rl5Y4uXnL7KyuEl9o0Wj1iZJNI5rky949A8VOXRijMnDQ5x8dIpyf+GONZDuFENjFZpHh1CWIo2TnjVjsZxjcLTC8HjfrQ/QRTan3HzsAgspPOg2yuzV2+qDhRRDQva5V4hbhBQChRBZk5AxCcYkGTFcVbBUESFsQr1MqJeJ0w1SE+GqUZT0u7o8AXG6TmoCQr2EEj6WKmGp/XG9Hqwn+ofYF9JbZCeUUKh7ql2zlVno/bikpN3z3z3BWyKzTp40pRGFXKgvs9CqI4XkYLH/vszxmkwB+UairiDjLt14vT9tZCUt54HgFQkpcFyL42cmOfbIJJlW/w2fhJt9LMSOH93//bTWRMqSFEo+jz1zhEc/dgSMucn4d8hT9P6ArjHl1oLDmP2t74plnxNnJvm9r/53mW7NXVzLfiGkvKv7boAkvq5lI4TYVjMeGa/y9KdOXL+XW7/sOF/mH3t3umt3AyklUnX1luj9qB57eILHnjmyp+MYk/S4lPdsI+lmMgxKuqifQhn6fkOgUOTBpN0sVhsldhtlpybcNiNV0keJ60RwWw7iWROEyRzt+CKhXkIKl5x9GCULZIGUIohnEELRSWbI2Yd2ZHf2/iF6sJ7oH2JfkELh3ORLpI2+pcnpnSFTI76R0CroZhzu4VPLloqS4xGnKaP5MhXHv2/PRIXKWuoRPTwoAyQm2aXL8yGuY2cmZr+ZjQcF+7kGnaYkXRNTY7J/N4OIUs6j0Q6YX6txcKQfnaYIoJT36IQxUZK1l3eimGoxh2fbtMMIz8m6eYI44eLCGqPVEn15D8+1aQcxUgpsJZFC0ugEBFFCECeM95cydWqtcW2LONEIIXBti2YQoqRESkmzE1LKuUghCGONYyl0mo2/4Lv3JJO2K7MsrkeED0JQ/n6Yv7LK+TdmiWPdex0Cpo8Oc+LM1J6Ok5gmkb6551SS1gmTTP3ellVseec+eg8qpPDJ2QdpJ++RpJsEyRx5+/iu/eJ0g06S2fY4ahhHDbL1fbNVH54aJdDzWTdW2sG3pzKfMOGgZA7XGiNKV0lNRJyskHOOoGSR/T53Pgx4PsCQQuJIG3HDEsVgtjtuFOqezEVZANAb8EiRcXvu5aNtS0kpTlNylkOh26V1PzQ56HKGlLB2Ga4mJib9gLSGfoj7j04Ys1JvgQG7WwraaHYIophaK2Bxo0Hed4mTzOi03g7ZbHWQQuDYik5Xc8axLDpR9lkzJgtc5ldrCCAIY2xLsdnskPMcyjmPIL4eNIVxdowwTgiimGLOI01TLCXJuQ6tIKLgO7i2zWq9STuMkEIQJymI7HyWlPiug5IPlrbUTxpL8xtcubC0SxqhVMkxNFpmcHhvDQtJWqeTzJCaEIm33YoNKbFep5NcBjLSrqOG3v9gH0AomSPnHEUG3yXSqzSj8+TtIxijujYR2b2IkiXa8bsAeNbYDv0csGQRW1VpRG9m/BwsPDUGXa6iFA6uGiFJGyS6Tpxu4qohlNi/IOyHAc8HGEqormnk7gfXFhnXvwWJbK8w3TR/nIboG0o/UqjMMf0ePjjjNKWZhLSSCEsI2ve5Ld3qkrsTvTPgMYQ6uAm350P8vGK51uT5s1ewlGSwXCDnOWw224RxQqxTYp1yfnaZTpQQRglhkrCy2WSkWuTkVNb6fWVpg1hrbKWYXd1ECIFnWzQ6IUGccRqanYjlzSZTgxWOjPVzYWGNsWqRgp9lcr939jLrjTbtIGKkWiTvOXi2je/a2JZicqBMtaiYWanR6mTlbsdSrDXaOLZFX8FnqFLAd23Uz2HAs8Xdm7m0zNuvXu3ZJpXgyMkxhsb7yO9RLTtMrrEZvEik13DUALLbNJOagHZ8iY3O84AgZx8h71wvk92s0eN6ltns+IvZlUrbet7evFnEXLdB6fpV3Wx+uB6M7H79zp+3O4YlK1T9T7LQ+Ne0ogsI8TUGcp9GCh+M2r4Xjegsa+1vAoKS+0hXRDCDo/rwrFEivUKQzOGqUXLOkW1ulMAh5xwiSlYI9TUivY5nTWHJ/Ws1fRjwfIDhSJc+p/+m6eOO7rAaLjPhT99VejklJdAdWrpFlPY6GtvCps+u3lPCtyUlOcuhEQWkJsWz7m+nlCNdClaRlm72/H05vMa4v7e09of42YfWKa0wK2HlPYec6/DG5QX6S3l0amgFEWXfw1IS4ViU8i4TA2WqxRxD5TxvXl1iqFxAAG9dvUa16JP3XTzbotkJCaIEW0kGy3kmBzLD1GYQ4TsWA+UClpJcXFyjkvcYKOWwpCTSmpLvkXNtcq7DK5fmUVKQGphd3qSYc1FS0Agi+ks5Cp5LKecRxAmubfHzaP5tDCzOrHH14hILV1Z7timlePbzDzMysXfLFik8JBZnl/8rCs4pPGsUJXNsBD+mE18h1muMFn+donsaW+48rulaJrxLSkBqInTaIUgWM96PSVnrfAtLVlDCQwoPzxrHksXtzIYhIdGbBMkCmjZpGhLqRRJT6xqTLrDa/gZK5JDSRYnc9jG2pn5DRJAsEuuNTDXadGhEb3Y7olIa4RtIbJT0kcLHlhVs1Y8lM7FEJXzyzlHGS7/Jeud7bHR+wFtLf5uC8xCWrGAw1MOX6SSz6LTFROlvUnafwrOu+/XZcgjPmiZJm7Sid1GuT8H5AqLbJCOFQ8E5yULwLwmSWQyGnH14ewz7wW0DnmYrYKPe4eLMCscODKFkliIdH6mwttEiCGM81+bi1WVKBY+RwTLNdshgXwEpBUurDWxLEcUJUaIpFzyklMSxZqPepq/sUyr4FHI/e4Su+w0lFJ7yKVpF0lj3iA+GacB6tHbXk3aSxvjlytsAACAASURBVKxHa7uyO1uaMFVn4K5EB29EagyR1mxGAY6yUEJ2uaP3tktrC77KUXX6WQoXe/6+Gq7QSpq3eNWH+CDDGENKzEL7FTajq5yufOW2n61qKc9TRydxbYtKwcexFE8cmSDvOaTG0Aljljezz4trWxwcqXYDI5uca3NsbICi74LIVIqLvoNjW1hSUsp5GGOQUuI7FrbqymhgCKOE/lI+06yRWRejUlkpNklTXFthK4VtKR5OR6jkfAq+yxNHx/HsrNydpCm+Y+NYCte2yLn2XdlKfJBh0pS3X7vK6rVaj1FoRmD3OHJyjFJl71lxzxql7D5FkMwT6WVCvYAhJdZr2LJCwTnBQO7zOGp4ewKHLFiJ9QYLjX+FIcaYhJSYIJlDp5lN0Errq0jhIoSNxKaa+zRF5xS+zJ7pOm3SjN5hufXnpN1j6LRJrGsYEoLkKkvNP+k6rlvYso/+3GcpuY90GzIMSdpgvfMdGuFbGBKMiQmTRZK0zpYPViee7erW2V1D1McouY+zLTVjbPq8jyGFiyOrdJKrNMK3QCi2DFF9axrPGqc/91kcNdhjpGrJPI7qRwhFakJA4VmT2wtpKWw8axJDSmoSlPRxVD9K7l8C4rYBTyeMWV5r8KNXL9NX8pFSUm8GjA2XWVlvsNnoMFQt8srZWcaHK+R8h5mFDXKeg21JLs+vkfOcLM0bxUyMVEiSlGYrZGGlzvhwmclR8TMQ8Nw8j3IzUcB7BdUlLVfsKh3dId5RlunoNivhUpa2vItnW5RGrITXdhGWLWHhK5+y3Ye8hxkegyExmnYSYYxBCUHa/Xk/kLPy9LtDiEYvcXktWqGR1EjSGNUVqfwQd4YswOiKfgqJegCEPbWJmW+9wJXm9zld+XVu9yXpL+boL/ZOhEOVTGPFGEOiU75/9jJSCHzH5sBwHznX2e6+Kua87TOMVksZV637mZocrJB2ywtbdLyd27fO0V/Kbx/jxn2MMVSLue2/DZbz23+/2fF+HpGmhjjWvPXSFdZuUFj2fIf+4TITBwbw9jEXuWqEivcUQTJFPXyJTjJLktZxVD8F5yFK7uP0eR/bpZulU01H17na+DauVCgpwECcaqQoIIVgtXN2W47DEhaWmkKIURCj2FIS6Da1aJaF1vewxPUgWRsHJTyiVLMRvEEriXCVRd4eoeCcpKWO4CoHRyqCpMla5yzrneexhCTFkBqDMS5K+oTJCrG+ngnTRiPFMKl4CN9yUN3rUuo4eSeHEEOEzT+lFc+iTRtLSBw1hWM9Qt59DMd6lFQoIp0Qp5k5NNgYUcIwghAxSg3iWqO0kgRHCRQWUo6QUsWIJkr2kYoCoRYYIiwhsaRC7uHzfduAZ6CvgJKSgxP9HJwYYHmtwcWrK2Bgs9Gh1Y448HCV6fEq48MVRgfLvPTmDIenBjDG4tpKnVLBY7i/yOHJAUaHSvy777zNylqDkcESMwsbFHIuY0N37g30IEAK0W2s7sW97Za6yXkRHCwcoaWbPWWZjWiNt+tv8KnBz93V8Vu6yVv114hvKGcNuMMMuiP3XKvGloqK4zOSKyKFoBGHNJOQguVi3YcHdtnqY9I/sOvva9EK851ZZjtXOJDbW4vqh7g5tImoxTM0kxXyqp8Bb3cXxwcdlpI898itbQPELX7f6/b9HmMvf/95Q9AOWZrf4Id/+TbNeq/N0dh0P8996VFs19pXu74hBWExXvpPGOc3brLHzQ+2ESdcbXp8Z+Pv8/mxEwzlyiRpytnNRSp2jorjsxw06CQJvrIZ80t0UMzV2nT0BR6qDNOIBZvRR1jnIY4WBtAYOknMaqfOeK6Cr7IM39cuv8JTA9NMl8YZLgzwxzNvMOQ3+OjAAa60bBaTv0msfpMD+SrNJKQWB9SiDhNehWPlYfrd623ma2GLq811/ujiN/n0yDEm833EacrbtUVKtseAewptnaCWNBFCMJIrcbW5TisIidOUAe9dDhX6CdOEtzevcboyghSSMIVl838wne+j6JdRoo8/nnmZx/onOFwc4ErLZVn/PRxLUfXLnN2ssR4uEumEiUIfx0tD5Kzb8z1vO1vt9MSAzOvGsS1efPMq11bquI6FVJJWO2Z9s83qRgvfdXhvdg2tU4Igopj3UEriOFkU2l/JkSSaMEqYHK1Q2SNB7P1gotfBtEA4YD/akzK77WuTOUjOYqJXEf6XEPbpfZ/fkjaW7L3hhpRGUt+3IeN+IIXidPkxFjvzLAbz239v6xaLnXlm21cY8UbJW/sneLWSJsvBNc7X395F4D2QP8zB/JF7vmoMtWYtaOMIRWoMm2GHHy1d5ZnhA5Sce69iW3H6mM4fIqfydHSnpxPtSvsS1prNhH8ga2H/Kakbf9CRmIClzpuAwRYf9EzubtyL78DtjnGn23/eszpbSGLNe+cW+eq/eZGgHfYQdnMFl6nDw3zkuRMope7gnu12ErgdyrbPZL6PyXw/4/kqAsEPVi9Rsj2acUQtCmjEIR8dOogxhnO1JY6UBohSTaAjXGlxvr2MpyyeHTrMD1cuYwlFznI4VhphNFfCVRbaGKbyA0zlBxj1rycVsqyr4VJjlcPFAXKWwytrs1hSsRG1WQ0auMrmQKp7rqto+0zmq0zk+hjP92FLi+eXL1C0XVpxRCteJ2c5DHkl+twcQ16Rq82NrKNYSUIdc652jaqb57OjxyjYLu/WllnqNPjk8FFeW59Hmzrjub7tWxtpzcX6Ko9WJ2gnEedqSxRsjz7Hp5LPMZ4v46q9zfd72su2FWPDZSxLkfcdRgdLGAz9lTw5L2tLHh4sUsy5WEoyNlwmNYYk0YyPVOgr5akUfTwnS2UP9Re7vB7NyGBpH+UsAybGmDaYEISHEB7ggNmAdDP7Xa1gRAEhXMDORDZMgjEhmCYIG4ELshu5brm2J+ch/cQex9ILR7rdjqnrSE3KRrRGlIakJr0vE6ZAMOSO0O8OUrRKNJIsVauNpq2bXGi+gyMdHOnt2Soh+zKkLAbzzLQvU4s3ezRpbJE5qA97o+9zlDu9nixb5iir215v2IjaJPcpU+ZKl7JdYdgbYzGYo6OvGx7W4k2utt7jcusiY94EOSt/x+/hznLZg65Rci9gjEGbiFayTC2aZblzFiUd4rSzfSf6nGl8q7+bym8T6E1ayQraRJmqtPAp2qO4qowUitRomvE1UjTGaBITEekGhhQpLIa900hhAQKDphbNEaVNkrTTtZRReKpMxT0AZCqBBk09nqejN9BpiCElbw3iWwN4am+tycakaBOzHLyFK0tIYdPRa6RGY0kPT1Uo2xMZJ0c3WA7eZCz3BPaODsqN8DKJCShYI8SmQ5pGaBMT6BqOKqCEjTEpgd7Et/rIWYPYMsdG+B6JifBVhVayijEaKRRFexxfZcJsYdqgES9QsIbJ29dbo0PdoJUsIYWNr6q4+1St/SAg1SntdsjspWXOvnyFd169usutfeLgINNHhhjaVsveJ+6AtWBLRd5ysIREkJXtQ51grIzLpZDERlNxfOJU00pCtnqlDFCPAwIdb5f8Q52ghcFTFn2uT8n2cJRFnGoKlkPecnCURSuJaCYhfmLTiMPsdSZFm5RQJ3R0TGpS8pZLPQ6I014qg7M1bqkQbKntJxQsFyGzKkeoE3KWQ8XxKdjZ3C4Q22NNjCbslrS0SYlTTaSTLn8zoSNjmklIMwloJFmGf2uciUkJdIIjEzxl0+f62bn3+MbtKeAp5j0+8WSW1s/7DoPVQk9d2BjDJ5/KtkshGBksbdekb1ZXOzQ5gJkw28qke46oDRjThOQ9SFdAjmLUKMjul9hooA3Rm2CNYdQwQgxkCqqmDXoJ9AUQfRg5iJDZmIUaw4gKovOHcId8lLzKk7d6FSa10cy0r9BMGmiTIMgCjnu56hJCULYrTPhTrIZLnK2/sb0tMZrvrnyTnMpTtEqU7b7bnj+r+RvCNOC1zRd5u/5GT9ZDIrvnO8Cotz+n2r3AVYp+N0fJcdHGdL9U5qblwnsBKSSe9Hmk/Dht3ewJeDq6zWIwz9eX/owvDP8yk7kDPUrHt7uP2793n4gpaaYo/XOy6g7TOlea32Wu9WPWwgtIYaGEiy2/DsCTA3+L6fzHAUEzvsZ85yWuNL9NO17Dki5Fe5zj5S8xlnscgU9qYmZa3ydK28Rpm3ayzmpwDm1CXFXii+P/EEcVEQjitM3FxtdYC96lHs+hTYIlPUb8Mzw98DtA9hDWJuZq83vMtV+gGS+j05CDxU9xoPgcw97D2X63eb9SNFHa4AfL/4gh7zS+VWWm+TxR2qJkjzHqP8qZ/v8UYzTr0UW+sfA/8GsH/h8qznU3+Av1f089nudE+VeoRVfp6HXayTrLnbeoekfwVBltIhbbrzKRe5pDxc9Qdg7w5sYf0E5WGM89zZXmd4hNC1v4nKz8GhP5pwFYCd7hrY0/4Hj5Sxy2rpe46/E879b+At/qYyL/UYbUyV3X9qDDpNmi6Hrr9k7pZEMUJsxfXuWP/vnzXDg7z7UbHOWFgI9+9iSnnzyIfVvfrHuHrXmxmUSsBk1ylsNkvkIzCel38pRsj1aS6ShtLQIxBldZhKnmUmMVSygCnfDy2gxF28UASkg8ZffMu6KrCJ6kKYudOovtOnGqWezUKDkec61NDNDn+iy06/R7eSZzFV5emyVJe4PDLXuZZhyyGrQoOx6T+QqtJKRk5+j38sw2N3GlwpFbXVYSJdX2zNrvFEhSzbeuXeDhvjGiVOMqixdXryJFFhhtjXPI2yRn2VQcn3drmflqn+tjTBY0OnJ/79kdv8M3PgJu9++bHmPfz/0E0jroGRBlTPh1SNcRpX+QbU6XIbkA/pcg+AaYBqb49xAmgegVCP4U/F/JskPpGnDvuBkj3jgbUe+XyWBo6ybfWv4aS8ECnxz8Baz7RNh8pPIEfU4/M+0rtJJmNyNjqMUbfH3pz3mr9jrPDX2Ow/ljuOrWpaFGUmcpWOSr1/6Yhc4szaTRsz1n5fi1id9gzJ+4L5kKgcBVFp8bP74dVBvY/vLcDzjS5tmBT7ESLhHpiPX4OkkvMTHnG2+zGi4z5k9ypvIEDxUfxlc57Pd5Lw2Gjm6x0JlnJVxiIZhjrnOV5wY/z6OVJ+/btTxIyKl+Tlb+Q6byz/Dq2j+n6Iwy4B5jNPc4AHZXXj4xAS+u/VN8VeFM328w6J0iTGushRf48eo/4RNDf58+5wBWV1V8sf0KUtg83v9bFO1RUpOSmhhPVQBBLZ7l3Oaf0NGbHCx+hon8UyjhEOg6Ulg4Mk9sMtPb1CRoE/HRwf8aV5YI9CbfXPyf8VQfBWuIvDW8p2s1GFrJKlHaYNB6iF+a/McESY0rze9yvv7nHCw+1x3f3qC7li1fmPiHvLDyT1gPL3K68hX6naN09Aaz7R9Tdqbp6HVC3cBXFT439r8Rmw616CrPL/8jXFVgyD/NWO5xXl//lzTia9SiGcrOFCmaZrzEXPvHfGb0f6Vk3/vFy08Cb7x0mTd+fIm3XrpMruBhOxa2rUhiTW2jTX2zxcq1GmEnRie92Qo/53DyiQM8+9mTjE0P/MTHnrdc/otjz+DIrIx2vDxMYlJU11PwZGUURykw8KvTj2FJiTZpt4kjCx8ynRyQXaVwQSbtsfVstoTkr0+fwRIKJQQHC/38nYc+gURgS8WR4uA2sV0KgTZpN+iQnO4bu2lA4Smbv9UdtxSCo6WhnnE/VB5BCbkdrH1h/ETP67eU7ZPU4Cq1vchOuwkQ2RWE/bunfwFLSpSQHC8N70qiKJHtt58F5B0FPDee4GYnvNua9C1eBcgsmjcroJfBNMimRAOiAOpg979roJNsH1kFYQEpJLOgpuAey3yX7DID7iB9drWnBGQwLAZzJCamrdsMe6N40u8qFAtSNNpotEkIdUhkIiSCqdxBhtyR9w1OdsKXOYbcET5a/QQvbDxPPa51ZasMjbjGnEn5/upfcan5LiW7TNEq4UpvO0MXpRGb8Tqb8QZr4QoLnVnautVTyhp0hzmYP8xEbhpf+fclU7F1zL3WZO/RWfFUjtPlM1jS4odr3+3xKNMmYTNaJ0ljQh1wuXmBvFUkp/K4astkVJCalMTEhGlAqANaukkjbtDSTZpJnUBnf/95wJaStS18bJlHSQdLuNgyh6eucwmSNKQVL5OkHRxnkqp7BE9VsKRHqJv4qkozWcBTJYoyK6G6qoQrS5TsCVxVImt91WQ8CkGcNlkNz3Gg8Cmq7iF8VUWgUGKrU+p6r5MSNkP+w+StIWyZw5IetsyySVHaJM/eAh7ISltFe5wB7ziuLGHZLr7VhyUcQt3Alrs9hm4FJT08YZGzqljSw0p9ivYYAkmYNgh0bfuctvTp947hW324pkhqEmyZo6M3CZJNys4kQ/5JtIlYCd+h7EzRiBcI9AaeqpCz+rHuoMX3QUDYidhcb3H14jK2rVBKIpUk1YYgiAiDmKAd7XpdvugxNtXP5/6DJ+gbLGHZ929BdSsIIG9dV5I3xmCjtisn9tYiT4Df9Ua0jNxVXdk+3i3mYU9dX5hZQmwvHCALALaOcePr7VssMm8ct7ph3Ddi5/m3YIzBkd3rkDe/jsINtkm3Gud+8IESHjREQERW24qABEi7/wEiD1YZ1ATIkYzEbDZADIAsgRoFUwdi7nXvQt4qUHUGGM9N0Wo0e0T6NuMNGkmdhc4chwpHKVhFPOkjhSIxEUmaEJmIVtKkoztYQmFLh4pd3XPAY0mLkl3m8b6PMNu5QmpSmkkDgyE2MZvxOq9trnPRepc+u8qgO0TeKiKFJDUpHd1mIZilHtd2ZXUgK9lN+tOcKp2hz+7/mSrLCJFZ4B0uHEcKxaXmu6yE14jTeDvgi0zEerzGerzGOw3IqyIFq0DBLmALt1se0QRph3bSpK3btHWr5zxFq4TmQ7uKnUjRtPU6IHFlkYI9AmTZH0+VKdojtJN1QrtOkSzg8VUfvjWAb113s5Y7mhSSNKQeL1B1D1Gwhre32SL7Lu18uCrhMOidwBIeUigs6ePKrN08TvcfnBbtUSrOgW4rsYcjc9sZpZQbmxd2GJNuLdq6sKSLII/AQgkHR+bxrSqhriOEJN2huWVJn7IzhUBhSQtPlfFVhVi3CNMGAsmwf5rV4AKrwbscLn6OWjRDoGuU7UkcWXggpALuBGlqiMOE2nrr9jt34fo2IxNVjj08yUc+fQLH3d+1C2FhqRKeNYGjBlHyzppubpY4uN1T9cZ9fhKE+dvtv5dx3+wY+72Oe3GtH6iAh+hF0NeAGHJfQbQlxK/v2EGDScgeHHE3KPIACdbDUDgF+j1M+48g/Qai8r/f0+ENusP88uhX+L3g/2QjWuvpztJG09JN3qy9etvjFKwige7s27zSFg5TuYP82sRv8trmS3x7+es0dW/w0kzqNJM6s50rez6uFIpfGP4lThRPMZU7tK8xfZCQVwWOF08xemic/3fmnzEfzFKLN2+6b0s3aOkGS7vN6j/EHWHvilVKOFji1i2ohi4XzeypsN4tre3YVwiyl+6fjZqNbefKVHTJ0d3fewKc69AmIjHhjldJpFA7RiUQdFfcPZyVrWO937NCMJl/hvXgPVaCd4h0i4X2S6SkHCg+1xMs/qxDSsHjz/z/7b1ZkB1Xft75O7ln3r1u3bq3dgCFnSQIrs2t2d0S3VZLdo+1jS1vCo8nYkYOzxKeiImJUMzEvPhpwuGHidkckiyN3eqR5JixWm5Zvbg7mmySzQVNEjtAAFUoVBVqvfu9uWfOQ2ZdFIDC2kS3SN8voshCZebJ7eQ53/kv3/8AX/6VZzj+why68eBET5VGGM/+OuPZX38EVzjEo8Snq6eLEnAdvBMQh8TBecC/MSjE7cRlFfcTYiRkUKYh6kF4GvwP0x0dhDyaDhwN4uAq+KeIwyVwvw9RC6G/lFiMxP2bOlVJo6KP8dWJ/5QzrQ851zlNy298ss/gLthmwKP6GM+WXmTSnOFH9ddZ7C/Q9OoPLII4qlUYN6c4VniGQ7mjZJXcZ8qycyuEECgoFNQi/8nk32SxP8987xInWx9gh73bxBcfqG0EFb2KJf9ktc0+jRAk1g437OBFN6/EFaENgnf7wTqbznnK+kG8qEvHv86GnbimMsr9F17UpQxjxhGu9d4mImBCfhoJJT13jCKZ3Eo4PulEgt0gCxVF6MhCp+UtoUoZTHmEhnuFtr+CE+xOru8FJ2yx1HuX6cyLhJFHx79O21vCLIyQTWOQZFRK+l7csM1C9wfU3SsUtdkks42fvjvnk0JxJMvM/jHmjkzQqndxHB/PDfC9IJFQ0RVyBYvJ2TITs2Xmjkxw6Ng0I2N5NF2947vq+z6Xmlv0fI8xK8tc8UZZiChO9G42+j2ymk7Fun9X5X8sOL2wykari+MHFCwDWUpIv+MFVPIZcpZO1tQ5vbDKnmqJqdEitufx1rmrxHHMnrERWj0bNwgRCKqlbFK+JWMwXSlyamGVyXKeSiH7QNf1qSI8Qi4Tx9Mgb4GUA2U/SVaVSDK15IAkDd1KiI7IAiYIH4Se/FtoCJEDsZ1yKiXaPVIetM8h5Knk+O12HwBJ9XKdfZn9qW9dY9lepBt0BnEdfpyk/cXESfR6qu8iCwVDNtDSNOmCWnxoUb/tkg+mnKEbdMgrRTbdNdpBm27QwY88gsjfYYESKJKMIlR02cCUTHJqgQljkpo5xcHcUUpaGfkByN+nFZKQEKhMmNNokoYlZ5CETN3bpB/0sMM+vbBHEPlJ7BVhKi4ZIyEhCQlFKMiSii7pmLKJLplk5Ax7snOMaD/94MifNWRJo6BNU3cvs+VeQhE6klAp6fuw5BF0KcuocZAoDlm1T9ILNgkim36wRV6dJKvU0B+gUKAu5xm3nk7O51wkjFyEkAhjD0MuUDF+NtlISTmWDBXjCJvOhSTFXC7hhh2iOLwpTf2+20zdW91gneX+e8lzC7coaDNklAqanB3EU+WUcRy9xar9IQIJQy6gywXuNM4JAYalcfj47K31K1FVmdFa4aEsJDsRxzFXl+oYhkohZ2DchYTshtJolrnDE7i2T6fVx3N8PC8k8ENkRULVFDI5g9pkibGJEjP7x6hOFpGkG9m4QRTRdG1We10EUDJMJCFouQ5tz0WVZJqOTS/wKepJGZBLzS3sIKAmYCQyudZp4YQBcZpJFcQRec0gr+ksdpoEYYiuKFStLLqs0HBttuw+YRxjKipZVWPUtFhoNwmiEFlIVDNZMqqGIv109b98P8R1fdY22oxV8uSyDx7f1erZbLZ6uEGI7ycLRSEJKoUsW50+XhCSsww22z0qxSx+GHJltc5Wu4ckBFtmj41Wj6yhY+oqSxs3FgM506bR7VPJPzjR/FQRHuRJhDQO2nOAnAoipR+H+ljyE6fuLOQb1hlRQEiPgXKYJO5HTYOYAVFESEVQH0OYf+O2U95aUfZ+grFLWplnSp/jicJxznXOMt/7mA13lQ13jY7fwY+9dIBT0aWE5JiyxZhRo6SWKWuVNAX63vpESabJjWCu7Qh2RVLISTleHv0ix/ynaHh1Pu6e50rvIi2/SSfo0AuSgG9JyJhyhoJaoKxVqBmTHModZUyvYSl371SJ3ko8CFi7U+DaNmQhIwsFWUSDYVaR/vKVbpCQGNVqlNQqR/NPsWxfZdNdY8W5xtXePB0/SWH3cfAjjxhQhIwuG1hyloySpayOMmFOUdFrTJrTlLTyfev4SCJxaewkvaqkJGUuPoH4M1kkBHdn+4pQPtEyIdtQhclU5nlW7ZNsdM9zpfM9DCnHU+V/gJV5EUmoHCp8leX+e8x3vk8v2EARSVr64eJXKWjTqJJJELkIJISQEUh3DGK0lAoH8l/ho/q/4rr9ARdb3yQiQpMtasYxyvqBtB3lttiVJAVYSa0eNz+LOI6JonggpXHreWWhsrOQbhRFRCFEoUjfmcBURjhc+Cpnmv8GN2wjC42q+URKPvIIISU/SAPBNwklrWWUiNtJQh7UZZKQEQiC2OGD+u8TRDaqlOGx4q9T1GbRdgRKJ5a0mBNbv8Ns5lWK+r679kchBKVyll/++y/zy3//5ft51Q+FH753iVolz2OHJqhVHoxAVSdLVCdLPPXSw2fcukHAxfom31r4GFWSebo6wWQuWRDHMXQ8l/l2g6VOi2OVGpIQvL60wHgmT1bV8KOI15fm2ej3COOYsmnR9TyOlsc4Uq7wzSsXaLsOo6bFz8/uZ9S0OLmxyrurSzh+wHg2z75CiRcmpvnW/Md0fQ9DUfj5mX3sK4ygaHdx325XRo9vZD1vl6O4eb/k/9t/3hnwHKcp/EnQPziOx9p6m+/+4ByvffEo2czN89D9jNVhlPgTDE3BD0NcP0SVZZ49MMV3fnwRPwg5tnecMIqIogjb83n77FVGciaGrtLuuzS6NnPjZcZH8vzp22eYGi3QtV0uX68ThQ9XtEnsXiJ+gEdXCOphsfN6xeA/d9i+c1t8893c5wTrBgF2END3PEqmianev3gfJLE7UWoFSFII411E6ESajielpEFCFslAdq/OFUQR37l4CUkIiqbB89NTu3T2KK2RkmSE3ek6hBDpNSTnvx/NmCiO+f33P2A8l+VQZZS9I6W7HrNlt+kHLq7vU83l0tRFgS4bf2k0auK0gOmfn7/Idy5e5th4laemakwVcpQzJt84e46Tq6t0XJd/+guv3Rx8N3hnYpBeKVLLz/28z22EcUAQhQTxzQrXQkgYkvETiVgmWXnuoC9sIyFYCRH6JN9D0tciwtgdWMMEgsCT8F1wHJ+RsoWQk+KAcSqxtl13S0IZDNBh7GHbLr4X4rsSo6M5ZOV2YgKk5wvT9rbfjYySBi+HsUsY+2hSdnC/cRzjx/2UZMgIbijvBkHIn/zJu8zMlJmdHWVysrRj4ojxoi6KMJAljTiOeeONC1y4cI3FpTV++7d/DV1NJq6IMBU5TCYZKS2yCAJZqINnBElMUBA7IOP3XwAAIABJREFUQIwiDJICittjis/3Vv4nJKHy2sQ/JYp94vTZykJLSdKNZxNGLk1vkT+79o94pfrfU7OeJPsArsJHgTiO8fwwSYWWxa5E8lFjrdflg/UVfnBtnn947FnGrAxxDCc3Vjm9uYYd+BiKym8+9jSGIuMGIVfbTd5bvcb+Ypknx8b5X959g2dqkxR1g/lWndVel+dqk7wytYelTotLzTob/R5t12GuWB6I7OmKihcGeGFIP/AJooiCpqNIEj+4Ns9vHf8cc6U7ZxT3+y5b9R592yOb0ZFlicWlOocP1MhkEkG+jc02axsdgiBk/94xMul+cRxj2x6LS3VabQfTVNm/t4IfhGxsdAaEZ2qyxNp6m1zWwDRVTOPeJRzeOD3PWqMzKFLbtT1sz2d6tIAfRuQtnb21Ef7o9Y84PDXG4ekx4jhmebOFGwRIksTCap1ixiRn6XhByEtH9nB1rc6/ffsM/92vfYG8pQ8K7d6CO3agT5eFB+5NVO64XTyQhyqOY9wgZKnd5spWHT8MGc/nqGQyTBWTtFovCOh5PmvdLqOWRVbXMBSFrucRxTFhFLPe7ZI3DLKaRt5ImHLf8+l6LuvdHjldJ6frjFhJpH/f9+l5HpvdPrVcloymoSnJS+24Ln0/mQC7roulapQtCy8Mk4JvwIWNTcayGSxVxUjJWd8P6HkeWz2biUIOU9VQ0zbrvT4d16XneYzn81iqgq4m3aJpO7hh4vZqOy5Fw2DESsy9bcel53t0XI+u6+JaJuFdyHMUxzh+wKWNNg3bThQ2A5VaLkvRTO6953p0PJeW7TCRz2GqiYBWz0sG8r7n03ZdRiyTnK5jKApxHNNyXNquS8dxKVoGJdPEUlXiOE7+7rr0PJ/pQgFdkZGl5GPf6ifXEccxbcells9hKgpeGHJ5q85qp0MYR5QskxEzQ1630CWNp8Zn2Or6fOxspS6vG5Nly3FoOS5eGDKZz6MoMl4Y0nb6VLIZGn0bNwio5bLUbRtFkigY29lD6UQnkklQlxV0bqyu4kEmz+4deXvi3W4jneJv31GAJmsw2HqH9naeL97xu7hDu7ug33fp9zzq9S7ZnEE2a5DLGbhuwOLCOhvpQDw5NUK5nGNkJPHJN5s9ej0Hu9+mMpbHNFU0TSHwJBbn29TrXYIgYmp6hNFyjmIpsWT0eg79nkuz1SefN8lmDSzLpNWy8f0ASYoxDJf6Vpdc3qSQxgB0uw79vkenY1OrFdF1BSn9RtotG9v26HYd7L6H74dEqSBbr+fS67l0uw5jY3lkQx4YhvburdBs9Fmcb6akLbXYxIJeL6Dbdej1XPJ5k0LBwkjdQ7cWMt/WK0relIQkFOI4wo395I0MUo3vZBFOvsuWv8yme5GCNk1WrWJI96ck/ZOg1bb58ZlFXDcgCCMkSXD86DQjRQvfD7k4v86FK2vMTo5wZH+NUsGi03VY22xz+sIKX371KL2+y/pWh0arz+OHJijmP9k4uKymMVccIYgiTq6vMp0vkEsVgru+R89LvmdFktJFDKiSlISApm1IQqBLMoZyo9r9er/H6c11Nvs9wjhCl5OxoJbJMt9qcLGxyVSuwFxxBC8MObmxSkE3MBQVS1V5tjZJTr+7lX+r0eP9DxeolHOcvbBCp+NQLGZQVZlC3sSyNN557wrZrIGqynzn+2f5wiuHKOQN/CDiz79zmmxGxzQ1HNcjjEfZOR5s1bsEQcilK+u89Ln9KMr9hTXMjY8wXsoNmrq61mCt2eXgVAUhBLoik7N0fu7J/ZSyJiM5C0kSZAyNMIqIY9hodhkv55ks51MSHCMkwUQ5j6mpyA/h6vv0EZ6fItwgYK3T5ezaOpIQ+OkgN1nIE0UxDdthrdNlrdul73mUMxbThQKNvk3P97F9n3rfxuzblC2TrDZKTMxWv89yq03dthmxzGRSNQ38MGSz12O922Or38ePQkatDLV8FgGsdbqsdrpkdY2GbVO2LEo7iFLfT6TGbd+nks0wkc/jhyHr3S6bvT71lGhUMhkq2WSC2Or3We92absedhAwnssxWUgGwuVWm6ZjY2ka9X6fuFCgaJmEYcRKu0PDtnGCgI7n4Yd3D+iN4xgnCLhcr7Pe7SGLRGAwq2kUDIMwiljtdKjbNi3bwY8iJvI5MqrGZq+f1GnxPLquR8O22TdSQrMyxMRca7Zo2DY9z8cJA0xFxVASU+pyq03TdhKiGMN4PkdWT8qhXNmqExGjyTJb/T55Q0eTZZwgYLHZpON6GKpCJZuhaBpYamL5ODBa5qOV61yp3xCaDKMIP4y41mrRtB38MBEImy7k6Xk+C40meUNnqdWi6TjUclmut7uYqkJe14kJII7SFbyHLCxApCURVCAkJiSMHRSRId4ZYyZI1MQJ0zYC4jhEFtnUuhFzs3smJoy7SEIHZLazh7YJjkABwrTCuTtoJ44DIjxkrPS4CNi99lCSJRVT3+qxsdGm1epTGslCTEp4fFaWmywuboEAWZZRVYVSSlxazT6bmx16XQfH8amM5Rkby+O6PstLdVZWmggpiSXRdZVC0QJiNtY71Otdul0H10lWirqmsLzcIIqihBzIEltbXarVArIsYRhqeo023a4DMZRHc+TzBmEYsbrapNNJrqPfcwmDkDiGMIzYWE+P6zkEfsRYNU8+byJJgunpMstLDWRZuu25XF9p0m71sR0P1w0wDHVAeD5JRHFAEDk4YZNN9wJ19zIV4wiWPPLItXfiGNpdhx+dmB/cm6JI7J+tkM8aeH7A6nqLH757if4TM0zVipQKFq4fsFHvcuLUIk89Ps3GVpeFpS38IGT/nk/eIqVKMiOGxZ58iT+9dBY/CpnIJmOgAGRJQpUkGk6fnKYTRBFtz6UfJGOuHfgDETxZSCgpsW26DleadVZ7HcYy2fQbjalYGS7UN7nUrKPJMo+PjpFRk8VyGMX4UYhA5eho9Z4FMdsdh4uXVikVMywsbrG80uSF5/axcr1Ju22Tz5ssLtU5uL+KriucPrfMscenUGSB54d8dOoaTz4xTalo4XpBamFLaJwfRKystmi2+jRbfWRZQpHvj2RMlG8uBu4HEWEcs7c2klj10zHjuYPTN+1XzCTzWRhFjF7LMFUusHd8BAGsNjroiszByVFUWbqv6ui3Ykh47gI3DLFTIlEyDQxFQVeSR7bR7/H21Wu8e22Jv37kMN88fxFdUfitF57j1Ooap1bXWGq1+VvHn+DfnTtP3jD4xy99jhh4Y+EqP7q6yG8cP0bX89BtBUqw0Gjy5sIiV+oNvnxwjj/66DRThTy/+cxTmKrCty9e4vtX5vmlwwcHlqHtjnNlq07P9/mlwwf5gxMfcrRa4e8+fZzFRpPvX55ns9fji3N7+YMTH/BErcavPfEYkoCNbo/1bp+iafC/v/UuX9i3h9989ikA/s2p01zaqvPagTnyuo6fSybxpVaLPzt3HtsP+OLcXk6urJLVNI5P3Lm2VkxCIPuejx8GmLqOqaookkQQRax3e/y/p88mft7JSf6Pt9/lq0cPc2y8ygcrK7wxf5VaLssLs9P8n2+/y99+6klenJ0mimO+/uFJSpbJK3tm2Oz1Gc/lcIKAhXqDPzl5mkomw8GxUf75D9/iN58+zlOTE2iKzP/29juMWCZPTYyT15NSFjEQhFHiFpAkdFnBVNR7flw9z2ex2eTrH5ziQKVMNZvhn73+Jv/Nyy/S8zy+ceYceUPnz85eYL7e4KXZGd5YWKCatdg7ksMLVxFIRLFDzztDTn8WkIniHroyTRA18cMtbP9jCsaLyFIuTVNO3CERDn64iUDFC1fxgjWK5qtEsUNMnGqFJHaZKHJpOm9iqQdR5AIQITCIYpsodtGVKfxoCz9YxwmuUjQ/TxyHhFGbrneSnP48spQhinuo0hh3shD1+x5vvnmRK5fX+YWvHKPbcTBNjTgGzwuSjBovIJsz0HVlYHUMgpCtepd6PbHCfO1rb/Lcc/v45V95Fs8NsG85TlGS1bZte/yH756m23H4wpeO0Gr1yRdMDEPl33/zQ/bNVel1Hd566yIvvHCAra0uy8t1pqbLfP97Z5GE4Ilj03ztX7/FF754mKef2Uuj0ePb3zqFqsocOz7D2bMrjFUL7N0XsbnZ5S/+4iSmoXLk6CT/+l+9wV/9ypM8/fQeTHP3iSqKYvp9l2/82xOUR7M89fQeGvUe1Wph1/1/UthBnRX7A368+XtIQqGgTfPS2D+5ScPoUaJve5y9tMr/+F9/hanxEuYOUpexNL7yc48zf22LculGrFG5mCGYLnPsyCTf/A+n2djqEMUxv/1f/SKK8snHmK1021xu1jm5sYqd1nTadg0eKY9hKSo5TePr50/yTHUCS1H59sIlrrQatFyHaEcc5U5s6x2vdNvJOK8oSELCCQK6vkvTtanbfS41tpjKFXhtdo7fPXUCRUhUzAyHRkaZyd29X8RxTBzBc0/vxbZ9FFniycenOH9xleXrTRaX6rz68kGmJ0eQJMH11Rar6y0azR4x8NiRCZ45PsuemRtus27XIYpilpbrXFuqs3d2lP/yP/vCT/SMZ6tFxkdy901SJCF44fAMpq4O4kJVWWJ6rMhje2oPRXbgERKeIEqKgnUDl7xqJAXCohBTVvGiIKn6Gvj0Q4+iZlHUTHq+i5Yq7HpRQF416YceThhQ0kz6gUccJ2UGnChATplix3Mo6YmZ0wmDtA6JixeFabseiiQNCpndL0qmQTW1lFSyFocqo9RyibXl9PU15usNWrbDO4vXWGm1KRgG8/UmQRQxXSgwUyxwrFbj8mYdP4rY6vUZz+fJaUkhtw9XVnluepKJfI4ojvlg5TpF0+CvHJjj+MQ4K+0OURRzbn2DJydqGKrKeC7HLx05lFhIFGWwbp8rj2CpKscnxjm7tkFW05iv1/nx8nUm8jmeHK/xxHiVhXoTQ1W4sLHJ47UxZFnCjxIXTttx0iJtif3AUjVmikV+8fBBZCFhqgpRFHFqdZU9pRJly+T4RNJuNXv34GZZCMoZi/FcFktVKVkGR6sVMpqGGwS8f22ZzV6PKE7YfaNvc73doZxasI5P1JgpFnmiVuVgZXTgVqvmsuQNnZ7ncWZtnS/u20te1+i6Hu9dW+a56SmmC3lq+RwX1zdpux4LjSaHKmVyus5j1bHB/WX0JCOiZJnsK48MXJOPVcew1LuTnoZt8+PlFV7dt4d9IyUymsblrQbrvR4tx0GWJT7e3KJoGhyslHn/2jKWomAqTZr2D9CVCTS5iiS2V90SYdTFCa7Q9y+hymUEEmHs0Hbex1D3YKmHAOi6pwmiBppcxVBmCKM2ER51+3tpDIqMEAqqVCCMbIK4TRDV6XgnEKhIQqdgvEgQNXGDJfr+RTR5jCj2CGOHlvMjLHU/qlQGBC3nDcKoRxC1qeX+HrKURdpFuM4wtDReQHDu3ApPPT3L6GgWIaBYzDBayeH7AYVihv37q+TyJkKAIksokoTvRSxe3aLbcfG8REm5WMpQqSQZW8Wixf79NTJZHUlKzpfNGrRaNufOrfD85+YoFpNxIQxjDh6q4Xsh8/MbHD46Qb/nUt/q0aj32T83RmUsz+zsKPNXNgjDiEsfr7Kx0WHf3BiVSp4DB2scOlyjWLRwHJ/Ll9ZoNno0hcAPQtpth/W1FmurLfbsrezaTyRJYJo62ZxBr+fy8cdrfO6FOTKZe8dFbCOKk3ICqsjw8tg/uaub31BKTGdeYESbSwQ2hYaplH5qqehjozn+7i8/z3d/eB4EFHImX33tGKapJdaCXYiCEIKRQoZXP3eA//mff5PJaoHnn5hBkR9NRb3xTI6ibnBoZJQwisioGpqiIEjGou1SC1O5ApaqIQnBRDaPGwboskJG1Xh8tEpWS8aPPfkibhggS4m156nqOJqsIKd6TN9e+JgRw+J/eP4LjJoW3164RD8IeKJS4z9/Iik7IwuJjKpiqffXLyQp+RGpPzQmRpIEiqLgOD5hGAESjuOjKjK6phJGMbbjE4ThLmKCkMsaaJqCoSucOrvMof01dP3hKIOhKmipseB+Y7RylnGTNaiQMW9KzHkYPDLCU/f6dNOKrhtOl37gYQceBS31R4tkvbldoXXd6VB3++RUfZCGl1VsQBARseF0aXl9BIKcmqzGy3oGU1FZczo0PBsvSpjzZKaYrGTjmHWnS9PtM6Jb7M9Xkuq096nqqMoymqwMLDuWpmKmsSG2H6DJMuP5HLOlIllNI6NpZDQVIcBUk/1zuoalqdi+jx8mH89MscjTkxMIAUvNNnEMoxkL2/cxVZWCoZPVNEw1Oc5N0x0VSWAqCqOWdSOQMnWz6bJCVk+OMxQlccGFEX3Pp2xZ5NM2DTUJALUDn6VWm66bkMGZUjHxiwppEPKvyBKWqlLJ3CAztu9j+wGWqpI3EiuTpaoo96h1JYRAk2V0RcFQQgwlcWepsozt+/R8j6JpYqoKM8UiuiwzWyoOgsQLhkHRNMhpyfPcvndZCJ6oVWk5LpIQnFvfwFQT/27f98loKnnDIKclMT9RHA3cb5osk9N1RjM3kzVVkjDVxC2myTJZXbvnRxZGEX3fJ6dryTPRkuODKIQ4JqNprLQ75NN4rdOra+nzEwRREyXKEYocCEEQdYhimzBu44XrCKEiCZXt4rNh3CWK+0DIthUoiFrIwkqP6xNGndQdJqWkRyOM2sRxmBIZmzjqpjEhRkKEwmZ6Pg1ZmAN3WBh1CKMeksgQRG2i2COOXbZjhHaP50mCUKdnyoMg4uWlBgLByEgWVZVRNRlNV9F1BdPS0LSEUK+utuj1XGRFYmKiiGGoiY5HHKOkqca6rqBpN46LY5Blwd65CpmsDgKuLmwiS4LyaI6YmIylE+oRhqGSzei4TkAQhARBRLWWT+J9Mjq6ruywQnlkMgbZrE42q2PoKrIsEUUxtu1TKFiYpkZtvICmKoyPl9CNuw2rAlmGw0fG6XZdhBBcvrSGaWpY1u4LsiCKCMMILwwxVYWu69NzPUYyJoaYQAhBGEUEYZRMsqnbIQgjgkjghwYZec+NHI9YSt3zMbIkcPwARU7cMX4YIktSUtU6DDFUdWDx2LZu3y+EAMtUOXqghu361Js9uj2XxZU6MxMjd0139oOQerNPIWciyxLdvksYRfftUnkQ6GncTVbT0yy93QOnMzuypbK3EJGCfuNeMju2xXFMXjcGi/M4TUOXhSCIQtqei6Wq5FQdXVaYyhVSQhvf8Tp2x3bM3vaJwbI0RooZrq82029Hptd3yWUNcjmTIAixHY/Fa3U8N4nV3Ds7SpQWtTJNjZmp5D1durJOdSxPMW+iP6AyNYAkPVj+Z+J6vvne1fuMH7obHhnhudZrsG53kAVc7TVpuH36gUvVzJNVdXKqwZiRJY5hsdtmxW6x5nQoaxmyqk5W1ZGEoGrkyKo6725cZdPtJeY+I4ulaDxeHKcm5bnWa7LhdGn7Ni3P5kixxpRVRJMVTmwusuF0OVyoMp0podzDJ3orhEisE0EYpgNIMskaqsJEPseeUpEvH9w/SMlWJImLm1tEUXwbCUiTAHmsNsaB0REWGi3+4MQHVDIWT0+OY2kJmep5Pn4U4fg+YRRhKsqA2d7pg/fCENsPCKIINwxQU3KR0dXBZJy0GWCoCqok8cHKdXqeR9E0+NLcXr594WP0HZ1KlgTKrRGUgKGoBFGEHQRJymEQ3lZV907YJg5+GA4IoCQElqpysDLKVD7P01MTyfmFoOt6XNjYRJaSwnS3Iga+fHA/TdvhWqvNP3v9TUqmyaHKKBlNxQkSt6QXhkmMkyQN7lGRHmy1sF1kL4wSf3QyKSSDsCxJZDSNvh/gBAGKJGH7PqokkzN0Ri2Ly/U6L85MM5bN8jvvnuBXHj/KaCZGiC2CqI1IFXr9MPl3ELbwwwaGOkUUuwg8JJEEGycxN35KZpJ06MTttZn+NNDkClHsgYgR6LjBCpKwUKQsQeQPnl8cB4RxlyBqEUQtdGWKMO6TSBYk54tiBz/cwA+30OQqslxBFhkkyRykSN/+ZuCxxybZv7/K9etN/p8/fJu5/VUOH5kY9AUhEt2PIEgm9SiKOXNmmV7PIZc3eeHFA/zwjYs3yf9LaUB2EEQEQUgYyoNskGee2Uu/77G22uL3/+XreN4hXn4lsQgJkayAd6pZIASmpeL7IY7jEwSJBklBJK4wXVdTXZIA3w/xvIAoSoJvDUNl774K4+Mljj42CcTIcrKgiqM46SfpPQVBhKIkMUTE8MrnD9Nu21xfafB7v/sDSiNZxsZ2DyL2g5C+59HoO1RyGZabLVYabZ6YrCZyCLJMRtfoOi6WppGVkzHOCwN6rk/LdsjpaZC6gKyh03OTStyWprDe7pI1kgVBy3HI6hpeENJxXMbyWbwgyebTMnL6yO7vm4njGFWRqVby/OKXHuPy1U3OXFzh1IUVCjmTjKUThGGavp8QtjCMEJJgs9HjjXc+5tljMywu1zl9foUvf/4oGUu778DZB8H2OPRJIykxcnO7T1UmON/Y4IfLV1EkieOVCWbyNwrLSkLcdxaxJASqmihyy7JAUZJvQZYlSiWLIwcn+N3/+3UWFrdQVRnH9amM5qmM5nDdAM8N+OjUNU4KiGL4jV99brDAKORNnjo2g6Yp/OGfvMP+fWOJdeghCM9fFjwywlMxMjihz8mtZcpGhpqRQ00DQvOqTl4zqBg5PqovEwMTVoH9+UoSDS8kcpqekiQPNwwYM3LMZkewQ581u0PkuzQ8G0kIFrtbjBpZKkYGXVZww4CO7yAH0uC4qUwRc5ciZvfCiGUyO1Lkd945wXvXljkyVuFXn3iMl/fM8PqVBb576TKnV9fww4iZUoHfOH5sVzPtNta6XX68fJ1T11cxVBVVkqhkkkyf1w7s57sfX+ZPz57nzYWrdFyXw9Uxnhiv7TrZ78RSq0W9b3NhfYO1Xo9nJic4MFpmLJvh3527wJtXF/nB5XnarsszU5M8MV4jjuG7H1/mvcVlLm3WWet2B4HZd4IuK7y6d5bfP/EBP1xY5L1ry1zeqlPJ3F/mxJ5SkQ/t6/zxR2c4s7rOl+b2cWyixmsH5vgX77zPiaVlvn/5Cm4Q8guHDrB/9M4pmX4Ycr3d5v87c46O66FKEpP5HBlNpWga/OKRQ/yLH73HmwtXyWoaTcfh8/v2sK88csc27wY3CNjs9/nz8x9zYmmFpVaL/+ud9/grB+YYy2b5qwf387+++Q5vLlzFUBTajsNfO3qYjKZhyCpn1tbJ6TrljMW59Q2q2QyzpVl05QiDAGAEGe0IAoWYmIL5IknA8fZ7SQhvoveS/J7TjhNr2+neCoa6j6L5KulyPv2RSTSotmf7kLbzYwDyxjMIVEx1jhJfusP5EpJhaQfZGbOzbXXaDRvrbU68P8/CwmZixTHVgYsJYKxaoNd1+bNvfMCF8ysce3KGZ57dS7Wa5803Vzn50SKLVzfZ2kwyubZRGy/S7Tr8+29+yIXzKzz9zB6ePD7L5kaHN394kbX1FpqqUCxa5HJ3D8w1TZVXPn+Ib/zpj3n//XlyOYNux2HfXJUjRyeZmR3lD7/2Fh9+sMD778+zvNxgZnYUy9J4+ZWDfP1rb3Hm9BJvv30Rzw344s8d5cCBGu1Wn7fe/JizZ1e4urjJH//Rj3j2uX1MTpbwXJ9v/cUpbNtDliWq1cJNsS23QgiwvYCLq5ucXlrFDUK8IGSx3iSjaZQyFrPlIt86dZHn9k3x0v7ZwTvrux4XVzfpex6tfhJv8uqhvbxxYYEgipgsFWjbTrpwCVhv9/iNF55EAOdXNzlxdRlVlsmbOk/PTJIz9dsm8DvBdnwWrm3x9W+8h6Gr+EHilvw7f+M5dF3h0tV1vvvGeT48u8THVze4OL/OsSNTjJVztDo219db/OovPU2rbTO/uMnv/fFb/OpXnmJm8uG+378s2FcssadQJIoT7SBZergAXIBDB2rs21tB1xS+8MohPv/SQRRZYmaqnEidyBL/+L/4ecIwGlh5tDQLV9dlfusffpEg2LFNS7YV8hZ/72+NJG5EAf/tP3oNVdk9QeHThEemw9P1XbqBy4bdxVIS36aUml41WUaVFExZZcPpEhEjIVBSU6pE4k5yw6TIZ1KYMSk/X3d7XGivcaRQY1TPoisKK/0mpqyhSDKySPbdNu5FcYwsJLKqRklLBtsHeWmOH9BxXU5eXyWjqYxYFgdGEx2FlXaHxWZzoIlSMHQOVUZZbrUJ4xhVlpjM55mvNwiiiLFsFkUSrHV7bPQSRck4jimZJgdGy/hRxLVmi7VOFzldsZYti7l00r+0uUXDtnluanJwD1Ecs9ho0nQcbD9AlsTgXHMjJfwoYr7eYKvfH5CmajbLTKnIVq/P1UaTrueRN3Qats1UIc+B0VEEcGZtnSCKbgpGjuMYPww5t75B2/Uw0zT8ai7LRD5Hfkcg9W7oOC4bvR5X6g2KpsFMsUAlkyGMY86srtP1vFSbB2ZLRUqmwUo70XPIaTpF0+Ds2gYlyySna8hCcGmrjhsEA5PxXLnMiGUSRBGnrq/hhcFgQDkwWqZkWRDHvHNtibFM5jYCFMcxXc9jq9en43o8XhtDiOS5On6ScbXV69PzfCYLeWaKhYGb7cOV1VT4K2nraHUMVZJpOQ6X63X2lEpkNY3vXbrCK3tnKZlGap2IB319N2zr5dx9+25t3PkT9oJ1ALSBFsuN4+51vltErW7fmmp8rK0mGVpS6pIaGckynQZI9vse7Vafy5fWyOVNKpUc1VqRZqPH8nKDfmp+b7VsqrUCe/ZWksm/79Fs9pm/skE+bzBWLTBWzWPbHstLDXo9d3C+aq3AyEiWM2eWmJurEscx8/MbzMyUcRwf3wuZmCxy+fI6/b43+O4mJkqUR3MEQcjFC9dxXB9dU+j1PGq1AuXRHJalcfHCdWzbG1h4p6bLFEsWnhtw/XqTZrNPq9VnfLzIWLVAJqOkaG1/AAADYUlEQVQThRELC5v4ftJnozhmz55RisXd4+AaPZvlZpv35pfI6hpuakXM6ho5U0eVZKI45vTyKi/tnx0Qnq1un6VGiw+urjCSsei5Hm4QMF7IcXEtsZpOlvJ0HG/wBqM45vl9U3Qdj1NLq+iKTAzkTJ3PH9hLztDuOx04CELaXYeLV9YHui9CCA7NVVEVGdf1WbzeYKveRVFkLFOlXMximiqeH7K20ebYkUk8P6TdsVnb7LB/tvJQyr//sSOKkvFB2uXdbUssbMsmfMo5DdxFgOaRCg9uuwC2z779+06Rr7ttBwb6MlK6fdPpcqG1xvOVPWjSzYxzZ3vbw//2ccBDs+g4TszTNzQvbk4zdYMQJU2Tu59zbEf1B2GIJsu3dcJtUqHI8gO7XIIoQpFuj1PaPp8q3/zMgihh97Ik3fbs7+c+wjuc736Og8RttfP+wyjCj6L03d77eraVprd/NPn2VUgYRYRRdNu9PypsP9MHfS6fRURRTJS6dlRVGbiethHHMWGQ9AVJEkipy3Z7RSpLUir9c8txUZwGYt5+3PY5Ne3BFLy3r1PZZSW73ea2y2onwjAiDCIU9QH6bHTjR9Pu3i+3un2utzp8dO06lWwGJyU8Y7kMWUMjCGM2O4mUxfHpcZ6cThYoG50ey802Z5fXmC2X8MIQ1/cJw5iGnVjHc4ZO1/HI6BoZXSNraIzlMom1+PpGsnCII0xN5YV9Mxiq8lD6J0MM8VPEz4bwwM0y17tLXt+Qh7+f7TtxJ/2Pnfve+vtPch93Ou/dtj1oWzv3eZjrvdtxd3u+d7uWhz3fvY670zkf9H09yuf5MPgk+ttnBff7bm7d51Eed6/rfZg+9Cj67G77Dv7G7qP6rQvA3dtLVvHLzTbvzy9h+wFHxsfYVxkho9+ejbjdyoMuiIYY4meEnx3hGWKIIYYY4pPDrWRp5xB+Lz6yc18/TIKh4xh0VUFXbliUdyNOQ7IzxKcEQ8IzxBBDDDHEEEN85nFHwjN0xg4xxBBDDDHEEJ953CstfWjDHGKIIYYYYoghPvUYWniGGGKIIYYYYojPPIaEZ4ghhhhiiCGG+MxjSHiGGGKIIYYYYojPPIaEZ4ghhhhiiCGG+MxjSHiGGGKIIYYYYojPPIaEZ4ghhhhiiCGG+Mzj/weSFtwoqZu2BAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From 168f41e943873fff688382bb12a4750ecaee4259 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Sun, 7 Jun 2020 20:46:51 +0530 Subject: [PATCH 11/17] add nn from scratch --- NN_From_Scratch/README.md | 10 ++ .../NN_From_Scratch_Python.ipynb | 121 ++++++++++++++++++ 2 files changed, 131 insertions(+) create mode 100644 NN_From_Scratch/README.md create mode 100644 NN_From_Scratch/original_code/NN_From_Scratch_Python.ipynb diff --git a/NN_From_Scratch/README.md b/NN_From_Scratch/README.md new file mode 100644 index 0000000..b75be7d --- /dev/null +++ b/NN_From_Scratch/README.md @@ -0,0 +1,10 @@ +Understanding and coding Neural Networks From Scratch in Python and R +=============================================================================== + +This repository contains code for the article ["Understanding and coding Neural Networks From Scratch in Python and R"](https://www.analyticsvidhya.com/blog/2017/05/neural-network-from-scratch-in-python-and-r) article published on Analytics Vidhya + +Structure: +--------- + +- original_code/ + - NN_From_Scratch_Python.ipynb diff --git a/NN_From_Scratch/original_code/NN_From_Scratch_Python.ipynb b/NN_From_Scratch/original_code/NN_From_Scratch_Python.ipynb new file mode 100644 index 0000000..dd1c01e --- /dev/null +++ b/NN_From_Scratch/original_code/NN_From_Scratch_Python.ipynb @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Input:\n", + "[[1 0 1 0]\n", + " [1 0 1 1]\n", + " [0 1 0 1]]\n", + "\n", + " Actual Output:\n", + "[[1]\n", + " [1]\n", + " [0]]\n", + "\n", + " Output from the model:\n", + "[[0.97746871]\n", + " [0.9661872 ]\n", + " [0.04903716]]\n" + ] + } + ], + "source": [ + "# importing the library\n", + "import numpy as np\n", + "\n", + "# creating the input array\n", + "X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])\n", + "print ('\\n Input:')\n", + "print(X)\n", + "\n", + "# creating the output array\n", + "y=np.array([[1],[1],[0]])\n", + "print ('\\n Actual Output:')\n", + "print(y)\n", + "\n", + "# defining the Sigmoid Function\n", + "def sigmoid (x):\n", + " return 1/(1 + np.exp(-x))\n", + "\n", + "# derivative of Sigmoid Function\n", + "def derivatives_sigmoid(x):\n", + " return x * (1 - x)\n", + "\n", + "# initializing the variables\n", + "epoch=5000 # number of training iterations\n", + "lr=0.1 # learning rate\n", + "inputlayer_neurons = X.shape[1] # number of features in data set\n", + "hiddenlayer_neurons = 3 # number of hidden layers neurons\n", + "output_neurons = 1 # number of neurons at output layer\n", + "\n", + "# initializing weight and bias\n", + "wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))\n", + "bh=np.random.uniform(size=(1,hiddenlayer_neurons))\n", + "wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))\n", + "bout=np.random.uniform(size=(1,output_neurons))\n", + "\n", + "# training the model\n", + "for i in range(epoch):\n", + "\n", + " #Forward Propogation\n", + " hidden_layer_input1=np.dot(X,wh)\n", + " hidden_layer_input=hidden_layer_input1 + bh\n", + " hiddenlayer_activations = sigmoid(hidden_layer_input)\n", + " output_layer_input1=np.dot(hiddenlayer_activations,wout)\n", + " output_layer_input= output_layer_input1+ bout\n", + " output = sigmoid(output_layer_input)\n", + "\n", + " #Backpropagation\n", + " E = y-output\n", + " slope_output_layer = derivatives_sigmoid(output)\n", + " slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)\n", + " d_output = E * slope_output_layer\n", + " Error_at_hidden_layer = d_output.dot(wout.T)\n", + " d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer\n", + " wout += hiddenlayer_activations.T.dot(d_output) *lr\n", + " bout += np.sum(d_output, axis=0,keepdims=True) *lr\n", + " wh += X.T.dot(d_hiddenlayer) *lr\n", + " bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr\n", + "\n", + "print ('\\n Output from the model:')\n", + "print (output)" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 595fea98acb7fabf37750169f0dcd7548054cfd7 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Fri, 17 Jul 2020 17:36:33 +0530 Subject: [PATCH 12/17] improve nn from scratch --- .../improvements/NN_From_Scratch_Python.ipynb | 2076 +++++++++++++++++ NN_From_Scratch/improvements/images/error.png | Bin 0 -> 20214 bytes .../improvements/images/error_wrt_who.png | Bin 0 -> 38181 bytes .../images/error_wrt_who_matrix.png | Bin 0 -> 7255 bytes .../improvements/images/error_wrt_wih.png | Bin 0 -> 43534 bytes .../images/error_wrt_wih_matrix.png | Bin 0 -> 11060 bytes .../gradient_descent_update_equation.png | Bin 0 -> 3851 bytes .../images/hidden_layer_activations.png | Bin 0 -> 9206 bytes .../images/model_architecture.png | Bin 0 -> 33580 bytes .../improvements/images/output.png | Bin 0 -> 17581 bytes 10 files changed, 2076 insertions(+) create mode 100644 NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb create mode 100644 NN_From_Scratch/improvements/images/error.png create mode 100644 NN_From_Scratch/improvements/images/error_wrt_who.png create mode 100644 NN_From_Scratch/improvements/images/error_wrt_who_matrix.png create mode 100644 NN_From_Scratch/improvements/images/error_wrt_wih.png create mode 100644 NN_From_Scratch/improvements/images/error_wrt_wih_matrix.png create mode 100644 NN_From_Scratch/improvements/images/gradient_descent_update_equation.png create mode 100644 NN_From_Scratch/improvements/images/hidden_layer_activations.png create mode 100644 NN_From_Scratch/improvements/images/model_architecture.png create mode 100644 NN_From_Scratch/improvements/images/output.png diff --git a/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb b/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb new file mode 100644 index 0000000..d6382dd --- /dev/null +++ b/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb @@ -0,0 +1,2076 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cEG1dhnuNFRk" + }, + "source": [ + "## Steps to build a Neural Network in NumPy\n", + "\n", + "---\n", + "\n", + "#### 1. Load the dataset \n", + "#### 2. Define architecture of the model \n", + "#### 3. Initialize the parameters\n", + "#### 4. Implement forward propagation\n", + "#### 5. Implement backward propagation\n", + "#### 6. Train the model for multiple epochs \n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sbgj7HfHNFRr" + }, + "source": [ + "### 1. Load the dataset " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "E5S9HgBzNFRw" + }, + "outputs": [], + "source": [ + "# importing required libraries\n", + "%matplotlib inline\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1657, + "status": "ok", + "timestamp": 1585485745721, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "ogs6CaXu2zeZ", + "outputId": "f5055dbe-331b-461c-a1a1-13d28149d528" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Version of numpy: 1.18.1\n" + ] + } + ], + "source": [ + "# version of numpy library\n", + "print(\"Version of numpy:\", np.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1788, + "status": "ok", + "timestamp": 1585485751574, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "vNmvxGv723N6", + "outputId": "340278d2-64d4-43b2-fd9e-02585dc66d21" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Version of matplotlib: 3.1.3\n" + ] + } + ], + "source": [ + "# version of matplotlib library\n", + "import matplotlib\n", + "\n", + "print(\"Version of matplotlib:\", matplotlib.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set random seed\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 139 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1409, + "status": "ok", + "timestamp": 1585485752142, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "H_h7HoPONFR_", + "outputId": "552026b7-f129-41e9-c8f4-22a4c9d80e6e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input:\n", + " [[1 0 0 0]\n", + " [1 0 1 1]\n", + " [0 1 0 1]]\n", + "\n", + "Shape of Input: (3, 4)\n" + ] + } + ], + "source": [ + "# creating the input array\n", + "X = np.array([[1, 0, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1]])\n", + "\n", + "print(\"Input:\\n\", X)\n", + "\n", + "# shape of input array\n", + "print(\"\\nShape of Input:\", X.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 156 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 3240, + "status": "ok", + "timestamp": 1585485756254, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "LVvQz5g39wo3", + "outputId": "e0f22a43-1caa-4ca0-bfdd-0168c8853d6b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input in matrix form:\n", + " [[1 1 0]\n", + " [0 0 1]\n", + " [0 1 0]\n", + " [0 1 1]]\n", + "\n", + "Shape of Input Matrix: (4, 3)\n" + ] + } + ], + "source": [ + "# converting the input in matrix form\n", + "X = X.T\n", + "print(\"Input in matrix form:\\n\", X)\n", + "\n", + "# shape of input matrix\n", + "print(\"\\nShape of Input Matrix:\", X.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 191 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 3079, + "status": "ok", + "timestamp": 1585485756256, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "IRe8JE0xNFSL", + "outputId": "bd0f8cc4-140c-4788-fe12-0967af4b0f0f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual Output:\n", + " [[1]\n", + " [1]\n", + " [0]]\n", + "\n", + "Output in matrix form:\n", + " [[1 1 0]]\n", + "\n", + "Shape of Output: (1, 3)\n" + ] + } + ], + "source": [ + "# creating the output array\n", + "y = np.array([[1], [1], [0]])\n", + "\n", + "print(\"Actual Output:\\n\", y)\n", + "\n", + "# output in matrix form\n", + "y = y.T\n", + "\n", + "print(\"\\nOutput in matrix form:\\n\", y)\n", + "\n", + "# shape of input array\n", + "print(\"\\nShape of Output:\", y.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tKf4Ji1-NFSV" + }, + "source": [ + "## 2. Define architecture of the model " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "vlhBW0NNNFSg" + }, + "outputs": [], + "source": [ + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "OoOsLucmNFSo" + }, + "source": [ + "![alt text](images/model_architecture.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_Nmwj8RfNFSr" + }, + "source": [ + "## 3. Initialize the parameters\n", + "\n", + "NOTE: For simplicity, we are assuming that the bias for all the layers is 0" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "1T1IG-W8NFSu" + }, + "outputs": [], + "source": [ + "# initializing weight\n", + "# Shape of weights_input_hidden should number of neurons at input layer * number of neurons at hidden layer\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "\n", + "# Shape of weights_hidden_output should number of neurons at hidden layer * number of neurons at output layer\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1009, + "status": "ok", + "timestamp": 1585485756260, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "Fpa1--9KNFS1", + "outputId": "407ba6ee-ddc9-4830-d771-15704f6e39e6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((4, 3), (3, 1))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# shape of weight matrix\n", + "weights_input_hidden.shape, weights_hidden_output.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "srrDW1MNNFS-" + }, + "source": [ + "## 4. Implement forward propagation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "sOcBji4iNFTE" + }, + "outputs": [], + "source": [ + "# We are using sigmoid as an activation function so defining the sigmoid function here\n", + "\n", + "# defining the Sigmoid Function\n", + "def sigmoid(x):\n", + " return 1 / (1 + np.exp(-x))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "-g-SocwQNFTC" + }, + "source": [ + "![alt text](images/hidden_layer_activations.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "DO6AYHtGNFTM" + }, + "outputs": [], + "source": [ + "# hidden layer activations\n", + "\n", + "hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "o8zzYX6pNFTT" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1ETMoLD1fwi5u1HHLqtAdVUs-P8HNOU_p)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "CuqKwiToNFTW" + }, + "outputs": [], + "source": [ + "# calculating the output\n", + "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", + "output = sigmoid(outputLayer_linearTransform)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2132, + "status": "ok", + "timestamp": 1585485759226, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "BjPlMkVMNFTd", + "outputId": "98153d29-d232-4e9f-da3f-f834a5ad8ad9" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.68334694, 0.72697078, 0.71257368]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# output\n", + "output" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "mdFKMYyzNFTm" + }, + "source": [ + "## 5. Implement backward propagation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "c2m3XBgZNFTn" + }, + "source": [ + "![alt text](images/error.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "IvUAAhlcNFTp" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.05013458, 0.03727248, 0.25388062]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# calculating error\n", + "error = np.square(y - output) / 2\n", + "error" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "3H0vjBdNNFTw" + }, + "source": [ + "### Rate of change of error w.r.t weight between hidden and output layer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "4cncCd1WNFTz" + }, + "source": [ + "![alt text](images/error_wrt_who.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "DqrhlDeDNFT1" + }, + "source": [ + "**a. Rate of change of error w.r.t output**\n", + "\n", + "**b. Rate of change of output w.r.t Z2**\n", + "\n", + "**c. Rate of change of Z2 w.r.t weights between hidden and output layer**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "bKdk5m4FNFT3" + }, + "outputs": [], + "source": [ + "# rate of change of error w.r.t. output\n", + "error_wrt_output = -(y - output)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Bl1PDwrBNFT9" + }, + "outputs": [], + "source": [ + "# rate of change of output w.r.t. Z2\n", + "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "3vLk1nxLNFUD" + }, + "outputs": [], + "source": [ + "# rate of change of Z2 w.r.t. weights between hidden and output layer\n", + "outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1953, + "status": "ok", + "timestamp": 1585485762993, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "UXXifY9QNFUI", + "outputId": "869382cd-4440-47f1-c249-db25f9073338" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((1, 3), (1, 3), (3, 3))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# checking the shapes of partial derivatives\n", + "error_wrt_output.shape, output_wrt_outputLayer_LinearTransform.shape, outputLayer_LinearTransform_wrt_weights_hidden_output.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1725, + "status": "ok", + "timestamp": 1585485762995, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "ZvtS7wCRNFUN", + "outputId": "377481a7-6b8f-4d0c-abe2-82060ce48ab0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 1)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# shape of weights of output layer\n", + "weights_hidden_output.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gC9zQEH6HON5" + }, + "source": [ + "![alt text](images/error_wrt_who_matrix.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "l3HNVYGONFUr" + }, + "outputs": [], + "source": [ + "# rate of change of error w.r.t weight between hidden and output layer\n", + "error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1805, + "status": "ok", + "timestamp": 1585485763842, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "cwyI1EGZNFUw", + "outputId": "93df5cbf-3413-4acb-cdaa-394a9ce50a37" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 1)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "error_wrt_weights_hidden_output.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sDFPg2SHNFU2" + }, + "source": [ + "### Rate of change of error w.r.t weight between input and hidden layer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_757MrjBNFU2" + }, + "source": [ + "![alt text](images/error_wrt_wih.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_nPYGXkeNFU4" + }, + "source": [ + "**a. Rate of change of error w.r.t output**\n", + "\n", + "**b. Rate of change of output w.r.t Z2**\n", + "\n", + "**c. Rate of change of Z2 w.r.t hidden layer activations**\n", + "\n", + "**d. Rate of change of hidden layer activations w.r.t Z1**\n", + "\n", + "**e. Rate of change of Z1 w.r.t weights between input and hidden layer**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Sb7Ezxw9NFU6" + }, + "outputs": [], + "source": [ + "# rate of change of error w.r.t. output\n", + "error_wrt_output = -(y - output)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "3-SGbNaoNFVA" + }, + "outputs": [], + "source": [ + "# rate of change of output w.r.t. Z2\n", + "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "amuoR7h6NFVF" + }, + "outputs": [], + "source": [ + "# rate of change of Z2 w.r.t. hidden layer activations\n", + "outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "YDUZEdWKNFVJ" + }, + "outputs": [], + "source": [ + "# rate of change of hidden layer activations w.r.t. Z1\n", + "hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Ft4U6Td6NFVO" + }, + "outputs": [], + "source": [ + "# rate of change of Z1 w.r.t. weights between input and hidden layer\n", + "hiddenLayer_linearTransform_wrt_weights_input_hidden = X" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1069, + "status": "ok", + "timestamp": 1585485765410, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "A-hsfsi4NFVR", + "outputId": "2d5a0542-4563-4989-90be-382eba30a03a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 3) (1, 3) (3, 1) (3, 3) (4, 3)\n" + ] + } + ], + "source": [ + "# checking the shapes of partial derivatives\n", + "print(\n", + " error_wrt_output.shape,\n", + " output_wrt_outputLayer_LinearTransform.shape,\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations.shape,\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform.shape,\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden.shape,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1503, + "status": "ok", + "timestamp": 1585485766077, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "1uka_yPrNFVV", + "outputId": "238e6afd-f960-4eb3-c02c-b95a31932b5a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 3)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# shape of weights of hidden layer\n", + "weights_input_hidden.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gCeSm7vrHbHj" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1RkG5x1NEFWlF3tj0OlswOWvBcV5XNV1C)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "XTPNf3E5NFVs" + }, + "outputs": [], + "source": [ + "# rate of change of error w.r.t weights between input and hidden layer\n", + "error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2480, + "status": "ok", + "timestamp": 1585485768146, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "_WN0I-mpNFVw", + "outputId": "a7ab9b3d-3a2a-4480-f15e-11d1f5ae8e13" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 3)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "error_wrt_weights_input_hidden.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "W2bu4H5-NFVz" + }, + "source": [ + "### Update the parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "-nmJnY_PNFV1" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1A5jaB3WjZx9yrJkk9imVEvP3PZodjapE)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "_r59xEpINFV2" + }, + "outputs": [], + "source": [ + "# defining the learning rate\n", + "lr = 0.01" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2341, + "status": "ok", + "timestamp": 1585485769472, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "aiBFNXd3NFV7", + "outputId": "a7362697-b6e0-41c1-8a5a-bb525ed22c3e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.83244264],\n", + " [0.21233911],\n", + " [0.18182497]])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initial weights_hidden_output\n", + "weights_hidden_output" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1928, + "status": "ok", + "timestamp": 1585485769474, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "CuosFKUENFWB", + "outputId": "fa8986c3-9960-4985-b6ec-e7d9a51f16e1", + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.37454012, 0.95071431, 0.73199394],\n", + " [0.59865848, 0.15601864, 0.15599452],\n", + " [0.05808361, 0.86617615, 0.60111501],\n", + " [0.70807258, 0.02058449, 0.96990985]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initial weights_input_hidden\n", + "weights_input_hidden" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "D_Va2xywNFWF" + }, + "outputs": [], + "source": [ + "# updating the weights of output layer\n", + "weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ruFlc96BNFWL" + }, + "outputs": [], + "source": [ + "# updating the weights of hidden layer\n", + "weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1799, + "status": "ok", + "timestamp": 1585485770584, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "NTf4nS1xNFWP", + "outputId": "feb1e8da-cdff-4374-cf88-a66e1449ea05" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.83211079],\n", + " [0.21250681],\n", + " [0.18167831]])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# updated weights_hidden_output\n", + "weights_hidden_output" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2866, + "status": "ok", + "timestamp": 1585485772036, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "7VYNPPNlNFWU", + "outputId": "ae17551f-c966-4124-9ad1-95f3a9e59fad" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.37476062, 0.95075719, 0.7320294 ],\n", + " [0.59845481, 0.15594177, 0.15594545],\n", + " [0.05816641, 0.86618978, 0.60112315],\n", + " [0.70795169, 0.02052126, 0.96986892]])" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# updated weights_input_hidden\n", + "weights_input_hidden" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "SxLy6DZlNFWY" + }, + "source": [ + "## 6. Train the model for multiple epochs" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "8HKS9vIyNFWZ" + }, + "outputs": [], + "source": [ + "# defining the model architecture\n", + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer\n", + "\n", + "# initializing weight\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")\n", + "\n", + "# defining the parameters\n", + "lr = 0.1\n", + "epochs = 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "_yVAcyW_NFWk" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error at epoch 0 is 0.11553\n", + "Error at epoch 100 is 0.11082\n", + "Error at epoch 200 is 0.10606\n", + "Error at epoch 300 is 0.09845\n", + "Error at epoch 400 is 0.08483\n", + "Error at epoch 500 is 0.06396\n", + "Error at epoch 600 is 0.04206\n", + "Error at epoch 700 is 0.02641\n", + "Error at epoch 800 is 0.01719\n", + "Error at epoch 900 is 0.01190\n" + ] + } + ], + "source": [ + "losses = []\n", + "for epoch in range(epochs):\n", + " ## Forward Propogation\n", + "\n", + " # calculating hidden layer activations\n", + " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "\n", + " # calculating the output\n", + " outputLayer_linearTransform = np.dot(\n", + " weights_hidden_output.T, hiddenLayer_activations\n", + " )\n", + " output = sigmoid(outputLayer_linearTransform)\n", + "\n", + " ## Backward Propagation\n", + "\n", + " # calculating error\n", + " error = np.square(y - output) / 2\n", + "\n", + " # calculating rate of change of error w.r.t weight between hidden and output layer\n", + " error_wrt_output = -(y - output)\n", + " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", + "\n", + " error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + " )\n", + "\n", + " # calculating rate of change of error w.r.t weights between input and hidden layer\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + " )\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", + " error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + " )\n", + "\n", + " # updating the weights\n", + " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", + " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", + "\n", + " # print error at every 100th epoch\n", + " epoch_loss = np.average(error)\n", + " if epoch % 100 == 0:\n", + " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", + "\n", + " # appending the error of each epoch\n", + " losses.append(epoch_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2409, + "status": "ok", + "timestamp": 1585485773423, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "Ra5mTgwUNFWo", + "outputId": "20de9dc0-62b7-4f07-fd3d-cf290542ac8f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.25679149, 1.72312858, -0.27336634],\n", + " [-1.07615756, -1.73777864, 1.42316207],\n", + " [ 0.63053865, 0.88090942, -0.03448117],\n", + " [-0.56098781, -0.65506704, 0.61013995]])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# updated w_ih\n", + "weights_input_hidden" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.45176252],\n", + " [ 2.59109536],\n", + " [-2.18347501]])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# updated w_ho\n", + "weights_hidden_output" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2186, + "status": "ok", + "timestamp": 1585485784562, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "WeN2dcc0NFW8", + "outputId": "59ab0369-88ea-4f52-87b4-99da23925bb9", + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualizing the error after each epoch\n", + "plt.plot(np.arange(1, epochs + 1), np.array(losses))" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1949, + "status": "ok", + "timestamp": 1585485784571, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "bJlcGoeUNFXA", + "outputId": "052f7ac8-c10e-49e4-df8e-69bff60d4381" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.9155779 , 0.89643511, 0.18608711]])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# final output from the model\n", + "output" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1904, + "status": "ok", + "timestamp": 1585485785455, + "user": { + "displayName": "Pulkit Sharma", + "photoUrl": "", + "userId": "07234574884764057306" + }, + "user_tz": -330 + }, + "id": "ARNn3MiKNFXF", + "outputId": "eb1606ed-53da-48f8-c5a0-f4c459e71fdc" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 1, 0]])" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# actual target\n", + "y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.datasets import make_moons\n", + "\n", + "X, y = make_moons(n_samples=1000, random_state=42, noise=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "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": [ + "plt.scatter(X[:, 0], X[:, 1], s=10, c=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.datasets import make_blobs\n", + "\n", + "X, y = make_blobs(n_samples=1000, centers=2, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X[:, 0], X[:, 1], s=10, c=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.05146968, 0.44419863],\n", + " [ 1.03201691, -0.41974116],\n", + " [ 0.86789186, -0.25482711],\n", + " ...,\n", + " [ 1.68425911, -0.34822268],\n", + " [-0.9672013 , 0.26367208],\n", + " [ 0.78758971, 0.61660945]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "X -= X.min()\n", + "X /= X.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 1.0)" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.min(), X.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1])" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.unique(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1000, 2), (1000,))" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "X = X.T\n", + "\n", + "y = y.reshape(1, -1)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((2, 1000), (1, 1000))" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape, y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error at epoch 0 is 0.23478\n", + "Error at epoch 1000 is 0.25000\n", + "Error at epoch 2000 is 0.25000\n", + "Error at epoch 3000 is 0.25000\n", + "Error at epoch 4000 is 0.05129\n", + "Error at epoch 5000 is 0.02163\n", + "Error at epoch 6000 is 0.01157\n", + "Error at epoch 7000 is 0.00775\n", + "Error at epoch 8000 is 0.00689\n", + "Error at epoch 9000 is 0.07556\n" + ] + } + ], + "source": [ + "# defining the model architecture\n", + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 10 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer\n", + "\n", + "# initializing weight\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")\n", + "\n", + "# defining the parameters\n", + "lr = 0.1\n", + "epochs = 10000\n", + "\n", + "losses = []\n", + "for epoch in range(epochs):\n", + " ## Forward Propogation\n", + "\n", + " # calculating hidden layer activations\n", + " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "\n", + " # calculating the output\n", + " outputLayer_linearTransform = np.dot(\n", + " weights_hidden_output.T, hiddenLayer_activations\n", + " )\n", + " output = sigmoid(outputLayer_linearTransform)\n", + "\n", + " ## Backward Propagation\n", + "\n", + " # calculating error\n", + " error = np.square(y - output) / 2\n", + "\n", + " # calculating rate of change of error w.r.t weight between hidden and output layer\n", + " error_wrt_output = -(y - output)\n", + " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", + "\n", + " error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + " )\n", + "\n", + " # calculating rate of change of error w.r.t weights between input and hidden layer\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + " )\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", + " error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + " )\n", + "\n", + " # updating the weights\n", + " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", + " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", + "\n", + " # print error at every 100th epoch\n", + " epoch_loss = np.average(error)\n", + " if epoch % 1000 == 0:\n", + " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", + "\n", + " # appending the error of each epoch\n", + " losses.append(epoch_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualizing the error after each epoch\n", + "plt.plot(np.arange(1, epochs + 1), np.array(losses))" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[9.64860989e-01, 9.98678150e-01, 9.94656205e-01, 9.99198418e-01,\n", + " 2.17566533e-07]])" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# final output from the model\n", + "output[:, :5]" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 1, 1, 1, 0]])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y[:, :5]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define region of interest by data limits\n", + "steps = 1000\n", + "x_span = np.linspace(X[0, :].min(), X[0, :].max(), steps)\n", + "y_span = np.linspace(X[1, :].min(), X[1, :].max(), steps)\n", + "xx, yy = np.meshgrid(x_span, y_span)\n", + "\n", + "# forward pass for region of interest\n", + "hiddenLayer_linearTransform = np.dot(\n", + " weights_input_hidden.T, np.c_[xx.ravel(), yy.ravel()].T\n", + ")\n", + "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", + "output_span = sigmoid(outputLayer_linearTransform)\n", + "\n", + "# Make predictions across region of interest\n", + "labels = (output_span > 0.5).astype(int)\n", + "\n", + "# Plot decision boundary in region of interest\n", + "z = labels.reshape(xx.shape)\n", + "fig, ax = plt.subplots()\n", + "ax.contourf(xx, yy, z, alpha=0.2)\n", + "\n", + "# Get predicted labels on training data and plot\n", + "train_labels = (output > 0.5).astype(int)\n", + "\n", + "# create scatter plot\n", + "ax.scatter(X[0, :], X[1, :], s=10, c=y.squeeze())" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "Neural Network from scratch using NumPy.ipynb", + "provenance": [] + }, + "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/NN_From_Scratch/improvements/images/error.png b/NN_From_Scratch/improvements/images/error.png new file mode 100644 index 0000000000000000000000000000000000000000..d160823b434eb4d8df2eefe41e246b7308c1d2f2 GIT binary patch literal 20214 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 VyMFat1TINXQPNa=q;T=({{^k+v@rkx literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/error_wrt_who.png b/NN_From_Scratch/improvements/images/error_wrt_who.png new file mode 100644 index 0000000000000000000000000000000000000000..e35d89c5ee3f0dbc52d1bc43d1fa3c8a7bbc82e3 GIT binary patch literal 38181 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 >buO|Sa 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 G_WuW8W~~VT literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/error_wrt_who_matrix.png b/NN_From_Scratch/improvements/images/error_wrt_who_matrix.png new file mode 100644 index 0000000000000000000000000000000000000000..e9aa10a3ba35dacd2f68de667481b4522624ecb8 GIT binary patch literal 7255 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 CW5+iD literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/error_wrt_wih.png b/NN_From_Scratch/improvements/images/error_wrt_wih.png new file mode 100644 index 0000000000000000000000000000000000000000..4de7cf488405a6976a30605aca788d19f1c3e1c5 GIT binary patch literal 43534 zcmd?R1zVMC6fL?C5JV&uloljJLb_9=TS`(|y1Nub2|*E%F6l)pDXElnNOwqgH{6N) zob%js>kr(upJ#73uC>1Jd*AuaImVb{5~Qpsbqk9G3xPn~l985BMIg}f5eSqInAhMZ z(GktX@E=qsaTzsCOw6$vrD^!zd(Ka_oS)g5IlCD;nj*|??QBe$os1n#O>LcC+Bt8c z)(ImJR0tUfF*WyuwFwU`HPcg!txfC@Ce+|p*K7k*vS-Ax7~WBT{S+(rCFf;Mp~a@s zqv*blHrl6uCfOD8bq(5tO4bIj9i;51?2Vt{JD`r>oAT9(baB=f1-5q>n$;#-u@vxi zKVJ~$`Zc~Q*nR#RO$>qm?{yEmvL6NS-yg#@*l-_EU%l9wI#7cGuU^ylLe`*(I+O>^^^j--Udp7T+8L|~w0)!Vmd=H})(X;jqIeUxOxvhWEB2@|at z30l>PqwdwP2M*DrA|FE2{U z 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 literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/error_wrt_wih_matrix.png b/NN_From_Scratch/improvements/images/error_wrt_wih_matrix.png new file mode 100644 index 0000000000000000000000000000000000000000..b560fa5b45e70b7fffb819edda590fb97ac20a25 GIT binary patch literal 11060 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 literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/gradient_descent_update_equation.png b/NN_From_Scratch/improvements/images/gradient_descent_update_equation.png new file mode 100644 index 0000000000000000000000000000000000000000..0637c8cefb75bf8dc38fa762eb772a3cc7cd8f75 GIT binary patch literal 3851 zcmbVP_d8tM8s7RC(R)OhoM@wjAfpo`h$vCQ(MJiqf<3IG7Rsfm#_0MN;R zYXpQId@5z=*Mbv6h=Hjs1Og$FEf>I7;n3R-p*E<8p%F-oH{cV53iMV8@x*w02Zi{e zLU$P2bOC^)z|`oLZRGo{_t92a<05^91jHMDfsB<0@y?ez_i79zBDe;Ml-{ahp`-fw zxmQAJSi@?9b1y3oKB`sXAG#&W6ZpRR-hgQkJAW$IhoZsTidQG&*;${(#KmbZY3=OH zu?^M?YChJDTi4jpphOkMv{GV7A;WA)A!ZrAfz7Mc^>lm#T@ZdTtOrx+t_+`?KGwL% zfex+>?SWd6@5?-hho%|e>1`wVUh;qFEVilu{>M+F9ejO#C7yE``1$z_jZ@av)-oi` zATSnAG1VsC1f;dKH3TMt2vWr*#+=f)4Qgs??)g_*$v|M@F^8`oeK&sw-HDY}QX1*$ z=`qMp#A3OZ)FZavhaU_L4e4F{R#8w0q)y(jL>Kt*2MWwLjs6nrjU9 zbPVk4?S;$9vBFqcSyfa$Z*u=h1YUAzYH3}Z?&yh&iv#KXUJ*N_o_(i=phv2gIXO8G zI0S`-qc;AP?V8*z`07`8@*OeH7|*Hu%YA#cNu>d%sHmu>R##fOmWm+#IzQb>MLD>- z>gwuN+QRem^L>JPD{d7=9{rKXDPEu#7i(=jc6>l7vHpU?ZS^Dz+T$G6P^4zVM2>ec z>R)U(bog()OCc^VrRi;NZT&nta%+oiX&Q>WI6GpZ@4&JN4h#&Wps-P^HkLZxiYgCT zY@X-j<(Wb5%kVX~S$(qpvKzC|Bj~oQrV+fz2B>7gBmz$ZHMIVkDOY$V;3U1AJ&`u$LF$HFzbiS6PKiOS3dG zGJ5oAJ>-W@#QIoCZf zCcZDy9PN6~%OU-{`cVK#Ub8WPEc7I~xf&2v+P|DYkVvT58 zg~>H~Ajyb_i)&$dnGs+UkQcggMf>rg4DikCMxA3|W9IAEujl@WD8}xzo^F5p_Cndv z-qzNn#5!PQY3bnCQW_i9z{iI|@cH3E-f6oSc5M!rz5$q+n7rMdql>qa+1%OjVY_b+ z;-fj)E%w;^%27#<>!RKFJOn48d+|G@{_n;{q3CTYRi!s$dpiiI#^akpD6hzJ(T^Wb zX$+2!t0^g2No6J(eXMFbcPz33+Rx8Ug$KLqE$(rPbtx4T6aeVuZ`?t!uaSF;J-`R+ zFO7C25(z;6{uLY}ntMC)`1lxD*xnvi=*|hNh3n|#JB2NFvjV&O`?GD)nYOeM%3!NJ~SEJrohiL$w|=o1LE>&Fe(d)HO91 zXZWFMc>Mrsw-MR<;X}VZd}3l^OUoIlB|0j+T5)@AO({_Q4Dk%dt}3+6X$BxXJe+}nVRql;pKw-er?FU+(P_kZf3BK8u+WKRqx>jjiBCyM zkIrkZpcvMm z!zm#BZi)H|b$P7BECI1cilT_p7RhAfz0n*+mjSA=7JTFw27?t96@8F{*XE1!@i78* zb#)0le8=mb3)^30XBWnuM|pVA17l-jk#>0qRKdQYJU3AadL0IP!ZkKAF)==lm0Vja zEiD}xvBEnHsd1D)^og?}`g?nOd*IboRaN0|sJg2^3WW*`&RrmdJ{1+wZI?(o zFJm-vrE>-gBNth_&MI76G^M2}nU=a87h>vY_xaYCq@<(-CorAtfPkX2350Bieg0f1 zhBv{T68YD5@ThciX{k)X!L2yk1;9^mKCpL26_A(Y|UxXZxYRh}dPd58A$$NT-# zQIZ5+Fz6pWJ>H`qZv$5M?|0NmNJ-t1%2aUqT3b?rts@$63gj=KemG)7>`Y8v;BbLn zUf0mE(Y0_H8Hl~^;ppt_?CwSNbrnrvaEOR703fk$Io{j)eRfud?J$%V056x&(E`?E z!+fmBfh5D>&!6iejy^CRQPH`;bWyGFYQZBKZG)<$tLrMkRcc#CY(ROk4nHP?_klzj z6s3p78XFt?`hLz_FXJBeeE|02o@F= zSLuL;P5qPh=9#ym+6+N-E(OZb0sfv}cN?RazN&-C6?_4%ELg!bB>d1BpO|==+P?cA zR^W=LsB)BkS7T=gSTVJ}qd%#WAUQg84HW={wyV*z&)F1jUgF@$jj$rEX(krjc=eqg z0dE{;ak;O|OG!&h^R({`^=Mc4FsQPc8kql9vH9&=p(G<~H#a?P?G(jVsi{5i%HTV? z4nq(GQC?1t7m9uBg<+?H^%WFUpyI<};mKV32WVpQ^#{+-=>&c>&&k`IeF}A=kG74Sw z1~&D_Yt0o=etya9yVQ-1fBk;04CXM=)16#VA8reyJ_rdRJbT8V7`ET;Y+Ga{6dR&) z-VU7&83d($yxcy@PIJzKG&RwmGVHgQK0ZFava;eV*wr#Oj%qujo&2PNdeNw%q6LEI zn^(=u%uKT2b^1PU^z~a+6%`egmCVUHi8kL=WHl9z zx%v6D;Qkw`s=r@t$7TaImNkGjwXxD$PqxLa$3FgE{rpeEW*}=1c z>hP_ZcPSq9jhn9$^0gvfIjwAMDS&ol12i3PgwE3R&f5z$WM$WBTf|FUhetWFE1~uZD@FS4NmDFVpGUx z3lR(k<3K?X>r$ohZT@8G#F|KgkZiW`U{(zDdkg6^#Mqs)niIw;=1^jN&%{Z z&S^x{W{-@vC)m8WJCUPagSC*)jGlioeekD=tE-q(*itY1R=r={<;=J)5k0mC+r013M!lYkN~0hgG~< zQ3PQ?WF#Iuc1c(sb=7&?cR;Yl!;|ugfs2HJC`Owlpke|amneqe17{GGg7%up8{)Vu z2BXxNH~R|G@@IO&*mb_zWIbmnWKQ9hCGvUela`9ZfrE!fxOp(;5ubsBAG6%SmAs?x zvTD1+<1!a(-|5*=!5%Ixfgs|<1+k>C#A!4MDUy;KR)>QWU*f)xyedWE6Cl_p&9MHV zz}F;R6W?&Cf{ZLJJr1^)o%G2sUi|)|0RKGAV>Pu;v%e6em@p{ZZH<4-W$IUf0S5<1 zY;3IMc5RI$haP5ra`HMwKzC1%uC8w1wX5*a&x|kLymjkGfB!u;HjCj>tB7Gg)bE4U z+VSr0LZ@Y|G#dmNj9KudM0Iy}V=$Pltt~ryd#QIclKgqPRZg$~gCD^aF6*f^HKI3O z;~=KQKe+ERGBGoo!e@nqgm{S7YUJx(=FqWy`Ep^jia)v2+1B|7nMt-YSxH!yIOnwo`$7eU_rI1Emb ziM-Y2gHluLsqs8$9aWT*Yl9t>S`Kz&u_>5&1mV5hK&``ku_K;8zof(woASWO$SB!k zBVa_~Xrql&KtLcpJzd}P?|X_HXArC=iOE`Dw#H>Ds*WTPAs(Kd-d^5Yw{Eep$kb#Q zx5x3l_)dsw{<}2rDK+)VH9A~GneSFpol>G8pG7}AeW>%%z9So3_R+x(r%pNc$B&GZ zlviyttzFL^K5Te%{_4tTl@#In)|O7W?Z?80_z0FE0gF|BM0z-v?Cs|6PJG6vyu5sU zs)-UcFOf9veNv6VjC6J?h1~o5_itiC!mdY+I0G|;)7;$7!QrtJq)nVpfl3sa=x$13 zq1_n9HKIlE-o5_b-mSIY4d>3C+u*aXwx*|`cwub(h*03=BznYv8{QKdOHyMoke8O0 zc6@XoB`GOmT~<<(zQY*Jp{u2$!l*y>5CS?9=zj(L7S@bDP&JWnSl;JNSM;7~k5U}tNqS@7a)e7m)k)w|$ec6Rot zDi#E3|9+St|Gu@O0}`Q3nu(i>>sPT^WNz-Ao(nh#^Z8ACZuQo|LD%EMJv8}8<#MC8 z53Q}T88;vX-k#^*8)Y@P?*}y!5fY{lXGVSa z@JK?UxVV^$?jrIE}gUIWf6dL@4-pYK>K7c=wQ z{)@&YCQVIEJaiY3SBDO4@HTmQ`TksO6C)!@LO7Bw&f3HJ)1}yTSCA+k>m9ZJ`V~VS z5f)}U`;+=~cVYe<#+4yN6h{Ys z-^f~x+7|_yxw*MQPJhZh5AL0A#KBkbw7#GK#das~P;Zr)Nyx}Dl}zyvEK%j@$?56o z+0-80V@%7-BhA*wc}4XA|28^IL*G-~?k^jA0xqJ3Lw)Ey+mR@DSurao2i|RCYWhs@ zI`T@9!T00_1H-eQF?Z2nfG%`GPS5_bAz0hyiIWN2`)nF{Y1#UhE?s*5pC?oE^EpfQ zFa28Kc~Xmuw4+JJMA_KbTKe+8 z+7cnA42El@gF{1s8nyqMeE-hy#D|1~7(TMyxU97F(W6JQxnAm;nlVvP-yd5dNb^LZ zEu>zd;klqjb8G7lI!CNGZWwINwgV`CV^B0TW$w9aDkvl*1o#3lY0{ZAGdru8a6i0r zZgsROnp{<1zjJCm$$dp2!{7{}`@O!$t7;xjwJG%4ZS<9^R|op~0?Iaph4MN0Vo5 zDG+Am=U-kuizr_;TgZTwTx)-EI{- z_`^d$Kw#{Hha|$;idb!yyJ(K|_3<$ywQuD=YH;c!(elwN5NIH#ZS6ar%l0?2r99;V7K*k7pVa+4(gTglFXG=$NVxR;us_ zNdK5}&Kj~tR#mwVD~%=!IUgTxb_P)1=BA)9{iI!HZDefB9aFdGag07k2`CangnSOV z%sD$dd)=4kXMO#P{+y@sQaD;u(=CzCDK|tOgKc#{zo1V9xm=nX`rL_ecsC-uE z18v)v{DrA$v#Ab3qj1x6EjXBjDyY%8=w`APgVQ{g5&rpYn>To#M`J62z z>&n*1uk)U=y|2R&eQar9@Q_fzVV*p?t)!?3s>Nbw;NioE6*?>PU7w(nRIdN1{1Ym6 zJYiSif<%%4xX;*CT;;bm6eRb%NJT|Td*61X{AK7hv5b?2!n64JPQ6jmOj=)`;Y7EI zc%#C;-z@9gBXGF+A~%_J)$V^$SyZE0mC;=XMu^ZWz1}J zK!A)?Zh>ab{QNxQ!#6pa1(N{HtbtE&K831H_L_~1j2vE3kde8|&28?Se?RwNclYyk zE&-^rFJD;su5E30iq-x~ii*1E_5+PZf3~0Lyle0S+W>SyX1UUFseiP}8CsRZb(Ket z-t><7_~7mjY;J8m=6VBJxxG4mGT9iUs`P+@$gl0g9SbwFb0j1Q!mforQVUtFZEdln z4~TR0s`r5tK(D>=D3}3_-OSY`zRZ!vsaazFJ{bRCYhkmUf1H<}pHmN0o|PqY>2CIy zWH~k4VOmc>lfb}04L#S!-riy>vZIZeHVBb%(cswF7%Ndu6?}n4j^+g_st>WTExU0$ zuV250Y+qkngC^@I7}{oBBqA(K$Y{kGZ%U95^0X&;c*W7y_6patS3Y-RVq=#Fi~QS- zz4vCK2lDkV+l<3*+vE9x9hO*+R_2vGQCElREVUZGclJ{^)lz>hF$oEDu*crc657+# z(@eK+ky3LTLVXwN?*ZlXKHi(7CB1#`UTIHA@9z54(cz)>7^cFclYZvx0hzjyZJZAq zD=QHZ5mQ-Df++Opms3C9zke^2>m_Gj85v0#+N7rPY=ecBH83PZuh>)t2*d81__*ca zvejsPuY!VtfRGU50!?#K!RpU|H(_p{DVN{Z0$Korv2vg1_3ar~Psq+*Dl}?~i;Md% z5;rn30Z)cQ#()M;fz zz<%~8MbPg40h z6?VY#fCf5eXF)-$Wh%CKwSRo*Z#c4d-}@L-TkGxU$QRnQxv@dR_3T@NKN%$j1*~Lc zX-Q7MCtqI-B@M@~r4<(*9-f?>{O1NlF*PU0aK?Q$8bHU zi5c!57zhmrh`nc}_4sk`JHYHQ%);;A1*TosjY>GR4GgAU;}NK;sWm17a}0ws3kxIH z*Vh*jQOIw<6d)0yVdEj1+&KqY3N+B(?k;n>kR2#cGO|z*fL-po{MI8ef{u$&W}QhQ z!=s&!W@cuYCYJX0MZx;sbBWI878Y}z$=B%V728y`wX{G!u8ve}j=8U%axi`QTGkB3 z#Gy>3Yt;V35b#d16KD%`babP+s>J&G<8sj)iNda`@!aJQY!{bZ;NoZ$=f_g;fMt?i#?!NUx3zn8bhN!) zA$;X+Qj(s8#2FxIVbJ`lDl4J>KYaM$RF-8mT*_kiX|j#8HYYdN(a9;~?OSpaZBqYD z*s1q=7alA5*eE0VDlD+m>;@d%!mlhT-KH(}ha=SRA`W!!# z&ySCf4?F@WLhe0x@`RAU?ZrNe)+m;imX^z$dJaxbw^~2nz}U}qK#1RO;}1QIlpKy? zTTJ_prxDA3DSSPpk^M#q2OZ4beNey|;f3@qjN_;}L0`}tOpNvEtHA2eGm4IcG; zEW5F#rLf(!v?!Eia{dU39^~lb$7$d3)3G6Mr>O*$lVW0+r&M#)!0}K$xlx>|-|nmo z-CikKRDtkmjYmaqrZH5pzQ=kaNar%k!RyBi)QLi+<=E{n(3eAnLQ9MB%Xipc0_ z6Chumik_ZFEs?h~)6%AAXDiFgp^MDT%~8&b{ZlFY0AB<4#UadR0!jwCgeOh>aET+%HZ|MOmE6)}|)^Q(Xxy4T|f}@^WM2+GO1N z`K$MYfdPWW(Qe!sbNAs&gX7Tah=$Ivx7qdG_J>v6_)H&a>Akvk9eY# zng6&6={~oyIgOW5$s?XZ!`2Unz>< zTfH+Dc@!7RW71l~Ha|1txHYdL*dEa_9-bht8D16s|% z5##-P6crXm4VRcjOEaCySDOCJ3hk={HXkpCfb|hqp(So<`6s{jnDv0~<;$1L{i)a! z(s1eCU%!4iZErv!N=I`NgX$W{)t1Wly|fx4{Z5BPv4q;=+bbOC{*_M4Lx9U2$zn>! zN8v!R=;`UDLTF(v9~Z=VvXz;-#sa?tDG@TRudhpm(t~ga^jMaIbyy3Ts0QwCe7;ef z@wL2s7y36ig$&+gK5C?-q~I=rb$BWI5(~et#*-%?V-v^=4Vp;zcap`tkD*T_#Kl#* z{apn6;YmQ#Vlz;+bbM{of}&tzTZM<5v;d@Zw6rlHk{=+G6+3^0n5#feE+j?(zGsy^ zRaci>D!gf-0>W5LLt~)S7ew;m(GjpcTs*u>2^#WJj!|R3)m)Dv!FMdN7=Ya+zklEO zq9E;2vrfbwWG;ZY47NF@)5tB;C`f-4tp zJd%Fb0U!>#`qu5+(H}l+FAr-3IHJ*E;6Wlht=z!Ams+k{*bJ1*)JjpU^GQd+tVHkZWN@h#STtCZ12h_7C?+u!tP zy@&47a9g!cRu?V?M2Y^ z{X2NJrMjVE#sq?|U51LyWZA<*0s?^32ETjvt~b*SvSjN~V;r9ay|7D4PD4phyRj4) zEFIG$HJ(+<%pe_8Sgp~_T|Q@tUlvp)z{HsAFKyXM|w@v(%5)=xon)(!gLOvM^+d7DQ&An!^>YzF@NP znqnJ+E}vrr)w7t)KE@&^C&w2`@uRV^i)R7K+RE9C%N+6`qD-^zP5;H?rH zqY?4(a#4b4yQv@Vz<@R;q};B;PJR&BHC_WPCh8hTGF9Tq^!0U~EA#Dl%(4A2VBAP~N?F}I}# zGO;L+b>Oo~3HM+AuJ=oqiw@*}gGQ61z;uN3ccdl|gcg|TDWr8SZ$wU2b|y2?B@xwK zC#8i^S!6m`^*)iy3?=qMfl1J7&a`+t>EUB2qwc%vJN!c2#y_v@pMZ&`)FyrtxEE+I z^f5c%3n~hV4cIXy3OFE0nM$wkuo}rAs&jtzXNjpCwsOfYT<8Me@9pgcTg9Pz#=23Q z@b2BaPiwtAO-<*ab9;jz0a{sJQE>#RJNX$XI>hlDBRuDEuw15o;hcl6rsgjwZ*Z!i zHB3%U&i6)w`@K3?B=x08y2+-er>8MlbYtgsK}N=-A5CA=($Gm)3%dl8C$kP^nRNT| z1-@iw2L%P`>gb?RA3uJ4Zf%|SM*p+ZG+1a*I^Y#PRyiQMCaP2EU!7>&gwkmM zFA7d`co^exzLAZnz3CpPic$htlb%N@5xXw5De>ZG^zs=s7E8}abQ1%3?-#;-wHZxmD zlZkZOSrM_DZmzFK;p6o%Lv3oHP^ioxQghsOW+Fy(!*8aWH{a0-m4e;`XaM)YihjU(*FKF z=880}?@)esymy+4<$m@Gp~#)bj?m3i9%& z6Cy8gKALxaH2_07+MNmo`+jq-Q^R8e4HJj?PoW@zs4rajSoxdp{1LaMoN%DIp<&t< zAG3Hn1mOFUJq-g1#A208Bne0n?9_x}uB5F~MFX)6_lvxy7QusV=&$C}5 zs92~!$>6|9Jxl06^#Q|D`93jY^T5{yP6HH<5(S|5&A6z&y5{JM*ehqPj`UzZz7Za$~g zxd}v&cXQAe!A3r#)oD3{`@q8kLo@pV2YGf;GM0jpGBP4!acM~-SF6#19l>rg`m#wu z=)u^Y|4FmYZVOY0S4m{lIx7G5kSFg{ZgM?Eo>6g^AHs)EPE8Gqep4ezW+g^~#qp#4 z#To8{EupF!;Swaxlxop6I6VA`=q%EUM~!hmgIfp9X<=Em(r?y!T{U(772c~M2JphC zmu2t9RW*9rjx?M>N*;)~Xq-Fa1J3Eo{SR^HBzwxTvn`TEJ+BawA`TSXE*gIqdQ2ce z^78Vwl9xqapH*i@QWTpfMk&e3u}*bFL)YfkU4VhepE-*N5>aD@jeo{4{w1d!y5?+e zZ@_#V!K%QEVdPf~=&tp){IbPSLf8$yVP({Q^Sq{-H%XXxW1rnrV{PJlRxqMmW& zFJPK@@uDG^*r&s(Wr*sB`1pgPopDMO$@%lXK0e=hoMGO2o_n`8W$P-;tGRc@l=sgg zLuX-Bboz%D0Zi7SyzpK*q41>^`2Sh#r~j6A|0VH)*_PJ6)r%KC-8Kl8Lol%pjF+j& zNkT?I3~0NLPG5g{w0#1)67VSrumpk{wP4N*@;nBXo#O7m>nrAUcwbl;^YP2Zl779GVfB4O<|J2VD^4;>U-cYv9j;?GRZjR||M{x@vL8%81jA0&293r;kJO z8o&$H}Z= zj}T%v`VwPXV&Wi}!OK|3avKo^HGU2bDsq&CWK;(*l-}OQm+s&p zT#C7$n1Os+@e}!>P;Ws43*Nv%=5gQz+S=OEO9}nz7Z=S@Z{b`2djakm07HSP;wBrL z91{hY6{mb6F&sg*5I9^&uG5KR!!2|e&?9ispk9EG^#&q{Lv-AVA@qMr6sEd5S=g1^ z@)s8;Cnv~xSPqB{h%XGj{-SXJL_cSdDISbM52!ub9@e(0eh*aQ@?{M*H6Cz|z|{XW zIM@~aj$T9%Tx@a*T3TVaU*PX|d?Y1Z^LqH(g)7H(bDLI{mZ0y+X=!zom2EesWlqxz zt7D!^uo?w+N)ID~n4WLfx~3x>h$8Ij=^6e9K|FWwg8OQGj|*;Q zr%#^(Z2(^l6wbdqD>AjlFZ=pc6C^%p+5G(cckdLQKW980x|&k8w@*a0J)@?k4#;lC zL0)x_kc7-&a1g_u5g2|Uh5y$yEd8lHHx81rgeCazoh$ztg8hF?%#Os~c%Tr9^lScb PTMQy2sVI?$dgk*#hh`4! literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/model_architecture.png b/NN_From_Scratch/improvements/images/model_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..fa4fd6d2356f870b7f1084a4acd791efb6adf616 GIT binary patch literal 33580 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 Vn^l=w8t@qsvn=OYoHTO_{Xen6WoZBa literal 0 HcmV?d00001 diff --git a/NN_From_Scratch/improvements/images/output.png b/NN_From_Scratch/improvements/images/output.png new file mode 100644 index 0000000000000000000000000000000000000000..32ae7ef79fb67a5a5dd3ebcd0c9a745739744419 GIT binary patch literal 17581 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 literal 0 HcmV?d00001 From d79af244ba0314e7fd7f5b1426563f5e975e5604 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Fri, 17 Jul 2020 17:46:12 +0530 Subject: [PATCH 13/17] updated table of contents --- .../improvements/NN_From_Scratch_Python.ipynb | 3972 ++++++++--------- 1 file changed, 1944 insertions(+), 2028 deletions(-) diff --git a/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb b/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb index d6382dd..8a46da1 100644 --- a/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb +++ b/NN_From_Scratch/improvements/NN_From_Scratch_Python.ipynb @@ -1,2076 +1,1992 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "cEG1dhnuNFRk" - }, - "source": [ - "## Steps to build a Neural Network in NumPy\n", - "\n", - "---\n", - "\n", - "#### 1. Load the dataset \n", - "#### 2. Define architecture of the model \n", - "#### 3. Initialize the parameters\n", - "#### 4. Implement forward propagation\n", - "#### 5. Implement backward propagation\n", - "#### 6. Train the model for multiple epochs \n", - "\n", - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "sbgj7HfHNFRr" - }, - "source": [ - "### 1. Load the dataset " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "E5S9HgBzNFRw" - }, - "outputs": [], - "source": [ - "# importing required libraries\n", - "%matplotlib inline\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1657, - "status": "ok", - "timestamp": 1585485745721, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "ogs6CaXu2zeZ", - "outputId": "f5055dbe-331b-461c-a1a1-13d28149d528" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Version of numpy: 1.18.1\n" - ] - } - ], - "source": [ - "# version of numpy library\n", - "print(\"Version of numpy:\", np.__version__)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1788, - "status": "ok", - "timestamp": 1585485751574, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "vNmvxGv723N6", - "outputId": "340278d2-64d4-43b2-fd9e-02585dc66d21" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Version of matplotlib: 3.1.3\n" - ] - } - ], - "source": [ - "# version of matplotlib library\n", - "import matplotlib\n", - "\n", - "print(\"Version of matplotlib:\", matplotlib.__version__)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# set random seed\n", - "np.random.seed(42)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "accelerator": "GPU", "colab": { - "base_uri": "https://localhost:8080/", - "height": 139 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1409, - "status": "ok", - "timestamp": 1585485752142, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "H_h7HoPONFR_", - "outputId": "552026b7-f129-41e9-c8f4-22a4c9d80e6e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Input:\n", - " [[1 0 0 0]\n", - " [1 0 1 1]\n", - " [0 1 0 1]]\n", - "\n", - "Shape of Input: (3, 4)\n" - ] - } - ], - "source": [ - "# creating the input array\n", - "X = np.array([[1, 0, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1]])\n", - "\n", - "print(\"Input:\\n\", X)\n", - "\n", - "# shape of input array\n", - "print(\"\\nShape of Input:\", X.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 156 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 3240, - "status": "ok", - "timestamp": 1585485756254, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "LVvQz5g39wo3", - "outputId": "e0f22a43-1caa-4ca0-bfdd-0168c8853d6b" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Input in matrix form:\n", - " [[1 1 0]\n", - " [0 0 1]\n", - " [0 1 0]\n", - " [0 1 1]]\n", - "\n", - "Shape of Input Matrix: (4, 3)\n" - ] - } - ], - "source": [ - "# converting the input in matrix form\n", - "X = X.T\n", - "print(\"Input in matrix form:\\n\", X)\n", - "\n", - "# shape of input matrix\n", - "print(\"\\nShape of Input Matrix:\", X.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 191 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 3079, - "status": "ok", - "timestamp": 1585485756256, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "IRe8JE0xNFSL", - "outputId": "bd0f8cc4-140c-4788-fe12-0967af4b0f0f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actual Output:\n", - " [[1]\n", - " [1]\n", - " [0]]\n", - "\n", - "Output in matrix form:\n", - " [[1 1 0]]\n", - "\n", - "Shape of Output: (1, 3)\n" - ] + "name": "Neural Network from scratch using NumPy.ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "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" } - ], - "source": [ - "# creating the output array\n", - "y = np.array([[1], [1], [0]])\n", - "\n", - "print(\"Actual Output:\\n\", y)\n", - "\n", - "# output in matrix form\n", - "y = y.T\n", - "\n", - "print(\"\\nOutput in matrix form:\\n\", y)\n", - "\n", - "# shape of input array\n", - "print(\"\\nShape of Output:\", y.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "tKf4Ji1-NFSV" - }, - "source": [ - "## 2. Define architecture of the model " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "vlhBW0NNNFSg" - }, - "outputs": [], - "source": [ - "inputLayer_neurons = X.shape[0] # number of features in data set\n", - "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", - "outputLayer_neurons = 1 # number of neurons at output layer" - ] }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "OoOsLucmNFSo" - }, - "source": [ - "![alt text](images/model_architecture.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "_Nmwj8RfNFSr" - }, - "source": [ - "## 3. Initialize the parameters\n", - "\n", - "NOTE: For simplicity, we are assuming that the bias for all the layers is 0" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "1T1IG-W8NFSu" - }, - "outputs": [], - "source": [ - "# initializing weight\n", - "# Shape of weights_input_hidden should number of neurons at input layer * number of neurons at hidden layer\n", - "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", - "\n", - "# Shape of weights_hidden_output should number of neurons at hidden layer * number of neurons at output layer\n", - "weights_hidden_output = np.random.uniform(\n", - " size=(hiddenLayer_neurons, outputLayer_neurons)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1009, - "status": "ok", - "timestamp": 1585485756260, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "Fpa1--9KNFS1", - "outputId": "407ba6ee-ddc9-4830-d771-15704f6e39e6" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "((4, 3), (3, 1))" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# shape of weight matrix\n", - "weights_input_hidden.shape, weights_hidden_output.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "srrDW1MNNFS-" - }, - "source": [ - "## 4. Implement forward propagation" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "sOcBji4iNFTE" - }, - "outputs": [], - "source": [ - "# We are using sigmoid as an activation function so defining the sigmoid function here\n", - "\n", - "# defining the Sigmoid Function\n", - "def sigmoid(x):\n", - " return 1 / (1 + np.exp(-x))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "-g-SocwQNFTC" - }, - "source": [ - "![alt text](images/hidden_layer_activations.png)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "DO6AYHtGNFTM" - }, - "outputs": [], - "source": [ - "# hidden layer activations\n", - "\n", - "hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", - "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "o8zzYX6pNFTT" - }, - "source": [ - "![alt text](https://drive.google.com/uc?id=1ETMoLD1fwi5u1HHLqtAdVUs-P8HNOU_p)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "CuqKwiToNFTW" - }, - "outputs": [], - "source": [ - "# calculating the output\n", - "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", - "output = sigmoid(outputLayer_linearTransform)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2132, - "status": "ok", - "timestamp": 1585485759226, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "BjPlMkVMNFTd", - "outputId": "98153d29-d232-4e9f-da3f-f834a5ad8ad9" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.68334694, 0.72697078, 0.71257368]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cEG1dhnuNFRk" + }, + "source": [ + "## Steps to build a Neural Network in NumPy\n", + "\n", + "> #### 1. Load the dataset \n", + "> #### 2. Define architecture of the model \n", + "> #### 3. Initialize the parameters\n", + "> #### 4. Implement forward propagation\n", + "> #### 5. Implement backward propagation\n", + "> #### 6. Train the model for multiple epochs \n", + "\n", + "---" ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# output\n", - "output" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "mdFKMYyzNFTm" - }, - "source": [ - "## 5. Implement backward propagation" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "c2m3XBgZNFTn" - }, - "source": [ - "![alt text](images/error.png)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "IvUAAhlcNFTp" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.05013458, 0.03727248, 0.25388062]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sbgj7HfHNFRr" + }, + "source": [ + "### 1. Load the dataset " ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# calculating error\n", - "error = np.square(y - output) / 2\n", - "error" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "3H0vjBdNNFTw" - }, - "source": [ - "### Rate of change of error w.r.t weight between hidden and output layer" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "4cncCd1WNFTz" - }, - "source": [ - "![alt text](images/error_wrt_who.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "DqrhlDeDNFT1" - }, - "source": [ - "**a. Rate of change of error w.r.t output**\n", - "\n", - "**b. Rate of change of output w.r.t Z2**\n", - "\n", - "**c. Rate of change of Z2 w.r.t weights between hidden and output layer**" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "bKdk5m4FNFT3" - }, - "outputs": [], - "source": [ - "# rate of change of error w.r.t. output\n", - "error_wrt_output = -(y - output)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "Bl1PDwrBNFT9" - }, - "outputs": [], - "source": [ - "# rate of change of output w.r.t. Z2\n", - "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "3vLk1nxLNFUD" - }, - "outputs": [], - "source": [ - "# rate of change of Z2 w.r.t. weights between hidden and output layer\n", - "outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1953, - "status": "ok", - "timestamp": 1585485762993, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "UXXifY9QNFUI", - "outputId": "869382cd-4440-47f1-c249-db25f9073338" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "((1, 3), (1, 3), (3, 3))" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "E5S9HgBzNFRw", + "colab": {} + }, + "source": [ + "# importing required libraries\n", + "%matplotlib inline\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ogs6CaXu2zeZ", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "2a129bea-6c3b-4eac-f1bb-2a6f07e167c1" + }, + "source": [ + "# version of numpy library\n", + "print(\"Version of numpy:\", np.__version__)" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Version of numpy: 1.18.5\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# checking the shapes of partial derivatives\n", - "error_wrt_output.shape, output_wrt_outputLayer_LinearTransform.shape, outputLayer_LinearTransform_wrt_weights_hidden_output.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1725, - "status": "ok", - "timestamp": 1585485762995, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "ZvtS7wCRNFUN", - "outputId": "377481a7-6b8f-4d0c-abe2-82060ce48ab0" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(3, 1)" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "vNmvxGv723N6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "aac2f147-a0c3-4232-f823-7ef8d4b109b3" + }, + "source": [ + "# version of matplotlib library\n", + "import matplotlib\n", + "\n", + "print(\"Version of matplotlib:\", matplotlib.__version__)" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Version of matplotlib: 3.2.2\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# shape of weights of output layer\n", - "weights_hidden_output.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "gC9zQEH6HON5" - }, - "source": [ - "![alt text](images/error_wrt_who_matrix.png)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "l3HNVYGONFUr" - }, - "outputs": [], - "source": [ - "# rate of change of error w.r.t weight between hidden and output layer\n", - "error_wrt_weights_hidden_output = np.dot(\n", - " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", - " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1805, - "status": "ok", - "timestamp": 1585485763842, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "cwyI1EGZNFUw", - "outputId": "93df5cbf-3413-4acb-cdaa-394a9ce50a37" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(3, 1)" + }, + { + "cell_type": "code", + "metadata": { + "id": "cf5NZ52KragQ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# set random seed\n", + "np.random.seed(42)" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "H_h7HoPONFR_", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 121 + }, + "outputId": "77af76c4-e3fc-4a70-aca0-4cce73375d28" + }, + "source": [ + "# creating the input array\n", + "X = np.array([[1, 0, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1]])\n", + "\n", + "print(\"Input:\\n\", X)\n", + "\n", + "# shape of input array\n", + "print(\"\\nShape of Input:\", X.shape)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Input:\n", + " [[1 0 0 0]\n", + " [1 0 1 1]\n", + " [0 1 0 1]]\n", + "\n", + "Shape of Input: (3, 4)\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "error_wrt_weights_hidden_output.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "sDFPg2SHNFU2" - }, - "source": [ - "### Rate of change of error w.r.t weight between input and hidden layer" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "_757MrjBNFU2" - }, - "source": [ - "![alt text](images/error_wrt_wih.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "_nPYGXkeNFU4" - }, - "source": [ - "**a. Rate of change of error w.r.t output**\n", - "\n", - "**b. Rate of change of output w.r.t Z2**\n", - "\n", - "**c. Rate of change of Z2 w.r.t hidden layer activations**\n", - "\n", - "**d. Rate of change of hidden layer activations w.r.t Z1**\n", - "\n", - "**e. Rate of change of Z1 w.r.t weights between input and hidden layer**" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "Sb7Ezxw9NFU6" - }, - "outputs": [], - "source": [ - "# rate of change of error w.r.t. output\n", - "error_wrt_output = -(y - output)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "3-SGbNaoNFVA" - }, - "outputs": [], - "source": [ - "# rate of change of output w.r.t. Z2\n", - "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "amuoR7h6NFVF" - }, - "outputs": [], - "source": [ - "# rate of change of Z2 w.r.t. hidden layer activations\n", - "outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "YDUZEdWKNFVJ" - }, - "outputs": [], - "source": [ - "# rate of change of hidden layer activations w.r.t. Z1\n", - "hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", - " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "Ft4U6Td6NFVO" - }, - "outputs": [], - "source": [ - "# rate of change of Z1 w.r.t. weights between input and hidden layer\n", - "hiddenLayer_linearTransform_wrt_weights_input_hidden = X" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1069, - "status": "ok", - "timestamp": 1585485765410, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "A-hsfsi4NFVR", - "outputId": "2d5a0542-4563-4989-90be-382eba30a03a" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 3) (1, 3) (3, 1) (3, 3) (4, 3)\n" - ] - } - ], - "source": [ - "# checking the shapes of partial derivatives\n", - "print(\n", - " error_wrt_output.shape,\n", - " output_wrt_outputLayer_LinearTransform.shape,\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations.shape,\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform.shape,\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden.shape,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1503, - "status": "ok", - "timestamp": 1585485766077, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "1uka_yPrNFVV", - "outputId": "238e6afd-f960-4eb3-c02c-b95a31932b5a" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(4, 3)" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "LVvQz5g39wo3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 139 + }, + "outputId": "1f2e3a9e-2058-4943-dc25-b9e9816036c9" + }, + "source": [ + "# converting the input in matrix form\n", + "X = X.T\n", + "print(\"Input in matrix form:\\n\", X)\n", + "\n", + "# shape of input matrix\n", + "print(\"\\nShape of Input Matrix:\", X.shape)" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Input in matrix form:\n", + " [[1 1 0]\n", + " [0 0 1]\n", + " [0 1 0]\n", + " [0 1 1]]\n", + "\n", + "Shape of Input Matrix: (4, 3)\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# shape of weights of hidden layer\n", - "weights_input_hidden.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "gCeSm7vrHbHj" - }, - "source": [ - "![alt text](https://drive.google.com/uc?id=1RkG5x1NEFWlF3tj0OlswOWvBcV5XNV1C)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "XTPNf3E5NFVs" - }, - "outputs": [], - "source": [ - "# rate of change of error w.r.t weights between input and hidden layer\n", - "error_wrt_weights_input_hidden = np.dot(\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", - " (\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", - " * np.dot(\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", - " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", - " )\n", - " ).T,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2480, - "status": "ok", - "timestamp": 1585485768146, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "_WN0I-mpNFVw", - "outputId": "a7ab9b3d-3a2a-4480-f15e-11d1f5ae8e13" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(4, 3)" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "IRe8JE0xNFSL", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 173 + }, + "outputId": "5cbd1d8b-e0ae-4505-ce48-cd3f8f1a6fd0" + }, + "source": [ + "# creating the output array\n", + "y = np.array([[1], [1], [0]])\n", + "\n", + "print(\"Actual Output:\\n\", y)\n", + "\n", + "# output in matrix form\n", + "y = y.T\n", + "\n", + "print(\"\\nOutput in matrix form:\\n\", y)\n", + "\n", + "# shape of input array\n", + "print(\"\\nShape of Output:\", y.shape)" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Actual Output:\n", + " [[1]\n", + " [1]\n", + " [0]]\n", + "\n", + "Output in matrix form:\n", + " [[1 1 0]]\n", + "\n", + "Shape of Output: (1, 3)\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "error_wrt_weights_input_hidden.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "W2bu4H5-NFVz" - }, - "source": [ - "### Update the parameters" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "-nmJnY_PNFV1" - }, - "source": [ - "![alt text](https://drive.google.com/uc?id=1A5jaB3WjZx9yrJkk9imVEvP3PZodjapE)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "_r59xEpINFV2" - }, - "outputs": [], - "source": [ - "# defining the learning rate\n", - "lr = 0.01" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 69 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2341, - "status": "ok", - "timestamp": 1585485769472, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "aiBFNXd3NFV7", - "outputId": "a7362697-b6e0-41c1-8a5a-bb525ed22c3e" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.83244264],\n", - " [0.21233911],\n", - " [0.18182497]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tKf4Ji1-NFSV" + }, + "source": [ + "## 2. Define architecture of the model " ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# initial weights_hidden_output\n", - "weights_hidden_output" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 86 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1928, - "status": "ok", - "timestamp": 1585485769474, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "CuosFKUENFWB", - "outputId": "fa8986c3-9960-4985-b6ec-e7d9a51f16e1", - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.37454012, 0.95071431, 0.73199394],\n", - " [0.59865848, 0.15601864, 0.15599452],\n", - " [0.05808361, 0.86617615, 0.60111501],\n", - " [0.70807258, 0.02058449, 0.96990985]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "vlhBW0NNNFSg", + "colab": {} + }, + "source": [ + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer" + ], + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "OoOsLucmNFSo" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/model_architecture.png?raw=1)" ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# initial weights_input_hidden\n", - "weights_input_hidden" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "D_Va2xywNFWF" - }, - "outputs": [], - "source": [ - "# updating the weights of output layer\n", - "weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "ruFlc96BNFWL" - }, - "outputs": [], - "source": [ - "# updating the weights of hidden layer\n", - "weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 69 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1799, - "status": "ok", - "timestamp": 1585485770584, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "NTf4nS1xNFWP", - "outputId": "feb1e8da-cdff-4374-cf88-a66e1449ea05" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.83211079],\n", - " [0.21250681],\n", - " [0.18167831]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_Nmwj8RfNFSr" + }, + "source": [ + "## 3. Initialize the parameters\n", + "\n", + "NOTE: For simplicity, we are assuming that the bias for all the layers is 0" ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# updated weights_hidden_output\n", - "weights_hidden_output" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 86 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2866, - "status": "ok", - "timestamp": 1585485772036, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "7VYNPPNlNFWU", - "outputId": "ae17551f-c966-4124-9ad1-95f3a9e59fad" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.37476062, 0.95075719, 0.7320294 ],\n", - " [0.59845481, 0.15594177, 0.15594545],\n", - " [0.05816641, 0.86618978, 0.60112315],\n", - " [0.70795169, 0.02052126, 0.96986892]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "1T1IG-W8NFSu", + "colab": {} + }, + "source": [ + "# initializing weight\n", + "# Shape of weights_input_hidden should number of neurons at input layer * number of neurons at hidden layer\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "\n", + "# Shape of weights_hidden_output should number of neurons at hidden layer * number of neurons at output layer\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Fpa1--9KNFS1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "babbf8e8-90a5-49ff-a152-fa2dd2cc1eda" + }, + "source": [ + "# shape of weight matrix\n", + "weights_input_hidden.shape, weights_hidden_output.shape" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((4, 3), (3, 1))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 10 + } ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# updated weights_input_hidden\n", - "weights_input_hidden" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "SxLy6DZlNFWY" - }, - "source": [ - "## 6. Train the model for multiple epochs" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "8HKS9vIyNFWZ" - }, - "outputs": [], - "source": [ - "# defining the model architecture\n", - "inputLayer_neurons = X.shape[0] # number of features in data set\n", - "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", - "outputLayer_neurons = 1 # number of neurons at output layer\n", - "\n", - "# initializing weight\n", - "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", - "weights_hidden_output = np.random.uniform(\n", - " size=(hiddenLayer_neurons, outputLayer_neurons)\n", - ")\n", - "\n", - "# defining the parameters\n", - "lr = 0.1\n", - "epochs = 1000" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "_yVAcyW_NFWk" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error at epoch 0 is 0.11553\n", - "Error at epoch 100 is 0.11082\n", - "Error at epoch 200 is 0.10606\n", - "Error at epoch 300 is 0.09845\n", - "Error at epoch 400 is 0.08483\n", - "Error at epoch 500 is 0.06396\n", - "Error at epoch 600 is 0.04206\n", - "Error at epoch 700 is 0.02641\n", - "Error at epoch 800 is 0.01719\n", - "Error at epoch 900 is 0.01190\n" - ] - } - ], - "source": [ - "losses = []\n", - "for epoch in range(epochs):\n", - " ## Forward Propogation\n", - "\n", - " # calculating hidden layer activations\n", - " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", - " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", - "\n", - " # calculating the output\n", - " outputLayer_linearTransform = np.dot(\n", - " weights_hidden_output.T, hiddenLayer_activations\n", - " )\n", - " output = sigmoid(outputLayer_linearTransform)\n", - "\n", - " ## Backward Propagation\n", - "\n", - " # calculating error\n", - " error = np.square(y - output) / 2\n", - "\n", - " # calculating rate of change of error w.r.t weight between hidden and output layer\n", - " error_wrt_output = -(y - output)\n", - " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", - " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", - "\n", - " error_wrt_weights_hidden_output = np.dot(\n", - " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", - " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", - " )\n", - "\n", - " # calculating rate of change of error w.r.t weights between input and hidden layer\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", - " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", - " )\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", - " error_wrt_weights_input_hidden = np.dot(\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", - " (\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", - " * np.dot(\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", - " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", - " )\n", - " ).T,\n", - " )\n", - "\n", - " # updating the weights\n", - " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", - " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", - "\n", - " # print error at every 100th epoch\n", - " epoch_loss = np.average(error)\n", - " if epoch % 100 == 0:\n", - " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", - "\n", - " # appending the error of each epoch\n", - " losses.append(epoch_loss)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 86 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2409, - "status": "ok", - "timestamp": 1585485773423, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "Ra5mTgwUNFWo", - "outputId": "20de9dc0-62b7-4f07-fd3d-cf290542ac8f" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1.25679149, 1.72312858, -0.27336634],\n", - " [-1.07615756, -1.73777864, 1.42316207],\n", - " [ 0.63053865, 0.88090942, -0.03448117],\n", - " [-0.56098781, -0.65506704, 0.61013995]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "srrDW1MNNFS-" + }, + "source": [ + "## 4. Implement forward propagation" ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# updated w_ih\n", - "weights_input_hidden" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1.45176252],\n", - " [ 2.59109536],\n", - " [-2.18347501]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "sOcBji4iNFTE", + "colab": {} + }, + "source": [ + "# We are using sigmoid as an activation function so defining the sigmoid function here\n", + "\n", + "# defining the Sigmoid Function\n", + "def sigmoid(x):\n", + " return 1 / (1 + np.exp(-x))" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "-g-SocwQNFTC" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/hidden_layer_activations.png?raw=1)" ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# updated w_ho\n", - "weights_hidden_output" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 283 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 2186, - "status": "ok", - "timestamp": 1585485784562, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "WeN2dcc0NFW8", - "outputId": "59ab0369-88ea-4f52-87b4-99da23925bb9", - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "DO6AYHtGNFTM", + "colab": {} + }, + "source": [ + "# hidden layer activations\n", + "\n", + "hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)" + ], + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "o8zzYX6pNFTT" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1ETMoLD1fwi5u1HHLqtAdVUs-P8HNOU_p)" ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "

" + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "CuqKwiToNFTW", + "colab": {} + }, + "source": [ + "# calculating the output\n", + "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", + "output = sigmoid(outputLayer_linearTransform)" + ], + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "BjPlMkVMNFTd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "8a81d2de-a2f5-49c7-a6b5-bd65bd19cac3" + }, + "source": [ + "# output\n", + "output" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.68334694, 0.72697078, 0.71257368]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# visualizing the error after each epoch\n", - "plt.plot(np.arange(1, epochs + 1), np.array(losses))" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1949, - "status": "ok", - "timestamp": 1585485784571, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "bJlcGoeUNFXA", - "outputId": "052f7ac8-c10e-49e4-df8e-69bff60d4381" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.9155779 , 0.89643511, 0.18608711]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "mdFKMYyzNFTm" + }, + "source": [ + "## 5. Implement backward propagation" ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# final output from the model\n", - "output" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 34 - }, - "colab_type": "code", - "executionInfo": { - "elapsed": 1904, - "status": "ok", - "timestamp": 1585485785455, - "user": { - "displayName": "Pulkit Sharma", - "photoUrl": "", - "userId": "07234574884764057306" - }, - "user_tz": -330 - }, - "id": "ARNn3MiKNFXF", - "outputId": "eb1606ed-53da-48f8-c5a0-f4c459e71fdc" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1, 0]])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "c2m3XBgZNFTn" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/error.png?raw=1)" ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# actual target\n", - "y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.datasets import make_moons\n", - "\n", - "X, y = make_moons(n_samples=1000, random_state=42, noise=0.1)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "IvUAAhlcNFTp", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "ef34ba99-13be-41f7-b886-ccaf9b80d403" + }, + "source": [ + "# calculating error\n", + "error = np.square(y - output) / 2\n", + "error" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.05013458, 0.03727248, 0.25388062]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 15 + } ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "3H0vjBdNNFTw" + }, + "source": [ + "### Rate of change of error w.r.t weight between hidden and output layer" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(X[:, 0], X[:, 1], s=10, c=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.datasets import make_blobs\n", - "\n", - "X, y = make_blobs(n_samples=1000, centers=2, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "4cncCd1WNFTz" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/error_wrt_who.png?raw=1)" ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "DqrhlDeDNFT1" + }, + "source": [ + "**a. Rate of change of error w.r.t output**\n", + "\n", + "**b. Rate of change of output w.r.t Z2**\n", + "\n", + "**c. Rate of change of Z2 w.r.t weights between hidden and output layer**" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(X[:, 0], X[:, 1], s=10, c=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[-0.05146968, 0.44419863],\n", - " [ 1.03201691, -0.41974116],\n", - " [ 0.86789186, -0.25482711],\n", - " ...,\n", - " [ 1.68425911, -0.34822268],\n", - " [-0.9672013 , 0.26367208],\n", - " [ 0.78758971, 0.61660945]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "bKdk5m4FNFT3", + "colab": {} + }, + "source": [ + "# rate of change of error w.r.t. output\n", + "error_wrt_output = -(y - output)" + ], + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Bl1PDwrBNFT9", + "colab": {} + }, + "source": [ + "# rate of change of output w.r.t. Z2\n", + "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" + ], + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "3vLk1nxLNFUD", + "colab": {} + }, + "source": [ + "# rate of change of Z2 w.r.t. weights between hidden and output layer\n", + "outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations" + ], + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "UXXifY9QNFUI", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "525336f9-e81e-49ef-ac93-2d87baa7f29b" + }, + "source": [ + "# checking the shapes of partial derivatives\n", + "error_wrt_output.shape, output_wrt_outputLayer_LinearTransform.shape, outputLayer_LinearTransform_wrt_weights_hidden_output.shape" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((1, 3), (1, 3), (3, 3))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 19 + } ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "X -= X.min()\n", - "X /= X.max()" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 1.0)" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ZvtS7wCRNFUN", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "1eb93c65-713a-409d-cbc2-3f26ab201976" + }, + "source": [ + "# shape of weights of output layer\n", + "weights_hidden_output.shape" + ], + "execution_count": 20, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(3, 1)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 20 + } ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X.min(), X.max()" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1])" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gC9zQEH6HON5" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/error_wrt_who_matrix.png?raw=1)" ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.unique(y)" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((1000, 2), (1000,))" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "l3HNVYGONFUr", + "colab": {} + }, + "source": [ + "# rate of change of error w.r.t weight between hidden and output layer\n", + "error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + ")" + ], + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "cwyI1EGZNFUw", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "cd2a892b-4a5f-43eb-c543-3415ebd713bd" + }, + "source": [ + "error_wrt_weights_hidden_output.shape" + ], + "execution_count": 22, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(3, 1)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 22 + } ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X.shape, y.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [], - "source": [ - "X = X.T\n", - "\n", - "y = y.reshape(1, -1)" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((2, 1000), (1, 1000))" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sDFPg2SHNFU2" + }, + "source": [ + "### Rate of change of error w.r.t weight between input and hidden layer" ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X.shape, y.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error at epoch 0 is 0.23478\n", - "Error at epoch 1000 is 0.25000\n", - "Error at epoch 2000 is 0.25000\n", - "Error at epoch 3000 is 0.25000\n", - "Error at epoch 4000 is 0.05129\n", - "Error at epoch 5000 is 0.02163\n", - "Error at epoch 6000 is 0.01157\n", - "Error at epoch 7000 is 0.00775\n", - "Error at epoch 8000 is 0.00689\n", - "Error at epoch 9000 is 0.07556\n" - ] - } - ], - "source": [ - "# defining the model architecture\n", - "inputLayer_neurons = X.shape[0] # number of features in data set\n", - "hiddenLayer_neurons = 10 # number of hidden layers neurons\n", - "outputLayer_neurons = 1 # number of neurons at output layer\n", - "\n", - "# initializing weight\n", - "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", - "weights_hidden_output = np.random.uniform(\n", - " size=(hiddenLayer_neurons, outputLayer_neurons)\n", - ")\n", - "\n", - "# defining the parameters\n", - "lr = 0.1\n", - "epochs = 10000\n", - "\n", - "losses = []\n", - "for epoch in range(epochs):\n", - " ## Forward Propogation\n", - "\n", - " # calculating hidden layer activations\n", - " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", - " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", - "\n", - " # calculating the output\n", - " outputLayer_linearTransform = np.dot(\n", - " weights_hidden_output.T, hiddenLayer_activations\n", - " )\n", - " output = sigmoid(outputLayer_linearTransform)\n", - "\n", - " ## Backward Propagation\n", - "\n", - " # calculating error\n", - " error = np.square(y - output) / 2\n", - "\n", - " # calculating rate of change of error w.r.t weight between hidden and output layer\n", - " error_wrt_output = -(y - output)\n", - " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", - " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", - "\n", - " error_wrt_weights_hidden_output = np.dot(\n", - " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", - " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", - " )\n", - "\n", - " # calculating rate of change of error w.r.t weights between input and hidden layer\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", - " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", - " )\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", - " error_wrt_weights_input_hidden = np.dot(\n", - " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", - " (\n", - " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", - " * np.dot(\n", - " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", - " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", - " )\n", - " ).T,\n", - " )\n", - "\n", - " # updating the weights\n", - " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", - " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", - "\n", - " # print error at every 100th epoch\n", - " epoch_loss = np.average(error)\n", - " if epoch % 1000 == 0:\n", - " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", - "\n", - " # appending the error of each epoch\n", - " losses.append(epoch_loss)" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_757MrjBNFU2" + }, + "source": [ + "![alt text](https://github.com/faizankshaikh/AV_Article_Codes/blob/master/NN_From_Scratch/improvements/images/error_wrt_wih.png?raw=1)" ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_nPYGXkeNFU4" + }, + "source": [ + "**a. Rate of change of error w.r.t output**\n", + "\n", + "**b. Rate of change of output w.r.t Z2**\n", + "\n", + "**c. Rate of change of Z2 w.r.t hidden layer activations**\n", + "\n", + "**d. Rate of change of hidden layer activations w.r.t Z1**\n", + "\n", + "**e. Rate of change of Z1 w.r.t weights between input and hidden layer**" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# visualizing the error after each epoch\n", - "plt.plot(np.arange(1, epochs + 1), np.array(losses))" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[9.64860989e-01, 9.98678150e-01, 9.94656205e-01, 9.99198418e-01,\n", - " 2.17566533e-07]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Sb7Ezxw9NFU6", + "colab": {} + }, + "source": [ + "# rate of change of error w.r.t. output\n", + "error_wrt_output = -(y - output)" + ], + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "3-SGbNaoNFVA", + "colab": {} + }, + "source": [ + "# rate of change of output w.r.t. Z2\n", + "output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))" + ], + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "amuoR7h6NFVF", + "colab": {} + }, + "source": [ + "# rate of change of Z2 w.r.t. hidden layer activations\n", + "outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output" + ], + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "YDUZEdWKNFVJ", + "colab": {} + }, + "source": [ + "# rate of change of hidden layer activations w.r.t. Z1\n", + "hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + ")" + ], + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Ft4U6Td6NFVO", + "colab": {} + }, + "source": [ + "# rate of change of Z1 w.r.t. weights between input and hidden layer\n", + "hiddenLayer_linearTransform_wrt_weights_input_hidden = X" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "A-hsfsi4NFVR", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "346c0c6a-5113-4f2b-eddb-cd0f48b02862" + }, + "source": [ + "# checking the shapes of partial derivatives\n", + "print(\n", + " error_wrt_output.shape,\n", + " output_wrt_outputLayer_LinearTransform.shape,\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations.shape,\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform.shape,\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden.shape,\n", + ")" + ], + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(1, 3) (1, 3) (3, 1) (3, 3) (4, 3)\n" + ], + "name": "stdout" + } ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# final output from the model\n", - "output[:, :5]" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 1, 1, 1, 0]])" + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "1uka_yPrNFVV", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "0610b524-50cf-4d26-af18-0d11d5eeb5dd" + }, + "source": [ + "# shape of weights of hidden layer\n", + "weights_input_hidden.shape" + ], + "execution_count": 29, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(4, 3)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 29 + } ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y[:, :5]" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gCeSm7vrHbHj" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1RkG5x1NEFWlF3tj0OlswOWvBcV5XNV1C)" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "XTPNf3E5NFVs", + "colab": {} + }, + "source": [ + "# rate of change of error w.r.t weights between input and hidden layer\n", + "error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + ")" + ], + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "_WN0I-mpNFVw", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "2f2c1dbe-52ba-47db-f2df-5e39d42aea9f" + }, + "source": [ + "error_wrt_weights_input_hidden.shape" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(4, 3)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 31 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "W2bu4H5-NFVz" + }, + "source": [ + "### Update the parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "-nmJnY_PNFV1" + }, + "source": [ + "![alt text](https://drive.google.com/uc?id=1A5jaB3WjZx9yrJkk9imVEvP3PZodjapE)" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "_r59xEpINFV2", + "colab": {} + }, + "source": [ + "# defining the learning rate\n", + "lr = 0.01" + ], + "execution_count": 32, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "aiBFNXd3NFV7", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "outputId": "07b26520-3e50-423e-a218-80a68a875a9f" + }, + "source": [ + "# initial weights_hidden_output\n", + "weights_hidden_output" + ], + "execution_count": 33, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.83244264],\n", + " [0.21233911],\n", + " [0.18182497]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "CuosFKUENFWB", + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "outputId": "b127e2f5-4d08-4d23-9f5f-aaf9971bc0af" + }, + "source": [ + "# initial weights_input_hidden\n", + "weights_input_hidden" + ], + "execution_count": 34, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.37454012, 0.95071431, 0.73199394],\n", + " [0.59865848, 0.15601864, 0.15599452],\n", + " [0.05808361, 0.86617615, 0.60111501],\n", + " [0.70807258, 0.02058449, 0.96990985]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "D_Va2xywNFWF", + "colab": {} + }, + "source": [ + "# updating the weights of output layer\n", + "weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output" + ], + "execution_count": 35, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ruFlc96BNFWL", + "colab": {} + }, + "source": [ + "# updating the weights of hidden layer\n", + "weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden" + ], + "execution_count": 36, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "NTf4nS1xNFWP", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "outputId": "34890c4b-e441-4aa6-ce00-0b6b04a3a31d" + }, + "source": [ + "# updated weights_hidden_output\n", + "weights_hidden_output" + ], + "execution_count": 37, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.83211079],\n", + " [0.21250681],\n", + " [0.18167831]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "7VYNPPNlNFWU", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "outputId": "bd6bc8eb-4570-4a6f-ff28-347f99db88d6" + }, + "source": [ + "# updated weights_input_hidden\n", + "weights_input_hidden" + ], + "execution_count": 38, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.37476062, 0.95075719, 0.7320294 ],\n", + " [0.59845481, 0.15594177, 0.15594545],\n", + " [0.05816641, 0.86618978, 0.60112315],\n", + " [0.70795169, 0.02052126, 0.96986892]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "SxLy6DZlNFWY" + }, + "source": [ + "## 6. Train the model for multiple epochs" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "8HKS9vIyNFWZ", + "colab": {} + }, + "source": [ + "# defining the model architecture\n", + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 3 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer\n", + "\n", + "# initializing weight\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")\n", + "\n", + "# defining the parameters\n", + "lr = 0.1\n", + "epochs = 1000" + ], + "execution_count": 39, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "_yVAcyW_NFWk", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 191 + }, + "outputId": "9e5d717f-e053-43c2-8da6-c2e437ed65de" + }, + "source": [ + "losses = []\n", + "for epoch in range(epochs):\n", + " ## Forward Propogation\n", + "\n", + " # calculating hidden layer activations\n", + " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "\n", + " # calculating the output\n", + " outputLayer_linearTransform = np.dot(\n", + " weights_hidden_output.T, hiddenLayer_activations\n", + " )\n", + " output = sigmoid(outputLayer_linearTransform)\n", + "\n", + " ## Backward Propagation\n", + "\n", + " # calculating error\n", + " error = np.square(y - output) / 2\n", + "\n", + " # calculating rate of change of error w.r.t weight between hidden and output layer\n", + " error_wrt_output = -(y - output)\n", + " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", + "\n", + " error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + " )\n", + "\n", + " # calculating rate of change of error w.r.t weights between input and hidden layer\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + " )\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", + " error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + " )\n", + "\n", + " # updating the weights\n", + " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", + " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", + "\n", + " # print error at every 100th epoch\n", + " epoch_loss = np.average(error)\n", + " if epoch % 100 == 0:\n", + " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", + "\n", + " # appending the error of each epoch\n", + " losses.append(epoch_loss)" + ], + "execution_count": 40, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Error at epoch 0 is 0.11553\n", + "Error at epoch 100 is 0.11082\n", + "Error at epoch 200 is 0.10606\n", + "Error at epoch 300 is 0.09845\n", + "Error at epoch 400 is 0.08483\n", + "Error at epoch 500 is 0.06396\n", + "Error at epoch 600 is 0.04206\n", + "Error at epoch 700 is 0.02641\n", + "Error at epoch 800 is 0.01719\n", + "Error at epoch 900 is 0.01190\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "Ra5mTgwUNFWo", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "outputId": "a7d314be-c563-4218-a191-40f0e5992773" + }, + "source": [ + "# updated w_ih\n", + "weights_input_hidden" + ], + "execution_count": 41, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1.25679149, 1.72312858, -0.27336634],\n", + " [-1.07615756, -1.73777864, 1.42316207],\n", + " [ 0.63053865, 0.88090942, -0.03448117],\n", + " [-0.56098781, -0.65506704, 0.61013995]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ncRRRhdirair", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "outputId": "17bef20e-894f-414e-ba0e-895f35f7d21e" + }, + "source": [ + "# updated w_ho\n", + "weights_hidden_output" + ], + "execution_count": 42, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1.45176252],\n", + " [ 2.59109536],\n", + " [-2.18347501]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 42 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "WeN2dcc0NFW8", + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 285 + }, + "outputId": "36c2519b-7b61-440f-99b1-8c476ba90415" + }, + "source": [ + "# visualizing the error after each epoch\n", + "plt.plot(np.arange(1, epochs + 1), np.array(losses))" + ], + "execution_count": 43, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 43 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "bJlcGoeUNFXA", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "373881a8-db77-479b-dada-8cd2e47ef88e" + }, + "source": [ + "# final output from the model\n", + "output" + ], + "execution_count": 44, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.9155779 , 0.89643511, 0.18608711]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 44 + } ] - }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "metadata": { + "colab_type": "code", + "id": "ARNn3MiKNFXF", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "d0b245bf-9b23-4cad-aa6b-d1924ed3e821" + }, + "source": [ + "# actual target\n", + "y" + ], + "execution_count": 45, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1, 1, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 45 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kImrrAcsrai0", + "colab_type": "text" + }, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "fSkVIPP-rai2", + "colab_type": "code", + "colab": {} + }, + "source": [ + "from sklearn.datasets import make_moons\n", + "\n", + "X, y = make_moons(n_samples=1000, random_state=42, noise=0.1)" + ], + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "UaFOpfTYrai4", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "4a1c76ab-c6b0-4b3e-a0ed-50760593cd9b" + }, + "source": [ + "plt.scatter(X[:, 0], X[:, 1], s=10, c=y)" + ], + "execution_count": 47, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 47 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "14xxesCSrai_", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 139 + }, + "outputId": "e442cd91-c463-47f5-e53c-5aa78aa6ab8d" + }, + "source": [ + "X" + ], + "execution_count": 48, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-0.05146968, 0.44419863],\n", + " [ 1.03201691, -0.41974116],\n", + " [ 0.86789186, -0.25482711],\n", + " ...,\n", + " [ 1.68425911, -0.34822268],\n", + " [-0.9672013 , 0.26367208],\n", + " [ 0.78758971, 0.61660945]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 48 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CYPqOhoNrajC", + "colab_type": "code", + "colab": {} + }, + "source": [ + "X -= X.min()\n", + "X /= X.max()" + ], + "execution_count": 49, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "5mFbA4YWrajE", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "3315cc0c-1fe5-4b5c-d847-168d9ba8bb28" + }, + "source": [ + "X.min(), X.max()" + ], + "execution_count": 50, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(0.0, 1.0)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7jA_Og4FrajG", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "576c1857-174c-4f9a-aff1-d1f4f25ca8da" + }, + "source": [ + "np.unique(y)" + ], + "execution_count": 51, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([0, 1])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 51 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rUF7MVdPrajI", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "f020dda6-5742-4554-d2da-b08175db0e82" + }, + "source": [ + "X.shape, y.shape" + ], + "execution_count": 52, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((1000, 2), (1000,))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 52 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dOWg-GBOrajK", + "colab_type": "code", + "colab": {} + }, + "source": [ + "X = X.T\n", + "\n", + "y = y.reshape(1, -1)" + ], + "execution_count": 53, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "W8sP8ri4rajL", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "fd7086cd-0db4-4319-d61c-a0d2b7fd5dac" + }, + "source": [ + "X.shape, y.shape" + ], + "execution_count": 54, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((2, 1000), (1, 1000))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 54 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "reJ-8MUIrajN", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 191 + }, + "outputId": "f0473754-d6de-4b63-b2ba-007c1d0faa29" + }, + "source": [ + "# defining the model architecture\n", + "inputLayer_neurons = X.shape[0] # number of features in data set\n", + "hiddenLayer_neurons = 10 # number of hidden layers neurons\n", + "outputLayer_neurons = 1 # number of neurons at output layer\n", + "\n", + "# initializing weight\n", + "weights_input_hidden = np.random.uniform(size=(inputLayer_neurons, hiddenLayer_neurons))\n", + "weights_hidden_output = np.random.uniform(\n", + " size=(hiddenLayer_neurons, outputLayer_neurons)\n", + ")\n", + "\n", + "# defining the parameters\n", + "lr = 0.1\n", + "epochs = 10000\n", + "\n", + "losses = []\n", + "for epoch in range(epochs):\n", + " ## Forward Propogation\n", + "\n", + " # calculating hidden layer activations\n", + " hiddenLayer_linearTransform = np.dot(weights_input_hidden.T, X)\n", + " hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "\n", + " # calculating the output\n", + " outputLayer_linearTransform = np.dot(\n", + " weights_hidden_output.T, hiddenLayer_activations\n", + " )\n", + " output = sigmoid(outputLayer_linearTransform)\n", + "\n", + " ## Backward Propagation\n", + "\n", + " # calculating error\n", + " error = np.square(y - output) / 2\n", + "\n", + " # calculating rate of change of error w.r.t weight between hidden and output layer\n", + " error_wrt_output = -(y - output)\n", + " output_wrt_outputLayer_LinearTransform = np.multiply(output, (1 - output))\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output = hiddenLayer_activations\n", + "\n", + " error_wrt_weights_hidden_output = np.dot(\n", + " outputLayer_LinearTransform_wrt_weights_hidden_output,\n", + " (error_wrt_output * output_wrt_outputLayer_LinearTransform).T,\n", + " )\n", + "\n", + " # calculating rate of change of error w.r.t weights between input and hidden layer\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations = weights_hidden_output\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform = np.multiply(\n", + " hiddenLayer_activations, (1 - hiddenLayer_activations)\n", + " )\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden = X\n", + " error_wrt_weights_input_hidden = np.dot(\n", + " hiddenLayer_linearTransform_wrt_weights_input_hidden,\n", + " (\n", + " hiddenLayer_activations_wrt_hiddenLayer_linearTransform\n", + " * np.dot(\n", + " outputLayer_LinearTransform_wrt_hiddenLayer_activations,\n", + " (output_wrt_outputLayer_LinearTransform * error_wrt_output),\n", + " )\n", + " ).T,\n", + " )\n", + "\n", + " # updating the weights\n", + " weights_hidden_output = weights_hidden_output - lr * error_wrt_weights_hidden_output\n", + " weights_input_hidden = weights_input_hidden - lr * error_wrt_weights_input_hidden\n", + "\n", + " # print error at every 100th epoch\n", + " epoch_loss = np.average(error)\n", + " if epoch % 1000 == 0:\n", + " print(f\"Error at epoch {epoch} is {epoch_loss:.5f}\")\n", + "\n", + " # appending the error of each epoch\n", + " losses.append(epoch_loss)" + ], + "execution_count": 55, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Error at epoch 0 is 0.23478\n", + "Error at epoch 1000 is 0.25000\n", + "Error at epoch 2000 is 0.25000\n", + "Error at epoch 3000 is 0.25000\n", + "Error at epoch 4000 is 0.05129\n", + "Error at epoch 5000 is 0.02163\n", + "Error at epoch 6000 is 0.01157\n", + "Error at epoch 7000 is 0.00745\n", + "Error at epoch 8000 is 0.00713\n", + "Error at epoch 9000 is 0.00642\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0PRn6H5YrajQ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "1c35deee-e83f-4a7c-9744-364cb677275d" + }, + "source": [ + "# visualizing the error after each epoch\n", + "plt.plot(np.arange(1, epochs + 1), np.array(losses))" + ], + "execution_count": 56, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 56 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3q1DUTKirajR", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "0b5fc5bd-aa86-4f36-90a9-44ff0f2a1999" + }, + "source": [ + "# final output from the model\n", + "output[:, :5]" + ], + "execution_count": 57, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[9.64781360e-01, 9.98834309e-01, 9.95018421e-01, 9.99193286e-01,\n", + " 9.11292450e-08]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 57 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Twysplz1rajU", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "955bc224-910d-41b1-e238-54411ed31888" + }, + "source": [ + "y[:, :5]" + ], + "execution_count": 58, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1, 1, 1, 1, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 58 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5qFlH9xbrajV", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "88e6f398-4b07-4f7a-fa53-6b5a259ce5bb" + }, + "source": [ + "# Define region of interest by data limits\n", + "steps = 1000\n", + "x_span = np.linspace(X[0, :].min(), X[0, :].max(), steps)\n", + "y_span = np.linspace(X[1, :].min(), X[1, :].max(), steps)\n", + "xx, yy = np.meshgrid(x_span, y_span)\n", + "\n", + "# forward pass for region of interest\n", + "hiddenLayer_linearTransform = np.dot(\n", + " weights_input_hidden.T, np.c_[xx.ravel(), yy.ravel()].T\n", + ")\n", + "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", + "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", + "output_span = sigmoid(outputLayer_linearTransform)\n", + "\n", + "# Make predictions across region of interest\n", + "labels = (output_span > 0.5).astype(int)\n", + "\n", + "# Plot decision boundary in region of interest\n", + "z = labels.reshape(xx.shape)\n", + "fig, ax = plt.subplots()\n", + "ax.contourf(xx, yy, z, alpha=0.2)\n", + "\n", + "# Get predicted labels on training data and plot\n", + "train_labels = (output > 0.5).astype(int)\n", + "\n", + "# create scatter plot\n", + "ax.scatter(X[0, :], X[1, :], s=10, c=y.squeeze())" + ], + "execution_count": 59, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 59 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } - ], - "source": [ - "# Define region of interest by data limits\n", - "steps = 1000\n", - "x_span = np.linspace(X[0, :].min(), X[0, :].max(), steps)\n", - "y_span = np.linspace(X[1, :].min(), X[1, :].max(), steps)\n", - "xx, yy = np.meshgrid(x_span, y_span)\n", - "\n", - "# forward pass for region of interest\n", - "hiddenLayer_linearTransform = np.dot(\n", - " weights_input_hidden.T, np.c_[xx.ravel(), yy.ravel()].T\n", - ")\n", - "hiddenLayer_activations = sigmoid(hiddenLayer_linearTransform)\n", - "outputLayer_linearTransform = np.dot(weights_hidden_output.T, hiddenLayer_activations)\n", - "output_span = sigmoid(outputLayer_linearTransform)\n", - "\n", - "# Make predictions across region of interest\n", - "labels = (output_span > 0.5).astype(int)\n", - "\n", - "# Plot decision boundary in region of interest\n", - "z = labels.reshape(xx.shape)\n", - "fig, ax = plt.subplots()\n", - "ax.contourf(xx, yy, z, alpha=0.2)\n", - "\n", - "# Get predicted labels on training data and plot\n", - "train_labels = (output > 0.5).astype(int)\n", - "\n", - "# create scatter plot\n", - "ax.scatter(X[0, :], X[1, :], s=10, c=y.squeeze())" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [], - "name": "Neural Network from scratch using NumPy.ipynb", - "provenance": [] - }, - "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 -} + ] +} \ No newline at end of file From 8e90832773ce7bda66205e084c1a07f48c67fd11 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Wed, 9 Sep 2020 17:04:02 +0530 Subject: [PATCH 14/17] add article unsupervised DL --- .../Unsupervised_Deep_Learning.ipynb | 1150 +++++++++++++++++ 1 file changed, 1150 insertions(+) create mode 100644 Unsupervised_Deep_Learning/original_code/Unsupervised_Deep_Learning.ipynb diff --git a/Unsupervised_Deep_Learning/original_code/Unsupervised_Deep_Learning.ipynb b/Unsupervised_Deep_Learning/original_code/Unsupervised_Deep_Learning.ipynb new file mode 100644 index 0000000..6f52d86 --- /dev/null +++ b/Unsupervised_Deep_Learning/original_code/Unsupervised_Deep_Learning.ipynb @@ -0,0 +1,1150 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "\n", + "import os\n", + "import keras\n", + "import metrics\n", + "import pandas as pd\n", + "import keras.backend as K\n", + "\n", + "from time import time\n", + "\n", + "from keras import callbacks\n", + "from keras.models import Model\n", + "from keras.optimizers import SGD\n", + "from keras.layers import Dense, Input\n", + "from keras.initializers import VarianceScaling\n", + "from keras.engine.topology import Layer, InputSpec\n", + "\n", + "from imageio import imread\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.metrics import accuracy_score, normalized_mutual_info_score" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# To stop potential randomness\n", + "seed = 128\n", + "rng = np.random.RandomState(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = os.path.abspath('.')\n", + "data_dir = os.path.join(root_dir, 'data', 'MNIST')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "train = pd.read_csv(os.path.join(data_dir, 'train.csv'))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
filenamelabel
00.png4
11.png9
22.png1
33.png7
44.png3
\n", + "
" + ], + "text/plain": [ + " filename label\n", + "0 0.png 4\n", + "1 1.png 9\n", + "2 2.png 1\n", + "3 3.png 7\n", + "4 4.png 3" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAFGUlEQVR4nO3dsUvUfxzHcb8RCIrQkkuD60FT6w02lbi6NGhgENgkKP4JBTYK1Rgt3mIEghxuLre3RJN/gIsOBk3Ct+k3CPf9FHe/b74uH4/x3tz3c8vTN/Thuqqu6ykgz52b/gDAcOKEUOKEUOKEUOKEUHdLw6qq/FMutKyu62rY6zYnhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhBInhLp70x+AyXHnTvlv+YcPH4rzjY2N4vzr16+Ns8ePHxff++PHj+J8EtmcEEqcEEqcEEqcEEqcEEqcEEqcEKqq67p5WFXNQ26dZ8+eFee9Xq+1sx88eFCcn52dtXZ22+q6roa9bnNCKHFCKHFCKHFCKHFCKHFCKF8Z45qHDx82zvb29v7iJ8HmhFDihFDihFDihFDihFDihFDihFDuOW+Z6enp4nxzc7Nxdv/+/bHO/vnzZ3H+5s2bxtnl5eVYZ08imxNCiRNCiRNCiRNCiRNCiRNCiRNCuee8Zd6+fVucv3z5srWzP378WJzv7u62dvYksjkhlDghlDghlDghlDghlDghlDghlJ8A/Md0Op3i/OTkpDifn58f+ex+v1+cr66uFue38TubU1N+AhAmjjghlDghlDghlDghlDghlDghlO9zTpiZmZnifGdnpzgf5x7zd/eQW1tbY72f62xOCCVOCCVOCCVOCCVOCCVOCOUqZcIsLS0V5y9evBjr+aXrjvX19eJ7T09Pxzqb62xOCCVOCCVOCCVOCCVOCCVOCCVOCOWeM8zs7Gxxvr293er5g8GgcXZ4eNjq2Vxnc0IocUIocUIocUIocUIocUIocUIo95xhnj59Wpx3u91Wz9/f32/1+fw5mxNCiRNCiRNCiRNCiRNCiRNCiRNCuecM8/z581aff3BwUJz3+/1Wz+fP2ZwQSpwQSpwQSpwQSpwQSpwQSpwQyj3nDSj9xubi4uJYz764uCjOX79+XZyXfp+Tv8vmhFDihFDihFDihFDihFDihFCuUlqwsLBQnPd6vcbZvXv3xjr78+fPxfm3b9/Gej5/j80JocQJocQJocQJocQJocQJocQJodxztuDRo0fF+Th3mefn58X5+/fvR342WWxOCCVOCCVOCCVOCCVOCCVOCCVOCOWecwTLy8vF+adPn1o7+8uXL8W572v+O2xOCCVOCCVOCCVOCCVOCCVOCCVOCOWecwQrKyvF+dzc3MjP/t33Nd+9ezfys5ksNieEEieEEieEEieEEieEEieEcpUyxOzsbHHe6XRaO9tXwviPzQmhxAmhxAmhxAmhxAmhxAmhxAmh3HMO8eTJk+K82+22dvbx8XFrz2ay2JwQSpwQSpwQSpwQSpwQSpwQSpwQyj3nEL+75xzX9+/fG2dHR0etns3ksDkhlDghlDghlDghlDghlDghlDghlHvOIQaDQXH+6tWr4vzi4qI4X1tba5xdXV0V38vtYXNCKHFCKHFCKHFCKHFCKHFCKHFCqKqu6+ZhVTUPgf9FXdfVsNdtTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTgglTghV/K8xgZtjc0IocUIocUIocUIocUIocUKoXwSMpFp0B0DXAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "img_name = rng.choice(train.filename)\n", + "filepath = os.path.join(data_dir, 'images', img_name)\n", + "\n", + "img = imread(filepath, as_gray=True)\n", + "\n", + "pylab.imshow(img, cmap='gray')\n", + "pylab.axis('off')\n", + "pylab.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28, 28)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "temp = []\n", + "for img_name in train.filename:\n", + " image_path = os.path.join(data_dir, 'images', img_name)\n", + " img = imread(image_path, as_gray=True)\n", + " img = img.astype('float32')\n", + " temp.append(img)\n", + " \n", + "train_x = np.stack(temp)\n", + "\n", + "train_x /= 255.0\n", + "train_x = train_x.reshape(-1, 784).astype('float32')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "train_y = train.label.values" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "split_size = int(train_x.shape[0]*0.7)\n", + "\n", + "train_x, val_x = train_x[:split_size], train_x[split_size:]\n", + "train_y, val_y = train_y[:split_size], train_y[split_size:]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "km = KMeans(n_jobs=-1, n_clusters=10, n_init=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,\n", + " n_clusters=10, n_init=20, n_jobs=-1, precompute_distances='auto',\n", + " random_state=None, tol=0.0001, verbose=0)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "km.fit(train_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "pred = km.predict(val_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "0.49702246628189856" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "normalized_mutual_info_score(val_y, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/jalfaizy/miniconda3/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "If using Keras pass *_constraint arguments to layers.\n" + ] + } + ], + "source": [ + "# this is our input placeholder\n", + "input_img = Input(shape=(784,))\n", + "\n", + "# \"encoded\" is the encoded representation of the input\n", + "encoded = Dense(500, activation='relu')(input_img)\n", + "encoded = Dense(500, activation='relu')(encoded)\n", + "encoded = Dense(2000, activation='relu')(encoded)\n", + "encoded = Dense(10, activation='sigmoid')(encoded)\n", + "\n", + "# \"decoded\" is the lossy reconstruction of the input\n", + "decoded = Dense(2000, activation='relu')(encoded)\n", + "decoded = Dense(500, activation='relu')(decoded)\n", + "decoded = Dense(500, activation='relu')(decoded)\n", + "decoded = Dense(784)(decoded)\n", + "\n", + "# this model maps an input to its reconstruction\n", + "autoencoder = Model(input_img, decoded)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_1 (InputLayer) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 500) 392500 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 500) 250500 \n", + "_________________________________________________________________\n", + "dense_3 (Dense) (None, 2000) 1002000 \n", + "_________________________________________________________________\n", + "dense_4 (Dense) (None, 10) 20010 \n", + "_________________________________________________________________\n", + "dense_5 (Dense) (None, 2000) 22000 \n", + "_________________________________________________________________\n", + "dense_6 (Dense) (None, 500) 1000500 \n", + "_________________________________________________________________\n", + "dense_7 (Dense) (None, 500) 250500 \n", + "_________________________________________________________________\n", + "dense_8 (Dense) (None, 784) 392784 \n", + "=================================================================\n", + "Total params: 3,330,794\n", + "Trainable params: 3,330,794\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "autoencoder.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# this model maps an input to its encoded representation\n", + "encoder = Model(input_img, encoded)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "autoencoder.compile(optimizer='adam', loss='mse')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 34300 samples, validate on 14700 samples\n", + "Epoch 1/10\n", + "34300/34300 [==============================] - 4s 115us/step - loss: 0.0298 - val_loss: 0.0299\n", + "Epoch 2/10\n", + "34300/34300 [==============================] - 4s 121us/step - loss: 0.0291 - val_loss: 0.0285\n", + "Epoch 3/10\n", + "34300/34300 [==============================] - 4s 123us/step - loss: 0.0279 - val_loss: 0.0280\n", + "Epoch 4/10\n", + "34300/34300 [==============================] - 4s 121us/step - loss: 0.0276 - val_loss: 0.0269\n", + "Epoch 5/10\n", + "34300/34300 [==============================] - 4s 125us/step - loss: 0.0262 - val_loss: 0.0259\n", + "Epoch 6/10\n", + "34300/34300 [==============================] - 4s 128us/step - loss: 0.0258 - val_loss: 0.0261\n", + "Epoch 7/10\n", + "34300/34300 [==============================] - 5s 149us/step - loss: 0.0250 - val_loss: 0.0248\n", + "Epoch 8/10\n", + "34300/34300 [==============================] - 5s 150us/step - loss: 0.0241 - val_loss: 0.0240\n", + "Epoch 9/10\n", + "34300/34300 [==============================] - 5s 151us/step - loss: 0.0237 - val_loss: 0.0237\n", + "Epoch 10/10\n", + "34300/34300 [==============================] - 5s 150us/step - loss: 0.0231 - val_loss: 0.0231\n" + ] + } + ], + "source": [ + "train_history = autoencoder.fit(train_x, train_x, epochs=100, batch_size=2048, validation_data=(val_x, val_x))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "pred_auto_train = encoder.predict(train_x)\n", + "pred_auto = encoder.predict(val_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "km.fit(pred_auto_train)\n", + "pred = km.predict(pred_auto)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "0.515053669179042" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "normalized_mutual_info_score(val_y, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "...Pretraining...\n", + "Epoch 1/10\n", + "34300/34300 [==============================] - 4s 111us/step - loss: 0.0820\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.1797, nmi: 0.0931 <==|\n", + "Epoch 2/10\n", + "34300/34300 [==============================] - 4s 109us/step - loss: 0.0644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.1902, nmi: 0.0989 <==|\n", + "Epoch 3/10\n", + "34300/34300 [==============================] - 5s 149us/step - loss: 0.0636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.1793, nmi: 0.0866 <==|\n", + "Epoch 4/10\n", + "34300/34300 [==============================] - 4s 127us/step - loss: 0.0634\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.2209, nmi: 0.1235 <==|\n", + "Epoch 5/10\n", + "34300/34300 [==============================] - 4s 115us/step - loss: 0.0612\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.2748, nmi: 0.2046 <==|\n", + "Epoch 6/10\n", + "34300/34300 [==============================] - 4s 120us/step - loss: 0.0571\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.4195, nmi: 0.3639 <==|\n", + "Epoch 7/10\n", + "34300/34300 [==============================] - 5s 154us/step - loss: 0.0519\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.4277, nmi: 0.3654 <==|\n", + "Epoch 8/10\n", + "34300/34300 [==============================] - 5s 157us/step - loss: 0.0480\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.5260, nmi: 0.4316 <==|\n", + "Epoch 9/10\n", + "34300/34300 [==============================] - 5s 153us/step - loss: 0.0428\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.4294, nmi: 0.4324 <==|\n", + "Epoch 10/10\n", + "34300/34300 [==============================] - 4s 114us/step - loss: 0.0380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " |==> acc: 0.5455, nmi: 0.4648 <==|\n", + "Pretraining time: 110.16003656387329\n", + "Pretrained weights are saved to results/ae_weights.h5\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "Keras implementation for Deep Embedded Clustering (DEC) algorithm:\n", + "\n", + "Original Author:\n", + " Xifeng Guo. 2017.1.30\n", + "\"\"\"\n", + "\n", + "\n", + "def autoencoder(dims, act='relu', init='glorot_uniform'):\n", + " \"\"\"\n", + " Fully connected auto-encoder model, symmetric.\n", + " Arguments:\n", + " dims: list of number of units in each layer of encoder. dims[0] is input dim, dims[-1] is units in hidden layer.\n", + " The decoder is symmetric with encoder. So number of layers of the auto-encoder is 2*len(dims)-1\n", + " act: activation, not applied to Input, Hidden and Output layers\n", + " return:\n", + " (ae_model, encoder_model), Model of autoencoder and model of encoder\n", + " \"\"\"\n", + " n_stacks = len(dims) - 1\n", + " # input\n", + " x = Input(shape=(dims[0],), name='input')\n", + " h = x\n", + "\n", + " # internal layers in encoder\n", + " for i in range(n_stacks-1):\n", + " h = Dense(dims[i + 1], activation=act, kernel_initializer=init, name='encoder_%d' % i)(h)\n", + "\n", + " # hidden layer\n", + " h = Dense(dims[-1], kernel_initializer=init, name='encoder_%d' % (n_stacks - 1))(h) # hidden layer, features are extracted from here\n", + "\n", + " y = h\n", + " # internal layers in decoder\n", + " for i in range(n_stacks-1, 0, -1):\n", + " y = Dense(dims[i], activation=act, kernel_initializer=init, name='decoder_%d' % i)(y)\n", + "\n", + " # output\n", + " y = Dense(dims[0], kernel_initializer=init, name='decoder_0')(y)\n", + "\n", + " return Model(inputs=x, outputs=y, name='AE'), Model(inputs=x, outputs=h, name='encoder')\n", + "\n", + "\n", + "class ClusteringLayer(Layer):\n", + " \"\"\"\n", + " Clustering layer converts input sample (feature) to soft label, i.e. a vector that represents the probability of the\n", + " sample belonging to each cluster. The probability is calculated with student's t-distribution.\n", + "\n", + " # Example\n", + " ```\n", + " model.add(ClusteringLayer(n_clusters=10))\n", + " ```\n", + " # Arguments\n", + " n_clusters: number of clusters.\n", + " weights: list of Numpy array with shape `(n_clusters, n_features)` witch represents the initial cluster centers.\n", + " alpha: parameter in Student's t-distribution. Default to 1.0.\n", + " # Input shape\n", + " 2D tensor with shape: `(n_samples, n_features)`.\n", + " # Output shape\n", + " 2D tensor with shape: `(n_samples, n_clusters)`.\n", + " \"\"\"\n", + "\n", + " def __init__(self, n_clusters, weights=None, alpha=1.0, **kwargs):\n", + " if 'input_shape' not in kwargs and 'input_dim' in kwargs:\n", + " kwargs['input_shape'] = (kwargs.pop('input_dim'),)\n", + " super(ClusteringLayer, self).__init__(**kwargs)\n", + " self.n_clusters = n_clusters\n", + " self.alpha = alpha\n", + " self.initial_weights = weights\n", + " self.input_spec = InputSpec(ndim=2)\n", + "\n", + " def build(self, input_shape):\n", + " assert len(input_shape) == 2\n", + " input_dim = input_shape[1]\n", + " self.input_spec = InputSpec(dtype=K.floatx(), shape=(None, input_dim))\n", + " self.clusters = self.add_weight(shape=(self.n_clusters, input_dim), initializer='glorot_uniform', name='clusters')\n", + " if self.initial_weights is not None:\n", + " self.set_weights(self.initial_weights)\n", + " del self.initial_weights\n", + " self.built = True\n", + "\n", + " def call(self, inputs, **kwargs):\n", + " \"\"\" student t-distribution, as same as used in t-SNE algorithm.\n", + " q_ij = 1/(1+dist(x_i, u_j)^2), then normalize it.\n", + " Arguments:\n", + " inputs: the variable containing data, shape=(n_samples, n_features)\n", + " Return:\n", + " q: student's t-distribution, or soft labels for each sample. shape=(n_samples, n_clusters)\n", + " \"\"\"\n", + " q = 1.0 / (1.0 + (K.sum(K.square(K.expand_dims(inputs, axis=1) - self.clusters), axis=2) / self.alpha))\n", + " q **= (self.alpha + 1.0) / 2.0\n", + " q = K.transpose(K.transpose(q) / K.sum(q, axis=1))\n", + " return q\n", + "\n", + " def compute_output_shape(self, input_shape):\n", + " assert input_shape and len(input_shape) == 2\n", + " return input_shape[0], self.n_clusters\n", + "\n", + " def get_config(self):\n", + " config = {'n_clusters': self.n_clusters}\n", + " base_config = super(ClusteringLayer, self).get_config()\n", + " return dict(list(base_config.items()) + list(config.items()))\n", + "\n", + "\n", + "class DEC(object):\n", + " def __init__(self,\n", + " dims,\n", + " n_clusters=10,\n", + " alpha=1.0,\n", + " init='glorot_uniform'):\n", + "\n", + " super(DEC, self).__init__()\n", + "\n", + " self.dims = dims\n", + " self.input_dim = dims[0]\n", + " self.n_stacks = len(self.dims) - 1\n", + "\n", + " self.n_clusters = n_clusters\n", + " self.alpha = alpha\n", + " self.autoencoder, self.encoder = autoencoder(self.dims, init=init)\n", + "\n", + " # prepare DEC model\n", + " clustering_layer = ClusteringLayer(self.n_clusters, name='clustering')(self.encoder.output)\n", + " self.model = Model(inputs=self.encoder.input, outputs=clustering_layer)\n", + "\n", + " def pretrain(self, x, y=None, optimizer='adam', epochs=200, batch_size=256, save_dir='results/temp'):\n", + " print('...Pretraining...')\n", + " self.autoencoder.compile(optimizer=optimizer, loss='mse')\n", + "\n", + " csv_logger = callbacks.CSVLogger(save_dir + '/pretrain_log.csv')\n", + " cb = [csv_logger]\n", + " if y is not None:\n", + " class PrintACC(callbacks.Callback):\n", + " def __init__(self, x, y):\n", + " self.x = x\n", + " self.y = y\n", + " super(PrintACC, self).__init__()\n", + "\n", + " def on_epoch_end(self, epoch, logs=None):\n", + " if epoch % int(epochs/10) != 0:\n", + " return\n", + " feature_model = Model(self.model.input,\n", + " self.model.get_layer(\n", + " 'encoder_%d' % (int(len(self.model.layers) / 2) - 1)).output)\n", + " features = feature_model.predict(self.x)\n", + " km = KMeans(n_clusters=len(np.unique(self.y)), n_init=20, n_jobs=4)\n", + " y_pred = km.fit_predict(features)\n", + " # print()\n", + " print(' '*8 + '|==> acc: %.4f, nmi: %.4f <==|'\n", + " % (metrics.acc(self.y, y_pred), metrics.nmi(self.y, y_pred)))\n", + "\n", + " cb.append(PrintACC(x, y))\n", + "\n", + " # begin pretraining\n", + " t0 = time()\n", + " self.autoencoder.fit(x, x, batch_size=batch_size, epochs=epochs, callbacks=cb)\n", + " print('Pretraining time: ', time() - t0)\n", + " self.autoencoder.save_weights(save_dir + '/ae_weights.h5')\n", + " print('Pretrained weights are saved to %s/ae_weights.h5' % save_dir)\n", + " self.pretrained = True\n", + "\n", + " def load_weights(self, weights): # load weights of DEC model\n", + " self.model.load_weights(weights)\n", + "\n", + " def extract_features(self, x):\n", + " return self.encoder.predict(x)\n", + "\n", + " def predict(self, x): # predict cluster labels using the output of clustering layer\n", + " q = self.model.predict(x, verbose=0)\n", + " return q.argmax(1)\n", + "\n", + " @staticmethod\n", + " def target_distribution(q):\n", + " weight = q ** 2 / q.sum(0)\n", + " return (weight.T / weight.sum(1)).T\n", + "\n", + " def compile(self, optimizer='sgd', loss='kld'):\n", + " self.model.compile(optimizer=optimizer, loss=loss)\n", + "\n", + " def fit(self, x, y=None, maxiter=2e4, batch_size=256, tol=1e-3,\n", + " update_interval=140, save_dir='./results/temp'):\n", + "\n", + " print('Update interval', update_interval)\n", + " save_interval = x.shape[0] / batch_size * 5 # 5 epochs\n", + " print('Save interval', save_interval)\n", + "\n", + " # Step 1: initialize cluster centers using k-means\n", + " t1 = time()\n", + " print('Initializing cluster centers with k-means.')\n", + " kmeans = KMeans(n_clusters=self.n_clusters, n_init=20)\n", + " y_pred = kmeans.fit_predict(self.encoder.predict(x))\n", + " y_pred_last = np.copy(y_pred)\n", + " self.model.get_layer(name='clustering').set_weights([kmeans.cluster_centers_])\n", + "\n", + " # Step 2: deep clustering\n", + " # logging file\n", + " import csv\n", + " logfile = open(save_dir + '/dec_log.csv', 'w')\n", + " logwriter = csv.DictWriter(logfile, fieldnames=['iter', 'acc', 'nmi', 'ari', 'loss'])\n", + " logwriter.writeheader()\n", + "\n", + " loss = 0\n", + " index = 0\n", + " index_array = np.arange(x.shape[0])\n", + " for ite in range(int(maxiter)):\n", + " if ite % update_interval == 0:\n", + " q = self.model.predict(x, verbose=0)\n", + " p = self.target_distribution(q) # update the auxiliary target distribution p\n", + "\n", + " # evaluate the clustering performance\n", + " y_pred = q.argmax(1)\n", + " if y is not None:\n", + " acc = np.round(metrics.acc(y, y_pred), 5)\n", + " nmi = np.round(metrics.nmi(y, y_pred), 5)\n", + " ari = np.round(metrics.ari(y, y_pred), 5)\n", + " loss = np.round(loss, 5)\n", + " logdict = dict(iter=ite, acc=acc, nmi=nmi, ari=ari, loss=loss)\n", + " logwriter.writerow(logdict)\n", + " print('Iter %d: acc = %.5f, nmi = %.5f, ari = %.5f' % (ite, acc, nmi, ari), ' ; loss=', loss)\n", + "\n", + " # check stop criterion\n", + " delta_label = np.sum(y_pred != y_pred_last).astype(np.float32) / y_pred.shape[0]\n", + " y_pred_last = np.copy(y_pred)\n", + " if ite > 0 and delta_label < tol:\n", + " print('delta_label ', delta_label, '< tol ', tol)\n", + " print('Reached tolerance threshold. Stopping training.')\n", + " logfile.close()\n", + " break\n", + "\n", + " # train on batch\n", + " # if index == 0:\n", + " # np.random.shuffle(index_array)\n", + " idx = index_array[index * batch_size: min((index+1) * batch_size, x.shape[0])]\n", + " self.model.train_on_batch(x=x[idx], y=p[idx])\n", + " index = index + 1 if (index + 1) * batch_size <= x.shape[0] else 0\n", + "\n", + " # save intermediate model\n", + " if ite % save_interval == 0:\n", + " print('saving model to:', save_dir + '/DEC_model_' + str(ite) + '.h5')\n", + " self.model.save_weights(save_dir + '/DEC_model_' + str(ite) + '.h5')\n", + "\n", + " ite += 1\n", + "\n", + " # save the trained model\n", + " logfile.close()\n", + " print('saving model to:', save_dir + '/DEC_model_final.h5')\n", + " self.model.save_weights(save_dir + '/DEC_model_final.h5')\n", + "\n", + " return y_pred\n", + "\n", + "\n", + "# setting the hyper parameters\n", + "init = 'glorot_uniform'\n", + "pretrain_optimizer = 'adam'\n", + "dataset = 'mnist'\n", + "batch_size = 2048\n", + "maxiter = 100\n", + "tol = 0.001\n", + "save_dir = 'results'\n", + "\n", + "import os\n", + "if not os.path.exists(save_dir):\n", + " os.makedirs(save_dir)\n", + "\n", + "update_interval = 25\n", + "pretrain_epochs = 100\n", + "init = VarianceScaling(scale=1. / 3., mode='fan_in',\n", + " distribution='uniform') # [-limit, limit], limit=sqrt(1./fan_in)\n", + "#pretrain_optimizer = SGD(lr=1, momentum=0.9)\n", + "\n", + "\n", + "# prepare the DEC model\n", + "dec = DEC(dims=[train_x.shape[-1], 500, 500, 2000, 10], n_clusters=10, init=init)\n", + "\n", + "dec.pretrain(x=train_x, y=train_y, optimizer=pretrain_optimizer,\n", + " epochs=pretrain_epochs, batch_size=batch_size,\n", + " save_dir=save_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_5\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input (InputLayer) (None, 784) 0 \n", + "_________________________________________________________________\n", + "encoder_0 (Dense) (None, 500) 392500 \n", + "_________________________________________________________________\n", + "encoder_1 (Dense) (None, 500) 250500 \n", + "_________________________________________________________________\n", + "encoder_2 (Dense) (None, 2000) 1002000 \n", + "_________________________________________________________________\n", + "encoder_3 (Dense) (None, 10) 20010 \n", + "_________________________________________________________________\n", + "clustering (ClusteringLayer) (None, 10) 100 \n", + "=================================================================\n", + "Total params: 1,665,110\n", + "Trainable params: 1,665,110\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "dec.model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "dec.compile(optimizer=SGD(0.01, 0.9), loss='kld')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Update interval 5\n", + "Save interval 83.740234375\n", + "Initializing cluster centers with k-means.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter 0: acc = 0.49096, nmi = 0.42283, ari = 0.30934 ; loss= 0\n", + "saving model to: results/DEC_model_0.h5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/utils/linear_assignment_.py:127: DeprecationWarning: The linear_assignment function is deprecated in 0.21 and will be removed from 0.23. Use scipy.optimize.linear_sum_assignment instead.\n", + " DeprecationWarning)\n", + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter 5: acc = 0.49318, nmi = 0.42050, ari = 0.31161 ; loss= 0\n", + "saving model to: results/DEC_model_final.h5\n" + ] + } + ], + "source": [ + "y_pred = dec.fit(train_x, y=train_y, tol=tol, maxiter=maxiter, batch_size=batch_size,\n", + " update_interval=update_interval, save_dir=save_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "pred_val = dec.predict(val_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jalfaizy/miniconda3/lib/python3.7/site-packages/sklearn/metrics/cluster/supervised.py:859: FutureWarning: The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.\n", + " FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "0.40744934405662664" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "normalized_mutual_info_score(val_y, pred_val)" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From bda1200429c9d526671740b03250810c6cfc3aa5 Mon Sep 17 00:00:00 2001 From: faizankshaikh Date: Tue, 24 Nov 2020 16:20:49 +0530 Subject: [PATCH 15/17] add typing tutor article --- Typing_Tutor/original/README.md | 3 + Typing_Tutor/original/SessionState.py | 96 ++++++++++++++ Typing_Tutor/original/example_code.py | 17 +++ Typing_Tutor/original/requirements.txt | 4 + Typing_Tutor/original/typing_app.py | 174 +++++++++++++++++++++++++ 5 files changed, 294 insertions(+) create mode 100644 Typing_Tutor/original/README.md create mode 100644 Typing_Tutor/original/SessionState.py create mode 100644 Typing_Tutor/original/example_code.py create mode 100644 Typing_Tutor/original/requirements.txt create mode 100644 Typing_Tutor/original/typing_app.py diff --git a/Typing_Tutor/original/README.md b/Typing_Tutor/original/README.md new file mode 100644 index 0000000..285569f --- /dev/null +++ b/Typing_Tutor/original/README.md @@ -0,0 +1,3 @@ +## Steps to run + +> streamlit run app.py diff --git a/Typing_Tutor/original/SessionState.py b/Typing_Tutor/original/SessionState.py new file mode 100644 index 0000000..63e8a26 --- /dev/null +++ b/Typing_Tutor/original/SessionState.py @@ -0,0 +1,96 @@ +# https://gist.github.com/FranzDiebold/898396a6be785d9b5ca6f3706ef9b0bc +"""Hack to add per-session state to Streamlit. + +Works for Streamlit >= v0.65 + +Usage +----- + +>>> import SessionState +>>> +>>> session_state = SessionState.get(user_name='', favorite_color='black') +>>> session_state.user_name +'' +>>> session_state.user_name = 'Mary' +>>> session_state.favorite_color +'black' + +Since you set user_name above, next time your script runs this will be the +result: +>>> session_state = get(user_name='', favorite_color='black') +>>> session_state.user_name +'Mary' + +""" + +import streamlit.report_thread as ReportThread +from streamlit.server.server import Server + + +class SessionState(): + """SessionState: Add per-session state to Streamlit.""" + def __init__(self, **kwargs): + """A new SessionState object. + + Parameters + ---------- + **kwargs : any + Default values for the session state. + + Example + ------- + >>> session_state = SessionState(user_name='', favorite_color='black') + >>> session_state.user_name = 'Mary' + '' + >>> session_state.favorite_color + 'black' + + """ + for key, val in kwargs.items(): + setattr(self, key, val) + + +def get(**kwargs): + """Gets a SessionState object for the current session. + + Creates a new object if necessary. + + Parameters + ---------- + **kwargs : any + Default values you want to add to the session state, if we're creating a + new one. + + Example + ------- + >>> session_state = get(user_name='', favorite_color='black') + >>> session_state.user_name + '' + >>> session_state.user_name = 'Mary' + >>> session_state.favorite_color + 'black' + + Since you set user_name above, next time your script runs this will be the + result: + >>> session_state = get(user_name='', favorite_color='black') + >>> session_state.user_name + 'Mary' + + """ + # Hack to get the session object from Streamlit. + + session_id = ReportThread.get_report_ctx().session_id + session_info = Server.get_current()._get_session_info(session_id) + + if session_info is None: + raise RuntimeError('Could not get Streamlit session object.') + + this_session = session_info.session + + # Got the session object! Now let's attach some state into it. + + if not hasattr(this_session, '_custom_session_state'): + this_session._custom_session_state = SessionState(**kwargs) + + return this_session._custom_session_state + diff --git a/Typing_Tutor/original/example_code.py b/Typing_Tutor/original/example_code.py new file mode 100644 index 0000000..a9839cd --- /dev/null +++ b/Typing_Tutor/original/example_code.py @@ -0,0 +1,17 @@ +def reverse(x: int) -> int: + """ + Given a 32-bit signed integer, reverse digits of an integer. + """ + str_num = str(x) + is_negative = False + if str_num[0] == '-': + is_negative = True + str_num = str_num[1:] + + sign = '-' if is_negative else '+' + + num = int(sign + "".join(list(reversed(str_num)))) + + return num + +print(reverse(123)) diff --git a/Typing_Tutor/original/requirements.txt b/Typing_Tutor/original/requirements.txt new file mode 100644 index 0000000..4a16eeb --- /dev/null +++ b/Typing_Tutor/original/requirements.txt @@ -0,0 +1,4 @@ +transformers +streamlit +streamlit-ace +torch \ No newline at end of file diff --git a/Typing_Tutor/original/typing_app.py b/Typing_Tutor/original/typing_app.py new file mode 100644 index 0000000..85758cb --- /dev/null +++ b/Typing_Tutor/original/typing_app.py @@ -0,0 +1,174 @@ +import time +import difflib +import logging +import textwrap +import SessionState +import streamlit as st + +from random import choice +from streamlit_ace import st_ace +from tokenizers import AddedToken +from transformers import AutoTokenizer, AutoModelWithLMHead + + +CONTEXTS = [ + "def fib", + "def fact", + "def sum_of_int", + "def sum_of_fact", + "def sum_of_square_error", + "def get_val", + "def convert_to_num", + "def convolute", + "def dict_sort", +] + + +@st.cache( + hash_funcs={ + st.delta_generator.DeltaGenerator: lambda x: None, + AddedToken: lambda x: None, + "_regex.Pattern": lambda x: None, + }, + allow_output_mutation=True, +) +def _load_model(): + tokenizer = AutoTokenizer.from_pretrained( + "congcongwang/distilgpt2_fine_tuned_coder" + ) + model = AutoModelWithLMHead.from_pretrained( + "congcongwang/distilgpt2_fine_tuned_coder" + ) + model.eval() + + return tokenizer, model + + +class TypingTutor: + def __init__(self): + + st.set_page_config(page_title="Typing Tutor", layout="wide") + + self.tokenizer, self.model = _load_model() + + self.session_state = SessionState.get( + name="typingSession", + start_time=0, + end_time=0, + num_chars=0, + text="", + content="", + ) + + st.markdown( + "

Typing Tutor

", + unsafe_allow_html=True, + ) + + self.col1, self.col2 = st.beta_columns(2) + placeholder = st.empty() + + with self.col1: + self.start_button = st.button("Start!", key="start_button") + st.subheader("Text to write") + + with placeholder.beta_container(): + st.subheader("Steps to check your Typing speed") + st.write( + "1. When you are ready, click on the start button which will generate code for you to write on the left hand side. A point to note that the timer starts as soon as you click on the start button" + ) + st.write( + "2. Start writing the same code on the code window given on the right hand side. When you're done - press 'CTRL + ENTER' to save your code. **Remember to do this as this ensures that the code you have written is ready for submission**" + ) + st.write( + "3. Lastly, click on Check Speed button to check you writing accuracy and the writing speed. Good luck!" + ) + + with self.col2: + self.eval_button = st.button("Check Speed", key="eval_button") + st.subheader("Text Input") + st.write("") + + self.session_state.content = st_ace( + placeholder="Start typing here ...", + language="python", + theme="solarized_light", + keybinding="sublime", + font_size=20, + tab_size=4, + show_gutter=True, + show_print_margin=True, + wrap=True, + readonly=False, + auto_update=False, + key="ace-editor", + ) + + def _code_gen(self, context, realtime=True): + if realtime: + input_ids = self.tokenizer.encode( + " " + context, return_tensors="pt" + ) + outputs = self.model.generate( + input_ids=input_ids, + max_length=256, + temperature=0.7, + num_return_sequences=1, + ) + + text = self.tokenizer.decode(outputs[0], skip_special_tokens=True) + + return text + else: + with open("example_code.py", "r") as f: + text = "".join(f.readlines()) + + return text + + def on_start_click(self): + with self.col1: + context = choice(CONTEXTS) + self.session_state.text = self._code_gen(context, realtime=True) + + self.session_state.num_chars = len(self.session_state.text) + st.code(textwrap.dedent(self.session_state.text)) + + self.session_state.start_time = time.time() + + logging.info(f"On start click, start time is {self.session_state.start_time}") + logging.info( + f"On start click, num_chars to type are {self.session_state.num_chars}" + ) + + def on_eval_click(self): + self.session_state.end_time = time.time() - self.session_state.start_time + + logging.info(f"On eval click, current time is {time.time()}") + logging.info(f"On eval click, start time is {self.session_state.start_time}") + logging.info(f"On eval click, end time is {self.session_state.end_time}") + + speed = ((self.session_state.num_chars / self.session_state.end_time) / 5) * 60 + accuracy = difflib.SequenceMatcher( + None, self.session_state.text, self.session_state.content + ).ratio() + with self.col1: + st.write("Time to write:", round(speed), "WPM") + st.write("Accuracy:", round(accuracy * 100, 2), "%") + + logging.info(f"On eval click, speed is {speed}") + + +if __name__ == "__main__": + logging.info(f"Starting init") + tt = TypingTutor() + logging.info(f"Done with init") + + if tt.start_button: + logging.info(f"Start button clicked at {time.time()}") + tt.on_start_click() + logging.info(f"Done with Start button") + + if tt.eval_button: + logging.info(f"Eval button clicked at {time.time()}") + tt.on_eval_click() + logging.info(f"Done with Eval button") From fba0ceb066b5361038858a0194b7b66aa5ba07e5 Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Wed, 10 May 2023 11:13:53 +0200 Subject: [PATCH 16/17] remove death bug (p2) --- experiments/trial1.ipynb | 671 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 671 insertions(+) create mode 100644 experiments/trial1.ipynb diff --git a/experiments/trial1.ipynb b/experiments/trial1.ipynb new file mode 100644 index 0000000..0a96dbc --- /dev/null +++ b/experiments/trial1.ipynb @@ -0,0 +1,671 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyPydNZb+Iqcl+v3Ef39seWI", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "V2BNDFAEr5fq", + "outputId": "8c74ec66-16d6-4160-cf20-ad134926fce7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m925.5/925.5 kB\u001b[0m \u001b[31m34.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m816.1/816.1 kB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m162.7/162.7 kB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCloning into 'HomMul'...\n", + "remote: Enumerating objects: 29, done.\u001b[K\n", + "remote: Counting objects: 100% (29/29), done.\u001b[K\n", + "remote: Compressing objects: 100% (25/25), done.\u001b[K\n", + "remote: Total 29 (delta 5), reused 19 (delta 2), pack-reused 0\u001b[K\n", + "Unpacking objects: 100% (29/29), 17.56 KiB | 1.03 MiB/s, done.\n" + ] + } + ], + "source": [ + "# !pip install -q black gymnasium pettingzoo tianshou\n", + "# !git clone https://github.com/faizankshaikh/HomMul.git" + ] + }, + { + "cell_type": "code", + "source": [ + "%cd HomMul/" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NBShrrDlsJLP", + "outputId": "517799d5-e8c0-44dd-ae10-2a11021b5615" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/HomMul\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "%load_ext tensorboard\n", + "\n", + "import os\n", + "import torch\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from hommul.envs.hommul_v0 import HomMul\n", + "\n", + "from torch.optim import Adam\n", + "\n", + "from tianshou.data import Batch\n", + "from tianshou.utils.net.common import Net\n", + "from tianshou.utils import TensorboardLogger\n", + "from tianshou.trainer import offpolicy_trainer\n", + "from tianshou.data import Collector, VectorReplayBuffer\n", + "from tianshou.env import DummyVectorEnv, PettingZooEnv\n", + "from tianshou.policy import BasePolicy, DQNPolicy, MultiAgentPolicyManager\n", + "\n", + "from pettingzoo.utils import parallel_to_aec\n", + "\n", + "from torch.utils.tensorboard import SummaryWriter" + ], + "metadata": { + "id": "othtAUgWs8MA" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "env = HomMul()\n", + "original_env = HomMul(render_mode=\"human\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZkPx4nCOuhXX", + "outputId": "1f30a9ca-76bc-4e2f-be84-bc131beaac25" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", + " and should_run_async(code)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# example of gameplay\n", + "episodes = 1\n", + "\n", + "for episode in range(episodes):\n", + " print(f\"Episode #{episode+1}\")\n", + " print(\"=\" * 10)\n", + " obs = original_env.reset()\n", + " print()\n", + "\n", + " while original_env.agents:\n", + " acts = {\n", + " \"player1\": np.random.choice([0, 1]),\n", + " \"player2\": np.random.choice([0, 1])\n", + " }\n", + " print(f\"--Action taken by player 1: {original_env.action_dict[acts['player1']]}\")\n", + " print(f\"--Action taken by player 2: {original_env.action_dict[acts['player2']]}\")\n", + " print()\n", + "\n", + " obs, rews, terms, truncs, infos = original_env.step(acts)\n", + " print()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ANr_Vc2ouvVJ", + "outputId": "0f675e47-5a95-4d8d-cb39-7cad550af69a" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Episode #1\n", + "==========\n", + "--Days left: 2\n", + "--Current life of agent 1: 3\n", + "--Current life of agent 2: 1\n", + "--Probability of payoff for agent 1: 0.4\n", + "--Probability of payoff for agent 2: 0.4\n", + "\n", + "--Action taken by player 1: wait\n", + "--Action taken by player 2: play\n", + "\n", + "--Days left: 1\n", + "--Current life of agent 1: 2\n", + "--Current life of agent 2: 0\n", + "--Probability of payoff for agent 1: 0.4\n", + "--Probability of payoff for agent 2: 0.4\n", + "--Previous action of agent 1: wait\n", + "--Previous action of agent 2: play\n", + "\n", + "--Action taken by player 1: play\n", + "--Action taken by player 2: wait\n", + "\n", + "--Days left: 0\n", + "--Current life of agent 1: 0\n", + "--Current life of agent 2: 0\n", + "--Probability of payoff for agent 1: 0.4\n", + "--Probability of payoff for agent 2: 0.4\n", + "--Previous action of agent 1: play\n", + "--Previous action of agent 2: wait\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# both always cooperate\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 1,\n", + " \"player2\": 1\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "biogmPIWxNv3", + "outputId": "1b8b2004-b6fa-4e83-cbf8-32ef831a0301" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-341 -350]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# both always defect\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 0,\n", + " \"player2\": 0\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "EpB7M86F3Nmk", + "outputId": "8d9a0151-ae11-4617-9e8e-9b7b2b3a2e3a" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-498 -491]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# player1 defects, player2 cooperates\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 0,\n", + " \"player2\": 1\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "O2wI3VsI3Tc8", + "outputId": "0a8e8e61-7a82-4b55-ca6d-d23bedd70e94" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-517 -583]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# player1 cooperates, player2 defects\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 1,\n", + " \"player2\": 0\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "9eJWcQqC3Z99", + "outputId": "224d735c-c51b-45b8-b7d8-666fec94fabf" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-565 -487]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Always cooperate vs a random agent\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 1,\n", + " \"player2\": np.random.choice([0, 1])\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "FPLlpZUh3i8f", + "outputId": "2e1808d4-84ce-4ac2-9274-ab4c4727cedd" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-454 -393]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Always defect vs a random agent\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 0,\n", + " \"player2\": np.random.choice([0, 1])\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "A2Ei4LU75us9", + "outputId": "8ead19a8-36e6-49ba-cbc6-9bbe4ad737ad" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-501 -564]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Always forage vs a hail mary\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 1,\n", + " \"player2\": 1 if obs[\"player2\"][\"observation\"][0, 2] <= 1 else 0\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "onhvByjW51QN", + "outputId": "3b60fae3-7bb7-4b73-a151-83b1ec2dbfc9" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-527 -244]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Always defect vs a hail mary\n", + "episodes = 1000\n", + "\n", + "episode_rews = []\n", + "\n", + "for _ in range(episodes):\n", + "\n", + " obs = env.reset()\n", + " while env.agents:\n", + " acts = {\n", + " \"player1\": 0,\n", + " \"player2\": 1 if obs[\"player2\"][\"observation\"][0, 2] <= 1 else 0\n", + " }\n", + "\n", + " obs, rews, terms, truncs, infos = env.step(acts)\n", + " # print(obs, rews)\n", + "\n", + " episode_rews.append([rews['player1'], rews['player2']])\n", + "\n", + "arr = np.array(episode_rews)\n", + "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", + "plt.plot(arr.cumsum(axis=0))\n", + "plt.legend((\"player1\", \"player2\"))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 448 + }, + "id": "V8KQIrS76GRt", + "outputId": "92c87879-06a4-49bf-ed40-35bb2297b7bb" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Score [player1, player2]:[-487 -322]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 651b4ad41c896ae6d2e76959cb056db2f30fdb9d Mon Sep 17 00:00:00 2001 From: jalFaizy Date: Wed, 10 May 2023 11:21:35 +0200 Subject: [PATCH 17/17] Delete experiments directory --- experiments/trial1.ipynb | 671 --------------------------------------- 1 file changed, 671 deletions(-) delete mode 100644 experiments/trial1.ipynb diff --git a/experiments/trial1.ipynb b/experiments/trial1.ipynb deleted file mode 100644 index 0a96dbc..0000000 --- a/experiments/trial1.ipynb +++ /dev/null @@ -1,671 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "authorship_tag": "ABX9TyPydNZb+Iqcl+v3Ef39seWI", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "V2BNDFAEr5fq", - "outputId": "8c74ec66-16d6-4160-cf20-ad134926fce7" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m925.5/925.5 kB\u001b[0m \u001b[31m34.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m816.1/816.1 kB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m162.7/162.7 kB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCloning into 'HomMul'...\n", - "remote: Enumerating objects: 29, done.\u001b[K\n", - "remote: Counting objects: 100% (29/29), done.\u001b[K\n", - "remote: Compressing objects: 100% (25/25), done.\u001b[K\n", - "remote: Total 29 (delta 5), reused 19 (delta 2), pack-reused 0\u001b[K\n", - "Unpacking objects: 100% (29/29), 17.56 KiB | 1.03 MiB/s, done.\n" - ] - } - ], - "source": [ - "# !pip install -q black gymnasium pettingzoo tianshou\n", - "# !git clone https://github.com/faizankshaikh/HomMul.git" - ] - }, - { - "cell_type": "code", - "source": [ - "%cd HomMul/" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NBShrrDlsJLP", - "outputId": "517799d5-e8c0-44dd-ae10-2a11021b5615" - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "/content/HomMul\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "%load_ext tensorboard\n", - "\n", - "import os\n", - "import torch\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from hommul.envs.hommul_v0 import HomMul\n", - "\n", - "from torch.optim import Adam\n", - "\n", - "from tianshou.data import Batch\n", - "from tianshou.utils.net.common import Net\n", - "from tianshou.utils import TensorboardLogger\n", - "from tianshou.trainer import offpolicy_trainer\n", - "from tianshou.data import Collector, VectorReplayBuffer\n", - "from tianshou.env import DummyVectorEnv, PettingZooEnv\n", - "from tianshou.policy import BasePolicy, DQNPolicy, MultiAgentPolicyManager\n", - "\n", - "from pettingzoo.utils import parallel_to_aec\n", - "\n", - "from torch.utils.tensorboard import SummaryWriter" - ], - "metadata": { - "id": "othtAUgWs8MA" - }, - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "env = HomMul()\n", - "original_env = HomMul(render_mode=\"human\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ZkPx4nCOuhXX", - "outputId": "1f30a9ca-76bc-4e2f-be84-bc131beaac25" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", - " and should_run_async(code)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# example of gameplay\n", - "episodes = 1\n", - "\n", - "for episode in range(episodes):\n", - " print(f\"Episode #{episode+1}\")\n", - " print(\"=\" * 10)\n", - " obs = original_env.reset()\n", - " print()\n", - "\n", - " while original_env.agents:\n", - " acts = {\n", - " \"player1\": np.random.choice([0, 1]),\n", - " \"player2\": np.random.choice([0, 1])\n", - " }\n", - " print(f\"--Action taken by player 1: {original_env.action_dict[acts['player1']]}\")\n", - " print(f\"--Action taken by player 2: {original_env.action_dict[acts['player2']]}\")\n", - " print()\n", - "\n", - " obs, rews, terms, truncs, infos = original_env.step(acts)\n", - " print()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ANr_Vc2ouvVJ", - "outputId": "0f675e47-5a95-4d8d-cb39-7cad550af69a" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Episode #1\n", - "==========\n", - "--Days left: 2\n", - "--Current life of agent 1: 3\n", - "--Current life of agent 2: 1\n", - "--Probability of payoff for agent 1: 0.4\n", - "--Probability of payoff for agent 2: 0.4\n", - "\n", - "--Action taken by player 1: wait\n", - "--Action taken by player 2: play\n", - "\n", - "--Days left: 1\n", - "--Current life of agent 1: 2\n", - "--Current life of agent 2: 0\n", - "--Probability of payoff for agent 1: 0.4\n", - "--Probability of payoff for agent 2: 0.4\n", - "--Previous action of agent 1: wait\n", - "--Previous action of agent 2: play\n", - "\n", - "--Action taken by player 1: play\n", - "--Action taken by player 2: wait\n", - "\n", - "--Days left: 0\n", - "--Current life of agent 1: 0\n", - "--Current life of agent 2: 0\n", - "--Probability of payoff for agent 1: 0.4\n", - "--Probability of payoff for agent 2: 0.4\n", - "--Previous action of agent 1: play\n", - "--Previous action of agent 2: wait\n", - "\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# both always cooperate\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 1,\n", - " \"player2\": 1\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "biogmPIWxNv3", - "outputId": "1b8b2004-b6fa-4e83-cbf8-32ef831a0301" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-341 -350]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGdCAYAAADnrPLBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpJ0lEQVR4nO3dd3QVRRvH8e9N7wkQSCgJhCKhV4HQm4CCgIoUkSIIoqAUpanYkaKgogL6KoiKghUREQkdJPTeeyehJ6Gk7/vHwk2uAQRMclN+n3P2uDs7u/e5CyYPMzszFsMwDERERERyKAd7ByAiIiLyXyiZERERkRxNyYyIiIjkaEpmREREJEdTMiMiIiI5mpIZERERydGUzIiIiEiOpmRGREREcjQneweQFVJSUjh16hTe3t5YLBZ7hyMiIiJ3wDAMYmNjKVKkCA4Ot25/yRPJzKlTpwgKCrJ3GCIiInIPjh8/TrFixW55Pk8kM97e3oD5MHx8fOwcjYiIiNyJmJgYgoKCrL/HbyVPJDM3upZ8fHyUzIiIiOQw//aKiF4AFhERkRxNyYyIiIjkaEpmREREJEfLE+/MiIiIgDnUNykpieTkZHuHIoCjoyNOTk7/edoUJTMiIpInJCQkcPr0aa5evWrvUCQNDw8PChcujIuLyz3fQ8mMiIjkeikpKRw+fBhHR0eKFCmCi4uLJlG1M8MwSEhI4OzZsxw+fJgyZcrcdmK821EyIyIiuV5CQgIpKSkEBQXh4eFh73DkOnd3d5ydnTl69CgJCQm4ubnd0330ArCIiOQZ9/ovf8k8GfFnoj9VERERydFyTDLz6aefUqJECdzc3Khduzbr1q2zd0giIiJ2V6JECT788EN7h2FXOSKZmT17NkOGDOH1119n06ZNVKlShZYtW3LmzBl7hyYiIiLX/fLLL7Ro0YICBQpgsVjYsmVLlnxujkhmJk6cSJ8+fXjqqacoX748U6dOxcPDg2nTptk7NBERkTwvISEBgCtXrlC/fn3GjRuXpZ+f7ZOZhIQENm7cSPPmza1lDg4ONG/enIiIiJteEx8fT0xMjM2WGdZ89zYRk/vy2/z5pKQYmfIZIiKStzVu3JgBAwYwYMAAfH198ff3Z9SoURjGzX/vTJw4kUqVKuHp6UlQUBDPPfccly9fBsxkw8fHh59++snmmjlz5uDp6UlsbCwAx48fp2PHjvj5+ZE/f37atWvHkSNHrPV79uxJ+/btGT16NEWKFKFs2bIAdOvWjddee83md3ZWyPbJzLlz50hOTiYgIMCmPCAggMjIyJteM2bMGHx9fa1bUFBQpsSW79A8ws7MptqaFxg8a8Mt/2KJiEj2YxgGVxOSsny7l98VM2bMwMnJiXXr1vHRRx8xceJEvvjii5vWdXBwYNKkSezcuZMZM2awZMkShg0bBoCnpyedO3dm+vTpNtdMnz6dDh064O3tTWJiIi1btsTb25uVK1fy999/4+XlRatWrawtMACLFy9m7969hIeHM2/evLv+ThkpV84zM3LkSIYMGWI9jomJyZSEJrb0w7BnD8EOZ3lo9wjenPsRb7SrmOGfIyIiGe9aYjLlX/sryz9311st8XC5u1+/QUFBfPDBB1gsFsqWLcv27dv54IMP6NOnT7q6gwYNsu6XKFGCd955h379+jF58mQAnn76aerWrcvp06cpXLgwZ86cYf78+SxatAgw31NNSUnhiy++sE4sOH36dPz8/Fi2bBktWrQAzMToiy+++E8z92aUbN8y4+/vj6OjI1FRUTblUVFRBAYG3vQaV1dXfHx8bLbMULPzqyQ1fgWAlo4b6LaxA7FfdYRZXWHhKEhOypTPFRGRvKVOnTo2MxaHhYWxf//+m64xtWjRIpo1a0bRokXx9vamW7dunD9/3rqMQ61atahQoQIzZswA4Ntvv6V48eI0bNgQgK1bt3LgwAG8vb3x8vLCy8uL/PnzExcXx8GDB62fU6lSpWyRyEAOaJlxcXGhRo0aLF68mPbt2wPmtNSLFy9mwIAB9g0OcGowmORdv+F4ZgelHE7DkdPWc1fXfY17kxex1HvBjhGKiMjNuDs7suutlnb53Mxy5MgR2rRpw7PPPsvo0aPJnz8/q1atonfv3iQkJFhnP3766af59NNPGTFiBNOnT+epp56yJkuXL1+mRo0azJw5M939CxYsaN339PTMtO9xt7J9MgMwZMgQevToQc2aNalVqxYffvghV65c4amnnrJ3aODojGOfRZxYPYvJC7djAJ0dl1LF4RAeSZcgfBSUagqB6n4SEclOLBbLXXf32MvatWttjtesWUOZMmVwdLRNjDZu3EhKSgoTJkywzqz7ww8/pLvfk08+ybBhw5g0aRK7du2iR48e1nPVq1dn9uzZFCpUKNN6NjJatu9mAujUqRPvv/8+r732GlWrVmXLli0sWLAg3UvBduPsTrFGT9HhmVHU6jCEw+1+5bPCb7MiuZJ5fmo9iI26/T1ERERu4dixYwwZMoS9e/fy/fff8/HHHzNw4MB09UqXLk1iYiIff/wxhw4d4ptvvmHq1Knp6uXLl49HH32UoUOH0qJFC4oVK2Y917VrV/z9/WnXrh0rV67k8OHDLFu2jBdeeIETJ07cNs4LFy6wZcsWdu3aBcDevXvZsmXLLQfsZJQckcwADBgwgKNHjxIfH8/atWupXbu2vUNKp3pwPh6pVoz2NUrwcKc+jE/pmnpywn2w42f7BSciIjlW9+7duXbtGrVq1aJ///4MHDiQvn37pqtXpUoVJk6cyLhx46hYsSIzZ85kzJgxN73nja6nXr162ZR7eHiwYsUKgoODefTRRylXrhy9e/cmLi7uX1tq5s6dS7Vq1WjdujUAnTt3plq1ajdNqDKSxcgD44ljYmLw9fUlOjo6S5vMXvpxKy5bZvCu85ephV1mQ9lWWRaDiIhAXFwchw8fJiQk5J5XZraXxo0bU7Vq1QxfsuCbb75h8ODBnDp1yq4v8t7uz+ZOf3/nmJaZnOjZxqX4LrkZLeLTzIT410hISf/2uYiISFa4evUqBw8eZOzYsTzzzDPZZkTSf6FkJhOVKujF5K7V2WcEEZY4xSy8cAjeyg+nNoNh2G4iIiKZbPz48YSGhhIYGMjIkSPtHU6GUDdTFug4NYJ1Ry7wWanVtDz5yc0rufpCj9+gSLWsDU5EJA/Iyd1MuZ26mXKIZxuXAuCZg3VZUPsbcLrJ/0jx0fB5Y7PFRkRERO5Yzhhgn8M1LluQ+wK82Bd1mYF/O7Nx5CG8iEutcOEQfHl9Ua7PG8MDb0G99EPuREREJD21zGQBi8XCHy80oJC3K/FJKTT/aA3J7vnBs4C5Bd0PfZelXrByAsRlzkrfIiIiuY2SmSzi7OjAqDblAYiMiePriCNsO3EpdUsJ4eTAU1CgDMRFw6qJcHJT6nZ2r14SFhERuQl1M2Whh6sU4cCZy3y0eD9v/r7rpnVm1niSeudfh1UfmFtaVZ6A+oOh4H1ZEK2IiEjOoJaZLNarXgj3l8hHUT93m+2GnhtD2OhWB8O3GPgGmdsNW7+DT++HDdPsELmIiEj2pJaZLObr4cyP/eqmKz9x8Spd/reG4xeu8dilF6gVkp+n6pYAwCE5geobXqLgiYVm5XmDITYSqnSG/CWzMHoREcluSpQowaBBgxg0aJC9Q7EbtcxkE8XyebBiaBOahRYCYN3hCzw7cxPPztzEM7N2cP+Bnjzln2Y59uXjYFI1OLXFPgGLiIikkZiYyPDhw6lUqRKenp4UKVKE7t27c+rUqUz/bCUz2YjFYuF/3WvSI6w4tUrkt24+bmYD2tITFurHf8QB3zQtO988Aolxt7ijiIhI5ktISODq1ats2rSJUaNGsWnTJn755Rf27t1L27ZtM/3zlcxkMw4OFt5sV5Ef+oVZt82vtaB3/RAAThgFaR41gE9CPjUvuHYBvmkP0SftF7SIiGSaxo0bM2DAAAYMGICvry/+/v6MGjWKW03gP3HiRGvrSFBQEM899xyXL18G4MqVK/j4+PDTTz/ZXDNnzhw8PT2JjY0F4Pjx43Ts2BE/Pz/y589Pu3btOHLkiLV+z549ad++PaNHj6ZIkSKULVsWX19fwsPD6dixI2XLlqVOnTp88sknbNy4kWPHjmXOw7lOyUwO4OhgYVSb8mx/owW+7s4AvL87H3MDXzArHIuAD8rD8vGw9jNIirdjtCIiOYRhQMKVrN/uYZqNGTNm4OTkxLp16/joo4+YOHEiX3zxxU3rOjg4MGnSJHbu3MmMGTNYsmQJw4YNA8DT05POnTszffp0m2umT59Ohw4d8Pb2JjExkZYtW+Lt7c3KlSv5+++/8fLyolWrViQkJFivWbx4MXv37iU8PJx58+bdNJbo6GgsFgt+fn53/Z3vhtZmymEuXEnghe83s+rAOVxIZFG5+QQfnm1bqXAVeHoJOOr9bhERuMX6PwlX4N0iWR/My6fAxfOOqzdu3JgzZ86wc+dOLBYLACNGjGDu3Lns2rXrX18A/umnn+jXrx/nzp0DYN26ddStW5fjx49TuHBhzpw5Q9GiRVm0aBGNGjXi22+/5Z133mH37t3Wz0tISMDPz485c+bQokULevbsyYIFCzh27NgtV92Oi4ujXr16hIaGMnPmzJvWuVFPazPlMfk9Xfj26drUDslPAs403N2Or4uP5VK5rlCwnFnp9Fb4pAZsnGHfYEVEJEPUqVPHmlgAhIWFsX//fpKTk9PVXbRoEc2aNaNo0aJ4e3vTrVs3zp8/z9WrVwGoVasWFSpUYMYM83fEt99+S/HixWnYsCEAW7du5cCBA3h7e+Pl5YWXlxf58+cnLi6OgwcPWj+nUqVKt0xkEhMT6dixI4ZhMGXKlAx7Dreif7rnUOM7VKbRe8sAeG1vMK8RzLvth/PEvoFwaClcPAK/vwAFSkGJ+naNVUQkW3L2MFtJ7PG5meTIkSO0adOGZ599ltGjR5M/f35WrVpF7969SUhIwMPD/Oynn36aTz/9lBEjRjB9+nSeeuopa7J0+fJlatSocdPWlIIFC1r3PT1v3rp0I5E5evQoS5YsyZIeESUzOVTxAp4sfrERM9ccY9rfhwF4ec4OFpYZzuSmzfE4tACOrDRnEVYyIyKSnsVyV9099rR27Vqb4zVr1lCmTBkcHR1tyjdu3EhKSgoTJkzAwcHsfPnhhx/S3e/JJ59k2LBhTJo0iV27dtGjRw/ruerVqzN79mwKFSp014nIjURm//79LF26lAIFCtzV9fdK3Uw5WKmCXrz2cHnm9K9nHb69bP8F6i8vy5VWH4DFAQ4sgmXj7BypiIj8F8eOHWPIkCHs3buX77//no8//piBAwemq1e6dGkSExP5+OOPOXToEN988w1Tp05NVy9fvnw8+uijDB06lBYtWlCsWDHrua5du+Lv70+7du1YuXIlhw8fZtmyZbzwwgucOHHiljEmJibSoUMHNmzYwMyZM0lOTiYyMpLIyEibF4czg5KZXKBqkB8rhzflsermX8YLVxL43w4DKnYwKywfBxeP2jFCERH5L7p37861a9eoVasW/fv3Z+DAgfTt2zddvSpVqjBx4kTGjRtHxYoVmTlzJmPGjLnpPW90PfXq1cum3MPDgxUrVhAcHMyjjz5KuXLl6N27N3FxcbdtqTl58iRz587lxIkTVK1alcKFC1u31atX/7cH8C80mimXeWPuTr5afQSAnjXy8frBLljiLpknO30L5R62W2wiIvZyuxEz2V3jxo2pWrUqH374YYbe95tvvmHw4MGcOnXqli/yZgWNZpJ0RrUpT6mCZh/wVxsvEnH/R6knZz8J+8PtFJmIiGQHV69e5eDBg4wdO5ZnnnnGrolMRlEyk8s4Olj4vm8dapXID8A7Owpg9PortcLMDvBxTXP7tA5s/+kWdxIRkdxo/PjxhIaGEhgYyMiRI+0dToZQN1MudfFKAvXGLeFqQjIPVgxkSpuC8GGl9BU9CsCgHeCSeUMFRUTsLSd3M+V26maSW8rn6ULPuiUA+HNHJNsu+8DQg/DUn6mbX3G4eh42f2vfYEVERP4DJTO52EstylI7xOxuavvJ30xefwmK103d6l1f2+nPoTC72z2tFyIiImJvSmZyMQcHC6MfSe1a+mjRfk5eusbVhCRztdWqXSGfuRo3u+fCvgV2ilREJGvkgTcrcpyM+DNRMpPLlS7kxY43WxKc34P4pBTqjV1C+df+4skv12I4uUH/dVC+nVn5+87w67OQnGjfoEVEMpizszOAdX0iyT5u/Jnc+DO6F3oBOI9Ytf8cvb5aT0JyirWsTsn8fN+nDpaYUzC5DsTHmCe8AqH/GnDPZ6doRUQy3unTp7l06RKFChXCw8PDZuFGyXqGYXD16lXOnDmDn58fhQsXTlfnTn9/K5nJQxKTU0hKNnh/4V6+XGWu5/RknWDeaV8JUpLhl76w4/pQ7XoDofaz4JP+L5eISE5kGAaRkZFcunTJ3qFIGn5+fgQGBt40uVQyk4aSmfSG/7SN2RuO4+xoYcWwJhT2dTdPbPsBfumTWrHpKLivFRQqBw6ON7+ZiEgOkpycTGKiutOzA2dn53SLZaalZCYNJTM31+mzCNYevkCHGsV4vEYxHBwsVAz0xP3nJ2H/QtvK97WCzt+Dg16zEhGRrKFkJg0lMze3bO8Zek5fb1NW1M+db5+uTYh7HMzqAqc2Q/L11U6bvgoNh9ohUhERyYs0aZ78q0b3FaRLrSBKFfSkqJ/ZzXTy0jWavL+M/22MZnXj7zBeiYJSTc0LVn8CO+fAnj8gLsZ+gYuIiKShlhmx+nLVYd6et8umrHm5ANpVCaD18rY4XDyUesKzELR4+/p+QSjdLAsjFRGRvEDdTGkomblzeyNjGT1/N6v2nyUlzd+Mtr4H+CBwEY7XzsGZXekvDG0Doa2hXFtw9cq6gEVEJNfKEd1MJUqUwGKx2Gxjx461qbNt2zYaNGiAm5sbQUFBjB8/3k7R5g1lA735ulctdr7Zik41gyhX2PzLMze6NG/lHwPPRcBD70OpZuZmuf5XaM88mPMsfFwdNs80h3qLiIhkASd7B/DWW2/Rp0/qUGBvb2/rfkxMDC1atKB58+ZMnTqV7du306tXL/z8/Ojbt689ws0z3F0cGdehMgCv/7aDGRFHmRFxFH8vV55r8jSOta7/mcXHwsJX4cQGiNoBl6Pgt+cg4TLUfsaO30BERPIKu78A7O3tTWBgoHXz9PS0nps5cyYJCQlMmzaNChUq0LlzZ1544QUmTpxox4jznjfaVqBKkB8AE8L38dBHKzl87op50tUbHv4Inv0bWo2DkEZm+d+TtCyCiIhkCbu+M1OiRAni4uJITEwkODiYJ554gsGDB+PkZDYYde/enZiYGObMmWO9ZunSpTRt2pQLFy6QL9/Np9uPj48nPj7eehwTE0NQUJDemfkPDpyJ5ekZGzhyPnVdk551S2CxgL+XK30blsTZ0QES4+DDSnDljLnmk3cRs7LFASo9BkVr2OkbiIhITnOn78zYtZvphRdeoHr16uTPn5/Vq1czcuRITp8+bW15iYyMJCQkxOaagIAA67lbJTNjxozhzTffzNzg85jShbxZNKQRE8L3MWXZQQC+Wn3Eev6biKM827gU3cOKYwnrD4teh12/2d5kzafQdzkUqZp1gYuISK6X4S0zI0aMYNy4cbets3v3bkJDQ9OVT5s2jWeeeYbLly/j6upKixYtCAkJ4bPPPrPW2bVrFxUqVGDXrl2UK1fupvdXy0zmijh4nlUHzgIQviuKfVGXree+71OHsOLesO4zuHbRLEyKh4hPUm/Qfz0UvC8rQxYRkRzIbkOzz549y/nz529bp2TJkri4uKQr37lzJxUrVmTPnj2ULVv2nruZ/klDszNPcorB7PXH+XPHaVbuP0fD+wryda9a6SseXQ3THzT3SzSAnvOyNlAREclx7NbNVLBgQQoWLHhP127ZsgUHBwcKFSoEQFhYGK+88gqJiYk4OzsDEB4eTtmyZe84kZHM5ehg4YnawdQv7U/j95eyYt9ZOn4WwZSu1Sng5ZpasXhd6DIbvu8ER1bCjIfBwQnylTBfHHZKn9yKiIjcCbuNZoqIiODDDz9k69atHDp0iJkzZzJ48GCefPJJa6LyxBNP4OLiQu/evdm5cyezZ8/mo48+YsiQIfYKW24huIAH7asWBWDd4Qs0nbCc2Lh/jGYq2wqqdzf3D6+Ag0tgwzQYGwRftoSIyVkctYiI5AZ2G820adMmnnvuOfbs2UN8fDwhISF069aNIUOG4Oqa+i/6bdu20b9/f9avX4+/vz/PP/88w4cPv6vPUjdT1rgSn8T4BXuYEXHUWlahiPm8HSwWuoUVp2Pl/OaK3EkJsPU7OLQs9QYWB3h+I+QvmcWRi4hIdqTlDNJQMpO13vtrD58uPZiu3NPFkdUjmuHrYXYZkpICh5ebE++tnQpH/4aavaDNB1kcsYiIZEdKZtJQMpP1thy/xKWrCdbjsX/uYU9kLADTetakaWiA7QVH/oavHgKLI3gXNstKNzMn5LNYsipsERHJRpTMpKFkxv4W7Iik37cbrcd+Hs44Wiw827gUTzcoCYYBX7c136VJy6MA9FlivigsIiJ5ipKZNJTMZA87T0XzyOTVJCSlWMvcnB34e3hTc+RTYhyc3QMYsPRd892aG5zcIKg2PPkLONp9STEREckCSmbSUDKTfVyJT+J09DUABs/eyvaT0QCMf6wyj9cshuVGl1JKCuyaAz89ZXuDItXNlhp1PYmI5Hp3+vvb7gtNSt7i6epE6ULelC7kzUsty1rLh/28jd4zNmDNrR0coOKjMOIYDNoOdZ83y09tgr1/wpVzWshSREQAJTNiR43uK8jGV5tTLJ87AEv2nGHNoQu2ldx8wS8YWrwD1Z40y2Z1gfdKwaTqEBeTxVGLiEh2o2RG7KqAlysrhjahY81iAExeduDWlRu/DD7FUo+jj8HCV8y1n0REJM9SMiN25+Bg4fmmZXB0sLBy/zn+3H6abScucejsZduKvkVhyE54IxraXZ8teNPX8GFluHQs6wMXEZFsQcmMZAtB+T14uLI5v8yzMzfR9pO/aTphOZMW77/5BZUeh5JNzP3LkfBhJdj9exZFKyIi2YmSGck2Bj9wH+UL+1DUz91aNjF8Hyv2nU1f2ckFus+xnS149pNwPv3MwyIikrtpaLZkS5fjkwgbs5jYuCSqFPOlX6NSlA30pmRBr/SVLx6Fjyqb+0WqQe9wcHTO2oBFRCTDaWi25Gherk4sGtIIF0cHtp6I5tmZm2g6YTkbj15MXzlfcXjqT3P/1GZY8V7WBisiInalZEayrQAfN95sV4FaIfmtZY9NWc3e62s82QgOg9A25v7ycXBqS9YEKSIidqdkRrK1LrWC+eGZMOYOqGcta/nhChbsOG1b0WKBjt+A/33m8XcdISkBERHJ/ZTMSI5QuZgf3/epYz3u9+0mJi7ca1vJwQHafmzuX46C7T9kYYQiImIvSmYkxwgrVYCZT9fG2dFcl2nSkgPsOvWPGYCD68ADb5v7v/XX6CYRkTxAyYzkKPVK+7PhlQfwcHEEoO0nq1i1/5xtpZpPmcsgAHxcHaJPZnGUIiKSlZTMSI7j6+HMD8+EAZCUYvDkl2t5d/5ukpJTzAqu3tDu09QLPigPC0dB/OWb3E1ERHI6JTOSI1Us6svkrtWtx5+vOESP6etISbk+bVK5h6HtJ6kXrJ4Eqz5ARERyHyUzkmM9VKkwK4Y2oXxhcyKlvw+cJ3x3VGqF6t3gyZ+hZi/zeOX78OdwSE6yQ7QiIpJZlMxIjhZcwIPfn69PlSA/AJ75ZiMH0y5QWbo5PDQBCoaax2unwswOkPsnvhYRyTOUzEiO5+hg4cseNXF0MEc5vTNvl20FBwfo+hMUu988PrQU3i8D3z8BV/7x8rCIiOQ4SmYkV/D3cuWzJ2sAsHTvWd7/6x9z0PgFQa+/ILiueXzlLOz9A1ZOyOJIRUQkoymZkVyjefkA2lYpAsDU5Qc5eemabQUHR+j+m9lK0/xNs2zNZPiuEyTGZXG0IiKSUZTMSK4yvkNlCvu6kZRi8L8Vh9JXcHKBMg9AvYGp3U77FsD/mkJKctYGKyIiGULJjOQqbs6OvNehCgBfrT7C9+uO3byixQLdfoVq3czjMzvhrfwwroS5fdVGrTUiIjmEkhnJdeqVLkBooDcAI3/ZzrxtpzAMw7pZuXqbaznV6Jladu2iuR1ZCVtmZm3gIiJyTyyGkfvHqMbExODr60t0dDQ+Pj72DkeyQFxiMpXe+IvEZNu/3kX93Jn9TB3ye7pgwYK7i6M5TPvSUUiKNyvtnAPL3jX3u/0KpZpmbfAiIgLc+e9vJTOSa8XGJdJ0wnLOxsbfss7DVYow4fEquDilaaRMuAJji0NKIhSuCn2Xmd1SIiKSpZTMpKFkJu9KSk4hJs6c8Xfl/rO89OPWdK01bs4OLH2pMYV93VMLY6NgYigYKdDxayjfLivDFhERlMzYUDIjNyQmp5B0PZkZ9dsOftp4wnrut/71rKtxB/i64bP0VXPGYIBnV0NAhSyPV0QkL1Myk4aSGbmV1QfP8cT/1qYr9/NwZkmf+8j/mTkyigqPwuPTszg6EZG87U5/f2s0k+RpdUv583m3GgT6uJHf04X8ni64ODlw6Woi07bFQ7+/zYq75sD5g3aNVUREbk4tMyL/sGDHafp9uwkfNyf+HtEU75+fgP0LIag29JwPjk72DlFEJE9Qy4zIPWpRPpCSBT2JiUti/IK9rC3awzxxfC3MaAO7foM9f0BcjH0DFRERQMmMSDoODhb6NSoFwDdrjtJpgYVN7mHmyWMR8EN3mPUETKlnDuMWERG7UjIjchOPVCtK5/uDqFUiP44OFh672J9z5Xuaq24XKm9Wij4Gfw63a5wiIpKJyczo0aOpW7cuHh4e+Pn53bTOsWPHaN26NR4eHhQqVIihQ4eSlJRkU2fZsmVUr14dV1dXSpcuzVdffZVZIYtYOTs6MPaxyvzQL4x2VYtg4ECrfQ9zuevv8FyEuVAlwOZvYPl4SE66/Q1FRCTTZFoyk5CQwOOPP86zzz570/PJycm0bt2ahIQEVq9ezYwZM/jqq6947bXXrHUOHz5M69atadKkCVu2bGHQoEE8/fTT/PXXX5kVtkg6N7qczl2O56GPVhKXmAwPvAUlGpgVlo6GKWGw/D34exJcvWDHaEVE8p5MH8301VdfMWjQIC5dumRT/ueff9KmTRtOnTpFQEAAAFOnTmX48OGcPXsWFxcXhg8fzh9//MGOHTus13Xu3JlLly6xYMGCO45Bo5nkv3p3/m4+X3EIgMK+bnzZ437Ku0TB953h/AHbyk7u8OTPUKKeHSIVEck9sv1opoiICCpVqmRNZABatmxJTEwMO3futNZp3ry5zXUtW7YkIiLitveOj48nJibGZhP5L0Y+GMqj1YsCcDo6jocmrWRPUgD0XwdNXzVX3g5pZFZOugbfdTRX3xYRkUxnt2QmMjLSJpEBrMeRkZG3rRMTE8O1a9duee8xY8bg6+tr3YKCgjI4eslrLBYLEx6vwssPhVrLhszeimFxgIZD4eGPoMdceORz82TCZfjqYUhOtFPEIiJ5x10lMyNGjMBisdx227NnT2bFesdGjhxJdHS0dTt+/Li9Q5JcwGKx0LdhKb7tXRuAXadjWLH/nG2lKp3gsS/N/ajt8M0jkJKSxZGKiOQtdzWV6YsvvkjPnj1vW6dkyZJ3dK/AwEDWrVtnUxYVFWU9d+O/N8rS1vHx8cHd3Z1bcXV1xdXV9Y7iELlb9cv407t+CF+uOszkpQdodF9B2woVH4Nts81Zg4+shN1zoUJ7u8QqIpIX3FXLTMGCBQkNDb3t5uLickf3CgsLY/v27Zw5c8ZaFh4ejo+PD+XLl7fWWbx4sc114eHhhIWF3U3YIhnu6QYhODtaWHv4Au0//ZszsXGpJy0W6DILitUyj1d9ALl/1RAREbvJtHdmjh07xpYtWzh27BjJycls2bKFLVu2cPnyZQBatGhB+fLl6datG1u3buWvv/7i1VdfpX///tZWlX79+nHo0CGGDRvGnj17mDx5Mj/88AODBw/OrLBF7khhX3c61CgGwJbjl/hw0X7bCg6O0OV7c2TT6S1waFmWxygikldk2tDsnj17MmPGjHTlS5cupXHjxgAcPXqUZ599lmXLluHp6UmPHj0YO3YsTk6pvV/Lli1j8ODB7Nq1i2LFijFq1Kh/7er6Jw3NlsxwNSGJCQv38eWqwzg7WrgvwBtXJwdeaV2eGsXzmZX+HA5rp0JIQ+jxu30DFhHJYe7097dWzRb5DwzDoPPna1h72HaivD8HNqBcYR+4dAwmVYOUJChQGvyC4fGvwM3XPgGLiOQgSmbSUDIjmSk2LpHNxy5x7nI8Q37Yai1fPrQxxQt4wtwXYNM/Wil9ipkJTccZ4F8miyMWEckZlMykoWRGssr6Ixd4fGrqpI7rXm5GIQ8HOL0Vds2BiE9sL6jwiNlSIyIi6SiZSUPJjGSlZXvP0HP6egAcLLD5tRb4ujubJ88fhPgYiDkNs7qYZflLQu9F4FnAThGLiGRP2X45A5HcqnHZQkzpWh2AFAO+XXM09WSBUlCkGoQ+ZM5HA3DhELxXEjbP1BBuEZF7oGRGJBM8WKkwb7atAMC0VYfNlbb/6bEvzWUQbvjtOXPhSiU0IiJ3RcmMSCbpWjuYYvncOX8lgR823GRJDYvFXKBy6EHwDTbL9i2AI6uyNE4RkZxOyYxIJnFydKBvQ3N5j8+WH2JfVCwXriSkr+jpDwO3QtWu5vGK9+DMHnNLvPWCqiIiYtILwCKZKC4xmXpjl3A+TRIzsWMVShfywsfNmRL+nqmVLxyGj6uDkWZhSjdfGLRd89KISJ6k0UxpKJkRe/pp4wnGL9jDmdj4dOf6NSrFoOZlcHN2NAuWjIYN08yE5tr1ifgcXaDbr+BXHPyCsjByERH7UjKThpIZyQ4OnLnMgO82ERuXxMlLqd1HD5QP4H/da6a/YOts+LWvbdlTC6C4FloVkbxByUwaSmYku4m+lkjvr9az4ehFAEY/UpH8Hi74ebhQp2R+LBaLWXHjV7BmCpzdYx5bHGHoAfDIb5/ARUSykJKZNJTMSHb1wvebmbv1lE3ZR52r0q5qUduKp7fBZw3M/dLNoetP5mgoEZFc7E5/fzvd8oyIZLqhLcsSG5fIlfhkLl5NYP+Zy3y0eD+X45MAqB6cz1ywsnBlc16an3vDgUVmi03Np+wbvIhINqGWGZFsIiYukXpjlhB7PZG54ad+YdQskR+Sk+DL5nBqs3mi07dQ7mE7RCoikjW0nIFIDuPj5sz7HavQqkIgLcoHWMs7TI3g/b/28teec9BzPnhcX8Np9pOwdIydohURyT7UMiOSTW07cYm2n/xtUzasVVmeCzoOMztAyvUWnH5/Q2BFO0QoIpK51DIjksNVLubHL8/VpWvtYByuv+v73l97OexbC17aD84eZuHfH9otRhGR7EAtMyI5wPnL8YSNWUJCcgr+Xi4sG9oEr/M74PNGYHGAqk+Y6zs1eBEc9V6/iOQOapkRyUUKeLny7dO1ATh3OYGa74QzcacHRqlm5mzBm7+FZe/CzMcgJeVf7iYikrsomRHJIWqF5KdHWHEA4hJTmLR4P3+VeQ0eeAsKlTcrHVoG+/60X5AiInagbiaRHMQwDBbsiOSP7aeZt+00oYHe/DmwARYjBb5oDqc2gXdhM7mp1MHsfhIRyaHUzSSSC1ksFh6sVJh32lfE08WRPZGxLNt3Fhwc4YnZ4OwJsafh4GL4fRBcPmPvkEVEMp2SGZEcyM/DhSdqBwMwZelBs9CrEPRZDI98DoGVITke3i8DexfYMVIRkcynZEYkh+pdvyTOjhbWHblAk/eX8eQXa4n2Kg1VOkGz11Irzn8JkhPtF6iISCZTMiOSQwX6utH5frN15vC5K6w6cI4mE5ZxLSEZyjwAvRaaFaOPwwcV4M8RdoxWRCTzKJkRycFee7g8vz5Xl36NSgFw4UoCP2w4bp4Mrg2txpr7l6Ng7RT4oCLEnLZTtCIimUPJjEgO5uzoQLXgfIx4MJRnGpUE4M3fdxI66k9GzdkBtftB/3VQooF5QfRxzRgsIrmOkhmRXGJw8/soXsCDFMOch+abNUfZExULBctC97nw0PtmxY0z4Mp5+wYrIpKBlMyI5BJuzo6ED27EquFNaFnBXHX706UHOX85nvNXE0mp0RsKV4Gka7Bqop2jFRHJOJo0TyQX2n4imoc/WWVTVjbAm1+bnMVjTi+zoN1kqNbVDtGJiNwZTZonkodVKuZLhxrFbMr2RsVScZYLCT7mCCjmD4X4y3aITkQkY6llRiQP+GLlId75YzcA9xfz4IdrfbFcOQMFSsOADWCx2DlCEZH01DIjIlZPNyjJgkHmiKb1J64yxbm7eeL8AdgfbsfIRET+OyUzInlEaKAPj1YrCsD4yOp8ntTaPPFrXzi3346RiYj8N0pmRPKQCR2r0D2sOABfJD1EAk5w7SJ8UhNWToRDyyD39zyLSC6jZEYkD7FYLLzVriLTe97PGfLxduKTqScXvwlft4PvO8Pls/YLUkTkLimZEcmDmoQWYsgD9/FNcgv6+EzBKN0cHJzNk/sWwIeV4OoF+wYpInKHMi2ZGT16NHXr1sXDwwM/P7+b1rFYLOm2WbNm2dRZtmwZ1atXx9XVldKlS/PVV19lVsgieUqPsBJ4ujgSfsaXd/O9zbou26ByJ/Nk0jWYVA3iou0bpIjIHci0ZCYhIYHHH3+cZ5999rb1pk+fzunTp61b+/btrecOHz5M69atadKkCVu2bGHQoEE8/fTT/PXXX5kVtkie4evhzBO1zTln/rfyMB2/3MxInmdF6WFmhbhLMLkuJFyxX5AiInfAKbNu/OabbwL8a0uKn58fgYGBNz03depUQkJCmDBhAgDlypVj1apVfPDBB7Rs2TJD4xXJiwY0LUN8UgpfRxwF4Pt1x/ieqgx2epSBTr9AzAlY+i60HG3nSEVEbs3u78z0798ff39/atWqxbRp00g7h19ERATNmze3qd+yZUsiIiJue8/4+HhiYmJsNhFJz9fdmbfaVWTF0Cb0rFuCR64P3f4gqQMzk5qZlSI+gQOL7BiliMjtZVrLzJ146623aNq0KR4eHixcuJDnnnuOy5cv88ILLwAQGRlJQECAzTUBAQHExMRw7do13N3db3rfMWPGWFuGROTfBRfw4I22FQB4oHwAz83cxCtJvajusJ9yDsfg28fY6NeKZIsTDqUbU7N1HztHLCKS6q5aZkaMGHHTl3bTbnv27Lnj+40aNYp69epRrVo1hg8fzrBhw3jvvffu+kv808iRI4mOjrZux48f/8/3FMkrHqpUmG971+a5xqV5IXGAtbzGpQXUujiPauuG8tbXf3A1IcmOUYqIpLqrlpkXX3yRnj173rZOyZIl7zmY2rVr8/bbbxMfH4+rqyuBgYFERUXZ1ImKisLHx+eWrTIArq6uuLq63nMcInld/TL+1C/jT5dawcyKCKH42WVACl6HFlDJ4TDPH+xL/bcm8USDigx54D4cHLS2k4jYz10lMwULFqRgwYKZFQtbtmwhX7581kQkLCyM+fPn29QJDw8nLCws02IQkVRB+T3o3LoF0AKAS7tbwuz25LNcZoNjb6atbEW9DU9ROtDP5jpPFydeaV2OoPweWR+0iOQ5mfbOzLFjx7hw4QLHjh0jOTmZLVu2AFC6dGm8vLz4/fffiYqKok6dOri5uREeHs67777LSy+9ZL1Hv379+OSTTxg2bBi9evViyZIl/PDDD/zxxx+ZFbaI3IZfuSYYYc9jifgYB4vB005/0jphLU8eGMlBo6hN3QU7I2lTuTBjH6uMl6tdX88TkVzOYhiZsxBLz549mTFjRrrypUuX0rhxYxYsWMDIkSM5cOAAhmFQunRpnn32Wfr06YODQ+qrPMuWLWPw4MHs2rWLYsWKMWrUqH/t6vqnO11CXETu0MGlpCwZjcPJ9daiBQ+Ec82jCHsiY/ls+SGb6jOfrk290v5ZHaWI5HB3+vs705KZ7ETJjEgmSE6CjdNhfmprKmVaQIfp7DyfzJcrD/PL5pPWU1WK+TKhY1VKF/KyQ7AikhMpmUlDyYxIJtrxM/zUy7bMvyw8+jl/Xy1G1y/W2pwa1aY8veuHZGGAIpJT3envb7tPmiciOVzFx+D5TVCrb2rZub3weSPqhbdj4+BKvPtIJeupt+ftYubao3YIVERyK7XMiEjGOXcAzuyEH7qnltXpD63eJSomjlYfruDi1UQA6pUuwIynauHkqH9TicjNqWVGRLKef2ko3w6GH4H2U82yNZ9CxGQCvF2JGNmMIr5uAPx94DxtPl5FUnKK/eIVkVxByYyIZDz3fFClMxQMNY//GgnTH8TN0cKKYU3o29CcXHNPZCylX/mT9UcuEBuXaMeARSQnUzeTiGSe5ESY2gDO7jaPW42D2s+AxcKY+bv5bIXtEO6BzcrQoUYx67G7iyP+XprNWySv0mimNJTMiNiRYcBfr5jdTQDF60HrieDiwfbLvjz55Vqir926VWZ8h8p0rBmURcGKSHaiZCYNJTMidnblHHzRDC4esS1v9ylUe5L4pGSe/GIt209GW0+lGJCQlEJRP3eWDW2Ms14UFslzlMykoWRGJJsIfw02zzS7n+KjweII/VZBQPl0VeMSk6k/bgnnLifwQtPSDGlR1g4Bi4g9aTSTiGQ/D7wFww7Ci3vAwx+MZJgSBovehMMrzVmFr3NzduSpeubkepOWHODd+btZffAciRr9JCL/oGRGRLKeiwc8OC71eNVEmNEGlo+1qdY9rDje1xep/HzFIZ7431p6TFtHckqub1AWkbugbiYRsZ/YKJjTD2Ij4cwucPGGh8aD5fq/s5zdOV+kCUN+2cOW45esLwoPa1WW5xqXtmPgIpIV9M5MGkpmRLK5lBSYUjd1CHda9QdD8zcwDIPu09axcv858nu68Pfwpri7OGZ9rCKSZfTOjIjkHA4O0HYS3PcglGpmbsF1zXPrvoBrl7BYLEzveT9B+d25cCWB57/fTB74t5iI3AElMyKSPQTVgidmQbdfzK3nH1CoPCTEwvedISUFJ0cH+jYsBcCi3VEM/3mbnYMWkexAyYyIZE8ODlBvkLl/LAKm1oNlY+lczoX7ArwA+GHDCbp+sYbxC/bwxcpDGukkkkfpnRkRyb5SkuGr1mYyc4OLF9f6b6Xp5K2cjo6zqV7Uz53nmpTiiVrBWCyWLA5WRDKaXgBOQ8mMSA6WnAirJ8GJjbD3D7OsRk9iHnifL1Yc4nJ8Msv3neHg2SvWS2qH5OfjLtUo5ONmp6BFJCMomUlDyYxILrH0XVg+DhxdYNB28A4EIDnF4Ns1R/lw0T4uXk1d5+mRakXpdH8QdUoWsFfEIvIfKJlJQ8mMSC5hGDCtJRxfCz5FYcAGcwK+667EJ/HOH7v4ft1xm8ualyuEg8VC8/IBWrRSJAdRMpOGkhmRXGTfQvjucXPf0QVK1Df3PQrAg+PBIz8r9p1l56kYxi3Yk+7ydx+pxBO1g7MwYBG5V0pm0lAyI5LLzH0BNs1IX+5ZEAZuBRdPAI6cu0LEofMYBrzx+04SkszRTp8+UZ3WlQtnZcQicg+UzKShZEYklzEMOLAIrl4wjw+vgC3fmvv5S8Jza8HJxeaSi1cSqPZ2OAD+Xq6sGt4EN2fNICySnWkGYBHJvSwWKPMAVOlkbu0/hbAB5rkLh2BsEJzcaHNJPk8X1r3cDIBzl+P5aeOJrI5aRDKJkhkRyR1avAPVu5v7SXGwcFS6KoV83Hjj4fIAvDpnB2sOnc/KCEUkkyiZEZHcwWKBhydBl1nm8dG/4b0ycOmYTbVO9wfj6mT+6Ov8+RremLszqyMVkQymZEZEcg+LBco+CLWeMY+vnIEV75vv2Fzn7uLIwsENuTFB8Ferj/DW77vsEKyIZBQlMyKS+7QaC+0+Nfc3zYB3CsHGGdakpngBT7a93oJaIfkBmPb3YSYs3MvVhCStxC2SA2k0k4jkXjM7wv6/Uo+D68JT87nRLGMYBm0+XsXOUzHWKnVLFWDm07W1tpNINqDRTCIiT8yGwbvAr7h5fGw1fPmAtYXGYrEw7/n6VA/2s16y+uB55m49ZYdgReReKZkRkdzLYgHfouZEevUGmWUn1sPcAWmqWPj52brsfqsVveuHADBw1hZ+2XSCmLjEm9xURLIbJTMikvtZLPDAm3D/0+bxlu/h4tE0py24uzjyTKOS1rIhP2yl6psLOXzuyj/vJiLZjJIZEck7Wk+Akk3ASIbfB0JKis3pQt5urBzWhNKFvABIMaDJ+8uIjI6zR7QicoeUzIhI3lJ/sPnfQ0vh+05w5ZzN6aD8Hiwa0ojZfetYy+qMWczSvWe4Ep+UlZGKyB1SMiMieUtIQ7N1BmD/QpgQCpfPpqtWu2QBpvWsaT1+avp6Bs/ekkVBisjdUDIjInmLxQJP/gxVnzSPUxJhYmjqopVpNA0N4NMnqlMlyA8HCyzcFcWHi/YRn5ScxUGLyO1onhkRybu2/Qi/XH8p2D0fDNwGbjf/GdH/u038se00AKULefFUvRIU9XOncdlCWRWtSJ5j93lmjhw5Qu/evQkJCcHd3Z1SpUrx+uuvk5CQYFNv27ZtNGjQADc3N4KCghg/fny6e/3444+Ehobi5uZGpUqVmD9/fmaFLSJ5SeXH4cH3zP1rF2FSVTi1+aZVR7QKpcz1F4MPnLnMK7/uoOf09azcn76LSkSyVqYlM3v27CElJYXPPvuMnTt38sEHHzB16lRefvlla52YmBhatGhB8eLF2bhxI++99x5vvPEGn3/+ubXO6tWr6dKlC71792bz5s20b9+e9u3bs2PHjswKXUTyktp9odEIc//qefi8MYS/BucP2lQLyu/BwsENGdS8DC0rBFC+sPmvxMlLDyIi9pWl3UzvvfceU6ZM4dChQwBMmTKFV155hcjISFxcXAAYMWIEc+bMYc+ePQB06tSJK1euMG/ePOt96tSpQ9WqVZk6deodfa66mUTkX63/Av540bas3iAoXhfua5mu+qlL12j03lISkw161i1BoK8bPeuWwM3ZMWviFckD7N7NdDPR0dHkz5/fehwREUHDhg2tiQxAy5Yt2bt3LxcvXrTWad68uc19WrZsSURExC0/Jz4+npiYGJtNROS27n8a+v0NVbumlv39IXzX0Zxk7x+K+LnTvmpRwFx5e+yfe/hs+aEsClZE0sqyZObAgQN8/PHHPPPMM9ayyMhIAgICbOrdOI6MjLxtnRvnb2bMmDH4+vpat6CgoIz6GiKSmwVWhPaTocfvUOe51PI5/eCvVyDZdnmDkQ+Vo3+TUjxcpQgAX60+zNUEzUUjktXuOpkZMWIEFovlttuNLqIbTp48SatWrXj88cfp06dPhgV/KyNHjiQ6Otq6HT9+PNM/U0RykZCG0GoMDN6ZWhbxCWz+xqZafk8XhrYM5YOOVShewIOLVxOZtU4/b0SymtPdXvDiiy/Ss2fP29YpWTJ1fZNTp07RpEkT6tata/NiL0BgYCBRUVE2ZTeOAwMDb1vnxvmbcXV1xdXV9V+/i4jIbfkWMxepnN0NIrfB3x9Bte7gaPuj08nRgb4NS/LKrzt4a94uqgb7UT04n52CFsl77rplpmDBgoSGht52u/EOzMmTJ2ncuDE1atRg+vTpODjYflxYWBgrVqwgMTG16TY8PJyyZcuSL18+a53FixfbXBceHk5YWNhdf1kRkbuWrwT0WgDu+eHiEZj1BNxk3MRj1YuR39P82ffo5NVMXnYga+MUycMy7Z2ZG4lMcHAw77//PmfPniUyMtLmXZcnnngCFxcXevfuzc6dO5k9ezYfffQRQ4YMsdYZOHAgCxYsYMKECezZs4c33niDDRs2MGDAgMwKXUTElosnhPU39/f/BYeWpavi5uzItJ73W4/HL9jL9hPRWRSgSN6WaclMeHg4Bw4cYPHixRQrVozChQtbtxt8fX1ZuHAhhw8fpkaNGrz44ou89tpr9O3b11qnbt26fPfdd3z++edUqVKFn376iTlz5lCxYsXMCl1EJL16g6BIdXP/m/aw+uN0VaoG+bH4xUYU8XUDYMpytc6IZAUtZyAicqcuHYePa0ByvHnsVxyavwEVH7WpticyhlYfrgTgpRb3MaBpmSwOVCR3yJbzzIiI5Gh+QdB/DfgFm8eXjsKCEZAYZ1MtNNCH5uXMNZsmLTnA2dj4rI5UJE9RMiMicjfyl4T+66DXX+AbBJej4P0y8FEViNplrfbJE9Up5O1KQlIK949exLxtp+wYtEjupmRGRORuObtDcB1oONQ8jo8xRzotHW2t4ubsyPuPV7Eev/vHbhKSUrI4UJG8Qe/MiIj8F5eOw/kD5kvBYLbaFCxrPX38wlWaTVhOQrKZyLSpXJjxHSrb3MLBYtGaTiI3cae/v5XMiIhkhFldYc88KN8eOs6wOTVz7VFe+XXHbS/vUiuIl1qUxc/DBUcHSyYGKpJzKJlJQ8mMiGS64+vhy+uL4jZ5BRoNszkdG5fIm7/v4qeNJ257m2L53Fk0pJFaakRQMmNDyYyIZIlvHoGDS8DFCwbvAPf0SxrEJSanm0B4yA9b+HNH6oSifh7OLB7SiAJeWpZF8jYNzRYRyWpP/gKFKkDCZVj/xU2ruDk74u5iu015sgZHxrZm3GOVALh0NZEa7yxi1f5zWRm9SI6lZEZEJKNYLFB/sLm/ZiokXL2ryzvdH8xrbcpbj5/8ci2bjl3MyAhFciUlMyIiGanCI+akelfPwZx+cO3SXV3eq34IS19qbD1+dPJqFu+OIg+8ESByz5TMiIhkJEcnqPuCub/rN5j5+E1X2b6dEH9P/nihvvW494wNvD53Z0ZGKZKrKJkREclo1bpBaBtz/8Q6mP8SxF++q1tUKOLLj/3CcHY0h2l/HXGUQbM2s+3EpQwOViTn02gmEZHMMn8YrPvM3PcuDI2GQ0hDKFDqjm8Rl5hM4/eWERmTuv7TpC7VaFulSEZHK5LtaDSTiIi9NRoGxeuZ+7GnYd4g+Lg6/D0JYiNve+kNbs6OLBzSkEerFbWWvfD9ZpbtPZMJAYvkTGqZERHJbBGT4chK2Ds/TaHFnFzvn4LrQEiDm97m2PmrNHxvKQBerk5EjGyKt5tzJgQskj1o0rw0lMyISLZwZJXZKrP/r1vXcXSBgVvB5+bdSPuiYmnxwQoAWpQPoHQhLyoW9eWhSoUzI2IRu1Iyk4aSGRHJVnb9Zs4U/E9HVpmLVoYNgJaj05+/7ocNxxn20zabsj9eqE+FIr4ZHamIXSmZSUPJjIjkCPsWwnePm/t1X4Bmr5tDvf8hOcVg2qrDnI6OY+PRC2w9EU35wj40KluQgc3KaF0nyTWUzKShZEZEcgTDgKkNIGq7eVyyMTz5KzjceqzGrlMxPDRppfXY282JpqGFcHd2ZGDzMhT2dc/koEUyj0YziYjkNBYLdPoaAsw1mji0DPb9edtLyhfx4cseNalZ3FzUMjYuid+2nGLW+uOM/mN3Jgcskj2oZUZEJLtJSYYvmsOpTVC0Jjy9yEx0bsMwDH7fdpqzsfFcjU9iQvg+AF5rU55e9UOyImqRDKeWGRGRnMrBEZ6YDU5ucHKDOT/Nv7BYLLStUoTe9UN4vlkZGpctCMC4BXs4dzk+kwMWsS8lMyIi2ZFXIajR09zf+BVE3d3aTB91roa7syPxSSlM//twhocnkp0omRERya4eeAsKlDb3Z7SFj2vCDz0gOfFfL/V1d+aDTlUB+N/Kwzz40UrWHDqficGK2I+SGRGR7MrJFTpMBwcnuHoOzu+HXXPgbX/4c8S/Xt6ifADlCvuQkJTC7tMxdP58DdtPRGd+3CJZTC8Ai4hkdxcOmWs5bZgO239ILe+7HIpUve2lMXGJrD10gT5fb7CW+XmYSyC4OTny/uNVqF/GPzOiFvnPNM9MGkpmRCRXMAw4tw+WvA27fzdbbJw9oNUYqPbkbS/dcTKaNh+vSlceGujNnwMbYPmX0VIi9qBkJg0lMyKSq5zZA583hqRr5rFnQRiwHtzz3fay6KuJnL0cB0BcYgqdPovgSkIyAAsHN+S+AO/MjFrkrmlotohIblUoFF7aZy5I6RsEV87CuBIwq+ttL/P1cKZ0IW9KF/KmYlFf+jUqZT03afH+TA5aJPMomRERyYncfCBfCWg6CizX12LaMw/2zDffr7kDzzcrww/PhAEwf/tpNh69wPELV0lMTsmkoEUyh7qZRERyuqQE+GMIbP4mtaz5m1B/0B1d3uur9SzZc8Z6XNjXjelP3Y/j9fdoiuZzx8Ml/YKXIplN78ykoWRGRHK9i0fh67Zmq0xSHLj5weAd4Prv78HsPBXNU9PXE30tkfik9K0y7s6O/Dagnt6pkSynZCYNJTMikmekJMOnteD8AajwCDw8yeySukPfrzvGxPB9JKeYvxouXEmwnuvfpBSd7w8mKL9HhoctcjNKZtJQMiMiecqmr2Hu8+a+mx8M2n5XCU1aC3acpt+3m2zKvuldiwZlCv7HIEX+nUYziYjkVZU7Q2gbcz/uEnzf5Z5v1apiYTaPeoB6pQtYy7p9uY6zsVq8UrIPJTMiIrmNkwt0ngmtJ5jHR1fB6k9g6yzY95c5+d5dyOfpwsyn67BoSENrmRavlOxE3UwiIrnZnP6w5VvbspKNoXw7cHI3/+ty5+/ALNwZSd9vNgLwXofKdKhRTLMHS6axezfTkSNH6N27NyEhIbi7u1OqVClef/11EhISbOpYLJZ025o1a2zu9eOPPxIaGoqbmxuVKlVi/vz5mRW2iEju0vQVKN8eSjUzkxeAQ8tg3mCY0w8Wv3VXt2teLoAyhbwAGPrTNrr8bw3L953N2JhF7lKmTRywZ88eUlJS+OyzzyhdujQ7duygT58+XLlyhffff9+m7qJFi6hQoYL1uECB1L7Z1atX06VLF8aMGUObNm347rvvaN++PZs2baJixYqZFb6ISO7gUwQ6zjD3E+MgfBTEnDKHbx9YBBu/As8CUK4dFLzvX2/n4GBhfIfK9Lw+lHvNoQusObSOzvcHMapNeTxdNR+NZL0s7WZ67733mDJlCocOHQLMlpmQkBA2b95M1apVb3pNp06duHLlCvPmzbOW1alTh6pVqzJ16tQ7+lx1M4mI/INhwP+awKnN5nH+Uub6Tg6Od3R5XGIy7/+1ly9Wpb47k8/DmS61gilewIOONYPU/ST/md27mW4mOjqa/Pnzpytv27YthQoVon79+sydO9fmXEREBM2bN7cpa9myJREREbf8nPj4eGJiYmw2ERFJw2KB9lPh/j7m8O0LB+GXPvDnCNi38F8vd3N25NU25Vn3SjPqlDR/rl+8msjkZQcZ/vN2Hp2ymgU77mxZBZH/KsuSmQMHDvDxxx/zzDPPWMu8vLyYMGECP/74I3/88Qf169enffv2NglNZGQkAQEBNvcKCAggMvLW/5OMGTMGX19f6xYUFJTxX0hEJKcrFAqt34c6z5rHO36GtVPgu8fhj5fMZRL+7Rbebnzfpw7vPlKJXvVC8HV3BmDzsUv0+3Yjs9Ydy8xvIALcQzfTiBEjGDdu3G3r7N69m9DQUOvxyZMnadSoEY0bN+aLL7647bXdu3fn8OHDrFy5EgAXFxdmzJhBly6p8yRMnjyZN998k6ioqJveIz4+nvj41DkQYmJiCAoKUjeTiMjNJMbBus/g2iVYNTG13KMAlGoKJepDjZ53dKurCUl8tfoI4xfstZY1L1cIT1cnqgb58VS9kIyNXXK1O+1muus3tV588UV69ux52zolS5a07p86dYomTZpQt25dPv/883+9f+3atQkPD7ceBwYGpktaoqKiCAwMvOU9XF1dcXV1/dfPEhERwNkN6g0092v2gp96wYl1cPU8bP/R3DZ9A96BUKA0NHvtlu/WeLg48Vzj0nSoXoxa7y4GYNFucxHL37acokqQH9WD82XJ15K8I1NfAD558iRNmjShRo0afPvttzg6/vuLZX369GHjxo1s2mROn92pUyeuXr3K77//bq1Tt25dKleurBeARUQyQ0qKmcBcPQ/Lx0JctO35+1pBl1nmeze3cerSNRbujCTZgGV7z7By/zkA1r7cjAAft8yKXnKRTGuZuVMnT56kcePGFC9enPfff5+zZ1PnIbjRqjJjxgxcXFyoVq0aAL/88gvTpk2z6YoaOHAgjRo1YsKECbRu3ZpZs2axYcOGO2rlERGRe+DgAFU6mftVn4A9f0BygjmM+/QW2LcADi83J9+7jSJ+7vS83q3U6L6CNJ+4HIAPwvcx9rHKmRe/5DmZ1jLz1Vdf8dRTT9303I2PnDFjBuPGjePo0aM4OTkRGhrK0KFD6dChg039H3/8kVdffZUjR45QpkwZxo8fz0MPPXTHsahlRkQkAyQnwZfNzeHcJRtD99/u6vKvI47w2m87cXa0sHJYUwJ91Tojt6dVs9NQMiMikkEuHYOPqoKRbL4/gwUKlYPHvjTXhPoXHadGsO7IBQp5u1KzRD4+7FQNFyctEyg3ly3nmRERkRzOLxiqdTX3zx+A8/th91wYHQAnNvzr5S80KwPAmdh45m+PpNxrC9h6/FImBix5gZIZERG5Ow9NgN6L4Kk/oXJns8xIgS+awaI3b3tp/TL+LBrSkPZViwCQnGIw9s89mR2x5HLqZhIRkXtnGObCld+0T1NoATdfaPcplGtzi8sMVu4/R/dp6wD45bm6VAvy0xIIYkPdTCIikvksFijVBIYfhaA61wsNiLsEs7vCrK7mi8PpLrPQ8L6CPF6jGACPTl5N/XFLOXHxKnng39iSwdQyIyIiGSMlBWJPQVwMfNUarl24fsJiLmLpXybdJYfPXaHtx6uIjU9NeKoH+/Fjv7o4OqiVJq9Ty4yIiGQtBwfwLQYB5eGl/VDjxvQcBnxSEy4dT3dJiL8nG0Y156POVXF2NJOXTccu8eWqQ6Sk5Pp/a0sGUcuMiIhknmNrYVoLc9/iCCOOgavXTasmJqcwafF+Pl5yAIBaIfmZ1acODmqhybPUMiMiIvYXXBt6/mHuG8mw+K1bVnV2dKB3/RBK+nsCsO7wBTp/voZtJy4RG5eYFdFKDqVkRkREMleJ+vDwJHN/3Wew89dbVvXzcGHJS43pVqe4Wf3IBdp+8jf3j17E7tMxWRGt5EBKZkREJPNV6Qze5twyLBtnvix8G2+3r0jPuiUo6ucOQFxiCg9+tJK/D5zL7EglB9I7MyIikjXiouGDihAfA01fhbKtzZeF/8X87ad5buYmAKoG+fFMw5LWc4V83KhRPF+mhSz2pbWZ0lAyIyKSTYS/Dn9/mHr8wFtQ5zlwdL7tZaejr9Fw/FISk9P/yvqmdy0alCmYwYFKdqBkJg0lMyIi2cTVC/D7QHM9pxsCK0PNpyBfiDkB3y18u+Yoc7eeguu/tc5ejufwuSt4ujiyekQzfD1unxBJzqNkJg0lMyIi2cy5/TCzA1w8Ylte6XGo3Q+K1fzXW6RtrfH3cmXZ0MZ4uTplTrxiF0pm0lAyIyKSDaUkw9LRcHYv7Jlne652P/DwTz0OaQDBdfinqcsPWheqfLJOMO+0r5SZEUsWUzKThpIZEZFs7vJZWPYubJh26zqNRkDDoeBo2/ry7vzdfL7iEC5ODqwa3oRC3m6ZHKxkFSUzaSiZERHJIc7uhXX/g5Trk+QZBmyakXq+9QS4/2mbSwzDoMPUCDYevUhJf0/+HNQAVyfHLAxaMouSmTSUzIiI5GBn98GsLnD+AHgFwn0twMULGrwInmZX1KJdUTz99QYARj4YyjONStkzYskgWs5ARERyh4L3wTMrzXdoLkfCpq9hzWR4rzTsDwegWblCtKoQCMCYP/ew8ehFe0YsWUzJjIiIZH8uHtDtF2g6Csq1vV5owM+9IT4Wi8XCpC7VCPBxBeCxKauZuvyg/eKVLKVkRkREcobCVaDhS9DpG+gy2yyLi4aNXwHg4uTA591Sh3SPVQtNnqFkRkREcp6yraDtx+b+wlfh8EoAqgT5sXBwQwr7miOa1DqTNyiZERGRnKlyZ/AoYO7PaAMnzfWb7gvw5tuna2OxQPiuKB6Z/DcXriTYMVDJbEpmREQkZ3Jygaf+TD3+62XrbqmCXrSpbK7SvfnYJaq/Hc6A7zaRmHz71bolZ1IyIyIiOVfBstBnibl/LAKORlhPjX+sMv3SDNGet+00f2w7ndURShZQMiMiIjlb0RpQvYe5v+oDa7G7iyMjHgxl0ZCG9KoXAsCUZQfJA9Or5TlKZkREJOerNxAsDrD/L4jcYXOqdCFvBjYvg5erE3ujYin32gLGzN9tp0AlMyiZERGRnK9AKSjfztyfWs9clTtNC4yvuzPPNCwJQFxiCp+tOMT+qFh7RCqZQMmMiIjkDg2Hpu5/UhOm1oekeGvR883KsO7lZjQoYy6B8MAHK/ggfB8pKep2yumUzIiISO4QUAG6zwVHF/M4agdsm21TpZCPGy+1KGs9/mjxftp9+jfJSmhyNCUzIiKSe5RsBC+fguZvmscLX4XYSJsqVYL82PtOK2oUzwfA9pPRfBNxJIsDlYykZEZERHIXR2e4vze4+ZnLHUwoC+v+B5fPWqu4Ojny87N1GdisDABv/L6LL1cdZk9kjLqdciAlMyIikvu4esMDb6Uez38J3i8NUTttqvWqF4KDxdx/e94uWn24kj5fb+CiZgzOUZTMiIhI7lSjBwzaAYWrppZNqQsXDlkPfT2ciRjZjCrFfK1li/ec4f7RizgTG5eFwcp/oWRGRERyL78geGY59A5PLZtUDY6uth4G+Ljx24D6HHr3IR6vUQyApBSDzp+tUZdTDqFkRkREcr+gWtDt19Tj6Q/CHy9CfOpcMw4OFt57vAqTu1YH4NC5Kwz/eRsxcYlZHa3cJSUzIiKSN5RqCp2/Tz1e/wV8XDPdjMEPVSrMM43MCfZ+3HiCJu8tY8fJ6KyMVO5SpiYzbdu2JTg4GDc3NwoXLky3bt04deqUTZ1t27bRoEED3NzcCAoKYvz48enu8+OPPxIaGoqbmxuVKlVi/vz5mRm2iIjkVqEPwdBDULy+eXw50pwxeO1nkJK6ovZzjUpbJ9c7fyWBx6dGcO5y/M3uKNlApiYzTZo04YcffmDv3r38/PPPHDx4kA4dOljPx8TE0KJFC4oXL87GjRt57733eOONN/j888+tdVavXk2XLl3o3bs3mzdvpn379rRv354dO3bc7CNFRERuz7MAPPUHtBqXWvbnMPiiKez+HTBfDP6md23eblcBgGuJycxYfcQOwcqdsBhZuHzo3Llzad++PfHx8Tg7OzNlyhReeeUVIiMjcXExZ2wcMWIEc+bMYc+ePQB06tSJK1euMG/ePOt96tSpQ9WqVZk6deodfW5MTAy+vr5ER0fj4+OT8V9MRERyptPbYObjZgvNDb0XQdD91sMFO07T79tN+Lg58WSd4tZyiwWahgZYJ9+TjHenv7+z7J2ZCxcuMHPmTOrWrYuzszMAERERNGzY0JrIALRs2ZK9e/dy8eJFa53mzZvb3Ktly5ZERETc8rPi4+OJiYmx2URERNIpXBkGbYOGw6BINbPsy+awP3X0U4vygZQq6ElMXBKTlx20bp8uPchjU1az7vAFOwUvN2R6MjN8+HA8PT0pUKAAx44d47fffrOei4yMJCAgwKb+jePIyMjb1rlx/mbGjBmDr6+vdQsKCsqoryMiIrmNkys0fQUeSX3FgZkdYOccwBzl9MkT1enTIIRe9cytZ90S1qodP4vgi5WHyMKODvmHu05mRowYgcViue12o4sIYOjQoWzevJmFCxfi6OhI9+7dM/0PfOTIkURHR1u348ePZ+rniYhILlDwPtvRTr8PtA7dLlfYh1dal+e1h83tjbYV+H1AfWvVd/7YzeNTI4iK0UR79uB0txe8+OKL9OzZ87Z1SpYsad339/fH39+f++67j3LlyhEUFMSaNWsICwsjMDCQqKgom2tvHAcGBlr/e7M6N87fjKurK66urnfztURERMzRTgO3wkdVIO4SfFgZuv4ExWqkq1qpmC9/vFCfXl+tJyomng1HL1L73cW0KB9ACX9PhrUsi5OjZkDJCnedzBQsWJCCBQve04elXB/2Fh9vDm8LCwvjlVdeITEx0foeTXh4OGXLliVfvnzWOosXL2bQoEHW+4SHhxMWFnZPMYiIiNxWvhLQ7lP4rT9cu2COcmr2OjQYkq5qhSK+LH2pMeP+3MOMiKMALNxl/gP8hw3HqVTUl4cqFaZLreCs/AZ5TqaNZlq7di3r16+nfv365MuXj4MHDzJq1CiioqLYuXMnrq6uREdHU7ZsWVq0aMHw4cPZsWMHvXr14oMPPqBv376AOTS7UaNGjB07ltatWzNr1izeffddNm3aRMWKFe8oFo1mEhGRu2IYsPlbmDsgtazvstSXhG8i4uB5Dp+7wg8bjrPl+CWbc++0r2gzEkruzJ3+/s60ZGb79u0MHDiQrVu3cuXKFQoXLkyrVq149dVXKVq0qLXetm3b6N+/P+vXr8ff35/nn3+e4cOH29zrxx9/5NVXX+XIkSOUKVOG8ePH89BDD91xLEpmRETknpzbD1+3h5gTUL49dJzxr5ckpxgs3h3FlYQkXv5lB9cSk/F0cWT1iGb4ejhnesi5id2TmexEyYyIiNyzqJ3mattYoEDp1HKLBSp3hIZDb3lp9NVE7n93EQlJKbzU4j4GNC2T+fHmItlunhkREZEcKaAClGsLGHB+f+p2bh8seQfevw+2zr7ppb4ezox/rDIA7y/cx3MzN5KslbgznFpmRERE/k1iHJzeCkZyatnvg+Dc3tTjsq2h07fgYNtOkJScQquPVnLgzGVrWd+GJXn5oXKZHHTOp26mNJTMiIhIhktKgKjt8M2j5jBugI7fQLmHzX2LxVr1SnwSr87Zwa+bT9rcwsfNibGPVeahSoWzKOicRclMGkpmREQk0yTGwZxnYecvqWW+QdDzD/D0B2cPsFgwDIMTF68x9KetrDmUugRCcH4P/nihPu7OjpqX5h+UzKShZEZERDLV5bMwtb7tgpU3hDSC7r9ZW2oMw+B0dBwJSSk8OmU1F64kAODp4siMXrWoGuSnpOY6vQAsIiKSVbwKwuAdMPQQPPYlOKQZgn14Ocx42Jy7BrBYLBTxc6eEvyeDmpfB4Xpv1JWEZDpMjaDWu4s5fuGqHb5EzqWWGRERkYyWnGhuS96GNZPNstIPQIt3zBaafCHg5AJAfFIyO0/F0HPaOmLikqy3GNaqLA+UMxdadnN2pFg+dyxp3sPJC9TNlIaSGRERsZvf+puzCaflFwyPfwVO7lAw1DoCauHOSPp+s/GmtxnzaKU8tyyCkpk0lMyIiIhdzX0B9syDlOTUkU83NHkFGg2zHkZfS6THtHUcu97VlJScQkxcEg4W2PjqA+TzdMnCwO1LyUwaSmZERCTbWDPF7HpKToTY0+DqC49+Dj5FoHDldNXjEpOpP24p5y7H4+xoYdOoB/B2yxvLIugFYBERkeyozrMwaDsM3gX+ZSE+Gr7vBJ81gD+Hw9m9NtXdnB157eHyACQmGzw9Y4M9os7WlMyIiIjYg4MDtH4fitVKLVs7FT6tBWs/N7ukrmtbpQhvt6tgVjl8gS9WHmJfVGxWR5xtqZtJRETE3i6fhXmDzPdqbihaE6p1NfedPaB8e16as5efNp6wVhnasixtqxQhKL9H1sabRfTOTBpKZkREJEeI2gXfPgaxp9KfyxfC2Ye/5o2IJP7YftpaXLKgJ+GDG+HokPuGbSuZSUPJjIiI5BjJSbD4Dbhw2Dw+swsuHDL3fYrCC5vZERXH1OUHWb73LLHxSXSpFUwRXzdqheSndskCdgs9oymZSUPJjIiI5FiGASvfhyXvmMdtP4bq3QGYGL6PSYv3W6u6ODmwangTCnm72SPSDHenv7+dsjAmERERuVsWCzQcCk5usPBVWDbO7I4qHka/Rq1JTE7h0tVEIg6e48j5q0z/+wjDW4XaO+ospZYZERGRnCA+Fj6oaDvpXpkWUKQ6NHyJ8L0X6PO1OWz7ucaleLFF2Rz/Ho26mdJQMiMiIrnC8XWw7y9YNRGMlNRyrwBS6g6k1dqK7Iu6DECIvyf/616T0oW87BTsf6dkJg0lMyIikqvERsG2WbDtR4jabi2OrvoMHQ+3YW+aOWhWDmuSY4duK5lJQ8mMiIjkSinJsO0HWPymuTQCkNRvDVN3OfH+wn3Wao3LFqRbneI0u74Kd06hZCYNJTMiIpKrxV+Gj2vA5Uio2hXaT+bnjSd48cetNtWqB/vh5ebM2+0qULyAp52CvXNKZtJQMiMiIrneiQ3wRTNwcIIXtoBfEFuOX2JfVCzDftqWrvral5sR4JO9h3BroUkREZG8pFhNKNEAUpLM9Z3ioqka5EfHmkGse7kZU5+szosP3GetnnZ+mpxOLTMiIiK5xeEVMOPh1OMnfoD7WtpU+X7dMUb+sh1HBwsB3q4AWCwW2lcrwtCW2Wt+GrXMiIiI5DUhDaH5m6nH33WEI3/bVOl8fxBhJQuQnGJwKjqOU9FxnLx0jU+XHmTiwr1ZHHDGUMuMiIhIbnN6G3zWIPXY2RPqD4aGLwEQl5TCgTOXuZEBDP1pK3sizeHcr7UpT6/6IVkd8U3pBeA0lMyIiEiec+EwfFobkuNty509oNO3ULqZtSg5xaDRe0s5cfEaAJWL+fJN79o4O6bOIOzk4ICLU9Z26CiZSUPJjIiI5EkJV+HKWfixJ5zaZHuu7zIoUs16mJScQssPV3Dw7JWb3srF0YEvetSk4X0FMy/ef9A7MyIiInmdiwfkKw59lsDQQ/Dc2tRz84ZAQmri4uToQPjgRgxtWZabLemUkJzCK3O2ExuXmAWB3x21zIiIiOQl5w7AJzVSj7v9CsFh4OxuLYpPSiYlzdJPl64l0OT9ZcQlmoU/PxtGjeL5Mz1UtcyIiIhIev6loe7zqcffPAJTG0BSgrXI1ckRd5fUrbCvO4Oap85R89iUCP7aGcm2E5es25X4pKz8FjbUMiMiIpIXHV8PP/eCmFPmRHs1e0GLd8Dl1sscHDgTS/OJK2567pfn6lI9OF+GhqiWGREREbm1oPth0HZo+qp5vGEaTK5jvjR8C6ULefNb/3qULuRFUT93m83F0X4phVpmRERE8rL4WPi+CxxZaR77BUO3OVCglF3DAg3NtqFkRkRE5F8sfReWj0s9bjEaPP1Tj128oOyD4OCYZSHd6e9vpyyLSERERLKvJi+Dkxssvr4cwsJX0tdp/oY5k3A2k6kdXG3btiU4OBg3NzcKFy5Mt27dOHXqlPX8kSNHsFgs6bY1a9bY3OfHH38kNDQUNzc3KlWqxPz58zMzbBERkbypwRDosxTKPgSlmqVuxWqZ5xe9AVE77RrizWRqN9MHH3xAWFgYhQsX5uTJk7z0krkmxOrVqwEzmQkJCWHRokVUqFDBel2BAgVwdna21m3YsCFjxoyhTZs2fPfdd4wbN45NmzZRsWLFO4pD3UwiIiL/QXIiTKoO0ccgXwl4flOWdDdly3dm5s6dS/v27YmPj8fZ2dmazGzevJmqVave9JpOnTpx5coV5s2bZy2rU6cOVatWZerUqXf0uUpmRERE/qPDK2DGw+Z+lSfgkSmZ/pHZbmj2hQsXmDlzJnXr1rW2utzQtm1bChUqRP369Zk7d67NuYiICJo3b25T1rJlSyIiIm75WfHx8cTExNhsIiIi8h+ENIRGI8z9rd/B9IfgzxGp28Wjdgst05OZ4cOH4+npSYECBTh27Bi//fab9ZyXlxcTJkzgxx9/5I8//qB+/fq0b9/eJqGJjIwkICDA5p4BAQFERkbe8jPHjBmDr6+vdQsKCsr4LyYiIpLX1B8Evtd/px79G9ZOSd0un7FbWHfdzTRixAjGjRt32zq7d+8mNDQUgHPnznHhwgWOHj3Km2++ia+vL/PmzcNiuckqVkD37t05fPgwK1ea491dXFyYMWMGXbp0sdaZPHkyb775JlFRUTe9R3x8PPHxqUuex8TEEBQUpG4mERGR/youBtb/z2aRSgBqPAV+Gdt4kGlDs1988UV69ux52zolS5a07vv7++Pv7899991HuXLlCAoKYs2aNYSFhd302tq1axMeHm49DgwMTJe0REVFERgYeMvPd3V1xdXV9Q6+jYiIiNwVNx9o8KK9o7Bx18lMwYIFKViw4D19WMr1JTjTtpr805YtWyhcuLD1OCwsjMWLFzNo0CBrWXh4+C2TIREREclbMm3SvLVr17J+/Xrq169Pvnz5OHjwIKNGjaJUqVLWRGTGjBm4uLhQrVo1AH755RemTZvGF198Yb3PwIEDadSoERMmTKB169bMmjWLDRs28Pnnn2dW6CIiIpKDZFoy4+HhwS+//MLrr7/OlStXKFy4MK1ateLVV1+16QJ6++23OXr0KE5OToSGhjJ79mw6dOhgPV+3bl2+++47Xn31VV5++WXKlCnDnDlz7niOGREREcndtDaTiIiIZEvZbp4ZERERkcygZEZERERyNCUzIiIikqMpmREREZEcTcmMiIiI5GhKZkRERCRHUzIjIiIiOZqSGREREcnRlMyIiIhIjpZpyxlkJzcmOY6JibFzJCIiInKnbvze/rfFCvJEMhMbGwtAUFCQnSMRERGRuxUbG4uvr+8tz+eJtZlSUlI4deoU3t7eWCyWDLtvTEwMQUFBHD9+XGs+ZTI966yh55w19Jyzhp5z1smsZ20YBrGxsRQpUgQHh1u/GZMnWmYcHBwoVqxYpt3fx8dH/6NkET3rrKHnnDX0nLOGnnPWyYxnfbsWmRv0ArCIiIjkaEpmREREJEdTMvMfuLq68vrrr+Pq6mrvUHI9PeusoeecNfScs4aec9ax97POEy8Ai4iISO6llhkRERHJ0ZTMiIiISI6mZEZERERyNCUzIiIikqMpmfkPPv30U0qUKIGbmxu1a9dm3bp19g4pxxgzZgz3338/3t7eFCpUiPbt27N3716bOnFxcfTv358CBQrg5eXFY489RlRUlE2dY8eO0bp1azw8PChUqBBDhw4lKSkpK79KjjJ27FgsFguDBg2yluk5Z5yTJ0/y5JNPUqBAAdzd3alUqRIbNmywnjcMg9dee43ChQvj7u5O8+bN2b9/v809Lly4QNeuXfHx8cHPz4/evXtz+fLlrP4q2VZycjKjRo0iJCQEd3d3SpUqxdtvv22zdo+e871ZsWIFDz/8MEWKFMFisTBnzhyb8xn1XLdt20aDBg1wc3MjKCiI8ePH//fgDbkns2bNMlxcXIxp06YZO3fuNPr06WP4+fkZUVFR9g4tR2jZsqUxffp0Y8eOHcaWLVuMhx56yAgODjYuX75srdOvXz8jKCjIWLx4sbFhwwajTp06Rt26da3nk5KSjIoVKxrNmzc3Nm/ebMyfP9/w9/c3Ro4caY+vlO2tW7fOKFGihFG5cmVj4MCB1nI954xx4cIFo3jx4kbPnj2NtWvXGocOHTL++usv48CBA9Y6Y8eONXx9fY05c+YYW7duNdq2bWuEhIQY165ds9Zp1aqVUaVKFWPNmjXGypUrjdKlSxtdunSxx1fKlkaPHm0UKFDAmDdvnnH48GHjxx9/NLy8vIyPPvrIWkfP+d7Mnz/feOWVV4xffvnFAIxff/3V5nxGPNfo6GgjICDA6Nq1q7Fjxw7j+++/N9zd3Y3PPvvsP8WuZOYe1apVy+jfv7/1ODk52ShSpIgxZswYO0aVc505c8YAjOXLlxuGYRiXLl0ynJ2djR9//NFaZ/fu3QZgREREGIZh/o/n4OBgREZGWutMmTLF8PHxMeLj47P2C2RzsbGxRpkyZYzw8HCjUaNG1mRGzznjDB8+3Khfv/4tz6ekpBiBgYHGe++9Zy27dOmS4erqanz//feGYRjGrl27DMBYv369tc6ff/5pWCwW4+TJk5kXfA7SunVro1evXjZljz76qNG1a1fDMPScM8o/k5mMeq6TJ0828uXLZ/OzY/jw4UbZsmX/U7zqZroHCQkJbNy4kebNm1vLHBwcaN68OREREXaMLOeKjo4GIH/+/ABs3LiRxMREm2ccGhpKcHCw9RlHRERQqVIlAgICrHVatmxJTEwMO3fuzMLos7/+/fvTunVrm+cJes4Zae7cudSsWZPHH3+cQoUKUa1aNf73v/9Zzx8+fJjIyEibZ+3r60vt2rVtnrWfnx81a9a01mnevDkODg6sXbs2675MNla3bl0WL17Mvn37ANi6dSurVq3iwQcfBPScM0tGPdeIiAgaNmyIi4uLtU7Lli3Zu3cvFy9evOf48sRCkxnt3LlzJCcn2/xwBwgICGDPnj12iirnSklJYdCgQdSrV4+KFSsCEBkZiYuLC35+fjZ1AwICiIyMtNa52Z/BjXNimjVrFps2bWL9+vXpzuk5Z5xDhw4xZcoUhgwZwssvv8z69et54YUXcHFxoUePHtZndbNnmfZZFypUyOa8k5MT+fPn17O+bsSIEcTExBAaGoqjoyPJycmMHj2arl27Aug5Z5KMeq6RkZGEhISku8eNc/ny5bun+JTMiN3179+fHTt2sGrVKnuHkuscP36cgQMHEh4ejpubm73DydVSUlKoWbMm7777LgDVqlVjx44dTJ06lR49etg5utzjhx9+YObMmXz33XdUqFCBLVu2MGjQIIoUKaLnnIepm+ke+Pv74+jomG7ER1RUFIGBgXaKKmcaMGAA8+bNY+nSpRQrVsxaHhgYSEJCApcuXbKpn/YZBwYG3vTP4MY5MbuRzpw5Q/Xq1XFycsLJyYnly5czadIknJycCAgI0HPOIIULF6Z8+fI2ZeXKlePYsWNA6rO63c+NwMBAzpw5Y3M+KSmJCxcu6FlfN3ToUEaMGEHnzp2pVKkS3bp1Y/DgwYwZMwbQc84sGfVcM+vniZKZe+Di4kKNGjVYvHixtSwlJYXFixcTFhZmx8hyDsMwGDBgAL/++itLlixJ1+xYo0YNnJ2dbZ7x3r17OXbsmPUZh4WFsX37dpv/ecLDw/Hx8Un3SyWvatasGdu3b2fLli3WrWbNmnTt2tW6r+ecMerVq5dueoF9+/ZRvHhxAEJCQggMDLR51jExMaxdu9bmWV+6dImNGzda6yxZsoSUlBRq166dBd8i+7t69SoODra/uhwdHUlJSQH0nDNLRj3XsLAwVqxYQWJiorVOeHg4ZcuWvecuJkBDs+/VrFmzDFdXV+Orr74ydu3aZfTt29fw8/OzGfEht/bss88avr6+xrJly4zTp09bt6tXr1rr9OvXzwgODjaWLFlibNiwwQgLCzPCwsKs528MGW7RooWxZcsWY8GCBUbBggU1ZPhfpB3NZBh6zhll3bp1hpOTkzF69Ghj//79xsyZMw0PDw/j22+/tdYZO3as4efnZ/z222/Gtm3bjHbt2t10aGu1atWMtWvXGqtWrTLKlCmT54cMp9WjRw+jaNGi1qHZv/zyi+Hv728MGzbMWkfP+d7ExsYamzdvNjZv3mwAxsSJE43NmzcbR48eNQwjY57rpUuXjICAAKNbt27Gjh07jFmzZhkeHh4amm1PH3/8sREcHGy4uLgYtWrVMtasWWPvkHIM4Kbb9OnTrXWuXbtmPPfcc0a+fPkMDw8P45FHHjFOnz5tc58jR44YDz74oOHu7m74+/sbL774opGYmJjF3yZn+Wcyo+eccX7//XejYsWKhqurqxEaGmp8/vnnNudTUlKMUaNGGQEBAYarq6vRrFkzY+/evTZ1zp8/b3Tp0sXw8vIyfHx8jKeeesqIjY3Nyq+RrcXExBgDBw40goODDTc3N6NkyZLGK6+8YjPUV8/53ixduvSmP5d79OhhGEbGPdetW7ca9evXN1xdXY2iRYsaY8eO/c+xWwwjzbSJIiIiIjmM3pkRERGRHE3JjIiIiORoSmZEREQkR1MyIyIiIjmakhkRERHJ0ZTMiIiISI6mZEZERERyNCUzIiIikqMpmREREZEcTcmMiIiI5GhKZkRERCRHUzIjIiIiOdr/AX7ZucZPw0NEAAAAAElFTkSuQmCC\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# both always defect\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 0,\n", - " \"player2\": 0\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "EpB7M86F3Nmk", - "outputId": "8d9a0151-ae11-4617-9e8e-9b7b2b3a2e3a" - }, - "execution_count": 7, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-498 -491]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# player1 defects, player2 cooperates\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 0,\n", - " \"player2\": 1\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "O2wI3VsI3Tc8", - "outputId": "0a8e8e61-7a82-4b55-ca6d-d23bedd70e94" - }, - "execution_count": 8, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-517 -583]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# player1 cooperates, player2 defects\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 1,\n", - " \"player2\": 0\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "9eJWcQqC3Z99", - "outputId": "224d735c-c51b-45b8-b7d8-666fec94fabf" - }, - "execution_count": 9, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-565 -487]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Always cooperate vs a random agent\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 1,\n", - " \"player2\": np.random.choice([0, 1])\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "FPLlpZUh3i8f", - "outputId": "2e1808d4-84ce-4ac2-9274-ab4c4727cedd" - }, - "execution_count": 10, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-454 -393]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Always defect vs a random agent\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 0,\n", - " \"player2\": np.random.choice([0, 1])\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "A2Ei4LU75us9", - "outputId": "8ead19a8-36e6-49ba-cbc6-9bbe4ad737ad" - }, - "execution_count": 11, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-501 -564]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Always forage vs a hail mary\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 1,\n", - " \"player2\": 1 if obs[\"player2\"][\"observation\"][0, 2] <= 1 else 0\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "onhvByjW51QN", - "outputId": "3b60fae3-7bb7-4b73-a151-83b1ec2dbfc9" - }, - "execution_count": 12, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-527 -244]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Always defect vs a hail mary\n", - "episodes = 1000\n", - "\n", - "episode_rews = []\n", - "\n", - "for _ in range(episodes):\n", - "\n", - " obs = env.reset()\n", - " while env.agents:\n", - " acts = {\n", - " \"player1\": 0,\n", - " \"player2\": 1 if obs[\"player2\"][\"observation\"][0, 2] <= 1 else 0\n", - " }\n", - "\n", - " obs, rews, terms, truncs, infos = env.step(acts)\n", - " # print(obs, rews)\n", - "\n", - " episode_rews.append([rews['player1'], rews['player2']])\n", - "\n", - "arr = np.array(episode_rews)\n", - "print(f\"Score [player1, player2]:{np.sum(arr, axis=0)}\")\n", - "plt.plot(arr.cumsum(axis=0))\n", - "plt.legend((\"player1\", \"player2\"))\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 448 - }, - "id": "V8KQIrS76GRt", - "outputId": "92c87879-06a4-49bf-ed40-35bb2297b7bb" - }, - "execution_count": 13, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Score [player1, player2]:[-487 -322]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file