Copy_of_NLP_Course_Week_3_Exercise_Question.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Copy of NLP Course - Week 3 Exercise Question.ipynb",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RhuthuHegde/Tensorflow-coursera/blob/master/Copy_of_NLP_Course_Week_3_Exercise_Question.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zX4Kg8DUTKWO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "hmA6EzkQJ5jt",
        "colab": {}
      },
      "source": [
        "import json\n",
        "import tensorflow as tf\n",
        "import csv\n",
        "import random\n",
        "import numpy as np\n",
        "\n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from tensorflow.keras import regularizers\n",
        "\n",
        "\n",
        "embedding_dim = 100\n",
        "max_length = 16\n",
        "trunc_type='post'\n",
        "padding_type='post'\n",
        "oov_tok = \"<OOV>\"\n",
        "training_size= 160000#Your dataset size here. Experiment using smaller values (i.e. 16000), but don't forget to train on at least 160000 to see the best effects\n",
        "test_portion=.1\n",
        "\n",
        "corpus = []\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "bM0l_dORKqE0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "0cba125d-9d57-4ec5-9ef6-36e9c48d400b"
      },
      "source": [
        "# Note that I cleaned the Stanford dataset to remove LATIN1 encoding to make it easier for Python CSV reader\n",
        "# You can do that yourself with:\n",
        "# iconv -f LATIN1 -t UTF8 training.1600000.processed.noemoticon.csv -o training_cleaned.csv\n",
        "# I then hosted it on my site to make it easier to use in this notebook\n",
        "\n",
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/training_cleaned.csv \\\n",
        "    -O /tmp/training_cleaned.csv\n",
        "\n",
        "num_sentences = 0\n",
        "\n",
        "with open(\"/tmp/training_cleaned.csv\") as csvfile:\n",
        "    reader = csv.reader(csvfile, delimiter=',')\n",
        "    for row in reader:\n",
        "      # Your Code here. Create list items where the first item is the text, found in row[5], and the second is the label. Note that the label is a '0' or a '4' in the text. When it's the former, make\n",
        "      # your label to be 0, otherwise 1. Keep a count of the number of sentences in num_sentences\n",
        "        list_item=[]\n",
        "        # YOUR CODE HERE\n",
        "        list_item.append(row[5])\n",
        "        label=row[0]\n",
        "        if label=='0':\n",
        "          list_item.append(0)\n",
        "        else:\n",
        "          list_item.append(1)\n",
        "        num_sentences = num_sentences + 1\n",
        "        corpus.append(list_item)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-08-04 06:32:42--  https://storage.googleapis.com/laurencemoroney-blog.appspot.com/training_cleaned.csv\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.204.128, 64.233.187.128, 108.177.97.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.204.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 238942690 (228M) [application/octet-stream]\n",
            "Saving to: ‘/tmp/training_cleaned.csv’\n",
            "\n",
            "/tmp/training_clean 100%[===================>] 227.87M  39.1MB/s    in 5.8s    \n",
            "\n",
            "2020-08-04 06:32:48 (39.1 MB/s) - ‘/tmp/training_cleaned.csv’ saved [238942690/238942690]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3kxblBUjEUX-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "25476ab4-7644-48cc-9c33-6c2b036c5ecf"
      },
      "source": [
        "print(num_sentences)\n",
        "print(len(corpus))\n",
        "print(corpus[1])\n",
        "\n",
        "# Expected Output:\n",
        "# 1600000\n",
        "# 1600000\n",
        "# [\"is upset that he can't update his Facebook by texting it... and might cry as a result  School today also. Blah!\", 0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1600000\n",
            "1600000\n",
            "[\"is upset that he can't update his Facebook by texting it... and might cry as a result  School today also. Blah!\", 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ohOGz24lsNAD",
        "colab": {}
      },
      "source": [
        "sentences=[]\n",
        "labels=[]\n",
        "random.shuffle(corpus)\n",
        "for x in range(training_size):\n",
        "    sentences.append(corpus[x][0])\n",
        "    labels.append(corpus[x][1])\n",
        "\n",
        "\n",
        "tokenizer = Tokenizer()\n",
        "tokenizer.fit_on_texts(sentences)\n",
        "\n",
        "word_index = tokenizer.word_index\n",
        "vocab_size=len(word_index)\n",
        "\n",
        "sequences = tokenizer.texts_to_sequences(sentences)\n",
        "padded = pad_sequences(sequences,maxlen=max_length,padding=padding_type,truncating=trunc_type)\n",
        "\n",
        "split = int(test_portion * training_size)\n",
        "\n",
        "test_sequences = padded[split:training_size]\n",
        "training_sequences = padded[0:split]\n",
        "test_labels = labels[split:training_size]\n",
        "training_labels = labels[0:split]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gIrtRem1En3N",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "1c4a4bdc-2f52-4a4b-efff-fe52f9a7e9d4"
      },
      "source": [
        "print(vocab_size)\n",
        "print(word_index['i'])\n",
        "# Expected Output\n",
        "# 138858\n",
        "# 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "138338\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "C1zdgJkusRh0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "c98d580c-57f4-419d-a761-1bb22d664e1c"
      },
      "source": [
        "# Note this is the 100 dimension version of GloVe from Stanford\n",
        "# I unzipped and hosted it on my site to make this notebook easier\n",
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/glove.6B.100d.txt \\\n",
        "    -O /tmp/glove.6B.100d.txt\n",
        "embeddings_index = {};\n",
        "with open('/tmp/glove.6B.100d.txt') as f:\n",
        "    for line in f:\n",
        "        values = line.split();\n",
        "        word = values[0];\n",
        "        coefs = np.asarray(values[1:], dtype='float32');\n",
        "        embeddings_index[word] = coefs;\n",
        "\n",
        "embeddings_matrix = np.zeros((vocab_size+1, embedding_dim));\n",
        "for word, i in word_index.items():\n",
        "    embedding_vector = embeddings_index.get(word);\n",
        "    if embedding_vector is not None:\n",
        "        embeddings_matrix[i] = embedding_vector;"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-08-04 06:39:43--  https://storage.googleapis.com/laurencemoroney-blog.appspot.com/glove.6B.100d.txt\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 108.177.97.128, 74.125.203.128, 74.125.204.128, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|108.177.97.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 347116733 (331M) [text/plain]\n",
            "Saving to: ‘/tmp/glove.6B.100d.txt’\n",
            "\n",
            "/tmp/glove.6B.100d. 100%[===================>] 331.04M  46.3MB/s    in 8.4s    \n",
            "\n",
            "2020-08-04 06:39:52 (39.6 MB/s) - ‘/tmp/glove.6B.100d.txt’ saved [347116733/347116733]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "71NLk_lpFLNt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fafb7d64-d3b1-4e36-da55-20e6fcf2df28"
      },
      "source": [
        "print(len(embeddings_matrix))\n",
        "# Expected Output\n",
        "# 138859"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "138339\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "iKKvbuEBOGFz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "a035ae4e-ae2c-4211-ff6a-7695fe7b00fa"
      },
      "source": [
        "model = tf.keras.Sequential([\n",
        "    tf.keras.layers.Embedding(vocab_size+1, embedding_dim, input_length=max_length, weights=[embeddings_matrix], trainable=False),\n",
        "    tf.keras.layers.Conv1D(64,kernel_size=5,activation='relu'),\n",
        "    tf.keras.layers.LSTM(64),\n",
        "    tf.keras.layers.Dense(64,activation='relu'),\n",
        "    tf.keras.layers.Dense(1,activation='sigmoid')\n",
        "\n",
        "\n",
        "    # YOUR CODE HERE - experiment with combining different types, such as convolutions and LSTMs\n",
        "])\n",
        "model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])\n",
        "model.summary()\n",
        "\n",
        "num_epochs = 50\n",
        "\n",
        "training_sequences=np.array(training_sequences)\n",
        "training_labels=np.array(training_labels)\n",
        "test_sequences=np.array(test_sequences)\n",
        "test_labels=np.array(test_labels)\n",
        "\n",
        "history = model.fit(training_sequences, training_labels, epochs=num_epochs, validation_data=(test_sequences, test_labels), verbose=2)\n",
        "\n",
        "print(\"Training Complete\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_2 (Embedding)      (None, 16, 100)           13833900  \n",
            "_________________________________________________________________\n",
            "conv1d_2 (Conv1D)            (None, 12, 64)            32064     \n",
            "_________________________________________________________________\n",
            "lstm_2 (LSTM)                (None, 64)                33024     \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 64)                4160      \n",
            "_________________________________________________________________\n",
            "dense_4 (Dense)              (None, 1)                 65        \n",
            "=================================================================\n",
            "Total params: 13,903,213\n",
            "Trainable params: 69,313\n",
            "Non-trainable params: 13,833,900\n",
            "_________________________________________________________________\n",
            "Epoch 1/50\n",
            "500/500 - 16s - loss: 0.6289 - accuracy: 0.6386 - val_loss: 0.5809 - val_accuracy: 0.6995\n",
            "Epoch 2/50\n",
            "500/500 - 15s - loss: 0.5596 - accuracy: 0.7093 - val_loss: 0.5652 - val_accuracy: 0.7115\n",
            "Epoch 3/50\n",
            "500/500 - 15s - loss: 0.5190 - accuracy: 0.7401 - val_loss: 0.5569 - val_accuracy: 0.7090\n",
            "Epoch 4/50\n",
            "500/500 - 15s - loss: 0.4752 - accuracy: 0.7663 - val_loss: 0.5661 - val_accuracy: 0.7126\n",
            "Epoch 5/50\n",
            "500/500 - 15s - loss: 0.4257 - accuracy: 0.7988 - val_loss: 0.5984 - val_accuracy: 0.7005\n",
            "Epoch 6/50\n",
            "500/500 - 15s - loss: 0.3710 - accuracy: 0.8327 - val_loss: 0.6500 - val_accuracy: 0.7015\n",
            "Epoch 7/50\n",
            "500/500 - 15s - loss: 0.3205 - accuracy: 0.8591 - val_loss: 0.7602 - val_accuracy: 0.6911\n",
            "Epoch 8/50\n",
            "500/500 - 16s - loss: 0.2784 - accuracy: 0.8815 - val_loss: 0.7347 - val_accuracy: 0.6928\n",
            "Epoch 9/50\n",
            "500/500 - 15s - loss: 0.2360 - accuracy: 0.9024 - val_loss: 0.8336 - val_accuracy: 0.6951\n",
            "Epoch 10/50\n",
            "500/500 - 15s - loss: 0.2020 - accuracy: 0.9183 - val_loss: 0.9110 - val_accuracy: 0.6879\n",
            "Epoch 11/50\n",
            "500/500 - 16s - loss: 0.1786 - accuracy: 0.9298 - val_loss: 0.9420 - val_accuracy: 0.6836\n",
            "Epoch 12/50\n",
            "500/500 - 15s - loss: 0.1502 - accuracy: 0.9419 - val_loss: 1.1485 - val_accuracy: 0.6760\n",
            "Epoch 13/50\n",
            "500/500 - 15s - loss: 0.1355 - accuracy: 0.9473 - val_loss: 1.0244 - val_accuracy: 0.6836\n",
            "Epoch 14/50\n",
            "500/500 - 15s - loss: 0.1155 - accuracy: 0.9559 - val_loss: 1.2006 - val_accuracy: 0.6833\n",
            "Epoch 15/50\n",
            "500/500 - 15s - loss: 0.1094 - accuracy: 0.9574 - val_loss: 1.1968 - val_accuracy: 0.6871\n",
            "Epoch 16/50\n",
            "500/500 - 15s - loss: 0.0922 - accuracy: 0.9659 - val_loss: 1.3746 - val_accuracy: 0.6830\n",
            "Epoch 17/50\n",
            "500/500 - 15s - loss: 0.0845 - accuracy: 0.9704 - val_loss: 1.4111 - val_accuracy: 0.6817\n",
            "Epoch 18/50\n",
            "500/500 - 15s - loss: 0.0781 - accuracy: 0.9711 - val_loss: 1.6172 - val_accuracy: 0.6872\n",
            "Epoch 19/50\n",
            "500/500 - 15s - loss: 0.0692 - accuracy: 0.9749 - val_loss: 1.6491 - val_accuracy: 0.6882\n",
            "Epoch 20/50\n",
            "500/500 - 15s - loss: 0.0667 - accuracy: 0.9743 - val_loss: 1.7761 - val_accuracy: 0.6703\n",
            "Epoch 21/50\n",
            "500/500 - 15s - loss: 0.0698 - accuracy: 0.9735 - val_loss: 1.5550 - val_accuracy: 0.6696\n",
            "Epoch 22/50\n",
            "500/500 - 15s - loss: 0.0626 - accuracy: 0.9764 - val_loss: 1.6563 - val_accuracy: 0.6777\n",
            "Epoch 23/50\n",
            "500/500 - 15s - loss: 0.0565 - accuracy: 0.9793 - val_loss: 1.8765 - val_accuracy: 0.6832\n",
            "Epoch 24/50\n",
            "500/500 - 15s - loss: 0.0578 - accuracy: 0.9781 - val_loss: 1.8282 - val_accuracy: 0.6832\n",
            "Epoch 25/50\n",
            "500/500 - 15s - loss: 0.0582 - accuracy: 0.9788 - val_loss: 1.4647 - val_accuracy: 0.6781\n",
            "Epoch 26/50\n",
            "500/500 - 15s - loss: 0.0472 - accuracy: 0.9830 - val_loss: 1.8739 - val_accuracy: 0.6763\n",
            "Epoch 27/50\n",
            "500/500 - 15s - loss: 0.0470 - accuracy: 0.9833 - val_loss: 1.9677 - val_accuracy: 0.6872\n",
            "Epoch 28/50\n",
            "500/500 - 16s - loss: 0.0534 - accuracy: 0.9808 - val_loss: 1.9521 - val_accuracy: 0.6845\n",
            "Epoch 29/50\n",
            "500/500 - 15s - loss: 0.0487 - accuracy: 0.9822 - val_loss: 1.8276 - val_accuracy: 0.6852\n",
            "Epoch 30/50\n",
            "500/500 - 15s - loss: 0.0415 - accuracy: 0.9838 - val_loss: 1.8980 - val_accuracy: 0.6842\n",
            "Epoch 31/50\n",
            "500/500 - 15s - loss: 0.0432 - accuracy: 0.9838 - val_loss: 1.8703 - val_accuracy: 0.6767\n",
            "Epoch 32/50\n",
            "500/500 - 16s - loss: 0.0406 - accuracy: 0.9849 - val_loss: 1.9224 - val_accuracy: 0.6766\n",
            "Epoch 33/50\n",
            "500/500 - 15s - loss: 0.0347 - accuracy: 0.9867 - val_loss: 2.2821 - val_accuracy: 0.6799\n",
            "Epoch 34/50\n",
            "500/500 - 15s - loss: 0.0427 - accuracy: 0.9837 - val_loss: 1.9411 - val_accuracy: 0.6836\n",
            "Epoch 35/50\n",
            "500/500 - 15s - loss: 0.0351 - accuracy: 0.9870 - val_loss: 2.2292 - val_accuracy: 0.6896\n",
            "Epoch 36/50\n",
            "500/500 - 15s - loss: 0.0368 - accuracy: 0.9870 - val_loss: 2.2968 - val_accuracy: 0.6800\n",
            "Epoch 37/50\n",
            "500/500 - 15s - loss: 0.0332 - accuracy: 0.9879 - val_loss: 1.8972 - val_accuracy: 0.6741\n",
            "Epoch 38/50\n",
            "500/500 - 15s - loss: 0.0437 - accuracy: 0.9832 - val_loss: 1.9506 - val_accuracy: 0.6801\n",
            "Epoch 39/50\n",
            "500/500 - 15s - loss: 0.0301 - accuracy: 0.9884 - val_loss: 2.1358 - val_accuracy: 0.6809\n",
            "Epoch 40/50\n",
            "500/500 - 15s - loss: 0.0285 - accuracy: 0.9896 - val_loss: 2.3000 - val_accuracy: 0.6804\n",
            "Epoch 41/50\n",
            "500/500 - 15s - loss: 0.0372 - accuracy: 0.9862 - val_loss: 2.0206 - val_accuracy: 0.6795\n",
            "Epoch 42/50\n",
            "500/500 - 15s - loss: 0.0285 - accuracy: 0.9894 - val_loss: 2.2214 - val_accuracy: 0.6852\n",
            "Epoch 43/50\n",
            "500/500 - 15s - loss: 0.0274 - accuracy: 0.9900 - val_loss: 2.2889 - val_accuracy: 0.6836\n",
            "Epoch 44/50\n",
            "500/500 - 15s - loss: 0.0301 - accuracy: 0.9881 - val_loss: 1.9178 - val_accuracy: 0.6849\n",
            "Epoch 45/50\n",
            "500/500 - 15s - loss: 0.0405 - accuracy: 0.9841 - val_loss: 2.1599 - val_accuracy: 0.6831\n",
            "Epoch 46/50\n",
            "500/500 - 15s - loss: 0.0339 - accuracy: 0.9872 - val_loss: 2.0490 - val_accuracy: 0.6836\n",
            "Epoch 47/50\n",
            "500/500 - 15s - loss: 0.0245 - accuracy: 0.9914 - val_loss: 2.2080 - val_accuracy: 0.6846\n",
            "Epoch 48/50\n",
            "500/500 - 15s - loss: 0.0280 - accuracy: 0.9892 - val_loss: 1.9656 - val_accuracy: 0.6779\n",
            "Epoch 49/50\n",
            "500/500 - 15s - loss: 0.0328 - accuracy: 0.9879 - val_loss: 2.1367 - val_accuracy: 0.6838\n",
            "Epoch 50/50\n",
            "500/500 - 15s - loss: 0.0254 - accuracy: 0.9903 - val_loss: 2.1045 - val_accuracy: 0.6852\n",
            "Training Complete\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "qxju4ItJKO8F",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 607
        },
        "outputId": "fa1c759d-766e-485d-8332-b9b039cdb8af"
      },
      "source": [
        "import matplotlib.image  as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\n",
        "acc=history.history['accuracy']\n",
        "val_acc=history.history['val_accuracy']\n",
        "loss=history.history['loss']\n",
        "val_loss=history.history['val_loss']\n",
        "\n",
        "epochs=range(len(acc)) # Get number of epochs\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation accuracy per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, acc, 'r')\n",
        "plt.plot(epochs, val_acc, 'b')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.legend([\"Accuracy\", \"Validation Accuracy\"])\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation loss per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, loss, 'r')\n",
        "plt.plot(epochs, val_loss, 'b')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend([\"Loss\", \"Validation Loss\"])\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "\n",
        "# Expected Output\n",
        "# A chart where the validation loss does not increase sharply!"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3hUZfbA8e8BQq8CIk2KiizSEpqKSrEiCCuoK8oi665t7fqz7aqgq66uZRErq9gWBFFcVgEVERRdRSFIV1SkF4lI7yTn98eZMZOQSSbJTCaTOZ/nuc/M3Llz570TuOe+5Z5XVBXnnHPJq1y8C+Cccy6+PBA451yS80DgnHNJzgOBc84lOQ8EzjmX5DwQOOdckvNA4KJKRN4TkcuivW08icgqETkjBvtVETk28Px5Ebknkm2L8D2Xisj0opYzn/32FJF10d6vK3kV4l0AF38isivkZVVgP5AZeH2Vqo6LdF+q2icW25Z1qnp1NPYjIs2BlUCKqh4K7HscEPHf0CUfDwQOVa0efC4iq4A/qeqM3NuJSIXgycU5V3Z405ALK1j1F5E7RGQT8LKI1BGRKSKSISJbA8+bhHzmYxH5U+D5MBH5TEQeC2y7UkT6FHHbFiIyW0R2isgMEXlGRMaGKXckZfybiPwvsL/pIlIv5P3fi8hqEdkiIn/N5/fpJiKbRKR8yLrzRWRR4HlXEflCRLaJyEYReVpEKobZ1ysi8kDI69sCn9kgIpfn2raviHwtIjtEZK2IjAh5e3bgcZuI7BKRk4K/bcjnTxaRuSKyPfB4cqS/TX5E5DeBz28TkaUi0j/kvXNFZFlgn+tF5P8C6+sF/j7bROQXEflURPy8VML8B3cFOQo4AmgGXIn9m3k58PpoYC/wdD6f7wYsB+oB/wDGiIgUYdvXga+AusAI4Pf5fGckZbwE+ANwJFARCJ6Y2gDPBfbfKPB9TciDqn4J7AZ659rv64HnmcDNgeM5CTgd+HM+5SZQhnMC5TkTOA7I3T+xGxgK1Ab6AteIyG8D750WeKytqtVV9Ytc+z4CmAqMChzbE8BUEamb6xgO+20KKHMK8C4wPfC564FxInJ8YJMxWDNjDaAtMDOw/lZgHVAfaAD8BfC8NyXMA4ErSBYwXFX3q+peVd2iqpNUdY+q7gQeBHrk8/nVqvqCqmYCrwINsf/wEW8rIkcDXYB7VfWAqn4GvBPuCyMs48uq+p2q7gUmAh0D6y8ApqjqbFXdD9wT+A3CGQ8MBhCRGsC5gXWoarqqzlHVQ6q6ChidRznyclGgfEtUdTcW+EKP72NVXayqWaq6KPB9kewXLHB8r6r/DpRrPPAtcF7INuF+m/ycCFQHHg78jWYCUwj8NsBBoI2I1FTVrao6P2R9Q6CZqh5U1U/VE6CVOA8EriAZqrov+EJEqorI6EDTyQ6sKaJ2aPNILpuCT1R1T+Bp9UJu2wj4JWQdwNpwBY6wjJtCnu8JKVOj0H0HTsRbwn0XdvU/UEQqAQOB+aq6OlCOVoFmj02BcjyE1Q4KkqMMwOpcx9dNRGYFmr62A1dHuN/gvlfnWrcaaBzyOtxvU2CZVTU0aIbudxAWJFeLyCciclJg/aPAD8B0EflRRO6M7DBcNHkgcAXJfXV2K3A80E1Va5LdFBGuuScaNgJHiEjVkHVN89m+OGXcGLrvwHfWDbexqi7DTnh9yNksBNbE9C1wXKAcfylKGbDmrVCvYzWipqpaC3g+ZL8FXU1vwJrMQh0NrI+gXAXtt2mu9v1f96uqc1V1ANZsNBmraaCqO1X1VlVtCfQHbhGR04tZFldIHghcYdXA2ty3Bdqbh8f6CwNX2POAESJSMXA1eV4+HylOGd8C+onIKYGO3fsp+P/J68CNWMB5M1c5dgC7RKQ1cE2EZZgIDBORNoFAlLv8NbAa0j4R6YoFoKAMrCmrZZh9TwNaicglIlJBRH4HtMGacYrjS6z2cLuIpIhIT+xvNCHwN7tURGqp6kHsN8kCEJF+InJsoC9oO9avkl9TnIsBDwSusEYCVYCfgTnA+yX0vZdiHa5bgAeAN7D7HfJS5DKq6lLgWuzkvhHYinVm5ifYRj9TVX8OWf9/2El6J/BCoMyRlOG9wDHMxJpNZuba5M/A/SKyE7iXwNV14LN7sD6R/wVG4pyYa99bgH5YrWkLcDvQL1e5C01VD2An/j7Y7/4sMFRVvw1s8ntgVaCJ7Grs7wnWGT4D2AV8ATyrqrOKUxZXeOL9Mi4RicgbwLeqGvMaiXNlndcIXEIQkS4icoyIlAsMrxyAtTU754rJ7yx2ieIo4G2s43YdcI2qfh3fIjlXNnjTkHPOJTlvGnLOuSSXcE1D9erV0+bNm8e7GM45l1DS09N/VtX6eb2XcIGgefPmzJs3L97FcM65hCIiue8o/5U3DTnnXJLzQOCcc0nOA4FzziW5hOsjyMvBgwdZt24d+/btK3hjV2pUrlyZJk2akJKSEu+iOJfUykQgWLduHTVq1KB58+aEn/PElSaqypYtW1i3bh0tWrSId3GcS2plomlo37591K1b14NAAhER6tat67U450qBMhEIAA8CCcj/Zs6VDmUmEDjn4m/LFtgfLjl4FKjCq6/Cz8VKmu1y80AQJdWrRzKbn3Nl17Rp0KQJjBgRu+/46CMYNgxGjSr+vlasgPHji7+fssADgXNJbswYOPfc4u3jzTdhwADYtw8+/zw65crLk0/a46xiTl3z9ddw0klwySWwOuz9tsnDA0EMLViwgBNPPJH27dtz/vnns3XrVgBGjRpFmzZtaN++PRdffDEAn3zyCR07dqRjx46kpqayc+fOeBbdJZGJE+G992DDhqJ9/uWX4eKLoVs3GDwYFi2yJpxo+/57mDIF6tSBL7+E3buLtp/PP4devSxogQWFZFcmho/mcNNNsGBBdPfZsSOMHFnojw0dOpSnnnqKHj16cO+993LfffcxcuRIHn74YVauXEmlSpXYtm0bAI899hjPPPMM3bt3Z9euXVSuXDm6x+BcHlQhPd2ez51rV/WFMWoU3HgjnHUWvP02vPaaNbesWwdNm0a3rE89BSkp8M9/WvPQ//5n31sYM2bYMTZuDO+8AyecAPPnw29/G92yJhqvEcTI9u3b2bZtGz169ADgsssuY/bs2QC0b9+eSy+9lLFjx1KhgsXi7t27c8sttzBq1Ci2bdv263rnYmnNGuvgBfjqq8g/pwoPPmhB4Pzz7aRarRq0b2/vL1oU3XJu3241j8GDYdAgqFABZuaeybkAkydD375wzDHw6afQurUtXiMoizWCIly5l7SpU6cye/Zs3n33XR588EEWL17MnXfeSd++fZk2bRrdu3fngw8+oHXr1vEuqivj5s+3xypVrEYQqb/8BR5+GIYMsRN08LqlbVt7XLTITrrR8tJLsGuXBZ7q1a0ZqjD9BGPHWi2ic2fr1D7iCFufmgoffxy9ciYqrxHESK1atahTpw6ffvopAP/+97/p0aMHWVlZrF27ll69evHII4+wfft2du3axYoVK2jXrh133HEHXbp04dtvv43zEbhkkJ4O5cvDBRdYIMjKKvgzCxdaEPjTn2woZ2jltVYtaNYMFi+OXhkzM61Z6NRTIS3N1vXqBfPmWU2hIOPGwdChcNpp8OGH2UEAbH/r18PmzdErbyLyQBAle/bsoUmTJr8uTzzxBK+++iq33XYb7du3Z8GCBdx7771kZmYyZMgQ2rVrR2pqKjfccAO1a9dm5MiRtG3blvbt25OSkkKfPn3ifUguCaSnQ5s20KMHbNsGP/xQ8GeCV+LDh0O5PM4g7dtHt2no3Xdh5UqrDQT17m1BK3CdFZYq3Htvdk2gRo2c76em2mOsmoeWLrXyl3Zlr2koTrLCXErNmTPnsHWfffbZYeueeuqpqJfJufwEO4r79oWuXW3d3LnQqlX+n/v4Y2tnb9Ik7/fbt7eT7v79UKlS8cv55JNWywjtyD7pJNv3zJnQr1/4z375Jfz4I9xzD+Q1/qJjR3v8+ms4++zilzWUKlx2GSxZYv0w1apFd//R5DUC55LUunWQkQGdOsFvfgNVqxbcYZyVBbNnWw0inPbtrTnnm2+KX8YFCyzwXHddziaoypXh5JML7icYN862HTgw7/fr1IEWLbL7SqJp9mwLtPv3F75ju6R5IHAuSQWHjXbqZCfZTp0KDgSLF8PWrdCzZ/htojlyaNQoC1B//OPh7/XqZYEiOOopt4MH4Y034LzzoGbN8N+RmhqbpqHHH4d69aw5asqU6O8/mjwQOJek0tOtjb9DB3vdtaudEA8cCP+ZTz6xx/xqBMcea802xe0w3rzZruiHDbMr99x6985ZptxmzLAaz6WX5v89qanWN7JjR8FlSk+P7Ea25cutb+Daa+HMM2Hq1NjcZBctHgicS1LBjuKqVe11ly7WjLFkSfjPfPyxNaUcfXT4bSpUsBu1ilsjGD3agtINN+T9fpcuVvZwzS5jx1oAKWjcRXAkUkH3oW7aZMNWL7ss/+3AbnqrVAn+/Gfrw1i/3kZblVYeCJxLQsGO4k6dstcFO4zDNQ8F+wfyaxYKKu7IoQMH4Nln7SR+/PF5b1Oxog0pzaufYNcuu4Hswgttu/xEOnLovfes72PSJNt3OBkZNqx26FA48sjsQDR1av77D/rySyt/SfJA4FwS2rDBml5CA0Hz5tamHS4QLF1q7fH5NQsFtW9vV9BFHZ//9tv2+dAho3np1QuWLbNtQ/33v7BnT8HNQgANG0KDBgUHgilTLDVFx452pR/IDnOY556zPEa33GKvjzrKai+R9BPMmAEnnmg1rr/8pej5nwrLA0EU9OrViw8++CDHupEjR3LNNdeE/UzPnj2ZN28eAOeee+6vOYdCjRgxgsceeyzf7548eTLLli379fW9997LjBkzClP8PH388cf0y29cnktowY7iYLMIgIidsMLdYRxJ/0BQsMO4qP0EL75ogenMM/PfLthPkPvu4HHjLNfRKadE9n1pafmPHNq/H6ZPt2aeF1+En36C228/fLu9e+Hpp21IbmhigL597Uo/IyP/cjz1FNSvbwHu4YftNxg2LPopO3LzQBAFgwcPZsKECTnWTZgwgcGDB0f0+WnTplG7du0ifXfuQHD//fdzxhlnFGlfLnkEO4qD4+iDuna1K/+8kt9+/LGN52/evOD9t2tnj0UJBCtX2rwDf/hD3jeshUpNtbuZQ/sJNm+2k/YllxT8+dD9LFuWnZE0t08/teaavn2tFnXrrfDCC4cHoLFj7WR/66051/frZ81x770XvgyrV1ut4YorrPnp++/hqqssxXeHDpZgL1bpMDwQRMEFF1zA1KlTORAYbrFq1So2bNjAqaeeyjXXXEPnzp054YQTGD58eJ6fb968OT8Hplx68MEHadWqFaeccgrLly//dZsXXniBLl260KFDBwYNGsSePXv4/PPPeeedd7jtttvo2LEjK1asYNiwYbz11lsAfPTRR6SmptKuXTsuv/xy9gemjmrevDnDhw8nLS2Ndu3aFSqdxfjx42nXrh1t27bljjvuACAzM5Nhw4bRtm1b2rVrxz//+U8g73TbrnRIT7cr1tw3OXXtaies3FfHqlYjiKR/AKxtvEGDol3Jvvyy1U6GDSt42woVLHVEaD/BxInWlh9Js1BQaqp9JlxH+ZQpdj/C6afb6xEj7Ka6K66wWgBYH8oTT9i+cv9OqanWRJRfP8Hzz9vjVVfZ4zHHWA1h7Vp46CEr2//+F/kxFUaZu7M4HlmojzjiCLp27cp7773HgAEDmDBhAhdddBEiwoMPPsgRRxxBZmYmp59+OosWLaJ9sN6cS3p6OhMmTGDBggUcOnSItLQ0OgUacQcOHMgVV1wBwN13382YMWO4/vrr6d+/P/369eOCCy7Isa99+/YxbNgwPvroI1q1asXQoUN57rnnuOmmmwCoV68e8+fP59lnn+Wxxx7jxRdfLPB32LBhA3fccQfp6enUqVOHs846i8mTJ9O0aVPWr1/PksD/omAzV17ptl3pkJ6ed7NLly72OHduziagZctseshImoWCitJhnJkJr7xiV7/5jUwK1bu3DdVcu9aag8aNs+8O1koiEWwimz/f0lGEUrVA0Lt39girqlWtRtC7twWFRx6xq/1vv7VaQe7puMuVs9rEm2/a/Q0pKTnf37fPmpz69z/8uI84Au66y/ocDh2K/JgKw2sEURLaPBTaLDRx4kTS0tJITU1l6dKlOZpxcvv00085//zzqVq1KjVr1qR///6/vrdkyRJOPfVU2rVrx7hx41i6dGm+5Vm+fDktWrSgVSBfQGgabLDAAtCpUydWrVoV0THOnTuXnj17Ur9+fSpUqMCll17K7NmzadmyJT/++CPXX38977//PjUDd+/klW7bxd+GDda5GtpRHFS/vjX95O4wDjZJRFojADsZL11auJPXjBl2Qs/rBrJwevWyx1mzbPrJOXMKVxsAGxJbq1beHcbffWf7zZ1NtVcvS7z3+OMWQB5/3NJuXHRR3t/Rt6/dq5DXVf2bb1qgvfba8GWsVCl2aSrK3P/OeGWhHjBgADfffDPz589nz549dOrUiZUrV/LYY48xd+5c6tSpw7Bhw9gXrhGyAMOGDWPy5Ml06NCBV155hY+L2VhYKZAEpnz58hwq5mVGnTp1WLhwIR988AHPP/88EydO5KWXXsoz3bYHhPgLvaM4L127WsdmqE8+savtSPoHgtq3tyvdH37I2XGanzFjoG5duzKOVLt29pmZM2HVKrsaj7B77lciVvPPKxAEm3PySqv96KNWWxg0yL77H/84/Go/6IwzbCjrlCmHB9RnnrFhssGmp5LmNYIoqV69Or169eLyyy//tTawY8cOqlWrRq1atfjpp594L7+eIuC0005j8uTJ7N27l507d/JuSNrCnTt30rBhQw4ePMi4ceN+XV+jRo08p7U8/vjjWbVqFT8E0kkG02AXR9euXfnkk0/4+eefyczMZPz48fTo0YOff/6ZrKwsBg0axAMPPMD8+fPDptt28Zeenn3iy0uXLtZxGRz6Gdo/kLvJIz+F7TD++Wcbnz9kSOGS1ZUrZ2WbORNef936DIoyO1pamt30lfu6aMoUm2ehWbPDP1O7tp3EV62yeRICrbd5qlHDmtZy9xOkp1vg/fOfC/f7RpMHgigaPHgwCxcu/DUQdOjQgdTUVFq3bs0ll1xC9+7d8/18Wloav/vd7+jQoQN9+vShS7DBFvjb3/5Gt27d6N69e44Jay6++GIeffRRUlNTWbFixa/rK1euzMsvv8yFF15Iu3btKFeuHFdffXWhjuejjz7KkVp71apVPPzww/Tq1YsOHTrQqVMnBgwYwPr16+nZsycdO3ZkyJAh/P3vfw+bbtvF3/z5doVevXre74dmIgVr9968uXDNQmCJ7MqXj7yfYOxYaz8vTLNQUO/e1qS0fHnhm4WCUlOtBhMyRoPt223EUH4jqQcOhLvvtruJC/on3q+f/Z4h/1V55hlr8onkjuWYUdWYLEBTYBawDFgK3JjHNgKMAn4AFgFpBe23U6dOmtuyZcsOW+cSg//tSl6jRqpDhoR/f+dO1XLlVO+9114/+6wqqP7wQ+G/q00b1f79C94uK0u1bVvVLl0K/x2qqsuWWRkrVlT95Zei7WPxYtvHv/+dvW7iRFv32WdF22duP/xg+3vySXv988+qlSurXnVVdPafH2CehjmvxrJGcAi4VVXbACcC14pIm1zb9AGOCyxXAs/FsDzOJb1Nm6yzOFz/AFhNoU2b7BrBJ59YJ2jLloX/vkhHDs2da8Mji1IbAKvhHH209S3klaAu0n1Urpxz6OyUKTZq58QTi7bP3I45xr4neJfxyy9bLSS/TuKSELNAoKobVXV+4PlO4Bugca7NBgCvBQLWHKC2iDSMVZmcS3YFdRQHde1qI4dUbcRQjx5Fa79u397azwvK7DlmjM2bXNTbTUTg889tCGZRVahg5Q12GGdm2pDQPn2siSta+vWz4Lp9u6WjOPXUwg11jYUS6SMQkeZAKpBrLAKNgbUhr9dxeLBARK4UkXkiMi8jzD3aWppzvLo8+d+s5BXUURzUtavlFXr/fUunUNj+gaDgCS6/jKa7d8P48ZYgrlaton0PWB6g4nwesucmULVaSkZG/v0DRdG3ryXVu+02mz0t3rUBKIFAICLVgUnATaoaQcbvw6nqv1S1s6p2rl+//mHvV65cmS1btviJJYGoKlu2bKFyXvMHuphJT7epKHPP3ZtbcJzCo4/aY1EHnEUySc2kSZbS4vLLi/Yd0ZSWZlfqK1da80358tGfwrJ7dwtYL7xgdxuff350918UMR3ULSIpWBAYp6pv57HJeqxTOahJYF2hNGnShHXr1hGutuBKp8qVK9Mk3MS3ZdSzz8KaNdbmfOKJdiIoSenpkZ3U27WzIZyzZkGjRjbZTFE0bWonvfwCwZgxtv/TTivad0RTaErqqVPtpF3UPodwUlIsuEycCFdeWXCa7JIQs0AgIgKMAb5R1SfCbPYOcJ2ITAC6AdtVdWNhvyslJYUWLVoUvbDOlYA337RmAJHs2aqaNcsOCv37F61DNlI//WQTpBTUPwB2skpLgy++KHr/ANjn8usw/v57m+PgoYfiN4Y+VLt2Vgt4911LVfPII7H5niFDLLHelVfGZv+FFcumoe7A74HeIrIgsJwrIleLSHBA+zTgR2z46AvAn2NYHufi5rvvbETMiSdaHvvPP7cEZd262fObb7YcN4HcgzERHA0TSSCA7OahovYPBLVvbzeV5W65XbPGJm8pXz7OY+hDVK5sI6bGjrXXscrEft559rdufFiPaHzErEagqp9h9wnkt40CpaCrxLnY2bvXOkJTUmwy9Zo14aSTbAlKT7egMHy43WAUC8ERQ8Hmj4KcfrqNailuVvN27WzU0Jo12XfnvvuunfwPHYIJE6z5qbRITbXA1aKF3RSXDPzOYudi7LrrrGlk7NjwGTU7dYJrrrFUxPmNsCmqAwcsoVurVhaIInHeebBxY/Gbq0I7jA8csFz9/ftb3qL58yFX4ty4CwbKvn1LR3NVSfBA4FwMvfIKvPQS/PWvBU+iPmKEdazedNPhzSjFsWKFzdT1ySeFG5kjYsnciqttW3ucMsXGzD/xhPWVfP550TuhYyk4q9mgQfEtR4kKd8txaV3ySjHhXGm0aJFqlSqqvXqpHjoU2WdGjbIUBJMn57/dtm2WAmL6dNXMzPDbjRunWqOGau3aqm+9FXnZo61lSzuumjVV33wzfuWI1MaN8S5B9JFPignRBBt737lzZw3O9etcabVjh3W27thhQxEjHSZ68KBNS3jggOXyzysL59atNvwwmAKiWTO70h82LLvpadcuuP56q5F0726TteSVPbOk3H673ak8ZoylWXAlT0TSVbVzXu9505BzAZMmWRbJaGTLvuoqy8M/YULh7hVISbEslitWwKhRh7//yy/WebtwoQ1HHT8ejjvOOpmbN4dzzoF//cv6HF59Fe65J3uu4Xj6xz+sHB4ESqlwVYXSunjTkIuFrCzV5s2t+aJlS9XZs4u+rw0bbD933VX0ffTrZ006mzZlr8vIUO3YUbVSJdWpU3Nu/+OPqvfco9qkiX13o0aqs2YV/ftd2UOcso86lzC+/tqSo/05cCdLjx42R2xwYvLCCE7EctZZRS/P449bVsq777bXGRmWc//bb+G//4Vzz825fYsWcP/9dgxz5tjIo+KO/3fJwwOBc1izUPnydjJduNCGcv7znzaUMPe0jQUJBoLgaJmiaNXK2vjHjIEPPrD5cX/4wcbf55f7pnx5ux8h2mkRXNnmgcAlPVULBD172nDJ6tXtpq4PP4Q9e+Dkky1ARGrxYusXqFeveOW65x4rzznnWBK0qVOLf3OXc3nxQOCS3rJlNj1h7nHjZ5xhJ/Xf/tY6YzdsiGx/S5ZEJ7987dpWK2nQwPLi9+pV/H06lxcPBC7pvfWW3TyVVzrg4A1ekHPmqnAyM23YZ3GahUINGWJ395aGzJyu7PJA4JLepEk21j7cMM+OHS1QRBIIVqywTt5ozjiVLGkOXPx4IHBJ7fvvrfknv3QCNWpY520kgSDYURzvqQedKwwPBC6hzZpld9OuXl20z0+aZI8DB+a/XadO2dk787NkiV3Bt2lTtPI4Fw8eCFzCOnTIhliuXWvpnYti0iSbnzdcVtCgtDRYtw42b85/u8WL7e7ZqlWLVh7n4sEDgUtYY8ZYx2ytWtlX9oWxahXMmxdZlsm0NHv8+uv8t1u82JuFXOLxQOAS0o4dNs7+tNPgzjstodnatYXbx9uBWbQjCQTBHPX5NQ/t3Ws3fXkgcInGA4FLSA89ZGkXnngiu30/eGKP1KRJlukzkkRotWvbdvl1GH/zDWRleSBwiccDgUs4K1fajVZDh1onbqtWNm6/MIFgwwabGKUwk4+kpeUfCKKRWsK5ePBA4BLOXXdZTp2HHspeN2gQfPop/PRTZPv4z3+yPxepTp0sCP3yS97vL15s8weUxlm3nMuPBwKXUL74wkYI3X47NG6cvX7QIMsZNHlyZPuZNAlaty7cMM+COowXL7b9VagQ+T6dKw08ELiEoQo33wwNG8Jtt+V8r21bm6AlktFDGRk2f29h56QNBoJwzUM+YsglKg8ELmG88YalhH7oIahWLed7InZinzUrfNNN0OTJ1ql7wQWF+/66dW2mr7xGDm3ZYjmBvH/AJSIPBC4h7N0Ld9xhwziHDs17m4ED7Sazd9/Nf19vvQUtW9qIocIK12G8ZIk9eo3AJSIPBK5UU4UZM6BfP1izxmbuKhfmX23nznaHcH7NQ++8A9Onw2WXFS2ZW6dOlp9o+/ac6z3HkEtkHghcqbR/P7zyil21n3mmXXGPHJl/Tn4RqxVMnw47dx7+/qZN8Mc/WjbRO+4oWrmC/QQLFuRcv3ixzQrWqFHR9utcPHkgcKXK1q3wwAPWFv+HP1iN4KWXLKncjTcW/PlBgyyITJ2ac70qXH457NoF48bZMM+iCNdhvGSJ9Q94ymiXiDwQuFLlggssdURaml3ZL1pkAaFy5cg+f/LJNq9A7uahZ5+1Wb4efbR4mUEbNLBhq6EdxiB6Qh8AABy1SURBVKrRm5XMuXjwQOBKjTVrYOZMuO8+mDbNmoQKe4VdrpxNLTltmnUwg6V++L//s7l/r722+OXM3WG8Zo3lPvJA4BKVBwJXagRTSV96afH2M2iQTTr/wQdw4IDtr3p1ePnl6DTdpKXBt9/C7t322lNLuETn90C6UmP8eOjSJbIkcPnp0QOOOMKah774wu4Enjw5/FSUhdWpkzUHLVhgU1wGh456IHCJygOBKxWWL7cT9hNPFH9fKSkwYABMmGDzB19xhb2OltAO4+7drUbQtKllKHUuEXnTkCsVxo+3Zpvf/S46+xs0yPoIjj3WMpVGU6NG1mkc7Cfw1BIu0XkgcHGnalfvPXpEbxz+mWfCVVfBm28eno6iuESsVpCeDgcPWn+BNwu5ROaBwMXdggXWNHTxxdHbZ8WK8PzzRUsjEYm0NFi2DBYutGDgNQKXyGIWCETkJRHZLCJLwrzfU0S2i8iCwHJvrMriSrfx4y11c2GTwMVTp06QmQmvv26vPRC4RBbLzuJXgKeB1/LZ5lNV7RfDMrhSLivLmoXOOsuyeyaKYIfxuHE2SU7r1vEtj3PFEbMagarOBgpICOyS3Rdf2KTzgwfHuySFc/TRNkR182abKrOoKSucKw3i3UdwkogsFJH3ROSEcBuJyJUiMk9E5mVkZJRk+VyMjR9v6SOiObyzJIhY8xB4s5BLfPEMBPOBZqraAXgKCDvJoKr+S1U7q2rn+vXrl1gBXWwdOmSjevr1gxo14l2awgs2D3kgcIkuboFAVXeo6q7A82lAiojUi1d5XMmbOdOaVhKtWSjIA4ErK+IWCETkKBHL/CIiXQNl2RKv8riSN3481KwJ554b75IUTf/+NlHOOefEuyTOFU/MRg2JyHigJ1BPRNYBw4EUAFV9HrgAuEZEDgF7gYtVVWNVHle67N8Pb78N558feYrp0qZyZbjllniXwrnii1kgUNV8K/yq+jQ2vNQloffes9TN0byJzDlXNPEeNeSS1OuvQ716cPrp8S6Jc84DgStRc+dCnz42WuiSSyxTqHMuvjwQuBKxYIF1rnbtCl99BQ8/bItzLv58PgIXU0uXwvDhNklM7drwt7/BDTfYaCHnXOnggcDFzDffQGqqja659164+WafvMW50sgDgYuZ556zVAzffAONG8e7NM65cLyPwMXEnj3w2mswcKAHAedKOw8ELiYmToTt222WMOdc6eaBwMXE6NFw/PE2/aRzrnTzQOCibtEimDMHrrzS+gicc6WbBwIXdaNH20Qtl10W75I45yLhgcBF1e7dMHaszT+cSFNPOpfMPBC4qHrjDUsm553EziUODwQuqkaPht/8Bk45Jd4lcc5FygOBi5oFCyyP0FVXeSexc4kkokAgItVEpFzgeSsR6S8injfS5TB6tKWTGDo03iVxzhVGpDWC2UBlEWkMTAd+D7wSq0K5xLNrF4wbBxddBHXqxLs0zrnCiDQQiKruAQYCz6rqhcAJsSuWSzTjx8POnd5J7FwiijgQiMhJwKXA1MC68rEpkivNws0qPXo0tG0LJ51UsuVxzhVfpNlHbwLuAv6jqktFpCUwK3bFcqXRAw/AiBFQvbrNJxBcqlSB9HR46invJHYuEYmGu8QL9wHrNK6uqjtiU6T8de7cWefNmxePr05q+/ZBkybQvDl07273CoQuVarAf/8LtWrFu6TOubyISLqqds7rvYhqBCLyOnA1kAnMBWqKyJOq+mj0iulKs0mTYMsWu2HMJ5x3rmyJtI+gTaAG8FvgPaAFNnLIJYnnn4fjjoNeveJdEudctEUaCFIC9w38FnhHVQ8ChWtTcqXOf/4D69cXvN3SpfDZZ5ZNtJzfguhcmRPpf+vRwCqgGjBbRJoBcekjcNHx4482e9jQoeFHAgWNHg0VK8KwYSVSNOdcCYsoEKjqKFVtrKrnqlkNeCNBApswwR5nzrRO3nB277YpJy+8EOrVK5myOedKVqQpJmqJyBMiMi+wPI7VDlyCGj8eunWDNm3g1lth//68t3vjDZty8uqrS7Z8zrmSE2nT0EvATuCiwLIDeDlWhXKxtWSJLUOGwMiR1kw0cmTe2z7/PJxwgg0Zdc6VTZEGgmNUdbiq/hhY7gNaxrJgLnYmTLBO3wsvhDPPhPPOs5vFNm7MuV16Osyd69lEnSvrIg0Ee0Xk1wzzItId2BubIrlYUrVAcPrp0KCBrXv8cWsa+stfcm47erTdKPZ7HyjsXJkWaSC4GnhGRFaJyCrgacDTiyWgefNgxQq4+OLsdccdBzfdBK+8YjUAsLuFX38dBg+G2rXjUlTnXAmJdNTQQlXtALQH2qtqKtA7piVzMTF+PKSk2NDRUHffDUceaQFB1VJK797tncTOJYNC3R6kqjtCcgzdEoPyuBjKyrJRQH36HH6VX7MmPPQQfP65BYvnnoO0NOicZ2YS51xZUpz7RL37MMF8+ils2GDNPXkZNgxSU+Gaa2DxYu8kdi5ZFCcQ5Hs/qoi8JCKbRWRJmPdFREaJyA8iskhE0opRFheB8eOhalUbJZSX8uXhySetf6BGjfABwzlXtuSbfVREdpL3CV+AKgXs+xWsU/m1MO/3AY4LLN2A5wKPLgYOHoS33oL+/aFaPrcCnnqqjR468kgLBs65si/fQKCqRT4VqOpsEWmezyYDgNfUJkSYIyK1RaShqm7M5zOuiGbMsDTSkVzlP/hg7MvjnCs94plLsjGwNuT1usC6w4jIlcH0FhkZGSVSuLJmwgTrID777HiXxDlX2iREUmFV/ZeqdlbVzvXr1493cRLO3r2WcnrgQKhUKd6lcc6VNvEMBOuBpiGvmwTWuSibNg127vTOX+dc3uIZCN4BhgZGD50IbPf+gdiYMMHSSfjsYs65vEQ0Z3FRiMh4oCdQT0TWAcOBFABVfR6YBpwL/ADsAf4Qq7Iks6VLYcoU+NOfbHioc87lFrNAoKr5NkQERgtdG6vvT2ZZWfDee3ZPwIcfWuK4K66Id6mcc6VVQnQWu8js3AlPPw2tW0O/flYbeOABWL0a2rePd+mcc6VVzGoErmRNmgSXX253BXfrZplDL7jAEsw551x+PBCUAdOn24igtDRrDurm92c75wrBA0GCmzMHzj/f5h5+/32fO8A5V3jeR5DAli6Fc8+Fhg09CDjnis4DQYJatQrOOgsqV7aRQUcdFe8SOecSlTcNJaCffrJJ5/fssTkGWrSId4mcc4nMA0GC2b4dzjnHJpiZMQPato13iZxzic4DQQLJyrJJ55cuhXfegZNOineJnHNlgQeCBDJypHUKP/OM1Qqccy4avLM4QcyfD3feCb/9rc0p7Jxz0eKBIAHs2mU3jB15JLz4ok8o75yLLm8aSgA33gjffw8ffQR168a7NM65ssZrBKXcxInw0ktw110+n4BzLjY8EMTR3r0wbBiMGGFX/LmtWgVXXmm5g0aMKNmyOeeShweCOLrvPnj1Vbj/fmjVCrp2hVGj7IaxQ4fgkktsyOjrr3sWUedc7HggiJP0dHjsMfjjH2HtWnj0UTh40PoDGjeGjh3hiy9g9Gho2TLepXXOlWViE4Uljs6dO+u8efPiXYxiOXgQunSBzZth2bKcyeKWLYNx46xv4Kyz7J4B55wrLhFJV9XOeb3no4bi4NFHYeFC+M9/Ds8Y2qYNPPigLc45VxK8aaiEffut9Q1ceKHdHOacc/HmgaAEZWVZn0D16vDUU/EujXPOGW8aKkHPPAOffw6vvQYNGsS7NM45Z7xGUEJWrbKbws45B4YMiXdpnHMumweCEqAKV11lOYKef95zBTnnShcPBDG2fTtceilMnw5//zs0axbvEjnnXE7JEwj277fUnSV438ScOXZj2MSJ8MAD8Oc/l9hXO+dcxJInEIwdC1dcAdddZ8N3Yigz0+4DOOUUe/3pp/DXv0K55Pm1nXMJJHlGDV1+OSxfbndzHThgjfXly0f9a9ats87gTz6xOQSeew5q1Yr61zjnXNQkTyAQgUcegcqV4W9/s6ail16CCtH5CXbvhldegXvvtV2/8goMHeodw8650i9pAsH27bB2rfCb4fdTvnJla6vZt88S+xQjteemTfD003bl/8sv1hw0ZoxlE3XOuUSQNK3WH3wA7dpBnTpw5qy/cM8ZXzD1zd383P9yu4QvpKVL7S7hZs3goYegRw/43/+sP8CDgHMukSRNjeDUUy33/5w5tvx90YlkMhXeh2OO2ECrU46kafMKHH00vy5Nm9p8wStXHr4sWQJVqsCf/gQ33QTHHRfvI3TOuaJJ2jTUu3fbnABzRn3FV5PWsCrlONZUbkXGziphP1O9OrRoYUu3bjZ7WL16xS6Kc87FnKehzkO1anDaaXDaaV3hi0y46Ur46iv2pnVn7a0jWdugM2vW2HbBk3/dut7565wre2LaRyAi54jIchH5QUTuzOP9YSKSISILAsufYlmesE46yaYDGzuWKptX0+rSLpz+/IX8oedKLrrIJpGpV8+DgHOubIpZIBCR8sAzQB+gDTBYRNrksekbqtoxsLwYq/IUqFw5ywWxfLlNGDBtGrRubaOL9uyJW7Gccy7WYlkj6Ar8oKo/quoBYAIwIIbfFx1Vq9rNAN99BxddZEOCTjgBpk6Nd8mccy4mYhkIGgNrQ16vC6zLbZCILBKRt0SkaQzLUziNG8O//w0ff2zDg/r1g4EDbaZ555wrQ+J9H8G7QHNVbQ98CLya10YicqWIzBOReRkZGSVaQHr0gAUL4OGH4f334Te/gccesxnonXOuDIhlIFgPhF7hNwms+5WqblHV4N1cLwKd8tqRqv5LVTurauf69evHpLD5qlgR7rgDvvkGTj8dbrvNepAXLy75sjjnXJTFMhDMBY4TkRYiUhG4GHgndAMRaRjysj/wTQzLU3zNmsF//wuTJ1tuic6drXaQmRnvkjnnXJHFLBCo6iHgOuAD7AQ/UVWXisj9ItI/sNkNIrJURBYCNwDDYlWeqBowwGoDffta7aB3b5uL0jnnElDS3lkcFao2E/3119vrUaPgssv8hgPnXKmT353F8e4sTmwiduJfvBjS0uAPf4BBg2Dr1niXzDnnIuaBIBqaNYOZM62/YMoUCwrp6fEulXPORcQDQbSUKwe33mp5qDMz4eSTYfToEp0j2TnnisIDQbR16wZff20dyFdfbdOU7d4d71I551xYHghioW5dS0nxt7/ZDGjdusG338a7VM45lycPBLFSrhzcfTdMnw6bN9s9By+/7E1FzrlSxwNBrJ1xhjUVdekCl18OF14IW7bEu1TOOfcrDwQloXFjmDEDHnkE3nkH2re31845Vwp4ICgp5cvD7bfDl19CrVpw5plwyy2wb1+8S+acS3IeCEpaairMmwfXXQf//Cd07WqvnXMuTjwQxEPVqvDUUzYLWkaGBYMrr7TnzjlXwjwQxFOfPjas9OabbURRq1YWIA4dinfJnHNJxANBvNWqBY8/DosW2RDTG26w5qOPP453yZxzScIDQWnxm9/YPQdvvw07d0KvXnDxxbBuXbxL5pwr4zwQlCYicP75NhPaiBE2Cc7xx9s0mfv3F/hx55wrCg8EpVGVKjB8uAWEs8+Gu+6Cdu3gvffiXTLnXBnkgaA0a97cmoref99qC+eea7OjrVgR75I558oQDwSJ4OyzbfKbRx6Bjz6C1q1tQpxvSvcUz865xOCBIFFUrGh3Jn/3nd2M9uabcMIJMHAgzJ0b79I55xKYB4JE06iR3ZG8ejX89a82M1rXrpayYsYMmxTHOecKwQNBoqpf3+Y7WLPGmowWL7Zg0KQJXHstzJrlN6Y55yLigSDR1axpTUYrV8Lrr0P37naXcu/e0LChpa6YPt1rCs65sDwQlBVVqsDgwfDWW5az6K23bC6E8eOts7lFC7jvPli7Nt4ldc6VMh4IyqJq1WDQIAsCGRnWsdymjQWC5s3hvPPg3Xe96cg5B4Bogk2d2LlzZ53naZuLZuVKGDPGlk2bbMKcc86xHEedO9uEORUrxruUzrkYEJF0Ve2c53seCJLQwYMwdar1Jfzvf9lTZ1asaMGgc2c45RQ46yzrlHbOJTwPBC48VRuKOm+e3Y8wbx6kp8P27XY3c1qa1RrOPhtOPBFSUuJdYudcEXggcIWTlQVff22pLd5/H774wkYd1awJ3brZaKQjj8y5NG5s/RAVKsS79M65PHggcMWzbZultnj/fQsQGRmwefPh8y1Xr27DV0891ZauXaFy5fiU2TmXgwcCF32qsGtXdlBYuRI++wxmz4YlS2ybihWhSxc49lirMTRpYkvweb16UM4HrjlXEjwQuJL1yy/WCT17NsyZY30QGzYcflNb+fLWGd2gQc6lcWMb5hpcateOw0E4V7bkFwi8QddF3xFH2L0K552XvS4z02oO69ZlL5s22bqffrJl+XJ7zN3kVKuWBYRGjaBqVbt5rnJle6xSxWoee/bA7t05l717rSyNGtnSsGH286OOgrp1vU/DOTwQuJJSvrydiBs2tOaicFStRrFq1eHLxo12ct+714JF8PmBAxYgqlXLXqpXt2CxcqXVTn7++fDvErFAUb++dXjXr2+fO3jQbrYLPgaXrCwrn2r283Ll7K7t1q1tNrnjj4djjolsdNX+/TkD4f79VvupU8eW2rWtg96bz1yMedOQSw7791sNZMMGWL/eTsCbN2f3cQQfd++2k3hKitUWgo/ly9sJWSTn44EDNlHQTz9lf1f58tCypQUVsG1Fsp/v2GHbb99ecLnLlbOgEFqbCdZuGjSwbQ4csGX//uznKSnZNaZgLapKFatdBYNepUqHf19WlpVt7Vqrtf3yS/aosMaN7XlxA1NWlv0dvvvOlp07bQa+jh2tplZa7dgBP/5ov2ODBvZbBv+uCcCbhpyrVAmaNbMlFrZts5Pat99aE9f331utJViDgOznLVvaieTII3P2jVSqZPvZujX7cetWu+Fv40Y7eS5bZs+jkUSwRo3soFChgp3416+3mlA4FSpk1+xEbNtg8AkulSpZEKxRI+eyc6f9Lt9/b015eTnqKEhNtaVtW9tPxYo5l/LlLaivXm3LqlX2uGZNzr9z6FK/fnZQDwb2ChXsGPbutfIEl7177aS/YkV2eb//3i4UQlWqlPPv17Sp1Q5btsxeatXK+ZmsLPuOnTtt2brVgm3wb711q3133boW8IMBuFEj+w1jJKY1AhE5B3gSKA+8qKoP53q/EvAa0AnYAvxOVVflt0+vEbikl5VlTV0//WRX58ETZKVK9piSYifo4Aku2IS2Z48FmIyM7CVYGzp40EZyNW2avTRpYk1nmzdbgAhdNm2ysuQ+SaekWM1k167sk11wqVoVWrWy5bjjsp9XqwaLFtnQ5K+/hgULLOBFkgsrJQWOPtpO9kcfbYEoGCDWr88OwkXVsKGVNbgcc4x9x6ZN9vuHPq5ZYyfyUHXq2G+4e7f9Jrt2FfydlSrZb5hbjRqWafjuu4t0KHGpEYhIeeAZ4ExgHTBXRN5R1WUhm/0R2Kqqx4rIxcAjwO9iVSbnyoRy5bJv5CsJzZrl368TDT162BK0b59dke/bd3iN4+BBO/bmza0GEa6p6uBBq+WsXm21qszMnH0+wX6fYNNZ1arZz6tXt/0Hm/citW2b9Uv9+GP247ZtdhKvXj27phR8DPYHBQNG7doWUHftym7GDD6uX2+1pBiIWY1ARE4CRqjq2YHXdwGo6t9DtvkgsM0XIlIB2ATU13wK5TUC55wrvPxqBLEcjtAYCE1+vy6wLs9tVPUQsB2om3tHInKliMwTkXkZGRkxKq5zziWnhBiXpqr/UtXOqtq5vmfDdM65qIplIFgPNA153SSwLs9tAk1DtbBOY+eccyUkloFgLnCciLQQkYrAxcA7ubZ5B7gs8PwCYGZ+/QPOOeeiL2ajhlT1kIhcB3yADR99SVWXisj9wDxVfQcYA/xbRH4AfsGChXPOuRIU0xvKVHUaMC3XuntDnu8DLoxlGZxzzuUvITqLnXPOxY4HAuecS3IJl3RORDKA1UX8eD0gjzSUSSFZj92PO7n4cYfXTFXzHH+fcIGgOERkXrg768q6ZD12P+7k4sddNN405JxzSc4DgXPOJblkCwT/incB4ihZj92PO7n4cRdBUvUROOecO1yy1Qicc87l4oHAOeeSXNIEAhE5R0SWi8gPInJnvMsTKyLykohsFpElIeuOEJEPReT7wGOdeJYxFkSkqYjMEpFlIrJURG4MrC/Txy4ilUXkKxFZGDju+wLrW4jIl4F/728EEj+WOSJSXkS+FpEpgddl/rhFZJWILBaRBSIyL7CuWP/OkyIQhEyb2QdoAwwWkTbxLVXMvAKck2vdncBHqnoc8FHgdVlzCLhVVdsAJwLXBv7GZf3Y9wO9VbUD0BE4R0ROxKZ9/aeqHgtsxaaFLYtuBL4JeZ0sx91LVTuG3DtQrH/nSREIgK7AD6r6o6oeACYAA+JcpphQ1dlYJtdQA4BXA89fBX5booUqAaq6UVXnB57vxE4OjSnjx64mOCN6SmBRoDfwVmB9mTtuABFpAvQFXgy8FpLguMMo1r/zZAkEkUybWZY1UNWNgeebgAbxLEysiUhzIBX4kiQ49kDzyAJgM/AhsALYFpj+Fcruv/eRwO1AVuB1XZLjuBWYLiLpInJlYF2x/p3HNA21K31UVUWkzI4ZFpHqwCTgJlXdYReJpqweu6pmAh1FpDbwH6B1nIsUcyLSD9isquki0jPe5Slhp6jqehE5EvhQRL4NfbMo/86TpUYQybSZZdlPItIQIPC4Oc7liQkRScGCwDhVfTuwOimOHUBVtwGzgJOA2oHpX6Fs/nvvDvQXkVVYU29v4EnK/nGjqusDj5uxwN+VYv47T5ZAEMm0mWVZ6JSglwH/jWNZYiLQPjwG+EZVnwh5q0wfu4jUD9QEEJEqwJlY/8gsbPpXKIPHrap3qWoTVW2O/X+eqaqXUsaPW0SqiUiN4HPgLGAJxfx3njR3FovIuVibYnDazAfjXKSYEJHxQE8sLe1PwHBgMjAROBpL4X2RqubuUE5oInIK8CmwmOw2479g/QRl9thFpD3WOVgeu7CbqKr3i0hL7Er5COBrYIiq7o9fSWMn0DT0f6rar6wfd+D4/hN4WQF4XVUfFJG6FOPfedIEAuecc3lLlqYh55xzYXggcM65JOeBwDnnkpwHAuecS3IeCJxzLsl5IHAuQEQyAxkdg0vUEtSJSPPQjLDOlSaeYsK5bHtVtWO8C+FcSfMagXMFCOR//0cgB/xXInJsYH1zEZkpIotE5CMROTqwvoGI/CcwR8BCETk5sKvyIvJCYN6A6YE7gRGRGwLzKCwSkQlxOkyXxDwQOJetSq6mod+FvLddVdsBT2N3qAM8Bbyqqu2BccCowPpRwCeBOQLSgKWB9ccBz6jqCcA2YFBg/Z1AamA/V8fq4JwLx+8sdi5ARHapavU81q/CJn/5MZDYbpOq1hWRn4GGqnowsH6jqtYTkQygSWhqg0Bq7A8DE4cgIncAKar6gIi8D+zCUoFMDplfwLkS4TUC5yKjYZ4XRmjOm0yy++j6YjPopQFzQ7JnOlciPBA4F5nfhTx+EXj+OZb5EuBSLOkd2FSB18Cvk8bUCrdTESkHNFXVWcAdQC3gsFqJc7HkVx7OZasSmOkr6H1VDQ4hrSMii7Cr+sGBddcDL4vIbUAG8IfA+huBf4nIH7Er/2uAjeStPDA2ECwEGBWYV8C5EuN9BM4VINBH0FlVf453WZyLBW8acs65JOc1AuecS3JeI3DOuSTngcA555KcBwLnnEtyHgiccy7JeSBwzrkk9/9C9KCsGRMRHQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V-ZM-adGVXsB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}