TP_NN_Mohamad_Jawad_ABOU_ALEIWI.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EBnaMKtPaRbw"
      },
      "source": [
        "Name: Mohamad Jawad ABOU ALEIWI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iafPdtuncbq7"
      },
      "source": [
        "# TP: MNIST with Neural Networks (NN)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OlKZ3Hnas7B4",
        "outputId": "aa032709-9152-45e4-a784-b9886afb0c0f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using tensorflow version 2.15.0\n",
            "Using keras version 2.15.0\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import keras\n",
        "print(\"Using tensorflow version \" + str(tf.__version__))\n",
        "print(\"Using keras version \" + str(keras.__version__))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s_QLz9_jbRZq"
      },
      "source": [
        "## Loading and preparing the MNIST dataset\n",
        "Load the MNIST dataset made available by keras.datasets. Check the size of the training and testing sets.\n",
        "\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "cellView": "both",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gG83hGyVmijn",
        "outputId": "321cf393-38c9-4866-e912-1cf855dde59c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training images size:  60000\n",
            "Testing images size:  10000\n"
          ]
        }
      ],
      "source": [
        "# The MNSIT dataset is ready to be imported from Keras into RAM\n",
        "# Warning: you cannot do that for larger databases (e.g., ImageNet)\n",
        "from keras.datasets import mnist\n",
        "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
        "\n",
        "print(\"Training images size: \", len(train_images))\n",
        "print(\"Testing images size: \", len(test_images))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gRPbU_Z4U6Ac"
      },
      "source": [
        "The MNIST database contains 60,000 training images and 10,000 testing images.\n",
        "Using the pyplot package, visualize the first sample of the training set:\n",
        "\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "x5VAu7oW0Zu4",
        "outputId": "1f72453a-94cf-4d57-9eb2-98d120fbc233"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Let us visualize the first training sample using the Matplotlib library with the imshow function\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "plt.imshow(train_images[0], cmap='gray')\n",
        "plt.title(f'Label: {train_labels[0]}')\n",
        "# turn off axis\n",
        "plt.axis('off')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s7YsRekMVDg-"
      },
      "source": [
        "The database contains images of handwritten digits. Hence, they belong to one of 10 categories, depending on the digit they represent.\n",
        "Reminder: in order to do multi-class classification, we use the softmax function, which outputs a multinomial probability distribution. That means that the output to our model will be a vector of size $10$, containing probabilities (meaning that the elements of the vector will be positive sum to $1$).\n",
        "For easy computation, we want to true labels to be represented with the same format: that is what we call **one-hot encoding**. For example, if an image $\\mathbf{x}$ represents the digit $5$, we have the corresponding one_hot label (careful, $0$ will be the first digit):\n",
        "$$ \\mathbf{y} = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0] $$\n",
        "Here, you need to turn train and test labels to one-hot encoding using the following function:\n",
        "\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "lQbkllF8mnaf"
      },
      "outputs": [],
      "source": [
        "from keras.utils import to_categorical\n",
        "\n",
        "# convert train and test labels to one-hot encoding\n",
        "y_train = to_categorical(train_labels, num_classes=10)\n",
        "y_test = to_categorical(test_labels, num_classes=10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jv29YLtVO3q"
      },
      "source": [
        "Images are black and white, with size $28 \\times 28$. We will work with them using a simple linear classification model, meaning that we will have them as vectors of size $(784)$.\n",
        "You should then transform the images to the size $(784)$ using the numpy function ```reshape```.\n",
        "\n",
        "Then, after casting the pixels to floats, normalize the images so that they have zero-mean and unitary deviation. Be careful to your methodology: while you have access to training data, you may not have access to testing data, and must avoid using any statistic on the testing dataset.\n",
        "\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "95ypXrxVdPW1"
      },
      "source": [
        "Using the parameters calculated from the training set for normalization of the testing set ensures that the model is trained and evaluated in a fair and consistent manner, avoiding data leakage and enabling reliable generalization to unseen data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "ptTRSDo5nJyZ"
      },
      "outputs": [],
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "# Reshape images to vectors of pixels\n",
        "img_rows, img_cols = train_images.shape[1], train_images.shape[2]\n",
        "\n",
        "X_train = train_images.reshape(train_images.shape[0] ,img_rows*img_cols)\n",
        "X_test = test_images.reshape(test_images.shape[0] ,img_rows*img_cols)\n",
        "\n",
        "# Cast pixels from uint8 to float32\n",
        "X_train = X_train.astype('float32')\n",
        "X_test = X_test.astype('float32')\n",
        "\n",
        "# Now let us normalize the images so that they have zero mean and standard deviation\n",
        "# Hint: are real testing data statistics known at training time ?\n",
        "\n",
        "# calculate mean and standard deviation only from the training data\n",
        "mean = np.mean(X_train, axis=0)\n",
        "std = np.std(X_train, axis=0)\n",
        "\n",
        "std[std == 0] = 1.0\n",
        "\n",
        "# normalize both training and testing datasets\n",
        "X_train = (X_train - mean) / std\n",
        "X_test = (X_test - mean) / std"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p8aGg4aS6am2"
      },
      "source": [
        "# First part: working with Numpy\n",
        "\n",
        "Look at this [cheatsheet](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf) for some basic information on how to use numpy.\n",
        "\n",
        "### Defining the model\n",
        "\n",
        "We will here create a simple, linear classification model. We will take each pixel in the image as an input feature (making the size of the input to be $784$) and transform these features with a weight matrix $\\mathbf{W}$ and a bias vector $\\mathbf{b}$. Since there is $10$ possible classes, we want to obtain $10$ scores. Then,\n",
        "$$ \\mathbf{W} \\in \\mathbb{R}^{784 \\times 10} $$\n",
        "$$ \\mathbf{b} \\in \\mathbb{R}^{10} $$\n",
        "\n",
        "and our scores are obtained with:\n",
        "$$ \\mathbf{z} = \\mathbf{W}^{T} \\mathbf{x} +  \\mathbf{b} $$\n",
        "\n",
        "where $\\mathbf{x} \\in \\mathbb{R}^{784}$ is the input vector representing an image.\n",
        "We note $\\mathbf{y} \\in \\mathbb{R}^{10}$ as the target one_hot vector.\n",
        "\n",
        "Here, you fist need to initialize $\\mathbf{W}$ and $\\mathbf{b}$ using ```np.random.normal``` and ```np.zeros```, then compute $\\mathbf{z}$.\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "id": "04yCT8Tl6am4"
      },
      "outputs": [],
      "source": [
        "# To avoid implementing a complicated gradient back-propagation,\n",
        "# we will try a very simple architecture with one layer\n",
        "def initLayer(n_input,n_output):\n",
        "    \"\"\"\n",
        "    Initialize the weights, return the number of parameters\n",
        "    Inputs: n_input: the number of input units - int\n",
        "          : n_output: the number of output units - int\n",
        "    Outputs: W: a matrix of weights for the layer - numpy ndarray\n",
        "           : b: a vector bias for the layer - numpy ndarray\n",
        "           : nb_params: the number of parameters  - int\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    # Create W at the right size with a normal distribution\n",
        "    W = np.random.normal(size=(n_input, n_output))\n",
        "    # Create b at the right size, with zeros\n",
        "    b = np.zeros(n_output)\n",
        "    nb_params = n_output * (n_input + 1)\n",
        "    return W, b, nb_params"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "xM1gqfuD6am5"
      },
      "outputs": [],
      "source": [
        "n_training = train_images.shape[0]\n",
        "n_feature = train_images.shape[1] * train_images.shape[2]\n",
        "n_labels = 10\n",
        "W, b, nb_params = initLayer(n_feature, n_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-UAaRbtN6am6"
      },
      "source": [
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "idOjMLd96am7"
      },
      "outputs": [],
      "source": [
        "def forward(W, b, X):\n",
        "    \"\"\"\n",
        "    Perform the forward propagation\n",
        "    Inputs: W: the weights - numpy ndarray\n",
        "          : b: the bias - numpy ndarray\n",
        "          : X: the batch - numpy ndarray\n",
        "    Outputs: z: outputs - numpy ndarray\n",
        "    \"\"\"\n",
        "\n",
        "    z = X @ W + b\n",
        "    return z"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDbw_H4H6am7"
      },
      "source": [
        "### Computing the output\n",
        "\n",
        "To obtain classification probabilities, we use the softmax function:\n",
        "$$ \\mathbf{o} = softmax(\\mathbf{z}) \\text{         with          } o_i = \\frac{\\exp(z_i)}{\\sum_{j=0}^{9} \\exp(z_j)} $$\n",
        "\n",
        "The usual difficulty with the softmax function is the possibility of overflow when the scores $z_i$ are already large. Since a softmax is not affected by a shift affecting the whole vector $\\mathbf{z}$:\n",
        "$$ \\frac{\\exp(z_i - c)}{\\sum_{j=0}^{9} \\exp(z_j - c)} =  \\frac{\\exp(c) \\exp(z_i)}{\\exp(c) \\sum_{j=0}^{9} \\exp(z_j)} = \\frac{\\exp(z_i)}{\\sum_{j=0}^{9} \\exp(z_j)}$$\n",
        "what trick can we use to ensure we will not encounter any overflow ?\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "79SMqtsZfa2k"
      },
      "source": [
        "\n",
        "To prevent overflow when computing the softmax function, we can use a simple trick by subtracting the maximum value from each element of the input vector\n",
        "z before computing the softmax. This ensures numerical stability without affecting the result of the softmax function. The trick is based on the fact that subtracting a constant from each element of z does not change the output of the softmax function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "Wmdi0DKT6am8"
      },
      "outputs": [],
      "source": [
        "def softmax(z):\n",
        "    \"\"\"\n",
        "    Perform the softmax transformation to the pre-activation values\n",
        "    Inputs: z: the pre-activation values - numpy ndarray\n",
        "    Outputs: out: the activation values - numpy ndarray\n",
        "    \"\"\"\n",
        "    if len(z.shape) > 1:\n",
        "      z = z - z.max(axis=1, keepdims=True)\n",
        "      out = np.exp(z) / np.exp(z).sum()\n",
        "      return out\n",
        "    z_shifted = z - np.max(z)\n",
        "    out = np.exp(z_shifted) / np.sum(np.exp(z_shifted))\n",
        "    return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOisvNaV6am9"
      },
      "source": [
        "### Making updates\n",
        "\n",
        "We define a learning rate $\\eta$. The goal is to be able to apply updates:\n",
        "$$ \\mathbf{W}^{t+1} = \\mathbf{W}^{t} + \\nabla_{\\mathbf{W}} l_{MLE} $$\n",
        "\n",
        "In order to do this, we will compute this gradient (and the bias) in the function ```update```. In the next function ```updateParams```, we will actually apply the update with regularization.\n",
        "\n",
        "Reminder: the gradient $\\nabla_{\\mathbf{W}} l_{MLE}$ is the matrix containing the partial derivatives\n",
        "$$ \\left[\\frac{\\delta l_{MLE}}{\\delta W_{ij}}\\right]_{i=1..784, j=1..10} $$\n",
        "**Remark**: Careful, the usual way of implementing this in python has the dimensions of $\\mathbf{W}$ reversed compared to the notation of the slides.\n",
        "\n",
        "Coordinate by coordinate, we obtain the following update:\n",
        "$$ W_{ij}^{t+1} = W_{ij}^{t} + \\eta \\frac{\\delta l_{MLE}}{\\delta W_{ij}} $$\n",
        "\n",
        "Via the chain rule, we obtain, for an input feature $i \\in [0, 783]$ and a output class $j \\in [0, 9]$: $$\\frac{\\delta l_{MLE}}{\\delta W_{ij}} = \\frac{\\delta l_{MLE}}{\\delta z_{j}} \\frac{\\delta z_j}{\\delta W_{ij}}$$\n",
        "\n",
        "It's easy to compute that $\\frac{\\delta z_j}{\\delta W_{ij}} = x_i$\n",
        "\n",
        "We compute the softmax derivative, to obtain:\n",
        "$$ \\nabla_{\\mathbf{z}} l_{MLE} = \\mathbf{o} - \\mathbf{y} $$\n",
        "\n",
        "Hence, $\\frac{\\delta l_{MLE}}{\\delta z_{j}} = o_j - y_j$ and we obtain that $$\\frac{\\delta l_{MLE}}{\\delta W_{ij}} = (o_j - y_j) x_i$$\n",
        "\n",
        "This can easily be written as a scalar product, and a similar computation (even easier, actually) can be done for $\\mathbf{b}$. Noting $\\nabla_{\\mathbf{z}} l_{MLE} = \\mathbf{o} - \\mathbf{y}$ as ```grad``` in the following function, compute the gradients $\\nabla_{\\mathbf{W}} l_{MLE}$ and $\\nabla_{\\mathbf{b}} l_{MLE}$ in order to call the function ```updateParams```.\n",
        "\n",
        "Note: the regularizer and the weight_decay $\\lambda$ are used in ```updateParams```.\n",
        "\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "id": "umhLUQsY6am-"
      },
      "outputs": [],
      "source": [
        "def update(eta, W, b, grad, X, regularizer, weight_decay):\n",
        "    \"\"\"\n",
        "    Perform the update of the parameters\n",
        "    Inputs: eta: the step-size of the gradient descent - float\n",
        "          : W: the weights - ndarray\n",
        "          : b: the bias -  ndarray\n",
        "          : grad: the gradient of the activations w.r.t. to the loss -  list of ndarray\n",
        "          : X: the data -  ndarray\n",
        "          : regularizer: 'L2' or None - the regularizer to be used in updateParams\n",
        "          : weight_decay: the weight decay to be used in updateParams - float\n",
        "    Outputs: W: the weights updated -  ndarray\n",
        "           : b: the bias updated -  ndarray\n",
        "    \"\"\"\n",
        "    grad_w = np.outer(grad, X.T)\n",
        "    grad_b = grad\n",
        "\n",
        "    W = updateParams(W, grad_w, eta, regularizer, weight_decay)\n",
        "    b = updateParams(b, grad_b, eta, regularizer, weight_decay)\n",
        "    return W, b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFpCHOnU6am_"
      },
      "source": [
        "The update rule is affected by regularization. We implement two cases: No regularization, or L2 regularization. Use the two possible update rules to implement the following function: <div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "l5y12c8W6anA"
      },
      "outputs": [],
      "source": [
        "def updateParams(param, grad_param, eta, regularizer=None, weight_decay=0.):\n",
        "    \"\"\"\n",
        "    Perform the update of the parameters\n",
        "    Inputs: param: the network parameters - ndarray\n",
        "          : grad_param: the updates of the parameters - ndarray\n",
        "          : eta: the step-size of the gradient descent - float\n",
        "          : weight_decay: the weight-decay - float\n",
        "    Outputs: the parameters updated - ndarray\n",
        "    \"\"\"\n",
        "    if regularizer==None:\n",
        "        grad = param - eta * grad_param.T\n",
        "        return grad\n",
        "    elif regularizer=='L2':\n",
        "        grad = (1 - 2 * weight_decay) * param - eta * grad_param.T\n",
        "        return grad\n",
        "    else:\n",
        "        raise NotImplementedError"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vk31heuB6anB"
      },
      "source": [
        "### Computing the Accuracy\n",
        "\n",
        "Here, we simply use the model to predict the class (by taking the argmax of the output !) for every example in ```X```, and count the number of times the model is right, to output the accuracy.\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {
        "id": "uKrk-qxT6anC"
      },
      "outputs": [],
      "source": [
        "def computeAcc(W, b, X, labels):\n",
        "    \"\"\"\n",
        "    Compute the loss value of the current network on the full batch\n",
        "    Inputs: act_func: the activation function - function\n",
        "          : W: the weights - list of ndarray\n",
        "          : B: the bias - list of ndarray\n",
        "          : X: the batch - ndarray\n",
        "          : labels: the labels corresponding to the batch\n",
        "    Outputs: loss: the negative log-likelihood - float\n",
        "           : accuracy: the ratio of examples that are well-classified - float\n",
        "    \"\"\"\n",
        "    # Forward propagation\n",
        "    z = forward(W, b, X)\n",
        "\n",
        "    # Compute the softmax and the prediction\n",
        "    out = softmax(z)\n",
        "    pred = out.argmax(axis=1)\n",
        "\n",
        "    # Compute the accuracy\n",
        "    accuracy = (pred == labels).sum() / len(labels)\n",
        "\n",
        "    return accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HvunYEwP6anD"
      },
      "source": [
        "### Preparing training\n",
        "\n",
        "The following hyperparameters are given. Next, we can assemble all the function previously defined to implement a training loop. We will train the classifier on **one epoch**, meaning that the model will see each training example once."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "id": "gqtrfXr66anD"
      },
      "outputs": [],
      "source": [
        "# Optimization\n",
        "eta = 0.01\n",
        "regularizer = 'L2'\n",
        "weight_decay = 0.0001\n",
        "\n",
        "# Training\n",
        "log_interval = 5000"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Eg5qOs8H6anE"
      },
      "source": [
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eqHZQGM_6anF",
        "outputId": "d00243c7-933f-4c32-8d1d-051dff480575"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 0.09125 0.0836 0.01\n",
            "5000 0.8271833333333334 0.8334 0.01\n",
            "10000 0.8516 0.8566 0.01\n",
            "15000 0.8410166666666666 0.8433 0.01\n",
            "20000 0.8481666666666666 0.8551 0.01\n",
            "25000 0.8422 0.8481 0.01\n",
            "30000 0.85345 0.8554 0.01\n",
            "35000 0.8376166666666667 0.8404 0.01\n",
            "40000 0.8497666666666667 0.849 0.01\n",
            "45000 0.8547 0.8549 0.01\n",
            "50000 0.8500166666666666 0.8574 0.01\n",
            "55000 0.8289333333333333 0.8311 0.01\n",
            "Final result: 0.8289333333333333 0.8311 0.01\n"
          ]
        }
      ],
      "source": [
        "# Data structures for plotting\n",
        "g_train_acc=[]\n",
        "g_valid_acc=[]\n",
        "\n",
        "#######################\n",
        "### Learning process ##\n",
        "#######################\n",
        "for j in range(n_training):\n",
        "    # Getting the example\n",
        "    X, y = X_train[j], y_train[j]\n",
        "\n",
        "    # Forward propagation\n",
        "    z = forward(W, b, X)\n",
        "\n",
        "    # Compute the softmax\n",
        "    out = softmax(z)\n",
        "\n",
        "    # Compute the gradient at the top layer\n",
        "    derror = out - y # This is o - y\n",
        "\n",
        "    # Update the parameters\n",
        "    W, b = update(eta, W, b, derror, X, regularizer, weight_decay)\n",
        "\n",
        "    if j % log_interval == 0:\n",
        "        # Every log_interval examples, look at the training accuracy\n",
        "        train_accuracy = computeAcc(W, b, X_train, train_labels)\n",
        "\n",
        "        # And the testing accuracy\n",
        "        test_accuracy = computeAcc(W, b, X_test, test_labels)\n",
        "\n",
        "        g_train_acc.append(train_accuracy)\n",
        "        g_valid_acc.append(test_accuracy)\n",
        "        result_line = str(int(j)) + \" \" + str(train_accuracy) + \" \" + str(test_accuracy) + \" \" + str(eta)\n",
        "        print(result_line)\n",
        "\n",
        "g_train_acc.append(train_accuracy)\n",
        "g_valid_acc.append(test_accuracy)\n",
        "result_line = \"Final result:\" + \" \" + str(train_accuracy) + \" \" + str(test_accuracy) + \" \" + str(eta)\n",
        "print(result_line)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 410
        },
        "id": "0GiZLxp9HMz2",
        "outputId": "38fbfa8c-2294-4356-9448-0d917692266a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "x = np.arange(len(g_train_acc)) * 5000\n",
        "plt.figure(figsize=(8,4))\n",
        "plt.title('Model accuracy')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.xlabel('Number of iterations')\n",
        "plt.plot(x, g_train_acc, label='Training accuracy')\n",
        "plt.plot(x, g_valid_acc, label='Test accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3A8VhkYd6anG"
      },
      "source": [
        "What can you say about the performance of this simple linear classifier ?\n",
        "<div class='alert alert-block alert-warning'>\n",
        "            Answer:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RUQks9ZDIkw5"
      },
      "source": [
        "\n",
        "The model achieved an accuracy of approximately 0.84, starting from an initial accuracy of about 0.1 due to its random initialization. It quickly approached its peak performance. Additionally, the similarity in results between the training and testing sets suggests that the model did not suffer from overfitting."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tGEuueqZ6anG"
      },
      "source": [
        "# Second part: Autoencoder with Keras"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ogXUpXzl6anH"
      },
      "source": [
        "## Autoencoder and PCA\n",
        "\n",
        "First, we will try to connect the representation produced by Principal Component Analysis with what is learnt by a simple, linear, autoencoder. We will use the ```scikit-learn``` implementation of the ```PCA``` to obtain the two first components (hint: use the attribute ```.components_```), and visualize them:\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 324
        },
        "id": "nKCIEDOd6anI",
        "outputId": "7d8ac588-842d-4265-a4d4-59eb2843db38"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Second Principal Component')"
            ]
          },
          "execution_count": 88,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.decomposition import PCA\n",
        "\n",
        "# Let's find the first 2 PCA components\n",
        "num_components = 2\n",
        "pca = PCA(n_components=num_components).fit(X_train)\n",
        "\n",
        "# Reshape so they resemble images and we can print them\n",
        "eigen_mnist = pca.components_.reshape(2, img_rows, img_cols)\n",
        "\n",
        "# Show the reshaped principal components\n",
        "f, ax = plt.subplots(1,2)\n",
        "ax[0].imshow(eigen_mnist[0], cmap='gray')\n",
        "ax[0].set_xlabel('First Principal Component')\n",
        "ax[1].imshow(eigen_mnist[1], cmap='gray')\n",
        "ax[1].set_xlabel('Second Principal Component')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "20mbNRUy6anI",
        "outputId": "9a59bf50-2130-41be-c611-6431d889efe0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([40.48892 , 29.241385], dtype=float32)"
            ]
          },
          "execution_count": 89,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print the variance explained by those components\n",
        "pca.explained_variance_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5JPQo1G6anJ"
      },
      "source": [
        "Comment on the visualization in relation to the variance explained by only keeping the two principal components:\n",
        "<div class='alert alert-block alert-warning'>\n",
        "            Answer:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EF6h90nAlQ1w"
      },
      "source": [
        "The visulaization is not clear.\n",
        "\n",
        "The visualization of the first two principal components provides a graphical representation of the most prominent patterns in the data, but it may not fully capture all the variability present in the dataset. The first two principal components explain only around 69.73% of the total variance, leaving approximately 30.27% of the variance unaccounted for.\n",
        "\n",
        "Additional principal components or other techniques may be needed to capture more of the dataset's variance and provide a clearer understanding of its structure."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I24n2xnK6anK"
      },
      "source": [
        "### Implementing the Autoencoder with Keras"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "id": "KtFsbXSM6anK"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.layers import Input, Dense\n",
        "from tensorflow.keras.optimizers import SGD"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xKusxaTe6anL"
      },
      "source": [
        "Now, we will use Keras to implement the autoencoder. You can take a look at this [cheatsheet](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Keras_Cheat_Sheet_Python.pdf) for some basic commands to use keras.\n",
        "\n",
        "In this first case, we implement a **simple linear autoencoder**. Build it in order to have the same capacity as the PCA decomposition (2 hidden dimensions !) we made just above.\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rxc1ULfz6anM",
        "outputId": "937a03aa-9bbf-4432-8977-16146e1a8905"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"ae_model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_9 (InputLayer)        [(None, 784)]             0         \n",
            "                                                                 \n",
            " dense_20 (Dense)            (None, 2)                 1570      \n",
            "                                                                 \n",
            " dense_21 (Dense)            (None, 784)               2352      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3922 (15.32 KB)\n",
            "Trainable params: 3922 (15.32 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Input layer\n",
        "input_layer = Input(img_rows*img_cols)\n",
        "\n",
        "# Encoding layer\n",
        "# ReLU activation function introduces non-linearity, enabling to learn complex patterns in the data.\n",
        "latent_view = Dense(2, activation='relu')(input_layer)\n",
        "\n",
        "# Decoding layer\n",
        "output_layer = Dense(img_rows*img_cols)(latent_view)\n",
        "\n",
        "ae_model = Model(input_layer, output_layer, name='ae_model')\n",
        "ae_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBj2PGXJ6anM"
      },
      "source": [
        "What loss shoud we use ? Choose the usual one and import it directly from Keras. You can use a simple ```SGD``` optimizer, and then compile the model; finally, train it to rebuild images from the original examples.\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0x7_KVjBnmcH"
      },
      "source": [
        "For reconstructing images from the original examples in an autoencoder, a commonly used loss function is the mean squared error (MSE) loss. This loss function computes the mean squared difference between the input and output images, aiming to minimize the reconstruction error."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qSKfame76anN",
        "outputId": "d5db1f18-7535-4dbb-f965-060bf4a5f094"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "469/469 [==============================] - 3s 5ms/step - loss: 0.9186 - val_loss: 0.9192\n",
            "Epoch 2/10\n",
            "469/469 [==============================] - 2s 3ms/step - loss: 0.9175 - val_loss: 0.9184\n",
            "Epoch 3/10\n",
            "469/469 [==============================] - 2s 4ms/step - loss: 0.9168 - val_loss: 0.9179\n",
            "Epoch 4/10\n",
            "469/469 [==============================] - 2s 5ms/step - loss: 0.9163 - val_loss: 0.9175\n",
            "Epoch 5/10\n",
            "469/469 [==============================] - 3s 6ms/step - loss: 0.9159 - val_loss: 0.9172\n",
            "Epoch 6/10\n",
            "469/469 [==============================] - 2s 5ms/step - loss: 0.9156 - val_loss: 0.9169\n",
            "Epoch 7/10\n",
            "469/469 [==============================] - 2s 5ms/step - loss: 0.9153 - val_loss: 0.9167\n",
            "Epoch 8/10\n",
            "469/469 [==============================] - 2s 5ms/step - loss: 0.9151 - val_loss: 0.9164\n",
            "Epoch 9/10\n",
            "469/469 [==============================] - 2s 3ms/step - loss: 0.9148 - val_loss: 0.9162\n",
            "Epoch 10/10\n",
            "469/469 [==============================] - 2s 5ms/step - loss: 0.9146 - val_loss: 0.9160\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.losses import MeanSquaredError\n",
        "loss = MeanSquaredError()\n",
        "\n",
        "optimizer = SGD(learning_rate=0.01)\n",
        "ae_model.compile(optimizer=optimizer, loss=loss)\n",
        "\n",
        "batch_size = 128\n",
        "epochs = 10\n",
        "# No noise here - we want to train a simple auto-encoder and compare visually with PCA\n",
        "history = ae_model.fit(X_train,\n",
        "                       X_train,\n",
        "                       epochs=epochs,\n",
        "                       batch_size=batch_size,\n",
        "                       verbose=1,\n",
        "                       shuffle=True,\n",
        "                       validation_data=(X_test, X_test))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6sWYrkAU6ane"
      },
      "source": [
        "Assuming that the name of your layer (obtained through the command ```model.summary()```) is ```'layer'```, here is the way to obtained the weights. Visualize the weights of the encoder and compare them to the two components obtained through the PCA."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {
        "id": "pF3z5gtB6anf"
      },
      "outputs": [],
      "source": [
        "weights, bias = ae_model.get_layer('dense_20').get_weights()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1I7nE-I26ang"
      },
      "source": [
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 324
        },
        "id": "HxOjkRyS6anh",
        "outputId": "eb8ffd1d-2399-4765-d855-5a1cdb40f4d4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Second Dimension')"
            ]
          },
          "execution_count": 96,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAEiCAYAAABZUbA/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABCVklEQVR4nO3deVxV1f7/8TciswyiApKI43W4zhM5kSWO5VUzNXOu7DrgNU1NLUXLQimHNHMqRbPUzHDWUhM0U0zUzHm4pnhFnAIElXH9/vDH+UKe81kguAF5Px8PHo88r7MPmw17tTicvY6VUkqBiIiIyCAlCnoHiIiIqHjh5IOIiIgMxckHERERGYqTDyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhOPkgIiIiQ3HyQURERIYqWdA78HcZGRm4du0anJ2dYWVlVdC7Q1QsKaVw9+5deHt7o0SJovE7CscOooKVq3FDPSGff/658vX1VXZ2dqpZs2YqMjIyR9tFR0crAPzgBz8KwUd0dPSTGiLMetxxQymOHfzgR2H5yMm48USe+Vi7di3GjBmDRYsWwc/PD3PnzkWHDh1w9uxZeHh4iNs6OzsDABYtWgQHBwez97l37574GC1bthT72bNnxb548WKxt2vXTuxff/212ENDQ8UOAK+88orYn332WbEPGDBA7P/5z3/E/sYbb4i9Tp06Ytcdg969e4vd0vc+06VLl8S+bt06sQcFBYn9xo0bYre2thY7ADRp0kTs8fHxeepTp04Vu+48kb6GtLQ0REZGms5HI+Rl3AD+b+wYNmwY7OzszN4nJSVFfAw/Pz+xf/fdd2KvUaOG2Pfs2SN2f39/sa9cuVLsAHDkyBGxT58+Xex9+/YV+6lTp8Q+fvx4sb/zzjtif/XVV8Xeo0cPsY8dO1bsFy5cELuPj4/Y//jjD7HfvXtX7LqxBwBGjhwp9tq1a4t9586dYteN/yVLylOD+fPnm709PT0dx48fz9G48UQmH7Nnz8aQIUMwePBgAA8nElu3bsWyZcswYcIEcdvMp0sdHBzg6Oho9j5K8154ui/c0uNmsrGxEbu9vb3Ydf9jKlWqlNgBaJ+ysrW1FbuTk5PYdfuo+xp1j5/X/dNNPnRdd/LovgeJiYliz8nkw8XFRewZGRliT09PF7vua9T1nHwNRv75Ii/jBvB/+2pnZ2dx8qH7evI6Nlj6vJl0x1y3fU6+H7qfO925qTs3dOeebh91Y4tu/NYdQ933UHeMdV+fbvvk5GSx5+R/zE/650z3Neo+v+7xc/Jzmu9/zE1JSUFUVBQCAgL+75OUKIGAgAAcOHDgkfsnJycjISEh2wcRFS+5HTcAjh1ERVm+Tz5u3bqF9PR0eHp6Zrvd09MT169ff+T+wcHBcHV1NX3onvIioqdPbscNgGMHUVFW4C9jnzhxIuLj400f0dHRBb1LRFQEcOwgKrry/TUfZcuWhbW1NWJjY7PdHhsbCy8vr0fuL/19loiKh9yOGwDHDqKiLN+f+bC1tUXjxo2xe/du020ZGRnYvXs3mjdvnt+fjoieAhw3iIqXJ3K1y5gxYzBw4EA0adIEzZo1w9y5c5GUlGR6FXtOrFu3zuIrbsPDw8VtL168KHbdpV66SxjLli0r9pkzZ4pdt/+A/moX3WWYP/zwg9h1l3tdvXo1T5+/cePGYtf9LLRo0ULsukttN2zYIPbffvtN7LrLVF1dXcUOAKtXrxb7vn37xH7+/Hmxt2/fPk/bHzt2zGLTXYnzJOTHuAE8vMzQ0qvx+/fvL27boUMHsf/3v/8Ve61atcR+5coVsQ8fPlzsJ0+eFDsAvPbaa2LXXW1y5swZsa9Zs0bsup/727dvi113brZu3VrsDRo0ELvuSraPP/5Y7Dq6pRp0VxsBQFxcnNj79OkjduncBvSXY9erV0/sAwcONHv7/fv3cfToUXHbTE9k8tG7d2/cvHkTU6ZMwfXr19GgQQPs2LHjkReTERFl4rhBVHw8seXVAwMDERgY+KQenoieQhw3iIqHAr/ahYiIiIoXTj6IiIjIUJx8EBERkaE4+SAiIiJDcfJBREREhnpiV7vkVbdu3Sy+O6G3t7e4rW6NDN07ZOqu0544caLYd+3aJXbdNdoAsGLFCrHr3hZbtxZJaGio2HXrWOjWM9i7d6/Yp0yZIva2bduK/dtvvxX7Cy+8IHbd/lerVk3sOXlHWN1be3fq1EnsixYtEnvnzp3FrlvP4aeffrLYHjx4gA8//FDcvrAKDg62+K7J7u7u4raW3kcmk24NCN36NJUqVRL75s2bxV6hQgWxA/pzp27dumLXjQ26x9+yZYvYdW85r1vnQ7dGhW6dp65du4pdN37rzv2bN2+K3c/PT+wAsHHjRrGfO3dO+xiSBw8eiF33/5/Zs2ebvV23hkpWfOaDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZChOPoiIiMhQnHwQERGRoTj5ICIiIkMV2nU+9u7dC1tbW7Nt8uTJ4ranTp0S+4YNG8Q+c+ZMsZcvX17s9+/fF/u0adPEDgBt2rQRu7Ozs9h114HrrnWvU6eO2Lt37y72kJAQscfExIh98ODBYv/666/FrruO/ejRo3na3t/fX+yA/ufo+PHjYr99+7bYGzVqJPb9+/eLXfoZSEpKErctzC5dugQHBwezrUqVKuK2q1evFnu7du3EHhQUJPahQ4eK/bXXXhP7tm3bxA4A27dvF/ukSZPErlurRLfO0dq1a8V+/vx5sR86dEjsunWS3n//fbHfuHFD7BcuXBD7jh07xP7777+L3c3NTeyA/hi/8sorYk9NTc3TPjRs2FDslv7/pJQSt8uKz3wQERGRoTj5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZCgrlZsLcw2QkJAAV1dX9OrVCzY2Nmbvc/HiRfExypUrJ3ZL64dk0l0H/+uvv4q9QYMGYtetsQEAXbp0Efvp06fFvnTpUrF37NhR7P/617/ErjuG3333ndjXrFkj9lWrVom9devWYv/888/FXqNGDbGnp6eLXbcOCKC/5t3Pz0/suvVqUlJSxH7z5k2x9+7d22K7f/8+Ro8ejfj4eLi4uIiPU1hkjh1z5syxuM6H7piPHTtW7Pb29mJ3d3cXu+57am1tLfZZs2aJHQA+/fRTsdeqVUvsunNTt0bEwoULxT5kyBCxSz+XALBlyxaxu7q6iv3KlSti9/DwEPu9e/fE/vrrr4td9zME6L/P69evF7vu53Dr1q1iL1FCfl5i06ZNZm9PTU3Fpk2bcjRu8JkPIiIiMhQnH0RERGQoTj6IiIjIUJx8EBERkaE4+SAiIiJDcfJBREREhuLkg4iIiAxVMr8fcOrUqZg2bVq222rUqIEzZ87k6nFOnTpl8Zr3ChUqiNsuWLBA7Ldv3xb7hg0bxB4WFiZ23foLgYGBYgeA5ORksb/55ptiHzhwoNgXL14s9vv374v92WefFXurVq3EPn36dLH3799f7I0aNcrT4+uOr26tmJyst1CtWjWx16xZU+w+Pj5inzt3rthLlpRP7xMnTlhsup/h/JZf4wYAODg4WFzn45VXXhG39ff3F/trr70m9tTUVLFPnjxZ7P369RO7bv0aAGjSpInYExISxK4bn7744gux79q1S+wzZ84U+/Lly8U+fvx4sf/1119iX7RokdgbNmwodt15W7lyZbEPHTpU7AAQEREh9uDgYLHrxn/dOky6dZTq1Klj9vbk5GSLa4D8Xb5PPgDgn//8Z7YfQN0gSETEcYOo+HgiZ3fJkiXh5eX1JB6aiJ5SHDeIio8n8pqP8+fPw9vbG1WqVEHfvn21y9kSEXHcICo+8v2ZDz8/P4SGhqJGjRqIiYnBtGnT0Lp1a5w4cQLOzs6P3D85OTnb3991f48koqdPbscNgGMHUVGW75OPTp06mf67Xr168PPzg6+vL7777ju88cYbj9w/ODj4kReaEVHxkttxA+DYQVSUPfFLbd3c3PCPf/wDFy5cMNsnTpyI+Ph400d0dPST3iUiKuR04wbAsYOoKHvik4/ExERcvHgR5cuXN9vt7Ozg4uKS7YOIijfduAFw7CAqyvL9zy5jx45Fly5d4Ovri2vXriEoKAjW1tbo06dPrh5n6dKlKFWqlNn2wgsviNvqrtPWXeNsaY2ATJs3bxa7bg0MOzs7sQP6a/X/97//id3e3l7sltZQyTRy5Eix69YrsPRUeSbdWim632KnTp0q9h07dohdt9bLoUOHxN6uXTuxA/rr/VevXi329957T+z16tUTu4eHh9ibNm1qsd27dw9LliwRt89P+TVuAA+/N5ZeJ+Lk5CRuW79+fbHv2bNH7Bs3bhR7eHi42JctWyb2O3fuiB0AVqxYIfZff/1V7Lo1gHT72LNnT7FPmDBB7Lr1cU6dOiV23VoouvNS99qhP//8U+y6/784OjqKHQD2798v9l9++UXsAQEBYr98+bLYt2/fLvZ9+/aZvT0pKQkzZswQt82U75OPq1evok+fPrh9+zbKlSuHVq1a4eDBg9pFm4io+OK4QVS85PvkY82aNfn9kET0lOO4QVS88L1diIiIyFCcfBAREZGhOPkgIiIiQ3HyQURERIbi5IOIiIgMVWjfs7p///4W16LQreEwZ84cseuuA2/VqpXYr1+/Lvasbwtuzvvvvy92AGjUqJHYdetctGnTRuy6dS50a6Xo1vlo3ry52IcOHSr2t956S+zz5s0Te1xcnNjv378v9vj4eLH/9ttvYgeAw4cPi3306NFiv3v3rti7desmdt0xlN64LTU1Vdy2MJszZ47FtXR8fX3Fbd955x2xN2jQQOwvv/yy2F988UWxt2jRQuzt27cXOwCcOHFC7PPnzxe7bi0R3c+VbnzTrYOhG3t0688sXLhQ7BUrVhS7bh0OW1tbsZ87d07ssbGxYgeAL774QuzBwcFiV0qJvUaNGmKvUKGC2C0do4yMDHG7rPjMBxERERmKkw8iIiIyFCcfREREZChOPoiIiMhQnHwQERGRoTj5ICIiIkNx8kFERESG4uSDiIiIDFVoFxnbsGEDnJ2dzbaSJeXd1i1CNmPGDLFbWVmJfcCAAWJft26d2HULZAHAmDFjxO7m5iZ2BwcHsdetW1fsycnJYh80aJDYc7IIl0S3ENDq1avFrluo6KWXXhJ7dHS02Js0aSJ2AKhdu7bYly9fLvauXbuKXXeMfvrpJ7FLiyUlJibi+++/F7cvrNLS0iwuUNi4cWNx2+7du4tdd17pFgdcunSp2GvVqiV23eJRAPDXX3+JfcuWLWI/duyY2D08PMSuO3d0i+vpFjnTnVeW/r+R6aOPPhK7bqG4L7/8Uuy6BcJcXV3FDgBvv/222HVfQ2Jiotj79esn9g4dOojd0viuW7wxKz7zQURERIbi5IOIiIgMxckHERERGYqTDyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhCu06H7/99hscHR3NtkWLFonb6tbx0F0HrrvOPTAwUOxBQUFij4mJETsAvPrqq2L38vISu+5rfOWVV8Q+d+5csaekpIj93r17Yt+wYYPY+/fvL/bNmzeLvU2bNmJfuHCh2H18fMSuWycEALZu3Sr2I0eOiP3ChQtiv3r1qth16+EsWbLEYsvN9fqFjbu7O+zt7c226dOni9vq1tHo06eP2E+cOCH2AwcOiP3DDz8U++nTp8UO6H82dWvg6I6Rr6+v2P39/cWuW6djyJAhYj9+/LjYV65cKfYrV66IXbeGz9dffy123Tom//73v8UOADVq1BC77vzUjX+6n+OLFy+KvUGDBmZv160vkhWf+SAiIiJDcfJBREREhuLkg4iIiAzFyQcREREZipMPIiIiMhQnH0RERGQoTj6IiIjIULle52Pv3r345JNPEBUVhZiYGISFhaFbt26mrpRCUFAQli5diri4OLRs2RILFy5E9erVc/V5Tp48CTs7O7Nt9uzZ4rZ//fWX2Fu2bCn2qKgosbu5uYnd1dU1Tx0AunTpInbdddqXL18W+7Rp08T+xRdfiD04OFjsvXv3FntycrLYdetsnD9/XuwTJ04U+4ABA8TeuXNnsXfs2FHsAPDpp5+KXfc90q1XoFvv5vr162KXjvHdu3fFbXPLqHEDANq1a4dSpUqZbbo1IkaNGiX2jz76SOzvvvuu2MuXLy/2xYsXi/2PP/4QOwD8+uuvYtetY6RbQ0h3bkyaNEns0voyAPD888+Lfc6cOWJfv3692G/fvi123TolzZs3F/u8efPErjs+gP4Yb9myRewLFiwQ+48//ih2Pz8/sT948MDs7bp1crLK9TMfSUlJqF+/vsUvLiQkBPPmzcOiRYsQGRkJJycndOjQweLOEtHTj+MGEWWV62c+OnXqhE6dOpltSinMnTsX77//Prp27Qrg4W9vnp6e2LBhg3bVTiJ6OnHcIKKs8vU1H5cuXcL169cREBBgus3V1RV+fn4WlxVOTk5GQkJCtg8iKj4eZ9wAOHYQFWX5OvnI/Buzp6dntts9PT0t/v05ODgYrq6upg/d3/qJ6OnyOOMGwLGDqCgr8KtdJk6ciPj4eNNHdHR0Qe8SERUBHDuIiq58nXxkvko6NjY22+2xsbEWX0FtZ2cHFxeXbB9EVHw8zrgBcOwgKsrydfJRuXJleHl5Yffu3abbEhISEBkZqb08iYiKJ44bRMVPrq92SUxMxIULF0z/vnTpEo4dOwZ3d3dUrFgRb7/9NqZPn47q1aujcuXKmDx5Mry9vbNd058TrVu3hpOTk9l29epVcdvAwECx664THzp0qNh16yfMmjVL7B4eHmIH9OtcREZGil23PsKePXvEXq1aNbEnJSWJXXetvO7n4dChQ2KvUKFCnra/deuW2A8ePCh23XoPgP5a+2XLlold93O8efNmsdeuXVvsFy9etNh039/cMmrcAB5+b2xsbB5rPw8fPiz2zz77TOxt27YVe5MmTcT+zTffiN3b21vsADB48GCx69bwiYmJEbvu3EtLSxP7unXrxB4XFyf2CRMmiL1du3ZiL126tNhr1qwpdt1aLs8++6zYdfsP6NeCmjp1qth168HMmDFD7NOnTxf7b7/9ZvZ23fpNWeV68nH48OFsi8CMGTMGADBw4ECEhoZi/PjxSEpKwltvvYW4uDi0atUKO3bsgL29fW4/FRE9JThuEFFWuZ58tGnTRlzFzMrKCh988AE++OCDPO0YET09OG4QUVYFfrULERERFS+cfBAREZGhOPkgIiIiQ3HyQURERIbi5IOIiIgMZaWkl6AXgISEBLi6umLt2rVwdHQ0ex/ddej//e9/xf79999r90Giu468V69eYh80aJDYAeBf//qX2P++GuTf6daxGDlypNgbNWok9pUrV4r92rVrYq9UqZLYe/fuLfZy5cqJvWfPnmIvW7as2HXrqFSpUkXsALJdWmpO1jdSM+d///uf2HXrFSQmJopdWo8mLS0NUVFRiI+PLzIrh2aOHZUrV0aJEuZ/r6pbt674GDt27BC7btGzjIwMsbdu3VrsuvP2zTffFHtO9kFn7969Yn/hhRfE/uGHH4o9IiJC7B9//LHYW7ZsKfZXXnlF7D/++GOeHv+ll14S+6hRo8Tu7OwsdgBYtWqV2HXrGIWHh4tdNz5evnxZ7L6+vmZvT0lJQWhoaI7GDT7zQURERIbi5IOIiIgMxckHERERGYqTDyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhcv2utkYpWbIkbGxszLYlS5aI2y5YsEDsw4cPF7tunY727duL3c/PT+whISFiB4ALFy6IXbdGhG4dDTs7O7FfuXJF7KdPnxa7l5eX2Js2bSr2u3fvil23hoVu+ZqPPvpI7E5OTmJfuHCh2AFg586dYtetKXH16lWxDx06NE+fX1qvITk5GVFRUeL2hdU///lPi2PHqVOnxG11Y4tu7YIJEyaIvUWLFmLXjR3r1q0TOwAcOHBA7Lo1fvbv3y/26OhosR85ckTsY8eOFfvt27fz1H/44Qexf/bZZ2LXvbNy48aNxT516lSx68Y2AHjttdfEXqdOnTxtr1sLJi0tTeyW1hmxtL6O2fvm+J5ERERE+YCTDyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhOPkgIiIiQ3HyQURERIYqtOt8JCUlWVyrQbdGRenSpcW+du1asevW0Lh06ZLYf//9d7H7+/uLHQBu3Lgh9nHjxolddy1///79xb5nzx6x69bZmDx5sti7dOki9uPHj4t91qxZYh8wYIDYf/75Z7Hr1ltYv3692AFgzpw5Yv/tt9/EXqpUKbGvWrVK7Lpr+aWfw6SkJMyePVvcvrC6ceMGSpY0P7RVrlxZ3LZhw4Zi133fdeu/NGjQQOwbN24U+507d8QOAGfOnBG7bi0TDw8Psbdu3Vrsbdq0Efv169fF/swzz4hdN76GhYWJvWrVqmL/6aefxD5//nyx69bIuHfvntgB4JdffhG77udg2bJlYo+NjRW77v+Rffv2NXt7YmIiFi1aJG6bic98EBERkaE4+SAiIiJDcfJBREREhuLkg4iIiAzFyQcREREZipMPIiIiMhQnH0RERGSoXK/zsXfvXnzyySeIiopCTEwMwsLC0K1bN1MfNGgQVqxYkW2bDh06YMeOHbn6PC4uLnBycjLb3nvvPXHb6dOni33q1Kli79mzZ562r1OnjtgDAwPFDgBly5YV+5AhQ8SuW4fjs88+E/sLL7wg9mvXrold9z1wcXER+6lTp8R+69YtsS9fvlzsunVA+vXrJ/a6deuKHQCGDx8u9g4dOoj9008/Fbvue7xt2zaxR0REWGzJycnitrll1LgBADY2NhbX+fjggw9y/XhZnT17Vuzffvut2HXr3+jW4OjTp4/YAaBSpUpi37Rpk9ijoqLErjv39u7dK3Yd3Tobbm5uYtedN5GRkWLXraE0fvx4sb/44otiHzx4sNgB/fj73HPPiX337t1i/+abb8T+xhtviD06Otrs7TlZwyRTrp/5SEpKQv369bFgwQKL9+nYsSNiYmJMH6tXr87tpyGipwjHDSLKKtfPfHTq1AmdOnUS72NnZwcvL6/H3ikierpw3CCirJ7Iaz7Cw8Ph4eGBGjVqYNiwYbh9+7bF+yYnJyMhISHbBxEVP7kZNwCOHURFWb5PPjp27IiVK1di9+7dmDlzJiIiItCpUyekp6ebvX9wcDBcXV1NHz4+Pvm9S0RUyOV23AA4dhAVZfn+xnKvvvqq6b/r1q2LevXqoWrVqggPD0fbtm0fuf/EiRMxZswY078TEhI4iBAVM7kdNwCOHURF2RO/1LZKlSooW7YsLly4YLbb2dnBxcUl2wcRFW+6cQPg2EFUlD3xycfVq1dx+/ZtlC9f/kl/KiJ6SnDcIHq65frPLomJidl+G7l06RKOHTsGd3d3uLu7Y9q0aejRowe8vLxw8eJFjB8/HtWqVdOuafB3gwcPRokS5udGS5cuFbcNCAgQ+6xZs8S+c+dOsUuXCwLAvHnzxD5hwgSxA8ChQ4fE/uOPP4p98+bNYn/zzTfFHhQUJPZnn31W7G3atBF7TEyM2G1tbcX++++/i123FoGO7jp73VoAALB27Vqx29jYiF13zfy+ffvErlvvQPo5t7a2FrfNLaPGDeDhWh6lSpUy20JCQsRtdWv06M678PBwsX/++edinzlzpth1axAB+q9Bt07RwIEDxa5bx0K3hoTuvNC9cLhq1api143fly9fFrtuLRfd9+jMmTNi163hBAChoaFi170Y++effxa79IwiAKxZs0bsBw8eNHu79Bqtv8v15OPw4cN4/vnnTf/O/JvrwIEDsXDhQhw/fhwrVqxAXFwcvL290b59e3z44Yews7PL7acioqcExw0iyirXk482bdpAKWWx634zIKLih+MGEWXF93YhIiIiQ3HyQURERIbi5IOIiIgMxckHERERGYqTDyIiIjKUlZJegl4AEhIS4OrqijVr1sDR0dHsfSpVqiQ+hm4NiBUrVojd0voimb7++muxlywpX0Q0YsQIsQMP1yqQvP7662LXrfGgu47b399f7N7e3mKvX7++2LMup23OqFGjxK5bI0N3rX3jxo3FHhcXJ/bk5GSxA8DKlSvFfuTIEbG3a9dO7H379hV7jRo1xC6th3Dv3j0MHjwY8fHxRWbl0MyxY9asWXBwcDB7H906BLo1Htzc3MQeGxsr9qtXr4q9a9euYk9JSRE7AJw7d07suncXrlixotinTJmi3QeJ7ucpMTFR7Lo1aEaPHi123TobP/zwg9h134OTJ0+KvWHDhmIHgEaNGol90aJFYteNn7rxt2XLlmJ/7bXXzN5+79499O3bN0fjBp/5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZChOPoiIiMhQuX5XW6NMnTrV4vXcuuuwdde5665hPnjwoNh110h7enqKfcKECWIHgFWrVon90qVLYtddB27pOu1Md+7cEbtunY1ff/1V7Lq1Wi5evCh23Voq06ZNE7u0xgUAVK9eXezz588XOwBER0eLfebMmWJPSEgQu269GN0+Ll++3GJLS0sTty3MFixYYHGtHjs7O3HbXr16if3mzZti140tunVA6tatK/bx48eLHQBatWoldt1aI7p1Pjp37ix23RoVunWUdOs06db5uHfvntjt7e3FvnTpUrF/+eWXYh80aJDYw8PDxQ4At2/fFrtufAoMDBS7u7u72Hv06CH2Z555xuztujVasuIzH0RERGQoTj6IiIjIUJx8EBERkaE4+SAiIiJDcfJBREREhuLkg4iIiAzFyQcREREZqtCu87Fr1y64uLiYbT/++KO4re469qZNm4r9pZdeErtSSuz79+8Xe5kyZcQOACtXrhT7vn37xP7WW2+J/cSJE2K/du2a2IOCgsSuWwdk4MCBYtetNVCzZk2xb9u2Tey6NTgGDx4s9gsXLogdsHwtfKbZs2eLfdOmTWLXreeQkZEh9sqVK1tsKSkp4raFmbW1tcW1IHTreOiOmY+Pj9ifffZZsbdu3Vrse/fuFbulMTErX19fsSclJYn96NGjYtetldK2bVuxOzg4iH3ixIli141tffv2FfuhQ4fE3q9fP7Hr1kjS/f/jxo0bYgeAw4cPi3369Olib9CggfZzSMaOHSv2nj17mr09OTk5x5+Dz3wQERGRoTj5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZKhcrfMRHByMH374AWfOnIGDgwNatGiBmTNnokaNGqb7PHjwAO+88w7WrFmD5ORkdOjQAV988QU8PT1ztWP79++Ho6Oj2WZvby9uO27cOLFPmDBB7EeOHBH74sWLxb59+3axf/zxx2IHgPPnz4tdt47FrFmzxH7lyhWxz5gxQ+yfffaZ2JcsWSJ23ToSoaGhYtetx/D++++L3c3NTewlS8qnhm6tGEB/jO7cuSP25cuXi93Pz0/suu9xpUqVLLYHDx6I2+aWkWPHunXr4OzsbLbFxcWJ2+rWXklPTxd79erVxa47Lw4ePCh23RpCgH78unz5sti9vLzE3qxZM7FfvHhR7LpzR7fOyDvvvCP2P//8U+x16tQRe0BAgNil9XEA4NatW2LXHT8AmDZtmth1/w/58ssvxZ6WliZ23Vpa9+/fN3t7btYHytUzHxERERgxYgQOHjyInTt3IjU1Fe3bt8+2aM3o0aOxefNmrFu3DhEREbh27Rpefvnl3HwaInrKcOwgoqxy9czHjh07sv07NDQUHh4eiIqKgr+/P+Lj4/HVV1/h22+/xQsvvADg4W9vtWrVwsGDB7Wr/xHR04ljBxFllafXfMTHxwMA3N3dAQBRUVFITU3N9rRVzZo1UbFiRRw4cMDsYyQnJyMhISHbBxE93Th2EBVvjz35yMjIwNtvv42WLVua/oZ2/fp12NraPvL3dE9PT1y/ft3s4wQHB8PV1dX0oXvvBCIq2jh2ENFjTz5GjBiBEydOYM2aNXnagYkTJyI+Pt70oXvDLyIq2jh2ENFjvattYGAgtmzZgr1796JChQqm2728vJCSkoK4uLhsv8HExsZafAW1nZ2d9l0SiejpwLGDiIBcPvOhlEJgYCDCwsLw888/P3LJUePGjWFjY4Pdu3ebbjt79iyuXLmC5s2b588eE1GRw7GDiLKyUkqpnN55+PDh+Pbbb7Fx48Zs1+e7urrCwcEBADBs2DBs27YNoaGhcHFxwciRIwEAv/76a44+R0JCAlxdXREQEAAbGxuz95HWJwCAHj16iD0sLEzsumv5ddfi6z5/p06dxA4Ap06dErtuDQndOhnjx48Xu4uLi9h117q3bt1a7DpZfys254033hC7pdcJZOrfv7/Yp0yZIvacPMW/atUqsVv6+c5UsWJFsa9cuVLst2/fFvuAAQMstgcPHmDSpEmIj4/X/izkhJFjx5o1ayyuEaT7vurWFLH0uJk++OADsX/yySdi79Kli9jv3bsndgBo06aN2DOPqyW6tRp062QEBgaKXbeOyLlz58TeuXNnsScmJopdt1aKbp0Q3Ro4Hh4eYp87d67YAf1aLO+++67Y7969K3bd/8MaNGgg9n379pm9PTU1Fd9//32Oxo1c/dll4cKFAB794V6+fDkGDRoEAJgzZw5KlCiBHj16ZFsoiIiKL44dRJRVriYfOXmSxN7eHgsWLMCCBQsee6eI6OnCsYOIsuJ7uxAREZGhOPkgIiIiQ3HyQURERIbi5IOIiIgMxckHERERGYqTDyIiIjLUYy2vboRBgwZZXNBHtwiNTpMmTcReooQ8J9MtcrZr1y6x52TFxokTJ4rd2dlZ7LoFpnSLIdnb24vd29tb7CtWrBD7zJkzxa5bSEi3UNuVK1fytL3ue5STxZ4mT54s9ueee07suoXaBg8eLPbz58+LvV69ehZbUlKSuG1hdvDgQYvLruu+r7rF83QLnul+7oYMGSL2Xr16iX3v3r1iB/SLfL311ltiP3z4sNh1i0e9+OKLYn/11VfF/vc3F/y77du3i33YsGFi1537a9euFbvu+JQpU0bsOXn35bNnz4r9yJEjYi9btqzYGzZsKHbdQmpNmza1uN33338vbpuJz3wQERGRoTj5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZKhCu85HxYoVUapUKbNNd536hQsXxK67Dvn06dNiHzt2rNh///13sQ8dOlTsADBgwIA87cPx48fFnp6eLvb//Oc/Yn/++efFXrNmTbF369ZN7DY2Nnn6/DExMWIvXbq02NetWyf2NWvWiB0A5s6dK/aSJeXTLywsTOzz588Xe9WqVcUufQ0pKSnitoXZjz/+CGtra7Nt586d4ra6tVcyMjLEnpaWJvYlS5aIXbf+TXR0tNiBh+ucSHRrOKxcuVLsXbp0Efszzzwjdt0aOS1atBC77utbsGCB2O/cuSN23fFp1aqV2HVrvYSEhIgdAK5evSr2cePGiX327Nli9/T0FHtUVJTYLa3zkZiYKG6XFZ/5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZChOPoiIiMhQhXadj6NHj8LBwcFsmzRpkrjtxo0bxd66dWuxv/jii2KvUKGC2I8cOSL2l19+WewAUKKEPC+Mi4sTu26tE906IGfOnHmi28fGxoq9cePGYtetU2JpjZhMH3/8sdhv3rwpdt1aBwBw48YNsd+9e1fsDRo0EHufPn3ErlurRTqP7t+/r13vobCKiYmBlZWV2RYRESFuu3btWrHrjsmlS5fErltjIiAgQOzt27cXO6Bfw0E3/nzwwQdi163TMWbMGLHrxoYtW7aIfdOmTWJPSkoSu24dkm3btoldN7Z8/vnnYt+/f7/YAcDW1lbsdevWFbuln/9MvXv3FrtufLS0VlZycrK4XVZ85oOIiIgMxckHERERGYqTDyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhcjX5CA4ORtOmTeHs7AwPDw9069YNZ8+ezXafNm3awMrKKttHTt5CnoieXhw7iCirXK3zERERgREjRqBp06ZIS0vDpEmT0L59e5w6dQpOTk6m+w0ZMiTbteKOjo653rHY2FjY29ubbf/73//EbdPS0sQ+depUsc+ePVvsq1atEvu8efPEXrNmTbED+nUkdI+huxZ+xYoVYtdd5z158mSx//HHH2LXrXGh+x6PGzdO7J9++qnYZ82aJXbd19+vXz+xA8D8+fPF3r17d7FfvHhR7Lpj0KpVK7H7+PhYbLq1EnLLyLGjc+fOFtdJCAkJEbfds2eP2OvXry923Tohhw8fFvu5c+fEPnLkSLED+jVwrK2txb5161axb9++XezXr18X+5o1a8TesGFDsevWIZk4caLYXVxcxK77GYmMjBR78+bNxa5bJwQA/v3vf4tdN7bo1qJavny52HVrrbz++utmb09MTNSOvZlyNfnYsWNHtn+HhobCw8MDUVFR8Pf3N93u6OgILy+v3Dw0ET3FOHYQUVZ5es1HfHw8AMDd3T3b7d988w3Kli2LOnXqYOLEidoV8YioeOHYQVS8Pfby6hkZGXj77bfRsmVL1KlTx3T7a6+9Bl9fX3h7e+P48eN49913cfbsWfzwww9mHyc5OTnbkqwJCQmPu0tEVARw7CCix558jBgxAidOnMAvv/yS7fa33nrL9N9169ZF+fLl0bZtW1y8eBFVq1Z95HGCg4Mxbdq0x90NIipiOHYQ0WP92SUwMBBbtmzBnj17tC9s8fPzA2D5jc4mTpyI+Ph400d0dPTj7BIRFQEcO4gIyOUzH0opjBw5EmFhYQgPD0flypW12xw7dgwAUL58ebPdzs4OdnZ2udkNIipiOHYQUVa5mnyMGDEC3377LTZu3AhnZ2fTJVWurq5wcHDAxYsX8e2336Jz584oU6YMjh8/jtGjR8Pf3x/16tV7Il8AERV+HDuIKKtcTT4WLlwI4OFiQFktX74cgwYNgq2tLXbt2oW5c+ciKSkJPj4+6NGjB95///1c71i3bt0sXg9dooT816LExESx9+nTR+y9evUSu+63Nt3Xe/v2bbEDgLe3t9hbt24tdt0x0K3joFuHQ3cdeGBgoNiXLVsm9tTUVLG3a9dO7Lr/YenW0ND9Rl29enWxA0BUVJTYFy1aJPZJkyaJ/eeffxb7u+++K/bVq1dbbCkpKeK2uWXk2FG9enWLawSFhYWJ20rHBACOHj0q9ryurxAXFyd23c8MIK/fAiDbi3TN+fsVSH/n4eEhdt0aFJbWYMnUpEkTsevWUlFKif3+/ftiX79+vdjfeecdsX/11Vdiz8laLbpzV7dO0cGDB8UeExMj9sGDB4v91KlTZm/PzdVpuf6zi8THxwcRERG5eUgiKgY4dhBRVnxvFyIiIjIUJx9ERERkKE4+iIiIyFCcfBAREZGhOPkgIiIiQ3HyQURERIayUrpr4AyWkJAAV1dXvPTSS7CxsTF7n8mTJ4uP0a9fP7FPnTpV7Lo1NFasWCF23SHNySWFlSpVErtunQk3NzexOzs7i123nsG+ffvE/uabb4q9a9euYu/Zs6fYhw4dKnZLa8RkCg4OFvuHH34o9ldffVXsgH6tkiNHjoh9z549Yj958qTYhwwZIvYJEyZYbKmpqdi4cSPi4+Ph4uIiPk5hkTl2dO/e3eLY4eTkJD5GxYoVxa5bg8La2lrsV69eFbtuDSDd2jEAcObMGbFnvqOwJVZWVmIPDQ0Ve8OGDcX+9/f0+bvp06eL3dHRUeyNGzcW+44dO8Suo3t83fmiO+8BWPz5zeTv7y92S2/GmKlRo0Ziv3btmthv3Lhh9vb09HScPHkyR+MGn/kgIiIiQ3HyQURERIbi5IOIiIgMxckHERERGYqTDyIiIjIUJx9ERERkqFy9q60RMi9TlS5T1L1dfHp6uth1b/urezv5Bw8eiF13qW1aWprYAf1bmuv2Qfe20bpLAnVvu637GnSfPyEhIU+Pr/se6i4X1D1+UlKS2DMyMsSek/vofs50x1D3PdI9vnSOZbZCdiW+KCdjh+680h1T3c+d7rzSfU9157Xu8m1AP/7pfi51547u3NCd27pjqDs3dV33PdQdHx3dz5Cu52T8130P8vo15nUfLT1+5u05GTcK3TofV69ehY+PT0HvBhEBiI6ORoUKFQp6N3KEYwdR4ZCTcaPQTT4yMjJw7do1ODs7w8rKCgkJCfDx8UF0dHSRWeyosOExzJviePyUUrh79y68vb1RokTR+Ossx478xeOXd8XtGOZm3Ch0f3YpUaKE2RmTi4tLsfjmPUk8hnlT3I6fq6trQe9CrnDseDJ4/PKuOB3DnI4bReNXGiIiInpqcPJBREREhir0kw87OzsEBQXBzs6uoHelyOIxzBsev6KJ37e84fHLOx5DywrdC06JiIjo6Vbon/kgIiKipwsnH0RERGQoTj6IiIjIUJx8EBERkaEK/eRjwYIFqFSpEuzt7eHn54dDhw4V9C4VWnv37kWXLl3g7e0NKysrbNiwIVtXSmHKlCkoX748HBwcEBAQgPPnzxfMzhZCwcHBaNq0KZydneHh4YFu3brh7Nmz2e7z4MEDjBgxAmXKlEGpUqXQo0cPxMbGFtAekyUcN3KO40becNx4PIV68rF27VqMGTMGQUFBOHLkCOrXr48OHTrgxo0bBb1rhVJSUhLq16+PBQsWmO0hISGYN28eFi1ahMjISDg5OaFDhw7aN7MqLiIiIjBixAgcPHgQO3fuRGpqKtq3b5/tjbRGjx6NzZs3Y926dYiIiMC1a9fw8ssvF+Be099x3Mgdjht5w3HjMalCrFmzZmrEiBGmf6enpytvb28VHBxcgHtVNABQYWFhpn9nZGQoLy8v9cknn5hui4uLU3Z2dmr16tUFsIeF340bNxQAFRERoZR6eLxsbGzUunXrTPc5ffq0AqAOHDhQULtJf8Nx4/Fx3Mg7jhs5U2if+UhJSUFUVBQCAgJMt5UoUQIBAQE4cOBAAe5Z0XTp0iVcv3492/F0dXWFn58fj6cF8fHxAAB3d3cAQFRUFFJTU7Mdw5o1a6JixYo8hoUEx438xXEj9zhu5EyhnXzcunUL6enp8PT0zHa7p6cnrl+/XkB7VXRlHjMez5zJyMjA22+/jZYtW6JOnToAHh5DW1tbuLm5Zbsvj2HhwXEjf3HcyB2OGzlX6N7VlqgwGDFiBE6cOIFffvmloHeFiIoIjhs5V2if+Shbtiysra0feUVwbGwsvLy8Cmiviq7MY8bjqRcYGIgtW7Zgz5492d6i3cvLCykpKYiLi8t2fx7DwoPjRv7iuJFzHDdyp9BOPmxtbdG4cWPs3r3bdFtGRgZ2796N5s2bF+CeFU2VK1eGl5dXtuOZkJCAyMhIHs//TymFwMBAhIWF4eeff0blypWz9caNG8PGxibbMTx79iyuXLnCY1hIcNzIXxw39DhuPKaCfsWrZM2aNcrOzk6FhoaqU6dOqbfeeku5ubmp69evF/SuFUp3795VR48eVUePHlUA1OzZs9XRo0fV5cuXlVJKzZgxQ7m5uamNGzeq48ePq65du6rKlSur+/fvF/CeFw7Dhg1Trq6uKjw8XMXExJg+7t27Z7rP0KFDVcWKFdXPP/+sDh8+rJo3b66aN29egHtNf8dxI3c4buQNx43HU6gnH0opNX/+fFWxYkVla2urmjVrpg4ePFjQu1Ro7dmzRwF45GPgwIFKqYeXzU2ePFl5enoqOzs71bZtW3X27NmC3elCxNyxA6CWL19uus/9+/fV8OHDVenSpZWjo6Pq3r27iomJKbidJrM4buQcx4284bjxeKyUUsq451mIiIiouCu0r/kgIiKipxMnH0RERGQoTj6IiIjIUJx8EBERkaE4+SAiIiJDcfJBREREhuLkg4iIiAzFyUch16ZNG7z99tsFvRvZhIaGPvIOjYXRoEGD0K1bt4LeDaJiIz/PuaJy/laqVAlz584t6N0ocrjIWCEwaNAgrFix4pHbz58/D3d3d9jY2MDZ2fmxH9/KygphYWHaE9nKysr0346OjvD29kbLli0xcuRING7c2NTu37+Pu3fvwsPD47H3yQjx8fFQShWJiRJRpps3b2LKlCnYunUrYmNjUbp0adSvXx9TpkxBy5YtC3r3RIMGDUJcXBw2bNhgtoeHh+P5558H8HC8cXZ2RpUqVdCuXTuMHj0a5cuXN923qJy/N2/ehJOTExwdHQt6V4qUkgW9A/RQx44dsXz58my3lStXDtbW1uJ2KSkpsLW1zbf9WL58OTp27IgHDx7g3LlzWLJkCfz8/LBs2TIMGDAAAODg4AAHB4d8+5xPiqura0HvAlGu9ejRAykpKVixYgWqVKmC2NhY7N69G7dv3y7oXcs3Z8+ehYuLCxISEnDkyBGEhITgq6++Qnh4OOrWrQug6Jy/5cqVK+hdKJoKcm13emjgwIGqa9euZttzzz2nRo0aZfq3r6+v+uCDD1T//v2Vs7OzGjhwoEpOTlYjRoxQXl5eys7OTlWsWFF9/PHHpvsjy/sN+Pr6WtwPACosLOyR2wcMGKCcnZ3VnTt3lFJKLV++XLm6upp6UFCQql+/vvrqq6+Uj4+PcnJyUsOGDVNpaWlq5syZytPTU5UrV05Nnz492+P+9ddf6o033lBly5ZVzs7O6vnnn1fHjh175HFXrlypfH19lYuLi+rdu7dKSEgw3WfdunWqTp06yt7eXrm7u6u2bduqxMREs8f1wYMHauTIkapcuXLKzs5OtWzZUh06dMjUM9/jYteuXapx48bKwcFBNW/eXJ05c8biMSPKT3/99ZcCoMLDw7X3k84dpZTatGmTatKkibKzs1NlypRR3bp1M7U7d+6o/v37Kzc3N+Xg4KA6duyozp07Z+qZ5/iOHTtUzZo1lZOTk+rQoYO6du2a6T5paWlq9OjRytXVVbm7u6tx48apAQMGWBzLlPq/c+yvv/7Kdvu9e/dUjRo1VMuWLU23/f38fe6551RgYKAaNWqUcnNzUx4eHmrJkiUqMTFRDRo0SJUqVUpVrVpVbdu2Ldtj//HHH6pjx47KyclJeXh4qH79+qmbN29me9yRI0eqcePGqdKlSytPT08VFBRk6hkZGSooKEj5+PgoW1tbVb58eTVy5EhT9/X1VXPmzDH9+/Lly+pf//qXcnJyUs7Ozqpnz57Z3tQwJ+NaccDXfBRBn376KerXr4+jR49i8uTJmDdvHjZt2oTvvvsOZ8+exTfffINKlSoBAH777TcAD5/RiImJMf07N0aPHo27d+9i586dFu9z8eJFbN++HTt27MDq1avx1Vdf4cUXX8TVq1cRERGBmTNn4v3330dkZKRpm549e+LGjRvYvn07oqKi0KhRI7Rt2xZ37tzJ9rgbNmzAli1bsGXLFkRERGDGjBkAgJiYGPTp0wevv/46Tp8+jfDwcLz88stQFv6SOH78eKxfvx4rVqzAkSNHUK1aNXTo0CHb5wOA9957D7NmzcLhw4dRsmRJvP7667k+ZkSPo1SpUihVqhQ2bNiA5ORki/fTnTtbt25F9+7d0blzZxw9ehS7d+9Gs2bNTNsPGjQIhw8fxqZNm3DgwAEopdC5c2ekpqaa7nPv3j18+umn+Prrr7F3715cuXIFY8eONfVZs2YhNDQUy5Ytwy+//II7d+4gLCzssb5uBwcHDB06FPv378eNGzcs3m/FihUoW7YsDh06hJEjR2LYsGHo2bMnWrRogSNHjqB9+/bo378/7t27BwCIi4vDCy+8gIYNG+Lw4cPYsWMHYmNj0atXr0ce18nJCZGRkQgJCcEHH3xgGu/Wr1+POXPmYPHixTh//jw2bNhgenbm7zIyMtC1a1fcuXMHERER2LlzJ/773/+id+/e2e4njWvFRkHPfujhDN/a2lo5OTmZPl555RWllPlnPrL+BqOUUiNHjlQvvPCCysjIMPv4sPCMRk7vd//+fQVAzZw5Uyll/pkPR0fHbDP3Dh06qEqVKqn09HTTbTVq1FDBwcFKKaX27dunXFxc1IMHD7J9rqpVq6rFixdbfNxx48YpPz8/pZRSUVFRCoD6888/zX49WX9zSkxMVDY2Nuqbb74x9ZSUFOXt7a1CQkKUUtmf+ci0detWBYBvH06G+f7771Xp0qWVvb29atGihZo4caL6/fffTT0n507z5s1V3759zT7+uXPnFAC1f/9+0223bt1SDg4O6rvvvlNKPTzHAagLFy6Y7rNgwQLl6elp+nf58uVN545SSqWmpqoKFSo81jMfSim1fft2BUBFRkYqpcw/89GqVSvTv9PS0pSTk5Pq37+/6baYmBgFQB04cEAppdSHH36o2rdvn+3zREdHKwCmd+b9++MqpVTTpk3Vu+++q5RSatasWeof//iHSklJMfs1ZX3m46efflLW1tbqypUrpn7y5EkFwPQsq25cKy74zEch8fzzz+PYsWOmj3nz5lm8b5MmTbL9e9CgQTh27Bhq1KiB//znP/jpp5/ydd/U/38mIesLUv+uUqVK2V4U6+npidq1a6NEiRLZbsv8reb3339HYmIiypQpY/ptr1SpUrh06RIuXrxo8XHLly9veoz69eujbdu2qFu3Lnr27ImlS5fir7/+Mrt/Fy9eRGpqarYX7NnY2KBZs2Y4ffp0tvvWq1cv2+cDIP42RpSfevTogWvXrmHTpk3o2LEjwsPD0ahRI4SGhgLI2blz7NgxtG3b1uzjnz59GiVLloSfn5/ptjJlyqBGjRrZzgVHR0dUrVrV9O+s5158fDxiYmKyPUbJkiUfGZtyIyfjTNZz09raGmXKlMn2LISnpycAZBtn9uzZk+041axZEwCyjTNZHxfI/rX27NkT9+/fR5UqVTBkyBCEhYUhLS3N7P6dPn0aPj4+8PHxMd1Wu3ZtuLm5ZTu20rhWXPAFp4WEk5MTqlWrluP7ZtWoUSNcunQJ27dvx65du9CrVy8EBATg+++/z5d9yzxpKleubPE+NjY22f5tZWVl9raMjAwAQGJiIsqXL4/w8PBHHivrq9ulx7C2tsbOnTvx66+/4qeffsL8+fPx3nvvITIyUtxXnayfM3MgzPycREawt7dHu3bt0K5dO0yePBlvvvkmgoKCMGjQoBydO/nxgnBz5556ghdHZo4zmX8yzuk+SedrYmIiunTpgpkzZz7yWFmvrJHGGR8fH5w9exa7du3Czp07MXz4cHzyySeIiIh4ZLuckj5fccFnPp4SLi4u6N27N5YuXYq1a9di/fr1pr//2tjYID09/bEfe+7cuXBxcUFAQEB+7S4aNWqE69evo2TJkqhWrVq2j7Jly+b4caysrNCyZUtMmzYNR48eha2trdm/O1etWhW2trbYv3+/6bbU1FT89ttvqF27dr58TURPSu3atZGUlAQgZ+dOvXr1sHv3brOPVatWLaSlpWV7/dXt27dx9uzZHJ8Lrq6uKF++fLbHSEtLQ1RU1GN9fffv38eSJUvg7++fr1ePNGrUCCdPnkSlSpUeOVZ//yVO4uDggC5dumDevHkIDw/HgQMH8Mcffzxyv1q1aiE6OhrR0dGm206dOoW4uDiOM3/DZz6eArNnz0b58uXRsGFDlChRAuvWrYOXl5fpt6BKlSph9+7daNmyJezs7FC6dGmLjxUXF4fr168jOTkZ586dw+LFi7FhwwasXLkyX6+3DwgIQPPmzdGtWzeEhITgH//4B65du2Z6oVxOnr6NjIzE7t270b59e3h4eCAyMhI3b95ErVq1Hrmvk5MThg0bhnHjxsHd3R0VK1ZESEgI7t27hzfeeCPfvi6ivLh9+zZ69uyJ119/HfXq1YOzszMOHz6MkJAQdO3aFUDOzp2goCC0bdsWVatWxauvvoq0tDRs27YN7777LqpXr46uXbtiyJAhWLx4MZydnTFhwgQ888wzps+RE6NGjcKMGTNQvXp11KxZE7Nnz0ZcXFyOtr1x4wYePHiAu3fvIioqCiEhIbh16xZ++OGHxzlsFo0YMQJLly5Fnz59MH78eLi7u+PChQtYs2YNvvzyS+1SBsDDRRXT09Ph5+cHR0dHrFq1Cg4ODvD19X3kvgEBAahbty769u2LuXPnIi0tDcOHD8dzzz2Xpz9JPY04+XgKODs7IyQkBOfPn4e1tTWaNm2Kbdu2mV5vMWvWLIwZMwZLly7FM888gz///NPiYw0ePBjAw6d9n3nmGbRq1QqHDh1Co0aN8nWfrayssG3bNrz33nsYPHgwbt68CS8vL/j7+5v+bqvj4uKCvXv3Yu7cuUhISICvry9mzZqFTp06mb3/jBkzkJGRgf79++Pu3bto0qQJfvzxR3EyRmSkUqVKwc/PD3PmzDG9TsnHxwdDhgzBpEmTAOTs3GnTpg3WrVuHDz/8EDNmzICLiwv8/f1Nn2f58uUYNWoUXnrpJaSkpMDf3x/btm3L1Z8R3nnnHcTExGDgwIEoUaIEXn/9dXTv3h3x8fHabWvUqAErKyuUKlUKVapUQfv27TFmzBh4eXnl8ojJvL29sX//frz77rto3749kpOT4evri44dO2Z7PZrEzc0NM2bMwJgxY5Ceno66deti8+bNKFOmzCP3tbKywsaNGzFy5Ej4+/ujRIkS6NixI+bPn5+vX9fTgCucEhERkaH4mg8iIiIyFCcfREREZChOPoiIiMhQnHwQERGRoTj5ICIiIkNx8kFERESG4uSDiIiIDMXJBxERERmKkw8iIiIyFCcfREREZChOPoiIiMhQnHwQERGRof4ffX/3Lpc1umsAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Show the two dimensions of the encoder, in a similar manner to the principal components\n",
        "# (after reshaping them as images !)\n",
        "comp_nn = weights.reshape(2, img_rows, img_cols)\n",
        "\n",
        "# Show the reshaped principal components\n",
        "f, ax = plt.subplots(1,2)\n",
        "ax[0].imshow(comp_nn[0], cmap='gray')\n",
        "ax[0].set_xlabel('First Dimension')\n",
        "\n",
        "ax[1].imshow(comp_nn[1], cmap='gray')\n",
        "ax[1].set_xlabel('Second Dimension')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-iQfZsX6ani"
      },
      "source": [
        "Now, visualize the images rebuilt by the network !\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "E2_q-lhm6ani",
        "outputId": "e034d0ff-bdb8-4d1d-fabc-0f3c6f26ffdc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 2s 5ms/step\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Select a few images at random: look from n\n",
        "n = np.random.randint(0,len(test_images)-5)\n",
        "\n",
        "# Plot a few images from n\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "    ax[i].imshow(X_test[a].reshape(img_rows, img_cols), cmap = 'gray')\n",
        "\n",
        "# Get the prediction from the model\n",
        "X_pred = ae_model.predict(X_test)\n",
        "\n",
        "# ... and plot them\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "    ax[i].imshow(X_pred[a].reshape(img_rows, img_cols), cmap = 'gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vF3zp_H6anj"
      },
      "source": [
        "Do the same ( = build a new model) with a latent dimension that is largely higher than 2. Compare the visualizations and the images that are rebuilt.\n",
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z2jUIEy4saUr"
      },
      "source": [
        "As expected the visualization becomes better when we have used dimensions more than two.\n",
        "Using higher-dimensional latent spaces in autoencoders improves representation by capturing richer, more nuanced features, avoiding information loss, and modeling non-linear relationships, leading to better data reconstruction and visualization."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "deDBt51-lc0J",
        "outputId": "21583667-8880-4be7-a384-9b22eb2ca3db"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"ae_model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_layer (InputLayer)    [(None, 784)]             0         \n",
            "                                                                 \n",
            " latent_view (Dense)         (None, 256)               200960    \n",
            "                                                                 \n",
            " output_layer (Dense)        (None, 784)               201488    \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 402448 (1.54 MB)\n",
            "Trainable params: 402448 (1.54 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Input layer\n",
        "input_layer = Input(shape=(784,), name='input_layer')\n",
        "\n",
        "# Encoding layer\n",
        "latent_view = Dense(256, activation='linear', name='latent_view')(input_layer)\n",
        "\n",
        "# Decoding layer\n",
        "output_layer = Dense(784, activation='sigmoid', name='output_layer')(latent_view)\n",
        "\n",
        "ae_model = Model(input_layer, output_layer, name='ae_model')\n",
        "ae_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qgLPoS4um26q",
        "outputId": "980d6713-b0d2-4cb1-9729-35c3c6fe7a8a"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.SGD.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "469/469 [==============================] - 6s 13ms/step - loss: 0.9960 - val_loss: 0.9942\n",
            "Epoch 2/10\n",
            "469/469 [==============================] - 5s 10ms/step - loss: 0.9922 - val_loss: 0.9904\n",
            "Epoch 3/10\n",
            "469/469 [==============================] - 5s 12ms/step - loss: 0.9884 - val_loss: 0.9866\n",
            "Epoch 4/10\n",
            "469/469 [==============================] - 4s 9ms/step - loss: 0.9847 - val_loss: 0.9829\n",
            "Epoch 5/10\n",
            "469/469 [==============================] - 4s 9ms/step - loss: 0.9810 - val_loss: 0.9793\n",
            "Epoch 6/10\n",
            "469/469 [==============================] - 6s 12ms/step - loss: 0.9774 - val_loss: 0.9757\n",
            "Epoch 7/10\n",
            "469/469 [==============================] - 4s 9ms/step - loss: 0.9739 - val_loss: 0.9721\n",
            "Epoch 8/10\n",
            "469/469 [==============================] - 5s 10ms/step - loss: 0.9703 - val_loss: 0.9686\n",
            "Epoch 9/10\n",
            "469/469 [==============================] - 5s 11ms/step - loss: 0.9668 - val_loss: 0.9651\n",
            "Epoch 10/10\n",
            "469/469 [==============================] - 4s 9ms/step - loss: 0.9634 - val_loss: 0.9616\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.losses import MSE\n",
        "\n",
        "loss = MSE\n",
        "\n",
        "optimizer = SGD(lr=0.01)\n",
        "ae_model.compile(optimizer=optimizer, loss=loss)\n",
        "\n",
        "batch_size = 128\n",
        "epochs = 10\n",
        "# No noise here - we want to train a simple auto-encoder and compare visually with PCA\n",
        "history = ae_model.fit(X_train,\n",
        "                       X_train,\n",
        "                       epochs=epochs,\n",
        "                       batch_size=batch_size,\n",
        "                       verbose=1,\n",
        "                       shuffle=True,\n",
        "                       validation_data=(X_test, X_test))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 338
        },
        "id": "2tkAh9dfm59T",
        "outputId": "bb5af59e-7cff-45f6-c09a-1b6eac310c3f"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:5 out of the last 943 calls to <function Model.make_predict_function.<locals>.predict_function at 0x788831798700> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1/1 [==============================] - 0s 58ms/step\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Select a few images at random: look from n\n",
        "n = np.random.randint(0,len(test_images)-5)\n",
        "\n",
        "# Plot a few images from n\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "    ax[i].imshow(test_images[a].reshape(28,28), cmap='gray')\n",
        "\n",
        "# Get the prediction from the model\n",
        "pred = ae_model.predict(X_test[n:n+5])\n",
        "\n",
        "# ... and plot them\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "    ax[i].imshow(pred[i].reshape(28,28))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kg4_B-8O6ank"
      },
      "source": [
        "### Bonus: De-noising Autoencoder\n",
        "\n",
        "Now, we can implement a **de-noising autoencoder**. The following function will transform an array of images by adding it random noise. Create a new autoencoder model, this time with **more layers** and **non-linear activations** (like the ReLU) and train it to rebuild the de-noised images. Display some testing images, with noise, and re-built."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {
        "id": "R6i3NPm56ank"
      },
      "outputs": [],
      "source": [
        "def noise(array):\n",
        "    \"\"\"\n",
        "    Adds random noise to each image in the supplied array.\n",
        "    \"\"\"\n",
        "    noise_factor = 0.4\n",
        "    noisy_array = array + noise_factor * np.random.normal(\n",
        "        loc=0.0, scale=1.0, size=array.shape\n",
        "    )\n",
        "    return noisy_array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {
        "id": "HOhIrJP36anl"
      },
      "outputs": [],
      "source": [
        "# Create a copy of the data with added noise\n",
        "noisy_train_images = noise(train_images)\n",
        "noisy_test_images = noise(test_images)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "09OPmC7S6anl"
      },
      "source": [
        "<div class='alert alert-block alert-info'>\n",
        "            Code:</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "KL2zkf4Xk7ji",
        "outputId": "09165b10-a23b-4997-b37f-b42cb0e06d50"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"ae_model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_10 (InputLayer)       [(None, 784)]             0         \n",
            "                                                                 \n",
            " dense_22 (Dense)            (None, 50)                39250     \n",
            "                                                                 \n",
            " dense_23 (Dense)            (None, 10)                510       \n",
            "                                                                 \n",
            " dense_24 (Dense)            (None, 50)                550       \n",
            "                                                                 \n",
            " dense_25 (Dense)            (None, 784)               39984     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 80294 (313.65 KB)\n",
            "Trainable params: 80294 (313.65 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "Epoch 1/10\n",
            "469/469 [==============================] - 5s 10ms/step - loss: 0.6466 - val_loss: 0.5980\n",
            "Epoch 2/10\n",
            "469/469 [==============================] - 3s 7ms/step - loss: 0.5878 - val_loss: 0.5806\n",
            "Epoch 3/10\n",
            "469/469 [==============================] - 3s 7ms/step - loss: 0.5702 - val_loss: 0.5852\n",
            "Epoch 4/10\n",
            "469/469 [==============================] - 3s 6ms/step - loss: 0.5803 - val_loss: 0.5857\n",
            "Epoch 5/10\n",
            "469/469 [==============================] - 4s 8ms/step - loss: 0.5776 - val_loss: 0.5993\n",
            "Epoch 6/10\n",
            "469/469 [==============================] - 3s 7ms/step - loss: 0.5690 - val_loss: 0.5728\n",
            "Epoch 7/10\n",
            "469/469 [==============================] - 3s 7ms/step - loss: 0.5717 - val_loss: 0.5890\n",
            "Epoch 8/10\n",
            "469/469 [==============================] - 4s 8ms/step - loss: 0.5682 - val_loss: 0.5834\n",
            "Epoch 9/10\n",
            "469/469 [==============================] - 4s 9ms/step - loss: 0.5679 - val_loss: 0.5766\n",
            "Epoch 10/10\n",
            "469/469 [==============================] - 4s 8ms/step - loss: 0.5616 - val_loss: 0.5728\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:6 out of the last 944 calls to <function Model.make_predict_function.<locals>.predict_function at 0x7888318a0ca0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 1s 3ms/step\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize some of the images with noise against the originals\n",
        "from tensorflow.keras import optimizers\n",
        "\n",
        "n = np.random.randint(0,len(test_images)-5)\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "  ax[i].imshow(X_train[a].reshape(img_rows, img_cols))\n",
        "\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "  ax[i].imshow(noisy_train_images[a].reshape(img_rows, img_cols), cmap = 'gray')\n",
        "\n",
        "# Build a new model with more layers and Relu activations\n",
        "\n",
        "input_layer = Input(img_rows*img_cols)\n",
        "\n",
        "latent_view_1 = Dense(50, activation='relu')(input_layer)\n",
        "latent_view_2 = Dense(10, activation='relu')(latent_view_1)\n",
        "latent_view_3 = Dense(50, activation='relu')(latent_view_2)\n",
        "\n",
        "output_layer = Dense(img_rows*img_cols)(latent_view_3)\n",
        "\n",
        "ae_model = Model(input_layer, output_layer, name='ae_model')\n",
        "ae_model.summary()\n",
        "\n",
        "# Compile it but here, use noised data as inputs !\n",
        "\n",
        "loss = MeanSquaredError()\n",
        "\n",
        "optimizer = optimizers.Adam(learning_rate=0.01)\n",
        "ae_model.compile(optimizer=optimizer, loss=loss)\n",
        "\n",
        "batch_size = 128\n",
        "epochs = 10\n",
        "# No noise here - we want to train a simple auto-encoder and compare visually with PCA\n",
        "history = ae_model.fit(X_train,\n",
        "                       X_train,\n",
        "                       epochs=epochs,\n",
        "                       batch_size=batch_size,\n",
        "                       verbose=1,\n",
        "                       shuffle=True,\n",
        "                       validation_data=(X_test, X_test))\n",
        "\n",
        "# Visualize the images rebuilt by the model !\n",
        "\n",
        "# Select a few images at random: look from n\n",
        "n = np.random.randint(0,len(test_images)-5)\n",
        "\n",
        "# Plot a few images from n\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "  ax[i].imshow(X_test[a].reshape(img_rows, img_cols), cmap = 'gray')\n",
        "\n",
        "# Get the prediction from the model\n",
        "\n",
        "X_pred = ae_model.predict(X_test)\n",
        "\n",
        "# ... and plot them\n",
        "f, ax = plt.subplots(1,5)\n",
        "for i,a in enumerate(range(n,n+5)):\n",
        "  ax[i].imshow(X_pred[a].reshape(img_rows, img_cols), cmap = 'gray')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qlvpuaVL6anm"
      },
      "source": [
        "Assuming that we normalize the images to be in the 0-1 range, what other loss function could we use ?\n",
        "<div class='alert alert-block alert-warning'>\n",
        "            Answer:</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tTlxgaZVrxC3"
      },
      "source": [
        "When images are normalized to the 0-1 range, they are typically treated as probability distributions, where each pixel value represents the probability of observing a certain intensity level. In this context, Maximum Likelihood Estimation (MLE) becomes a natural choice for training autoencoders because it aims to maximize the likelihood of generating observed data under a given probabilistic model."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.16"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}