IA_Coding_Neural_Network_Forwad_Back_Propagation.ipynb

{
  "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.6.4"
    },
    "colab": {
      "name": "IA_Coding-Neural-Network-Forwad-Back-Propagation.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MedicalImageAnalysisTutorials/DeepLearning4All/blob/main/IA_Coding_Neural_Network_Forwad_Back_Propagation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tM6nGXMRYLD1"
      },
      "source": [
        "<!-- <h1 style=\"font-family: Georgia; font-size:3em;color:#2462C0; font-style:bold\"> -->\n",
        "# Coding Neural Network - Forward Propagation and Backpropagation\n",
        "<!-- </h1><br> -->\n",
        "\n",
        "Source: https://github.com/ImadDabbura/blog-posts/tree/master/notebooks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N36ZHTFFYLD4"
      },
      "source": [
        "## **Why Neural Networks?**\n",
        "\n",
        "According to *Universal Approximate Theorem*, Neural Networks can approximate as well as learn and represent any function given a large enough layer and desired error margin. The way neural network learns the true function is by building complex representations on top of simple ones. On each hidden layer, the neural network learns new feature space by first compute the affine (linear) transformations of the given inputs and then apply non-linear function which in turn will be the input of the next layer. This process will continue until we reach the output layer. Therefore, we can define neural network as information flows from inputs through hidden layers towards the output. For a 3-layers neural network, the learned function would be: $f(x) = f_3(f_2(f_1(x)))$ where:\n",
        "- $f_1(x)$: Function learned on first hidden layer\n",
        "- $f_2(x)$: Function learned on second hidden layer\n",
        "- $f_3(x)$: Function learned on output layer\n",
        "\n",
        "Therefore, on each layer we learn different representation that gets more complicated with later hidden layers.Below is an example of a 3-layers neural network (we don't count input layer):\n",
        "<p align=\"center\">\n",
        "<img src=\"https://miro.medium.com/max/700/0*hzIQ5Fs-g8iBpVWq.jpg\"><br>\n",
        "<caption><center><u><b><font color=\"purple\">Figure 1:</font></b></u> Neural Network with two hidden layers</center></caption>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLKfxKrjYLD5"
      },
      "source": [
        "For example, computers can't understand images directly and don't know what to do with pixels data. However, a neural network can build a simple representation of the image in the early hidden layers that identifies edges. Given the first hidden layer output, it can learn corners and contours. Given the second hidden layer, it can learn parts such as nose. Finally, it can learn the object identity.\n",
        "\n",
        "Since **truth is never linear** and representation is very critical to the performance of a machine learning algorithm, neural network can help us build very complex models and leave it to the algorithm to learn such representations without worrying about feature engineering that takes practitioners very long time and effort to curate a good representation. \n",
        "\n",
        "The notebook has two parts:\n",
        "1. Coding the neural network: This entails writing all the helper functions that would allow us to implement a multi-layer neural network. While doing so, I'll explain the theoretical parts whenever possible and give some advices on implementations.\n",
        "2. Application: We'll implement the neural network we coded in the first part on image recognition problem to see if the network we built will be able to detect if the image has a cat or a dog and see it working :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "7ldRtgVQYLD5"
      },
      "source": [
        "# Import packages\n",
        "import os as os\n",
        "\n",
        "import h5py\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "\n",
        "%matplotlib inline\n",
        "sns.set_context(\"notebook\")\n",
        "plt.style.use(\"fivethirtyeight\")"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hzi5gaIRYLD7"
      },
      "source": [
        "<a id=\"Coding the NN\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-rC4TEmYLD7"
      },
      "source": [
        "<!-- <h2 style=\"font-family: Georgia; font-size:2em;color:purple; font-style:bold\"> -->\n",
        "## I. Coding The Neural Network\n",
        "<!-- </h2> -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RLZesMqNYLD8"
      },
      "source": [
        "<!-- <h3 style=\"font-family: Georgia; font-size:1.5em;color:purple; font-style:bold\"> -->\n",
        "### Forward Propagation\n",
        "<!-- </h3> -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9sL0hhqYYLD8"
      },
      "source": [
        "The input $X$ provides the initial information that then propagates to the hidden units at each layer and finally produce the output $\\widehat{Y}$. The architecture of the network entails determining its depth, width, and activation functions used on each layer. \n",
        "\n",
        "* **Depth** is the number of hidden layers. \n",
        "* **Width** is the number of units (nodes) on each hidden layer since we don't control neither input layer nor output layer dimensions. \n",
        "* There are quite a few set of activation functions such *Rectified Linear Unit, Sigmoid, Hyperbolic tangent, etc*. Research has proven that deeper networks outperform networks with more hidden units. Therefore, it's always better and won't hurt to train a deeper network (with diminishing returns).\n",
        "\n",
        "Lets first introduce some notations that will be used throughout the notebook:\n",
        "* $W^l$: Weights matrix for the $l^{th}$ layer\n",
        "* $b^l$: Bias vector for the $l^{th}$ layer\n",
        "* $Z^l$: Linear (affine) transformations of given inputs for the $l^{th}$ layer\n",
        "* $g^l$: Activation function applied on the $l^{th}$ layer\n",
        "* $A^l$: Post-activation output for the $l^{th}$ layer\n",
        "* $dW^l$: Derivative of the cost function w.r.t  $W^l$ ($\\frac{\\partial J}{\\partial W^l}$)\n",
        "* $db^l$: Derivative of the cost function w.r.t $b^l$ ($\\frac{\\partial J}{\\partial b^l})$)\n",
        "* $dZ^l$: Derivative of the cost function w.r.t $Z^l$ ($\\frac{\\partial J}{\\partial Z^l}$)\n",
        "* $dA^l$: Derivative of the cost function w.r.t $A^l$ ($\\frac{\\partial J}{\\partial A^l}$)\n",
        "* $n^l$: Number of units (nodes) of the $l^{th}$ layer\n",
        "* $m$: Number of examples\n",
        "* $L$: Number of layers in the network (not including the input layer)\n",
        "\n",
        "Next, we'll write down the dimensions of a multi-layer neural network in the general form to help us in matrix multiplication because one of the major challenges in implementing a neural network is getting the dimensions right.\n",
        "* $W^l,\\ dW^l$: Number of units (nodes) in $l^{th}$ layer x Number of units (nodes) in $l - 1$ layer\n",
        "* $b^l,\\ db^l$: Number of units (nodes) in $l^{th}$ layer x 1\n",
        "* $Z^l,\\ dZ^l$: Number of units (nodes) in $l^{th}$ layer x number of examples\n",
        "* $A^l,\\ dA^l$: Number of units (nodes) in $l^{th}$ layer x number of examples\n",
        "\n",
        "The two equations we need to implement forward propagations are:\n",
        "$$Z^l = W^lA^{l - 1} + b ^l\\tag1\\\\{}$$\n",
        "$$A^l = g^l(Z^l) = g^l(W^lA^{l - 1} + b ^l)\\tag2$$\n",
        "These computations will take place on each layer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PyE9cep5YLD9"
      },
      "source": [
        "<!-- <h3 style=\"font-family: Georgia; font-size:1.3em;color:purple; font-style:bold\"> -->\n",
        "### Parameters Initialization\n",
        "<!-- </h3><br> -->\n",
        "We'll first initialize the weight matrices and the bias vectors. It's important to note that we shouldn't initialize all the parameters to zero because doing so will lead the gradients to be equal and on each iteration the output would be the same and the learning algorithm won't learn anything. Therefore, it's important to randomly initialize the parameters to values between 0 and 1. It's also recommended to multiply the random values by small scalar such as 0.01 to make the activation units active and be on the regions where activation functions' derivatives are not close to zero."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "YVGbqhR8YLD-"
      },
      "source": [
        "# Initialize parameters\n",
        "def initialize_parameters(layers_dims):\n",
        "    \"\"\"\n",
        "    Initialize parameters dictionary.\n",
        "    \n",
        "    Weight matrices will be initialized to random values from uniform normal\n",
        "    distribution.\n",
        "    bias vectors will be initialized to zeros.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    layers_dims : list or array-like\n",
        "        dimensions of each layer in the network.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    parameters : dict\n",
        "        weight matrix and the bias vector for each layer.\n",
        "    \"\"\"\n",
        "    np.random.seed(1)               \n",
        "    parameters = {}\n",
        "    L = len(layers_dims)            \n",
        "\n",
        "    for l in range(1, L):           \n",
        "        parameters[\"W\" + str(l)] = np.random.randn(\n",
        "            layers_dims[l], layers_dims[l - 1]) * 0.01\n",
        "        parameters[\"b\" + str(l)] = np.zeros((layers_dims[l], 1))\n",
        "\n",
        "        assert parameters[\"W\" + str(l)].shape == (\n",
        "            layers_dims[l], layers_dims[l - 1])\n",
        "        assert parameters[\"b\" + str(l)].shape == (layers_dims[l], 1)\n",
        "\n",
        "    return parameters"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IfZSpYogYLD-"
      },
      "source": [
        "<!-- <h3 style=\"font-family: Georgia; font-size:1.3em;color:purple; font-style:bold\"> -->\n",
        "###  Activation Functions\n",
        "<!-- </h3><br> -->\n",
        "There is no definitive guide for which activation function works best on specific problems. It's a trial and error process where one should try different set of functions and see which one works best on the problem at hand. We'll cover 4 of the most commonly used activation functions:\n",
        "- **Sigmoid function ($\\sigma$)**: $g(z) = \\frac{1}{1 + e^{-z}}$. It's recommended to be used only on the output layer so that we can easily interpret the output as probabilities since it has restricted output between 0 and 1. One of the main disadvantages for using sigmoid function on hidden layers is that the gradient is very close to zero over a large portion of its domain which makes it slow and harder for the learning algorithm to learn.\n",
        "- **Hyperbolic Tangent function**: $g(z) = \\frac{e^z - e^{-z}}{e^z + e^{-z}}$. It's superior to sigmoid function in which the mean of its output is very close to zero, which in other words center the output of the activation units around zero and make the range of values very small which means faster to learn. The disadvantage that it shares with sigmoid function is that the gradient is very small on good portion of the domain.\n",
        "- **Rectified Linear Unit (ReLU)**: $g(z) = max\\{0, z\\}$. The models that are close to linear are easy to optimize. Since ReLU shares a lot of the properties of linear functions, it tends to work well on most of the problems. The only issue is that the derivative is not defined at $z = 0$, which we can overcome by assigning the derivative to 0 at $z = 0$. However, this means that for $z\\leq 0$ the gradient is zero and again can't learn.\n",
        "- **Leaky Rectified Linear Unit**: $g(z) = max\\{\\alpha*z, z\\}$. It overcomes the zero gradient issue from ReLU and assigns $\\alpha$ which is a small value for $z\\leq 0$.\n",
        "\n",
        "If you're not sure which activation function to choose, start with ReLU.\n",
        "\n",
        "Next, we'll implement the above activation functions and draw a graph for each one to make it easier to see the domain and range of each function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "c5aCU5VoYLD-"
      },
      "source": [
        "# Define activation functions that will be used in forward propagation\n",
        "def sigmoid(Z):\n",
        "    \"\"\"\n",
        "    Computes the sigmoid of Z element-wise.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    A : array\n",
        "        post activation output.\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "    \"\"\"\n",
        "    A = 1 / (1 + np.exp(-Z))\n",
        "\n",
        "    return A, Z\n",
        "\n",
        "\n",
        "def tanh(Z):\n",
        "    \"\"\"\n",
        "    Computes the Hyperbolic Tagent of Z elemnet-wise.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    A : array\n",
        "        post activation output.\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "    \"\"\"\n",
        "    A = np.tanh(Z)\n",
        "\n",
        "    return A, Z\n",
        "\n",
        "\n",
        "def relu(Z):\n",
        "    \"\"\"\n",
        "    Computes the Rectified Linear Unit (ReLU) element-wise.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    A : array\n",
        "        post activation output.\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "    \"\"\"\n",
        "    A = np.maximum(0, Z)\n",
        "\n",
        "    return A, Z\n",
        "\n",
        "\n",
        "def leaky_relu(Z):\n",
        "    \"\"\"\n",
        "    Computes Leaky Rectified Linear Unit element-wise.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    A : array\n",
        "        post activation output.\n",
        "    Z : array\n",
        "        output of affine transformation.\n",
        "    \"\"\"\n",
        "    A = np.maximum(0.1 * Z, Z)\n",
        "\n",
        "    return A, Z"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 577
        },
        "id": "TxhQcXx7YLD_",
        "outputId": "8b8e481f-5aef-4240-8734-845b767dbf29"
      },
      "source": [
        "# Plot the 4 activation functions\n",
        "z = np.linspace(-10, 10, 100)\n",
        "\n",
        "# Computes post-activation outputs\n",
        "A_sigmoid, z = sigmoid(z)\n",
        "A_tanh, z = tanh(z)\n",
        "A_relu, z = relu(z)\n",
        "A_leaky_relu, z = leaky_relu(z)\n",
        "\n",
        "# Plot sigmoid\n",
        "plt.figure(figsize=(12, 8))\n",
        "plt.subplot(2, 2, 1)\n",
        "plt.plot(z, A_sigmoid, label = \"Function\")\n",
        "plt.plot(z, A_sigmoid * (1 - A_sigmoid), label = \"Derivative\")\n",
        "plt.legend(loc = \"upper left\")\n",
        "plt.xlabel(\"z\")\n",
        "plt.ylabel(r\"$\\frac{1}{1 + e^{-z}}$\")\n",
        "plt.title(\"Sigmoid Function\", fontsize = 16)\n",
        "# Plot tanh\n",
        "plt.subplot(2, 2, 2)\n",
        "plt.plot(z, A_tanh, 'b', label = \"Function\")\n",
        "plt.plot(z, 1 - np.square(A_tanh), 'r',label = \"Derivative\")\n",
        "plt.legend(loc = \"upper left\")\n",
        "plt.xlabel(\"z\")\n",
        "plt.ylabel(r\"$\\frac{e^z - e^{-z}}{e^z + e^{-z}}$\")\n",
        "plt.title(\"Hyperbolic Tangent Function\", fontsize = 16)\n",
        "# plot relu\n",
        "plt.subplot(2, 2, 3)\n",
        "plt.plot(z, A_relu, 'g')\n",
        "plt.xlabel(\"z\")\n",
        "plt.ylabel(r\"$max\\{0, z\\}$\")\n",
        "plt.title(\"ReLU Function\", fontsize = 16)\n",
        "# plot leaky relu\n",
        "plt.subplot(2, 2, 4)\n",
        "plt.plot(z, A_leaky_relu, 'y')\n",
        "plt.xlabel(\"z\")\n",
        "plt.ylabel(r\"$max\\{0.1z, z\\}$\")\n",
        "plt.title(\"Leaky ReLU Function\", fontsize = 16)\n",
        "plt.tight_layout();"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 4 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3kIDj1JVYLD_"
      },
      "source": [
        "<!-- <h3 style=\"font-family: Georgia; font-size:1.3em;color:purple; font-style:bold\"> -->\n",
        "### Feed Forward\n",
        "<!-- </h3><br> -->\n",
        "Given its inputs from previous layer, each unit computes affine transformation $z = W^Tx + b$ and then apply an activation function $g(z)$ such as ReLU element-wise. During the process, we'll store (cache) all variables computed and used on each layer to be used in back-propagation. We'll write first two helper functions that will be used in the L-model forward propagation to make it easier to debug. Keep in mind that on each layer, we may have different activation function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "I8Gpb2jbYLEA"
      },
      "source": [
        "# Define helper functions that will be used in L-model forward prop\n",
        "def linear_forward(A_prev, W, b):\n",
        "    \"\"\"\n",
        "    Computes affine transformation of the input.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    A_prev : 2d-array\n",
        "        activations output from previous layer.\n",
        "    W : 2d-array\n",
        "        weight matrix, shape: size of current layer x size of previuos layer.\n",
        "    b : 2d-array\n",
        "        bias vector, shape: size of current layer x 1.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    Z : 2d-array\n",
        "        affine transformation output.\n",
        "    cache : tuple\n",
        "        stores A_prev, W, b to be used in backpropagation.\n",
        "    \"\"\"\n",
        "    Z = np.dot(W, A_prev) + b\n",
        "    cache = (A_prev, W, b)\n",
        "\n",
        "    return Z, cache\n",
        "\n",
        "\n",
        "def linear_activation_forward(A_prev, W, b, activation_fn):\n",
        "    \"\"\"\n",
        "    Computes post-activation output using non-linear activation function.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    A_prev : 2d-array\n",
        "        activations output from previous layer.\n",
        "    W : 2d-array\n",
        "        weight matrix, shape: size of current layer x size of previuos layer.\n",
        "    b : 2d-array\n",
        "        bias vector, shape: size of current layer x 1.\n",
        "    activation_fn : str\n",
        "        non-linear activation function to be used: \"sigmoid\", \"tanh\", \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    A : 2d-array\n",
        "        output of the activation function.\n",
        "    cache : tuple\n",
        "        stores linear_cache and activation_cache. ((A_prev, W, b), Z) to be used in backpropagation.\n",
        "    \"\"\"\n",
        "    assert activation_fn == \"sigmoid\" or activation_fn == \"tanh\" or \\\n",
        "        activation_fn == \"relu\"\n",
        "\n",
        "    if activation_fn == \"sigmoid\":\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = sigmoid(Z)\n",
        "\n",
        "    elif activation_fn == \"tanh\":\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = tanh(Z)\n",
        "\n",
        "    elif activation_fn == \"relu\":\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = relu(Z)\n",
        "\n",
        "    assert A.shape == (W.shape[0], A_prev.shape[1])\n",
        "\n",
        "    cache = (linear_cache, activation_cache)\n",
        "\n",
        "    return A, cache\n",
        "\n",
        "\n",
        "def L_model_forward(X, parameters, hidden_layers_activation_fn=\"relu\"):\n",
        "    \"\"\"\n",
        "    Computes the output layer through looping over all units in topological\n",
        "    order.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    X : 2d-array\n",
        "        input matrix of shape input_size x training_examples.\n",
        "    parameters : dict\n",
        "        contains all the weight matrices and bias vectors for all layers.\n",
        "    hidden_layers_activation_fn : str\n",
        "        activation function to be used on hidden layers: \"tanh\", \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    AL : 2d-array\n",
        "        probability vector of shape 1 x training_examples.\n",
        "    caches : list\n",
        "        that contains L tuples where each layer has: A_prev, W, b, Z.\n",
        "    \"\"\"\n",
        "    A = X                           \n",
        "    caches = []                     \n",
        "    L = len(parameters) // 2        \n",
        "\n",
        "    for l in range(1, L):\n",
        "        A_prev = A\n",
        "        A, cache = linear_activation_forward(\n",
        "            A_prev, parameters[\"W\" + str(l)], parameters[\"b\" + str(l)],\n",
        "            activation_fn=hidden_layers_activation_fn)\n",
        "        caches.append(cache)\n",
        "\n",
        "    AL, cache = linear_activation_forward(\n",
        "        A, parameters[\"W\" + str(L)], parameters[\"b\" + str(L)],\n",
        "        activation_fn=\"sigmoid\")\n",
        "    caches.append(cache)\n",
        "\n",
        "    assert AL.shape == (1, X.shape[1])\n",
        "\n",
        "    return AL, caches"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "47Q7JL42YLEA"
      },
      "source": [
        " <!-- <h3 style=\"font-family: Georgia; font-size:1.3em;color:purple; font-style:bold\"> -->\n",
        "### Cost functions (loss functions)\n",
        "<!-- </h3><br> -->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F2qbbxEHggZJ"
      },
      "source": [
        " ####  **Binary Cross-Entropy (BCE )** loss function. \n",
        " \n",
        "It uses the log-likelihood method to estimate its error. The cost is:\n",
        "$$J(W, b) = -\\frac{1}{m}\\sum_{i = 1}^m\\big(y^ilog(\\widehat{y^i}) + (1 - y^i)log(1 - \\widehat{y^i})\\big)\\tag3$$\n",
        "The above cost function is convex; however, neural network usually stuck on a local minimum and is not guaranteed to find the optimal parameters. We'll use here gradient-based learning."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "iHU6yuwZYLEB"
      },
      "source": [
        "# Compute cross-entropy cost\n",
        "def compute_BCE_cost(AL, y):\n",
        "    \"\"\"\n",
        "    Computes the binary Cross-Entropy cost.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    AL : 2d-array\n",
        "        probability vector of shape 1 x training_examples.\n",
        "    y : 2d-array\n",
        "        true \"label\" vector.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    cost : float\n",
        "        binary cross-entropy cost.\n",
        "    \"\"\"\n",
        "    m = y.shape[1]              \n",
        "    cost = - (1 / m) * np.sum(\n",
        "        np.multiply(y, np.log(AL)) + np.multiply(1 - y, np.log(1 - AL)))\n",
        "\n",
        "    return cost"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgxZmaBLg9hE"
      },
      "source": [
        " ####  **Mean Squared Error (MSE)** loss function. \n",
        " \n",
        "The cost is:\n",
        "$$\n",
        "J(W, b) = -\\frac{1}{m}\\sum_{i = 1}^m \\big(y^i-\\widehat{y^i} \\big)^2\\tag3\n",
        "$$\n",
        "\n",
        "<!-- The above cost function is convex; however, neural network usually stuck on a local minimum and is not guaranteed to find the optimal parameters. We'll use here gradient-based learning. -->"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jxb9W9omg9ux"
      },
      "source": [
        "# Compute MSE cost\n",
        "def compute_MSE_cost(AL, y):\n",
        "    \"\"\"\n",
        "    Computes the MSE cost.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    AL : 2d-array\n",
        "        probability vector of shape 1 x training_examples.\n",
        "    y : 2d-array\n",
        "        true \"label\" vector.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    cost : float\n",
        "        binary cross-entropy cost.\n",
        "    \"\"\"\n",
        "    m = y.shape[1]              \n",
        "    cost = - (1 / m) * np.sum(  pow((y-AL),2) )\n",
        "\n",
        "    return cost"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b0balH9pYLEB"
      },
      "source": [
        "<!-- <h2 style=\"font-family: Georgia; font-size:1.5em;color:purple; font-style:bold\"> -->\n",
        "### Back-Propagation\n",
        "<!-- </h2> -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lrbc37CAYLEB"
      },
      "source": [
        "Backpropagation allows the information to go back from the cost backward through the network in order to compute the gradient. Therefore, loop over the nodes starting at the final node in reverse topological order to compute the derivative of the final node output with respect to each edge's node tail. Doing so will help us know who is responsible for the most error and change the parameters in that direction. The following derivatives' formulas will help us write the back-propagate functions:\n",
        "$$dA^L = \\frac{A^L - Y}{A^L(1 - A^L)}\\tag4\\\\{}$$\n",
        "$$dZ^L = A^L - Y\\tag5\\\\{}$$\n",
        "$$dW^l = \\frac{1}{m}dZ^l{A^{l - 1}}^T\\tag6\\\\{}$$\n",
        "$$db^l = \\frac{1}{m}\\sum_i(dZ^l)\\tag7\\\\{}$$\n",
        "$$dA^{l - 1} = {W^l}^TdZ^l\\tag8\\\\{}$$\n",
        "$$dZ^{l} = dA^l*g^{'l}(Z^l)\\tag9\\\\{}$$\n",
        "Since $b^l$ is always a vector, the sum would be across rows (since each column is an example)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "NynGPQtNYLEB"
      },
      "source": [
        "# Define derivative of activation functions w.r.t z that will be used in back-propagation\n",
        "def sigmoid_gradient(dA, Z):\n",
        "    \"\"\"\n",
        "    Computes the gradient of sigmoid output w.r.t input Z.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    dA : 2d-array\n",
        "        post-activation gradient, of any shape.\n",
        "    Z : 2d-array\n",
        "        input used for the activation fn on this layer.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dZ : 2d-array\n",
        "        gradient of the cost with respect to Z.\n",
        "    \"\"\"\n",
        "    A, Z = sigmoid(Z)\n",
        "    dZ = dA * A * (1 - A)\n",
        "\n",
        "    return dZ\n",
        "\n",
        "\n",
        "def tanh_gradient(dA, Z):\n",
        "    \"\"\"\n",
        "    Computes the gradient of hyperbolic tangent output w.r.t input Z.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    dA : 2d-array\n",
        "        post-activation gradient, of any shape.\n",
        "    Z : 2d-array\n",
        "        input used for the activation fn on this layer.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dZ : 2d-array\n",
        "        gradient of the cost with respect to Z.\n",
        "    \"\"\"\n",
        "    A, Z = tanh(Z)\n",
        "    dZ = dA * (1 - np.square(A))\n",
        "\n",
        "    return dZ\n",
        "\n",
        "\n",
        "def relu_gradient(dA, Z):\n",
        "    \"\"\"\n",
        "    Computes the gradient of ReLU output w.r.t input Z.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    dA : 2d-array\n",
        "        post-activation gradient, of any shape.\n",
        "    Z : 2d-array\n",
        "        input used for the activation fn on this layer.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dZ : 2d-array\n",
        "        gradient of the cost with respect to Z.\n",
        "    \"\"\"\n",
        "    A, Z = relu(Z)\n",
        "    dZ = np.multiply(dA, np.int64(A > 0))\n",
        "\n",
        "    return dZ\n",
        "\n",
        "\n",
        "# define helper functions that will be used in L-model back-prop\n",
        "def linear_backword(dZ, cache):\n",
        "    \"\"\"\n",
        "    Computes the gradient of the output w.r.t weight, bias, and post-activation\n",
        "    output of (l - 1) layers at layer l.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    dZ : 2d-array\n",
        "        gradient of the cost w.r.t. the linear output (of current layer l).\n",
        "    cache : tuple\n",
        "        values of (A_prev, W, b) coming from the forward propagation in the current layer.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dA_prev : 2d-array\n",
        "        gradient of the cost w.r.t. the activation (of the previous layer l-1).\n",
        "    dW : 2d-array\n",
        "        gradient of the cost w.r.t. W (current layer l).\n",
        "    db : 2d-array\n",
        "        gradient of the cost w.r.t. b (current layer l).\n",
        "    \"\"\"\n",
        "    A_prev, W, b = cache\n",
        "    m = A_prev.shape[1]\n",
        "\n",
        "    dW = (1 / m) * np.dot(dZ, A_prev.T)\n",
        "    db = (1 / m) * np.sum(dZ, axis=1, keepdims=True)\n",
        "    dA_prev = np.dot(W.T, dZ)\n",
        "\n",
        "    assert dA_prev.shape == A_prev.shape\n",
        "    assert dW.shape == W.shape\n",
        "    assert db.shape == b.shape\n",
        "\n",
        "    return dA_prev, dW, db\n",
        "\n",
        "\n",
        "def linear_activation_backward(dA, cache, activation_fn):\n",
        "    \"\"\"\n",
        "    Arguments\n",
        "    ---------\n",
        "    dA : 2d-array\n",
        "        post-activation gradient for current layer l.\n",
        "    cache : tuple\n",
        "        values of (linear_cache, activation_cache).\n",
        "    activation : str\n",
        "        activation used in this layer: \"sigmoid\", \"tanh\", or \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dA_prev : 2d-array\n",
        "        gradient of the cost w.r.t. the activation (of the previous layer l-1), same shape as A_prev.\n",
        "    dW : 2d-array\n",
        "        gradient of the cost w.r.t. W (current layer l), same shape as W.\n",
        "    db : 2d-array\n",
        "        gradient of the cost w.r.t. b (current layer l), same shape as b.\n",
        "    \"\"\"\n",
        "    linear_cache, activation_cache = cache\n",
        "\n",
        "    if activation_fn == \"sigmoid\":\n",
        "        dZ = sigmoid_gradient(dA, activation_cache)\n",
        "        dA_prev, dW, db = linear_backword(dZ, linear_cache)\n",
        "\n",
        "    elif activation_fn == \"tanh\":\n",
        "        dZ = tanh_gradient(dA, activation_cache)\n",
        "        dA_prev, dW, db = linear_backword(dZ, linear_cache)\n",
        "\n",
        "    elif activation_fn == \"relu\":\n",
        "        dZ = relu_gradient(dA, activation_cache)\n",
        "        dA_prev, dW, db = linear_backword(dZ, linear_cache)\n",
        "\n",
        "    return dA_prev, dW, db\n",
        "\n",
        "\n",
        "def L_model_backward(AL, y, caches, hidden_layers_activation_fn=\"relu\"):\n",
        "    \"\"\"\n",
        "    Computes the gradient of output layer w.r.t weights, biases, etc. starting\n",
        "    on the output layer in reverse topological order.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    AL : 2d-array\n",
        "        probability vector, output of the forward propagation (L_model_forward()).\n",
        "    y : 2d-array\n",
        "        true \"label\" vector (containing 0 if non-cat, 1 if cat).\n",
        "    caches : list\n",
        "        list of caches for all layers.\n",
        "    hidden_layers_activation_fn :\n",
        "        activation function used on hidden layers: \"tanh\", \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    grads : dict\n",
        "        with the gradients.\n",
        "    \"\"\"\n",
        "    y = y.reshape(AL.shape)\n",
        "    L = len(caches)\n",
        "    grads = {}\n",
        "\n",
        "    dAL = np.divide(AL - y, np.multiply(AL, 1 - AL))\n",
        "\n",
        "    grads[\"dA\" + str(L - 1)], grads[\"dW\" + str(L)], grads[\n",
        "        \"db\" + str(L)] = linear_activation_backward(\n",
        "            dAL, caches[L - 1], \"sigmoid\")\n",
        "\n",
        "    for l in range(L - 1, 0, -1):\n",
        "        current_cache = caches[l - 1]\n",
        "        grads[\"dA\" + str(l - 1)], grads[\"dW\" + str(l)], grads[\n",
        "            \"db\" + str(l)] = linear_activation_backward(\n",
        "                grads[\"dA\" + str(l)], current_cache,\n",
        "                hidden_layers_activation_fn)\n",
        "\n",
        "    return grads\n",
        "\n",
        "\n",
        "# define the function to update both weight matrices and bias vectors\n",
        "def update_parameters(parameters, grads, learning_rate):\n",
        "    \"\"\"\n",
        "    Update the parameters' values using gradient descent rule.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    parameters : dict\n",
        "        contains all the weight matrices and bias vectors for all layers.\n",
        "    grads : dict\n",
        "        stores all gradients (output of L_model_backward).\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    parameters : dict\n",
        "        updated parameters.\n",
        "    \"\"\"\n",
        "    L = len(parameters) // 2\n",
        "\n",
        "    for l in range(1, L + 1):\n",
        "        parameters[\"W\" + str(l)] = parameters[\n",
        "            \"W\" + str(l)] - learning_rate * grads[\"dW\" + str(l)]\n",
        "        parameters[\"b\" + str(l)] = parameters[\n",
        "            \"b\" + str(l)] - learning_rate * grads[\"db\" + str(l)]\n",
        "\n",
        "    return parameters"
      ],
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B5XmhnKTYLEC"
      },
      "source": [
        "<a id=\"Application\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EQoy5mZYLEC"
      },
      "source": [
        "<!-- <h2 style=\"font-family: Georgia; font-size:2em;color:purple; font-style:bold\"> -->\n",
        "## II. Application\n",
        "<!-- </h2> -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ivWi_FBSYLEC"
      },
      "source": [
        "The dataset that we'll be working on has 209 images. Each image is 64 x 64 pixels on RGB scale. We'll build a neural network to classify if the image has a cat or not. Therefore, $y^i \\in \\{0, 1\\}.$\n",
        "- We'll first load the images.\n",
        "- Show sample image for a cat.\n",
        "- Reshape input matrix so that each column would be one example. Also, since each image is 64 x 64 x 3, we'll end up having 12,288 features for each image. Therefore, the input matrix would be 12,288 x 209.\n",
        "- Standardize the data so that the gradients don't go out of control. Also, it will help hidden units have similar range of values. For now, we'll divide every pixel by 255 which shouldn't be an issue. However, it's better to standardize the data to have a mean of 0 and a standard deviation of 1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X_UgS0niazeG"
      },
      "source": [
        "### Download and prepare the datset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "aEtOgwK9YLEC",
        "outputId": "66322941-9f94-4cb2-e5da-4aee265c2ae5"
      },
      "source": [
        "# Import training dataset\n",
        "!wget https://github.com/rvarun7777/Deep_Learning/raw/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/train_catvnoncat.h5\n",
        "!wget https://github.com/rvarun7777/Deep_Learning/raw/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/test_catvnoncat.h5\n",
        "!mkdir data\n",
        "!mv train_catvnoncat.h5 data/train_catvnoncat.h5\n",
        "!mv test_catvnoncat.h5 data/test_catvnoncat.h5\n",
        "train_dataset = h5py.File(\"data/train_catvnoncat.h5\")\n",
        "X_train = np.array(train_dataset[\"train_set_x\"])\n",
        "y_train = np.array(train_dataset[\"train_set_y\"])\n",
        "\n",
        "test_dataset = h5py.File(\"data/test_catvnoncat.h5\")\n",
        "X_test = np.array(test_dataset[\"test_set_x\"])\n",
        "y_test = np.array(test_dataset[\"test_set_y\"])\n",
        "\n",
        "# print the shape of input data and label vector\n",
        "print(f\"\"\"Original dimensions:\\n{20 * '-'}\\nTraining: {X_train.shape}, {y_train.shape}\n",
        "Test: {X_test.shape}, {y_test.shape}\"\"\")\n",
        "\n",
        "# plot cat image\n",
        "plt.figure(figsize=(6, 6))\n",
        "plt.imshow(X_train[50])\n",
        "plt.axis(\"off\");\n",
        "\n",
        "# Transform input data and label vector\n",
        "X_train = X_train.reshape(209, -1).T\n",
        "y_train = y_train.reshape(-1, 209)\n",
        "\n",
        "X_test = X_test.reshape(50, -1).T\n",
        "y_test = y_test.reshape(-1, 50)\n",
        "\n",
        "# standarize the data\n",
        "X_train = X_train / 255\n",
        "X_test = X_test / 255\n",
        "\n",
        "print(f\"\"\"\\nNew dimensions:\\n{15 * '-'}\\nTraining: {X_train.shape}, {y_train.shape}\n",
        "Test: {X_test.shape}, {y_test.shape}\"\"\")"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2021-09-29 07:52:05--  https://github.com/rvarun7777/Deep_Learning/raw/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/train_catvnoncat.h5\n",
            "Resolving github.com (github.com)... 13.114.40.48\n",
            "Connecting to github.com (github.com)|13.114.40.48|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://raw.githubusercontent.com/rvarun7777/Deep_Learning/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/train_catvnoncat.h5 [following]\n",
            "--2021-09-29 07:52:05--  https://raw.githubusercontent.com/rvarun7777/Deep_Learning/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/train_catvnoncat.h5\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.111.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 2572022 (2.5M) [application/octet-stream]\n",
            "Saving to: ‘train_catvnoncat.h5’\n",
            "\n",
            "train_catvnoncat.h5 100%[===================>]   2.45M  --.-KB/s    in 0.1s    \n",
            "\n",
            "2021-09-29 07:52:06 (20.8 MB/s) - ‘train_catvnoncat.h5’ saved [2572022/2572022]\n",
            "\n",
            "--2021-09-29 07:52:06--  https://github.com/rvarun7777/Deep_Learning/raw/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/test_catvnoncat.h5\n",
            "Resolving github.com (github.com)... 52.192.72.89\n",
            "Connecting to github.com (github.com)|52.192.72.89|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://raw.githubusercontent.com/rvarun7777/Deep_Learning/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/test_catvnoncat.h5 [following]\n",
            "--2021-09-29 07:52:07--  https://raw.githubusercontent.com/rvarun7777/Deep_Learning/master/Neural%20Networks%20and%20Deep%20Learning/Week%202/Logistic%20Regression%20as%20a%20Neural%20Network/datasets/test_catvnoncat.h5\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.111.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 616958 (602K) [application/octet-stream]\n",
            "Saving to: ‘test_catvnoncat.h5’\n",
            "\n",
            "test_catvnoncat.h5  100%[===================>] 602.50K  --.-KB/s    in 0.1s    \n",
            "\n",
            "2021-09-29 07:52:07 (5.40 MB/s) - ‘test_catvnoncat.h5’ saved [616958/616958]\n",
            "\n",
            "mkdir: cannot create directory ‘data’: File exists\n",
            "Original dimensions:\n",
            "--------------------\n",
            "Training: (209, 64, 64, 3), (209,)\n",
            "Test: (50, 64, 64, 3), (50,)\n",
            "\n",
            "New dimensions:\n",
            "---------------\n",
            "Training: (12288, 209), (1, 209)\n",
            "Test: (12288, 50), (1, 50)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eG5JdauJYLED"
      },
      "source": [
        "### Define NN model \n",
        "\n",
        "Now, our dataset is ready to be used and test our neural network implementation. Let's first write **multi-layer model** function to implement gradient-based learning using predefined number of iterations and learning rate."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "code_folding": [
          0
        ],
        "id": "gqzt9i7xYLED"
      },
      "source": [
        "# Define the multi-layer model using all the helper functions we wrote before\n",
        "\n",
        "\n",
        "def L_layer_model_train(\n",
        "        X, y, layers_dims, learning_rate=0.01, num_iterations=3000,\n",
        "        print_cost=True, hidden_layers_activation_fn=\"relu\"):\n",
        "    \"\"\"\n",
        "    Implements multilayer neural network using gradient descent as the\n",
        "    learning algorithm.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    X : 2d-array\n",
        "        data, shape: number of examples x num_px * num_px * 3.\n",
        "    y : 2d-array\n",
        "        true \"label\" vector, shape: 1 x number of examples.\n",
        "    layers_dims : list\n",
        "        input size and size of each layer, length: number of layers + 1.\n",
        "    learning_rate : float\n",
        "        learning rate of the gradient descent update rule.\n",
        "    num_iterations : int\n",
        "        number of iterations of the optimization loop.\n",
        "    print_cost : bool\n",
        "        if True, it prints the cost every 100 steps.\n",
        "    hidden_layers_activation_fn : str\n",
        "        activation function to be used on hidden layers: \"tanh\", \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    parameters : dict\n",
        "        parameters learnt by the model. They can then be used to predict test examples.\n",
        "    \"\"\"\n",
        "    np.random.seed(1)\n",
        "\n",
        "    # initialize parameters\n",
        "    parameters = initialize_parameters(layers_dims)\n",
        "\n",
        "    # intialize cost list\n",
        "    cost_list = []\n",
        "\n",
        "    # iterate over num_iterations\n",
        "    print(\"=============================================\")\n",
        "    print(\"                Start Training\")\n",
        "    print(\"=============================================\")\n",
        "    for i in range(num_iterations):\n",
        "        # iterate over L-layers to get the final output and the cache\n",
        "        AL, caches = L_model_forward(X, parameters, hidden_layers_activation_fn)\n",
        "\n",
        "        # compute cost to plot it\n",
        "        cost = compute_BCE_cost(AL, y)\n",
        "\n",
        "        # iterate over L-layers backward to get gradients\n",
        "        grads = L_model_backward(AL, y, caches, hidden_layers_activation_fn)\n",
        "\n",
        "        # update parameters\n",
        "        parameters = update_parameters(parameters, grads, learning_rate)\n",
        "\n",
        "        # append each 100th cost to the cost list\n",
        "        if (i + 1) % 100 == 0 and print_cost:\n",
        "            print(f\"The cost after {i + 1} iterations is: {cost:.4f}\")\n",
        "\n",
        "        if i % 100 == 0:\n",
        "            cost_list.append(cost)\n",
        "\n",
        "    # plot the cost curve\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    plt.plot(cost_list)\n",
        "    plt.xlabel(\"Iterations (per hundreds)\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.title(f\"Loss curve for the learning rate = {learning_rate}\")\n",
        "\n",
        "    return parameters\n",
        "\n",
        "\n",
        "def accuracy(X, parameters, y, activation_fn=\"relu\"):\n",
        "    \"\"\"\n",
        "    Computes the average accuracy rate.\n",
        "\n",
        "    Arguments\n",
        "    ---------\n",
        "    X : 2d-array\n",
        "        data, shape: number of examples x num_px * num_px * 3.\n",
        "    parameters : dict\n",
        "        learnt parameters.\n",
        "    y : 2d-array\n",
        "        true \"label\" vector, shape: 1 x number of examples.\n",
        "    activation_fn : str\n",
        "        activation function to be used on hidden layers: \"tanh\", \"relu\".\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    accuracy : float\n",
        "        accuracy rate after applying parameters on the input data\n",
        "    \"\"\"\n",
        "    probs, caches = L_model_forward(X, parameters, activation_fn)\n",
        "    labels = (probs >= 0.5) * 1\n",
        "    accuracy = np.mean(labels == y) * 100\n",
        "\n",
        "    return f\"The accuracy rate is: {accuracy:.2f}%.\""
      ],
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nPYaNELObDHC"
      },
      "source": [
        "### Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uRqcXguZYLED"
      },
      "source": [
        "Next, we'll train two versions of the neural network where each one will use different activation function on hidden layers: One will use rectified linear unit (**ReLU**) and the second one will use hyperbolic tangent function (**tanh**). Finally we'll use the parameters we get from both neural networks to classify test examples and compute the test accuracy rates for each version to see which activation function works best on this problem."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "81a6ArBSbG6g"
      },
      "source": [
        "#### Training using tanh"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "y4FnjUPgYLED",
        "outputId": "f074b698-104f-4d15-8488-a84db204e0ad"
      },
      "source": [
        "# Setting layers dims\n",
        "layers_dims = [X_train.shape[0], 5, 5, 1]\n",
        "\n",
        "# NN with tanh activation fn\n",
        "parameters_tanh = L_layer_model_train( X_train, y_train, layers_dims, learning_rate=0.03, num_iterations=3000,\n",
        "    hidden_layers_activation_fn=\"tanh\")\n",
        "\n",
        "# Print the accuracy\n",
        "accuracy(X_test, parameters_tanh, y_test, activation_fn=\"tanh\")"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=============================================\n",
            "                Start Training\n",
            "=============================================\n",
            "The cost after 100 iterations is: 0.6556\n",
            "The cost after 200 iterations is: 0.6468\n",
            "The cost after 300 iterations is: 0.6447\n",
            "The cost after 400 iterations is: 0.6441\n",
            "The cost after 500 iterations is: 0.6440\n",
            "The cost after 600 iterations is: 0.6440\n",
            "The cost after 700 iterations is: 0.6440\n",
            "The cost after 800 iterations is: 0.6439\n",
            "The cost after 900 iterations is: 0.6439\n",
            "The cost after 1000 iterations is: 0.6439\n",
            "The cost after 1100 iterations is: 0.6439\n",
            "The cost after 1200 iterations is: 0.6439\n",
            "The cost after 1300 iterations is: 0.6438\n",
            "The cost after 1400 iterations is: 0.6438\n",
            "The cost after 1500 iterations is: 0.6437\n",
            "The cost after 1600 iterations is: 0.6434\n",
            "The cost after 1700 iterations is: 0.6429\n",
            "The cost after 1800 iterations is: 0.6413\n",
            "The cost after 1900 iterations is: 0.6361\n",
            "The cost after 2000 iterations is: 0.6124\n",
            "The cost after 2100 iterations is: 0.5112\n",
            "The cost after 2200 iterations is: 0.5347\n",
            "The cost after 2300 iterations is: 0.4830\n",
            "The cost after 2400 iterations is: 0.5311\n",
            "The cost after 2500 iterations is: 0.4253\n",
            "The cost after 2600 iterations is: 0.2088\n",
            "The cost after 2700 iterations is: 0.3167\n",
            "The cost after 2800 iterations is: 0.2111\n",
            "The cost after 2900 iterations is: 0.1165\n",
            "The cost after 3000 iterations is: 0.0950\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'The accuracy rate is: 64.00%.'"
            ]
          },
          "metadata": {},
          "execution_count": 44
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAGkCAYAAAAWpWy5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeVxU9f4/8NeZGfZ9l0VcQNzANNTcTRFcr5ZCmnW73b5ULvlzqXszs0xbrG5Fm2amLWZu4L7hSm6g5YaaqYCagqTsO8z6+wMZGGbYlzPA6/l4+IA5c+bMe+aAvM5nPouQnZ2tARERERGREZKIXQARERERUVUYVomIiIjIaDGsEhEREZHRYlglIiIiIqPFsEpERERERothlYiIiIiMFsMqETWL+/fvY+bMmfD394ejoyPs7e3x119/iV2Wjl9++QX29vZYvny5KM8/c+ZMo3xf6qPsvfzll1/ELoWIWjiGVTJ69vb2sLe3F7sMaqBZs2Zh48aNCAgIwKuvvorXX38ddnZ2zVqD2GGUWp8TJ07A3t4eM2fOFLuURpGSkoJXXnkF3bp1g6urKwICArBw4UJkZ2fX+VhFRUVYvnw5+vbtCzc3N/j6+uL555/H9evXDe7/5ZdfIiwsDAEBAfD09ET79u0xaNAgLFq0CCkpKQ19adSCycQugIhaP7lcjpiYGHTp0gUbN24UuxxqBhMmTEC/fv3g5uYmdilUS7dv30ZISAgePHiAcePGwc/PD+fOncOqVatw5MgRHDhwAI6OjrU6VklJCSZPnoy4uDj06dMHM2bMQEpKCnbs2IGDBw9i165d6Nu3r85jfvjhB1hZWWHw4MFwdXWFQqHApUuXsHLlSqxfvx67du1C7969m+Klk5FjWCWiJnf//n2o1Wq4urqKXQo1Ezs7u2ZvOaeGWbBgAR48eICPPvoIL7/8snb7okWLsHLlSrz77ruIiIio1bFWrFiBuLg4TJo0CT/88AMkktIPcp988kk888wzeOWVVxAbG6vdDgBxcXEwNzfXO9ZPP/2EuXPnYunSpdi+fXsDXyW1ROwGQK2KRqPBunXrMGrUKHh5ecHd3R1Dhw7FV199BYVCobf/lStXEB4ejl69esHNzQ2dO3fGoEGD8OqrryInJ0e7n1wux7fffovhw4ejU6dOaNeuHfz9/REaGopdu3bVuj6VSoUff/wRY8eOhbe3N9q1a4dHHnkEM2bMwNWrV7X7Vdd38a+//jL4sWPZY06cOIFNmzZhxIgR8PDwwJAhQ7B161bY29vjP//5j8G6lEolunbtCk9PT+Tn5+vct3PnTkyaNAkdO3aEq6srHn30UbzzzjvIzc2t1WsOCAhAQEAAAODUqVPabh0V65fL5fjyyy8xZMgQuLu7w8vLC6NGjcLPP/8MjUZ/RWh7e3sEBAQgJycHCxcuhL+/P5ycnLBy5coq65g5cyZmz54NAPjoo4+0dZS9Z5VdunQJTz31FLy9veHu7o5x48bhzJkzBo+tVquxbt06jB49Gt7e3nBzc8PAgQPx2WefQS6X1+p9qsnFixfxwgsvoFu3bnBxcUHXrl3x0ksv4ebNm3r7JiYm4p133sHjjz8OHx8fuLq6wt/fH3PmzMHdu3f19q/4UXZCQgL+9a9/wcfHBw4ODrh06ZLO/X/99RdeeOEFdO7cGW5ubnj88ccRHR2td8yq+qwGBATA3t4eSqUSn376KR599FG4urqiZ8+eWLJkSZXv15YtWzBs2DC0a9cOvr6+eOmll5Camorx48fXqZtQ2fOXlJRg+fLlePTRR+Hi4oKFCxcCAFJTU/HRRx9h9OjR8PPzg4uLC7p164b/+7//w59//qlzrOXLl+Mf//gHAGDjxo06P1OVX/fx48cxbdo0+Pj4wMXFBf7+/nj11Vdx//79WtfelG7duoWjR4/C29sbL774os59b7zxBqysrLB582YUFBTUeCyNRoPvv/8eALB06VKdQDp+/HgMHDgQ165dw8mTJ3UeZyioAsATTzwBAEhKSqrTa6LWgy2r1KrMmDEDmzdvhoeHB6ZPnw4TExNER0fjrbfeQkxMDLZs2QKZrPTH/sqVKxg1ahQEQcDo0aPRqVMn5Ofn486dO9iwYQNmz56tbRmaNWsWoqKi0K1bN4SFhcHKygqpqak4f/489uzZg4kTJ9ZYm1wux9SpUxETEwNPT09MmTIFdnZ2SE5OxpEjR9CrVy/06NGjwe/B119/jWPHjmHs2LEYPnw45HI5xo8fDzs7O2zduhXvv/8+TE1NdR5z5MgR3L9/H08//TSsra2121999VWsXbsWnp6emDBhAuzt7XH27Fl8/vnnOHjwIA4cOAAbG5tq65k5cybu3LmDVatWoX379pg+fToAaAOsQqFAaGgojh8/Dl9fX7zwwguQy+XYs2cP5syZg9OnT2PFihV6x5XL5Zg4cSJycnIQHBwMCwsLeHp6VlnH+PHjkZOTg3379mHw4MEYMmSI9j5vb2+dfS9evIgvv/wS/fr1w3PPPYfk5GTs2rULkyZNwokTJ9ClSxftvkqlEs8++yyio6Ph6+uLKVOmwMzMDKdOncKyZctw7NgxbN26VftzVx9btmzBrFmzYGpqirFjx8LT0xM3b97E1q1bER0djT179qBXr17a/Xfv3o3vv/8eQ4cORf/+/WFqaopr165h/fr1iI6Oxq+//mrwvbp16xaCgoLQtWtXTJ06FXl5ebC0tNReuN29exdBQUHo2LEjpk6diqysLGzfvh3Tp0/Hjh07MGzYsFq/pvDwcMTFxWHUqFGwsbHBoUOH8MUXXyAtLU3vouOLL77AkiVLYGdnh2nTpsHOzg4xMTEYPXo0bG1t6/WePvfcc4iPj0dQUBAmTJiADh06AABiY2Px+eefY+jQoZg4cSKsrKyQlJSEXbt2Yf/+/di/fz8eeeQRAMCQIUNw584dbNy4Ef7+/hg/frz2+GU/3wDw+eef45133oGDgwNCQkLg5uaGP/74A2vXrsX+/ftx6NChan92m0PZBdvIkSN1wiUA2NjY4LHHHsPRo0dx9uxZDB8+vNpj3bp1C8nJyfD19UXHjh317g8ODkZcXByOHz9eq5+Zsoshf3//Wr4aam0YVqnV2LZtGzZv3oyePXti//792j9iS5YsQWhoKI4ePYpvvvkGc+bMAVDaElJcXIz169djwoQJOsfKy8vTBrqcnBxs3boVvXv3xuHDh/VCR0ZGRq3q+/DDDxETE4OQkBCsW7dOpxVBoVAgKyur3q+9ohMnTuDgwYM64QUApkyZgu+//x4HDhzQtgaVKetHWhYkAWDz5s1Yu3YtJkyYgO+++w4WFhba+/73v//h/fffx4cffoj333+/2npmzZqFv/76C6tWrYK3tzfeeOMNnftXrFiB48ePY+TIkdi0aZP2fV+8eDHGjBmDX375BSEhIZg0aZLO4+7fv4/u3btj//79sLS0rPF9mTBhgjasDhkyRK+Oig4cOIAVK1bgmWee0W774YcfMH/+fKxatQqffvqpdntERASio6Px4osv4sMPP4RUKgVQ2to6f/58/PTTT1i7dq3Ox6p1cfPmTcyZMwdeXl7Yt28fPDw8tPedOHECTzzxBObMmYNjx45pt0+dOhWzZs2CmZmZzrGOHj2K0NBQfPLJJwY/zj19+jReffVVvPXWWzrbU1NTAQAnT57EwoULta2QABAWFoYpU6bgq6++qlNYvXXrFk6fPg0HBwcAwFtvvYUhQ4Zg06ZNWLJkibav6+3bt/Huu+/CwcEBx44d015YvPPOOwgPD8fWrVtr/ZwV3b17F6dOnYKTk5PO9mHDhuHGjRt6F2GXL1/GmDFjsGzZMu1zDh06FAC0AwcN/UydOnUKS5cuRb9+/RAZGanTCrxp0ybMmDEDCxcuxM8//1xjzdnZ2fjmm2/q9DqHDBmirbM6CQkJAAAfHx+D9/v4+ODo0aNITEysMazW5lhA1S2l69atQ0pKCgoKCnD16lX8+uuvaN++PZYtW1bj66DWiWGVWo1169YBKA2nFVtbTE1N8cEHH2DIkCH46aeftGG1TMUQVqbiHypBEKDRaGBqaqoNIhVV/mNniEqlwpo1a2Bubo7PPvtM7+MuExOTRuvP+a9//UsvqAKlQfT777/Hhg0bdMJqdnY29u/fjw4dOui0Nq5cuRJSqRRfffWV3nu0YMECrFq1Clu2bKkxrNak7LxVbvG1s7PD22+/jaeffho//fSTXlgFgHfffbdWQbWuBgwYoBNUAeDZZ5/Ff/7zH5w7d067Ta1WY9WqVXBxccHy5ct1fj4kEgmWLl2KdevWYfPmzfUOq2vXrkVJSQk++OADnaAKlIalsWPHYs+ePbh27Rq6desGAHr7lRk5ciS6deuGo0ePGrzf1dUV//3vf6uspX379npdSYKCguDl5aXzvtTG0qVLtUEVAKysrBAWFoaPP/4YFy5cwJgxYwAAkZGRUCqVCA8P12kBFwQBS5YswY4dO6BSqer03ADw5ptvGvzddXFxMbh/QEAAhg4dipiYGCgUCpiYmNTqeVatWgWNRoOIiAi97grTpk3DypUrsW/fPuTl5dX4KUVOTg4++uijWj1vRbUJq2XdeqrqZ1z2f2rF7lFNdax169bh7Nmz2tuBgYH47rvv0Llz5xqfm1onhlVqNeLj4wEY/o/Z398fLi4uSExMRH5+PqytrTF58mSsWrUKzzzzDCZOnIhhw4ahf//+8PPz03msra0txowZg+joaAwePBgTJkzAwIED0a9fP52PzKtz48YN5Obmonfv3vDy8mr4i61GYGCgwe19+/ZF165dcfjwYaSnp8PZ2RkAsHXrVpSUlGDatGkQBAEAUFhYiEuXLsHBwQGrVq0yeDxTU1OkpqYiMzOz1iOEK8vLy8PNmzfh6uqK7t27691f1oJTdm4rMjc3b7KPBQ2NOC67oKg4hU9iYiIyMjLQqVMn/O9//zN4LAsLC9y4caPetZT1k42NjTX4PqSlpQEArl+/rg2rGo0GW7ZswYYNG3DlyhVkZ2frBLrK3UDK+Pv767XGVhQQEGDwgs3Lywu//fZb7V8UDL/HZb8bFd/jS5cuAQAGDhyot7+3tzc8PT1x586dOj03UPXvCVDasv7999/j4sWLyMjIgFKp1Lk/IyMD7dq1q9XznDlzBjKZDLt378bu3bv17pfL5VCpVEhKSqpxpHuHDh3qNYVUS3P48GEAQGZmJi5duoT33nsPw4cPx9q1axESEiJydSQGhlVqNXJzc2Fra2uwpRQA3NzckJaWhtzcXFhbWyMwMBDR0dH49NNPsWfPHmzZsgVA6R/AefPm4YUXXtA+9ocffsCXX36JqKgofPzxxwBKw8uYMWPw3nvvafu7VaWsBcHd3b0xXmq1qmuhnT59OpYsWYLIyEjtAKeNGzdCEAQ8/fTT2v2ys7Oh0WiQmZlZY0tOfn5+vcNqWQtMVTVbWlrC1tbWYAuMs7OzNlw3tqpahKRSqU7oy8zMBFD6kXZ9Wrxqo+w5vv7662r3qzjwZdGiRfjmm2/Qrl07BAUFwd3dXduav2HDBoODrIDqf3aA6t8XtVpd7WMrMzQoqiwIV3yPy35GqmrxdHV1rVdYrWpKrW+++QZvvPEG7O3tMWLECHh5ecHCwgKCIGDv3r24cuUKSkpKav08mZmZUCqVtfo9ElNNrZ01tZY2xbEcHR3x+OOPo0+fPujfvz9mzJiBy5cvw8rKqsYaqHVhWKVWw9bWFllZWSgqKjIYWMtG3VbsItCvXz9s2rQJcrkcly5dQkxMDL777jssWLAAFhYW2gBnYWGB119/Ha+//jpSU1MRFxeHyMhI7N69G9euXUNsbGy1HwuW/adc1vevJmUDHAx9vFnTx3DVBbipU6di2bJl2LBhA2bOnIkbN27g7NmzGDx4sM5AiLL3qEePHoiNja1VzfVR9jwPHjwweH9hYSFyc3MNhuGmCqp1UVb/mDFjsGnTpiZ9jlu3bul8bF6VtLQ0fPvtt+jRo4fBAXDV9fE0hve0srL6y1qQK6vqZ6cmhl6rUqnEhx9+CDc3Nxw7dkyv9fT333+v8/PY2tpCoVBUeYFQF03ZZ7Vs0GBV/UjLtvv6+jbasarq01qZnZ0d+vbti7179+Lq1avo169frR5HrQfDKrUajzzyCH799VecPHkSwcHBOvddvXoVaWlp8PX1NfjRvampKfr27Yu+ffsiMDAQkydPxp49e3RaG8u4u7tj8uTJmDx5MkJCQvDbb7/h2rVrOqN/K/Pz84OdnR2uXbuG5OTkGrsClLU6JScn6/XTunDhQrWPrU67du0wcuRIHDp0CFeuXNEGl4oDqwDA2toaPXr0QEJCAjIyMmrVL7c+bGxs0LlzZ9y8eVOnz2WZ48ePAzD8kXF9GGq5a4iy83r+/HnI5fIqP15viH79+uHixYuIjY3VGW1eldu3b0OtVmPEiBF6QTUlJQW3b99u9BqbUq9evbBnzx7ExcVh5MiROvfduXOnUVc2ysjIQE5OjnaKrIry8/MNdsOo6WeqX79+OHDgAC5fvlzt/xG10ZR9Vsv2OXr0KNRqtc6MAHl5eThz5gwsLS31JvI3pFOnTvDy8kJiYiJu376tNyPAoUOHAKBOA/LKLvQbMqsGtVycZ5VajX/+858AgGXLlul8pKZQKPDmm28CKJ2upsyZM2dQVFSkd5yyFtiygTvp6em4cuWK3n4lJSXaVs6aBvlIpVKEh4ejuLgYCxYs0PsYUalU6rQQlf1B+PHHH3XmGf3rr78a/HFz2cCh9evXY8uWLbCysjI4eGn27NlQKBSYNWuWwZkK8vLydAZB1FfZeVu8eLHOXLi5ubna0b8Vz1tDlLXQJicnN8rxZDIZZsyYgQcPHuC1115DYWGh3j4ZGRnafpf18dJLL8HU1BSLFy822PdVqVRqQz1QPg3X6dOndQJUfn4+5s6dq9f/0tiFhYVBJpNhzZo1Oh/3azQaLFu2rNEuPIDSrgaWlpa4ePGi3v8hCxcuNDjzR00/U2Vz+86bN89gsC4uLkZcXFyt6ivrs1qXf9XNelFRp06dMHLkSNy5cwffffedzn3Lly9HQUEBpk6dqvcR/I0bN3Djxg2d311BELTdqJYsWaLTRWTv3r2Ii4tDt27ddAZ03r17t8pW8h9++AHnz5+Hu7t7gwM/tUy8RKEWo7q1t9977z1MmTIF0dHRiIyMxIABAzB+/HjtPKtl063MmjVL+5gvvvgCx48fx8CBA9GhQwfY2NggMTERBw4cgIWFhfb57t27h2HDhqFHjx7o2bMnPD09UVBQgKNHjyIpKQkTJ06s1cdZr7/+Os6dO4eDBw/i0UcfxZgxY2Bra4uUlBQcO3YMc+fO1dZXttThtm3bkJKSgv79++Pvv//G/v37MXr06HpP1wMAY8eOhYODA9auXQuFQqE3t2qZZ555BvHx8Vi9ejV69+6NoKAgeHt7IycnB3fu3EFsbCxGjBiBDRs21LsWoPSP+eHDh3H48GEMGjQIo0ePhkKhwO7du3Hv3j1MmzZNOyl4Q/Xv3x9WVlbYtm0bTExM0L59ewiCgKlTp+rNtVpb//nPf3D16lWsW7cOBw8exLBhw+Dp6Yn09HTt9ExlC0/UR5cuXbBy5UrMnj0bAwcOxKhRo+Dj4wOVSoWUlBScOXMGJSUl2iDn5uaGKVOmYOvWrRg6dChGjBiB3NxcxMTEwNzcHAEBAbh8+XK9ahFDp06dsGjRIixbtgxDhw7F5MmTtfOsZmVlwd/fH3/88UejPJdEIsHLL7+MiIgIDBo0COPGjYNCocCJEyeQlZWFoUOH6i0g0aVLF3h5eSEuLg4vvvgifHx8IJVKMXbsWPj7+2PYsGF49913sWTJEgQGBiI4OBgdO3ZEcXEx7t69i9jYWHh7e+tNkC+GTz/9FCEhIXj99ddx7NgxdO3aFWfPnsWJEyfg6+urN6UZUPo7BZQOgqzYd3/27Nk4ePAgdu7ciaCgIAwfPhzJycnYsWMHLC0t8fXXX+u03sbHx+P5559Hv3790LlzZ7i6uiIzMxO///47rl69CisrK3z77bdsWW2jeNapxahuTfmFCxfCyckJ3377LQYNGoSff/4ZP//8M9RqNXx8fLBs2TLMmDFD5z+68PBwODg44Ny5czhz5gwUCgXc3d0xbdo0vPLKK9pZAby9vbFo0SKcOHECp06dQnp6Ouzs7NC5c2fMnTtX7yP0qpiamiIqKgo//vgjNm3ahM2bN0OlUsHNzQ1BQUEYMWKEdl8zMzPs3LkTb7/9Ng4fPoyLFy/Cx8cHH3zwAYYPH96gsGpmZobQ0FBt60l19X/88ccICQnB2rVrcfLkSWRlZcHOzg4eHh4IDw9HaGhovesoY2pqim3btuGbb77Bli1bsGbNGkgkEnTv3h0LFy7Utrw2Bnt7e6xfvx4fffQRtm/frm09GzBgQL3Dqkwmw7p167B161b88ssvOHTokHbQWfv27bFgwQJMnTq1QXWHhobC398fK1aswLFjx7TBs127dggODtZblOKrr75Cx44dsW3bNqxZswbOzs4YO3YsFi1a1KjvZ3NZsGABPDw8sGLFCmzYsAHW1tYICgrC0qVLMXny5BqnfKqLsimtfv75Z/z444+wtbXF448/jsWLF2P58uV6+0ulUqxfvx7vvPMODhw4gLy8PGg0Gnh4eGhnq5gzZw4GDBiAVatWIS4uDtHR0bC2toa7uzueeuopPPnkk41Wf0N06tQJv/76Kz744AMcPnwYhw4dgpubm3Yu2LqsFGZmZobt27cjIiICW7duxcqVK2FjY4Px48fjjTfe0OvyU7aSX1xcHA4ePIisrCyYm5ujQ4cOmD17NmbMmIH27ds39kumFkLIzs7WX8uQiIjIyOXm5sLPzw8BAQHafpBE1PqwzyoRERm1jIwMnT6RQGlf3cWLF6O4uFhvBToial3YDYCIiIza3r17sWzZMjz++OPw9PREVlYWYmNjkZiYiICAALz00ktil0hETYhhlYiIjFqfPn0wcOBAxMbGahdJ6NChA1577TXMnTu3yoVAiKh1YJ9VIiIiIjJa7LNKREREREaLYZWIiIiIjBbDagMkJCSIXQKB58FY8DwYB54H48DzYBx4HoxHQ84FwyoRERERGS2GVSIiIiIyWgyrRERERGS0GFaJiIiIyGgxrBIRERGR0WJYJSIiIiKjJWpYTUxMRHBwMAIDAxEcHIykpCS9fV5++WUMGTJE+8/BwQH79u0ToVoiIiIiam4yMZ98/vz5CA8Px9SpU7F582bMmzcPu3fv1tnn22+/1X5/+fJlTJw4EUFBQc1dKhERERGJQLSW1bS0NMTHxyM0NBQAEBoaivj4eKSnp1f5mJ9//hlhYWEwMzNrrjKJiIiISESihdWUlBR4eHhAKpUCAKRSKdzd3ZGcnGxwf7lcjqioKDz77LPNWSYRERERiUjUbgB1sXfvXnh5eaFXr17V7tfcS6txKTfjwPNgHHgejAPPg3HgeTAOPA/Go6pz0aVLl2ofJ1pY9fT0xL1796BSqSCVSqFSqZCamgovLy+D+69fv75Wrao1veDGdP1GAvy6+EIQhGZ7TtKXkJDQrOedDON5MA48D8aB58E48DwYj4acC9G6Abi4uCAgIABRUVEAgKioKPTq1QvOzs56+6akpCAuLg5PPfVUc5dZJaVag2UJplh4JgcajUbscoiIiIhaJVGnroqIiMDq1asRGBiI1atXIyIiAgAQFhaGCxcuaPfbuHEjxowZA3t7e7FK1aFQa/DisSzsfSDDt38W4N3zuWKXRERERNQqidpn1c/PD0eOHNHbHhkZqXP7tddea66SamV+bDa23y7S3v7sUj4sZRK89oiNiFURERERtT5cwaoeZvawhoOZbj/V987nYsUf+SJVRERERNQ6MazWQ09HE2wLcYaVVLev6pu/5eCHawUiVUVERETU+jCs1lMfZ1N80bMEljLdFtYFcdnYlFgoUlVERERErQvDagM8YqvGxiBHmEnLt2kAzDqZhR23iqp8HBERERHVDsNqAw33MMe6EU4wqfBOqjVA+LFMRN9lYCUiIiJqCIbVRjC6vTnWDHeEpEKPAKUG+FdMJn69VyxeYUREREQtHMNqI5nU0QLfDHVAxR6sJSpg+pFMxN0vEa0uIiIiopaMYbURTfWxRMQg3YULCpUaPHUoA+fT5CJVRURERNRyMaw2sue7WuGD/nY62/IUGkw+mI4rmQqRqiIiIiJqmRhWm8CsntZ461FbnW3Zcg2ePJCOG9kMrERERES1xbDaRF59xAav9rLW2ZZWrMakA+m4nacUqSoiIiKiloVhtQktftQWM3pY6WxLLVRjYnQ6kvMZWImIiIhqwrDahARBwPL+dviXn6XO9jv5KjxxIAP3C1UiVUZERETUMjCsNjFBEPDZQHs85WOhsz0xV4knD6Qjs5iBlYiIiKgqDKvNQCoRsHKIAyZ2MNfZfjVbickHM5AjV4tUGREREZFxY1htJjKJgDXDHRHiZaaz/WKGAk8dykC+goGViIiIqDKG1WZkKhXw0wgnDHPXDaxnHsjx9OEMFCk1IlVGREREZJwYVpuZhUzAhiBHPOZqqrP9xN9y+G5MxRMH0vHxxVycSC1heCUiIqI2TyZ2AW2RtYkEW4KdMCk6HRczyhcJKFBq8Ou9Evx6rwRAHkwkQB8nUwxqZ4qBbmZ4zNUU9ma8viAiIqK2g2FVJHamEmwLccKE/em4mm14zlWFGvgtTY7f0uT4/HI+BAA9HGQY1M4Mg9xKA2w7S2nzFk5ERETUjBhWReRoLsWesc54/0Iedt0uQlpx9YOsNAD+yFLijywlvvuzAADQyUaKQe3MMNDNFIPczNDJRgpBEJqheiIiIqKmx7AqMkdzKT4daI9PBtghKVeJ2PtyxP5dgrj7cvyVX/McrLfyVLiVV4hfEgoBAO0sJBjoZoZuDjLYmkhgYyrA1kQCO1MBtqYS2JiUfrU1kcBMCgZbIiIiMmoMq0ZCEAT42pnA184Ez/mVLtF6r0CFuPsliL0vR9zfJVV2F6jo7yI1tt8uAm7X/JwmEsDWRAJbvSBbHmhtTQXYmEggk5ROvyUVAJlQOnesVEDpdqH0e1lvz+8AACAASURBVKlEKL1PKN+3bJtMAkgf7icRAOHhay79+vB2xe8ffgV094WBfYpUQEGFqb8q5+/yR5YfT/e9r7x/7dQ25zfm5UBjX1qI8RqIiIjqgmHViHlYSTGlsyWmdC5drjWrRI3TZeH1fgkupivQkAkDFGogo0SNjBIAaMkraVkCcaliF0GwBE6mNNrRqgvIVYXsah9TxeOru3jReUyFW4b2ESrdJ1TaQfdYlfcV9C/SDF3EPbxX+zgD+ygV5jC7dF97USgRyu+TCAIkFS4YJQIggVBpH919K190ygQB0odfdW+XXqTKdPYvu126n4mkdEYUK5kEFjIBljIBVjIBlibl31vIBFhIBX7qQ0RaDKstiIOZBGO9LTDWu3Tp1gKFGmfT5A/Dqxy/P5CjSMXprqh1qO4nWdPQH/N6Pb4pf7ca89gSoLjmT2GMmQDA8mGYrRhiLWUCLE0kpQFXJsDJTAIfOxl8bEv/uVlIGHKJWiGG1RbMykSC4R7mGO5RuoyrXKVBfIYCZ9PkSC9WIVehQa5cjVy5BrkKNfIefs2Vl27nNK5EZIw0KJ3Kr6CO/0lZywT42MngaytDZ1sZfB9+72Mr47R/RC0Yw2orYioV0M/VFP0qLThgiEajQbEKpWG2QpDNeRhk88qCrkKNfIUGSjWg0mig0kD7feVtSo0Gag2gVGug1ACqh9tUapTu8/AxGg2ggQYalH0P3e+12zQPay3fB3r7AGq1GhKJRLuvzuus1GJV+U+f/v61U5uWvca+Fmj049XygLymoZYiX1l6wR5fYf7qMk5mEvg+bIX1rdAa29lWCksZgyyRMWNYbaMEQYCFDLCQSeGGlj1Xa0JCArp06SJ2GW1ebc6DppYJuT5dAKp9TBWPr2q73n0VbpXtpzGwb+X7DNVafp9Ge7viBRgqfK97EVdeRVX7A8DN27fRoUMHqDWA+uH20u/LLxDVGkCt/V4DNXT31Ty88FSj/KKz4kWq8uFFqariVw2genihWn7Bqru/XK1BobL0X9HDltOy24UKDQqUahSpNChpgi70GSVqZDyQ48wDud59npZS+NjJEOJlhhe7W8NMyq4ERMaEYZWImk1t+xNWu5coOaLlhBeVhQZd7EzELqNBlBVCbfk/NQqVGhQoyrclF6hwM1eJxFwlknKUyK9n36aUQhVSClU4nlqCXxIKsWKIAx51qfkTKiJqHgyrRERkVGQS4eGUerV/jEajwf0iNZJylUjKVSIxpzzE3spTQl79mitaf2YrMWpvGub6W+P13rYwl7WcCxWi1ophlYiIWjxBENDOUop2llIMbmemc59KrcHdApU2xFYMtHfyVXpdSNQaIOJyPvbfLcaKIQ4IZCsrkagYVomIqFWTSgR0tJGho40MQZ6695WoNLiVp8SXl/OxIbFQ575r2UoE703DnJ7WeKMPW1mJxMIhkERE1GaZSQV0szfByqEO2DLKCR6Wun8W1Rrgiyv5GLbrAX43MDiLiJoewyoRERGAkPbmiH3CDc92sdS770aOEqP3peHt33NQxEmqiZoVwyoREdFD9mYSfD3EAVHBTvC01J3WT60BvnzYyvrbgxKRKiRqexhWiYiIKhnlZY7YJ13xnJ9+K2tCjhKj96Zj8W9sZSVqDgyrREREBtiZSvDlYAdsC3GCl5VuK6sGwNd/5GPozgc4fZ+trERNiWGViIioGiM9zRH7hCueN9DKmpirxNh96Vj0WzYKlbWczJWI6oRhlYiIqAa2phJ8PtgB26toZV35RwGG7nyAOLayEjU6hlUiIqJaGuFpjrgnXfFCVyu9+5JyVRi3Lx0Lz2SjWCVCcUStFMMqERFRHdiYSPDZIHvsHO2E9tb6rayrrhbg6QvmOJ/GeVmJGgPDKhERUT0M9yjtyxreTb+VNblYgqmHM5BWxCZWooZiWCUiIqonGxMJPhloj11jnOFdqZU1rViNzUmFVTySiGqLYZWIiKiBhrmbIfYJVzzV2UJne+TNIpEqImo9GFaJiIgagbWJBEv72UGosC0+Q4Eb2QrRaiJqDRhWiYiIGom7pRRD3c10trF1lahhRA2riYmJCA4ORmBgIIKDg5GUlGRwv+3bt2PQoEEYOHAgBg0ahAcPHjRzpURERLUTVqkrQNTNQmg0XJaVqL5EDavz589HeHg4zp07h/DwcMybN09vnwsXLuDDDz/E9u3bERcXh/3798PW1laEaomIiGo2saMFTIXycHorT4Vz6ewKQFRfooXVtLQ0xMfHIzQ0FAAQGhqK+Ph4pKen6+y3cuVKvPLKK3BzcwMA2NnZwdzcvNnrJSIiqg07UwkGO+pOWRXJWQGI6k0m1hOnpKTAw8MDUmnpVB9SqRTu7u5ITk6Gs7Ozdr9r166hQ4cOGDt2LAoKCvCPf/wDr732GgRBMHjchISEZqlfrOcjw3gejAPPg3HgeRDfGBcpYjLK/8RGJubjecc0yAz/6aImxN8H41HVuejSpUu1jxMtrNaWSqXClStXsGPHDsjlcoSGhsLLywtPP/20wf1resGNKSEhoVmfjwzjeTAOPA/GgefBOJSoE2BrKiBXXtodIFMhINWqPUZ68pPB5sTfB+PRkHMhWjcAT09P3Lt3DypV6UclKpUKqamp8PLy0tmvffv2mDRpEszMzGBjY4Nx48bh/PnzYpRMRERUK2YSYGIH3YFWW9gVgKheRAurLi4uCAgIQFRUFAAgKioKvXr10ukCAJT2ZY2JiYFGo4FCocCxY8fg7+8vRslERES1VnlWgD1/FaNIyVkBiOpK1NkAIiIisHr1agQGBmL16tWIiIgAAISFheHChQsAgClTpsDZ2RmPPfYYhg4dim7duuGf//ynmGUTERHVaEg7M7SzKP8zm6/UIPou51wlqitR+6z6+fnhyJEjetsjIyO130skEnzwwQf44IMPmrM0IiKiBpFKBEzubIGVfxRot0XeLMKTnSxFrIqo5eEKVkRERE3kqc66wfRQcjGyStQiVUPUMjGsEhERNZFHnEzga1v+IaZCDey8za4ARHXBsEpERNREBEFAmI/uQKvIm5wVgKguGFaJiIiaUFilrgCn/pYjOV8pUjVELQ/DKhERURPqbCtDoLOJzrZtt9gVgKi2GFaJiIiaWGil1tUtNxlWiWqLYZWIiKiJTe5kAYlQfvtKpgJ/ZinEK4ioBWFYJSIiamJullIMdzfT2RbFgVZEtcKwSkRE1AwqL78aebMIGg2XXyWqCcMqERFRM5jQwQLm0vLbd/JV+O2BXLyCiFoIhlUiIqJmYGsqwZj2uq2rURxoRVQjhlUiIqJmUrkrwLZbRVCo2RWAqDoMq0RERM1klJc57EzLpwXIKFHj13slIlZEZPwYVomIiJqJmVTAEx0rDbRK4qwARNVhWCUiImpGlRcI2HunGAUKtUjVEBk/hlUiIqJmNLidKTwsy//8Fig12H+3WMSKiIwbwyoREVEzkggCplRqXWVXAKKqMawSERE1s8qzAhxJKUFGsUqkaoiMG8MqERFRMwtwNEFXO5n2tlID7LjNOVeJDGFYJSIiamaCICDMR7crABcIIDKMYZWIiEgEoZW6AsTdl+NOvlKkaoiMF8MqERGRCDrayNDfxVRn21a2rhLpYVglIiISSeXWVc4KQKSPYZWIiEgkT3aygLR89VVczVbij0yFeAURGSGGVSIiIpG4WEgxwsNMZ1vkTbauElXEsEpERCQiQ7MCqDUakaohMj4Mq0RERCIa520Oiwp9AZILVDh9Xy5iRUTGhWGViIhIRDYmEozzNtfZxq4AROUYVomIiERWeVaAHbeLIFexKwARwLBKREQkuiBPcziYlXcFyCrR4EhKsYgVERkPhlUiIiKRmUoFPNFRt3WVy68SlWJYJSIiMgJhnXVnBdh3pxh5CrVI1RAZD4ZVIiIiIzDAzRReVlLt7SKVBvvusCsAEcMqERGREZAIApdfJTKAYZWIiMhIVO4KEHOvBGlFKpGqITIODKtERERGoqejCXrYy7S3VRpg+y0OtKK2jWGViIjIiBhafpWoLWNYJSIiMiJTKvVb/S1Njtt5SpGqIRIfwyoREZER8baWYaCbqc42tq5SW8awSkREZGQMzQqg0XD5VWqbGFaJiIiMzBMdLSArX30V13OUuJSpEK8gIhExrBIRERkZJ3MpgjzNdLZFJrErALVNDKtERERGqPKsAN9dy8f5NLlI1RCJh2GViIjICI1tbw470/K+ACUq4NmjGbhfyEUCqG1hWCUiIjJCViYSfDzAXmfbvUI1novJRImKg62o7RA1rCYmJiI4OBiBgYEIDg5GUlKS3j7Lly+Hr68vhgwZgiFDhuC1114ToVIiIqLmN9XHErN7WutsO/NAjv+ezubsANRmiBpW58+fj/DwcJw7dw7h4eGYN2+ewf2mTZuGkydP4uTJk/jkk0+auUoiIiLxLO1rixEeuoOtfrpRiO+vF4hUEVHzEi2spqWlIT4+HqGhoQCA0NBQxMfHIz09XaySiIiIjI5MIuD7xx3R0Uaqs/310zk49XeJSFURNR+ZWE+ckpICDw8PSKWlv3xSqRTu7u5ITk6Gs7Ozzr7btm3D0aNH4ebmhjfeeAP9+/ev8rgJCQlNWrfYz0eG8TwYB54H48DzYBwa+zws9xXwQrw5itSlg66UGuDZw2lY90gx2pmzS0BV+PtgPKo6F126dKn2caKF1dp64YUX8Nprr8HExAQxMTGYPn06fvvtNzg6Ohrcv6YX3JgSEhKa9fnIMJ4H48DzYBx4HoxDU5yHLgBWOxThn0cztduyFALevGmL6PHOsJRxzHRl/H0wHg05F6L9ZHt6euLevXtQqUqn4FCpVEhNTYWXl5fOfm5ubjAxMQEAjBgxAp6enrh69Wqz10tERCS2f3SwwH972+hsu5SpwP87xQFX1HqJFlZdXFwQEBCAqKgoAEBUVBR69eql1wXg3r172u8vXbqEO3fu8CqJiIjarIW9bTDO21xnW9TNInx1JV+kioialqifGURERGD16tUIDAzE6tWrERERAQAICwvDhQsXAADLli3DwIEDMXjwYMydOxfffvst3NzcxCybiIhINBJBwKqhDuhmr9uTb8nZXBxOLhapKqKmI2qfVT8/Pxw5ckRve2RkpPb7VatWNWdJRERERs/WVIINQU4YsfsBcuSlH/9rALxwLBMxE1zhY2f0Q1KIao29sYmIiFqgzrYyfP+4IyTlK7IiV67B9CMZyJWrxSuMqJExrBIREbVQQZ7meCfQVmfb9RwlXj6eBTUHXFErwbBKRETUgs3xt0ZYZwudbfvvFuPDi3kiVUTUuBhWiYiIWjBBEPDlYAc84mSis/3ji3nYdbtIpKqIGg/DKhERUQtnIROwfqQjnM11/6zPPJGFPzIVIlVF1DgYVomIiFqB9tYyrBvhCFmFAVcFSg2eOZqBrBIOuKKWi2GViIiolRjUzgwfDbDT2XY7T4V//5oJpZoDrqhlYlglIiJqRV7oaoXn/Sx1tv16rwRLzuaKVBFRwzCsEhERtSKCIODjAfYY4Gqqs33FH/nYmFgoUlVE9cewSkRE1MqYSgX8NMIRHpa6f+bnxWbhfJpcpKqI6odhlYiIqBVys5TilyAnmEnLt5WogGePZuB+oUq8wojqiGGViIiolerjbIovBjnobLtXqMbTRzLw+wM5NFzliloAhlUiIqJWbJqvJWb3tNbZdj5dgeC9aRi+Kw0/XS9AgYJTW5HxYlglIiJq5Zb2tcUIDzO97ZcyFZgbm43um//Gf09n43o2FxAg48OwSkRE1MrJJAK+f9xRb4aAMrkKDVb/WYDHtj/AhP1p2HGrCArOy0pGQiZ2AURERNT0HMwk2DfOGUdSSrDmWgEO3i2GoTh68m85Tv6dCTcLCZ7zs8K//CzhZc24QOJhyyoREVEbIREEBHuZY/MoJ1wMdcOCXtZwNjccBe4XqfG/+Dz0irqP6UcycDSlGGoOyCIRMKwSERG1QR1sZHg70A5/PNUOa4Y7YKCb4S4Cag2w704xJh/MQN+t9/HVlTxkFnPqK2o+DKtERERtmJlUQGhnS+wf54LYJ1wR3s0KNiaCwX1v5qnw1u+56L7lb8w8kYWzaZz+ipoeO6EQERERAKCHgwk+GWiPJX1tEZlUhDXX8nE1S6m3X4kK2JhYiI2JhehqJ4ODWWnbl1Ah4woPbws6twWd+7TfP9xHIpTW8OojNrAzZXsalWJYJSIiIh02JhK80M0K/+5qiTMP5Pj+WgF23C6C3MB0rNdz9MNsQxxOKcHx1BLsGO0MezMGVmI3ACIiIqqCIAgY4GaG1cMdcXVqO7wTaAtva2nND2ygixkKPHEgHdklXKyAGFaJiIioFpzNpZjXywYXprhhyygnjPYyg+GerY3jYoYCTx5kYCV2AyAiIqI6kEoEhLQ3R0h7czwoUuFmrhIaAGXjrDRl/yre1pR9V367bFhWxdufXcpD3H259rkupJcG1u0h7BLQljGsEhERUb24WkjhatF43QIGupki7FCGXmCdfDAd2xhY2yyedSIiIjIK1iYSRAY76c35ev5hYGWXgLaJYZWIiIiMRnWBdcrBdOQYmpKAWjWGVSIiIjIq1iYSbAl2wgBX3cB6Ll2ByQcYWNsahlUiIiIyOjYmEkSGGA6sbGFtWxhWiYiIyChVFVjPpjGwtiUMq0RERGS0ygLrYwYCa+jBdOQysLZ6DKtERERk1GweDrrq76IbWH9/2MLKwNq6MawSERGR0bM1lSAqxHBgDT2YwcDaijGsEhERUYtQVWD9LU3OwNqK1TmsXr9+HXv37tXZdurUKUyePBlBQUFYuXJloxVHREREVFFZYO3nYqKz/bc0OcIOZSBPwcDa2tQ5rC5evBg//fST9nZKSgqmTp2K+Ph4FBQUYPHixdiwYUOjFklERERUpjSwOusF1jMPSltYGVhblzqH1fj4eAwePFh7e/PmzVCr1Th58iROnz6N0aNHY82aNY1aJBEREVFFdg8Da18DgTWMgbVVqXNYzcnJgZOTk/b2oUOHMHToULi7uwMARo8ejcTExMarkIiIiMgAO1MJthoIrKcfyPHUoQwUKEUqjBpVncOqi4sL7ty5AwDIzs7G2bNnMWLECO39JSUljVcdERERUTXKAmugs25gjbsvx7yrZmxhbQVkdX3AiBEjsHr1atja2uLkyZMAgHHjxmnvv3btGjw9PRuvQiIiIqJq2JlKsG20MyYfSMe5dIV2+8VcKaYeysDuMc6QSgQRK6SGqHPL6ttvv43u3bvjrbfeQkxMDJYtWwZvb28AQHFxMXbs2IFhw4Y1eqFEREREVSlrYX20Ugtr7H05tt8uEqkqagx1bll1cXHB/v37kZOTAwsLC5ials91ptFosGvXLnh5eTVqkUREREQ1sTeTYFuIMyYfTMf5Ci2sJ1JLENrZUsTKqCHqvSiAnZ2dXlDVaDQICAiAg4NDoxRHREREVBf2ZhK8+aitzrYLFYIrtTx1Dqt79uzBsmXLdLZ99dVX8PT0hJeXF6ZPn47CwsJGK5CIiIioLno76XYFuJqlQLFSI1I11FB1Dquff/45/v77b+3tixcvYsmSJQgMDMTzzz+PQ4cO4YsvvmjUIomIiIhqy8lcCm9rqfa2UgP8kcXW1ZaqzmE1KSkJvXr10t6OjIyEo6MjoqKi8Nlnn+Hf//43tm3bVqtjJSYmIjg4GIGBgQgODkZSUlKV+yYkJMDd3R2LFy+ua8lERETUxvSpNNDqQrpcpEqooeocVouLi2FpWd5J+ejRowgKCoKZmRkAICAgACkpKbU61vz58xEeHo5z584hPDwc8+bNM7ifSqXCvHnzMH78+LqWS0RERG1QHydTndsXMtiy2lLVOax6enriwoULAEpbWa9du4aRI0dq78/MzIS5uXmNx0lLS0N8fDxCQ0MBAKGhoYiPj0d6errevhERERgzZgx8fHzqWi4RERG1QWxZbT3qPHXV1KlTsXz5cqSmpuLatWtwcHDAmDFjtPefP38evr6+NR4nJSUFHh4ekEpL+5RIpVK4u7sjOTkZzs7O2v0uX76MI0eOYM+ePfj4449rPG5CQkJdX1KDNPfzkWE8D8aB58E48DwYB54HcVkrAaD8k+BrWQpcvpYAc2mVD6EmVtXvRJcuXap9XJ3D6oIFC1BSUoKDBw/Cy8sLixYtgp2dHQAgKysLsbGxmDVrVl0Pa5BCocC8efOwYsUKbaitSU0vuDElJCQ06/ORYTwPxoHnwTjwPBgHngfj0P7iXdwtLv0QWQ0BhQ7eCHAzE7mqtqkhvxN1DqtSqRSLFy82ONDJwcGh1leSnp6euHfvHlQqFaRSKVQqFVJTU3UWFPj7779x69YthIWFAQBycnIAAHl5eZxxgIiIiKrV3VqtDatAab/VxxhWW5w6h9WK0tPTcefOHQCAt7e3zsf3NXFxcUFAQACioqIwdepUREVFoVevXjrHaN++PW7evKm9vXz5chQUFOC9995rSNlERETUBnS3VuNghaEw7LfaMtVrBau4uDiMHDkSfn5+GDVqFEaNGqX9/vTp07U+TkREBFavXo3AwECsXr0aERERAICwsDDtIC4iIiKi+uhuo9a5fZErWbVIdW5ZjYuLwxNPPAFra2vMnj0bfn5+AIAbN25g06ZNmDRpEnbu3IkBAwbUeCw/Pz8cOXJEb3tkZKTB/d944426lktERERtVFcrNQQAZWtX3chRIk+hho1JvVebJxHUOay+//778Pb2xoEDB+Do6Khz34IFCxASEoL3338fu3fvbrQiiYiIiOrKWgZ0sZPhRo4SQGlovZShwOB27LfaktT50uLChQt47rnn9IIqUDrA6rnnnuNH+ERERGQUenO+1RavzmFVKpVCLq/6RJeUlEAiYfM6ERERia/ySlYXuZJVi1PnVPnYY49hzZo1uH37tt59t2/fxpo1azBw4MDGqI2IiIioQbiSVctX5z6rS5YswdixY/HYY49h7Nix2tWqEhISEB0dDTMzM7z99tuNXigRERFRXQU4mkAiAOqHo6ySclXIkathZ8pPgVuKOodVf39/HDlyBMuWLcOhQ4ewc+dOAIClpSVGjx6N2bNnw8yMHZeJiIhIfFYmEnS1k+HPbKV2W3yGAsPcmVVainpdVvj5+WH9+vW4e/curl+/juvXr+Pu3btYt24dTpw4gf79+zd2nURERET10tu5Ur9VdgVoURrUBi6RSODq6gpXV1cOqiIiIiKj1Mepcr9VDrJqSZgwiYiIqFXrU6ll9UIGW1ZbEoZVIiIiatX8HU0gFcpv385TIatEXfUDyKgwrBIREVGrZiET0N1BtysA+622HLWaDeDcuXO1PuC9e/fqXQwRERFRU+jjZIIrmeV9VS9kKDDC01zEiqi2ahVWR40aBUEQat4RgEajqfW+RERERM2hj7Mpfk4o1N7m4gAtR63C6ooVK5q6DiIiIqImo7+SFWcEaClqFVanT5/e1HUQERERNZkeDiYwkQCKh+OqkgtUSCtSwcVCKm5hVCMOsCIiIqJWz0wqoGflQVYZbF1tCRhWiYiIqE3Q7wrAfqstAcMqERERtQl6iwOw32qLwLBKREREbUJvp8rdANiy2hIwrBIREVGb0N3BBGYVxlOlFqqRWqgSryCqFYZVIiIiahNMJAICHLmSVUvDsEpERERtRh+nSv1WOSOA0WNYJSIiojajtzNbVlsahlUiIiJqMwzNCKDRaESqhmqDYZWIiIjaDD87GSxlgvZ2WrEa9wrVIlZENWFYJSIiojZDJhHQy5GLA7QkDKtERETUpjxSeb5VLg5g1BhWiYiIqE3R67fKxQGMGsMqERERtSl9nCt3A+AgK2PGsEpERERtiq+tDNYVBllllqhxJ58rWRkrhlUiIiJqU6QSAb0q91vl4gBGi2GViIiI2hz9+VbZb9VYMawSERFRm2Oo3yoZJ4ZVIiIianP6OOnPCMBBVsaJYZWIiIjanE62Utialg+yypVrcCuPg6yMEcMqERERtTkSQUDvyq2r7LdqlBhWiYiIqE3q48R+qy0BwyoRERG1SVzJqmVgWCUiIqI2qXelGQHi0xVQc5CV0WFYJSIiojapg7UUDmblg6zylRok5ihFrIgMYVglIiKiNkkQBANTWLHfqrFhWCUiIqI2S39xAPZbNTYMq0RERNRm9a40yCqeLatGh2GViIiI2qzK01fFZyigUnOQlTFhWCUiIqI2y9NKChfz8jhUqNTgBgdZGRVRw2piYiKCg4MRGBiI4OBgJCUl6e2zfv16DBo0CEOGDMGgQYOwatUqESolIiKi1kgQBPZbNXKihtX58+cjPDwc586dQ3h4OObNm6e3z8SJE3Hq1CmcPHkSBw4cwNdff40rV66IUC0RERG1RpX7rXJGAOMiWlhNS0tDfHw8QkNDAQChoaGIj49Henq6zn62trYQhNI50IqKiqBUKrW3iYiIiBqqd6V+qxfZsmpURAurKSkp8PDwgFQqBQBIpVK4u7sjOTlZb999+/ZhwIABCAgIwJw5c9CzZ8/mLpeIiIhaqcrLrl7OVEDBQVZGQyZ2AbUxbtw4jBs3Dnfv3sUzzzyDkJAQdOnSxeC+CQkJzVpbcz8fGcbzYBx4HowDz4Nx4HkwDrU9D86m5kiXl7bhFauAg/FJ8LNmYG1MVZ2LqjJdGdHCqqenJ+7duweVSgWpVAqVSoXU1FR4eXlV+Zj27dsjMDAQ0dHRVb6wml5wY0pISGjW5yPDeB6MA8+DceB5MA48D8ahLueh718ZiL5brL2dYeWOLl2smqq0NqchvxOidQNwcXFBQEAAoqKiAABRUVHo1asXnJ2ddfa7fv269vuMjAycOHGC3QCIiIioUVWeEeBiOgdZGQtRuwFERERg5syZ+Pjjj2Fvb6+dliosLAyLFi1Cnz598OOPPyImJgYymQwajQYvvvgiRo4cKWbZRERE1Mr0G86CZAAAIABJREFUcao8IwAHWRkLUcOqn58fjhw5orc9MjJS+/3y5cubsyQiIiJqg3pXalm9kqlAiUoDMylnIBIbV7AiIiKiNs/VQgovK6n2tkIN/JnFrgDGgGGViIiICPrzrV5gv1WjwLBKREREBP35Vtlv1TgwrBIRERFBf0YAtqwaB4ZVIiIiIuh3A/gzS4EiJRcGEBvDKhEREREAR3MpOliXD7JSaoA/OMhKdAyrRERERA/p9VtNZ79VsTGsEhERET2kt5JVBltWxcawSkRERPRQ78orWbFlVXQMq0REREQPPVJpkNW1bCUKlWqRqiGAYZWIiIhIy95MAh/b8kFWag1wmV0BRMWwSkRERFSB/uIADKtiYlglIiIiqkB/2VX2WxUTwyoRERFRBZVbVi9yJStRMawSERERVdDLyQRChds3cpTIU3CQlVgYVomIiIgqsDGRoIudTHtbA+AS+62KhmGViIiIqJLezuy3aiwYVomIiIgq6VNpcQCuZCUehlUiIiKiSiovu8qWVfEwrBIRERFVEuBoAkmFUVZJuSpkl3CQlRgYVomIiIgqsTKRoFuFQVYAEM+uAKJgWCUiIiIyoHfl+VYz2BVADAyrRERERAbo91tly6oYGFaJiIiIDKi8khUHWYmDYZWIiIjIgJ4OJpBVGGT1V74KmcUq8QpqoxhWiYiIiAywkAno7qDbFYDzrTY/hlUiIiKiKlTut8qw2vwYVomIiIiqUHklqzMP5JCrNCJV0zbJat6FiIiIqG2q3LJ64G4x3Nbdg6uFBB5WUnhaSuFhJYWXVelXTyspPCylcLeUwlQqVHFUqguGVSIiIqIqdHcwgakEkFdYvEoD4H6RGveL1LgAw90CBACuFhJtePW0Kv/n8XBbe2spJAIDbU0YVomIiIiqYCYVMKGDBbbdKqrT4yoG2vNVBFovKyn+29sGz/haQiphaK0K+6wSERERVePjAXZ4pac1HnU2QTsLCRorViYXqPD/TmVj6M4HOJxcDI2GfWENYcsqERERUTWczaV4r7+d9rZcpcHfRSqkFKhwr6D0a9m/e4WlXx8UqVHb6Hk1W4nQQxkY4WGGZf3sEOBoUvOD2hCGVSIiIqI6MJUK8LaWwdu66hglV2mQWlgaXg0F2j+yFCiptL5AzL0SDNv5ANO7WOLNPrbwsJI28StpGRhWiYiIiBqZqVRABxsZOtgYjlrJ+Uq8dz4Xm5J0+8JqAPySUIhtN4sw298acwOsYWPStntttu1XT0RERCQCL2sZVg1zxK//cMHQdqZ69xepNPgkPg+PRt3HD9cKoFS33f6sDKtEREREIuntbIpdY5yxeZQTutrpt8KmFasxPy4bg3c8wIG7bXMQFsMqERERkYgEQfj/7d17VFTl/gbwZxhEvMEoMiAXwQuoBIih5iiQJqiIigpoeQ0FO3a0tH6ZrgWUdpK0c+RkRomlnqN2MEfxFt4SvJCXzBKVPCfEGxcvIA6kosbM/P5wzegwgALK3sw8n7Vaq71n73e+s1+2POx597sx1NUaP46WI0khg721cTz7X1klxv9wE+F7biL75gMBqhQOwyoRERGRCFhaSBDdvRV+iXTA//VsgxbVPAHr0NX7GLi9GH85VIqC25UCVNn4GFaJiIiIRKRNMwvEvWiDnyMcMKFrS6N5XbUAUvMq0HvLdSw6WYbyxx+vZYIYVomIiIhEyLmVFMmBbXEoXI6BTs2NXr+nBpadvo0XN1/H1+du408TvQmLYZWIiIhIxHzaNUPaEDsoQ+zQQ2Z8E1bJPQ3+71gZhqcX477a9AIrwyoRERGRyEkkEgS7WONwuBzLB8jg0MI4wp0o/hPKC3cFqO75YlglIiIiaiIsLSSY4tkKJyMc8L5fG7S0NBzRuvlCRQ17Nl0Mq0RERERNTOtmFljQywa7h7c3WH/w6n0UV6hr2KtpYlglIiIiaqJ87azg1fbROFa1Fth6ybSurgoaVs+fP4+QkBD4+/sjJCQEeXl5RtssXboU/fr1Q//+/fHyyy9j//79AlRKREREJE6RnVsaLJvaUABBw+rcuXMRExODkydPIiYmBnPmzDHaxt/fHxkZGThy5AhWrFiB6OhoVFSYVicQERER1dfYTi0Mlo/deIB8E3pggGBhtbi4GNnZ2YiMjAQAREZGIjs7GyUlJQbbDR48GC1bPvyLwdvbGwBQWlrauMUSERERiZR7G0v0sW9msC7toulc2DOerKuRFBYWwsnJCVKpFAAglUrRoUMHFBQUoH379tXu85///Afu7u5wdnausd3c3NznUq9Y3o+qx34QB/aDOLAfxIH9IA7m0g9BbSxxothKv7zhnAqh1tcErMhYTX3h4eFR636ChdW6ysrKwuLFi5GWllbrdk/6wM9Sbm5uo74fVY/9IA7sB3FgP4gD+0EczKkfZjirkXTxGnQPsfrfHQtA7g4P22a179hIGtIXgg0DcHZ2RlFREdTqh9MrqNVqXL16FS4uLkbb/vTTT3jjjTewfv16s/mhIyIiInpaDi2lCHA0fCSr0kRutBIsrNrb28PHxwdKpRIAoFQq4evrazQE4JdffsG0adPwr3/9C35+fkKUSkRERCR6kZ0Nb7TafKECWm3Tf/yqoLMBJCUlISUlBf7+/khJSUFSUhIAICoqCr/++isA4N1330VFRQXmzJmDgIAABAQEICcnR8iyiYiIiERnlFsLNHss2Z0vr0T2zT+FK+gZEXTMqqenZ7Xzpm7atEn//5mZmY1ZEhEREVGTJGtugcHO1tidf0+/bsvFCvi1t6plL/HjE6yIiIiITETVoQBbLlZA08SHAjCsEhEREZmIYa7WaCGV6JcL7qhx/MYDAStqOIZVIiIiIhPRupkFQjtaG6xr6o9fZVglIiIiMiERVR6/uvVSBSo1TXcoAMMqERERkQkJdrGGrdWjoQAl9zQ4ePW+gBU1DMMqERERkQlpLpVgpJvxnKtNFcMqERERkYmpOivAzssVuFfZNIcCMKwSERERmZgAx+awt34U88r/1GJf4b1a9hAvhlUiIiIiE2NpIcHoTqYxFIBhlYiIiMgERVYJq7vzK/DHnxqBqqk/hlUiIiIiE9RXbgXX1lL98j01sOtK0xsKwLBKREREZIIkEonRnKubL9wVqJr6Y1glIiIiMlERnVsaLO8vvI/Se2qBqqkfhlUiIiIiE+Xd1hKetpb65UotsP1y0xoKwLBKREREZKIkEgkiqsy5qmxiQwEYVomIiIhMWGQnw6EAP157gKI7TWcoAMMqERERkQnrYmsJP7tm+mUtgK2Xms6cqwyrRERERCau6lCApjQrAMMqERERkYkbW2UowMmSP3GxvFKgauqGYZWIiIjIxDm3kkLhYGWwbvPFpjEUgGGViIiIyAxENtGhAAyrRERERGYg3L0FpJJHy+dUlcgp/VO4gp4SwyoRERGRGWhvLcUgp+YG67ZcFP/VVYZVIiIiIjNR9fGrmy9WQKvVClTN02FYJSIiIjITYR2t0Vz6aPnSH2qcLBH3UACGVSIiIiIzYWNlgSEu1gbrxP74VYZVIiIiIjMSWWUoQNrFCqg14h0KwLBKREREZEaGuFijTbNH0wJcr9Ag69oDASuqHcMqERERkRlpYSnB8I6GQwHEPCsAwyoRERGRmak6FGDbpQo8UItzKADDKhEREZGZGejUHO2aP4qBqgdaZBTdE7CimjGsEhEREZmZZhYShLsbDgXYfKFCoGpqx7BKREREZIaqPiAg/co93K3UCFRNzRhWiYiIiMxQfwcrOLV8FAXvVGqxJ198QwEYVomIiIjMkIVEgjGdDK+uKkU4FIBhlYiIiMhMRXZuYbC8r+AeVPfFNRSAYZWIiIjITPnZNUPnNlL98gMNsPOKuK6uMqwSERERmSmJRIKxVW60EtusAAyrRERERGas6lCAg1fv40aFWqBqjDGsEhEREZmx7rJmeKGtpX5Zo334RCuxYFglIiIiMnNVH78qpqEADKtEREREZm5sJ8OhAMduPED+7UqBqjHEsEpERERk5tzaWKKvvZXBui0XxXF1lWGViIiIiDC2yo1WR64/EKgSQ5ZP3oSIiIiITN0Y9xb47MwfGOnWApGdW6BPlSutQhH0yur58+cREhICf39/hISEIC8vz2ibjIwMDBw4EHK5HHFxcQJUSURERGT6HFpKkTPOEUv7ydBX3hwSiUTokgAIHFbnzp2LmJgYnDx5EjExMZgzZ47RNu7u7li+fDneeustASokIiIiMh8WIgmojxMsrBYXFyM7OxuRkZEAgMjISGRnZ6OkpMRgu86dO8PX1xdSqbS6ZoiIiIjIhAk2ZrWwsBBOTk76ECqVStGhQwcUFBSgffv29W43Nzf3WZUoyvej6rEfxIH9IA7sB3FgP4gD+0E8auoLDw+PWvczuRusnvSBn6Xc3NxGfT+qHvtBHNgP4sB+EAf2gziwH8SjIX0h2DAAZ2dnFBUVQa1++OxZtVqNq1evwsXFRaiSiIiIiEhkBAur9vb28PHxgVKpBAAolUr4+vo2aAgAEREREZkWQWcDSEpKQkpKCvz9/ZGSkoKkpCQAQFRUFH799VcAwNGjR+Hl5YXk5GSsXbsWXl5e2L9/v5BlExEREVEjEXTMqqenZ7XBc9OmTfr/VygU+O233xqzLCIiIiISCT5ulYiIiIhEi2GViIiIiESLYZWIiIiIRIthlYiIiIhEi2GViIiIiERLolKptEIXQURERERUHV5ZJSIiIiLRYlglIiIiItFiWCUiIiIi0WJYJSIiIiLRYlglIiIiItFiWK2H8+fPIyQkBP7+/ggJCUFeXp7QJZklHx8f9OnTBwEBAQgICMD+/fuFLsksxMXFwdfXFzKZDL/99pt+Pc+LxlVTP/C8aFylpaWIiopC79690b9/f0yaNAklJSUAgBMnTmDAgAHw9/fHmDFjUFxcLHC1pqu2fpDJZOjfv7/+nMjJyRG4WtM2YcIEDBgwAIGBgQgNDcXp06cBNOx3BKeuqoeRI0di0qRJGD9+PDZu3Ij169djx44dQpdldnx8fLBx40Z4eXkJXYpZOXr0KFxdXREaGmpw/HleNK6a+oHnReO6desWzp49i8DAQABAfHw8bt26heXLl8Pf3x/JyclQKBT49NNPcenSJXzxxRcCV2yaauqHFStWQCaToaCgAK1btxa4SvNQVlYGW1tbAMD333+PJUuW4NChQw36HcErq3VUXFyM7OxsREZGAgAiIyORnZ2t/wuOyNQpFAq4uLgYrON50fiq6wdqfG3bttUHJADo3bs38vPzcerUKVhbW0OhUAAApk2bhq1btwpVpsmrqR+o8emCKgCUl5fDwsKiwb8jLJ9LpSassLAQTk5OkEqlAACpVIoOHTqgoKAA7du3F7g68xMbGwutVguFQoH4+HjIZDKhSzJLPC/EheeFMDQaDVavXo3Q0FDk5+fD1dVV/5qdnR00Gg1u3bqFtm3bClil6Xu8H3RGjBiByspKhISEYP78+WjevLmAFZq+2bNnIzMzE1qtFkqlssG/I3hllZqsXbt24ccff9SfEPPmzRO6JCLB8bwQzrx589CqVSvMmDFD6FLMWtV+OHv2LA4cOID09HT897//xaeffipwhabv888/x9mzZxEfH4+EhIQGt8ewWkfOzs4oKiqCWq0GAKjValy9epVfxwlAd8ybN2+O6dOn49ixYwJXZL54XogHzwthxMXFIS8vD2vWrIGFhQVcXV0Nvoa+efMmLCwseFX1OavaD8Cjc8LGxgZTpkzhOdGIXn31VRw+fBhOTk4N+h3BsFpH9vb28PHxgVKpBAAolUr4+vryq85GdufOHZSVlQEAtFottmzZAh8fH4GrMl88L8SB54UwFi1ahFOnTmHDhg36r5f9/PxQUVGBo0ePAgBWr16N8PBwIcs0edX1g0qlQkVFBQCgsrIS27Zt4znxHN2+fRsFBQX65V27dqFt27YN/h3B2QDq4ffff8fMmTOhUqkgk8nw1VdfwcPDQ+iyzMqlS5cwefJkqNVqaDQadOvWDUuWLIGjo6PQpZm8efPmYefOnbh+/Trs7OzQrl07HDt2jOdFI6uuH1JTU3leNLJz585BoVCga9eusLa2BgC4ublhw4YNOH78OObOnYt79+6hY8eOSElJgVwuF7hi01RTP7z99tuYM2cOJBIJKisr0bdvXyQmJnJmgOfkxo0bmDBhAu7evav/JuGjjz6Cn59fg35HMKwSERERkWhxGAARERERiRbDKhERERGJFsMqEREREYkWwyoRERERiRbDKhERERGJFsMqETVpYWFhCAsLE7qMWv3666+ws7NDXl6e0KUYSExMhEwmw/Xr14UuxYBMJkNiYmKjvNfMmTPrPO/mnj174Ozs/NTPNSeihmFYJSIAwIYNGyCTyXDixAn9ur179zZaaKjN8ePHkZiYCJVKJXQp9bJo0SKMGjUKXbp0EboUegaGDh0Kd3d3LFu2TOhSiMwCwyoR1Wjfvn1YsmSJ0GXgp59+wpIlS/RPZ3pcWloa0tLSBKjq6Zw5cwaZmZmIjo4WuhR6hqKjo7F27VqUl5cLXQqRyWNYJaJGd/fu3WfWlpWVFaysrJ5Ze8/a+vXrIZfLERAQIMj7P8tjLSZ37twR9P3Dw8Nx//59bN26VdA6iMwBwyoRVWvmzJlYtWoVgIdjCHX/Xb58Wb/Npk2bMGjQIDg6OsLNzQ1Tp07FpUuXDNoJCwtDnz59cPr0aYwYMQJOTk549913AQBHjhxBdHQ0vL29IZfL0a1bN7z11lu4deuWfv/ExETEx8cDAHr27Kmv4/Dhw/r2q45ZvXv3LuLj4/Xtvvjii0hKSoJGozHYTiaTYe7cudi5cycUCgXkcjn69euHH374wWC727dvIy4uDr6+vpDL5ejSpQvCwsLw448/PvE4fv/99wgKCoKFheE/t7rjcubMGYSGhqJDhw7w9vbG559/btSGVqvFypUr0b9/fzg4OKBr166YNWsWbt68abCdj48PIiIicPDgQQwePBgODg747LPPnlhjeXk5Zs6ciY4dO6Jjx4548803DULu5cuXIZPJsGHDBqN9q44v1Y2Dzc3NrbVNALh//z4WLFiALl26wMXFBa+++ioKCwuN3kPX5m+//YYZM2bA3d0dCoVC/3pGRgaGDx8OZ2dnODs7IyIiAqdPnzZqR9fPDg4OUCgU2LFjR7XHIy0tDYMGDYKrqytcXFzQt29fLF261GAbe3t7vPDCC9i5c2cNR5WInhVLoQsgInGKjo7GtWvXkJmZiZUrV+rXt2/fHgCQlJSERYsWITw8HBMnToRKpcKqVaswbNgwZGVl6bcDgLKyMkRERGDUqFGIjIyEra0tAGDr1q0oLy/H66+/Dnt7e5w9exbr1q3DuXPnsHfvXkgkEowcORJ5eXlQKpVYvHgx7OzsAADdunWrtm6tVouJEyciMzMTkyZNgp+fHw4ePIiFCxfiypUrSEpKMtj+p59+wu7duzFt2jS0bt0aK1euxJQpU3D27Fm0a9cOAPDOO+9g69atiImJQffu3VFWVoaff/4ZZ8+exYABA2o8hkVFRSgoKICfn1+1r5eXlyMiIgIjRozAmDFjkJ6ejvj4eKjVasyZM0e/3TvvvIN169bhtddeQ2xsLAoLC5GSkoJffvkFGRkZ+mehA8CFCxcwZcoUTJ06FZMnT4aLi0uN9elMmzYN7u7u+OCDD5CdnY1///vfsLe3x8KFC5+4b0PanD17Nr777jtERUWhb9++yMrKwrhx42pt083NDXFxcXjw4AGAh38wzZgxA4MGDUJCQgIePHiAtWvXYvjw4cjIyICnpyeAh4F2ypQp6NatG+Lj46FSqTBr1iw4OTkZvMeBAwcwbdo0BAUFISEhAVKpFLm5uTh27JhRPX5+fti+fTu0Wi0kEkm9jxUR1Y5hlYiq1bdvX3Tt2hWZmZkYP368wWv5+fn4+OOPMX/+fLz//vv69REREejXrx+Sk5ORkJCgX3/jxg188skn+Mtf/mLQzocffoiWLVsavW9sbCyOHTsGhUIBb29v9OzZE0qlEmFhYXBzc6u17l27diEzMxPz58/H/PnzAQAxMTF48803sWbNGsTGxsLLy0u//e+//47jx4+jc+fOAIDAwEAEBARAqVRixowZAB7e/T116lQsXrz4aQ8fACA3NxcA4O7uXu3r169fR0JCAt555x0AwPTp0xEeHo6lS5ciOjoatra2OH78ONasWYMvv/wSr732mn7fwYMHIzQ0FKmpqXj99df16y9evIhvv/0Ww4cPf+o6fX198cUXX+iXS0tLsW7dugaF1Se1eebMGXz33XeYPn06/vGPfwAAYmNj8cYbbyAnJ6faNj08PLBu3Tr98p07d/Dee+9hwoQJBu81efJk9O7dG0uXLsXXX38NAPjggw9gb2+P3bt36/9YCgwMRHh4OFxdXfX77tmzB23atMGWLVsglUpr/Yzu7u5QqVS4du0aOnToUJfDQ0R1wGEARFRnO3bsQGVlJcaOHYubN2/q/7OxsYGXl5f+K3odS0tLg0ClowuqWq0W5eXluHnzJvr27QsAOHXqVL1q27t3LywsLIyC8axZs/SvPy4wMFAfVAHA29sbNjY2BsMZbGxs8PPPP6OoqKhOtZSWlgJ4+FV5dSwsLBATE6NflkqliI2Nxd27d/XHMC0tDa1bt0ZwcLDBsfb09IRcLjc61s7OznUKqgAwdepUg2WFQoHS0tIG3Tz0pDb37dsH4GFAfVzVfnvc9OnTDZYzMzOhUqkQFRVlcGzUajUUCoX+2Fy7dg1nzpzB+PHj9UEVAF5++WX06NHDoE0bGxvcuXMHGRkZT/yMun6tOhyDiJ4tXlklojrTzRfap0+fal+veiXR0dHR4KtqnYKCAiQkJGDfvn34448/DF6rb1DKz8+HXC43CogeHh6wsLDAlStXDNZX9zW5ra2twTRZH330EWbOnAlvb2/4+voiODgY48ePh4eHx1PVpNVqq10vl8thY2NjsE43vZWuzry8PNy+fbvG9youLjZYftKV5+pUPQa6Y6dSqYzqe1Zt5ufnQyKRGPyhAKDW6b2q/lzpfg5Hjx5d7fa6ccL5+fk1tt2lSxdkZ2frl2NiYrBt2zZERUWhQ4cOePnllzFq1CiEhoYafdWv61cOASB6vhhWiajOdDcqKZVKWFoa/zNSNZi2aNHCaBu1Wo2xY8eipKQEc+fOhaenJ1q1agWNRoOIiAijm6Gel5q+6n08YI4ePRoKhQLp6enIyMjAypUr8dlnnyE5ORlRUVE1tq0b89qQ+WE1Gg3atWuH1atXV/t61VBe3bF+kicdg5rCmFqtrneb9VH1s+l+RpKTk43GntaXvb09Dh06hAMHDmDfvn3Yv38/UlNTMXToUKSmphocC12/6sZRE9HzwbBKRHXWqVMnAA+vnnXv3r1ebeTk5OD3339HcnIyJkyYoF/f0Kc8ubq6IjMzE2VlZQZf+Z4/fx4ajQYdO3asV7sODg6Ijo5GdHQ0VCoVQkJCkJiYWGtY1d0E9vgMCo+7ceMGysvLDa5e6j6/rs5OnTohMzMTvXv3RuvWretVe0PpAnHVeW51Vyzrw9XVFVqtFhcuXDD4GapL/+t+Dtu3b4+BAwfW+l41tV3dOisrKwwZMgRDhgyBVqvFwoUL8c9//hPHjx9Hv3799NvpZklwcHB46pqJqO44ZpWIatSqVSsAxlcGR40aBalUiqVLl1Z7pexpxvDprrxV3b+6qZtqqqM6Q4cOhUajMZjBAID+BpwhQ4Y8sY3HqdVqo5Amk8ng5uZW7UMKHqeb0qum8bcajUZ/A5BuedWqVWjRogUCAwMBAGPGjIFGozGaOklXW2M81cvGxgZ2dnY4cuSIwfrHa6+r4OBgANBPj6ZTtd9q88orr8DW1hbLli3Tzw7wON3jUB0dHeHj44ONGzca9NnBgwdx7tw5g31044x1JBIJfH19ARiH9VOnTqFPnz4cBkD0nPHKKhHVqFevXgCA9957D8HBwbC0tMSwYcPg7u6ODz/8EPHx8cjPz0dYWBhsbW1x+fJlpKenY8yYMViwYEGtbXt6eqJLly6Ii4tDUVER2rZti3379lV7E5OujkWLFiEyMhJWVlYICgqCvb290bbDhg3DoEGDkJiYiPz8fPTs2ROHDh3C9u3bER0dbTATwNP4448/4OXlhZEjR+pvvjp27Bh++OEHo5uDqjN8+HBs3rwZGo3GaK5VBwcHfPXVVygoKECPHj3w/fffIysrCwkJCfqrwgMGDEBsbCyWL1+OnJwcvPLKK2jevDkuXLiA7du3Y8GCBZg4cWKdPlN9TJkyBUlJSZg9ezZ69eqFI0eO4Pz58/Vuz9fXF5GRkfjmm29QXl6Ol156CYcPH65TmzY2NkhKSkJsbCyCgoIQEREBuVyO/Px87N+/H927d8eXX34J4OFsAOPGjUNoaCgmTJiAsrIypKSkoEePHrh9+7a+zdmzZ6O0tBRBQUFwdnbG1atXsWrVKjg6OqJ///767YqLi5GTk4Np06bV+xgQ0dNhWCWiGo0cORIzZ87E5s2boVQqodVqkZ2djVatWmH27Nno3LkzvvjiC/z973+HRqOBk5MTgoKCarzh5XHNmjVDamoq5s+fj88//xwWFhYIDg7G5s2b9XNj6vTq1QsffPABvvnmG/z1r3+FRqPBjh07qg2rEokE69evR2JiIrZs2YLU1FS4uLggISEBb7/9dp2PQcuWLRETE4PMzEzs2rULlZWVcHNz09909SSTJk3Cl19+iaysLAQFBRm8ZmNjg9WrV2PevHn49ttvYWdnh4ULFxrV+emnn8LX1xdr1qzB3/72N1haWsLFxQWjR482avN5mTdvHkpKSrBt2zZs3boVwcHBUCqV6Nq1a73bXLFiBezs7LBp0yakp6cjMDAQ3333HV544YWnbmPs2LFwdHTEsmXLsGKC05WbAAABE0lEQVTFCty/fx+Ojo546aWXDB5xGxwcjLVr1+Ljjz/GRx99hE6dOmHFihVIT09HVlaWfrtx48Zh3bp1WLNmDVQqFeRyOUJCQvD++++jTZs2+u22b98OKysrjBkzpt6fn4iejkSlUtV/tDsRET3R2LFjYWtrizVr1ujXhYWF4caNGzhx4oSAlVF9BQQEICAgAJ988onQpRCZPF5ZJSJ6zuLj4xEcHIy8vLxap2aipmHPnj24ePEi0tLShC6FyCwwrBIRPWe9evXixPEmZOjQoSgsLBS6DCKzwdkAiIiIiEi0OGaViIiIiESLV1aJiIiISLQYVomIiIhItBhWiYiIiEi0GFaJiIiISLQYVomIiIhItP4fzViVIZgQqyAAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "31OqwJs-bOmv"
      },
      "source": [
        "#### Training using ReLU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6jMq4XdcYLEE",
        "outputId": "529360d4-6296-4980-9514-6539c6d42c58"
      },
      "source": [
        "# NN with relu activation fn\n",
        "parameters_relu = L_layer_model_train(\n",
        "    X_train, y_train, layers_dims, learning_rate=0.03, num_iterations=3000,\n",
        "    hidden_layers_activation_fn=\"relu\")\n",
        "\n",
        "# Print the accuracy\n",
        "accuracy(X_test, parameters_relu, y_test, activation_fn=\"relu\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=============================================\n",
            "                Start Training\n",
            "=============================================\n",
            "The cost after 100 iterations is: 0.6556\n",
            "The cost after 200 iterations is: 0.6468\n",
            "The cost after 300 iterations is: 0.6447\n",
            "The cost after 400 iterations is: 0.6441\n",
            "The cost after 500 iterations is: 0.6440\n",
            "The cost after 600 iterations is: 0.6440\n",
            "The cost after 700 iterations is: 0.6440\n",
            "The cost after 800 iterations is: 0.6440\n",
            "The cost after 900 iterations is: 0.6440\n",
            "The cost after 1000 iterations is: 0.6440\n",
            "The cost after 1100 iterations is: 0.6439\n",
            "The cost after 1200 iterations is: 0.6439\n",
            "The cost after 1300 iterations is: 0.6439\n",
            "The cost after 1400 iterations is: 0.6439\n",
            "The cost after 1500 iterations is: 0.6439\n",
            "The cost after 1600 iterations is: 0.6439\n",
            "The cost after 1700 iterations is: 0.6438\n",
            "The cost after 1800 iterations is: 0.6437\n",
            "The cost after 1900 iterations is: 0.6435\n",
            "The cost after 2000 iterations is: 0.6432\n",
            "The cost after 2100 iterations is: 0.6423\n",
            "The cost after 2200 iterations is: 0.6395\n",
            "The cost after 2300 iterations is: 0.6259\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "waLORQQNYLEE"
      },
      "source": [
        "<!-- <h2 style=\"font-family: Georgia; font-size:2em;color:purple; font-style:bold\"> -->\n",
        "### Conclusion\n",
        "<!-- </h2> -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryVxRIg3YLEE"
      },
      "source": [
        "The purpose of this notebook is to code Deep Neural Network step-by-step and explain the important concepts while doing that. We don't really care about the accuracy rate at this moment since there are tons of things we could've done to increase the accuracy which would be the subject of following notebooks. Below are some takeaways:\n",
        "- Even if neural network can represent any function, it may fail to learn for two reasons:\n",
        "    1. The optimization algorithm may fail to find the best value for the parameters of the desired (true) function.\n",
        "        It can stuck in a local optimum.\n",
        "    2. The learning algorithm may find different functional form that is different than the intended function due to overfitting.\n",
        "- Even if neural network rarely converges and always stuck in a local minimum, it is still able to reduce the cost significantly and come up with very complex models with high test accuracy.\n",
        "- The neural network we used in this notebook is standard fully connected network. However, there are two other kinds of networks:\n",
        "    - Convolutional NN: Where not all nodes are connected. It's best in class for image recognition.\n",
        "    - Recurrent NN: There is a feedback connections where output of the model is fed back into itself. It's used mainly in sequence modeling.\n",
        "- The fully connected neural network also forgets what happened in previous steps and also doesn't know anything about the output.\n",
        "- There are number of hyperparameters that we can tune using cross validation to get the best performance of our network:\n",
        "    1. Learning rate ($\\alpha$): Determines how big the step for each update of parameters.\n",
        "        - Small $\\alpha$ leads to slow convergence and may become computationally very expensive.\n",
        "        - Large $\\alpha$ may lead to overshooting where our learning algorithm may never converge.\n",
        "    2. Number of hidden layers (depth): The more hidden layers the better, but comes at a cost computationally.\n",
        "    3. Number of units per hidden layer (width): Research proven that huge number of hidden units per layer doesn't add to the improvement of the network.\n",
        "    4. Activation function: Which function to use on hidden layers differs among applications and domains. It's a trial and error process to try different functions and see which one works best.\n",
        "    5. Number of iterations.\n",
        "- Standardize data would help activation units have similar range of values and avoid gradients to go out of control."
      ]
    }
  ]
}