Part4-Sentiment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Avdhoot_NLP_Sentiment_analysis.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S6jS38oi1oGT",
        "colab_type": "text"
      },
      "source": [
        "### SENTIMENT ANALYSIS USING NLP APPROACH TO DETECT SARCASM"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5xnaspFA1-Zq",
        "colab_type": "text"
      },
      "source": [
        "**Import all the required libraries.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "krw_ztl-1mqp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "import json\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F_cKehOu8Xgy",
        "colab_type": "text"
      },
      "source": [
        "**Let's load the data**\n",
        "<br> You can download this dataset from this [kaggle link](https://www.kaggle.com/rmisra/news-headlines-dataset-for-sarcasm-detection) or the way I've done it here.\n",
        "<br>This dataset is in json file so we need to get the data out of it first before we proceed to sentiment analysis"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V-IEYuwG8Vuk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#creating empty lists to store the data items from the dataset\n",
        "sentences = []\n",
        "labels = [] \n",
        "urls = []\n",
        "\n",
        "link = \"https://raw.githubusercontent.com/rishabhmisra/News-Headlines-Dataset-For-Sarcasm-Detection/master/Sarcasm_Headlines_Dataset.json\"\n",
        "#This function will yeild data from  the json file by reading through it\n",
        "def parse_data(link):\n",
        "    for l in open(link,'r'):\n",
        "        yield json.loads(l)\n",
        "\n",
        "#this line will parse the yeilded json data so that we can further use it to process\n",
        "data = parse_data('Sarcasm_Headlines_Dataset.json')\n",
        "\n",
        "#looping through the data parsed above and appending into the python arrays created\n",
        "for item in data:\n",
        "  sentences.append(item['headline'])\n",
        "  labels.append(item['is_sarcastic'])\n",
        "  urls.append(item['article_link'])"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pPphRgmz9JO2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "#defining the parameters for our model to build, in future if needed to change we can do it from here\n",
        "vocab_size = 10000\n",
        "embedding_dimension = 16\n",
        "max_length = 100\n",
        "trunc_type = 'post'\n",
        "padding_type = 'post'             \n",
        "oov_tok = '<OOV>'                  \n",
        "training_size = 20000\n",
        "\n",
        "#Training & Testing sentences\n",
        "training_sentences = sentences[0:training_size]\n",
        "testing_sentences = sentences[training_size:]\n",
        "\n",
        "#Training & Testing labels\n",
        "training_labels = labels[0:training_size]\n",
        "testing_labels = labels[training_size:]\n"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i0DmFHFujFOL",
        "colab_type": "text"
      },
      "source": [
        "# Pre-process the data for training a neural network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_cRGFGZ2dLA",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "In this we step of pre-processing we do these steps:-\n",
        "- **Tokenize** the text. [**Tokenizer class** allows to vectorize a text corpus, by turning each text into either a sequence of integers (each integer being the index of a token in a dictionary) or into a vector where the coefficient for each token could be binary, based on word count]<br>\n",
        "- Then use **fit_on_texts** function to fit the vocabulary size of the training sentences\n",
        "- Then create **sequences** of the tokens created in the previous step and outputs a python array of numberes with sequences of the tokens that represent the sentence numnerically in our defined way.\n",
        "- Then **pad** the sequences with zeros incase any sequence is short, as it may happen because all sentences are not of the same size.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3u8UB0MCkZ5N",
        "colab": {}
      },
      "source": [
        " # OOV tokens are the out-of-vocabulary words which could be encountered during tokenization\n",
        "tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)  \n",
        "\n",
        "#this will fit the text with num_words on input sentences\n",
        "tokenizer.fit_on_texts(training_sentences)\n",
        "\n",
        "#this will create a word index dictionary of indexing of tokens.\n",
        "word_index = tokenizer.word_index\n",
        "\n",
        "#this creates sequences of tokens and outputs a python array with sequences of tokens repersenting the sentence\n",
        "training_sequences = tokenizer.texts_to_sequences(training_sentences)\n",
        "\n",
        "#this will padd the sequences with zero who has a short sequences\n",
        "training_padded = pad_sequences(training_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)  \n",
        "\n",
        "\n",
        "#this creates sequences of tokens and outputs a python array with sequences of tokens repersenting the sentence\n",
        "testing_sequences = tokenizer.texts_to_sequences(testing_sentences)\n",
        "\n",
        "#this will padd the sequences with zero who has a short sequences\n",
        "testing_padded = pad_sequences(testing_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)"
      ],
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e3OyTpWbkkv8",
        "colab_type": "text"
      },
      "source": [
        "Next step of pre-processing is the final step in this we just convert the test & train sequences to numpy array in order to feede them to our neural network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PDMScpcLGE_p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "training_padded = np.array(training_padded)\n",
        "training_labels = np.array(training_labels)\n",
        "testing_padded = np.array(testing_padded)\n",
        "testing_labels = np.array(testing_labels)"
      ],
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7D0-p8TJjcgA",
        "colab_type": "text"
      },
      "source": [
        "# Build the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9sU0fp3DnvNF",
        "colab_type": "text"
      },
      "source": [
        "Building a neural network is the most interesting thing and also boring at the same time. \n",
        "In this we will use the layers as follows:\n",
        "- **Embedding layer:** Turns positive integers (indexes) into dense vectors of fixed size.\n",
        "e.g. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]].\n",
        "This layer can only be used as the first layer in a model.\n",
        "- **GlobalAveragePooling1D**\n",
        "- **Dense layer:** Just your regular densely-connected NN layer.Ie've used 24 units here, you can play around by trying to add more dense layers\n",
        "Dense implements the operation: output = activation(dot(input, kernel) + bias) where activation is the element-wise activation function passed as the activation argument, kernel is a weights matrix created by the layer, and bias is a bias vector created by the layer (only applicable if use_bias is True).\n",
        "- **Dense layer** - This is a final layer with only one unit as it is the ouput layer of the entire neural network and here we've used sigmoid activation function as sigmiod function gives better realistic values than relu  between 0 to 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JOCYsXMGGVrk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = tf.keras.Sequential([\n",
        "                             tf.keras.layers.Embedding(vocab_size,embedding_dimension,\n",
        "                                                       input_length=max_length),\n",
        "                             tf.keras.layers.GlobalAveragePooling1D(),\n",
        "                             tf.keras.layers.Dense(24,activation='relu'),\n",
        "                             tf.keras.layers.Dense(1,activation='sigmoid')\n",
        "])\n",
        "model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])"
      ],
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QmuhGv-YG5Ws",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 289
        },
        "outputId": "ec5f311e-1ac2-4e16-e652-f414b14f1653"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_1 (Embedding)      (None, 100, 16)           160000    \n",
            "_________________________________________________________________\n",
            "global_average_pooling1d_1 ( (None, 16)                0         \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 24)                408       \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 1)                 25        \n",
            "=================================================================\n",
            "Total params: 160,433\n",
            "Trainable params: 160,433\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Bs2VZr4jtwg",
        "colab_type": "text"
      },
      "source": [
        "# Train the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8odj4D8tth5M",
        "colab_type": "text"
      },
      "source": [
        "Training your model will finally make the neural network work in action and after training we can then use it to predict new unseen values.<br>\n",
        "**This is how the basic neural network computation works**\n",
        "- Take input\n",
        "- Forwarad propogate\n",
        "- Predict values\n",
        "- Calculate loss/error\n",
        "- Back Propogate\n",
        "\n",
        "<img src = \"https://miro.medium.com/proxy/1*mTTmfdMcFlPtyu8__vRHOQ.gif\" height=400 width =600>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cWtcKYguKpvG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "e0adbdde-a8c0-4959-df22-ed54f908b64c"
      },
      "source": [
        "history = model.fit(training_padded, training_labels, epochs = 30,validation_data=(testing_padded,testing_labels),verbose=2)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/30\n",
            "625/625 - 2s - loss: 0.6731 - accuracy: 0.5757 - val_loss: 0.6140 - val_accuracy: 0.6688\n",
            "Epoch 2/30\n",
            "625/625 - 2s - loss: 0.4612 - accuracy: 0.8209 - val_loss: 0.3935 - val_accuracy: 0.8365\n",
            "Epoch 3/30\n",
            "625/625 - 2s - loss: 0.3251 - accuracy: 0.8688 - val_loss: 0.3565 - val_accuracy: 0.8512\n",
            "Epoch 4/30\n",
            "625/625 - 2s - loss: 0.2697 - accuracy: 0.8938 - val_loss: 0.3449 - val_accuracy: 0.8545\n",
            "Epoch 5/30\n",
            "625/625 - 2s - loss: 0.2338 - accuracy: 0.9093 - val_loss: 0.3458 - val_accuracy: 0.8509\n",
            "Epoch 6/30\n",
            "625/625 - 2s - loss: 0.2063 - accuracy: 0.9216 - val_loss: 0.3585 - val_accuracy: 0.8456\n",
            "Epoch 7/30\n",
            "625/625 - 2s - loss: 0.1825 - accuracy: 0.9316 - val_loss: 0.3549 - val_accuracy: 0.8557\n",
            "Epoch 8/30\n",
            "625/625 - 2s - loss: 0.1648 - accuracy: 0.9373 - val_loss: 0.3670 - val_accuracy: 0.8557\n",
            "Epoch 9/30\n",
            "625/625 - 2s - loss: 0.1481 - accuracy: 0.9462 - val_loss: 0.3902 - val_accuracy: 0.8478\n",
            "Epoch 10/30\n",
            "625/625 - 2s - loss: 0.1339 - accuracy: 0.9524 - val_loss: 0.4128 - val_accuracy: 0.8468\n",
            "Epoch 11/30\n",
            "625/625 - 2s - loss: 0.1206 - accuracy: 0.9572 - val_loss: 0.4351 - val_accuracy: 0.8432\n",
            "Epoch 12/30\n",
            "625/625 - 2s - loss: 0.1106 - accuracy: 0.9631 - val_loss: 0.4511 - val_accuracy: 0.8457\n",
            "Epoch 13/30\n",
            "625/625 - 2s - loss: 0.1048 - accuracy: 0.9631 - val_loss: 0.4693 - val_accuracy: 0.8450\n",
            "Epoch 14/30\n",
            "625/625 - 2s - loss: 0.0934 - accuracy: 0.9688 - val_loss: 0.5166 - val_accuracy: 0.8344\n",
            "Epoch 15/30\n",
            "625/625 - 2s - loss: 0.0846 - accuracy: 0.9725 - val_loss: 0.5185 - val_accuracy: 0.8420\n",
            "Epoch 16/30\n",
            "625/625 - 2s - loss: 0.0789 - accuracy: 0.9737 - val_loss: 0.5501 - val_accuracy: 0.8378\n",
            "Epoch 17/30\n",
            "625/625 - 2s - loss: 0.0712 - accuracy: 0.9775 - val_loss: 0.5758 - val_accuracy: 0.8369\n",
            "Epoch 18/30\n",
            "625/625 - 2s - loss: 0.0649 - accuracy: 0.9794 - val_loss: 0.6133 - val_accuracy: 0.8323\n",
            "Epoch 19/30\n",
            "625/625 - 2s - loss: 0.0616 - accuracy: 0.9802 - val_loss: 0.6406 - val_accuracy: 0.8320\n",
            "Epoch 20/30\n",
            "625/625 - 2s - loss: 0.0548 - accuracy: 0.9826 - val_loss: 0.6705 - val_accuracy: 0.8301\n",
            "Epoch 21/30\n",
            "625/625 - 2s - loss: 0.0508 - accuracy: 0.9846 - val_loss: 0.7034 - val_accuracy: 0.8289\n",
            "Epoch 22/30\n",
            "625/625 - 2s - loss: 0.0459 - accuracy: 0.9865 - val_loss: 0.7378 - val_accuracy: 0.8281\n",
            "Epoch 23/30\n",
            "625/625 - 2s - loss: 0.0430 - accuracy: 0.9869 - val_loss: 0.7741 - val_accuracy: 0.8216\n",
            "Epoch 24/30\n",
            "625/625 - 2s - loss: 0.0411 - accuracy: 0.9881 - val_loss: 0.8179 - val_accuracy: 0.8229\n",
            "Epoch 25/30\n",
            "625/625 - 2s - loss: 0.0359 - accuracy: 0.9898 - val_loss: 0.8430 - val_accuracy: 0.8208\n",
            "Epoch 26/30\n",
            "625/625 - 2s - loss: 0.0329 - accuracy: 0.9911 - val_loss: 0.8809 - val_accuracy: 0.8185\n",
            "Epoch 27/30\n",
            "625/625 - 2s - loss: 0.0319 - accuracy: 0.9902 - val_loss: 0.9145 - val_accuracy: 0.8192\n",
            "Epoch 28/30\n",
            "625/625 - 2s - loss: 0.0293 - accuracy: 0.9915 - val_loss: 0.9495 - val_accuracy: 0.8171\n",
            "Epoch 29/30\n",
            "625/625 - 2s - loss: 0.0264 - accuracy: 0.9926 - val_loss: 0.9956 - val_accuracy: 0.8147\n",
            "Epoch 30/30\n",
            "625/625 - 2s - loss: 0.0263 - accuracy: 0.9924 - val_loss: 1.0218 - val_accuracy: 0.8150\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AWPCPRL_jzUp",
        "colab_type": "text"
      },
      "source": [
        "# Evaluate the model\n",
        "Evaluating the model is the important step as it allows us to better the model and tune some hyperparameters and pump up the accuracy. There also some things to keep in mind while tuning your projects like for example **not overfitting** the dataset to pump up the accuracy on testing set, **not underfitting** the dataset too is an important and there are some other metrics to keep in my mind."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IEDbGraHw4z1",
        "colab_type": "text"
      },
      "source": [
        "Here since the model is pretty easy we've got 0.9984 accuracy on the training data and around 80% accuracy on the test data which is the reakky good and almost as perfect and it means that our model can predict correctly 99%. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJzbSj8vxa2L",
        "colab_type": "text"
      },
      "source": [
        "Below are the graphs:\n",
        "<br>\n",
        "- First graphs shows the training set accuracy and  what is the validation sete accuracy.<br>\n",
        "- Second graph shows the loss function's values and what was the validation loss.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2RqNOeo8HAue",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 541
        },
        "outputId": "6798d2ae-9121-4aee-9ec6-ef66591ef214"
      },
      "source": [
        "def plot_graphs(history, string):\n",
        "  plt.plot(history.history[string])\n",
        "  plt.plot(history.history['val_'+string])\n",
        "  plt.xlabel(\"Epochs\")\n",
        "  plt.ylabel(string)\n",
        "  plt.legend([string,'val_'+string])\n",
        "  plt.show()\n",
        "\n",
        "plot_graphs(history,'accuracy')\n",
        "plot_graphs(history,'loss')"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEGCAYAAACHGfl5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU9bn48c+TTJLJRhKSEJawC4rsgqJilYq0trVatYjU2pa6tPbqRf211dpFr21ve2+3q/daW7zXrWq5itVar2JdUGpBaxAE2bcAYQnZySRkMpl5fn+ckzCEJExCJpNknvfrdV5zzplzznxPBs4z311UFWOMMfEtIdYJMMYYE3sWDIwxxlgwMMYYY8HAGGMMFgyMMcYAnlgnoLPy8vJ01KhRsU6GMcb0KWvWrClX1fz23u9zwWDUqFEUFRXFOhnGGNOniMiejt63YiJjjDEWDIwxxkQxGIjIoyJyWEQ+bud9EZEHRWSHiKwXkbOilRZjjDEdi2bO4HHg0g7e/wwwzl1uBh6OYlqMMcZ0IGrBQFVXApUdHHIF8KQ63gOyRWRItNJjjDGmfbGsMxgG7AvbLnH3nUBEbhaRIhEpKisr65HEGWNMPOkTFciqukRVZ6rqzPz8dpvJGmOM6aJY9jPYDwwP2y509xljTJ8XDCk+fxN17lIbvt7grjcG8QeCiAiJCUKCcNx6goi7QEKCcO6YXMYXZEYlvbEMBi8Bt4rIUmAWUKOqB2OYHmNMH6fqPICr6wNU1weobQhQ6z58fQ0BfO56+L46f5DEBCE1OZHUpERSkhJITXLWU5MT8SY5S2pSIiLgazk/4Kw3NLnXdT6red/RQLDb7++nV07qe8FARP4IzAHyRKQEuBdIAlDV3wGvAJ8FdgD1wKJopcUY07f4m4Luw9p50B4Je/BW1TdSXR+gsr6RqrpGquobqaoLOK/1jQSCHU/YleJJINPrIdObREaKh/SURJpCIcpqnQf40cYgDYGgsx4I0t78X5kpHjK8HjJSPGR6PWSlJVM4MM3ZH/ae8xnH9qUnh62nJJLiSURVCSmEVAmGFG1eV0VDx9bTk6P3+z1qV1bVhSd5X4F/itbnG2OiLxhSquobqfA1UuHzU17nvFb4Gqmoa8TfFCQYUppCSjDovoZCNIWUpqC674XwN4Xwhf2qbgyGOvzcxAQhJy2J7LRkBqYlMzI3jekjsslJTyYnLYmctGSy05LJdB/IA7xJLQ/nZE/kVaWqir8phD8Q4mggSEiVTPeBnpAgp/rnayEiJAokIiQldttlO6XPjU1kjIkuf1OQCl8jZbV+yn3Ny/HbFb5GKusaqaxvbPOXc4LAwPRkvEmJeBKcMnBPQoLzmti87bymJ3nITkvgtJZf2UnuL/dj282/vjO9HrJTnYd8dz6M2yMiLcVEWU7BRr9lwcCYOBEMKRU+PwdrGjhY08ChmqMcOuLnUM1RDtY0UObzU17r50hDU5vnZ6R4yMtIJi8jhbH5GZwzOpncjBTyMpIZmJ5MbrqznpuRQnZqUo88rE33sWBgTB8Qai6OqWuk3Oen3h+koSmIPxCioSlIQyCEv/k1EMTfFKIhEORIQ4BDNQ0cqmmgtNZPMHT8z/jkxAQKslIYPMDLhMEDyDvNedjnZaY4r+7DPz8zBW+syi9Mj7BgYEyM1dQH2Ha4luLyOsqby97dopnm18o6P6GO60VbpHgS3KKNBNJTPAzJ8nLe2DwGZ6UwOCuVIQO8DM5yloFpyfYL3gAWDIzpMfWNTWwv9bG1tJZth2qd19JaSo/4jzsuLTmRXPcXeWGOUzGal5FCbnoyeZkpDExPJjMliZSkBLwe56Gf4nGaRKZ4EhCxh7vpPAsGxnRBKKTUB4Ju08cAPv+x9eZ2574Gp0nk7vJ6tpXWsreyvuX8FE8C4woymH1aHqcXZDJ+cCZj8tLJz0whLYrNB41pj/2rM6YDRxuD7DjsY1tpLdsP+9heWsu2w7XsrzoaUbFNiieBEQPTmFyYxRdnFDK+IJPTB2cyYmAaiVY8Y3oRCwbG4PzS33Koli2HjrCt1Hnobz/sY19VfUvTyeTEBMbkpzNteA5XTB3GgFQPGSlO+/XMsI5FzU0i0zvZpt2YWLJgYOKSqrKrvI5VO8pZtbOC1bsqqK4PAJCUKIzJy2CK+2t+3KAMxhVkMio3DU+iPdxN/2TBwMSNA9VHWbWzoiUAHDrSAMDQLC+XTCjg/LG5TCnMYmRuOkn20DdxxoKB6VNCIWXTwSO8t6sCn7/tzlGtHa71s3pnBbvL6wCnZ+x5Y3OZPTaP88fmMjI3zVrgmLhnwcD0aqrK3sp63t1RzqodFazaWU6VW5wTqYwUD7NGD+S6WSNaWu9Y23pjjmfBwPQ65T4/q3ZW8Pft5fx9ZzklVUcBGJLlZe6EAi44zflFn5+ZEvE17Ze/MR2zYGBiSlUprqhn7d4q1u2r5h+7K9lyqBaAAV4P543N5RsXjmH2aXmMzku3h7oxUWLBwPSomvoA60qqWx7+6/ZVt7TiSU9OZNqIbL7z6dO54LQ8Jg3Lsrb4xvQQCwYmqvZV1vO37eWs2VPF2n1V7CpzKnFFYPygTC6dOJhpw7OZPiKH0wZl2MPfmBixYGC61dHGIO/truCdrWWs3F7W8vDPy0hh2vBsrj6rkOnDs5lcmEWmt3+PD29MX2LBwJwSVWXHYR/vbCvjnW1lvL+7ksamEN6kBM4dk8v1547kwvH5jLHyfmN6NQsGptNCIWX1rgr+8tEBVm4r40CN03lr3KAMvnLuSC46PZ+zRw208e+N6UMsGJiIVdY1smzNPp55fy/FFfVkpni4YFwet83N58Lx+QzLTo11Eo0xXWTBwHRIVfmguIqn39/DqxsO0RgMcfaoHBZfMo7PTBpiv/6N6ScsGJg21dQHeP7DEp75x152HPaR6fXwpVkj+NKsEYwvyIx18owx3cyCgWkRCIZYu7eaZ4v28ZePDuBvCjF1eDb//sUpfH7KUFKTLRdgTH9lwSCOBUPKxgM1rHaHcP5gdyV1jUHSkxO5ekYhXzpnBJOGZcU6mcaYHmDBII6EQsrW0lpn/P6dFby/u4LaBmfkz7H56Vx1ViHnjc3lwvH5ZKTYPw1j4on9j+/ngiHljc2l/HndflbvrGgZ8XNkbhqfmzyE88bmct6YXAYN8MY4pcaYWLJg0E8dbQyy7MMSHn13N7vL6xiUmcLFZxQ4D/+xudYM1BhzHAsG/Uy5z8+Tq/fwh9XFVNUHmFqYxX99aTqXThxsUzYaY9plwaCf2HHYx/+8u4vnP9xPIBhi7hkF3HzhGM4elWPDQBhjTsqCQR+mqry/u5JHVu7izS2HSfEk8MUZhdxwwWjG5mfEOnnGmD7EgkEf9d6uCn726hY+2ldNbnoyt18yjuvPHUluRuSzfxljTDMLBn3MzjIfP3tlC29sLmVolpefXjmJq88qtGEhjDGnxIJBH1Hh8/PAm9t5+v29pCYl8t1LT+frs0dbEDDGdAsLBr1cQyDIo3/fzW9X7ORoIMh1s0aweO44Kw4yxnQrCwa9VCikvPTRAX7x2lb2Vx/lkgkF3P2ZMzhtkFUMG2O6nwWDXui9XRX89P82s2F/DZOHZfHL+VM5b2xurJNljOnHLBj0IkcaAtz75428sHY/Q7O8/MeCaVw+dSgJNkm8MSbKLBj0Eu/tquD/PfsRh4408M9zx/GtOWOtctgY02OiOj6BiFwqIltFZIeI3N3G+yNF5E0RWS8ib4tIYTTT0xv5m4L87NXNLHzkPZIShWXfPI875423QGCM6VFRyxmISCLwEDAPKAE+EJGXVHVT2GG/BJ5U1SdE5GLgZ8D10UpTb7OttJbFS9ex+eARvjRrBD/43ATSki2zZozpedF88pwD7FDVXQAishS4AggPBmcCd7rrK4AXo5ieXiMUUh5bVcy/Ld/CAK+H//7KTC45syDWyTLGxLFoBoNhwL6w7RJgVqtjPgKuAh4ArgQyRSRXVSvCDxKRm4GbAUaMGBG1BPeEQzUNfPu5j3h3RzmXTBjEz6+eQp71GTDGxFisyyS+DfyXiHwNWAnsB4KtD1LVJcASgJkzZ2pPJrA7vbz+AN9/4WMam0L87KrJXHv2cBtR1BjTK0QzGOwHhodtF7r7WqjqAZycASKSAVytqtVRTFNMNAVDfO9PG3huTQnThmfzmwXTGJ2XHutkGWNMi2gGgw+AcSIyGicIXAt8KfwAEckDKlU1BHwPeDSK6YkJVeXelzby3JoSbv3kadx+yTibZMYY0+tE7amkqk3ArcBrwGbgWVXdKCL3i8jl7mFzgK0isg0oAH4arfTEym/f3snT7+/lljlj+fanT7dAYIzplaJaZ6CqrwCvtNr3o7D1ZcCyaKYhlp5fU8IvXtvKldOH8d1Pnx7r5BhjTLvsZ2qUrNxWxl3Pr+eC0/L4t6unWEWxMaZXs2AQBR/vr+GWp9YwriCTh798Fske+zMbY3o3e0p1s32V9Sx6/AOy05J5fNHZZHqTYp0kY4w5qVj3M+hXquoa+epj/8AfCPLMjbMoGOCNdZKMMSYiFgy6SUMgyI1PFlFSdZSnbpjFuILMWCfJGGMiZsVE3SAYUhYvXcuHe6v4jwXTOGf0wFgnyRhjOsWCwSlSVe7/y0Ze21jKDz93Jp+dPCTWSTLGmE6zYHCKfr9yF0+s3sNNnxjN1y8YHevkGGNMl1gwOAVvbCrl569u4fNTh/K9z0yIdXKMMabLLBh0karyq9e3MTY/nV/On2LzFBtj+jQLBl20cns5mw8e4RsXjSXFY1NUGmP6NgsGXfT7d3ZSMCCFK6YNjXVSjDHmlFkw6IL1JdWs2lnBDReMtlyBMaZfsGDQBb9/ZxeZKR4WntO3p+A0xphm1gO5k4rL63j144PcfOHYzo07FGyChETo6dFLQ0HY/BLsehs0ghlDRWDYDJhwOaRmRz15xpjewYJBJ/33u7vwJCTw9dmjTnwzFIIjJVCxAyp2ussOZ6neAymZkHc65LtL83rWcEjo5kxaYz2sexpW/xdUFYM3CzypJz8v2AhrHof/+zaM/zRMuQbGfQo8Kd2bPmNMr2LBoBPKfX6eKyrhqrOGMWiAF8p3OA/ciu3Og79yFzQ1HDshKR1yx8DQaTDxSmiohrJtsPVVWPuHsOPSIPc0yD8D8sfDoIkw4lxI68KwFnXl8I9H4INHoL4Chs2EeffDGZc5OZOTUYX9H8KGZ+Hj551chTcLzvyCExhGnN/9gcsYE3MWDDrhiVXFNAZD3HTBSFj1n/DWTyDUBDmjnYf52Iud1+Ylc3D7xUL1lVC2Fcq2QPk2Z33PKuch3GzQmTDyfGcZcT4M6GCoi8pdsPohWPs0NB2F8Z+B2f8MI87rXNGUCBTOcJZP/dQpXtrwLGxYBh8+AQMKYfIXncBQMDHy6xpjejXRSMqRe5GZM2dqUVFRj39unb+J83/+FlcU1nE/D8O+9+H0z8Jlv3Ee+t3F74ND653AsGeV8zmNPue9gWPc4DDbec0e6fyKX/UAbP4LJHhgygI4/zan+Kk7NdY5OZr1/ws73gQNQtYISMuB5AxITg9bMk5czx7h5HzS83u+3sQYg4isUdWZ7b5vwSAyj/1tB/uX/5p7vMtISEqFz/4CJs+P/oMt2BQWHP7uvDZUO++l5TpFQSlZcPbXYdY3uzcwtaeuHDa+AHtXO0Gisc4JWOHrfp8TMFrzZreqM3GLxgYUnlj85PfBkf1Qsw9q9rvrJc5Se9Ap0vJ4IcnrvHq8Tt1GUuqx7SSvc+1pC53iLmPilAWDbhAo3crm332FKbolOrmBzgiFoGyzExRKimDIFDjrK07ldG+i6lRGN9ZBQ41TiV22Fcq3OvUmZVugvvzY8UlpkDfeyTnUHnQCQENNq4sKZA6BrGEwYChIolNH09QAgQaneKzJD4GjJ+5PyYJzboJzvwXpuad2b6EQBOp639/cmA5YMDgVoSC891uCb/yY2qCHknP/hUmX3mjFHN2lrsINDluPBYr6CsgcClmF7kO/8Nh65hBI7MI0ogfWwd9+5RSlJaXCjK85RWkDOtF7XBUOfAgf/8lZag84rcAGT4bBU9zXyU5xmP37ML2QBYOuKt8Of/4n2Pc+qz2zeCD1Fp654ws2IF1fVrYV3v0NrH8WJAGmfQlmL4bcsW0frwqlG51WVRv/5ORuEpPhtEtg6FlO7ubQeuffCu7/I2/W8cGhYBJkDHJyPklpkGhtNkxsWDDoiqJHYfn3wONl0/Qf8NkVQ/jl/Gl8cUZhdD/X9IyqPbDqQfjwDxAKwKSr4YI7oeBM5/3yHU4A+Ph5J7ciiTBmjnPcGZ87sTNeYx0c3gwHP4JDG5yldKNTPNVaYrKTO2kODklpznZymlMHNHS6E2iGTIWUjGj/JUwcsWDQWcEA/HQIDD8HvvgoC/9YTHFFHe9855Mke6x9fb9SW+p0yit61Kn0Pm0e+EqdX/uI02pr0lVw5hWQnte5a4eCTt+T0g1wtMqpxwgcdQJH4CgE6sNe3fUjB6Fmr3O+JDiV60PPgmHuMmgieJK7/c9g4sPJgoHlWVurKXF+LU5dyEfVXlbvquAHn5tggaA/yiyAT/0YLrjD6ahX9ChkD4dP/wwmfqFzdQqtJSQ6raTyx3fuPF+ZUzex/0PYvwa2vQrrnnLeS0xxip6GTndyEQmJ7hAn7muCJ2zd3fZ4nUCWPsipnE8bGFnnQxN3LBi0VlXsvOaM4vcrd5Lp9XCtDUjXv6UNhDl3OUusZeQ7w4CM/7SzreoMZdIcHA6shXXPOK2ZukISnECSPsgJEhlukEjPc5r9pmQevyRnQMoAZ92TYpXj/ZgFg9aq9wCwj0G8+vEObrloLBkp9mcyMSICOaOcZdJVx/arOkVRGnR6wYfcVw0d29agM0ZVXZm7lEPdYWfd5+4rKXJemzs2diQhyanHSM4I69+R2nbfDk+qs2/YDBj7SWuG2wfYU661qmJISOJ3a4+SlJjA19oakM6YWBNxWyZ5gJMNInjGya8XOAoNR8BfC373tdHnboft8/uc/a37dvgOn9i3o7HeKXJNSIJRs2H8pU6OZ+CYbvgDmO4WUTAQkT8B/wO8qqqh6CYpxqqKacoaznMfHuTqswoZlOmNdYqMib4k95d8ZkH3XTPY5Aynsm05bHsNlt/tLHnjnZFwx1/qDMgYad8RVaey3ZNqgyVGQaQ5g98Ci4AHReQ54DFV3Rq9ZMVQVTH7QvkEgiFu+sToWKfGmL4r0ePkCEbNdirqK3fD9r86weEfS5yWXClZcNpcZ2Tfxjond9JQ4+REGmqOLf4jznsadHIaGYPcpSDstaDVvsFOk10TkYiCgaq+AbwhIlnAQnd9H/AI8JSqBqKYxp5VVUxRw9l86swCxuRbO29jus3A0TDrG87ir3VGxN22HLb91enUB05ltTfLfR3gtOjKP8PZ5x3g1Ff4a50mwL5SZ7yqA2udeo+2Ci282c41Bgx1erAPGOaM/jtg2LF9qTlOsZuqW8zlFn21NbyJJBwLPM3n9RMR1xmISC7wZeB6YC3wNHAB8FVgTjQS1+MaauBoFdsDuUwfkRPr1BjTf6VkwoTPO0soBI21zoO+q81eQ0FnKJPmIOE77IxxdeQgHDngBI1DG5z9tOpblejWuQT9nfvMlhxKG7mSzMFu8Bnq7OsDzXkjrTN4ATgd+APweVU96L71vyLS80OIRkuV05JorxYwPsNm9jKmRyQknPqIsgmJx4qOmNz+cU2N4DvkBon9TsCoPQiI2yIqxW0JFT4SblgLqVCT0yLLd9gJOrVu8KkpcZr+1pVxQrCRBKfIaoAbHAYMOz6XkprTdmuwUJPbWix4bHvwJKdlWRREmjN4UFVXtPVGRz3a+hy3j8E+HURehvX0NKbf8SQ7gwlmR6nvULDJzaG4Aaf2gJszcYNP2TbY9Y5TB9IVn/sVnH1j96bZFWkwOFNE1qpqNYCI5AALVfW3UUlVrLQEg3zyLGdgjOmsRI/TIiuzwBlfqj3+2mMBoqHG6S3e0os8odV2WK/yAdEbHy3SYHCTqj7UvKGqVSJyE04ro/6jeg/+pAEcaUgnP9OCgTEmSlIyIT+z88OVRFGkjXUTRY5Vm4tIItD/ylGqiqlOGQbAwPT+d3vGGNOeSIPBcpzK4rkiMhf4o7uvQyJyqYhsFZEdInJ3G++PEJEVIrJWRNaLyGc7l/xuVlXMYc9gctKSSEq0Ti3GmPgRaTHRXcA3gFvc7deB/+7oBDf38BAwDygBPhCRl1R1U9hhPwCeVdWHReRM4BVgVOTJ70ahIFTvZX/mTKsvMMbEnUg7nYWAh90lUucAO1R1F4CILAWuAMKDgQID3PUs4EAnrt+9ag9CsJE9wXzyrL7AGBNnIu1nMA74GXAm0DJYj6p2NOLUMGBf2HYJMKvVMfcBfxWR24B04JJI0hMVbh+DbYFcqzw2xsSdSAvGH8PJFTQBnwSeBJ7qhs9fCDyuqoXAZ4E/iMgJaRKRm0WkSESKysrKuuFj2+A2K91Yn2PFRMaYuBNpMEhV1Tdxpsnco6r3AZ87yTn7geFh24XuvnA3AM8CqOpqnFzHCfMLquoSVZ2pqjPz8/MjTHInVRWjksCOxhzyMq0lkTEmvkQaDPzuL/btInKriFwJnGwUtw+AcSIyWkSSgWuBl1odsxeYCyAiE3CCQZR++p9EVTHBzGE04bGcgTEm7kQaDBYDacA/AzNwBqz7akcnqGoTcCvwGrAZp9XQRhG5X0Qudw/7f8BNIvIRTnPVr6mqtn3FKKsq5mi607sv34KBMSbOnLQC2W0iukBVvw34cOY1iIiqvoLTXDR834/C1jcBsyNObTRV76Em/xMAljMwxsSdk+YMVDWIM1R1/9VYD75SypOGAlidgTEm7kTa6WytiLwEPAfUNe9U1T9FJVU9rdppVnpQnCn/ctMtZ2CMiS+RBgMvUAFcHLZPgf4RDNxmpXt1EFmpSSR7bCgKY0x8ibQHcsT1BH2SGwx2BnLJy+j9MxIZY0x3i7QH8mOcMH0PqOrXuz1FsVC1B5Iz2F3vJT/TcgXGmPgTaTHRy2HrXuBKYjmOUHerKoacUZTXBZg4dMBJDzfGmP4m0mKi58O3ReSPwLtRSVEsVBVD7ljKD/mtWakxJi51tUxkHDCoOxMSM6pQVUxT1ghq/U02SJ0xJi5FWmdQy/F1Bodw5jjo+3yHoekotanODGd5GdbHwBgTfyItJsqMdkJixu1jUJnsdjizYiJjTByKqJhIRK4Ukayw7WwR+UL0ktWD3GalpQmDAQsGxpj4FGmdwb2qWtO8oarVwL3RSVIPc4NBiTpDY9ssZ8aYeBRpMGjruEibpfZuVcWQOZTDR53N3HSrMzDGxJ9Ig0GRiPxaRMa6y6+BNdFMWI+p2gM5Iymr9TPA68GbZD2QjTHxJ9JgcBvQCPwvsBRoAP4pWonqUc0dznyNVkRkjIlbkbYmqgPujnJael6TH47sh5xRlB22DmfGmPgVaWui10UkO2w7R0Rei16yekj1PkDdnIHfZjgzxsStSIuJ8twWRACoahX9oQey25KInFGU1/qtw5kxJm5FGgxCIjKieUNERtHGKKZ9TnUxAP7MQo40NFkxkTEmbkXaPPT7wLsi8g4gwCeAm6OWqp5SVQweLxXkANbHwBgTvyKtQF4uIjNxAsBa4EXgaDQT1iOqiiF7JOV1AcB6Hxtj4lekA9XdCCwGCoF1wLnAao6fBrPvaWlW6gdskDpjTPyKtM5gMXA2sEdVPwlMB6o7PqWXU3U7nI2ivLYRsJyBMSZ+RRoMGlS1AUBEUlR1C3B69JLVA45Wgf+I0/vYzRnYXAbGmHgVaQVyidvP4EXgdRGpAvZEL1k9IKxZadk2P5kpNhSFMSZ+RVqBfKW7ep+IrACygOVRS1VPCO9j4PNbSyJjTFzr9MijqvpONBLS45qDQfZIyn0brPLYGBPXujoHct9XVQzp+ZCS4QxSZ5XHxpg4Fr/BoHoPZI8EcIqJLBgYY+JY/AYDt49BIBiiuj5gwcAYE9fiMxgEm5wRS3NGUeFz+xhkWp2BMSZ+xWcwOFICGmzV+9hyBsaY+BWfwSC8j0GtBQNjjInTYOD2lwvrfTzI+hkYY+JYnAaDYkjwwIBhVkxkjDHEczDIHgEJiZTXNpKenEhqsg1FYYyJX/EbDHJGAdhQFMYYgwUD63BmjDHEYzBoOAJHK1v1PrY+BsaY+BbVYCAil4rIVhHZISJ3t/H+b0RknbtsE5HoT5hT3dySaBSAjUtkjDF0YdTSSIlIIvAQMA8oAT4QkZdUdVPzMap6R9jxt+HMoBZdYX0MmoIhquotGBhjTDRzBucAO1R1l6o2AkuBKzo4fiHwxyimxxEWDCrrGlHFKpCNMXEvmsFgGLAvbLvE3XcCERkJjAbeauf9m0WkSESKysrKTi1VVXvAmw2p2Rx2ex/nW87AGBPneksF8rXAMlUNtvWmqi5R1ZmqOjM/P//UPqmqGHKOVR4D5NsgdcaYOBfNYLAfGB62Xejua8u19EQREbRqVuqOWGo5A2NMnItmMPgAGCcio0UkGeeB/1Lrg0TkDCAHWB3FtDhCIac1UVgfA7BgYIwxUQsGqtoE3Aq8BmwGnlXVjSJyv4hcHnbotcBSVdVopaVF7UEINh4LBrV+UpMSSU+JWqMqY4zpE6L6FFTVV4BXWu37Uavt+6KZhuOc0MfAb5PaGGMMvacCuWc0Nytt6X1sfQyMMQbiMRhIAmQ59do2LpExxjjiLxgMKASPUzRkwcAYYxzxFwzcPgbBkFJZ10i+DVJnjDHxFgyONSutqPMTUsi3oSiMMSaOgkFjPfgOHet9XGsdzowxpln8BIPqvc5rzmggrMOZ5QyMMSaOgkHYaKVgvY+NMSacBQOrQDbGmDgKBkOmwPm3QVou4HQ4S/EkkGFDURhjTHSHo+hVRp7vLK7yWqePgYjEMFHGGNM7xE/OoJUyn98qj40xxhW3waDcZx3OjDGmWdwGg7Jav3U4M8YYV1wGA2coChuXyBhjmsVlMKiqbySk1sfAGGOaxWUwsA5nxhhzvPgMBi3jElkFsjHGQLwGAxuXyBhjjhPfwcCKiYwxBojTYFDm85OcmA9USfIAAA/rSURBVMAAb/x0wDbGmI7EZTAor20kLyPZhqIwxhhXfAYDG4rCGGOOE5fBoKzWT77VFxhjTIu4LDQv9/mZPCwr1skwpl8IBAKUlJTQ0NAQ66QYwOv1UlhYSFJSUqfOi7tgEAopFXWN5GVaHwNjukNJSQmZmZmMGjXK6uFiTFWpqKigpKSE0aNHd+rcuCsmqj4aIBhSa1ZqTDdpaGggNzfXAkEvICLk5uZ2KZcWd8HA+hgY0/0sEPQeXf0u4i8Y1FowMMaY1uIuGJS5OYN8qzMwxpgWcRcMyn3Ng9RZzsAY0zlNTU2xTkLUxF1ronKfn6REISu1c82ujDEn9y9/2cimA0e69ZpnDh3AvZ+feNLjvvCFL7Bv3z4aGhpYvHgxN998M8uXL+eee+4hGAySl5fHm2++ic/n47bbbqOoqAgR4d577+Xqq68mIyMDn88HwLJly3j55Zd5/PHH+drXvobX62Xt2rXMnj2ba6+9lsWLF9PQ0EBqaiqPPfYYp59+OsFgkLvuuovly5eTkJDATTfdxMSJE3nwwQd58cUXAXj99df57W9/ywsvvNCtf6PuEHfBoKzWmeHMKryM6V8effRRBg4cyNGjRzn77LO54ooruOmmm1i5ciWjR4+msrISgB//+MdkZWWxYcMGAKqqqk567ZKSElatWkViYiJHjhzhb3/7Gx6PhzfeeIN77rmH559/niVLllBcXMy6devweDxUVlaSk5PDt771LcrKysjPz+exxx7j61//elT/Dl0Vd8Gg3GfTXRoTLZH8go+WBx98sOUX9759+1iyZAkXXnhhS3v7gQMHAvDGG2+wdOnSlvNycnJOeu358+eTmJgIQE1NDV/96lfZvn07IkIgEGi57je/+U08Hs9xn3f99dfz1FNPsWjRIlavXs2TTz7ZTXfcveIyGNhQFMb0L2+//TZvvPEGq1evJi0tjTlz5jBt2jS2bNkS8TXCSwtat9NPT09vWf/hD3/IJz/5SV544QWKi4uZM2dOh9ddtGgRn//85/F6vcyfP78lWPQ28VeBXNtoOQNj+pmamhpycnJIS0tjy5YtvPfeezQ0NLBy5Up2794N0FJMNG/ePB566KGWc5uLiQoKCti8eTOhUKjDMv2amhqGDRsGwOOPP96yf968efz+979vqWRu/ryhQ4cydOhQfvKTn7Bo0aLuu+luFlfBQFWpqLMRS43pby699FKampqYMGECd999N+eeey75+fksWbKEq666iqlTp7JgwQIAfvCDH1BVVcWkSZOYOnUqK1asAODnP/85l112Geeffz5Dhgxp97O++93v8r3vfY/p06cf17roxhtvZMSIEUyZMoWpU6fyzDPPtLx33XXXMXz4cCZMmBClv8CpE1WNdRo6ZebMmVpUVNSlc6vrG5l2/+v88LIzueGCzo3bYYxp2+bNm3v1Q643uPXWW5k+fTo33HBDj3xeW9+JiKxR1ZntnRPVnIGIXCoiW0Vkh4jc3c4x14jIJhHZKCLPtHVMdzk2FIV1ODPG9IwZM2awfv16vvzlL8c6KR2KWk2GiCQCDwHzgBLgAxF5SVU3hR0zDvgeMFtVq0RkULTSA1BW63Q4swpkY0xPWbNmTayTEJFo5gzOAXao6i5VbQSWAle0OuYm4CFVrQJQ1cNRTM+xnIHVGRhjzHGiGQyGAfvCtkvcfeHGA+NF5O8i8p6IXNrWhUTkZhEpEpGisrKyLifIRiw1xpi2xbo1kQcYB8wBFgKPiEh264NUdYmqzlTVmfn5+V3+sLJaP54EIduGojDGmONEMxjsB4aHbRe6+8KVAC+pakBVdwPbcIJDVJT7/ORmJJOQYENRGGNMuGgGgw+AcSIyWkSSgWuBl1od8yJOrgARycMpNtoVrQSV+6zDmTHGtCVqwUBVm4BbgdeAzcCzqrpRRO4Xkcvdw14DKkRkE7AC+I6qVkQrTTYukTEmIyMj1knolaI6SIaqvgK80mrfj8LWFbjTXaKuvNbPuEGZPfFRxsSnV++GQxu695qDJ8Nnft691+wFmpqaetU4RbGuQO4xquoUE9kMZ8b0K3ffffdxYw3dd999/OQnP2Hu3LmcddZZTJ48mT//+c8RXcvn87V73pNPPtky1MT1118PQGlpKVdeeSVTp05l6tSprFq1iuLiYiZNmtRy3i9/+Uvuu+8+AObMmcPtt9/OzJkzeeCBB/jLX/7CrFmzmD59OpdccgmlpaUt6Vi0aBGTJ09mypQpPP/88zz66KPcfvvtLdd95JFHuOOOO7r8dzuBqvapZcaMGdoV1fWNOvKul/WRlTu7dL4xpm2bNm2K6ed/+OGHeuGFF7ZsT5gwQffu3as1NTWqqlpWVqZjx47VUCikqqrp6entXisQCLR53scff6zjxo3TsrIyVVWtqKhQVdVrrrlGf/Ob36iqalNTk1ZXV+vu3bt14sSJLdf8xS9+offee6+qql500UV6yy23tLxXWVnZkq5HHnlE77zzTlVV/e53v6uLFy8+7rja2lodM2aMNjY2qqrqeeedp+vXr2/zPtr6ToAi7eDZ2nvyKFFmfQyM6Z+mT5/O4cOHOXDgAGVlZeTk5DB48GDuuOMOVq5cSUJCAvv376e0tJTBgwd3eC1V5Z577jnhvLfeeov58+eTl5cHHJur4K233mqZnyAxMZGsrKyTTpbTPGAeOJPmLFiwgIMHD9LY2Ngy90J7cy5cfPHFvPzyy0yYMIFAIMDkyZM7+ddqX/wEg1oLBsb0V/Pnz2fZsmUcOnSIBQsW8PTTT1NWVsaaNWtISkpi1KhRJ8xR0JaunhfO4/EQCoVatjuaG+G2227jzjvv5PLLL+ftt99uKU5qz4033si//uu/csYZZ3T7cNhxU2dQ7nPHJbKhKIzpdxYsWMDSpUtZtmwZ8+fPp6amhkGDBpGUlMSKFSvYs2dPRNdp77yLL76Y5557jooKp7Fj81wFc+fO5eGHHwYgGAxSU1NDQUEBhw8fpqKiAr/fz8svv9zh5zXPjfDEE0+07G9vzoVZs2axb98+nnnmGRYuXBjpnycicRMMymqd6GwjlhrT/0ycOJHa2lqGDRvGkCFDuO666ygqKmLy5Mk8+eSTnHHGGRFdp73zJk6cyPe//30uuugipk6dyp13Og0gH3jgAVasWMHkyZOZMWMGmzZtIikpiR/96Eecc845zJs3r8PPvu+++5g/fz4zZsxoKYKC9udcALjmmmuYPXt2RNN1dkbczGfw142HWLamhN99eYb1QDamG9l8Bj3rsssu44477mDu3LntHtPr5jPoTT41cTBLvjLTAoExpk+qrq5m/PjxpKamdhgIuipuKpCNMabZhg0bWvoKNEtJSeH999+PUYpOLjs7m23btkXt+hYMjDGnTFUR6Tu57smTJ7Nu3bpYJyMqulr0HzfFRMaY6PB6vVRUVHT5IWS6j6pSUVGB1+vt9LmWMzDGnJLCwkJKSko4lYmnTPfxer0UFhZ2+jwLBsaYU5KUlNTSc9b0XVZMZIwxxoKBMcYYCwbGGGPogz2QRaQMiGygkRPlAeXdmJzeoL/dU3+7H+h/99Tf7gf63z21dT8jVTW/vRP6XDA4FSJS1FF37L6ov91Tf7sf6H/31N/uB/rfPXXlfqyYyBhjjAUDY4wx8RcMlsQ6AVHQ3+6pv90P9L976m/3A/3vnjp9P3FVZ2CMMaZt8ZYzMMYY0wYLBsYYY+InGIjIpSKyVUR2iMjdsU7PqRKRYhHZICLrRKTzU7/1AiLyqIgcFpGPw/YNFJHXRWS7+9q9c/tFUTv3c5+I7He/p3Ui8tlYprGzRGS4iKwQkU0islFEFrv7++T31MH99NnvSUS8IvIPEfnIvad/cfePFpH33Wfe/4pIh3P+xkWdgYgkAtuAeUAJ8AGwUFU3xTRhp0BEioGZqtpnO8qIyIWAD3hSVSe5+/4dqFTVn7tBO0dV74plOiPVzv3cB/hU9ZexTFtXicgQYIiqfigimcAa4AvA1+iD31MH93MNffR7EmciiXRV9YlIEvAusBi4E/iTqi4Vkd8BH6nqw+1dJ15yBucAO1R1l6o2AkuBK2KcprinqiuByla7rwCecNefwPmP2ie0cz99mqoeVNUP3fVaYDMwjD76PXVwP32WOnzuZpK7KHAxsMzdf9LvKF6CwTBgX9h2CX38HwDOl/1XEVkjIjfHOjHdqEBVD7rrh4CCWCamm9wqIuvdYqQ+UZzSFhEZBUwH3qcffE+t7gf68PckIokisg44DLwO7ASqVbXJPeSkz7x4CQb90QWqehbwGeCf3CKKfkWdMsy+Xo75MDAWmAYcBH4V2+R0jYhkAM8Dt6vqkfD3+uL31Mb99OnvSVWDqjoNKMQpCTmjs9eIl2CwHxgetl3o7uuzVHW/+3oYeAHnH0B/UOqW6zaX7x6OcXpOiaqWuv9RQ8Aj9MHvyS2Hfh54WlX/5O7us99TW/fTH74nAFWtBlYA5wHZItI8gdlJn3nxEgw+AMa5tevJwLXASzFOU5eJSLpb+YWIpAOfAj7u+Kw+4yXgq+76V4E/xzAtp6z5gem6kj72PbmVk/8DbFbVX4e91Se/p/bupy9/TyKSLyLZ7noqTkOZzThB4YvuYSf9juKiNRGA21TsP4BE4FFV/WmMk9RlIjIGJzcAztSlz/TF+xGRPwJzcIbbLQXuBV4EngVG4AxVfo2q9olK2XbuZw5O0YMCxcA3wsraez0RuQD4G7ABCLm778EpZ+9z31MH97OQPvo9icgUnAriRJwf+M+q6v3uc2IpMBBYC3xZVf3tXidegoExxpj2xUsxkTHGmA5YMDDGGGPBwBhjjAUDY4wxWDAwxhiDBQNjWohIMGzUynXdObqtiIwKH83UmN7Gc/JDjIkbR90u/cbEHcsZGHMS7twR/+7OH/EPETnN3T9KRN5yBzd7U0RGuPsLROQFd3z5j0TkfPdSiSLyiDvm/F/d3qKIyD+74+uvF5GlMbpNE+csGBhzTGqrYqIFYe/VqOpk4L9werID/CfwhKpOAZ4GHnT3Pwi8o6pTgbOAje7+ccBDqjoRqAaudvffDUx3r/PNaN2cMR2xHsjGuETEp6oZbewvBi5W1V3uIGeHVDVXRMpxJkoJuPsPqmqeiJQBheFd/93hkl9X1XHu9l1Akqr+RESW40yK8yLwYtjY9Mb0GMsZGBMZbWe9M8LHhQlyrM7uc8BDOLmID8JGmjSmx1gwMCYyC8JeV7vrq3BGwAW4DmcANIA3gVugZdKRrPYuKiIJwHBVXQHcBWQBJ+ROjIk2+wVizDGp7mxRzZaranPz0hwRWY/z636hu+824DER+Q5QBixy9y8GlojIDTg5gFtwJkxpSyLwlBswBHjQHZPemB5ldQbGnIRbZzBTVctjnRZjosWKiYwxxljOwBhjjOUMjDHGYMHAGGMMFgyMMcZgwcAYYwwWDIwxxgD/H3xOL7jIHstTAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vWrMfuq7K8ws",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "4f54230e-8ac7-409b-e957-27c777fc1c58"
      },
      "source": [
        "sentences_to_predict = [ \"If stupidity was a profession then you’d be a billionaire.\",\n",
        "                        \"Don’t talk while I am interrupting!\",\n",
        "                        \"Today is bright and sunny day\"\n",
        "       \n",
        "]\n",
        "\n",
        "seq = tokenizer.texts_to_sequences(sentences_to_predict)\n",
        "\n",
        "pad = pad_sequences(seq,maxlen=max_length,padding=padding_type,\n",
        "                    truncating = trunc_type)\n",
        "print(model.predict(pad))\n"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[9.1199845e-06]\n",
            " [1.0707736e-02]\n",
            " [3.6320090e-04]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rv2BJuhF5nr-",
        "colab_type": "text"
      },
      "source": [
        "As you can see here the three sentences differing from not a sarcastic one to sarcastic to most sarcastic the output gets higher and closer to 1 which is sarcastic sentence and the sentences that are just plain text are with values almost equal to 0 or near to 0.<br><br>\n",
        "We can from here save the model and create a system(GUI) if we want to make an interactive project.\n",
        "That's all, Thank you for staying and making it this far.<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1LtWv5BD_AgO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 25,
      "outputs": []
    }
  ]
}