SMS_SPAM_HAM_Predictive_analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SMS_SPAM/HAM Predictive analysis",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9_x1GxgsduEH"
      },
      "source": [
        "**SMS SPAM/HAM DATASET**\n",
        "==============\n",
        "The SMS Spam Collection is a set of SMS tagged messages that have been collected for SMS Spam research. It contains one set of SMS messages in English of 5,574 messages, tagged acording being ham (legitimate) or spam."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iJDybKPBgwz5"
      },
      "source": [
        "Analysing the dataset![spam_classifier_g2mt4wa.png](data:image/png;base64,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)\n",
        "------\n",
        "\n",
        "Objective is to predict if a new sms is spam or ham.It is much worse to misclassify ham than misclassify an spam.\n",
        "\n",
        "*The reason is we normally don't check the spam messages if a ham message is moved to spam folder we probably don't read it.*\n",
        "The two possible situations are:\n",
        "------------\n",
        "\n",
        "* New spam sms in my inbox. (False negative). I delete it.\n",
        "* New ham sms in my spam folder (False positive). I may not read it.\n",
        "\n",
        "I prefer the first case and I dont want False positives.\n",
        "\n",
        "First we transform the variable spam/ham into binary variable, then we split our data set in training set and test .\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TVTH3TTBgwtz"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T3Er64s_VcTw"
      },
      "source": [
        "import nltk\n",
        "import pandas as pd\n",
        "import re\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "import string\n"
      ],
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sOOJv5NmWHGU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aeb635e7-ad02-4567-93c8-6b82c985ae3c"
      },
      "source": [
        "from nltk.corpus import stopwords\n",
        "nltk.download('stopwords')\n",
        "stopwords.words('english')[1:5]"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['me', 'my', 'myself', 'we']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q18a4haaWQ0f"
      },
      "source": [
        "# Code to read csv file into Colaboratory:\n",
        "!pip install -U -q PyDrive\n",
        "\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "# Authenticate and create the PyDrive client.\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ],
      "execution_count": 95,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O3p4-Iu9ilIh"
      },
      "source": [
        "train_downloaded = drive.CreateFile({'id': '1l30dRqD9p0Xtx7L7Ge65OAwd_LXOQKvq'})\n",
        "train_downloaded.GetContentFile('spam.csv')"
      ],
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfbz983Bi1Wf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "8208b1c4-7bcb-4693-88ce-8cd81d3f762e"
      },
      "source": [
        "\n",
        "df=pd.read_csv('spam.csv',encoding='latin-1')\n",
        "df.head()"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "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>v1</th>\n",
              "      <th>v2</th>\n",
              "      <th>Unnamed: 2</th>\n",
              "      <th>Unnamed: 3</th>\n",
              "      <th>Unnamed: 4</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>ham</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ham</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>spam</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>ham</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ham</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     v1  ... Unnamed: 4\n",
              "0   ham  ...        NaN\n",
              "1   ham  ...        NaN\n",
              "2  spam  ...        NaN\n",
              "3   ham  ...        NaN\n",
              "4   ham  ...        NaN\n",
              "\n",
              "[5 rows x 5 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R3nQDBG4j1kA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d00964be-e557-4de8-d1c4-ead9f9276e2d"
      },
      "source": [
        "\n",
        "df.info()"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 5572 entries, 0 to 5571\n",
            "Data columns (total 5 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   v1          5572 non-null   object\n",
            " 1   v2          5572 non-null   object\n",
            " 2   Unnamed: 2  50 non-null     object\n",
            " 3   Unnamed: 3  12 non-null     object\n",
            " 4   Unnamed: 4  6 non-null      object\n",
            "dtypes: object(5)\n",
            "memory usage: 217.8+ KB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ztSmufEajCnd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46a98938-d4cb-4cc2-9b14-83bb8aa3eb48"
      },
      "source": [
        "#checking the columns with most null values\n",
        "df.isnull().sum()"
      ],
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "v1               0\n",
              "v2               0\n",
              "Unnamed: 2    5522\n",
              "Unnamed: 3    5560\n",
              "Unnamed: 4    5566\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T8Dl9eVMkDBp"
      },
      "source": [
        "As most of the values in Unnamed: 2 , Unnamed: 3   ,Unnamed: 4 columns are null values lets drop those columns"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9zVbFBuUjlik"
      },
      "source": [
        "\n",
        "#drop unused columns and label the columns which are used \n",
        "df.drop(labels=[\"Unnamed: 2\" , \"Unnamed: 3\" ,\"Unnamed: 4\"],inplace=True,axis=1)\n",
        "df.columns=['label','text']"
      ],
      "execution_count": 100,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d2LkF7Fhk4uc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2175eb5d-9652-4c9e-a01f-08746039998f"
      },
      "source": [
        "df.shape"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5572, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZhGUSmwnlfi_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "c9f6de34-8c1e-435c-d419-ef66870e4cdd"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "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>label</th>\n",
              "      <th>text</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>ham</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ham</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>spam</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>ham</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ham</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  label                                               text\n",
              "0   ham  Go until jurong point, crazy.. Available only ...\n",
              "1   ham                      Ok lar... Joking wif u oni...\n",
              "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...\n",
              "3   ham  U dun say so early hor... U c already then say...\n",
              "4   ham  Nah I don't think he goes to usf, he lives aro..."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psgAmVFIlxpL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 264
        },
        "outputId": "ddc89931-8f09-462b-e501-42a6af6f6e83"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "count=df['label'].value_counts()\n",
        "count.plot(kind = 'pie')\n",
        "plt.title('pie chart')\n",
        "plt.ylabel('')\n",
        "plt.show();\n",
        "#portion of text messages actually spam"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WA921hxwE7_g"
      },
      "source": [
        "Feature engineering\n",
        "---------\n",
        "lets see if the text length and the percentage of special characters might be useful for identifying spam messages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4PehqMhGT70b"
      },
      "source": [
        ""
      ],
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Zp0-FZnAyAA"
      },
      "source": [
        "def punct(txt):\n",
        "    count = sum([1 for char in txt if char in string.punctuation])\n",
        "    #counting punctuations\n",
        "    textlen=(len(txt) - txt.count(\" \"))\n",
        "    #counting text length \n",
        "    return round(count/textlen, 3)*100\n",
        "    #percentage of punctuation in text\n",
        "\n",
        "df['text_len'] = df['text'].apply(lambda x: len(x) - x.count(\" \"))\n",
        "df['punct_percent'] = df['text'].apply(lambda x: punct(x))\n"
      ],
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "MjfN7fyXEs_I",
        "outputId": "9a897881-f77b-41a1-f62d-c377cd83aeee"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "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>label</th>\n",
              "      <th>text</th>\n",
              "      <th>text_len</th>\n",
              "      <th>punct_percent</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>ham</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "      <td>92</td>\n",
              "      <td>9.8</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ham</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "      <td>24</td>\n",
              "      <td>25.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>spam</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "      <td>128</td>\n",
              "      <td>4.7</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>ham</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "      <td>39</td>\n",
              "      <td>15.4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ham</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "      <td>49</td>\n",
              "      <td>4.1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  label  ... punct_percent\n",
              "0   ham  ...           9.8\n",
              "1   ham  ...          25.0\n",
              "2  spam  ...           4.7\n",
              "3   ham  ...          15.4\n",
              "4   ham  ...           4.1\n",
              "\n",
              "[5 rows x 4 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rgSYdhKx9zSJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 386
        },
        "outputId": "e6433d4e-272f-4b4f-ed50-3b84aa009f20"
      },
      "source": [
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "plt.figure(figsize=(10,8))\n",
        "sns.displot(df,x=\"text_len\",hue=\"label\",palette='CMRmap_r',bins=70)\n",
        "plt.xlim(0,300)\n",
        "plt.tight_layout()"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x576 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 423.25x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 289
        },
        "id": "L-jUOVXB4gBG",
        "outputId": "c25451f4-2450-4f83-c4a5-68ddbb6b28e3"
      },
      "source": [
        "bins = np.linspace(0, 200, 40)\n",
        "df.hist(column='text_len', by='label', bins=50,figsize=(12,4))\n",
        "plt.show()"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuEAAAEQCAYAAAAeZqqzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5RlZX3m8e8DrSioXFvEbrA7giZqvGAHcEyMAYNcHCEuRMyFhuDqZAWjUWekMZmFJmHSJJkQHCOTDqCYqIBopCMoEoQ4kwjSICIXlQZBuqWhlYsXjNLymz/2bjxUV0ld9z5V9f2sVav2effe5zx1TtXZv3rPu9+dqkKSJElSd7bpO4AkSZI031iES5IkSR2zCJckSZI6ZhEuSZIkdcwiXJIkSeqYRbgkSZLUMYtwzXpJ7kjyqr5zSJIkjZdFuCRJktQxi3BJkiSpYxbhmitenOSGJA8mOT/Jk5LsnORTSTYlub9dXrxlhyRXJvnzJP+R5PtJ/iXJrkk+nOS7Sa5JsqS/H0mSNBFJTkqyIcn3knwtyUFJ3p3kwvbY8L0k1yV50cA+K5Pc1q67OclvDKw7Lsm/Jzk9yQNJbk/yX9r2u5Lcm2R5Pz+tZjuLcM0VRwOHAEuBFwLH0fx+fwB4FrAX8EPgfSP2Owb4HWAR8GzgC+0+uwC3AKfMfHRJ0lQleS7wZuCXquqpwKuBO9rVRwAfo3lv/wjwySRPaNfdBvwKsCPwHuCfkuwxcNf7AzcAu7b7ngf8ErA38NvA+5I8ZeZ+Ms1VFuGaK95bVd+qqvuAfwFeXFXfqaqPV9VDVfU94FTgV0fs94Gquq2qHgQ+DdxWVf9aVZtp3rBf0ulPIUmarJ8A2wHPS/KEqrqjqm5r111bVRdW1cPA3wBPAg4AqKqPtcePR6rqfOBWYL+B+/1GVX2gqn4CnA/sCfxpVf2oqj4L/JimIJcmxCJcc8XGgeWHgKck2T7J3ye5M8l3gc8DOyXZdmDbewaWfzjKbXs3JGkWqKp1wB8B7wbuTXJekme2q+8a2O4RYD3wTIAkxya5vh1u8gDwAmC3gbseeVygqjxWaMoswjWXvQN4LrB/VT0NeEXbnv4iSZJmSlV9pKp+mWYYYgGntav23LJNkm2AxcC3kjwL+AeaYSy7VtVOwI14nFAHLMI1lz2VpofigSS74PhuSZqzkjw3yYFJtgP+k+b9/5F29UuTvC7JApre8h8BVwE70BTrm9r7OJ6mJ1yacRbhmsv+Fngy8G2aN9vP9BtHkjSDtgNW0bznbwSeDpzcrrsIeANwP83J+K+rqoer6mbgf9GclH8P8IvAv3ecW/NUqqrvDJIkSTMiybuBvavqt/vOIg2yJ1ySJEnqmEW4JEmS1DGHo0iSJEkdsydckjRtkpzTXsr7xoG2v0ry1SQ3JPnnJDsNrDs5ybr2EuOv7ie1JHXPIlySNJ0+CBwyou0y4AVV9ULg67QzViR5HnAM8Px2n/ePuJiWJM1ZC/oO8LPstttutWTJkr5jSNK4XHvttd+uqoV95+hTVX0+yZIRbZ8duHkVcFS7fARwXlX9CPhGknU0lwv/ws96DI8NkmaTsY4NQ12EL1myhLVr1/YdQ5LGJcmdfWeYBX4XOL9dXkRTlG+xvm3bSpIVwAqAvfbay2ODpFljrGODw1EkSZ1I8sfAZuDDE923qlZX1bKqWrZw4bz+sEHSHDHUPeGSpLkhyXHAa4CD6qfTcm0A9hzYbHHbJklznj3hkqQZleQQ4J3Aa6vqoYFVa4BjkmyXZCmwD/DFPjJKUtfsCZckTZskHwVeCeyWZD1wCs1sKNsBlyUBuKqqfr+qbkpyAXAzzTCVE6vqJ/0kl6RuWYRLkqZNVb1xlOazf8b2pwKnzlwiSRpODkeRJEmSOmYRLkmSJHXMIlySJEnq2LwaE75k5cVbtd2x6vAekkiSJE3eaDUNWNfMJvaES5IkSR173CI8yTlJ7k1y4yjr3pGkkuzW3k6S9yZZl+SGJPsObLs8ya3t1/Lp/TEkSZKk2WM8PeEfBA4Z2ZhkT+Bg4JsDzYfSXGxhH2AFcGa77S40c8XuD+wHnJJk56kElyRJkmarxy3Cq+rzwH2jrDqd5gpoNdB2BPChalwF7JRkD+DVwGVVdV9V3Q9cxiiFvSRJkjQfTGpMeJIjgA1V9eURqxYBdw3cXt+2jdUuSZIkzTsTnh0lyfbAu2iGoky7JCtohrKw1157zcRDSJIkSb2aTE/4s4GlwJeT3AEsBq5L8gxgA7DnwLaL27ax2rdSVaurallVLVu4cOEk4kmSJEnDbcJFeFV9paqeXlVLqmoJzdCSfatqI7AGOLadJeUA4MGquhu4FDg4yc7tCZkHt22SJEnSvDOeKQo/CnwBeG6S9UlO+BmbXwLcDqwD/gH4A4Cqug/4M+Ca9utP2zZJkiRp3nncMeFV9cbHWb9kYLmAE8fY7hzgnAnmkyRJkuYcr5gpSZIkdcwiXJIkSeqYRbgkSZLUsQnPEy5JkqTuLFl5cd8RNAPsCZckSZI6ZhEuSZIkdcwiXJIkSeqYRbgkSZLUMYtwSZIkqWMW4ZIkSVLHLMIlSZKkjlmES5IkSR2zCJckTZsk5yS5N8mNA227JLksya3t953b9iR5b5J1SW5Ism9/ySWpWxbhkqTp9EHgkBFtK4HLq2of4PL2NsChwD7t1wrgzI4ySlLvLMIlSdOmqj4P3Dei+Qjg3Hb5XODIgfYPVeMqYKcke3STVJL6ZREuSZppu1fV3e3yRmD3dnkRcNfAduvbNkma8yzCJUmdqaoCaqL7JVmRZG2StZs2bZqBZJLULYtwSdJMu2fLMJP2+71t+wZgz4HtFrdtW6mq1VW1rKqWLVy4cEbDSlIXLMIlSTNtDbC8XV4OXDTQfmw7S8oBwIMDw1YkaU5b0HcASdLckeSjwCuB3ZKsB04BVgEXJDkBuBM4ut38EuAwYB3wEHB854ElqSePW4QnOQd4DXBvVb2gbfsr4L8CPwZuA46vqgfadScDJwA/Ad5SVZe27YcAZwDbAmdV1arp/3EkSX2qqjeOseqgUbYt4MSZTSRJw2k8w1E+yNZzvl4GvKCqXgh8HTgZIMnzgGOA57f7vD/Jtkm2Bf6OZk7Y5wFvbLeVJEmS5p3HLcJHm/O1qj5bVZvbm1fRnEwDzZyv51XVj6rqGzQfMe7Xfq2rqtur6sfAee22kiRJ0rwzHSdm/i7w6XZ5rDlfxz0XrNNQSZIkaa6bUhGe5I+BzcCHpyeO01BJkiRp7pv07ChJjqM5YfOg9uQa+Nlzvo5rLlhJkiRprptUT3g708k7gddW1UMDq9YAxyTZLslSYB/gi8A1wD5JliZ5Is3Jm2umFl2SJEmancYzReFoc76eDGwHXJYE4Kqq+v2quinJBcDNNMNUTqyqn7T382bgUpopCs+pqptm4OeRJEmSht7jFuFjzPl69s/Y/lTg1FHaL6G5MIMkSZI0r3nZekmSJKljFuGSJElSxyzCJUmSpI5ZhEuSJEkdswiXJEmSOmYRLkmSJHXMIlySJEnqmEW4JEmS1DGLcEmSJKljFuGSJElSxyzCJUmSpI5ZhEuSJEkdswiXJEmSOmYRLkmSJHXMIlySJEnqmEW4JEmS1DGLcEmSJKljFuGSJElSxyzCJUmSpI4t6DtA35asvHjU9jtWHd5xEkma25K8DXgTUMBXgOOBPYDzgF2Ba4Hfqaof9xZSkjryuD3hSc5Jcm+SGwfadklyWZJb2+87t+1J8t4k65LckGTfgX2Wt9vfmmT5zPw4kqRhlGQR8BZgWVW9ANgWOAY4DTi9qvYG7gdO6C+lJHVnPMNRPggcMqJtJXB5Ve0DXN7eBjgU2Kf9WgGcCU3RDpwC7A/sB5yypXCXJM0bC4AnJ1kAbA/cDRwIXNiuPxc4sqdsktSpxy3Cq+rzwH0jmo+gebOEx75pHgF8qBpXATsl2QN4NXBZVd1XVfcDl7F1YS9JmqOqagPw18A3aYrvB2mGnzxQVZvbzdYDi/pJKEndmuyJmbtX1d3t8kZg93Z5EXDXwHZb3lDHat9KkhVJ1iZZu2nTpknGkyQNk/bTzyOApcAzgR2YQGeMxwZJc82UZ0epqqI5yWZaVNXqqlpWVcsWLlw4XXcrSerXq4BvVNWmqnoY+ATwcppPTLdMErAY2DDazh4bJM01ky3C72mHmdB+v7dt3wDsObDdljfUsdolSfPDN4EDkmyfJMBBwM3AFcBR7TbLgYt6yidJnZpsEb6G5s0SHvumuQY4tp0l5QDgwXbYyqXAwUl2bj+SPLhtkyTNA1V1Nc0JmNfRTE+4DbAaOAl4e5J1NNMUnt1bSEnq0OPOE57ko8Argd2SrKeZ5WQVcEGSE4A7gaPbzS8BDgPWAQ/RzAFLVd2X5M+Aa9rt/rSqRp7sKUmaw6rqFJpjyKDbaWbNkqR55XGL8Kp64xirDhpl2wJOHON+zgHOmVA6SZIkaQ7ysvWSJElSxyzCJUmSpI5ZhEuSJEkdswiXJEmSOmYRLkmSJHXMIlySJEnq2ONOUShJkqSZt2TlxX1HUIfsCZckSZI6ZhEuSZIkdcwiXJIkSeqYY8IlSZLmiNHGld+x6vAekujx2BMuSZIkdcwiXJIkSeqYRbgkSZLUMYtwSZIkqWMW4ZIkSVLHLMIlSZKkjlmES5IkSR2zCJckSZI6NqUiPMnbktyU5MYkH03ypCRLk1ydZF2S85M8sd12u/b2unb9kun4ASRJkqTZZtJFeJJFwFuAZVX1AmBb4BjgNOD0qtobuB84od3lBOD+tv30djtJkiRp3pnqcJQFwJOTLAC2B+4GDgQubNefCxzZLh/R3qZdf1CSTPHxJUmSpFln0kV4VW0A/hr4Jk3x/SBwLfBAVW1uN1sPLGqXFwF3tftubrffdbKPL0mSJM1WUxmOsjNN7/ZS4JnADsAhUw2UZEWStUnWbtq0aap3J0mSJA2dqQxHeRXwjaraVFUPA58AXg7s1A5PAVgMbGiXNwB7ArTrdwS+M/JOq2p1VS2rqmULFy6cQjxJkiRpOE2lCP8mcECS7dux3QcBNwNXAEe12ywHLmqX17S3add/rqpqCo8vSZIkzUpTGRN+Nc0JltcBX2nvazVwEvD2JOtoxnyf3e5yNrBr2/52YOUUckuSZpkkOyW5MMlXk9yS5GVJdklyWZJb2+87951Tkrqw4PE3GVtVnQKcMqL5dmC/Ubb9T+D1U3k8SdKsdgbwmao6qr2GxPbAu4DLq2pVkpU0HTQn9RlSkrrgFTMlSTMuyY7AK2g/Ha2qH1fVAzx2+trBaW0laU6zCJckdWEpsAn4QJIvJTkryQ7A7lV1d7vNRmD30XZ25ixJc41FuCSpCwuAfYEzq+olwA8YcW5Qe7L+qCfsO3OWpLnGIlyS1IX1wPr2pH5oTuzfF7gnyR4A7fd7e8onSZ2yCJckzbiq2gjcleS5bdOWaW0Hp68dnNZWkua0Kc2OIknSBPwh8OF2ZpTbgeNpOoMuSHICcCdwdI/5JKkzFuGSpE5U1fXAslFWHdR1Fknqm8NRJEmSpI5ZhEuSJEkdswiXJEmSOmYRLkmSJHXMIlySJEnqmEW4JEmS1DGLcEmSJKljFuGSJElSxyzCJUmSpI5ZhEuSJEkdswiXJEmSOmYRLkmSJHXMIlySJEnq2JSK8CQ7JbkwyVeT3JLkZUl2SXJZklvb7zu32ybJe5OsS3JDkn2n50eQJEmSZpcFU9z/DOAzVXVUkicC2wPvAi6vqlVJVgIrgZOAQ4F92q/9gTPb70NpycqLt2q7Y9XhPSSRJEmz1Wj1BFhTaAo94Ul2BF4BnA1QVT+uqgeAI4Bz283OBY5sl48APlSNq4Cdkuwx6eSSJEnSLDWV4ShLgU3AB5J8KclZSXYAdq+qu9ttNgK7t8uLgLsG9l/ftj1GkhVJ1iZZu2nTpinEkyRJkobTVIrwBcC+wJlV9RLgBzRDTx5VVQXURO60qlZX1bKqWrZw4cIpxJMkSZKG01SK8PXA+qq6ur19IU1Rfs+WYSbt93vb9RuAPQf2X9y2SZIkSfPKpIvwqtoI3JXkuW3TQcDNwBpgedu2HLioXV4DHNvOknIA8ODAsBVJkiRp3pjq7Ch/CHy4nRnlduB4msL+giQnAHcCR7fbXgIcBqwDHmq3lSRJkuadKRXhVXU9sGyUVQeNsm0BJ07l8SRJkuaCsaYu1PzhFTMlSZKkjk11OIokSdK84gV4NB3sCZckSZI6ZhEuSZIkdcwiXJIkSeqYRbgkqTNJtk3ypSSfam8vTXJ1knVJzm+nvJWkOc8iXJLUpbcCtwzcPg04var2Bu4HTugllSR1zCJcktSJJIuBw4Gz2tsBDgQubDc5Fziyn3SS1C2LcElSV/4WeCfwSHt7V+CBqtrc3l4PLBptxyQrkqxNsnbTpk0zn1SSZphFuCRpxiV5DXBvVV07mf2ranVVLauqZQsXLpzmdJLUPS/WI0nqwsuB1yY5DHgS8DTgDGCnJAva3vDFwIYeM0pSZ+wJlyTNuKo6uaoWV9US4Bjgc1X1W8AVwFHtZsuBi3qKKEmdsgiXJPXpJODtSdbRjBE/u+c8ktQJh6NIkjpVVVcCV7bLtwP79ZlHkvpgT7gkSZLUMYtwSZIkqWMW4ZIkSVLHLMIlSZKkjlmES5IkSR2bchGeZNskX0ryqfb20iRXJ1mX5PwkT2zbt2tvr2vXL5nqY0uSJEmz0XT0hL8VuGXg9mnA6VW1N3A/cELbfgJwf9t+erudJEmSNO9MaZ7wJIuBw4FTaS62EOBA4DfbTc4F3g2cCRzRLgNcCLwvSaqqppKhS0tWXrxV2x2rDu8hiSRJkmazqfaE/y3wTuCR9vauwANVtbm9vR5Y1C4vAu4CaNc/2G4vSZIkzSuTLsKTvAa4t6quncY8JFmRZG2StZs2bZrOu5YkSZKGwlR6wl8OvDbJHcB5NMNQzgB2SrJlmMtiYEO7vAHYE6BdvyPwnZF3WlWrq2pZVS1buHDhFOJJkiRJw2nSRXhVnVxVi6tqCXAM8Lmq+i3gCuCodrPlwEXt8pr2Nu36z82m8eCSJEnSdJmJecJPojlJcx3NmO+z2/azgV3b9rcDK2fgsSVJkqShN6XZUbaoqiuBK9vl24H9RtnmP4HXT8fjSZIkSbOZV8yUJEmSOmYRLkmSJHVsWoajSJIkzXejXdRPGos94ZIkSVLHLMIlSZKkjlmES5IkSR2zCJckSZI6ZhEuSZIkdcwiXJIkSeqYRbgkSZLUMYtwSZIkqWMW4ZIkSVLHLMIlSTMuyZ5Jrkhyc5Kbkry1bd8lyWVJbm2/79x3VknqgkW4JKkLm4F3VNXzgAOAE5M8D1gJXF5V+wCXt7clac5b0HeA2W7JyotHbb9j1eEdJ5Gk4VVVdwN3t8vfS3ILsAg4Anhlu9m5wJXAST1ElKROWYR3yIJdkiDJEuAlwNXA7m2BDrAR2L2nWJLUKYtwSVJnkjwF+DjwR1X13SSPrquqSlJj7LcCWAGw1157dRFVc9honWJ2iKlrFuEzZKxeb0mar5I8gaYA/3BVfaJtvifJHlV1d5I9gHtH27eqVgOrAZYtWzZqoS5Js4knZkqSZlyaLu+zgVuq6m8GVq0BlrfLy4GLus4mSX2wJ1yS1IWXA78DfCXJ9W3bu4BVwAVJTgDuBI7uKZ80Kj/Z1kyZdBGeZE/gQzQn0RSwuqrOSLILcD6wBLgDOLqq7m97Qc4ADgMeAo6rquumFl+SNBtU1f8DMsbqg7rMIknDYCo94VvmfL0uyVOBa5NcBhxHM+frqiQraeZ8PQk4FNin/dofOLP9LkmSpBniiajDadJF+CTmfD0C+FBVFXBVkp22nIwz+fhzg38ckiRJ88u0jAkf55yvi4C7BnZb37Y9pgh3GipJktQ1x36ra1OeHWXknK+D69pe7wlNJVVVq6tqWVUtW7hw4VTjSZIkSUNnSj3hE5zzdQOw58Dui9s2SZKkcXMYp+aCSfeET2LO1zXAsWkcADzoeHBJkiTNR1PpCZ/onK+X0ExPuI5misLjp/DYkiRJ0qw1ldlRJjTnazs+/MTJPt5EeHKFJEmShpmXrZckSZI65mXrJUma5zzRUeqePeGSJElSx+wJlyRJvZtqb7zng03MWM+Xn4B0x55wSZIkqWMW4ZIkSVLHLMIlSZKkjjkmXJIkDSXHeWsusydckiRJ6phFuCRJktQxh6NIkjSEZuICOtMxvGMiubwIkDQ2e8IlSZKkjtkTPqScRF+SJGnusidckiRJ6pg94ZIk9chp+DRMHMffHXvCJUmSpI5ZhEuSJEkdcziKJElT4HASzVcOXZkae8IlSZKkjnXeE57kEOAMYFvgrKpa1XWG2cz/OiXNRR4bpt9Ue+hnqoffTw6kRqdFeJJtgb8Dfh1YD1yTZE1V3dxljrlmOuYUt7iX1BePDZLmo657wvcD1lXV7QBJzgOOAHyjnQFTLay9YJCkjnRybJhqD+ywvvcNQ8/yMGTQzBmG17frmqSLzsmui/BFwF0Dt9cD+3ecYV6bjj+kLv8YR/uFn8jjj/UH03fPv//gSI/hsUHSvDN0s6MkWQGsaG9+P8nXJngXuwHfnt5UU2am8dkqU06b2h1OZP8xtu30eRpn3lnx2g2JrnM9q8PHmlem4dgw9Qxb/312/ns/i98jwFwTNStzTfW4PVEjHm9Gn7Mp/GyjHhu6LsI3AHsO3F7ctj2qqlYDqyf7AEnWVtWyye4/E8w0PmYaHzON37Dm0lZm/NgwE4b198tcE2OuiRnWXDDc2UbT9RSF1wD7JFma5InAMcCajjNIkoaLxwZJ806nPeFVtTnJm4FLaaahOqeqbuoygyRpuHhskDQfdT4mvKouAS6ZwYcYqo8rW2YaHzONj5nGb1hzaYQOjg0zYVh/v8w1MeaamGHNBcOdbSupqr4zSJIkSfOKl62XJEmSOmYRLkmSJHVs6OYJn6gkP09zZbVFbdMGYE1V3dJfKkmSJGlss3pMeJKTgDcC59FcYQ2a+WWPAc6rqlV9ZRtGSXZn4J+VqrqnzzxbJNkFoKru6zvLFsOWaRhfOzNJkjR5s70I/zrw/Kp6eET7E4GbqmqffpI9mmMoCoIkLwb+D7AjP70AxmLgAeAPquq6HjLtBfwlcFCbI8DTgM8BK6vqDjMN7WtnJs0rSQ6pqs+0yzsCfwP8EnAj8LY+/9lr85wMHAk8HSjgXuAiYFVVPdBTrqF9ztpMQ3F8HkuSpwDPAW7v6zUckSfAfjx21MEXa4iKyGF7zsalqmbtF/BV4FmjtD8L+FqPuV4MXAXcAvxr+/XVtm3fHvJcD+w/SvsBwJd7eo6+ALwB2HagbVuaTzGuMtNQv3Zm8mtefQHXDSyfBfx5e5x5G/DJnrNdCpwEPGOg7Rlt22d9zrbKNVTH54Fc7x9Y/mXgm8AVwF3AYT3/jh0MrAM+3b6WZwGfadsO9jmb/Nds7wk/BHgfcCvNkw6wF7A38OZq/wvvIdf1wO9V1dUj2g8A/r6qXtRxnltrjE8Fkqyrqr27zDOOTGOuM9Nj1g3ja2cmzTlJrquqfdvl66vqxQPrHnO7h2xfq6rnTnTdTBvW52zYjs8Djz/4fF0BvKOqrkvyc8AF1eOl2JPcAhxaIz4NTrIUuKSqfqGnXEP7nI3XrD4xs6o+k+Q5bP0RyTVV9ZP+krHDyD9wgKq6KskOPeT5dJKLgQ/x039W9gSOpflvtg/XJnk/cO6ITMuBL5npUcP42plJ883Tk7yddohaktRPe7D6nmXsziTvBM6tdkhFO9TiOH76t9CHYX3Ohu34PJqnVTuErqpuT9L379gCfnre3aANwBM6zjKWYXvOxmVW94QPqyTvBZ7N6AXBN6rqzT1kOpTRZ5Hp5Qp17bj9E0bLBJxdVT8y06O5huq1M5PmmySnjGh6f1VtSvIM4C+r6tg+cgEk2RlYSfO7vzvNmPB7aN63TqueTi4f1udsGI/Pba6HaIZ3BFgC7FVV97fF5A1V9YI+crXZTgaOppkEY/A5O4amx/kveso1tM/ZeFmEzxALAkmaO9rpcBcBV1fV9wfaHz0BcRgk+RWaT4e/UlWf7THHW4B/rqo+e+NHNYzH5yTPGtH0rap6OMluwCuq6hN95NoiyS8w+nN2c4+Zhvo5Gw+L8Hlg4Oz5wZ6SXs+eT7KAptf5SB77R30RTa/zw2PtO88yDeNrZybNK0n+EHgzzcl8LwbeWlUXteseHZfaU7YvVtV+7fKbgBOBT9KcTPcv1dNUvUkeBH4A3AZ8FPhYVW3qI4s0rGbFmJnZJsmOSVYluSXJfUm+0y6vSrJTD5EuAO4Hfq2qdqmqXYFfo5m+7YIe8gD8I83B7D3AYe3Xe4AXAf9kpkcN42tnJs03K4CXVtWRwCuB/5Hkre269JaqMTgm9/doZqt4D00R/lv9RALgdpppQv8MeClwc5LPJFme5Kl9hRrC4/OWXE9L8hdJ/jHJb45Y9/6+crWPf8jA8o5JzkpyQ5KPtOcf9JXruiR/kuTZfWWYKnvCZ0CSS2nmlj63qja2bc+gOVHmwKo6uOM8Q3f2fJKvV9VzJrpuHmYaxtfOTJpXktxUVc8fuP0U4ELgZpr39D5nR/kyzT8G2wCXDs4IkeRLVfWSnnI95hOCJE8ADqW5wN6rqmphT7mG6vg8kOvjNDO9XQX8LvAw8JtV9aMh+LRlcBaSs4CNwD8ArwN+tf3ntI9c3wA+TjNefSPNJy7nV9W3+sgzGfaEz4wlVXXalj9wgKra2H4sOHIMUxfuTPLOwf9Yk+ye5oqjfY3Xuy/J6wfPYE6yTZI30PRomqkxjK+dmTTf3JPmglAAtGPCXwPsBvxib6kaOwLXAmuBXZLsAY/+o9BnL/1jHruqHq6qNVX1Rvo5Dm4xbMfnLZ5dVSur6pNV9VrgOuBzSXbtMdNollXVn1TVnVV1Os0JkX25v6r+W1XtBbwD2Ae4LskVSVb0mGvcLMJnxrAVBG8AdgX+Lcn9Se4DrgR2ofkPsg/HAEcBG5N8Pc3VTzfS/Gd9TM+Z7mkz3ToEmYbxtTOT5ptjad4LHlVVm9sZPl7RT6RHcyypqp+rqqXt97vbVY8Av9FjtDeMtaKqHuoyyD3vdjQAAANZSURBVAjDdnzeYrvBDqCqOpWmt/nzNO9tfXp6krcneQftdJMD64aijqyq/1tVf0BzPtdpwMt6jjQuDkeZAXnslFFPb5u3TBm1qqo671VNc2b/YporPw7Fmf1J9qc5ge424Odp/mhuHoYZZAZ6H86oqt/uNcyADMHMB+3r9tWqejDJ9jS/6/sCNwH/s6oe7CHT0M7EIGl4DOPxuc31lzRXOP3XEe2HAP+7erhY3ECGYZ1u8ryq6quDbFpYhHcsyfFV9YGOH/MtNGfMD82Z/e0f9aE0FwG4jKawvBL4dZpxjaf2kGnNKM0H0owfpP2IsFMZwpkPktwEvKiqNidZTTMDwseBg9r21/WQaXAmho/QzMTw7a5zSJq9+jg+j8ew5oLhzTasuUayCO9Ykm+245e6fMyvAC+rqu8nWUJzQtE/VtUZfZ2402Z6MbAdzce8i6vqu0meTDMP7wt7yHQdzYlWZ9H00IfmRI9jAKrq33rI9Ojrk+Qa4LC2B2IHmk81Oh+PmuSWai9TPMrJV71cjjrJl2hmYHgVzcfgr6UZJ/tR4BNV9b2uM0maXfo4Po/HsOaC4c02rLlGmtWXrR9WSW4YaxXNHMZd22bLEJSquiPJK4EL00x039eJO5ur6ifAQ0luq6rvtvl+mOSRnjItA94K/DHw36vq+iQ/7KP4HrBN+/HpNjT/NG8CqKofJNncU6YbB3oZvpxkWVWtTfIcmjP6+1BV9QjwWeCzeexMDH8N9DITg6ThMoTH5+bBhzQXDG+2Yc01ERbhM2N34NVsPaNGgP/oPk5zZn9VXQ/Nmf1JXgOcQ39n9v84yfbtCTov3dKY5qIrvRThbRF3epKPtd/vof+/kS0zHwSoJHtU1d09z3zwJuCMJH8CfBv4QpK7aE5qelNPmbaaiYFmjOeadty6JMHwHZ+3GNZcMLzZhjXXuPVdYMxVnwKesqXoHZTkyu7jcCzwmF7TqtoMHJvk73vIA80lZX/UZhksup8ALO8nUqOq1gOvT3I48N2esywZY1VvMx+0J14el+RpwFKa95H1VXVPH3lawzoTg6ThMmzH5y2GNRcMb7ZhzTVujgmXJEmSOjYU8ztKkiRJ84lFuCRJktQxi3BJkiSpYxbhkiRJUscswiVJkqSO/X+HHubAUYssbwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 864x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "na1QNN0h9jT2"
      },
      "source": [
        "From the above plots its clear that spam messages are of more length and text_len emerged as an important feature for identifying spam messages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 386
        },
        "id": "oQGlVMpMA6e0",
        "outputId": "1aef653a-4975-418b-db1f-750d0ea390c0"
      },
      "source": [
        "%matplotlib inline\n",
        "sns.displot(df,x=\"punct_percent\",hue=\"label\",palette='inferno',bins=30)\n",
        "plt.xlim(0,60)"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.0, 60.0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 423.25x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "Uao3RzMU-jOf",
        "outputId": "cd263a15-e9d0-4896-bfb7-aed455fe12a2"
      },
      "source": [
        "bins = np.linspace(0, 50, 40)\n",
        "\n",
        "plt.hist(df['punct_percent'], bins)\n",
        "plt.title(\"Punctuation % Distribution\")\n",
        "plt.show()"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "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": "24cTNWPC96Cx"
      },
      "source": [
        "import numpy as np\n",
        "df['label']=np.where(df['label']=='spam',1,0)"
      ],
      "execution_count": 110,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ANPFer4Go34c"
      },
      "source": [
        "Preprocessing the text\n",
        "========="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EIytolV3BkLn",
        "outputId": "f26515c6-d297-449b-b8c2-87f449254126"
      },
      "source": [
        "df['text'][8:15]"
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8     WINNER!! As a valued network customer you have...\n",
              "9     Had your mobile 11 months or more? U R entitle...\n",
              "10    I'm gonna be home soon and i don't want to tal...\n",
              "11    SIX chances to win CASH! From 100 to 20,000 po...\n",
              "12    URGENT! You have won a 1 week FREE membership ...\n",
              "13    I've been searching for the right words to tha...\n",
              "14                  I HAVE A DATE ON SUNDAY WITH WILL!!\n",
              "Name: text, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaHS2-HQqJwh"
      },
      "source": [
        "we can clearly see that the text is containig punctuations ,lets dive into data cleaning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9fEc13jshwqr"
      },
      "source": [
        "lemma = nltk.WordNetLemmatizer()"
      ],
      "execution_count": 112,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OcnVwy4-5sWG"
      },
      "source": [
        "def cleaning_text(text):\n",
        "   #removing punctuations\n",
        "   text=\"\".join([word.lower() for word in text if word not in string.punctuation])\n",
        "   # tokenizing data\n",
        "   tokens=re.split('\\W+',text)\n",
        "   #removal of stopwords from the tokenixed text\n",
        "   text=[lemma.lemmatize(word) for word in tokens if word not in stopwords]\n",
        "   return text"
      ],
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TIvZCc2lUnVR"
      },
      "source": [
        "stopwords=nltk.corpus.stopwords.words('english')"
      ],
      "execution_count": 114,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5t5jb2Mv-7nI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "54fc2c56-ff0b-4e63-8670-5ce6aa28c020"
      },
      "source": [
        "import nltk\n",
        "nltk.download('wordnet')\n",
        "df['clean_text'] = df['text'].apply(lambda x: cleaning_text(x))\n",
        "df.head()"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/wordnet.zip.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "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>label</th>\n",
              "      <th>text</th>\n",
              "      <th>text_len</th>\n",
              "      <th>punct_percent</th>\n",
              "      <th>clean_text</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "      <td>92</td>\n",
              "      <td>9.8</td>\n",
              "      <td>[go, jurong, point, crazy, available, bugis, n...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "      <td>24</td>\n",
              "      <td>25.0</td>\n",
              "      <td>[ok, lar, joking, wif, u, oni]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "      <td>128</td>\n",
              "      <td>4.7</td>\n",
              "      <td>[free, entry, 2, wkly, comp, win, fa, cup, fin...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "      <td>39</td>\n",
              "      <td>15.4</td>\n",
              "      <td>[u, dun, say, early, hor, u, c, already, say]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "      <td>49</td>\n",
              "      <td>4.1</td>\n",
              "      <td>[nah, dont, think, go, usf, life, around, though]</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   label  ...                                         clean_text\n",
              "0      0  ...  [go, jurong, point, crazy, available, bugis, n...\n",
              "1      0  ...                     [ok, lar, joking, wif, u, oni]\n",
              "2      1  ...  [free, entry, 2, wkly, comp, win, fa, cup, fin...\n",
              "3      0  ...      [u, dun, say, early, hor, u, c, already, say]\n",
              "4      0  ...  [nah, dont, think, go, usf, life, around, though]\n",
              "\n",
              "[5 rows x 5 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QhZK0J4xXiPo"
      },
      "source": [
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": 116,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QZy9u21_Ui9W"
      },
      "source": [
        "#splitting our data into train and text\n",
        "X_train, X_test, y_train, y_test = train_test_split(df.drop('label',axis=1),df['label'], test_size=0.2)"
      ],
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SmWtaJhtf5jp"
      },
      "source": [
        "Vectorizing text using TF-IDF\n",
        "==============="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BYMrWDwUYK46"
      },
      "source": [
        "tfidf_vect = TfidfVectorizer(analyzer=cleaning_text)\n",
        "train_vect=tfidf_vect.fit_transform(X_train['text'])\n",
        "test_vect = tfidf_vect.transform(X_test['text'])"
      ],
      "execution_count": 118,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JjwbEnr757cP",
        "outputId": "6934deab-b732-4df9-967d-6aa171333feb"
      },
      "source": [
        "train_vect.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4457, 7813)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "evQQ768Os-u5",
        "outputId": "947e9fa3-9ec2-4a29-9d4a-28f0bdeceb62"
      },
      "source": [
        "tfidf_train = pd.DataFrame(train_vect.toarray())\n",
        "tfidf_train.columns = tfidf_vect.get_feature_names()\n",
        "tfidf_test = pd.DataFrame(test_vect.toarray())\n",
        "tfidf_test.columns = tfidf_vect.get_feature_names()\n",
        "print(tfidf_train.shape)\n",
        "print(tfidf_test.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4457, 7813)\n",
            "(1115, 7813)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QAp6W4mht0O1"
      },
      "source": [
        "dff=pd.DataFrame(X_train['text_len'])\n",
        "dgg=pd.DataFrame(X_train['punct_percent'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8U5z4j0stlHp"
      },
      "source": [
        "dss=pd.DataFrame(X_test['text_len'])\n",
        "dqq=pd.DataFrame(X_test['punct_percent'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6rP35BolmiCG",
        "outputId": "b9c8e711-b002-4da0-f753-a7e72a9be2ae"
      },
      "source": [
        "from scipy.sparse import hstack\n",
        "# with the same hstack function we are concatinating a sparse matrix and a dense matirx :)\n",
        "train_feat= hstack((tfidf_train,dff,dgg))\n",
        "test_feat=hstack((tfidf_test,dss,dqq))\n",
        "print(train_feat.shape)\n",
        "print(test_feat.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4457, 7815)\n",
            "(1115, 7815)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lblv2jWGdPsu"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "rf = RandomForestClassifier()\n",
        "rf_model = rf.fit(train_feat, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M7oNKS11jtWu"
      },
      "source": [
        "y_pred = rf_model.predict(test_feat)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "swYBIzKbjx4f",
        "outputId": "fca8d735-4dad-4bbd-856d-732ac5d074b3"
      },
      "source": [
        "from sklearn.metrics import precision_score, recall_score\n",
        "precision = precision_score(y_test, y_pred)\n",
        "recall = recall_score(y_test, y_pred)\n",
        "print('Precision: {} / Recall: {} / Accuracy: {}'.format(\n",
        "    round(precision, 3), round(recall, 3), round((y_pred==y_test).sum()/len(y_pred), 3)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Precision: 1.0 / Recall: 0.827 / Accuracy: 0.978\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-7fFekian0FV"
      },
      "source": [
        "VERCTORIZING TEXT USING WORD2VEC\n",
        "-------------------"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EtnPUbIj9TI"
      },
      "source": [
        "import gensim\n",
        "w2v_model = gensim.models.Word2Vec(X_train['clean_text'],\n",
        "                                   size=100,\n",
        "                                   window=5,\n",
        "                                   min_count=2)\n",
        "# Train a basic word2vec model on our training data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v_WJ8GPdkx43"
      },
      "source": [
        "words = set(w2v_model.wv.index2word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TQ3jTUXbBHT2",
        "outputId": "d20ea5c1-2d22-4769-b646-f737a9b2a674"
      },
      "source": [
        "from tqdm import tqdm\n",
        "avg_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
        "for sentence in tqdm(X_train['clean_text']): # for each review/sentence\n",
        "    vector = np.zeros(100) # as word vectors are of zero length\n",
        "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
        "    for word in sentence: # for each word in a review/sentence\n",
        "        if word in words:\n",
        "            vector += w2v_model[word]\n",
        "            cnt_words += 1\n",
        "    if cnt_words != 0:\n",
        "        vector /= cnt_words\n",
        "    avg_w2v_vectors.append(vector)\n",
        "\n",
        "print(len(avg_w2v_vectors))\n",
        "print(len(avg_w2v_vectors[0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 0/4457 [00:00<?, ?it/s]/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:8: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
            "  \n",
            "100%|██████████| 4457/4457 [00:00<00:00, 11669.57it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "4457\n",
            "100\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BO0XY0p2CZLg",
        "outputId": "af4a5e1e-ecdf-4575-be03-3e33da6d4876"
      },
      "source": [
        "from tqdm import tqdm\n",
        "test_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
        "for sentence in tqdm(X_test['clean_text']): # for each review/sentence\n",
        "    vector = np.zeros(100) # as word vectors are of zero length\n",
        "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
        "    for word in sentence: # for each word in a review/sentence\n",
        "        if word in words:\n",
        "            vector += w2v_model[word]\n",
        "            cnt_words += 1\n",
        "    if cnt_words != 0:\n",
        "        vector /= cnt_words\n",
        "    test_w2v_vectors.append(vector)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 0/1115 [00:00<?, ?it/s]/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:8: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
            "  \n",
            "100%|██████████| 1115/1115 [00:00<00:00, 7004.72it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "STPGskkICFUn",
        "outputId": "47bf2bd3-257a-4a99-fec4-cde39ffd0850"
      },
      "source": [
        "print(len(test_w2v_vectors))\n",
        "print(len(test_w2v_vectors[0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1115\n",
            "100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lh2YaBZiD18U",
        "outputId": "6fea6c56-f6fe-497f-ff8c-e7f0284a9724"
      },
      "source": [
        "#lets stack numeric aand text features\n",
        "train_w2v= hstack((avg_w2v_vectors,dff,dgg))\n",
        "test_w2v=hstack((test_w2v_vectors,dss,dqq))\n",
        "print(train_w2v.shape)\n",
        "print(test_w2v.shape)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4457, 102)\n",
            "(1115, 102)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7KoRNE4n03w"
      },
      "source": [
        "rf = RandomForestClassifier()\n",
        "rf_model = rf.fit(train_w2v, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fY3a8Bn5tjAY",
        "outputId": "1aa43e56-353c-44aa-b159-d8e5039161d6"
      },
      "source": [
        "#model prediction and evaluation on test set\n",
        "y_pred = rf_model.predict(test_w2v) \n",
        "precision = precision_score(y_test, y_pred)\n",
        "recall = recall_score(y_test, y_pred)\n",
        "print('Precision: {} / Recall: {} / Accuracy: {}'.format(\n",
        "    round(precision, 3), round(recall, 3), round((y_pred==y_test).sum()/len(y_pred), 3)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Precision: 1.0 / Recall: 0.691 / Accuracy: 0.961\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QNwlVUfbPRvB"
      },
      "source": [
        "Vectorization using DOC2VEC\n",
        "========="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x9UKFrDjtY5k"
      },
      "source": [
        "#getting words usind DOC2VEC\n",
        "doc_tag_train = [gensim.models.doc2vec.TaggedDocument(v, [i])\n",
        "                     for i, v in enumerate(X_train['clean_text'])]\n",
        "doc_tag_test = [gensim.models.doc2vec.TaggedDocument(v, [i])\n",
        "                    for i, v in enumerate(X_test['clean_text'])]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GtZyZKRozd23",
        "outputId": "9a064915-782a-485a-ccd0-e5d17860dd40"
      },
      "source": [
        "doc_tag_train[:10]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[TaggedDocument(words=['omw', 'back', 'tampa', 'west', 'palm', 'hear', 'happened'], tags=[0]),\n",
              " TaggedDocument(words=['pure', 'hearted', 'person', 'wonderful', 'smile', 'make', 'even', 'hisher', 'enemy', 'feel', 'guilty', 'enemy', 'catch', 'world', 'smile', 'goodmorning', 'amp', 'smiley', 'sunday'], tags=[1]),\n",
              " TaggedDocument(words=['recpt', '13', 'ordered', 'ringtone', 'order', 'processed'], tags=[2]),\n",
              " TaggedDocument(words=['ok', 'april', 'cant', 'wait'], tags=[3]),\n",
              " TaggedDocument(words=['ya', 'ok', 'dinner'], tags=[4]),\n",
              " TaggedDocument(words=['consider', 'wall', 'bunker', 'shit', 'important', 'never', 'play', 'peaceful', 'guess', 'place', 'high', 'enough', 'dont', 'matter'], tags=[5]),\n",
              " TaggedDocument(words=['sure', 'night', 'menu', 'know', 'noon', 'menu'], tags=[6]),\n",
              " TaggedDocument(words=['someone', 'u', 'know', 'asked', 'dating', 'service', '2', 'contact', 'cant', 'guess', 'call', '09058091854', 'revealed', 'po', 'box385', 'm6', '6wu'], tags=[7]),\n",
              " TaggedDocument(words=['callsmessagesmissed', 'call'], tags=[8]),\n",
              " TaggedDocument(words=['ok', 'enjoy', 'r', 'u', 'home'], tags=[9])]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HzLjm3pKzqmM"
      },
      "source": [
        "d2v_model = gensim.models.Doc2Vec(doc_tag_train,\n",
        "                                  vector_size=100,\n",
        "                                  window=5,\n",
        "                                  min_count=2)\n",
        "# Training a basic doc2vec model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-W_QesIL7e-k",
        "outputId": "edd158db-f5ad-492d-eaa7-fc11a22619c1"
      },
      "source": [
        "d2v_model.infer_vector(['happy', 'deepavali', 'to', 'everyone'])\n",
        "#example to see how d2v vectors look like"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2.50690710e-03, -1.48047535e-02, -7.04272278e-03, -6.83367485e-03,\n",
              "        2.22320762e-03,  7.95769412e-03,  2.40248279e-03,  5.61994128e-03,\n",
              "       -6.94849482e-03,  2.21587182e-03,  9.69665218e-03, -7.47682585e-04,\n",
              "       -8.38195160e-03,  3.77993286e-03,  2.37473124e-03,  3.40466481e-03,\n",
              "        1.12460693e-02, -1.95820280e-03, -1.47327119e-02, -9.97993909e-03,\n",
              "        1.61639787e-03, -9.83112841e-04,  1.74994243e-03, -1.05431754e-05,\n",
              "       -9.99938138e-03,  1.25824036e-02,  1.13125984e-02,  1.06225237e-02,\n",
              "       -1.18393479e-02,  1.00579225e-02,  5.54088643e-03, -7.88440183e-03,\n",
              "       -4.85946424e-03,  1.16722926e-03, -5.48183126e-03,  1.90768912e-02,\n",
              "       -2.68416409e-03,  6.02410734e-03,  9.82735027e-03,  9.06077679e-03,\n",
              "        1.04715605e-03,  1.75151974e-03,  7.35337613e-04, -1.01058381e-02,\n",
              "        1.23227686e-02,  7.22568668e-03, -3.17909825e-03,  1.39575843e-02,\n",
              "       -1.19969165e-02,  3.40859126e-03,  1.10997027e-02, -1.99971627e-03,\n",
              "        4.96758195e-03,  1.31764226e-02,  6.83411164e-03,  1.04980776e-02,\n",
              "       -1.25934593e-02, -1.93415571e-03,  4.31372924e-03, -1.09696584e-02,\n",
              "       -7.16959534e-04, -4.89237078e-04,  5.18846652e-03,  1.04651600e-02,\n",
              "       -1.49765788e-02,  4.46408521e-03, -1.37381935e-02, -3.39567450e-05,\n",
              "       -5.46319690e-03,  7.82365911e-03, -2.32040347e-03,  3.52951465e-03,\n",
              "        1.88128110e-02, -9.90920886e-03, -1.38948644e-02,  3.17864888e-03,\n",
              "        8.02118052e-03, -1.44566512e-02, -1.74165110e-03,  1.02729397e-02,\n",
              "       -4.64663794e-03, -4.63069417e-03, -2.79618357e-03,  4.05988144e-03,\n",
              "        1.36338081e-02,  1.09986365e-02,  1.31692588e-02, -1.02669010e-02,\n",
              "        4.77355625e-03, -3.27168289e-03, -2.74333428e-03, -1.40287820e-02,\n",
              "       -4.53165872e-03,  8.06259178e-03,  7.81726383e-04, -1.15796539e-03,\n",
              "        5.56509849e-03,  6.25510188e-03, -6.00026734e-03,  1.35983210e-02],\n",
              "      dtype=float32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kS_PyzQP9XPi"
      },
      "source": [
        "#obtaning vectors using d2v for train and test data\n",
        "train_vectors_final = [d2v_model.infer_vector (v.words) for v in doc_tag_train]\n",
        "test_vectors_final = [d2v_model.infer_vector (v.words) for v in doc_tag_test]   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AHLbsmXKFVcV",
        "outputId": "e315393e-04a1-406b-ab10-7e3ca555ba8d"
      },
      "source": [
        "#stack numerical and text features \n",
        "train_d2v= hstack((train_vectors_final,dff,dgg))\n",
        "test_d2v=hstack((test_vectors_final,dss,dqq))\n",
        "print(train_d2v.shape)\n",
        "print(test_d2v.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4457, 102)\n",
            "(1115, 102)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3OQn72soBTcJ",
        "outputId": "af00ff3f-c2f2-4e0c-f8b3-169fd1c4f1aa"
      },
      "source": [
        "#instantiate the random forest classifier\n",
        "rf = RandomForestClassifier()\n",
        "rf_model = rf.fit(train_d2v, y_train)\n",
        "#predict model performance using test vectors\n",
        "y_pred = rf_model.predict(test_d2v)\n",
        "#evaluate the models performance\n",
        "precision = precision_score(y_test, y_pred)\n",
        "recall = recall_score(y_test, y_pred)\n",
        "print('Precision: {} //// Recall: {} //// Accuracy: {}'.format(\n",
        "    round(precision,2), round(recall, 2), round((y_pred==y_test).sum()/len(y_pred), 2)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Precision: 0.81 //// Recall: 0.27 //// Accuracy: 0.9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c--XHZ3QD631"
      },
      "source": [
        "Recurrent neural network \n",
        "========="
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nLqxgJl8BLN_"
      },
      "source": [
        "# training the tokenizer and use tokenizer to convert the sentences to sequences of numbers\n",
        "from keras.preprocessing.text import Tokenizer\n",
        "from keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "tokenizer = Tokenizer()\n",
        "tokenizer.fit_on_texts(X_train['clean_text'])\n",
        "X_train_seq = tokenizer.texts_to_sequences(X_train['clean_text'])\n",
        "X_test_seq = tokenizer.texts_to_sequences(X_test['clean_text'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9OYrg3NHKc7"
      },
      "source": [
        "train_seq_padded = pad_sequences(X_train_seq, 50)\n",
        "test_seq_padded = pad_sequences(X_test_seq, 50)\n",
        "# padding the sequences so each sequence is of same length"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8pBtQM5uGz9L",
        "outputId": "fc049f37-2d9e-4005-9a3d-5f553ba736ec"
      },
      "source": [
        "train_rnn= hstack((train_seq_padded,dff,dgg))\n",
        "test_rnn=hstack((test_seq_padded,dss,dqq))\n",
        "\n",
        "print(train_rnn.shape)\n",
        "print(test_rnn.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4457, 52)\n",
            "(1115, 52)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xH2X3xCdJwys"
      },
      "source": [
        "import keras.backend as K\n",
        "from keras.layers import Dense, Embedding, LSTM\n",
        "from keras.models import Sequential"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aHxoE9-SJxa9",
        "outputId": "e1b16478-bf51-43d4-e382-6be9378d0e60"
      },
      "source": [
        "#instantiating our neural network model\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Embedding(len(tokenizer.index_word)+1, 32))\n",
        "model.add(LSTM(32, dropout=0, recurrent_dropout=0))\n",
        "model.add(Dense(32, activation='relu'))\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_3 (Embedding)      (None, None, 32)          250048    \n",
            "_________________________________________________________________\n",
            "lstm_3 (LSTM)                (None, 32)                8320      \n",
            "_________________________________________________________________\n",
            "dense_6 (Dense)              (None, 32)                1056      \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (None, 1)                 33        \n",
            "=================================================================\n",
            "Total params: 259,457\n",
            "Trainable params: 259,457\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x0NCFVESl6ae"
      },
      "source": [
        "import keras\n",
        "train_data=train_rnn.toarray()\n",
        "test_data=test_rnn.toarray()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fbjtjd80bpPI",
        "outputId": "1063946e-6ab9-42de-be0b-077382c99753"
      },
      "source": [
        "train_seq_padded"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[   0,    0,    0, ..., 3492,  291,  554],\n",
              "       [   0,    0,    0, ...,   97, 3496,  927],\n",
              "       [   0,    0,    0, ...,  351,  524, 2227],\n",
              "       ...,\n",
              "       [   0,    0,    0, ..., 1575,  559,  310],\n",
              "       [   0,    0,    0, ...,  479,   28,   77],\n",
              "       [   0,    0,    0, ...,   97, 1829,    1]], dtype=int32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 165
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4bqnxPDWJxL0"
      },
      "source": [
        "#compiling our rnn model\n",
        "model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy',keras.metrics.Precision(),keras.metrics.Recall()])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YP_AfVEdKD0J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66ce2db7-8e6c-46ad-8e93-82d6e8527b0b"
      },
      "source": [
        "#fitting our model to our train data and evaluating on test data for each epoch\n",
        "history = model.fit(train_data,\n",
        "                    y_train,\n",
        "                    batch_size=32, \n",
        "                    epochs=10,\n",
        "                    validation_data=(test_data, y_test))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "140/140 [==============================] - 4s 27ms/step - loss: 1.1528e-05 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1387 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 2/10\n",
            "140/140 [==============================] - 4s 25ms/step - loss: 9.9789e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1403 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 3/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 8.7129e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1419 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 4/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 7.6621e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1433 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 5/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 6.7922e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1446 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 6/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 6.0493e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1460 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 7/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 5.4026e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1471 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 8/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 4.8466e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1485 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 9/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 4.3662e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1496 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n",
            "Epoch 10/10\n",
            "140/140 [==============================] - 4s 26ms/step - loss: 3.9453e-06 - accuracy: 1.0000 - precision_3: 1.0000 - recall_3: 1.0000 - val_loss: 0.1508 - val_accuracy: 0.9848 - val_precision_3: 0.9919 - val_recall_3: 0.8849\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_YjjtmlTKVkM"
      },
      "source": [
        "Summarizing All models performace "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_AegChQGKbhf"
      },
      "source": [
        "from prettytable import PrettyTable\n"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CjrRQUIaKdc7"
      },
      "source": [
        "myTable = PrettyTable([\"model\", \"Accuracy \", \"Precision           \",\"Recall           \"])"
      ],
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U8kXLxJcLp04"
      },
      "source": [
        "#x.add_column(\"TFIDF\",\"WORD2VEC\",\"DOC2VEC\",\"RNN\",[model])\n",
        "myTable.add_row([\"TFIDF\", \"97 %\", \"1.0\", \"0.82\"]) \n",
        "myTable.add_row([\"WORD2VEC\", \"96.1 %\", \"1.0\", \"0.69\"]) \n",
        "myTable.add_row([\"DOC2VEC\", \"90 %\", \"0.81\", \"0.27\"]) \n",
        "myTable.add_row([\"RNN\", \"98 %\", \"0.99\", \"0.88\"]) \n"
      ],
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rcdxyr5FLC18",
        "outputId": "b3278d78-26e1-42fb-cf58-c0ebeb3555bf"
      },
      "source": [
        "print(myTable)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "+----------+-----------+----------------------+-------------------+\n",
            "|  model   | Accuracy  | Precision            | Recall            |\n",
            "+----------+-----------+----------------------+-------------------+\n",
            "|  TFIDF   |    97 %   |         1.0          |        0.82       |\n",
            "| WORD2VEC |   96.1 %  |         1.0          |        0.69       |\n",
            "| DOC2VEC  |    90 %   |         0.81         |        0.27       |\n",
            "|   RNN    |    98 %   |         0.99         |        0.88       |\n",
            "+----------+-----------+----------------------+-------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aQW3DWrOXTnN"
      },
      "source": [
        "Summary\n",
        "-------------\n",
        "We can clearly see that our basic RNN model performs better than TFIDF,W2V,D2V models.\n",
        "we can further tune the hyper parameters and experiment on TFIDF,W2V,D2V which might increase the models performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xFHBV7nRTlDD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}