Clickbait.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "from google.colab import drive\r\n",
    "import warnings\r\n",
    "warnings.filterwarnings('ignore')"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lBnaYLtyZcJF"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "try :\r\n",
    "    %tensorflow_version 2.x\r\n",
    "except :\r\n",
    "    pass\r\n",
    "import tensorflow as tf\r\n",
    "from tensorflow import keras\r\n",
    "from tensorflow.keras import layers\r\n",
    "from tensorflow.keras.models import Sequential"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BInxdKa5ZfXj"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "import gensim.models\r\n",
    "import nltk\r\n",
    "\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "import numpy as np\r\n",
    "import pandas as pd\r\n",
    "from gensim.models import Word2Vec\r\n",
    "from nltk.corpus import stopwords \r\n",
    "from nltk.tokenize import word_tokenize\r\n",
    "\r\n",
    "from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score\r\n",
    "from sklearn.model_selection import train_test_split\r\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences \r\n",
    "\r\n",
    "from nltk.corpus import stopwords \r\n",
    "from nltk.tokenize import word_tokenize\r\n",
    "nltk.download('punkt')\r\n",
    "nltk.download('stopwords')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 3
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 108
    },
    "colab_type": "code",
    "id": "WO_Q8mg8Zg9C",
    "outputId": "107bb42d-58e6-4844-c0b3-acd209dd1d52"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "drive.mount(\"/content/drive\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "GLUjgjw4Zizy",
    "outputId": "dc47c301-0c1a-4662-87fb-ae226321e617"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "data_clickbait = pd.read_csv ('/content/drive/My Drive/clickbait_data' , sep = '\\n' , header = None)\r\n",
    "data_noclickbait = pd.read_csv ('/content/drive/My Drive/non_clickbait_data' , sep = '\\n' , header = None)\r\n",
    "data_clickbait['class'] = [1 for i in range(data_clickbait.shape[0])]\r\n",
    "data_noclickbait['class'] = [0 for i in range(data_noclickbait.shape[0])] \r\n",
    "data_Final = pd.concat((data_clickbait , data_noclickbait), ignore_index = True) \r\n",
    "df = data_Final.rename(columns = { 0 : \"text\" })\r\n",
    "print(df.shape)\r\n",
    "df.head(5)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(32000, 2)\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "                                                text  class\n",
       "0                                 Should I Get Bings      1\n",
       "1      Which TV Female Friend Group Do You Belong In      1\n",
       "2  The New \"Star Wars: The Force Awakens\" Trailer...      1\n",
       "3  This Vine Of New York On \"Celebrity Big Brothe...      1\n",
       "4  A Couple Did A Stunning Photo Shoot With Their...      1"
      ],
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>text</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Should I Get Bings</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Which TV Female Friend Group Do You Belong In</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>The New \"Star Wars: The Force Awakens\" Trailer...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>This Vine Of New York On \"Celebrity Big Brothe...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>A Couple Did A Stunning Photo Shoot With Their...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 5
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 216
    },
    "colab_type": "code",
    "id": "I8rE44VZwjmQ",
    "outputId": "3489b957-d967-4254-b05a-fe389491a16f"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "stop_words  = set(stopwords.words('english'))"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VyA7JmVAZ50Z"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "L = []\r\n",
    "for  i , token  in  enumerate (df['text']) :\r\n",
    "    words = [w for w in token.split()]\r\n",
    "    L.append(len(words))\r\n",
    "sequence_size = max (L)\r\n",
    "\r\n",
    "X = df['text']\r\n",
    "y = df['class']\r\n",
    "X_train, X_test, y_train, y_test = train_test_split(X , y, test_size = 0.2, random_state = 42)\r\n",
    "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.25, random_state = 42)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "87wv0ADBZ7tq"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "y_train = np.array(y_train)\n",
    "y_test = np.array(y_test)\n",
    "y_val = np.array(y_val)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8J-6KN_ZZ9dp"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "WORD2VEC_VECTORS_BIN  = '/content/drive/My Drive/GoogleNews-vectors-negative300.bin'\n",
    "w2v  =  gensim.models.KeyedVectors.load_word2vec_format(WORD2VEC_VECTORS_BIN , binary = True)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OM9dY7aUZ_Pq"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "embedding_dim = 300\n",
    "def create_data(data, sequence_size, embedding_dim):\n",
    "    embedding_data = np.zeros((len(data), sequence_size, embedding_dim))\n",
    "    for i,sentence in enumerate(data) :\n",
    "        sentence = sentence.replace('-', ' ')\n",
    "        words = nltk.word_tokenize(sentence)\n",
    "        j = 0 \n",
    "        for w in words:\n",
    "            try :\n",
    "                embedding_data[i , j] = w2v[w]\n",
    "                j += 1\n",
    "            except :\n",
    "                pass\n",
    "    return embedding_data\n",
    "        \n",
    "train_data = create_data(X_train, sequence_size, embedding_dim)\n",
    "test_data = create_data(X_test, sequence_size, embedding_dim)\n",
    "val_data = create_data(X_val, sequence_size, embedding_dim)\n",
    "print(test_data.shape)\n",
    "print(train_data.shape)\n",
    "print(val_data.shape)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(6400, 26, 300)\n",
      "(19200, 26, 300)\n",
      "(6400, 26, 300)\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "EPH4XjAjLBhw",
    "outputId": "3cc00131-3d60-4532-cee7-42c91be8847a"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "class PositionalEncoding(layers.Layer):\n",
    "  \n",
    "    def __init__(self) :\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "    def get_angles(self, pos, i, d_model) :\n",
    "        angles = 1 / np.power(10000., (2*(i//2)) / np.float32(d_model))\n",
    "        return pos * angles\n",
    "\n",
    "    def call(self, inputs) :\n",
    "        seq_length = inputs.shape.as_list()[-2]\n",
    "        d_model = inputs.shape.as_list()[-1]\n",
    "        angles = self.get_angles(np.arange(seq_length)[:, np.newaxis],np.arange(d_model)[np.newaxis, :],d_model)\n",
    "        angles[:, 0::2] = np.sin(angles[:, 0::2])\n",
    "        angles[:, 1::2] = np.cos(angles[:, 1::2])\n",
    "        pos_encoding = angles[np.newaxis, ...]\n",
    "        return inputs + tf.cast(pos_encoding, tf.float32)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jFl9wNKwaQm2"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "def scaled_dot_product_attention(queries, keys, values, mask) :\n",
    "    product = tf.matmul(queries, keys, transpose_b  = True)\n",
    "    keys_dim = tf.cast(tf.shape(keys)[-1], tf.float32)\n",
    "    scaled_product = product / tf.math.sqrt(keys_dim)\n",
    "    attention = tf.matmul(tf.nn.softmax(scaled_product, axis = -1), values)\n",
    "    return attention"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Q7LtllFaV12"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "class MultiHeadAttention(layers.Layer):\n",
    "    \n",
    "    def __init__(self, nb_proj) :\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        self.nb_proj = nb_proj\n",
    "        \n",
    "    def build(self, input_shape) :\n",
    "        self.d_model = input_shape[-1]\n",
    "        assert self.d_model % self.nb_proj == 0\n",
    "        self.d_proj = self.d_model // self.nb_proj\n",
    "        self.query_lin = layers.Dense(units=self.d_model)\n",
    "        self.key_lin = layers.Dense(units=self.d_model)\n",
    "        self.value_lin = layers.Dense(units=self.d_model)\n",
    "        self.final_lin = layers.Dense(units=self.d_model)\n",
    "        \n",
    "    def split_proj(self, inputs, batch_size): \n",
    "        shape = (batch_size,-1, self.nb_proj,self.d_proj)\n",
    "        splited_inputs = tf.reshape(inputs, shape=shape)\n",
    "        return tf.transpose(splited_inputs, perm=[0, 2, 1, 3]) \n",
    "    \n",
    "    def call(self, queries, keys, values, mask) :\n",
    "        batch_size = tf.shape(queries)[0]\n",
    "        queries = self.query_lin(queries)\n",
    "        keys = self.key_lin(keys)\n",
    "        values = self.value_lin(values)\n",
    "        queries = self.split_proj(queries, batch_size)\n",
    "        keys = self.split_proj(keys, batch_size)\n",
    "        values = self.split_proj(values, batch_size)\n",
    "        attention = scaled_dot_product_attention(queries, keys, values, mask)\n",
    "        attention = tf.transpose(attention, perm=[0, 2, 1, 3])\n",
    "        concat_attention = tf.reshape(attention,shape=(batch_size, -1, self.d_model))\n",
    "        outputs = self.final_lin(concat_attention)\n",
    "        return outputs"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2lDxXvPwaeN0"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "class EncoderLayer(layers.Layer):\n",
    "    \n",
    "    def __init__(self, FFN_units, nb_proj, dropout_rate) :\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.FFN_units = FFN_units\n",
    "        self.nb_proj = nb_proj\n",
    "        self.dropout_rate = dropout_rate\n",
    "    \n",
    "    def build(self, input_shape) :\n",
    "        self.d_model = input_shape[-1]\n",
    "        self.multi_head_attention = MultiHeadAttention(self.nb_proj)\n",
    "        self.dropout_1 = layers.Dropout(rate=self.dropout_rate)\n",
    "        self.norm_1 = layers.LayerNormalization(epsilon=1e-6)\n",
    "        self.dense_1 = layers.Dense(units=self.FFN_units, activation=\"relu\")\n",
    "        self.dense_2 = layers.Dense(units=self.d_model)\n",
    "        self.dropout_2 = layers.Dropout(rate=self.dropout_rate)\n",
    "        self.norm_2 = layers.LayerNormalization(epsilon=1e-6)\n",
    "        \n",
    "    def call(self, inputs, mask, training) :\n",
    "        attention = self.multi_head_attention(inputs,\n",
    "                                              inputs,\n",
    "                                              inputs,\n",
    "                                              mask)\n",
    "        attention = self.dropout_1(attention, training=training)\n",
    "        attention = self.norm_1(attention + inputs)\n",
    "        outputs = self.dense_1(attention)\n",
    "        outputs = self.dense_2(outputs)\n",
    "        outputs = self.dropout_2(outputs, training=training)\n",
    "        outputs = self.norm_2(outputs + attention)\n",
    "        return outputs"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4uvjMQttaeQ7"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "class Encoder(layers.Layer) :\n",
    "    \n",
    "    def __init__(self,\n",
    "                 nb_layers,\n",
    "                 FFN_units,\n",
    "                 nb_proj,\n",
    "                 dropout_rate,\n",
    "                 d_model,\n",
    "                 name=\"encoder\") :\n",
    "\n",
    "        super(Encoder, self).__init__(name=name)\n",
    "        self.nb_layers = nb_layers\n",
    "        self.d_model = d_model\n",
    "        self.pos_encoding = PositionalEncoding()\n",
    "        self.dropout = layers.Dropout(rate=dropout_rate)\n",
    "        self.enc_layers = [EncoderLayer(FFN_units,\n",
    "                                        nb_proj,\n",
    "                                        dropout_rate) \n",
    "                           for _ in range(nb_layers)]\n",
    "    \n",
    "    def call(self, inputs, mask, training) :\n",
    "        inputs *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
    "        outputs = self.pos_encoding(inputs)\n",
    "        outputs = self.dropout(outputs, training)\n",
    "        for i in range(self.nb_layers) :\n",
    "            outputs = self.enc_layers[i](outputs, mask, training)\n",
    "        return outputs"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kaF-Q2K_lm16"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "class Transformer(tf.keras.Model):\n",
    "    \n",
    "    def __init__(self,\n",
    "                 d_model,\n",
    "                 nb_layers,\n",
    "                 FFN_units,\n",
    "                 nb_proj,\n",
    "                 dropout_rate,\n",
    "                 name=\"transformer\"):\n",
    "        super(Transformer, self).__init__(name=name)\n",
    "        \n",
    "        self.encoder = Encoder(nb_layers,\n",
    "                               FFN_units,\n",
    "                               nb_proj,\n",
    "                               dropout_rate,\n",
    "                               d_model)\n",
    "    \n",
    "    def create_padding_mask(self, seq):\n",
    "        mask = tf.cast(tf.math.equal(seq, 0), tf.float32)\n",
    "        return mask[:, tf.newaxis, tf.newaxis, :]\n",
    "\n",
    "    def create_look_ahead_mask(self, seq):\n",
    "        seq_len = tf.shape(seq)[1]\n",
    "        look_ahead_mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)\n",
    "        return look_ahead_mask\n",
    "    \n",
    "    def call(self, enc_inputs, training = True):\n",
    "        enc_mask = self.create_padding_mask(enc_inputs)\n",
    "        enc_outputs = self.encoder(enc_inputs, enc_mask, training)\n",
    "        return enc_outputs"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GJcIjNCQlseu"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "D_MODEL = 300\n",
    "NB_LAYERS = 2\n",
    "FFN_UNITS = 512\n",
    "NB_PROJ = 4\n",
    "DROPOUT_RATE = 0.1\n",
    "transformer = Transformer(d_model = D_MODEL,\n",
    "                          nb_layers = NB_LAYERS,\n",
    "                          FFN_units = FFN_UNITS,\n",
    "                          nb_proj = NB_PROJ,\n",
    "                          dropout_rate = DROPOUT_RATE)\n",
    "\n",
    "\n",
    "  \n",
    "inputs = layers.Input(shape = (sequence_size,D_MODEL))\n",
    "x = transformer(inputs)\n",
    "x = layers.Flatten()(x)\n",
    "x = layers.Dense(512, activation=\"relu\")(x)\n",
    "x = layers.Dropout(DROPOUT_RATE)(x)\n",
    "x = layers.Dense(256, activation=\"relu\")(x)\n",
    "x = layers.Dropout(DROPOUT_RATE)(x)\n",
    "outputs = layers.Dense(1, activation=\"sigmoid\")(x)\n",
    "model = keras.Model(inputs = inputs, outputs = outputs)\n",
    "model.summary()\n",
    "model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Model: \"functional_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         [(None, 26, 300)]         0         \n",
      "_________________________________________________________________\n",
      "transformer (Transformer)    (None, 26, 300)           1340824   \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 7800)              0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 512)               3994112   \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 512)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 256)               131328    \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 257       \n",
      "=================================================================\n",
      "Total params: 5,466,521\n",
      "Trainable params: 5,466,521\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 454
    },
    "colab_type": "code",
    "id": "9moaXe9eaBqR",
    "outputId": "fd372bae-1c7c-4aa5-a55e-02dcb980ce23"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "history = model.fit(train_data, y_train, batch_size = 64, epochs = 20, validation_data = (val_data , y_val), verbose = 1)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Epoch 1/20\n",
      "300/300 [==============================] - ETA: 0s - loss: 0.1624 - accuracy: 0.9571WARNING:tensorflow:Callbacks method `on_test_batch_end` is slow compared to the batch time (batch time: 0.0027s vs `on_test_batch_end` time: 0.0056s). Check your callbacks.\n",
      "300/300 [==============================] - 10s 32ms/step - loss: 0.1624 - accuracy: 0.9571 - val_loss: 0.1042 - val_accuracy: 0.9744\n",
      "Epoch 2/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0544 - accuracy: 0.9823 - val_loss: 0.0698 - val_accuracy: 0.9831\n",
      "Epoch 3/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0459 - accuracy: 0.9859 - val_loss: 0.0580 - val_accuracy: 0.9844\n",
      "Epoch 4/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0402 - accuracy: 0.9867 - val_loss: 0.0475 - val_accuracy: 0.9814\n",
      "Epoch 5/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0336 - accuracy: 0.9879 - val_loss: 0.0652 - val_accuracy: 0.9825\n",
      "Epoch 6/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0401 - accuracy: 0.9879 - val_loss: 0.0742 - val_accuracy: 0.9772\n",
      "Epoch 7/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0380 - accuracy: 0.9879 - val_loss: 0.0462 - val_accuracy: 0.9837\n",
      "Epoch 8/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0366 - accuracy: 0.9876 - val_loss: 0.0482 - val_accuracy: 0.9847\n",
      "Epoch 9/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0349 - accuracy: 0.9882 - val_loss: 0.0538 - val_accuracy: 0.9836\n",
      "Epoch 10/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0320 - accuracy: 0.9891 - val_loss: 0.0698 - val_accuracy: 0.9786\n",
      "Epoch 11/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0386 - accuracy: 0.9860 - val_loss: 0.0637 - val_accuracy: 0.9825\n",
      "Epoch 12/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0349 - accuracy: 0.9879 - val_loss: 0.0638 - val_accuracy: 0.9844\n",
      "Epoch 13/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0348 - accuracy: 0.9884 - val_loss: 0.0501 - val_accuracy: 0.9847\n",
      "Epoch 14/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0540 - accuracy: 0.9828 - val_loss: 0.0632 - val_accuracy: 0.9762\n",
      "Epoch 15/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0561 - accuracy: 0.9814 - val_loss: 0.0596 - val_accuracy: 0.9755\n",
      "Epoch 16/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0464 - accuracy: 0.9850 - val_loss: 0.0622 - val_accuracy: 0.9806\n",
      "Epoch 17/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0419 - accuracy: 0.9868 - val_loss: 0.0750 - val_accuracy: 0.9789\n",
      "Epoch 18/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0555 - accuracy: 0.9822 - val_loss: 0.0731 - val_accuracy: 0.9769\n",
      "Epoch 19/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0589 - accuracy: 0.9805 - val_loss: 0.0609 - val_accuracy: 0.9809\n",
      "Epoch 20/20\n",
      "300/300 [==============================] - 9s 29ms/step - loss: 0.0402 - accuracy: 0.9869 - val_loss: 0.0590 - val_accuracy: 0.9827\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 783
    },
    "colab_type": "code",
    "id": "oOnxkZRdaEAi",
    "outputId": "b3ed4a45-5b75-49c8-bb85-ede4efd2534f"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Training', 'Validation'], loc='lower right')\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUVfrA8e+bTkIoqZTQSyiKAQIWpIpKURFsoGJdu2vFXV1ddV3Lb11WRGVVVBRURMS1IQKCNKV3gUAILYSShJYJCenn98e5gSEGMglzZ5LM+TzPPJm5bc4NYd457T2ilMIwDMMwXOXn7QIYhmEYNYsJHIZhGEalmMBhGIZhVIoJHIZhGEalmMBhGIZhVIoJHIZhGEalmMBhGGcgIi1FRIlIgAvH3iEiv3qiXIbhbSZwGLWCiOwWkQIRiSqzfZ314d/SOyUzjNrHBA6jNtkFjCp9ISLnA6HeK0714EqNyTAqwwQOozb5FLjN6fXtwBTnA0SkvohMEZFMEdkjIs+JiJ+1z19ExorIIRHZCQwt59yPROSAiOwTkZdFxN+VgonIVyJyUESyRGSxiHR22ldHRP5jlSdLRH4VkTrWvktFZKmIHBORvSJyh7V9oYj8yekapzWVWbWsh0RkO7Dd2jbeuoZDRNaISG+n4/1F5G8iskNEsq39zURkgoj8p8y9fC8ij7ty30btZAKHUZssB+qJSEfrA30k8FmZY94G6gOtgb7oQHOnte8e4CqgK5AIXF/m3E+AIqCtdcwVwJ9wzU9AOyAGWAt87rRvLNAduASIAP4ClIhIC+u8t4FoIAFY7+L7AVwLXAh0sl6vsq4RAUwFvhKREGvfE+ja2hCgHnAXkAtMBkY5BdcoYKB1vuGrlFLmYR41/gHsRn+gPQe8BgwCfgYCAAW0BPyBAqCT03n3AQut578A9zvtu8I6NwCIBfKBOk77RwELrOd3AL+6WNYG1nXro7+8nQAuKOe4Z4BvznCNhcCfnF6f9v7W9QdUUI6jpe8LbAOGneG4JOBy6/nDwCxv/3ubh3cfpu3TqG0+BRYDrSjTTAVEAYHAHqdte4Cm1vMmwN4y+0q1sM49ICKl2/zKHF8uq/bzCnADuuZQ4lSeYCAE2FHOqc3OsN1Vp5VNRMYAd6PvU6FrFqWDCc72XpOBW9GB+FZg/DmUyagFTFOVUasopfagO8mHAP8rs/sQUIgOAqWaA/us5wfQH6DO+0rtRdc4opRSDaxHPaVUZyp2MzAMXSOqj679AIhVpjygTTnn7T3DdoAcTu/4b1TOMSdTX1v9GX8BbgQaKqUaAFlWGSp6r8+AYSJyAdAR+PYMxxk+wgQOoza6G91Mk+O8USlVDEwHXhGRcKsP4QlO9YNMBx4RkTgRaQg87XTuAWAu8B8RqScifiLSRkT6ulCecHTQOYz+sH/V6bolwCTgDRFpYnVSXywiweh+kIEicqOIBIhIpIgkWKeuB0aISKiItLXuuaIyFAGZQICIPI+ucZT6EPiniLQTrYuIRFplTEP3j3wKfK2UOuHCPRu1mAkcRq2jlNqhlFp9ht1/Rn9b3wn8iu7knWTt+wCYA2xAd2CXrbHcBgQBW9D9AzOAxi4UaQq62Wufde7yMvvHAL+jP5yPAP8C/JRSqeia05PW9vXABdY549D9NenopqTPObs5wGwg2SpLHqc3Zb2BDpxzAQfwEVDHaf9k4Hx08DB8nChlFnIyDOPsRKQPumbWQpkPDZ9nahyGYZyViAQCjwIfmqBhgAkchmGchYh0BI6hm+Te9HJxjGrCNFUZhmEYlWJqHIZhGEal+MQEwKioKNWyZUtvF8MwDKNGWbNmzSGlVHTZ7bYGDhEZhJ5l6o/uWPu/MvtboIdCRqOHG95qjRlHRP7FqSRz/1RKfWltbwVMAyKBNcBopVTB2crRsmVLVq8+0+hMwzAMozwisqe87bY1VVlpFiYAg9FJ1kaJSKcyh40FpiilugAvoXMMISJDgW7ohGwXAmNEpHSy0r+AcUqptuix9BVNfDIMwzDcyM4+jp5AilJqp1UjmIZOu+CsEzqxHMACp/2dgMVKqSJr9u9GYJDoJEED0BOvQE9KutbGezAMwzDKsDNwNOX0malpnEomV2oDMMJ6PhwIt9IcbEAHilArjXN/dA6hSOCYUqroLNcEQETuFZHVIrI6MzPTLTdkGIZheH9U1Rigr4isQ6+NsA8oVkrNBWYBS4EvgGVAcWUurJSaqJRKVEolRkf/oW/HMAzDqCI7A8c+Ts80GsepLKQAKKX2K6VGKKW6As9a245ZP19RSiUopS5HZ/BMRieJa+C0FOYfrmkYhmHYy87AsQpoJyKtRCQIvRrb984HiEhU6cpi6EVrJlnb/Uszc4pIF6ALMNdKd7CAUyuz3Q58Z+M9GIZhGGXYFjisfoiH0Vk5k4DpSqnNIvKSiFxjHdYP2CYiyegV1l6xtgcCS0RkCzARPUy3tF/jr8ATIpKC7vP4yK57MAzDMP7IJ1KOJCYmKjOPw/Ck/KJiFm3LJKegiOFd47xdHMOoEhFZo5RKLLvdJ2aOG4YnFBaX8FvKIX7YcIC5Ww6SnacryVm5hdzRq5WXS2cY7mMCh2Gcg+ISxYqdh/lh4wFmbzrA0dxCwkMCuLJzI67q0pjPlqfy0swtNIsI5bKOsd4urmG4hQkchlFJJSWKNalHmblhP7M2HSQzO5/QIH8u7xTLVV2a0Kd9FMEB/gD0bBXBje8v489frGP6fRdzXtP6Xi69YZw708dhGC5QSrExLYsfNuznx98PcCArj+AAPwZ0iOHqC5rQPz6GOkH+5Z6b7shj+ITfKFaKbx/qReP6dco9rjrJKywmJeM4JUrRJa6Bt4tjeMmZ+jhM4DCMM1BKkXQgm5kb9zNz4wFSj+QS6C/0bR/N1Rc04bKOsdQNdq3SnnTAwQ3vLaN5RCjT77/Y5fPsppTioCOPrQey2XLAwdaD2Ww94GDnoRyKSxR+AvOf7EerqDBvF9XwAhM4TOAwKlBSokjJPM7KXUdOPg468vD3E3q1jeKqLo25slMj6ocGVun6C7dlcPfk1fRtH83E0d0J8Pds4oYTBcUkp2ez9aCDpAPZJFmBIutE4clj4hrWoUOjenRsHE6rqDCe/t/v3NA9jleGn+/RshrVgxlVZVTa+r3H2LD3mFfLUCfQn+aRobSMDCMmPBg/P3HbtYuKS9hywHEySKzafYSjufpDNCY8mAtbR3Jx60iu7BxLZN3gc36/fvExvHhNZ/7+7SZe/jGJF6/pfM7XPJt9x07wzdo0HSQOOth9KIcS63tiaJA/8Y3CGdqlMR0bhdOhcT3iG4VTL+T0oLhq91G+WpPGYwPbEx1+7r8Do3YwgcM4TUmJYmFyBu8t2snKXUe8XZzThAT60SIijBaRobSMsn5G6p+N69fBv4KgkldYzMa0LFbuOszK3UdZs/sIOQU6BVqLyFAGdoylR6sILmwVQfOIUHQyZvcafVEL9hzK4cNfd9EiMpQ7bRqmO3Pjfp753+9k5xXRPCKUjo3DubpLEzo2Dqdj43o0axjqUhC+p3crpq1KZcqy3Tx5RbwtZTVqHhM4DAAKikr4YcN+3l+8g+T04zSpH8Lfr+rE1V0ae7xJxVl2XiF7Duey53AOu62fOw/lsHBbJgXFJSePC/L3o1lEHSuQhNEyKpQWkbpdftWuI6zcfYT1e49RUKTPiY8NZ0S3OHq2iqBnqwhi64V47J6eGdKRPUdy9TDdhqEM7OS+Ybq5BUW8+P1mpq9OI6FZA8aPTDj5e6iK1tF1uaJTLFOW7eH+vm0IqyZ9M4Z3mT4OH3c8v4hpK1P56NddHMjKIz42nPv6tubqC5oQ6MWAUZHiEt2pu+fQqYCy+3AOew7nsvtwDnmFp4KKv59wXpN6VpCIJLFFQxqGBXmx9PoD/qb3l5OScZyv7nfPMN1N+7J45It17Dqcw4P92vDYwPZu+Tdcm3qUEf9dyvNXdeKuS81ERl9iOsdN4DhNZnY+nyzdxafL9uDIK+Ki1hHc17cN/dpH29JE40lKKTKy89l9KIeiEkVCswbV8ptyhiOPayf8RlGJHqbbpEHVhumWlCgm/baL12dvo2FYIONuSuCSNlFuLeuN7y1j37ETLHyqX7X+QmG4lwkcJnAAsOtQDhMX7+TrtWkUFpcwqHMj7u3Tmq7NG3q7aD5p60EH17+7jLiGdZjxwCWVHqabmZ3PmK82sCg5k4EdY3n9+i5E2FCbmp+Uzt2TV/PmTQlc27XctdOMWsiMqvJx6/ce4/1FO5i9+SCB/n5c1y2Oe/u0NuPzvaxDo3pMuKUbd32yij9PXcsHtyW63Ke0KDmTJ6dvwJFXyD+HdebWi1rYVlvsHx9Du5i6vLdoB8MSmtT4WqkvKC5R5BYUER5SteHjZ2PqnLWYUooF2zIYOXEZ1074jd9SDvFgvzb8+tf+vDbifBM0qom+7aP5xzWdWbAtk5dmbqGiVoD8omJenrmF2yetJCIskO8f7sXoi1va+mHu5yfc26c1Ww9ms2T7IdvepzpZsfMwr/2UdHJARU2zcFsGF746n037stx+bVPjqGXyi4pZsfMI85PSmZeUwb5jJ2hcP4TnhnZkZM/m1WbGsnG6Wy9qwZ7DOXywZBctI8PO2Am9M/M4j0xbx6Z9Dm69qDnPDe1ESGD5qU7cbVhCU8bO3cb7i3fQp33tXY65oKiEN35O5v3FO1AKYsJDuLsGDgr4fEUqYcEBxDcKd/u1zadILXAkp4AFWzOYl5TO4uRMcgqKCQn049K2UYy5sj1Dz29CUICpXFZ3zwzuSOqRXP754xbiGtbhis6NTu5TSjFjTRovfL+ZoAA/3h/dnSud9ntCUIAfd1/aildnbeX3tCzOj6t9CRu3p2fz6LT1bDngYFTPZqQeyeWt+du5rltTGoR6dyReZaQdzWXBtgwe7t/WlsEMJnDUQEopUjKOMy8pg/lJ6axNPUqJgth6wVyT0JSBHWO4pE3UGZPuGdWTn5/w5k1duWniMh6dtp7p913M+XH1ceQV8uw3m/hhw34uah3BuJsSvJYocVTP5rw9P4X3F+/gnZu7eaUMdlBKMWXZHl6dlURYcAATR3fnis6N2HrQwZDxS3j7lxT+flUnbxfTZV+u2gvATT2a2XJ9EzhqiMLiElbtOqKDxdZ09hzOBaBzk3o8PKAdl3eMpXOTem5NyWF4Xp0gfz68PZHhE5Zy9+RV/OOazrwyK4kDWXk8dWU89/dtU+EMeTuFhwRyy0UtmLh4B6mHc2keGeq1srhLhiOPp2ZsZFFyJv3io3n9+i7EhOsJoR0a1ePGxGZMWbab0Re1oGUN6BcsLC5h2qq99I+PIa6hPf8+JnBUY7kFRfy8RfdVLNyWQXZeEUEBfvRqE8k9vVtzWceYGpGi26icmPAQJt3Rg+veXcoDn68lrmEdpt93Md1bVI8h03f2asmkX3fx4a87eWnYed4uzjmZvekgz/xvI7kFxWccmfbEFe35fsN+/u+nrbw3uruXSuq6+UnpZGbnc3PP5ra9hwkc1VRhcQk3f7CC9XuPEVU3iMHnNeKyjrH0bhdFaJD5Z6vt4huFM+mOHsxPSuehAW3/kHzQm2LrhTC8a1Omr97Lo5e1c0sCSE/LyS/ipR+28OXqvZzXtB5v3pRA25jyO5FjwkO4v28b3vg5mZW7jtCzVYSHS1s5n69IpUn9EPp3iLHtPcwnUDU17udk1u89xr+v78J13eJME5QPKs2jVR3d06c1X67ey5Rle3j88vbeLk6lrE09yuNfrif1SO7J1CwVDR65p3drpq5I5ZUft/DNg72q7f/HPYdzWLL9EE9c3t7WJk0z1KYaWppyiHcX7WBkj2bckNis2v6RGr6rbUxdBnaMZcqy3eQWFHm7OC4pKi5h3M/J3PDeMoqKFV/eezF/GdTBpRGHdYL8eerKeDakZfHDxv0eKG3VTF2Zir+f2NYpXsrWwCEig0Rkm4ikiMjT5exvISLzRWSjiCwUkTinfa+LyGYRSRKRt8RqeLSO2yYi662HffUxLziSU8Dj09fTKiqM56+uOaM4DN9zf9/WHM0t5KvVad4uSoV2H8rh+veWMX7+doZd0ISfHutd6drc8K5NOa9pPV6fvY28wmKbSlp1+UXFzFidxsCOMbZne7YtcIiIPzABGAx0AkaJSNlPwrHAFKVUF+Al4DXr3EuAXkAX4DygB9DX6bxblFIJ1iPDrnvwNKUUf/16I0dyCnhrZFfTl2FUa4ktI+jeoiEfLNlJUXH1nF2tlGLaylSGvLWEnZnHeXtUV964KaFKfUZ+fsKzQzqx79gJJv22y4bSnps5m9M5nFPAzRe2sP297Kxx9ARSlFI7lVIFwDRgWJljOgG/WM8XOO1XQAgQBAQDgUC6jWWtFj5bkcrPW9L566AObkmzbRh2u69Pa9KOnmDWpoPeLsofZJ0o5L5P1/D0/34noVkD5jzeh6svaHJO17y4TSQDO8by3wU7OHQ8300ldY/Pl++hWUQderd1b2bk8tgZOJoCe51ep1nbnG0ARljPhwPhIhKplFqGDiQHrMccpVSS03kfW81Uf5czJOgRkXtFZLWIrM7MzHTH/dgqOT2bl2duoU/7aO6yaVU4w3C3gR1jaR0dxvuLdlSYY8uTlFI8OX09C7Zl8OyQjnx294VuG7r+zJAO5BUWM+7nZLdczx1SMo6zYtcRRvVs7pE+UW93jo8B+orIOnRT1D6gWETaAh2BOHSwGSAiva1zblFKnQ/0th6jy7uwUmqiUipRKZUYHV298+rkFRbzyBfrCA8J4D83XGA6w92hpBh2LIDfZ0BBrrdLU3MUFcCRnbBzEaz7DDZ/e9bD/fyE+/q0ZvN+B7+lHPZQISv2+YpU5iVl8MzgjtzTp7Vb/0+1ia7LLRc254uVqWxPz3bbdc/F1BWpBPoLN3S3t1O8lJ2N6PsA57uIs7adpJTaj1XjEJG6wHVKqWMicg+wXCl13Nr3E3AxsEQptc86N1tEpqKbxKbYeB+2e21WElsPZvPxnT2IDq95Y+KrlYO/w4ZpOmAct5pPQupD19HQ426IaO3d8nlbngOy9kJWGhxL1c+P7T3183g6uqXYSZON0PDM7ebXdm3K2Lk6KeCl7exvJqlISkY2L/+oa+93XNLSlvd4dGB7/rduH6/OSuLjO3va8h6uyiss5uu1aVzZuZHHPj/sDByrgHYi0godMEYCNzsfICJRwBGlVAnwDDDJ2pUK3CMirwGCro28KSIBQAOl1CERCQSuAubZeA+2m5+UzuRle7irVyv6xzsNECsphqQfwC8AOl7lvQLWBFn74PevYON0yNisf2ftroAuN0FoJKz+CJa/C8sm6O0974U2A8DP2xVumx3YCOs/1wHi2F7ISoW8Mim2/YOgXlNo0AzaDtQ/6zfTPxGYfBVs+wkuuv+MbxMc4M9dvVrxr9lb2bw/i85NvNc/l19UzCNfrCc0KICx13exrfYeERbEnwe05dVZW/l1+yGvBswfNx4g60QhN19o30zxsmwLHEqpIhF5GJgD+AOTlFKbReQlYLVS6nugH/CaiChgMfCQdfoMYADwO/rrz2yl1A8iEgbMsYKGPzpofGDXPditNEdOx8b1+OvgeL2xuFB/AP76BhxO0dtumAydr/VeQaujPIcOrBunwa4lgIK4HjBkLHQeAWGRp45t1Rsc+2HNJ7D6Y/j8Ol3z6HEPJNwMdRp46y7sUVICy/8L814E/0Bo2FIHg+YXngoK9ZtD/TioG3v2ABoVD9tmnTVwANx8YXMmLEhh4uKdjB/Z1a23UxlvzE1mywEHH9yWSIzNQ1Jvv6Qlny7fw8s/buHHR3p7LYfY1JWptI4K4+LWkRUf7CZm6VgvKSlR3DZpJav3HGHmny+lbcNAWP8Z/DpefzOMPR96Pw4rJsL+dXD7D/o/vi8rLoQdv8DGL2HrLCg6AQ1b6ZpFlxshsk3F1ygqgKTvYeVE2LsCAkP1+T3vgdjO9t+D3Y5nwLcPQMo8iB8Kw96B0HOYff7zC7DsHXhqR4UB9tVZSXz06y4WjulHswjPJz/8LeUQt3y4glsubM4rw8/3yHvO3Lifh6eu4/XrunCjzZPuypN0wMHg8Ut4bmhH/tTb/c2wZ1o6tpbX1auvD5bs5NeUQ7w0uBVtUybD+AvgxychPBZung73L4HzroNRX+hvhl+MhMM7vF1sz1MK9q2Bn/4K/+kAU2/UwaPrLXD3z/DIOuj/jGtBAyAgCM6/Hu6eC/cugvNGwIYv4N1L4OOhujO4uNDee7JLyjx9H7t/1TWvkZ+fW9AA6DAUSor0tStwZ6+W+Al89Kvn5zgczSngyekbaB0dxnNDPTdxduj5jenWvAFj524jJ9/zM+inrkglKEAvBe1JJnB4wca0Y7w7Zx3jm8zjhl+HwNxnIbo93Pa9/jBsfyWUjjIOjYBbZ+jXn10HOb6xbCcAuxbDOz3ggwG6iallLxg5FZ5MhqH/gWY9T/2eqqJJAgybAE8kweUv6ZreV7fDm11g0b/1t/eaoCgf5jyr/z5Co+CeBboG5Y6lZJsmQlg0bP2xwkMb16/DsISmfLlqL0dzCs79vV2klOJv3/zO4Zx83hrZ1aPr0IgIzw7tREZ2PhMX7/TY+4JO1PjNun0MPb8xDcM8u8iUCRwelnM0nQ2Tx7Ak6M8MOzIJaZqog8XtP0DrvuX/Z49oDaO+hOwDuuZReMLzBfc0pWD2M1CUB1ePhzHJcOMU/Q04wM3/SUIjoNej8Mh6GDUNYjrAgpfhjU66plOdm3MPpcCHA3VzUo8/wb0LINaN37j9/KD9IF3jKKo4GNzbpzUnCov5dPke95WhAl+tTuOnTQcZc0W8VybOdm/RkKFdGvP+4h0czMrz2Pv+sGE/x/OLuMWDneKlTODwlOyDMOdZAt/qwi0FMyho0RfuWwy3TNffnCvSrAdc9yGkrYav/6RHXdVm+9ZC+ibo/QR0v8MzHdh+/hA/GEZ/Aw+v1s1YK96DHfPtf+/KUkrPs3i/jx5KO3KqroUF2rA+S4ehkO+APb9WeGj72HAGdIjhk6W7PZLPafehHF78YTOXWGvUeMvTgzpQUgJj527z2HtOXZlKfGy4V9ZpMYHDbsdSdd/Fm10oWf4uPxQlMrnrNCLvnAaNL6jctTpeDYNeg60zYe5z9pS3ulj7ie64Pu9677x/VDu45h09+uiXl6tXrePEMZhxF3z3EDTtBg8s1R/udmndDwLq6AEJLrivT2uO5BTw1Rp7kx8WFpfw6JfrCfT34z83enfibLOIUO7o1ZKv16axeX9WxSeco9/TstiYlsXNFzb/w8JTnmACh51WfgBvdYU1kzne4XqGlozj88Z/Y/TVV1T9mhc9ABc+oIdbLn/XfWWtTvKz4fev9Tf+kHreK0dAEPT7qx7V5kIbv0ekroD3esOW72DA3+G276DeueVfqlBgHT3vZdtPLgXQnq0iSGjWgA8W76S4xL6A+9b87WzYe4z/G3F+tVgJ86H+bWlQJ5BXfkyyPf3K1JV7qBPoz/BuZbM4eYYJHHZRCn4dB026UfTnddyWeQtpNGL8yK4E+J/jr/3KV6DDVboPIOkH95S3Ovl9BhTmQLc7vF0S6DISItvCgle82zxYUgyLXoePB+t+sLvmQJ8xunnNEzoMAUcaHNxY4aEiwv19W5N6JJfZNiU/XLnrCBMWpHBjYhyDz29sy3tUVv06gTw2sD1Ldxzml632Daxw5BXy3fr9XH1BY6+tDGkCh13SN4FjH3S7jbdWn2Bt6jFeHn6ee8a3+/nDiA+gaXfd37F31blfszpZOxliOkHcH4aPe55/APR7BjK2wOZvvFOGrH0w+RodvDoP10O1m/XwbBnaDwLE5eaqyzs1olVUGBMWpJCV697hzVknCnn8y/U0jwjlhaur19ybmy9sTuvoMF6dlUShTanmv1u3j9yCYm5xJX16QY4tZTCBwy7JswFYF9KTd37ZzohuTRmW4MZqZVAo3PwlhDeGL27SielqgwMbddNQt9vdM5zUHTqPgNjzYMGrUOzhsfpJP+i5GfvXwbXv6gESIV5I6REWBc0u1LPIXeDvJzx+eXuSDjro/fovvL9oh9s6y5//bhMHHXm8ObIrYcHVa82aQH8/nhnckR2ZOUxbmer26yul+HxFKp2b1KNL3Fn+DkqK4bfx8Ob5cHS328thAoddkudS1KgrD32XRvOIUF4adp773yMsCm6ZAaoEPrsectyUnbS4SLehf3IVTB3p2Y7htZPBP1jPBK8u/Pyg/7NwZAdsmOq5913+Lnx5q04Zcv8SnR7Fm8G0wxDdVHVsb8XHAtdc0IRZj/SmW4uGvPbTVgaMXciMNWnn1O/x7bp9fLd+P48PbEdCs+qZKmZgxxguah3BuHnbceS5t7a1NvUYWw9mc8uFLc7cKZ6xFT66HH5+HppfrAeZuJkJHHbIOQRpq1hMNzKy8xk/sit17fpmFNVWzz3ISoNpN0PhOYwjP54Ji/8N47vA9Nt0ptnkn2D7z+4r79kU5MLGr6DTsHOf8exu8YN10+Ci1/WEO7tlbtPpPtoP1vN8XJ0Zb6f4Ifrntp9cPqVj43p8cmdPpt5zIdHhwYz5agND31rCgq0Zle5A3nskl79/u4keLRvyQL+2lTrXk0SE54Z24mhuARMWpLj12lNXpFI3OIBrEsoZEFFcBEvegPd7w5FdcN1HcNNnUNf9q2ubwGGH7T8Dip8KLiCxZUMusPubUfOLYMT7sHc5fHOfTnLnKqX03JD/3QvjOumhp9HxOhg9uQ0aNIfFr3um1rHlW8jP0vM2qhsRGPCcnjOxZrK971VSDN8+qJsjr3nL/RMeqyqqHUS2c7m5ytklbaL49qFevHNzV04UFnPnJ6sY9cFyNuw95tL5RcUlPP7legDG3ZTgtYSCrjqvaX2Gd23Kx7/u5tPleyhxw+iyrNxCZm7cz7CEJn/8Ipq+BT4aCPP/ob/kPLRCp9axqYZqAocdkmdD3UYsz21KI5szdJ7UeThc8bL+8J33fMXHF+bB+qnwQX/48DLd6Zl4l574Nvob/ccXGAKXPg5pq2DnQttvgTWT9QdTi0vsf6+qaN0fWlwKS8bauzjUsuX9WNoAACAASURBVAmwb7XON2XDt8Vz0mGIzoVVNj27C0SEq7o04efH+/KPazqzPf04wyb8xkNT17L70Nk7cf+7cAer9xzl5eHnEdfQ8wkUq+K5oZ24sHUEf/92Ezd/uJzUw+f2N/P12jTyi0pO7xQvLtStBO/30U2IN3yiMyzY/HdjAoe7FRXAjl9Q7a4gPbuQ2PoeChwAFz+sU4UvfVvPISnPsVSdbntcJ51FtSBXf0A9mQSD/6W/VTpLuAXCm+g/TjtlbNU1pm63VZ9O8bJKax3H03V2XTtkJutaX4erdJLL6iZ+CJQUnlPzZVCAH7df0pKFT/XjkQFt+SUpg4FvLOKF7zaVu4732tSjjJ+/neFd3TzAxGYRYUFMuasn/zfifDbtc3Dlm4uZvHR3lWofulN8DwnNGtCpiTW36eAmncftl5f15OCHVugvkB5gAoe7pS6DfAc5LQZSUFxCbLgHA4eI/vBvPxh++suptmil9FKg027RWXh/G687zW77Xv+x9bwHgsPLv2ZAsM7jtOc32P2bfWVfOwX8AnUHcHXW4mK94NFvb+o1QdyppFjPBg+sA0PfqJ4BNK6HTqRYiX6OMwkPCeSJK+JZ9FQ/buzRjM9WpNL39QWMn7f9ZKbZ4/lFPDZtPY3rh/CPYdVr6K0rRISRPZsz9/E+9GwVwQvfb2bkB8vZc7hyw2RX7DrCjswcnZequBAW/gsm9tP5626cAjd8rAfLeIgJHO62fS74B5MWofNPxXqqqaqUnz9c/5FOZzLjLt2ZO+FCmHKNDmq9HoNHN+qU22dKqlhW99shLEb3ddihME+nNu8w1KN//FU24Dk4cVTP3nenFe9B2koY8m+dXr868vOH+EG6xuGm9PMx9UJ4dfj5zH28D73bRTNuXjJ9/72Qz5bv4fnvNpF2NJc3b0rw2mQ3d2jSoA6f3NmD16/vQtIBXfuY9Osul2sfU1ekEh4SwNWxh3Xz8sJX9eJuD67Qg0k8zAQOd0ueDS0v5eAJPaO3UX0vrCEeFKbX9AiL0pPGgkLh2vfg8S0w8AVrWdBKCKwDl/xZ93PYMdlw60w4cUQHqJqgSVfdlLT0Hcg94p5rHt4B81/StcXzb3DPNe0SP0QPYthdcdLDymgTXZf3Rnfn6wcuoVVUKM99u4n/rd3Hw/3bktiymo2yqwIR4cbEZsx9vA8Xt47kpZlbuGniMnZV0L9z+Hg+8zbt5e1Gswn5+DLIToebPtdzesI8t+qfMxM43OlQil7utf0gMhy6rTbGk01VzurG6GGc9y2GexdCwijd2V1ViXdBnQh7+jrWfAINWkCrfu6/tl0GPAcFx3Wz37kqHUUVEAxXjaueTVTOWvfXSQ/d0FxVnu4tGjL9vov54LZEHu7flj9f1q7ik2qQxvXrMOmOHvznhgvYdjCbQW8u5sMlZ87rtXDhz3zt/yz9Dk7S/V4PrYCOV3m41KczgcOdts/RP9tfwUGHnk8RU88LNY5S4Y0qn4H3TILrwsUP6Xvcv9491wT9TXv3Eug2+uxrX1c3MR11zWDF+/ob4LlYOVEPDBj0L6hXPfIunVVQKLTpr4fl2jRMW0S4vFMsY66MJ/Bcc7tVQyLCdd3j+PmJvlzaNoqXf0zihveWsiPz+KmDigtR8//JsNWjiQ04rofIj5hYLeY41b5/EW9Kng3RHaFhS9IdeTQMDSQ4wHOrkdmu57063YU7ax1rp4D4Q8Kt7rump/R7GooLYMl/qn6Nwztg3j+g3ZVwwUj3lc1u8YP1nJb0Td4uSY0WWy+ED29PZNxNF7AjM4ch45cwcfEOXftY8AqyZCzfFl/K8kE/6t95NWECh7vkZcGepXrZVyDdke/5jnG7hdTTKd23zoT0zed+veJCPZek/ZU145t2WZFt9Nrnaz52OQ3HaUpK4Ps/g38QXP1m9W+iclbJpIdeUZin+2Gq01oq5RARhneN4+fH+9CnfTSvztrKmLc/Rf32FkvDB/FK4J+5rFu8t4t5GhM43GXHAigpOhk4MrLzal/gALjwPgiqC4vHnvu1tv0EORk6oWFN1ecv+mdVRpyt+lAPcx70mv1rarhb3Rg9NHdbNVmnpDzzXoRPhsKnw6sW2D0spl4IE0d3Z/xN5/Ono29yuKQuDx++jhsSm1W7lgtbA4eIDBKRbSKSIiJPl7O/hYjMF5GNIrJQROKc9r0uIptFJElE3hIro5eIdBeR361rntzudclzIKQBxOlhuAez8oj1Zv+GXUIj9LyPzd/oyWrnYu1kqNdUz4uoqRo0g+53wrrPdbOTq47sgnkvQNvLq//clTPpMAQObNBp36sbxwFYPUmPgNu7Ev57kX5dA2ofw/J+oDM7+KbRI5zwr8fNPT2/pnhFbAscIuIPTAAGA52AUSLSqcxhY4EpSqkuwEvAa9a5lwC9gC7AeUAPoK91zrvAPUA76zHIrntwWUmxnr/R7nLwD6CouIRDx2thU1Wpix/WQ3TPpW3/WCqkzIeut+o1L2qy3k/q5qaFr7l2fGkTlV8AXD2+ZjVROYu3lqutQu4q2/32JqhiuP5jeHCZXmJ35uMwZRgc3ePt0p3Z0d16Jni7K7nn/idZ/8LltIwK83ap/sDOGkdPIEUptVMpVQBMA8rOVOkE/GI9X+C0XwEhQBAQDAQC6SLSGKinlFqudGrNKcC1Nt6Da/athdxDVrsvHM4poER5YfKfp4RF6eG5v39V9XVA1n2mf3atgZ3iZYXH6ia832foZHMVWf2RHkl25StQv+ak0PiDqHYQ0ab6BQ7Hflj9MVwwCiJaQcMWOkvCVeNg3xr478W6mbAyyUA9QSmY+QSIHwz9D4hUuyaqUnYGjqaAc8NimrXN2QZghPV8OBAuIpFKqWXoQHLAesxRSiVZ56dVcE0AROReEVktIqszMzPP+WbOKnm2HhnUZgAA6dZQ3FobOEBPCPQL0GmcK6ukWAeOtpfp7Lu1Qa9HddqWBa+c/biju3W69DYDoOtojxTNNiK6uWrXEvenXzkXv47TtY0+Y05tE9Ffdh5cpldP/PFJnU3hyC7vlbOs37+CHfPhsucrP0nXw7zdOT4G6Csi69BNUfuAYhFpC3QE4tCBYYCI9K7MhZVSE5VSiUqpxOjoaHeX+3Tb5+jV0azx1QezSgNHLezjKBXeSM/03vBF5TseU+ZZy+rW4E7xskIj9DyXrTN1DbQ8SukmKvGDq9+quU1UzuKH6qSHKfO8XRLNsV9PKE24WS+AVVaD5jD6W/37379er664YqL3ax85h2H209A0EXr8ybtlcYGdgWMf4Bw246xtJyml9iulRiilugLPWtuOoWsfy5VSx5VSx4GfgIut8+POdk2Py9qnFzyyRlMBpGfrWeO1usYB+ls2otuTK2PNJzr3VTUal+4WFz2oZ9efqdax5mPYtRiufLnaf6N0WbOeEBpp2yzySlvyhl4Rs/eYMx8jor/0PLhMJ/v86SmYfJV3l1+e8zc9pP+at3Q+sGrOzsCxCmgnIq1EJAgYCXzvfICIRIlIaRmeASZZz1PRNZEAEQlE10aSlFIHAIeIXGSNproN+M7Ge6jYydnip/roMxx5+AlE1a3FNQ6A+nH6m93aT/UoFlc4DugRaAk3g3/NTVpXrpB6cOlj+tv3nmWn7zuWCnP/Dq371a6alp+//tvfPsdtSQ+rLCtNj9RLuEX3a1SkQTO49Wu45h395e+/l+jlej1d+0iZDxun6bVvYmtGBmDbAodSqgh4GJgDJAHTlVKbReQlEbnGOqwfsE1EkoFYoPSr2gxgB/A7uh9kg1LqB2vfg8CHQIp1jHe/6iTP0XmWok9N0El35BEdHlztVylzi0sf1/NXlr7l2vHrP9Ptz91us7dc3tLjHqgbC7/889TQz9ImKoBr3q4dTVTO4oecmgDrTb+O07/rPmepbZQlotPdPLgcWvXWzUWfDKnc0OpzUZCjR3tFtjt7LamasbWPQyk1SynVXinVRin1irXteaXU99bzGUqpdtYxf1JK5Vvbi5VS9ymlOiqlOimlnnC65mql1HnWNR9WlV242J0KcnXG2PaDTvswOFgbZ42fSUQr6HKTHsVyvIJBCCUlunbSsnf1WEPbDkGh+gNgz2+wwxowuHay/ju54p+1ZzCAszb9ISDEu81VWWk6fU3XW6v2O67fVGeUvvZdPTLu3Uv0Sowlxe4vq7MFr8KxPXpY9rkkIfUwb3eO12y7l0BR3mn9G6CbqnwmcICex1CcD8vePvtxuxbq/yTVcU1xd+p+O9RvpsfjH0uFOc9Bqz56omBtFBSmm+C2/ei9CXZL/qPfu/eTVb+GiG5CfWi5vp85f4OPB+ugZIf96/SaLt3vgJa97HkPm5jAcS6S50BgGLS89LTN6Y5aOmv8TKLaQucRsPLDs69PsWYy1Gmo17KozQKCoe9fYP9a+OQq3VlbG5uonMUP1kHSHTnMKuvYXl2T7TbaPYMO6jXRmWiHv69rH+/30TVGdyou1M2XYTEw8B/uvbYHmMBRVUrpwNGmv/6gsOQVFnM0t9CzS8ZWB33GQGHOmVfFyzkEW3+EC26uUVXyKrvgZj057tgeuPwf5Q8NrU3aDwbEO81VpRkMzqW2UZaIzlZ8zy96qdxPh5/qQ3GHZRN0h/yQ16FOA/dc04NM4Kiq9M3gSPtDM1WmrwzFLSumI3S8Rq9PceLYH/evn6rH+9eUVf7OlX+Abi/v8xQk3u3t0tgvPBbiEj2f9PBYqp5M2u02PcrP3aLb6+DR8RqdNHH66HOf7Hhkp05P0+Eqfd0ayASOqkqerX+2u+K0zSdnjdf3scAB+kMy3wErPzh9u1K647LZRaeNPqv1ml+oVwqsSQtUnYv4wbrd3rHfc++5RKfmcGtto6zgunDDJ3DFyzqN/AcDIHNb1a6lFPzwmM5tNuTfNbb50kf+om2QPEdn3gxvdNrmdEdpjcOH+jhKNe6iR5gtnwD52ae271kKh7f7Tm3DV51Meuih5qqje6zaxu325/wS0Wl2bvsO8o7p4LH5m8pfZ/1U2LUIBr5Q81LpOzGBoypyDkHaKr1qWxmlS8b6XB9HqT5/gRNHYdVHp7atnQzB9aGT9/NRGjaKjoeI1p5LerhkrE7f0vuJio91l1a94d5Fumn2qztg7nNQXOTaucczYe6zuubd/S5bi2k3EziqImUeoP7QvwF6KG5QgB8NQmvZrGhXxXXXCfyWvaPnueQegc3fQpcb9BwHo/YS0ZMBdy0+vcZph6O79bf37nd4/pt7/aZwxyw92XPp2/DptRXPYQI9ubAgR8/ZqOHNlzW79N6SPFvPDm6c8IddpUNxq8v6Ul7R5y+Qk6lzUm2crud41KY0G8aZxQ/R67CnzLf3fRaP1RmpL/VgbcNZQBAMHQvXvqdbH97vA3tXnfn45LmwaYbui4np4Lly2sQEjsoqLtT/KdpdUe63hnRHvu82U5VqcbGeHf7beJ3Yr0lX3f9h1H7NLtSJHu1srjqyS9c2Eu/0/lr1CaPg7p913rWPB+t1PsoO2c0/Dj8+AVHxOkVPLWACR2WlLtMjh5ySGjpL97VZ42fS5yk4fhAyt5rahi/xD9BNuMlzXG/7r6wlY/UHda/H7Ll+ZTXuAvct0nO6fnwSvn0QCk+c2v/Ly3r2+TVvnzbnqyYzgaOykufooXSt+5W72wQOS6s++ttnYBicf723S2N4UvwQPfIodVnFx1bWkZ2w/gudvsXbtQ1ndRrCqC+h79OwYSp8dLnuh0lbDSvegx536+HZtUQNX+zZC5Jn6xQjwXX/sOt4fhE5BcW+ORS3LBG4fhIcz9Ar4xm+o80A8A/WzVWtKrX+WsUWW7WNS6tJbcOZnx/0f0avb/6/e+D9vnqBr/DGcNkL3i6dW5kaR2Uc3gGHU87aTAU+OGv8TOrH6f9Ehm8Jrgut++oUM+5Menh4B2yYppeALTN/qlppfyXcu1AnujyyU3eih9TzdqncytQ4KiPZWrSpzGzxUunWkrExpsZh+Lr4IbB9LmQkQWwn91xz8VjdTFxd+jbOJqI1/Olnff+18MuTqXFURvJsiO6g16AoR3q2DhyNTI3D8HWltXJ3ja46vAM2fqn7CsJj3XNNuwXWqZVBA0zgcF2eQy/OU86kv1Kl6UZiTOAwfF29xtC0OyT9AEX55369xf+2ahuPnvu1jHNWYeAQkaud1gX3XTt+0UuklpNmpNTBrDzqBgdQN9i0ABoG510PB9bDv1rBtFtg3eeuzbAu61DKqdpG3Rj3l9OoNFc+4W4C3hSRr4FJSqmtNpepekqeAyH19RDTM8jIzjP9G4ZR6qIHILItJP8E22bD1pmAQFwPiB+k1/CI6VhxhtjF/9ZL09aEvg0fUWHgUErdKiL1gFHAJyKigI+BL5RSNiekqSZKSnRHX9vL9QSnM0h35Jv+DcMoJQLtr9CPoW/AwY06c+62n2D+S/rRoIXuD4kfDC166VQezg5th9+nw8UPQ91o79yH8QcutakopRwiMgOoAzwGDAeeEpG3lFIVLDRdC+xfC7mHzjgMt1S6I48eLSM8VCjDqEFEoPEF+tHvaXAc0INNkmfr7Mkr34fgenoOSPxgPXIxNAIWva5rG5c84u07MJxUGDhE5BrgTqAtMAXoqZTKEJFQYAtQ+wNH8mydvrntZWc8RClFhiPfNFUZhivqNda5phLv1FmUdy3SI7CS58CWb/X/t7iekLZSr4NhahvViis1juuAcUqpxc4blVK5InLWNTFFZBAwHvAHPlRK/V+Z/S2ASUA0cAS4VSmVJiL9gXFOh3YARiqlvhWRT4C+QJa17w6l1HoX7qPqkmfrvo3QM9cmjuYWUlBcYhIcGkZlBYXqWkb8YN0sfGCd7hNJ/gnCYkxtoxpyJXC8CBwofSEidYBYpdRupdQZcyeLiD8wAbgcSANWicj3SqktToeNBaYopSaLyADgNWC0UmoBkGBdJwJIAeY6nfeUUmqGKzd4zrL26UXlB7541sNKZ4038sUlYw3DXfz89DDept1hwLPeLo1xBq4Ms/0KKHF6XWxtq0hPIEUptVMpVQBMA4aVOaYT8Iv1fEE5+wGuB35SSuW68J7ut92KVy70b4CPLhlrGIZPcSVwBFgf/ABYz4POcnyppsBep9dp1jZnG4AR1vPhQLiIRJY5ZiTwRZltr4jIRhEZJyLlflKLyL0islpEVmdmVmHseKnkOdCguZ4xfhalgSPGNFUZhlHLuRI4Mq0OcgBEZBhwyE3vPwboKyLr0P0W+9A1mtL3agycD8xxOucZdJ9HDyAC+Gt5F1ZKTVRKJSqlEqOjq9ixVngCdi7UtY0KxpqfmjVuahyGYdRurvRx3A98LiLvAIKuRdzmwnn7gGZOr+OsbScppfZj1ThEpC5wnVLqmNMhNwLfKKUKnc4p7W/JF5GP0cHHHruWQNGJs6YZKZXuyCMiLIjgAH/bimMYhlEduDIBcAdwkfXBjlLquIvXXgW0E5FW6IAxErjZ+QARiQKOKKVK0DWJSWWuMcra7nxOY6XUAdGLel8LbHKxPJWXPBsCQ6HFpRUemu7IIybc1DYMw6j9XJoAKCJDgc5AiFhNNkqpl852jlKqSEQeRjcz+aPTlWwWkZeA1Uqp74F+wGvWbPTFwENO79kSXWNZVObSn4tINLr2sx5dI7JHQAh0uhYCK+63SHfkm3U4DMPwCa5MAHwPCAX6Ax+iRzmtdOXiSqlZwKwy2553ej4DKHdYrVJqN3/sTEcpNcCV93aLQa+6fGi6I49OjWvXYi2GYRjlcaVz/BKl1G3AUaXUP4CLgfb2FqtmKSou4dDxfDMU1zAMn+BK4MizfuaKSBOgEKhGq8R736HjBZQosw6HYRi+wZU+jh9EpAHwb2AtoIAPbC1VDWPWGjcMw5ecNXBYCzjNt4bIfi0iM4EQpVTW2c7zNSfTjZjAYRiGDzhrU5U1THaC0+t8EzT+KD1bT/4zfRyGYfgCV/o45ovIdSIVLdPlu9Kz8vATiKxrAodhGLWfK4HjPnRSw3wRcYhItog4bC5XjZLuyCM6PBh/PxNbDcOo/VyZOR7uiYLUZOnZZslYwzB8hysTAPuUt73swk6+LMORR7OIUG8XwzAMwyNcGY77lNPzEPQ6G2sAz83gruYOOvJIbNnQ28UwDMPwCFeaqq52fi0izYA3bStRDZNXWMyx3ELTVGUYhs9wpXO8rDSgo7sLUlNlZpeuw2ECh2EYvsGVPo630bPFQQeaBPQMcgPdTAVm1rhhGL7DlT6O1U7Pi4AvlFK/2VSeGsesNW4Yhq9xJXDMAPKUUsUAIuIvIqFKqVx7i1YzlC4Za/o4DMPwFS7NHAfqOL2uA8yzpzg1T4Yjj6AAP+rXCfR2UQzDMDzClcAR4rxcrPXcTFqwHHTkEVsvGJORxTAMX+FK4MgRkW6lL0SkO3DCviLVLOmOPGLDTTOVYRi+w5U+jseAr0RkP3qd70bATbaWqgbJcOTTsYlZMtYwDN/hygTAVSLSAYi3Nm1TShXaW6yaI92RR7/4GG8XwzAMw2MqbKoSkYeAMKXUJqXUJqCuiDxof9Gqv+y8QnIKis1QXMMwfIorfRz3WCsAAqCUOgrcY1+Rao6TQ3Hrmz4OwzB8hyuBw995EScR8QeCXLm4iAwSkW0ikiIiT5ezv4WIzBeRjSKyUETirO39RWS90yNPRK619rUSkRXWNb8UEZfKYocMa/JfjOkcNwzDh7gSOGYDX4rIZSJyGfAF8FNFJ1kBZgIwGOgEjBKRTmUOGwtMUUp1AV4CXgNQSi1QSiUopRLQWXhzgbnWOf8Cximl2gJHgbtduAdbpGebWeOGYfgeVwLHX4FfgPutx++cPiHwTHoCKUqpnUqpAmAaMKzMMZ2sawMsKGc/wPXAT0qpXKvmMwA9mx1gMnCtC2WxxcGs0rXGTY3DMAzfUWHgUEqVACuA3ehgMABIcuHaTYG9Tq/TrG3ONgAjrOfDgXARiSxzzEh0LQcgEjimlCo6yzUBEJF7RWS1iKzOzMx0obiVl+7IIzw4gLBgV0Y1G4Zh1A5nDBwi0l5EXhCRrcDbQCqAUqq/UuodN73/GKCviKwD+gL7gGKnMjQGzgfmVPbCSqmJSqlEpVRidHS0m4p7uozsPGJMM5VhGD7mbF+VtwJLgKuUUikAIvJ4Ja69D2jm9DrO2naSUmo/Vo1DROoC1zmP4AJuBL5xmjdyGGggIgFWreMP1/Skg1l5ppnKMAyfc7amqhHAAWCBiHxgdYxXJiHTKqCdNQoqCN3k9L3zASISJSKlZXgGmFTmGqM41UyFUkqh+0KutzbdDnxXiTK5Vboj3wQOwzB8zhkDh1LqW6XUSKAD+sP6MSBGRN4VkSsqurBVI3gY3cyUBExXSm0WkZdE5BrrsH7ANhFJBmKBV0rPF5GW6BrLojKX/ivwhIikoPs8PnLhPt1OKUVGtqlxGIbhe1xJOZIDTAWmikhD4Ab0h/fcs56oz50FzCqz7Xmn5zM4NUKq7Lm7KafjWym1E91J71VHcwspLFZmKK5hGD6nUmuOK6WOWp3Ol9lVoJriYJZZMtYwDN9UqcBhnGIm/xmG4atM4KiiDIepcRiG4ZtM4Kii0gSH0eGmxmEYhm8xgaOKDjryiAgLIjjA39tFMQzD8CgTOKoow2GG4hqG4ZtM4KgiPfnPNFMZhuF7TOCoonRHHrFmHQ7DMHyQCRxVUFRcwqHjpsZhGIZvMoGjCg4dL6BEQaxZMtYwDB9kAkcVpJfO4TBNVYZh+CATOKrgoJn8ZxiGDzOBowpOzRo3fRyGYfgeEziqIN2Rj7+fEFnXBA7DMHyPCRxVkO7II7puMP5+lVnXyjAMo3YwgaMKDjryTDOVYRg+ywSOKsgwS8YahuHDTOCognSzZKxhGD7MBI5Kyiss5lhuoWmqMgzDZ5nAUUkZ1jocMabGYRiGjzKBo5JKl4xtZAKHYRg+ygSOSko3s8YNw/BxtgYOERkkIttEJEVEni5nfwsRmS8iG0VkoYjEOe1rLiJzRSRJRLaISEtr+ycisktE1luPBDvvoazSJWNNH4dhGL7KtsAhIv7ABGAw0AkYJSKdyhw2FpiilOoCvAS85rRvCvBvpVRHoCeQ4bTvKaVUgvVYb9c9lCfdkUdQgB/16wR68m0NwzCqDTtrHD2BFKXUTqVUATANGFbmmE7AL9bzBaX7rQAToJT6GUApdVwplWtjWV2W7sijUb0QRMysccMwfJOdgaMpsNfpdZq1zdkGYIT1fDgQLiKRQHvgmIj8T0TWici/rRpMqVes5q1xIlJum5GI3Csiq0VkdWZmpnvuCGvlP9NMZRiGD/N25/gYoK+IrAP6AvuAYiAA6G3t7wG0Bu6wznkG6GBtjwD+Wt6FlVITlVKJSqnE6OhotxU43ZFvhuIahuHT7Awc+4BmTq/jrG0nKaX2K6VGKKW6As9a246hayfrrWauIuBboJu1/4DS8oGP0U1iHqGUMmuNG4bh8+wMHKuAdiLSSkSCgJHA984HiEiUiJSW4RlgktO5DUSktKowANhindPY+inAtcAmG+/hNMfzi8gtKKZRfdNUZRiG77ItcFg1hYeBOUASMF0ptVlEXhKRa6zD+gHbRCQZiAVesc4tRjdTzReR3wEBPrDO+dza9jsQBbxs1z2UdWoorqlxGIbhuwLsvLhSahYwq8y2552ezwBmnOHcn4Eu5Wwf4OZiuqx08l+MaaoyDMOHebtzvEYpDRyN6pvAYRiG7zKBoxJKm6piwk0fh2EYvssEjkpId+QRHhxAWLCtLXyGYRjVmgkclZDuyCPGTP4zDMPHmcBRCemOPNO/YRiGzzOBoxLSHflm8p9hGD7PBA4XKaXIyM4z6UYMw/B5JnC46EhOAYXFyiQ4NAzD55nA4aLSobhmyVjDMHydCRwuKl1r3DRVGYbh60zgcFF6Vula46apyjAM32YCh4tOzRo3NQ7DMHybCRwuSs/OIzIsYNL81gAAEONJREFUiKAA8yszDMO3mU9BF2U4zFBcwzAMMIHDZQfNWuOGYRiAzetx1CbpjnzOa1Lf28UwDJ9XWFhIWloaeXl53i5KrRESEkJcXByBgYEuHW8ChwuKiks4dDzfNFUZRjWQlpZGeHg4LVu2RK8gbZwLpRSHDx8mLS2NVq1auXSOaapywaHjBShlhuIaRnWQl5dHZGSkCRpuIiJERkZWqgZnAocLDlor/5kEh4ZRPZig4V6V/X2awOECs2SsYRjGKSZwuCDDUZpuxDRVGYavO3z4MAkJCSQkJNCoUSOaNm168nVBQcFZz129ejWPPPJIhe9xySWXuKu4tjCd4y5Id+Tj7ydEhpnAYRi+LjIykvXr1wPw4osvUrduXcaMGXNyf1FREQEB5X+0JiYmkpiYWOF7LF261D2FtYmtgUNEBgHjAX/gQ6XU/5XZ3wKYBEQDR4BblVJp1r7mwIdAM0ABQ5RSu0WkFTANiATWAKOVUmcP8+fooCOP6LrB+PuZdlXDqE7+8cNmtux3uPWanZrU44WrO1fqnDvuuIOQkBDWrVtHr169GDlyJI8++ih5eXnUqVOHjz/+mPj4eBYuXMjYsWOZOXMmL774IqmpqezcuZPU1FQee+yxk7WRunXrcvz4cRYuXMiLL75IVFQUmzZtonv37nz22WeICLNmzeKJJ54gLCyMXr16sXPnTmbOnOnW38WZ2BY4RMQfmABcDqQBq0Tke6XUFqfDxgJTlFKTRWQA8Bow2to3BXhFKfWziNQFSqzt/wLGKaWmich7wN3Au3bdB+g+jljTv2EYxlmkpaWxdOlS/P39cTgcLFmyhICAAObNm8ff/vY3vv766z+cs3XrVhYsWEB2djbx8fE88MADf5hLsW7dOjZv3kyTJk3o1asXv/32G4mJidx3330sXryYVq1aMWrUKE/dJmBvjaMnkKKU2gkgItOAYYBz4OgEPGE9XwB8ax3bCQhQSv0MoJQ6bm0XYABws3XOZOBFbA4cGY58WkSG2vkWhmFUQWVrBna64YYb8Pf3ByArK4vbb7+d7du3IyIUFhaWe87QoUMJDg4mODiYmJgY0tPTiYuLO+2Ynj17ntyWkJDA7t27qVu3Lq1btz4572LUqFFMnDjRxrs7nZ2d402BvU6v06xtzjYAI6znw4FwEYkE2gPH/r+9u4+tqs7zOP7+ylMRWB6sOqywCwoCSxDKk7Mww8NKFNDAyqBQJ1kYJhlhcTNgWB8iIoIkOwO7MY7IBJZBhhBbEYaBTVnUzoQ12dGhMKVFGLSQbhbkoeJSSkBome/+cU7Ltdx76e19KsPnldz03N/5nXO+99dz++3vd879XTPbZmZ/MLOVYQ/mDuCcu9fF2ScAZvYjMysxs5KqqqqkXkgw3Yh6HCISW4cOHRqWX375ZcaPH8/BgwfZuXNnzM9ItGt37bppq1atqKura1adTMv2XVWLgLFm9gdgLHACuErQE/puuH4EcC8wO5Edu/tadx/u7sPvvPPOZgf4de1Vqi/V6lZcEWmy6upq7rkn+J/27bffTvn++/Xrx7Fjx6isrASgsLAw5ceIJ52J4wTBhe16PcKyBu7+hbtPc/c84KWw7BxBT6LU3Y+FvYvtwFDgLNDFzFrH2meqnWn4Hg7dUSUiTfPcc8/x4osvkpeXl5YeQvv27XnrrbeYOHEiw4YNo1OnTnTunLm59Mzd07Pj4I/7Z8BDBH/c9wJPufunEXVyga/c/U9mtgK46u5LwmGp/cAEd68ysw1AibuvNrMtwNaIi+Nl7v5WvFiGDx/uJSUlzXodeyu/4omf/45fzhnJmPub33MRkdQ4fPgwAwYMyHYYWXfhwgU6duyIuzN//nz69u3LwoULm72/aO1qZvvc/br7h9PW4wh7Cs8Au4HDwLvu/qmZLTOzKWG1ccARM/sMuBtYEW57lWCYqtjMygED1oXbPA88a2YVBNc81qfrNQCcavjKWA1ViUjLsW7dOoYMGcLAgQOprq7m6aefztix0/o5DncvAooalS2JWH4PeC/Gth8AD0QpP0Zwx1ZGNEw3osQhIi3IwoULk+phJCPbF8dbvDM1l2nX+jb+or0+ZC8iAkocN3Q6vBVXs3GKiASUOG7gVLW+MlZEJJISxw2cqbmsC+MiIhGUOOJw94ahKhERgPHjx7N79+5vlL3++uvMmzcvav1x48ZR/3GAyZMnc+7cuevqLF26lFWrVsU97vbt2zl06NqMTUuWLOHDDz9MNPyUUOKIo+ZyHRevXNVQlYg0yM/Pp6Cg4BtlBQUFTZposKioiC5dujTruI0Tx7Jly5gwYUKz9pUs3SoUR/0XOKnHIdJC7XoBTpWndp/fGgST/iXm6unTp7N48WKuXLlC27Ztqays5IsvvuCdd97h2Wef5dKlS0yfPp1XX331um179epFSUkJubm5rFixgo0bN3LXXXfRs2dPhg0bBgSfz1i7di1XrlyhT58+bNq0idLSUnbs2MGePXt47bXX2Lp1K8uXL+exxx5j+vTpFBcXs2jRIurq6hgxYgRr1qyhXbt29OrVi1mzZrFz505qa2vZsmUL/fv3T7qJ1OOI43Q43YgSh4jU69atGyNHjmTXrl1A0Nt48sknWbFiBSUlJZSVlbFnzx7Kyspi7mPfvn0UFBRQWlpKUVERe/fubVg3bdo09u7dy4EDBxgwYADr169n1KhRTJkyhZUrV1JaWsp9993XUP/rr79m9uzZFBYWUl5eTl1dHWvWXJswPDc3l/379zNv3rwbDoc1lXoccZxWj0OkZYvTM0in+uGqqVOnUlBQwPr163n33XdZu3YtdXV1nDx5kkOHDvHAA9d9hhmAjz76iMcff5zbbw++rmHKlCkN6w4ePMjixYs5d+4cFy5c4JFHHokby5EjR+jduzf3338/ALNmzWL16tUsWLAACBIRwLBhw9i2bVvSrx3U44jrVEPi0DUOEblm6tSpFBcXs3//fi5evEi3bt1YtWoVxcXFlJWV8eijj8acSv1GZs+ezZtvvkl5eTmvvPJKs/dTr35a9lROya7EEceZ85fplNOa29uqYyYi13Ts2JHx48czZ84c8vPzOX/+PB06dKBz586cPn26YRgrljFjxrB9+3YuXbpETU0NO3fubFhXU1ND9+7dqa2tZfPmzQ3lnTp1oqam5rp99evXj8rKSioqKgDYtGkTY8eOTdErjU6JIw7diisiseTn53PgwAHy8/MZPHgweXl59O/fn6eeeorRo0fH3Xbo0KHMmDGDwYMHM2nSJEaMGNGwbvny5Tz44IOMHj36GxeyZ86cycqVK8nLy+Po0aMN5Tk5OWzYsIEnnniCQYMGcdtttzF37tzUv+AIaZtWvSVp7rTqq39bwYXLdTw/Mfm7EEQkNTStenokMq26xmDimD++T7ZDEBFpcTRUJSIiCVHiEJGbzq0wxJ5JibanEoeI3FRycnI4e/askkeKuDtnz54lJ6fpNwLpGoeI3FR69OjB8ePHqaqqynYofzZycnLo0aNHk+srcYjITaVNmzb07t0722Hc0jRUJSIiCVHiEBGRhChxiIhIQm6JT46bWRXwP83cPBf4MoXhpJriS47iS47iS05Lj++v3f3OxoW3ROJIhpmVRPvIfUuh+JKj+JKj+JLT0uOLRUNVIiKSECUOERFJiBLHja3NdgA3oPiSo/iSo/iS09Lji0rXOEREJCHqcYiISEKUOEREJCFKHCEzm2hmR8yswsxeiLK+nZkVhus/MbNeGYytp5n91swOmdmnZvbjKHXGmVm1mZWGjyWZii88fqWZlYfHvu7rFi3wRth+ZWY2NIOx9Ytol1IzO29mCxrVyWj7mdkvzOyMmR2MKOtmZh+Y2efhz64xtp0V1vnczGZlML6VZvbH8Pf3KzPrEmPbuOdCGuNbamYnIn6Hk2NsG/e9nsb4CiNiqzSz0hjbpr39kubut/wDaAUcBe4F2gIHgL9pVOcfgZ+HyzOBwgzG1x0YGi53Aj6LEt844D+y2IaVQG6c9ZOBXYAB3wY+yeLv+hTBB5uy1n7AGGAocDCi7KfAC+HyC8BPomzXDTgW/uwaLnfNUHwPA63D5Z9Ei68p50Ia41sKLGrC7z/uez1d8TVa/6/Akmy1X7IP9TgCI4EKdz/m7leAAmBqozpTgY3h8nvAQ2ZmmQjO3U+6+/5wuQY4DNyTiWOn0FTglx74GOhiZt2zEMdDwFF3b+5MAinh7v8FfNWoOPIc2wj8fZRNHwE+cPev3P3/gA+AiZmIz93fd/e68OnHQNPn4U6xGO3XFE15ryctXnzh340ngXdSfdxMUeII3AP8b8Tz41z/h7mhTvjmqQbuyEh0EcIhsjzgkyir/9bMDpjZLjMbmNHAwIH3zWyfmf0oyvqmtHEmzCT2Gzab7Qdwt7ufDJdPAXdHqdNS2nEOQQ8ymhudC+n0TDiU9osYQ30tof2+C5x2989jrM9m+zWJEsdNxMw6AluBBe5+vtHq/QTDL4OBnwHbMxzed9x9KDAJmG9mYzJ8/Bsys7bAFGBLlNXZbr9v8GDMokXeK29mLwF1wOYYVbJ1LqwB7gOGACcJhoNaonzi9zZa/HtJiSNwAugZ8bxHWBa1jpm1BjoDZzMSXXDMNgRJY7O7b2u83t3Pu/uFcLkIaGNmuZmKz91PhD/PAL8iGBKI1JQ2TrdJwH53P914RbbbL3S6fvgu/HkmSp2stqOZzQYeA74fJrfrNOFcSAt3P+3uV939T8C6GMfNdvu1BqYBhbHqZKv9EqHEEdgL9DWz3uF/pTOBHY3q7ADq72CZDvwm1hsn1cIx0fXAYXf/txh1vlV/zcXMRhL8bjOS2Mysg5l1ql8muIh6sFG1HcA/hHdXfRuojhiWyZSY/+lls/0iRJ5js4BfR6mzG3jYzLqGQzEPh2VpZ2YTgeeAKe5+MUadppwL6Yov8prZ4zGO25T3ejpNAP7o7sejrcxm+yUk21fnW8qD4K6fzwjuuHgpLFtG8CYByCEY4qgAfg/cm8HYvkMwbFEGlIaPycBcYG5Y5xngU4K7RD4GRmUwvnvD4x4IY6hvv8j4DFgdtm85MDzDv98OBImgc0RZ1tqPIIGdBGoJxtl/SHDNrBj4HPgQ6BbWHQ78e8S2c8LzsAL4QQbjqyC4PlB/DtbfZfiXQFG8cyFD8W0Kz60ygmTQvXF84fPr3uuZiC8sf7v+nIuom/H2S/ahKUdERCQhGqoSEZGEKHGIiEhClDhERCQhShwiIpIQJQ4REUmIEodICpjZ1UYz8KZs1lUz6xU5y6pItrXOdgAifyYuufuQbAchkgnqcYikUfjdCj8Nv1/h92bWJyzvZWa/CSfkKzazvwrL7w6/6+JA+BgV7qqVma2z4PtY3jez9ll7UXLLU+IQSY32jYaqZkSsq3b3QcCbwOth2c+Aje7+AMFkgW+E5W8AezyYbHEowaeHAfoCq919IHAO+F6aX49ITPrkuEgKmNkFd+8YpbwS+Dt3PxZOVHnK3e8wsy8JpsSoDctPunuumVUBPdz9csQ+ehF8B0ff8PnzQBt3fy39r0zkeupxiKSfx1hOxOWI5avo+qRkkRKHSPrNiPj5u3D5vwlmZgX4PvBRuFwMzAMws1Zm1jlTQYo0lf5rEUmN9mZWGvH8P929/pbcrmZWRtBryA/L/gnYYGb/DFQBPwjLfwysNbMfEvQs5hHMsirSYugah0gahdc4hrv7l9mORSRVNFQlIiIJUY9DREQSoh6HiIgkRIlDREQSosQhIiIJUeIQEZGEKHGIiEhC/h8TIzyd+hhaPwAAAABJRU5ErkJggg=="
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     }
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "colab_type": "code",
    "id": "AWJflmuvaIqM",
    "outputId": "883f1dd4-b936-4476-e237-b1b29f029d8c"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "plt.plot(history.history['loss'], label='Training data')\n",
    "plt.plot(history.history['val_loss'], label='Validation data')\n",
    "plt.title('Loss')\n",
    "plt.ylabel('Loss value')\n",
    "plt.xlabel('No. epoch')\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     }
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "colab_type": "code",
    "id": "lVl-R4EDaKj9",
    "outputId": "fd54d391-a880-45e1-bd81-c68f9adb1041"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "y_pred = model.predict(test_data)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aTT31txecTt6"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "y_pred"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[2.0939126e-08],\n",
       "       [2.3471547e-07],\n",
       "       [9.9992108e-01],\n",
       "       ...,\n",
       "       [9.9971157e-01],\n",
       "       [9.9863094e-01],\n",
       "       [8.8735662e-02]], dtype=float32)"
      ]
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 23
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 145
    },
    "colab_type": "code",
    "id": "NHOi5fpPPWDt",
    "outputId": "79895a9e-d023-434e-8244-2f0f884733df"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "score , acc  =  model.evaluate(test_data, y_test, batch_size = 64)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "100/100 [==============================] - 1s 9ms/step - loss: 0.0578 - accuracy: 0.9822\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "w5vxqml_MkH6",
    "outputId": "9197c4a0-c0e9-4acf-e4bd-386e04ac68b8"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "source": [
    "print('Test Score:', score)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      " Test Score :  0.057759568095207214\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "UP2pwTHMPYA2",
    "outputId": "cf077c39-9cd7-4d5d-9892-15ecf660bcf4"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "source": [
    "print('Test Accuracy : ', acc)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Test Accuracy :  0.9821875095367432\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "Y68He4g3PfGY",
    "outputId": "92cd3bd5-4f5c-4ad6-fcc4-4a260308fc7a"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "source": [
    "def predict_function(y_pred) :\n",
    "    for i in range(y_pred.shape[0]) :\n",
    "        if y_pred[i][0] >= 0.5 :\n",
    "            y_pred[i][0] = 1\n",
    "        else :\n",
    "            y_pred[i][0] = 0\n",
    "        return y_pred.astype('int64')"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vTIR0MNrcYxR"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "source": [
    "y_pred = predict_function(y_pred)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1HcxwByxcZTY"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "source": [
    "y_test = y_test.reshape(-1,1)"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7g58nYSbdYr4"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "source": [
    "metrics = classification_report(y_test, y_pred, digits = 4)\n",
    "\n",
    "print('Classification Report ')\n",
    "print(\"\\n\")\n",
    "print(metrics)\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "print('Confusion Matrix')\n",
    "print(\"\\n\")\n",
    "print(cm)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Classification Report \n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9868    0.9767    0.9817      3127\n",
      "           1     0.9779    0.9875    0.9827      3273\n",
      "\n",
      "    accuracy                         0.9822      6400\n",
      "   macro avg     0.9823    0.9821    0.9822      6400\n",
      "weighted avg     0.9822    0.9822    0.9822      6400\n",
      "\n",
      "Confusion Matrix\n",
      "\n",
      "\n",
      "[[3054   73]\n",
      " [  41 3232]]\n"
     ]
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 326
    },
    "colab_type": "code",
    "id": "EKB3RgAndTTh",
    "outputId": "57d46f05-79fb-475f-d8fa-f67d65bb6685"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    "def TestingOwnData(sentence) :\n",
    "    X = np.zeros((1,sequence_size,300))\n",
    "    sentence = sentence.replace('-',' ')\n",
    "    words = nltk.word_tokenize(sentence)\n",
    "    j = 0\n",
    "    for w in words:\n",
    "        try :\n",
    "            X[0,j] = w2v[w]\n",
    "            j += 1\n",
    "        except :\n",
    "            pass\n",
    "    prediction = predict_function(model.predict(X))[0][0]\n",
    "    if prediction == 1 :         \n",
    "        return 'Clickbait'\n",
    "    return 'Not A Clickbait'"
   ],
   "outputs": [],
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wKs712yBM4OO"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "source": [
    "TestingOwnData('Amazing Inventions You Won’t Believe Exist')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'Clickbait'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 32
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "F7A59GgSZv-r",
    "outputId": "1d5abaca-4a47-41a9-e896-d83944996c02"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "source": [
    "TestingOwnData('Tamil Nadu reports 4,280 fresh COVID-19 cases and 65 deaths')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'Not A Clickbait'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 33
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "yTWkeysIRp5l",
    "outputId": "e1957695-8d3c-417d-f6d8-249256586a42"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "source": [
    "TestingOwnData('Can Face Masks Prevent You From Getting the Coronavirus? Doctors Weight In')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'Clickbait'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 34
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "EFDKxdQCSRem",
    "outputId": "7dd126d6-227b-4475-94a4-b2ebc2b74609"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "source": [
    "TestingOwnData('PM Modi asks to prepare Digital booklets documenting the relief works')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'Not A Clickbait'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 35
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "8MVbsB9fTA88",
    "outputId": "6e7aad15-9afe-480d-9e0f-56ea6ea4aa56"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "source": [
    "TestingOwnData('No passenger flights to Kolkata from Delhi, Mumbai, Chennai and 3 other cities between Jul 6-19')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'Not A Clickbait'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 36
    }
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "OGfcrnKnTF_8",
    "outputId": "9a4d1c38-b7a2-45ae-ec35-db8be53cb418"
   }
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Clickbait.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}