13-Dog Breed Softmax v_1.2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "biKcJVRzbFF1"
   },
   "source": [
    "# Dog Breed Classification using Softmax\n",
    "\n",
    "##  Adam Optimizer "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XynEVz9htI_K"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "g_9qmlBfbIfi",
    "outputId": "29c302fb-0928-4817-e006-418cb3cc44e3"
   },
   "outputs": [],
   "source": [
    "DATADIR = \"C:/Users/Omkar/ML and DS/Dog/dataset\"\n",
    "CATEGORIES = [\"German1\",\"Golden1\",\"Pug1\"]\n",
    "img_size = 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "64cLOTyJqQ7-",
    "outputId": "24116110-fd31-415f-b2b6-ef257af3aae0"
   },
   "outputs": [],
   "source": [
    "data = []\n",
    "\n",
    "def load_data():\n",
    "    for category in CATEGORIES:\n",
    "        \n",
    "        path = os.path.join(DATADIR, category)\n",
    "        class_num = CATEGORIES.index(category)\n",
    "        \n",
    "        for img in os.listdir(path):\n",
    "            \n",
    "            img_array = cv2.imread(os.path.join(path, img))\n",
    "            new_array = cv2.resize(img_array,(img_size,img_size))\n",
    "            data.append([new_array, class_num])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of images: 1004\n"
     ]
    }
   ],
   "source": [
    "load_data()\n",
    "print(\"No. of images: \" + str(len(data)))\n",
    "random.shuffle(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting Data and Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = []\n",
    "y_unsorted = []\n",
    "\n",
    "for features, label in data:\n",
    "    \n",
    "    X.append(features)\n",
    "    y_unsorted.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot(labels,C):\n",
    "    mapping = {}\n",
    "    for i in range(C):\n",
    "        mapping[i]=i\n",
    "    one_hot_encode = []\n",
    "    for l in labels:\n",
    "        arr = list(np.zeros(C, dtype = int))\n",
    "        arr[mapping[l]] = 1\n",
    "        one_hot_encode.append(arr)\n",
    "    return one_hot_encode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = one_hot(y_unsorted,len(CATEGORIES))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X = (1004, 64, 64, 3)\n",
      "Shape of y = (1004, 3)\n"
     ]
    }
   ],
   "source": [
    "X = np.array(X)\n",
    "y = np.array(y)\n",
    "\n",
    "print(\"Shape of X = \"+ str(X.shape))\n",
    "print(\"Shape of y = \" + str(y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y_train.T \n",
    "y_test = y_test.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 803\n",
      "Number of testing examples: m_test = 201\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (803, 64, 64, 3)\n",
      "train_set_y shape: (3, 803)\n",
      "test_set_x shape: (201, 64, 64, 3)\n",
      "test_set_y shape: (3, 201)\n"
     ]
    }
   ],
   "source": [
    "m_train = x_train.shape[0]\n",
    "m_test = x_test.shape[0]\n",
    "num_px = x_train.shape[1]\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(x_train.shape))\n",
    "print (\"train_set_y shape: \" + str(y_train.shape))\n",
    "print (\"test_set_x shape: \" + str(x_test.shape))\n",
    "print (\"test_set_y shape: \" + str(y_test.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 803)\n",
      "train_set_y shape: (3, 803)\n",
      "test_set_x_flatten shape: (12288, 201)\n",
      "test_set_y shape: (3, 201)\n",
      "sanity check after reshaping: [ 68  81 105  91  98]\n"
     ]
    }
   ],
   "source": [
    "train_set_x_flatten = x_train.reshape(x_train.shape[0], -1).T\n",
    "test_set_x_flatten = x_test.reshape(x_test.shape[0], -1).T\n",
    "\n",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(y_train.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(y_test.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = train_set_x_flatten/255.\n",
    "x_test = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MYCrMOuccJmt"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NTsIwkOUfP3h"
   },
   "outputs": [],
   "source": [
    "def init_params(layer_dims):\n",
    "    \n",
    "    parameters = {}\n",
    "    L = len(layer_dims)\n",
    "    \n",
    "    for l in range(1, L):\n",
    "        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * (np.sqrt(2. / layer_dims[l-1]))\n",
    "        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))\n",
    "        \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_adam(parameters) :\n",
    "\n",
    "    L = len(parameters) // 2 \n",
    "    v = {}\n",
    "    s = {}\n",
    "    \n",
    "    for l in range(L):\n",
    "\n",
    "        v[\"dW\" + str(l+1)] = np.zeros(parameters[\"W\" + str(l+1)].shape)\n",
    "        v[\"db\" + str(l+1)] = np.zeros(parameters[\"b\" + str(l+1)].shape)\n",
    "        s[\"dW\" + str(l+1)] = np.zeros(parameters[\"W\" + str(l+1)].shape)\n",
    "        s[\"db\" + str(l+1)] = np.zeros(parameters[\"b\" + str(l+1)].shape)\n",
    "    \n",
    "    return v, s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "roz7tnESicfO"
   },
   "outputs": [],
   "source": [
    "def relu(Z):\n",
    "    \n",
    "    A = np.maximum(0, Z)\n",
    "    cache = Z\n",
    "    \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Irs5R29uiose"
   },
   "outputs": [],
   "source": [
    "def relu_backward(dA, cache):\n",
    "    \n",
    "    Z = cache\n",
    "    dZ = np.array(dA, copy=True)\n",
    "    dZ[Z <= 0] = 0\n",
    "  \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "shMZanw5pBHm"
   },
   "outputs": [],
   "source": [
    "def sigmoid(Z):\n",
    "    \n",
    "    A = 1 / (1+np.exp(-Z))\n",
    "    cache = Z \n",
    "    \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bE-mfy-fp1Pa"
   },
   "outputs": [],
   "source": [
    "def sigmoid_backward(dA, cache):\n",
    "    \n",
    "    Z = cache\n",
    "    s = 1/(1+np.exp(-Z))\n",
    "    dZ = dA * s * (1 - s)\n",
    "    \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lG7fAaB8iz3I"
   },
   "outputs": [],
   "source": [
    "def softmax(Z):\n",
    "    \n",
    "    e_x = np.exp(Z - np.max(Z))\n",
    "    A = e_x / e_x.sum(axis=0, keepdims=True)\n",
    "    cache = Z\n",
    "    \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Z8qGhEoEG7vT"
   },
   "outputs": [],
   "source": [
    "def sigmoid_derivative(Z):\n",
    "    \n",
    "    s = 1 / (1 + np.exp(-Z))\n",
    "    \n",
    "    return s * (1 - s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QZJ02w-3iXjv"
   },
   "outputs": [],
   "source": [
    "def linear_forward(A, W, b):\n",
    "    \n",
    "    Z = W.dot(A) + b\n",
    "    cache = (A, W, b)\n",
    "    \n",
    "    return Z, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hPO4l__UhgC0"
   },
   "outputs": [],
   "source": [
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "    \n",
    "    if activation == \"relu\":\n",
    "        \n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = relu(Z)\n",
    "\n",
    "    if activation == \"sigmoid\":\n",
    "        \n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = sigmoid(Z)\n",
    "        \n",
    "    if activation == \"softmax\":\n",
    "        \n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = softmax(Z)\n",
    "\n",
    "    cache = (linear_cache, activation_cache)\n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xqmA7DD0gqQT"
   },
   "outputs": [],
   "source": [
    "def forwardpass(X, parameters):\n",
    "    \n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2\n",
    "  \n",
    "    for l in range(1, L):\n",
    "        \n",
    "        A_prev = A\n",
    "        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters[\"b\" + str(l)], activation=\"sigmoid\")\n",
    "        caches.append(cache)\n",
    "  \n",
    "    AL, cache = linear_activation_forward(A, parameters[\"W\" + str(L)], parameters[\"b\" + str(L)], activation=\"softmax\")\n",
    "    caches.append(cache)\n",
    "\n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(Y, AL):\n",
    "    \n",
    "    cost = -np.mean(Y * np.log(AL + 1e-8))\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LZJeEcq7od43"
   },
   "outputs": [],
   "source": [
    "def linear_backward(dZ, cache):\n",
    "    \n",
    "    A_prev, W, b = cache\n",
    "    n = A_prev.shape[1]\n",
    "\n",
    "    dW = 1./n * np.dot(dZ, A_prev.T)\n",
    "    db = 1./n * np.sum(dZ, axis=1, keepdims=True)\n",
    "    dA_prev = np.dot(W.T, dZ)\n",
    "\n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-b-iYkz4n7QE"
   },
   "outputs": [],
   "source": [
    "def linear_activation_backward(dA, cache, activation):\n",
    "    \n",
    "    linear_cache, activation_cache = cache\n",
    "  \n",
    "    if activation == \"relu\":\n",
    "        \n",
    "        dZ = relu_backward(dA, activation_cache)\n",
    "        \n",
    "    if activation == \"sigmoid\":\n",
    "        \n",
    "        dZ = sigmoid_backward(dA, activation_cache)\n",
    "        \n",
    "    elif activation == \"softmax\":\n",
    "        \n",
    "        dZ = dA\n",
    "  \n",
    "    dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SycGYYdFkgWZ"
   },
   "outputs": [],
   "source": [
    "def backwardpass(AL, Y, caches):\n",
    "    \n",
    "    grads = {}\n",
    "    L = len(caches)\n",
    "    n = AL.shape[1]\n",
    "    Y = Y.reshape(AL.shape)\n",
    "    dAL = AL - Y\n",
    "    curr_cache = caches[L-1]\n",
    "    \n",
    "    grads[\"dA\" + str(L-1)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dAL, curr_cache, activation=\"softmax\")\n",
    "\n",
    "    for l in reversed(range(L-1)):\n",
    "        \n",
    "        curr_cache = caches[l]\n",
    "        dA_prev, dW, db = linear_activation_backward(grads[\"dA\" + str(l+1)], curr_cache, activation = \"sigmoid\")\n",
    "        \n",
    "        grads[\"dA\" + str(l)] = dA_prev\n",
    "        grads[\"dW\" + str(l + 1)] = dW\n",
    "        grads[\"db\" + str(l + 1)] = db \n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2IqWdqTgoyJW"
   },
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    \n",
    "    L = len(parameters) // 2\n",
    "    \n",
    "    for l in range(1,L+1):\n",
    "        \n",
    "        parameters[\"W\" + str(l)] = parameters[\"W\" + str(l)] - learning_rate * grads[\"dW\" + str(l)]\n",
    "        parameters[\"b\" + str(l)] = parameters[\"b\" + str(l)] - learning_rate * grads[\"db\" + str(l)]\n",
    "        \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01,\n",
    "                                beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):\n",
    "\n",
    "    L = len(parameters) // 2                 \n",
    "    v_corrected = {}                         \n",
    "    s_corrected = {}                         \n",
    "    \n",
    "    for l in range(L):\n",
    "\n",
    "        v[\"dW\" + str(l+1)] = beta1*v[\"dW\" + str(l+1)] + (1-beta1)*grads['dW' + str(l+1)]\n",
    "        v[\"db\" + str(l+1)] = beta1*v[\"db\" + str(l+1)] + (1-beta1)*grads['db' + str(l+1)]\n",
    "\n",
    "        v_corrected[\"dW\" + str(l+1)] = v[\"dW\" + str(l+1)]/(1-np.power(beta1,t))\n",
    "        v_corrected[\"db\" + str(l+1)] = v[\"db\" + str(l+1)]/(1-np.power(beta1,t))\n",
    "\n",
    "        s[\"dW\" + str(l+1)] = beta2*s[\"dW\" + str(l+1)]+(1-beta2)*np.power(grads['dW' + str(l+1)],2)\n",
    "        s[\"db\" + str(l+1)] = beta2*s[\"db\" + str(l+1)]+(1-beta2)*np.power(grads['db' + str(l+1)],2)\n",
    "\n",
    "        s_corrected[\"dW\" + str(l+1)] = s[\"dW\" + str(l+1)]/(1-np.power(beta2,t))\n",
    "        s_corrected[\"db\" + str(l+1)] = s[\"db\" + str(l+1)]/(1-np.power(beta2,t))\n",
    "\n",
    "        parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)]-learning_rate*v_corrected[\"dW\" + str(l+1)]/np.sqrt(s_corrected[\"dW\" + str(l+1)] +epsilon)\n",
    "        parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)]-learning_rate*v_corrected[\"db\" + str(l+1)]/np.sqrt(s_corrected[\"db\" + str(l+1)]+epsilon)\n",
    "\n",
    "    return parameters, v, s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J7jIXGl9dWNA"
   },
   "outputs": [],
   "source": [
    "def model(X, Y, layer_dims, learning_rate = 0.001, epochs = 5, print_cost = True):\n",
    "    \n",
    "    costs = []\n",
    "    t = 0\n",
    "    \n",
    "    parameters = init_params(layer_dims)\n",
    "    v, s = initialize_adam(parameters)\n",
    "    \n",
    "    \n",
    "    for i in range(epochs):\n",
    "        AL, caches = forwardpass(X, parameters)\n",
    "        cost = compute_cost(Y, AL) \n",
    "        grads = backwardpass(AL, Y, caches)\n",
    "        #parameters = update_parameters(parameters, grads, learning_rate)\n",
    "        t = t + 1\n",
    "        parameters, v, s = update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01,\n",
    "                                beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8)\n",
    "\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print(\"Cost after iteration %i: %f\" % (i, cost))\n",
    "        if i % 10 == 0:\n",
    "            costs.append(cost)\n",
    "\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per 10s)')\n",
    "    plt.title(\"Learning rate = \" + str(learning_rate))\n",
    "    plt.show()\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 465
    },
    "colab_type": "code",
    "id": "lw8J0HgwpJ-5",
    "outputId": "093ceb3f-e8b6-4abd-acaa-46e1e33808c9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.368256\n",
      "Cost after iteration 100: 0.308622\n",
      "Cost after iteration 200: 0.359844\n",
      "Cost after iteration 300: 0.221493\n",
      "Cost after iteration 400: 0.250636\n",
      "Cost after iteration 500: 0.219193\n",
      "Cost after iteration 600: 0.357589\n",
      "Cost after iteration 700: 0.342811\n",
      "Cost after iteration 800: 0.341662\n",
      "Cost after iteration 900: 0.216195\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztnXmcHHWd99/f7p7puY9kJsdMQu4AISQEAwYQYREUBAFdXdF1cdVdZFeOZ3GfXVx31cWH51EUFRQPdEU8IIqgRkQOuW8SjgQSyB2SyTmTY5K5+/g+f1T1TGfSMz2T6eru6v6+X695pau6qvpXqe761Pf8iapiGIZhGMMRyPUADMMwjPzHxMIwDMNIi4mFYRiGkRYTC8MwDCMtJhaGYRhGWkwsDMMwjLSYWBhFgYj8WUQ+metxGIZfMbEwPEVEtojIubkeh6peoKp35nocACLyhIj8Qw4+d5yI/E5EOkXkbRH5+DDbioh8XUT2un83iYgkvX+SiLwsIl3uvyclvfdXIvK4iLSLyBaPT8vIEiYWhu8RkVCux5Agn8aSgtuAPmAi8LfAD0TkhCG2vQK4FFgILAAuAj4LICKlwB+AXwL1wJ3AH9z1AJ3AT4H/7c1pGLnAxMLIGSJykYi8JiIHROQ5EVmQ9N71IrJRRA6JyBoR+WDSe38vIs+KyLdFZB/wFXfdMyLyTRHZLyKbReSCpH36n+ZHsO0MEXnK/ey/iMhtIvLLIc7hbBFpEZF/F5FdwB0iUi8i94tIq3v8+0Vkirv9jcCZwPdEpENEvueuP05EHhGRfSKyVkT+JsP/15XAXwP/paodqvoMsAz4uyF2+SRws6q2qOp24Gbg7933zgZCwHdUtVdVbwUEOAdAVV9S1V8AmzJ5DkZuMbEwcoKInIzz9PlZYDzwI2CZiITdTTbi3FRrgf8Gfikik5MO8U6cm9EE4MakdWuBBuAm4H+SXSeDGG7bu4CX3HF9haFvqAkmAeOAaThP5AHgDnf5GKAb+B6Aqn4ReBq4SlWrVPUq90b+iPu5E4CPAd8f6qlfRL7vCmyqv1VDjHEuEFPVdUnrVgJDWRYnuO+n2vYEYJUe3ito1TDHMgoAEwsjV/wj8CNVfVFVY248oRdYAqCq96jqDlWNq+qvgfXAqUn771DV76pqVFW73XVvq+qPVTWG4xqZjONySUXKbUXkGOAU4Euq2pf0BD4cceDL7lN2t6ruVdV7VbVLVQ/hiNlZw+x/EbBFVe9wz+cV4F7gw6k2VtV/VtW6If4WpNoHqALaB61rB6pHuH07UOUK6miPZRQA+exfNQqbacAnReTqpHWlQBOAiFwOXAdMd9+rwrECEmxLccxdiReq2uUaClVDfP5Q2zYA+1S1a9BnTR3mXFpVtSexICIVwLeB83F8+gDVIhJ0xWkw04B3isiBpHUh4BfDfOZo6QBqBq2rAQ6NcPsaoENVVURGeyyjADDLwsgV24AbBz0VV6jq3SIyDfgxcBUwXlXrgDdw/OIJvGqXvBMY597wEwwnFKnG8nngWOCdqloDvNtdL0Nsvw14ctD/RZWq/lOqDxORH7rxjlR/q4cY4zogJCJzktYtBIbafrX7fqptVwMLBrn4FgxzLKMAMLEwskGJiJQl/YVwxOBKEXmnm6ZZKSIXikg1UIlzQ20FEJFPAfOzMVBVfRtYgRM0LxWR04APjPIw1ThxigMiMg748qD3dwMzk5bvB+aKyN+JSIn7d4qIHD/EGK90xSTVX8q4gap2AvcBN7j/12cAlzC09fJz4DoRaRaRJhwB/Jn73hNADLhGRMIicpW7/jEAEQmISBlQ4ixKWVKmlOFTTCyMbPAAzs0z8fcVVV2BE7f4HrAf2ICbbaOqa3Cyb57HubGeCDybxfH+LXAasBf4P8CvceIpI+U7QDnQBrwAPDjo/VuAD7uZUre6cY33ApcBO3BcZF8HwmSWf3bHtQe4G/gnVV0NICJnuu6lBD8C/gi8jmPV/cldh6r24aTVXg4cAD4NXOquB8eS6sa57okA/8MZPhcjy4hNfmQYwyMivwbeUtXBFoJhFA1mWRjGIFwX0CzXnXI+jrvm97kel2HkEsuGMowjmYTj3x8PtOC4a17N7ZAMI7eYG8owDMNIi7mhDMMwjLQUjBuqoaFBp0+fnuthGIZh+IqXX365TVUb021XMGIxffp0VqxYkethGIZh+AoReXsk25kbyjAMw0iLiYVhGIaRFhMLwzAMIy0mFoZhGEZaTCwMwzCMtJhYGIZhGGkxsTAMwzDSYmJhGD7mxU17Wb/bJqgzvMfEwjB8zBd//wa3PLo+18MwigATC8PwMb3RGB290VwPwygCTCwMw8fEYkpXbyzXwzCKABMLw/Ax0bjSFTHLwvAeEwvD8DGxuNLVZ5aF4T0mFobhY6JxpdvEwsgCJhaG4WNicaXTAtxGFiiY+SwMoxiJxuPE4jY1suE9ZlkYho+JxZVITInE4rkeilHgmFgYho+JulaFBbkNrzGxMAyfEo8r6nqguvosbmF4i4mFYfiUaFKswiwLw2tMLAzDpyQHti191vAaEwvD8CnR+EBQ2ywLw2tMLAzDpyRbFp0WszA8xsTCMHxK1NxQRhYxsTAMnxKzALeRRUwsDMOnHG5ZmBvK8BYTC8PwKbFYcszCLAvDW0wsDMOnWDaUkU1MLAzDp8TMDWVkEU/FQkTOF5G1IrJBRK4fZrsPi4iKyGJ3ebqIdIvIa+7fD70cp2H4EavgNrKJZy3KRSQI3AacB7QAy0VkmaquGbRdNXAN8OKgQ2xU1ZO8Gp9h+B3LhjKyiZeWxanABlXdpKp9wFLgkhTbfRW4CejxcCyGUXAcblmYG8rwFi/FohnYlrTc4q7rR0QWAVNV9f4U+88QkVdF5EkROTPVB4jIFSKyQkRWtLa2ZmzghuEHYhbgNrKIl2IhKdb1PwqJSAD4NvD5FNvtBI5R1UXAdcBdIlJzxMFUb1fVxaq6uLGxMUPDNgx/EHVTZ0WsgtvwHi/FogWYmrQ8BdiRtFwNzAeeEJEtwBJgmYgsVtVeVd0LoKovAxuBuR6O1TB8RyJmURUOWZ2F4TleisVyYI6IzBCRUuAyYFniTVVtV9UGVZ2uqtOBF4CLVXWFiDS6AXJEZCYwB9jk4VgNw3ckYhY1ZSWWOmt4jmdioapR4CrgIeBN4DequlpEbhCRi9Ps/m5glYisBH4LXKmq+7waq2H4kYRlUV0WspiF4Tmepc4CqOoDwAOD1n1piG3PTnp9L3Cvl2MzDL+TbFls39+d49EYhY5VcBuGT0lkQ1WXhejsi6KqafYwjKPHxMIwfEo0yQ0VV+iNxtPsYRhHj4mFYfiURMyiprwEsPRZw1tMLAzDpyTqLKrLnNBjV8TEwvAOEwvD8CkD2VCOZdHVa+mzhneYWBiGT0mOWYC1/DC8xcTCMHzKQDaUa1mYWBgeYmJhGD5loM7CsSy6I+aGMrzDxMIwfMrgmEVnr1kWhneYWBiGTznCsjA3lOEhJhaG4VOOyIayZoKGh5hYGAVBbzTGH1fuKKqWF4k6i5pyq7MwvMfEwigIHn+rlavvfpWNrR25HkrWSGRDlZcECQh0WczC8BATC6Mg6HGfqg/1FI8rJhpXQgFBRKgotTblhreYWBgFQSTmPGX3RIqnmV4srgQDzuzF5aVBS501PMXEwigIIq7/vqeI/PYJywKgsjRoloXhKSYWRkEQjScsi+K5YR5uWYSszsLwFBMLoyBIWBbdRSQW0XicUND5CVeYG8rwGBMLoyCIFnnMosLcUIbHmFgYBUGimrmoLIvYQMyiojRoFdyGp5hYGAXBQDZU8dwwD7csnHm4DcMrTCyMgiBa5NlQ5WZZGB5jYmEUBEVvWZRYzMLwFhMLoyAo2myogJsNFQ7RHYkRjxdPbywju5hYGAXBQJ1F8WZDqUJPtHjE0sguJhZGQVCcloUSCg6IBdjUqoZ3mFgYBUGizqK3iMTisAruEkcsLMhteIWJhVEQFHudRWXYndPCxMLwCE/FQkTOF5G1IrJBRK4fZrsPi4iKyOKkdV9w91srIu/zcpyG/7Gus45lYbUWhleEvDqwiASB24DzgBZguYgsU9U1g7arBq4BXkxaNw+4DDgBaAL+IiJzVdUem4yUJMSimNww0XicipDzE64wN5ThMV5aFqcCG1R1k6r2AUuBS1Js91XgJqAnad0lwFJV7VXVzcAG93iGkZL+orwiygYaXMEN5oYyvMNLsWgGtiUtt7jr+hGRRcBUVb1/tPsaRjIRN2bRU0Q3y+QK7opwIhvK3FCGN3gpFpJiXX/FkIgEgG8Dnx/tvknHuEJEVojIitbW1qMeqOF/+rvORoszZmGps4bXeCkWLcDUpOUpwI6k5WpgPvCEiGwBlgDL3CB3un0BUNXbVXWxqi5ubGzM8PANP5FwQxWTz/6wOosSc0MZ3uKlWCwH5ojIDBEpxQlYL0u8qartqtqgqtNVdTrwAnCxqq5wt7tMRMIiMgOYA7zk4VgNnxNJVHBHY6gWR8sLx7JwfsKJbKhuc0MZHuFZNpSqRkXkKuAhIAj8VFVXi8gNwApVXTbMvqtF5DfAGiAKfM4yoYzhSFgWqtAbjVPmZgcVMk5vKMeyKA0FKAmKWRaGZ3gmFgCq+gDwwKB1Xxpi27MHLd8I3OjZ4IyCIpE6C9AbKQ6xiMUGYhbgVHGbWBheYRXcRkGQLBbFUsWdnA0FTvqsZUMZXmFiYRQE0aTW3MUyp0VyNhTYPNyGt5hYGAVBNKZUuf2RitayCNtseYZ3mFgYBUEkFqe6zBGL4rIsBn7CdeWltHX25XBERiFjYmEUBNF4MVoW8f46C4DpDRVsbu0omtRhI7uYWBgFQbJl0VsknWcHxyxmNFRxsCfK/q5IDkdlFComFkZBEInFqSorAYrJsjg8ZjGzoRKAzW0duRqSUcCYWBgFQTSmRRWziMcVVQ6zLGY2OmKxsbUzV8MyChgTC8P3qCrRuFJTVjwxi0SqcLJl0VxXTklQ2NxmYmFkHhMLw/ckbpyJAHcxzJYXc885ORsqFAxwzLgKNptlYXiAiYXhexJ9oardmEUxuKGibuPEZMsCnCD3JotZGB5gYmH4nkTH2YrSIAEpDrEYsCwOF4tZjZVs2dvV/75hZAoTC8P3JCyLUEAoKymOKub+mEVwsGVRSV80zo4D3bkYllHAmFgYvifRRLAkFKC8JFgU83APZVnM6E+ftbiFkVlMLAzf0y8WgYBrWRR+gDtVNhTAzMYqADa1WtzCyCwmFobv6XdDBYWykkBxWBaxI7OhABqqSqkOh8yyMDKOiYXhe/ozg4KOZdFTFDGL1NlQIsKMxko2mVgYGaboxWLPwR6uvvtVVrUcyPVQjKMk4j5llwSk6GMW4LT9MMvCyDRFLxblpUGeXt/Ktx5Zl+uhGEfJgBsqUHzZUCnEYkZDFdsPdBdFCrGRPYpeLKrLSrjyrFk8sbaVFVv25Xo4xlEQ6XdDOamzxVXBnUIsGitRhbf3dmV7WEYBU/RiAXD5adNoqCrl5ofNuvAjkagjDqXBgBPgLoIn6qHqLMC6zxreYGKBM9H9P589m+c37eW5DW25Ho4xSpJdMuUlwaIQi5hrTQ3OhoKBWgsLchuZxMTC5ePvPIZJNWXc/Mg6m2nMZyTqLPpjFkUgFslV64OpDIeYWBNmkzUUNDKIiYVLWUmQq86Zzctv7+dHT20q+KfTPQd7eGN7e66HkRESN86SoFBeajELgJkNVTy/ca8V5xkZY0RiISIfGck6v/M3i6eyZOY4vvbntzjja4/x7UfWcainMKeovO3xDfzDnStyPYyMMFBzEKAsFKA7Eit463C4bCiAa94zh86+KBd99xnufbml4P8/DO8ZqWXxhRGu8zWloQB3/+MSll6xhJOm1nHLo+v5wn2v53pYntDeHaG1o7cgbiKRJMuirDQIQG+0sK2LdJbFabPG8+drz+TE5lo+f89KPn/PSnqLoP7E8I7QcG+KyAXA+4FmEbk16a0aIOrlwHKFiLBk5niWzBzP1x98ix8+uZF/ae1glttzp1DojsSIxZXOvlj/pEF+5bAK7pAjFj2RGGUlwVwOy1MGLIuhn/cm15Zz1z8u4dZH13PLo+vZvr+b2y9fTG15SbaGaRQQ6SyLHcAKoAd4OelvGfA+b4eWez7zrhmEQwF++MTGXA8l43S7fv0DXX05HsnYiUQPj1lA4c+WN5ANldqySBAMCP9y3ly+89GTeGXrfj7yw+esfblxVAwrFqq6UlXvBGar6p3u62XABlXdn+7gInK+iKwVkQ0icn2K968UkddF5DUReUZE5rnrp4tIt7v+NRH54VGe35hoqApz2SnH8LtXt9Oyv7AKnBL9k9q7/R+TSRTllbh1FlD483APV2eRiksXNfOzT53KzgM9XHjr09z2+AYOFmg8zvCGkcYsHhGRGhEZB6wE7hCRbw23g4gEgduAC4B5wMcSYpDEXap6oqqeBNwEJB9zo6qe5P5dOcJxZpwr3j0TEfjxU5tyNQRPSNxM27v8f8NITiMtLxlwQxUy6WIWqThjdgP3/vPpLJxaxzceWssZX3uMbz28lo7egvQoGxlmpGJRq6oHgQ8Bd6jqO4Bz0+xzKo4FsklV+4ClwCXJG7jHTFAJ5F20tamunA8tmsLS5dtoPdSb6+FkjIRYHCgEyyKpziLsikXBWxbD1FkMx9yJ1fzsU6dy/9Xv4l2zG7j1sQ2c/Y0nWPrSVpuK1RiWkYpFSEQmA38D3D/CfZqBbUnLLe66wxCRz4nIRhzL4pqkt2aIyKsi8qSInDnCz/SEK8+eRSQW56fPbs7lMDJKdwG5oRIumZKgWRYjZX5zLT/4xDv4/efOYNr4Cq6/73UuvPVplr60la4+szSMIxmpWNwAPITjGlouIjOB9Wn2SfUtPuLRRVVvU9VZwL8D/+mu3gkco6qLgOuAu0Sk5ogPELlCRFaIyIrW1tYRnsromdFQyTnHTeTel1sK5ukrkUZ5oCDcUEl1FkUiFiPJhhoJJ02t47dXnsb3Pr4IVbj+vtd5542P8p+/f52XNu8jXiDfd2PsjChnUlXvAe5JWt4E/HWa3VqAqUnLU3Cyq4ZiKfAD9/i9QK/7+mXX8piLk5mVPK7bgdsBFi9e7Om3+kMnN/OXN3fz3MY2zpzT6OVHZYVCsiyS6ywGLAvLhhopIsJFC5q48MTJvLJ1P796YSv3rGjhly9sZUJ1mPefOJmPLJ7CCU21Y/4sw7+MtIJ7ioj8TkT2iMhuEblXRKak2W05MEdEZohIKXAZTiZV8nHnJC1eiGutiEijGyDHtWLmADmNMJ9z3ASqy0L87tXto953f2dfXjUoVNWBAHd3AaTOxuIEA4KIDGRDFficFukquI8GEeEd08bxrY+exMv/dR63fmwRi46p466XtnLhrc9w6W3P8psV2woiKcIYPSOtxroDuAtItPj4hLvuvKF2UNWoiFyF474KAj9V1dUicgOwQlWXAVeJyLlABNgPfNLd/d3ADSISBWLAlaqa08kmykqCXHjiZJat3MH/uTRKRenIC9l+/vzb3PLoOl790nvzoiCqLxYn4V0oBMsiGldK3BTSfsuiwKuV+2MWI0ydHS1V4RAXL2zi4oVNtHdFuPeVFu56aSv/9ttVXC+rWHRMPe+e08jMxkoaq8NMqA7TWB2mKhxCxJsxGbllpHe8RlW9I2n5ZyLyv9LtpKoPAA8MWvelpNfXDrHfvcC9Ixxb1vjgomaWLt/Gw6t3c+miI2L1Q7LrYDdxhfW7D7F4+jgPRzgyevoGXDSFELOIxOKUuL77/mwosywyRm1FCZ9+1ww+dcZ0Xt12gCfWtvLkula+8+g6BneLCYcCNFSFqQwHKQ0FKAkGCLlWX0BAEERABAKuqAy8N/CaxHY42yX2EZH+daWhAKWhAOUlQSZUh5lcV87k2jImVpcxoSZc0BX8uWCkYtEmIp8A7naXPwbs9WZI+csp08fRXFfO717dPiqxaD3kuHre2pUfYpGcVloQlkVM+4vTEpZFsfeG8gIR4eRj6jn5mHquO28uB3si7GrvYc/BXvYc6qGto5e2jj5aD/XS3RcjEovTF4sTiytxVeJxUOKoOpkucdX+19r/OrEd/X3LVN1tk7aLqRKJOsfv6ovRleLhYFxlKZ/7q9l8+ozpZu1kgJGKxaeB7wHfxrmOzwGf8mpQ+UogIFy6qIkfPLGRPYd6mFBdNqL92jqc+ox1uw95ObwRkxCLUEAKwrKIxuOEgo5lURJ0nkwL3rKIZSYbaizUlJVQU1bC3InVORtDgkOucO1o72HPwR72HOrlhU17+er9a1ixZR9f//ACaspy7wL2MyP9pn0V+KSqNqrqBBzx+Ipno8pjPrhoCnGFP67cOeJ9EmLx1q48EQv3RjqxpqwgLItITCkJDLg0imG2vEQ2VBYNi7ymuqyEOROrOWtuIx9ZPJXP/dVsfv7pU/nCBcfx8JrdXPzdZ9hiMweOiZGKxYLkXlBusHmRN0PKb2ZPqGLh1DrufG4LfSNwdahqf+X3ut2H8qIleMKymFRbRkdvtL8C2q9EYgOWBVAUs+VF49ofCzBSIyJ89qxZLL1iCfs6+/jystW5HpKvGalYBESkPrHg9ojyd1/rMXDdeXPZuq+Lnz+/Je22Hb1ReqNxmuvKOdAVYU8etAzpTYhFjeNGO+hz6yI5ZgGOWBR+nYWOuIlgsXPK9HFcfc4cnlzXmlcp7H5jpGJxM/CciHzVTX19Dqc9R1Fy1txG3j23ke8+tiFti++2Duf9M2aPB2BtHriiEk/dE12x8LsrKhKLU3qYZREoeDeUY1nYrMgj5e9Om0ZTbRn/789vWVX6UTKib5uq/hynYns30Ap8SFV/4eXA8p0vvv94DvVEuPXRDcNul4hXnDG7AcgvsZhUGwb830wwOugp25mHu7DFIhbXrGZC+Z2ykiDXvfdYXt/ezgNvjDzeaAww4kcTVV2jqt9T1e+q6hovB+UHjp1UzUdPmcovXtjC5mECZ22u22n2hCoaq8N5EeROBLgn1ZYDhWFZJD9ll4WKIWYRz0qNRSHxwUXNHDepmm88tHZE8UbjcMyOHQP/ct5cSoIBvvnQ2iG3SVgWjVVhjptUnRfpsz2DYhZ+b98QjQ1UcINZFkZqggHh388/jrf3dvHr5VtzPRzfYWIxBiZUl/F3p03jwdW72H2wJ+U2rR19iDgFQnMnOmKR6861iafuybWFEbNwnrIHvsrhULB/2thCJRpTsyyOgrOPbeSU6fXc9vjG/s7LxsgwsRgjHzvlGGJx5Z4V21K+39bRy7iKUkLBAMdOqqY3GmfrvtxO0drttvuYUOPGLHxuWfTFjoxZ9BaDZWHZUKNGRLj2PXPZdbCH3yxP/Zs1UmNiMUamN1Ry+qzxLF2+LWWWReuhXhqqnJvysW6l69pdB4/YLpt0R2KUhgKEQ0GqwiEO+LzzbDQWpyQ5GyoUKIKYhWVDHS1nzB7PO6bV8/0nzLoYDfZtywCXnXoMLfu7eSZFDndbRy8N1aUAzJlYhQis3dWR7SEeRk8kRlnIufS15SX+d0NZzMIYBY51MYed7T3cs6Il18PxDSYWGeB9J0ykvqKEpSmCZm0dA5ZFRWmIY8ZVsHZ3bi2LnkiM8lKn4V5teYnvA9yReDFWcFs21Fg4c04DJx9Txw+e2GiZUSPExCIDhENB/vrkKTy8end/a48EbYf6+sUCHFdUrmstuiOx/u6sdRUFYlkEjqzgzofWKl5hlsXYEBGuPXcu2w90c+8rZl2MBBOLDHHZqVOJxvWwL15nb5TuSOxwsZhUzea2zpy6Sbr7Yv29/mvLS/xflHdEbyjndSG3KU/0hjKOnnfPaWBybRkvbiq62RaOChOLDDF7QjWnTK/nviSxSNRYNFSV9q97x7R64grP5rBHTXeSG6oQLItIfFDMon8e7sJ1RZllMXZEhMm1ZXnRr80PmFhkkDPnNLJudweHepybb39BXvWAZXH6rAZqykI88PqunIwR3JiFe0OtcWMWfnbZHFHBnZgtr4DFwqmzsJ/vWJlQbWIxUuzblkHmN9cA8OZOJyaRiF8ku6FKQwHOmzeJR9bsyllg7bCYRXkpfbG4r7u0Du46O2BZ+Pec0mGWRWZorA6zZ4iCWuNwTCwyyPzmWgBe394OONXbcLhlAfD+EydxsCfKcxtz44rq7otRluSGAnxda5Gq6ywU9mx5zuyAJhZjZUJ1mIM90Zy4LF/ctDfn3RxGg4lFBplQXcaE6jCrXbFINBEcV1l62HbvmtNAVTjEn3PkiuqJxCkLDQS4wd8tPwZ3nU24oXoKuODKLIvMkOhiMDiL0Ws2t3Xy0dtf4ME3cueOHi0mFhlmfnMtb+xwxaKjl/qKksOqi8FJtT33+Ak8tGZXTmapc+osnDHVuWLh15YfqupMBJTkv68KO/NyHeqJ5mpYnmPZUJlhQrXTHy3bcYt9nY4lv2Wvf6Z6NbHIMPObatiwp4PuvthhBXmDueDEyRzoivDipn1ZHuHhMYsan4tFJOaY8cnZUPWuJZduYio/Y5ZFZki4iFsPZTdu0dXnPMi07M9tn7jRYGKRYeY31xJXeHPXQdo6+oYUi7PmNlJRGsz6RCyqekRRHvh3atVo3LHMkussxrtisbejcMXCekNlhoQbKtuWRWdvQiy6s/q5Y8G+bRkmEeR+Y3s7bR29RwS3E5SVBDnnuAk89MaurAa5eqNxVOkPcCdiFn4NcEeizv9dskumpqyEYED6Tf1CxCyLzDC+MkxAYM/BbIuFE0/bbmJRvEyuLWNcZSlvbG8/rONsKi5a0MTezj4eeD171kUi6yNhWVSFQwQD4tsAd8S1LJLjQoGAUF9Rwr4CdkNZb6jMEAwIDVVh9uTKDXWg2zdzgptYZBgRYX5zLcu37KerL9bfcTYV582byNyJVXz7kXVEkwLdW9o6+dD3n2XDnsz3kOoeJBYi4rT88GnMIurGLAankdZXlLKvgN1QsZhZFpliQk04626oDtey6IvG+4t38x0TCw+Y31TTPy/3cJZFMCB8/r3Hsqmtk/te2Q44NQPXLn2VV7Ye4NE392R8bInag0S7D3AyonxrWcSOtCzASVcubMtCrc5OnAO3AAAgAElEQVQiQ0yoLsu6GyphWYBjXfgBEwsPSMQtwJl7ezjeO28iC6fU8p2/rKM3GuPWR9ezsqWdcCjAqpb2jI8tYVkkahEAan3cHyoaPzIbClyxsJiFMQImVOfCskgSC5/ELTwVCxE5X0TWisgGEbk+xftXisjrIvKaiDwjIvOS3vuCu99aEXmfl+PMNPObBsRiOMsCHDfQ/37fcexo7+H6e1/ntsc38OF3TOHc4yeysuVAxsfWk0osfGxZJNx3gzODxlWWsr+AxcKyoTLHhOowezt7D3MFe01Xb4zqMqceyC/ps55920QkCNwGXADMAz6WLAYud6nqiap6EnAT8C1333nAZcAJwPnA993j+YKp48qpcb8Iw8UsErxrTgOnzxrP717dzpT6Cr5y8QksmFJLy/5u9mbYn5nol1Recrgbyq8xi1R1FuCKRVefb4KHo8Usi8zRWFOGKuzN4sNFZ1+Uxqow4ypLfZMR5eWjyanABlXdpKp9wFLgkuQNVDV5yrhKIPHLvgRYqqq9qroZ2OAezxckgtzgpOaNhC9ccDxzJlTxnctOoiocYsGUOgBWbc+sK6o/ZjHIsvBrAVtkGMsirv5uYzIclg2VORKu4mzGLTp7o1SGQzTXlZsbCmgGtiUtt7jrDkNEPiciG3Esi2tGue8VIrJCRFa0trZmbOCZ4Ky5jRw/uYbS0Mj+i0+cUssj153FycfU9y+LwKptGRaLRDZU6cC4GqqcZmp+bLw3UJR3pGUB2X1azCZmWWSOgcK87KXPdvbFqCgNMqW+3NxQQKpv8hE+AVW9TVVnAf8O/Oco971dVRer6uLGxsYxDTbTfPasWfz52jOPev+qcIhZjVWsynDcIlWAe0ZjJUB/BpefGHBDHWlZAOz3qcWUDusNlTkmVGe/irurz7EsptSXs/1Aty/mk/FSLFqAqUnLU4Adw2y/FLj0KPctSBZMqWVlS3tGv0iDi/IAZjQ4YrGprSNjn5MtokOIRX1F4bb8iMcVVQhagDsjDPSHyqYbKtbvhuqJxH1hAXv5bVsOzBGRGSJSihOwXpa8gYjMSVq8EFjvvl4GXCYiYRGZAcwBXvJwrHnJwil1tHX0srM9c+ZxqjqLhFhsbvWhZTGEG2p8VeFaFol0YauzyAzhUJC6ipLsuqF6o1SWBplSXwH4I3025NWBVTUqIlcBDwFB4KequlpEbgBWqOoy4CoROReIAPuBT7r7rhaR3wBrgCjwOVX1n0N9jCyY4gTJV7UcoKmuPCPH7HdDhQbEoqI0RFNtGZt86IbqtywCqS2LQqy1SPQSs5hF5phQHc5qgLurL0ZFaYgp45zfdcv+Lk6aWpe1zz8aPBMLAFV9AHhg0LovJb2+dph9bwRu9G50+c/xk2sIBYTXtrVz/vzJGTlmdyRGaShAYNCNZmZjFZta/eiGSm1ZlJUEqSwNFqQbqj+ob2KRMbI5F7eq0tkXpSocpNl9CPRD+qw5PfOYspIgx02uzmiQu6cvdli8IsGMhko2tXb6ItCWTF9/u48jb5zjqkoL0g1llkXmmVAdzlrMojsSQxUqwiGqy0qoLS/xhRvKxCLPWTiljtdb2jNWXNYTiacUi5mNlRzqjdLmsyfx/kaCKYK94ypKfRE4HC39MQsTi4zRWOOIRTYelhKtPirduKFf0mdNLPKchVPqONQbZXOGpl/sjsQOC24nmNlYBeA7V9RQdRZQuC0/BiwL+/lmignVZfTF4lnpZNDldpytdKf/TaTP5jv2bctzFkx1gtyvbc2MK6o7EjusxiLBzP70WX8FuRN1FqXBI7/K9QXaTNAsi8yTzVqLTrfjbEWpIxbNdRW07M//WgsTizxn7oRqxlWW8uyGtowcrycSo7zkyMveVFdOaSjgP8siduS0qgnGF6hYxGIWs8g0A2LhffpsZ79lMeCG6uqLsT/P+7OZWOQ5gYBw5pwGnlrfmpG4RXdfajdUMCDMGO8Euf3EcDUH9ZWldEdivmxjMhzDud6Mo2NCTRmQnf5QCcsi2Q0F+d991sTCB5w1t5G2jj7W7DyYfuM0dEdSZ0OBE+T2W8uPyBB1FuBYFkDBTYJk2VCZpzGLbqj+mEXCDVXvj/RZEwsfcOYcp+/Vk+vG3ixxqJgFOGKxdV9XfydXPxAZos4CkgrzfJbhlQ6LWWSeqnCIitJgltxQCcvC+R021TpikclODV5gYuEDGqvDzG+uyYhY9PQNIxYNVUTjytZ9+W0OJzMw+dGRN85Ey4/CtSzs55tJsjVjXr8byrUsaspLECHvpwmwb5tPePecRl55ez8He8YWBBvODZXoPuunuEXE7b4qMoxl0ZndKTO9xiwLb2isDtOWDbFwLYsK17IIBoTa8hILcBuZ4ay5jUTjynMb9vavO5qAd08knjLADTCrwam12Oyj7rPRWHzIQG9i4ql9nfn9IxwtMTfAbTGLzNJQFaYtwzNTpqKzL0ZJUAgn9Werr8j/bgMmFj7h5Gn1VIVD/a6o1TvaOe1rj3Lb4xtGfAxVHTZmUVtRwvjKUn9ZFjE9oj15guqyEMGAFJ5lETPLwgsas9Tyo6s32l9jkaCuIv+nNjax8AklwQBnzB7PU+taWbntAB//8YvsPtjL9x/fMGJfZ2/0yPm3BzOz0V/ps9F4fEixCASE+orCq7WwbChvSMwY2Rv1NtW6ozfW3+ojgVkWRkZ599xGth/o5rLbX6C6LMSPL19MZ1+Mnz23ZUT7D8y/PfRln9FQ6atJkKKx4WeMG1dZUnBiYfNZeEODOxe3152KE7PkJWOWhZFRzprrpNBOrAnzm8+exnnzJnLu8RO549kt/c3JhmNg/u3hLIsq2jr6aO/O7y9ugr7Y0JYFOP2hCk0sLBvKG7I1Y15nX4yKQWJhloWRUabUV7D0iiXc+0+n90+GdNU5s2nvjvDLF95Ou3+q+bcHk+gR5ZfivGhMh33CLkSxsGwob2hwU629DnInZslLpr6ihK6+mOcusLFgYuEzlswcz3jXXAY4aWodZ85p4CdPb0rb1iLx/rBi0Z8+6w9XVDQeT+OGKjyxsGwob0i4obIiFke4oRyhymdXlIlFAXD1OXNo6+jjp89uHna7noQbahixOGZcJcGA+MayGC4bCpw5LQ50R/pdN4WAWRbekC03VFdf6gA35Pec8SYWBcCpM8bx3nkT+ebDa7lnxbYhtxtJzKI0FGBqfblvMqKiI4hZqOZ/dexosGwobygrCVIdDnk+AVgqy6K+ogSA/XlcE2RiUSDc+rFFvGt2A/927yrue6WFeFx5en0r19z9Kj96ciPgFOTB8JYFJDKifCIW8eFjFvWV+f/ENlqGmx3QGBsN1WFavXZDpcyGSrih8vd7Gkq/ieEHykqC3P53i/nMncv513tWcvPD6/pn3/rLm7u5/LTpIwpwg5MR9fymvcTjSiDPn14jsXjKjrMJElXcezv6mD0hW6Pyln7LwlJnM05jlbeFedFYnJ5InIrBbqhK17KwmIWRDcpLg/zPJ0/hPcdPZEZDJbd+bBF3/P0pdPXFeHztHnr60ruhwLEseiJxdh7M7y6Y4MQshrMsJtQ4YvH2Xv80R0yHxSy8o6G61NMAd5f7wFaVInUW8tsCNsuiwCgvDfLjyxf3L8fiSkNVmD+u3MGSmeOdbdJaFm76bGsnzW6Kbr4SjcWPMOmTmTOhiua6cv70+k7+5pSpWRyZd1g2lHc0VIVpO5SZWSlTkZjLYnC7j7KSIGUlgbx2Q5llUeAEA8KFJ07isbf29JvX6cRiVqPTUNAPldyRmFIyzE1TRPjAwiae2dDG3iw0icsGZll4R6PHLT86Bs1lkYxTmGduKCOHfGBhE73ROPev2gFAODT8ZZ9QHaayNOiLjKhofOiuswkuXthELK78+Y1dWRqVt1g2lHc0VCdqLbx5wu8aNJdFMnUVpWZZGLnl5GPqaaotY8veLsKhQNqgtYgwo9EfGVHRNHUWAMdPrmb2hCqWrdyRpVF5y4BlYT/fTNNfmOdRkLsz4YZKaVnk95wW9m0rAgIB4aKFTUD64HaCGQ1VvqjijgzTdTaBiPCBBU0s37KPne35Pc/xSDDLwjsaq72t4u6fUjWFZZHv/aFMLIqEixZMBtLHKxLMbKhk+4Hu/qrvfCVd19kEH1g4GVX406qdWRiVt9h8Ft6R6A/lVfps/5SqKZIy8r3zrKdiISLni8haEdkgIteneP86EVkjIqtE5FERmZb0XkxEXnP/lnk5zmLgxOZapo2vSFtjkWBmYyWq+Z9yGonFCaWxLMCpHZnfXFMQrqhYPI4IeV8D40e87g+VcEMNFeA+0NV3VDNgZgPPxEJEgsBtwAXAPOBjIjJv0GavAotVdQHwW+CmpPe6VfUk9+9ir8ZZLIgIX/7APD73V7NHtP1Md4rVfHdFOb2hRnbTvHhhE6ta2tnig1jMcETjI7OmjNFTVhKkusy7lh+JAPfg1FlwLIu4wqGe9NMN5AIvLYtTgQ2quklV+4ClwCXJG6jq46qaeHR9AZji4XiKnnOOm8iH3zGy/+IZie6zeX5jjcbiIw70XrSgiWBA+NFTGz0elbfE4mrxCg/xsoq737JIETvM98I8L8WiGUjuatfirhuKzwB/TlouE5EVIvKCiFyaagcRucLdZkVra+vYR2z0UxUOMaE6nPfps5H4yC2LprpyPnX6dJYu38bKbQc8Hpl3OJaFhRu9oqHKu/5QnX1RwqFAStfpQMuP4hOLVL/glM44EfkEsBj4RtLqY1R1MfBx4DsiMuuIg6nerqqLVXVxY2NjJsZsJDGzsZLNeV6Yl67r7GCuPXcODVVh/usPb/i2bblZFt7SWB32NBtqcKuPBPk+p4WXYtECJPdXmAIcEV0UkXOBLwIXq2r/FVLVHe6/m4AngEUejtVIwczGqrx2Q8XjSlxHNxd1dVkJ/3nh8axqaefXy4du557PpJvwyRgbDVWlnrmhuvpiKWssoLjdUMuBOSIyQ0RKgcuAw7KaRGQR8CMcodiTtL5eRMLu6wbgDGCNh2M1UjCzoZIDXRH+8Np2VPPvKTzi9kgajWUBTqD7nTPGcdNDb7Hfh7PomWXhLQ1VYQ71RD1JG+/ojaassYCkOS2KzbJQ1ShwFfAQ8CbwG1VdLSI3iEgiu+kbQBVwz6AU2eOBFSKyEngc+JqqmlhkmQ8sbOK4SdVcu/Q1PvSD51ixZV+uh3QYkaOsNxARvnrpfNq7I/xiBHOX5xsjrS0xjo5EYd5eDx4kulLMZZGgpqyEgOTvnBaedp1V1QeABwat+1LS63OH2O854EQvx2akZ2JNGX+65kzufbmFmx9Zy0d+9Dy/+sw7OX12Q66HBjjxCmBEdRaDmTuxmhOaanh2QxvXvGdOpofmKbG42lwWHpKotWg91JvxrsudvTGqy1LfdgMBoba8pCjdUEYBEAwIf3PKVB77/Nk015Vzw/1r+m/SuSZhWYw0G2owp80cz6vbDuR9lfpgLBvKW/qbCXoQt+gcxg0F+d151r5xxoioDIf4j/cfz1u7DrE0TwLDUTdmcbQ3ztNmjacvGueVrfszOSzPsZiFt3jZH6qrLzbs/CtOyw+zLAyfc8H8SZw6YxzfemQd7d25f/rp75F0lJbF4unjCAi8sHFvJoflOZYN5S3jK73rD9XRG03Z6iNBfUUp+ztz/9tKhYmFMWJEhC9dNI/9XX1899H1uR4OEdcdVnoUMQtwAoonNtfy/CZ/iYVZFt4y0PLDC8simrLVR4J8ntPCxMIYFfOba/no4qn87LktvPx2brOj+ud1GEOwd8ms8by27QDdff6JW1hvKO9xCvMye9Pui8aJxJSqYS2L/J3TwsTCGDX/+r5jaaor5+M/fpGHVudu9rm+6NhiFuAEuSMxZUWOhW80mGXhPc115WzYk9nuBYm5LIazLOorS+mOxPIy6cLEwhg1DVVh7vvn0zlucg1X/vJl7nxuS07GkbAsjjYbCuCU6eMIBYTnfRS3cOos7KfrJWfNbWTt7kNszWCL/sRcFkO1+wAnwA352fLDvnHGUdFQFWbpPy7h3OMn8uVlq7nlL9mPYYylziJBZTjEgin+iluYZeE9582bCMDDazJnOXf1DT2laoJ8bvlhYmEcNeWlQX74iXfw1ydP4dt/Wcf3HsuuYPTXWYzxxnnarPGsammnozc/5xEYTDQeH1OcxkjPtPGVHDuxmkfW7M7YMTuGmVI1QV1F/naeNbEwxkQwINz04QV8aFEz33x4Hd9/YkPWPru/zmIMlgXAkpnjicWV5XnWzmQozLLIDu89YSLLt+zLWP+wV9526nlmNFQOuU19HneeNbEwxkwwIHzjIwu55KQmbnpwLTf+aU1/WquXRMdYwZ1g8bRxlIYC3PHslqyMe6xYNlR2OG/eROIKj761J/3GI+CPq3ZyQlMN00cgFmZZGAVLMCDc/JGFXH7aNH789GY++qPn2XGg29PPTNzYR9t1djDlpUG+dNE8nlrXynW/WZn381yYZZEdTmyuZVJNGY9kIG6xbV8XK7cd4KIFTcNuV1/pNBN8Y3v7mD8z05hYGBkjFAxwwyXz+e7HFrFudwfvv/VpfvDERs/m8Y6MsYI7mU8smcb1FxzHH1fu4Iu/ez0vW7InsN5Q2UFEOG/eRJ5a1zbmVNb7V+0E4KIFk4fdLhwK8okl07j7pW08vT6/Zv+0b5yRcT6wsIk/Xv0u5kyo4usPvsU5Nz/Jed96kpsefItXtu4nnqEn97H2hhrMlWfN4upzZrN0+Tb+8ecv8+bOgxk5bqYxyyJ7nDdvIt2RGM+sbxvTce5ftYOFU+uYOq4i7bZfuOB4ZjVW8q/3rMyr+VZMLAxPmNFQyT1Xns6z15/Dlz8wj/FVpfzoqU186PvPcer//QvX3P0qdz63hTe2tx91F9uxdp1NxXXnzeXfzz+OFzft5YJbnuaKn6/g6fWtR1XhHY8rB3syH6i03lDZY8nM8VSHQyxbueOorc3NbZ2s3nGQD6SxKhKUlwa55bJF7Ovs4z/yyMr1dD4Lw2iuK+dTZ8zgU2fMoL0rwhPr9vDom3t4cfNelq10ZtkNhwKc0FTDgil1zJtcw8zGSmY2VlFfUYLI0DfFbrfIaazZUMmICP909iw+fuox/PTZzfz02c08vGY3JUFhwZQ6Fk6pY0ZDBdMbKikNBti2v5ut+7rojcaY3VjFnInVqCp/WrWT+1ftZNfBHk6ZXs/FC5u44MTJ/XMljIVYzCyLbFEaCnDpomZ+8cLb7DnUww2XzGfuxOpRHeN+93t+4QjFApy2Op9/77F87c9vcfPD67j6PbMJh4auz8gGki+qNVYWL16sK1asyPUwjBGiquxo72HFln2samlnVcsB3th+kO4k33B1WYjmunKm1FfQVFfG+Mow46tK6eyN8tDqXbyy9QChgPDKl86jpqzEk3F29kZ5acs+Xty0jxc37+WtnYcOGyOAiDNbX8LSAcfaOWtuI8dOqubh1btZ77aOaKwOM6uxkhkNVUypL6e5rpyp48o5sbmO0tCA6G0/0M2fX3f83OOrShlXGaahqpTG6jAX3voM5x4/gf/3oQWenLNxOLG4snT5Vm56cC2dvVEuO3UqH1zUzKKp9QRGINrv/faT1JaXcM+Vp4/6c6/7zWv84bUdTBtfwX9dOI/3HD9h2Aeoo0FEXlbVxWm3M7Ew8oVYXGnZ38Wm1k42tnawdV8X2/d3s/1ANzsOdHOwZ6Bo7oSmGi6YP4kLFzQNm7eeaVSVPYd62dzWSV80zjHjKmiqKycgsHVfF+t2d9AbjXH23AnUugVWqspbuw7xxNpWNrZ2sKm1g81tnYc1jKssDXLmnEYWT6/nqfVtPL2+leF+mpefNo0bLpnv9ekaSezr7OOmB9/ivle20xeLM7EmzFlzG5lSX8Gk2jKaasuZ0VjJ5JoyROCtXYd4ZM1uvvXIOv774hP45OnTj+pzn17fyn//cQ0b9nQwbXwF85tqmddUw/TxlYyvKqWhqpSGqjB1btrtaDGxMAqOvmi8P/98Yk1Zjkczdrr6ouw40MOm1g6eXNfKY2/tYWd7D5Nry/jI4ql85B1TqCkvYW9HL3s7+2g71Eub+/qiBZOZPWF07hAjMxzqifDYW3v406qdvPz2/iPm6g6HAlSGQ+xz1580tY47/v4U6iuP7mYOTpr40uXbeHZ9G6t3trNt3+Fp6Sc21/LHq991VMc2sTAMn6GqtOzvpqmu3GISPqI3GmPPwV627e9iS1sXm9s6ONAV4ZQZ43j3nEYm1Wb+waa9O8LO9m72dvSxt7OPslCA954w6aiONVKxsAC3YeQJIjKi1EojvwiHgkwdV8HUcRWcPis7n1lbXkJtuTdxuqGw1FnDMAwjLSYWhmEYRlpMLAzDMIy0mFgYhmEYaTGxMAzDMNJiYmEYhmGkxcTCMAzDSIuJhWEYhpGWgqngFpFW4O0xHKIBGFvTev9RjOcMxXnexXjOUJznPdpznqaqjek2KhixGCsismIkJe+FRDGeMxTneRfjOUNxnrdX52xuKMMwDCMtJhaGYRhGWkwsBrg91wPIAcV4zlCc512M5wzFed6enLPFLAzDMIy0mGVhGIZhpMXEwjAMw0hL0YuFiJwvImtFZIOIXJ/r8XiFiEwVkcdF5E0RWS0i17rrx4nIIyKy3v23PtdjzTQiEhSRV0Xkfnd5hoi86J7zr0Xk6Oe7zFNEpE5Efisib7nX/LRCv9Yi8i/ud/sNEblbRMoK8VqLyE9FZI+IvJG0LuW1FYdb3fvbKhE5+Wg/t6jFQkSCwG3ABcA84GMiMi+3o/KMKPB5VT0eWAJ8zj3X64FHVXUO8Ki7XGhcC7yZtPx14NvuOe8HPpOTUXnLLcCDqnocsBDn/Av2WotIM3ANsFhV5wNB4DIK81r/DDh/0Lqhru0FwBz37wrgB0f7oUUtFsCpwAZV3aSqfcBS4JIcj8kTVHWnqr7ivj6Ec/NoxjnfO93N7gQuzc0IvUFEpgAXAj9xlwU4B/itu0khnnMN8G7gfwBUtU9VD1Dg1xpnmuhyEQkBFcBOCvBaq+pTwL5Bq4e6tpcAP1eHF4A6EZl8NJ9b7GLRDGxLWm5x1xU0IjIdWAS8CExU1Z3gCAowIXcj84TvAP8GxN3l8cABVY26y4V4zWcCrcAdrvvtJyJSSQFfa1XdDnwT2IojEu3AyxT+tU4w1LXN2D2u2MVCUqwr6FxiEakC7gX+l6oezPV4vERELgL2qOrLyatTbFpo1zwEnAz8QFUXAZ0UkMspFa6P/hJgBtAEVOK4YAZTaNc6HRn7vhe7WLQAU5OWpwA7cjQWzxGREhyh+JWq3ueu3p0wS91/9+RqfB5wBnCxiGzBcTGeg2Np1LmuCijMa94CtKjqi+7yb3HEo5Cv9bnAZlVtVdUIcB9wOoV/rRMMdW0zdo8rdrFYDsxxMyZKcQJiy3I8Jk9wffX/A7ypqt9KemsZ8En39SeBP2R7bF6hql9Q1SmqOh3n2j6mqn8LPA582N2soM4ZQFV3AdtE5Fh31XuANRTwtcZxPy0RkQr3u54454K+1kkMdW2XAZe7WVFLgPaEu2q0FH0Ft4i8H+dpMwj8VFVvzPGQPEFE3gU8DbzOgP/+P3DiFr8BjsH5wX1EVQcHz3yPiJwN/KuqXiQiM3EsjXHAq8AnVLU3l+PLNCJyEk5QvxTYBHwK5+GwYK+1iPw38FGczL9XgX/A8c8X1LUWkbuBs3Fake8Gvgz8nhTX1hXO7+FkT3UBn1LVFUf1ucUuFoZhGEZ6it0NZRiGYYwAEwvDMAwjLSYWhmEYRlpMLAzDMIy0mFgYhmEYaTGxMHyDiDzn/jtdRD6e4WP/R6rP8goRuVREvuTRsW8UkW0i0jFofdjtvLrB7cQ6fZhjlIrIU0kFbUaRY2Jh+AZVPd19OR0YlVi4HYaH4zCxSPosr/g34PtjPcgQ5/VHnCaZg/kMsF9VZwPfxunImhK3seajOHULhmFiYfiHpCflrwFnishr7hwGQRH5hogsd3v2f9bd/mxx5vC4C6cYERH5vYi87M57cIW77ms43UpfE5FfJX+WW/n6DXeOhNdF5KNJx35CBuaM+JVbAIWIfE1E1rhj+WaK85gL9Kpqm7v8MxH5oYg8LSLr3J5WiXk4RnReyajqC0NU6SZ3Jv0t8B73/E4QkZfc818lInPcbX4P/O3Ir5BRyJiJafiR63GrsQHcm367qp4iImHgWRF52N32VGC+qm52lz/tVraWA8tF5F5VvV5ErlLVk1J81oeAk3DmhGhw93nKfW8RcAJOr51ngTNEZA3wQeA4VVURqUtxzDOAVwatmw6cBcwCHheR2cDlozivkdDfgVRVoyLSjtOF90rgFlX9ldv2JmGtvAGcMorjGwWMiYVRCLwXWCAiiR5AtTiTvfQBLw26oV4jIh90X091t9s7zLHfBdytqjGcZm1P4txAD7rHbgEQkddwbvgvAD3AT0TkT8D9KY45GaeFeDK/UdU4sF5ENgHHjfK8RsJQHUifB74oztwf96nqegBVjYlIn4hUu3OgGEWMuaGMQkCAq1X1JPdvhqomnsA7+zdy+kOdC5ymqgtxegWVjeDYQ5HcYygGhNy5E07F6e57KfBgiv26U3zu4L47ygjPaxT0dyB1A9e1wD5VvQu42B3XQyJyTtI+YRzxM4ocEwvDjxwCqpOWHwL+SZwW7IjIXHEm+xlMLU6At0tEjsOZXjZBJLH/IJ4CPurGDxpxZqB7aaiBiTNfSK2qPgD8LxwX1mDeBGYPWvcREQmIyCycyYvWjuK8RkpyZ9IP43ThVbex4iZVvdXdZoH7eeOBRMtvo8gxN5ThR1YBURFZiTMf8S04LqBX3CBzK6mnz3wQuFJEVuHcjF9Ieu92YJWIvOK2MU/wO+A0YCXO0/6/qeouV2xSUQ38QUTKcCyDf0mxzVPAzSIiOtDJcy3wJDARuFJVe0TkJyM8r8MQkYB91dgAAACbSURBVJtwssUqRKQF+ImqfgWnRf0vRGQDzrScl7m7fBT4hIhEgF3ADe76vwIeSPd5RnFgXWcNIweIyC3AH1X1LyLyM+B+Vf1tmt2yiojcB3xBVdfmeixG7jE3lGHkhv8LVOR6EEPhZkX93oTCSGCWhWEYhpEWsywMwzCMtJhYGIZhGGkxsTAMwzDSYmJhGIZhpMXEwjAMw0jL/wen/0/PrIV9+QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "layer_dims = [12288, 24, 4, 3]\n",
    "parameters = model(x_train, y_train, layer_dims, learning_rate = 0.001, epochs = 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J4oOLvEMV5D6"
   },
   "outputs": [],
   "source": [
    "def predict(X, y, parameters):\n",
    "    \n",
    "    predictions, caches = forwardpass(X, parameters)\n",
    "    \n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pred(X ,y):\n",
    "    \n",
    "    predictions = predict(X, y, parameters)\n",
    "\n",
    "    y_hat = np.argmax(predictions, axis = 0)\n",
    "    y_label = np.argmax(y, axis = 0)\n",
    "\n",
    "    return y_hat, y_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training accuracy: 64.63262764632628 %\n"
     ]
    }
   ],
   "source": [
    "y_hat, y_label = make_pred(x_train, y_train)\n",
    "\n",
    "score = accuracy_score(y_label, y_hat)\n",
    "\n",
    "print(\"Training accuracy: \" + str(score * 100) + \" %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing accuracy: 53.233830845771145 %\n"
     ]
    }
   ],
   "source": [
    "y_hat, y_label = make_pred(x_test, y_test)\n",
    "\n",
    "score = accuracy_score(y_label, y_hat)\n",
    "\n",
    "print(\"Testing accuracy: \" + str(score * 100) + \" %\")\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyNB/VofgpXgjOfH0NjVcG2I",
   "include_colab_link": true,
   "machine_shape": "hm",
   "name": "MNIST Softmax Classifier",
   "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": 1
}