3.LR, Linear-SVM, XGBoost with hyperparameter tuning+Sim fs+Adv fs+simple TF-IDF vectors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><p style=\"color: blue\">Performing hyperparameter tuning of Logistic regression, Linear-SVM, XGBoost with simple TF-IDF vectors</p></h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "        <script type=\"text/javascript\">\n",
       "        window.PlotlyConfig = {MathJaxConfig: 'local'};\n",
       "        if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}\n",
       "        if (typeof require !== 'undefined') {\n",
       "        require.undef(\"plotly\");\n",
       "        requirejs.config({\n",
       "            paths: {\n",
       "                'plotly': ['https://cdn.plot.ly/plotly-latest.min']\n",
       "            }\n",
       "        });\n",
       "        require(['plotly'], function(Plotly) {\n",
       "            window._Plotly = Plotly;\n",
       "        });\n",
       "        }\n",
       "        </script>\n",
       "        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from subprocess import check_output\n",
    "%matplotlib inline\n",
    "import plotly.offline as py\n",
    "py.init_notebook_mode(connected=True)\n",
    "import plotly.graph_objs as go\n",
    "import plotly.tools as tls\n",
    "import os\n",
    "import gc\n",
    "\n",
    "import re\n",
    "from nltk.corpus import stopwords\n",
    "import distance\n",
    "from nltk.stem import PorterStemmer\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "from fuzzywuzzy import fuzz\n",
    "from sklearn.manifold import TSNE\n",
    "# Import the Required lib packages for WORD-Cloud generation\n",
    "# https://stackoverflow.com/questions/45625434/how-to-install-wordcloud-in-python3-6\n",
    "from wordcloud import WordCloud, STOPWORDS\n",
    "from os import path\n",
    "from PIL import Image\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.preprocessing import normalize\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.decomposition import TruncatedSVD\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics.classification import accuracy_score, log_loss\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import StratifiedKFold \n",
    "from sklearn.calibration import CalibratedClassifierCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import normalized_mutual_info_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn import model_selection\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import precision_recall_curve, auc, roc_curve\n",
    "from mlxtend.classifier import StackingClassifier\n",
    "\n",
    "from collections import Counter, defaultdict\n",
    "from scipy.sparse import hstack\n",
    "\n",
    "from sqlalchemy import create_engine # database connection\n",
    "\n",
    "import xgboost as xgb\n",
    "\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV,StratifiedKFold\n",
    "\n",
    "from sklearn.utils.testing import ignore_warnings\n",
    "from sklearn.exceptions import ConvergenceWarning\n",
    "\n",
    "import warnings\n",
    "with warnings.catch_warnings():\n",
    "    warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)\n",
    "\n",
    "#import warnings\n",
    "#with warnings.catch_warnings():\n",
    "#    warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> 4. Loading Data Sheet and getting ready for apply TF-IDF</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Basic Feature and advance feature data set\n",
    "df_basic_feature = pd.read_csv(\"df_fe_without_preprocessing_train.csv\",encoding='latin-1')\n",
    "df_advance_feature = pd.read_csv(\"nlp_features_train.csv\",encoding='latin-1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color: blue\">Now drop 'qid1', 'qid2','question1','question2','is_duplicate' columns and add both the dataframe</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Columns dropped from basic feature dataframe \n",
    "df_basic_feature = df_basic_feature.drop(['qid1','qid2'],axis=1)\n",
    "\n",
    "# Columns dropped from advance feature dataframe \n",
    "df_advance_feature = df_advance_feature.drop(['qid1','qid2','question1','question2','is_duplicate'],axis=1)\n",
    "\n",
    "# Lets add both the truncated dataframe into one dataframe\n",
    "df_basic_advance_feature  = df_basic_feature.merge(df_advance_feature, on='id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            id                         question1  \\\n",
      "105780  105780    How can I develop android app?   \n",
      "201841  201841  How can I create an Android app?   \n",
      "363362  363362                               NaN   \n",
      "\n",
      "                                                question2  is_duplicate  \\\n",
      "105780                                                NaN             0   \n",
      "201841                                                NaN             0   \n",
      "363362  My Chinese name is Haichao Yu. What English na...             0   \n",
      "\n",
      "        freq_qid1  freq_qid2  q1len  q2len  q1_n_words  q2_n_words  ...  \\\n",
      "105780          2          2     30      0           6           1  ...   \n",
      "201841          1          2     32      0           7           1  ...   \n",
      "363362          1          1      0    123           1          21  ...   \n",
      "\n",
      "        ctc_max  last_word_eq  first_word_eq  abs_len_diff  mean_len  \\\n",
      "105780      0.0           0.0            0.0           0.0       0.0   \n",
      "201841      0.0           0.0            0.0           0.0       0.0   \n",
      "363362      0.0           0.0            0.0           0.0       0.0   \n",
      "\n",
      "        token_set_ratio  token_sort_ratio  fuzz_ratio  fuzz_partial_ratio  \\\n",
      "105780                0                 0           0                   0   \n",
      "201841                0                 0           0                   0   \n",
      "363362                0                 0           0                   0   \n",
      "\n",
      "        longest_substr_ratio  \n",
      "105780                   0.0  \n",
      "201841                   0.0  \n",
      "363362                   0.0  \n",
      "\n",
      "[3 rows x 30 columns]\n"
     ]
    }
   ],
   "source": [
    "nan_rows = df_basic_advance_feature[df_basic_advance_feature.isnull().any(1)]\n",
    "print (nan_rows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color: blue\">Found 3 such rows, we will remove these rows from the original dataset itself</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_basic_advance_feature = df_basic_advance_feature[df_basic_advance_feature['question1'].notnull()]\n",
    "df_basic_advance_feature = df_basic_advance_feature[df_basic_advance_feature['question2'].notnull()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty DataFrame\n",
      "Columns: [id, question1, question2, is_duplicate, freq_qid1, freq_qid2, q1len, q2len, q1_n_words, q2_n_words, word_Common, word_Total, word_share, freq_q1+q2, freq_q1-q2, cwc_min, cwc_max, csc_min, csc_max, ctc_min, ctc_max, last_word_eq, first_word_eq, abs_len_diff, mean_len, token_set_ratio, token_sort_ratio, fuzz_ratio, fuzz_partial_ratio, longest_substr_ratio]\n",
      "Index: []\n",
      "\n",
      "[0 rows x 30 columns]\n"
     ]
    }
   ],
   "source": [
    "nan_rows = df_basic_advance_feature[df_basic_advance_feature.isnull().any(1)]\n",
    "print (nan_rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 404287 entries, 0 to 404289\n",
      "Data columns (total 30 columns):\n",
      " #   Column                Non-Null Count   Dtype  \n",
      "---  ------                --------------   -----  \n",
      " 0   id                    404287 non-null  int64  \n",
      " 1   question1             404287 non-null  object \n",
      " 2   question2             404287 non-null  object \n",
      " 3   is_duplicate          404287 non-null  int64  \n",
      " 4   freq_qid1             404287 non-null  int64  \n",
      " 5   freq_qid2             404287 non-null  int64  \n",
      " 6   q1len                 404287 non-null  int64  \n",
      " 7   q2len                 404287 non-null  int64  \n",
      " 8   q1_n_words            404287 non-null  int64  \n",
      " 9   q2_n_words            404287 non-null  int64  \n",
      " 10  word_Common           404287 non-null  float64\n",
      " 11  word_Total            404287 non-null  float64\n",
      " 12  word_share            404287 non-null  float64\n",
      " 13  freq_q1+q2            404287 non-null  int64  \n",
      " 14  freq_q1-q2            404287 non-null  int64  \n",
      " 15  cwc_min               404287 non-null  float64\n",
      " 16  cwc_max               404287 non-null  float64\n",
      " 17  csc_min               404287 non-null  float64\n",
      " 18  csc_max               404287 non-null  float64\n",
      " 19  ctc_min               404287 non-null  float64\n",
      " 20  ctc_max               404287 non-null  float64\n",
      " 21  last_word_eq          404287 non-null  float64\n",
      " 22  first_word_eq         404287 non-null  float64\n",
      " 23  abs_len_diff          404287 non-null  float64\n",
      " 24  mean_len              404287 non-null  float64\n",
      " 25  token_set_ratio       404287 non-null  int64  \n",
      " 26  token_sort_ratio      404287 non-null  int64  \n",
      " 27  fuzz_ratio            404287 non-null  int64  \n",
      " 28  fuzz_partial_ratio    404287 non-null  int64  \n",
      " 29  longest_substr_ratio  404287 non-null  float64\n",
      "dtypes: float64(14), int64(14), object(2)\n",
      "memory usage: 95.6+ MB\n"
     ]
    }
   ],
   "source": [
    "df_basic_advance_feature.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "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>id</th>\n",
       "      <th>question1</th>\n",
       "      <th>question2</th>\n",
       "      <th>is_duplicate</th>\n",
       "      <th>freq_qid1</th>\n",
       "      <th>freq_qid2</th>\n",
       "      <th>q1len</th>\n",
       "      <th>q2len</th>\n",
       "      <th>q1_n_words</th>\n",
       "      <th>q2_n_words</th>\n",
       "      <th>...</th>\n",
       "      <th>ctc_max</th>\n",
       "      <th>last_word_eq</th>\n",
       "      <th>first_word_eq</th>\n",
       "      <th>abs_len_diff</th>\n",
       "      <th>mean_len</th>\n",
       "      <th>token_set_ratio</th>\n",
       "      <th>token_sort_ratio</th>\n",
       "      <th>fuzz_ratio</th>\n",
       "      <th>fuzz_partial_ratio</th>\n",
       "      <th>longest_substr_ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>What is the step by step guide to invest in sh...</td>\n",
       "      <td>What is the step by step guide to invest in sh...</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>66</td>\n",
       "      <td>57</td>\n",
       "      <td>14</td>\n",
       "      <td>12</td>\n",
       "      <td>...</td>\n",
       "      <td>0.785709</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>100</td>\n",
       "      <td>93</td>\n",
       "      <td>93</td>\n",
       "      <td>100</td>\n",
       "      <td>0.982759</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>What is the story of Kohinoor (Koh-i-Noor) Dia...</td>\n",
       "      <td>What would happen if the Indian government sto...</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>51</td>\n",
       "      <td>88</td>\n",
       "      <td>8</td>\n",
       "      <td>13</td>\n",
       "      <td>...</td>\n",
       "      <td>0.466664</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>12.5</td>\n",
       "      <td>86</td>\n",
       "      <td>63</td>\n",
       "      <td>66</td>\n",
       "      <td>75</td>\n",
       "      <td>0.596154</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 30 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   id                                          question1  \\\n",
       "0   0  What is the step by step guide to invest in sh...   \n",
       "1   1  What is the story of Kohinoor (Koh-i-Noor) Dia...   \n",
       "\n",
       "                                           question2  is_duplicate  freq_qid1  \\\n",
       "0  What is the step by step guide to invest in sh...             0          1   \n",
       "1  What would happen if the Indian government sto...             0          4   \n",
       "\n",
       "   freq_qid2  q1len  q2len  q1_n_words  q2_n_words  ...   ctc_max  \\\n",
       "0          1     66     57          14          12  ...  0.785709   \n",
       "1          1     51     88           8          13  ...  0.466664   \n",
       "\n",
       "   last_word_eq  first_word_eq  abs_len_diff  mean_len  token_set_ratio  \\\n",
       "0           0.0            1.0           2.0      13.0              100   \n",
       "1           0.0            1.0           5.0      12.5               86   \n",
       "\n",
       "   token_sort_ratio  fuzz_ratio  fuzz_partial_ratio  longest_substr_ratio  \n",
       "0                93          93                 100              0.982759  \n",
       "1                63          66                  75              0.596154  \n",
       "\n",
       "[2 rows x 30 columns]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_basic_advance_feature.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "202144"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data= df_basic_advance_feature.sample(frac = 0.5) \n",
    "data.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color: blue\"> Lets separate the target feature & drop unnecessary column</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true = data['is_duplicate']\n",
    "\n",
    "data.drop(['id','is_duplicate'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "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>question1</th>\n",
       "      <th>question2</th>\n",
       "      <th>freq_qid1</th>\n",
       "      <th>freq_qid2</th>\n",
       "      <th>q1len</th>\n",
       "      <th>q2len</th>\n",
       "      <th>q1_n_words</th>\n",
       "      <th>q2_n_words</th>\n",
       "      <th>word_Common</th>\n",
       "      <th>word_Total</th>\n",
       "      <th>...</th>\n",
       "      <th>ctc_max</th>\n",
       "      <th>last_word_eq</th>\n",
       "      <th>first_word_eq</th>\n",
       "      <th>abs_len_diff</th>\n",
       "      <th>mean_len</th>\n",
       "      <th>token_set_ratio</th>\n",
       "      <th>token_sort_ratio</th>\n",
       "      <th>fuzz_ratio</th>\n",
       "      <th>fuzz_partial_ratio</th>\n",
       "      <th>longest_substr_ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>153557</th>\n",
       "      <td>Which Presidential polls historically are the ...</td>\n",
       "      <td>Which current presidential election polls are ...</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>111</td>\n",
       "      <td>85</td>\n",
       "      <td>16</td>\n",
       "      <td>13</td>\n",
       "      <td>8.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.499997</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>77</td>\n",
       "      <td>67</td>\n",
       "      <td>53</td>\n",
       "      <td>60</td>\n",
       "      <td>0.174419</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>342536</th>\n",
       "      <td>Is there a method to decrease penis size?</td>\n",
       "      <td>What is the best way to decrease penis size?</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>41</td>\n",
       "      <td>44</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>5.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.555549</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>8.5</td>\n",
       "      <td>77</td>\n",
       "      <td>72</td>\n",
       "      <td>77</td>\n",
       "      <td>82</td>\n",
       "      <td>0.571429</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 28 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                question1  \\\n",
       "153557  Which Presidential polls historically are the ...   \n",
       "342536          Is there a method to decrease penis size?   \n",
       "\n",
       "                                                question2  freq_qid1  \\\n",
       "153557  Which current presidential election polls are ...          2   \n",
       "342536       What is the best way to decrease penis size?          2   \n",
       "\n",
       "        freq_qid2  q1len  q2len  q1_n_words  q2_n_words  word_Common  \\\n",
       "153557          1    111     85          16          13          8.0   \n",
       "342536          3     41     44           8           9          5.0   \n",
       "\n",
       "        word_Total  ...   ctc_max  last_word_eq  first_word_eq  abs_len_diff  \\\n",
       "153557        28.0  ...  0.499997           0.0            1.0           2.0   \n",
       "342536        17.0  ...  0.555549           1.0            0.0           1.0   \n",
       "\n",
       "        mean_len  token_set_ratio  token_sort_ratio  fuzz_ratio  \\\n",
       "153557      15.0               77                67          53   \n",
       "342536       8.5               77                72          77   \n",
       "\n",
       "        fuzz_partial_ratio  longest_substr_ratio  \n",
       "153557                  60              0.174419  \n",
       "342536                  82              0.571429  \n",
       "\n",
       "[2 rows x 28 columns]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>4.1 Performing TF-IDF Tokenization on columns- 'question1', 'question2'</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "vectorizer= TfidfVectorizer()\n",
    "\n",
    "ques1 = vectorizer.fit_transform(data['question1'].values.astype('U'))\n",
    "ques2 = vectorizer.fit_transform(data['question2'].values.astype('U'))\n",
    "\n",
    "# Combine all the features in question1 and question2\n",
    "ques1_ques2 = hstack((ques1,ques2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(202144, 98247)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Drop unnecessary question1 and question2 columns from \"data\" \n",
    "data.drop(['question1','question2'], axis=1, inplace=True)\n",
    "\n",
    "# add all basic, advance and tfidf features\n",
    "data_tfidf = hstack((data, ques1_ques2),format=\"csr\",dtype='float64')\n",
    "\n",
    "data_tfidf.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 4.2 Random train test split( 60:40) </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,X_test, y_train, y_test = train_test_split(data_tfidf, y_true, stratify=y_true, test_size=0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train data : (121286, 98247)\n",
      "Number of data points in test data : (80858, 98247)\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of data points in train data :\",X_train.shape)\n",
    "print(\"Number of data points in test data :\",X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------- Distribution of output variable in train data ----------\n",
      "Class 0:  0.6301469254489389 Class 1:  0.36985307455106115\n",
      "---------- Distribution of output variable in test data ----------\n",
      "Class 0:  0.369845902693611 Class 1:  0.369845902693611\n"
     ]
    }
   ],
   "source": [
    "print(\"-\"*10, \"Distribution of output variable in train data\", \"-\"*10)\n",
    "train_distr = Counter(y_train)\n",
    "train_len = len(y_train)\n",
    "print(\"Class 0: \",int(train_distr[0])/train_len,\"Class 1: \", int(train_distr[1])/train_len)\n",
    "print(\"-\"*10, \"Distribution of output variable in test data\", \"-\"*10)\n",
    "test_distr = Counter(y_test)\n",
    "test_len = len(y_test)\n",
    "print(\"Class 0: \",int(test_distr[1])/test_len, \"Class 1: \",int(test_distr[1])/test_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> 4.3 Plot the confusion_matrix and call this function when we need </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function plots the confusion matrices given y_i, y_i_hat.\n",
    "def plot_confusion_matrix(test_y, predict_y):\n",
    "    C = confusion_matrix(test_y, predict_y)\n",
    "    \n",
    "    A =(((C.T)/(C.sum(axis=1))).T)\n",
    "    \n",
    "    B =(C/C.sum(axis=0))\n",
    "    \n",
    "    plt.figure(figsize=(20,4))\n",
    "    \n",
    "    labels = [1,2]\n",
    "    # representing A in heatmap format\n",
    "    cmap=sns.light_palette(\"blue\")\n",
    "    plt.subplot(1, 3, 1)\n",
    "    sns.heatmap(C, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Confusion matrix\")\n",
    "    \n",
    "    plt.subplot(1, 3, 2)\n",
    "    sns.heatmap(B, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Precision matrix\")\n",
    "    \n",
    "    plt.subplot(1, 3, 3)\n",
    "    # representing B in heatmap format\n",
    "    sns.heatmap(A, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Recall matrix\")\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 4.4 Building a random model (Finding worst-case log-loss) </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log loss on Test Data using Random Model 0.8856139612202859\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predicted_y = np.zeros((test_len,2))\n",
    "for i in range(test_len):\n",
    "    rand_probs = np.random.rand(1,2)\n",
    "    predicted_y[i] = ((rand_probs/sum(sum(rand_probs)))[0])\n",
    "print(\"Log loss on Test Data using Random Model\",log_loss(y_test, predicted_y, eps=1e-15))\n",
    "\n",
    "predicted_y =np.argmax(predicted_y, axis=1)\n",
    "plot_confusion_matrix(y_test, predicted_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 4.5 Logistic Regression with hyperparameter tuning </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For values of alpha =  1e-05 The log loss is: 0.39328500165096403\n",
      "For values of alpha =  0.0001 The log loss is: 0.3976110696299839\n",
      "For values of alpha =  0.001 The log loss is: 0.41729496086480977\n",
      "For values of alpha =  0.01 The log loss is: 0.44292908898913513\n",
      "For values of alpha =  0.1 The log loss is: 0.4617562420193471\n",
      "For values of alpha =  1 The log loss is: 0.49103590455238916\n",
      "For values of alpha =  10 The log loss is: 0.5421696502214328\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For values of best alpha =  1e-05 The train log loss is: 0.38515121189365814\n",
      "For values of best alpha =  1e-05 The test log loss is: 0.39328500165096403\n",
      "Total number of data points : 80858\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha = [10 ** x for x in range(-5, 2)] # hyperparam for SGD classifier.\n",
    "\n",
    "log_error_array=[]\n",
    "for i in alpha:\n",
    "    clf = SGDClassifier(alpha=i, penalty='l2', loss='log', random_state=42)\n",
    "    clf.fit(X_train, y_train)\n",
    "    sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
    "    sig_clf.fit(X_train, y_train)\n",
    "    predict_y = sig_clf.predict_proba(X_test)\n",
    "    log_error_array.append(log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "    print('For values of alpha = ', i, \"The log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(alpha, log_error_array,c='g')\n",
    "for i, txt in enumerate(np.round(log_error_array,3)):\n",
    "    ax.annotate((alpha[i],np.round(txt,3)), (alpha[i],log_error_array[i]))\n",
    "plt.grid()\n",
    "plt.title(\"Cross Validation Error for each alpha\")\n",
    "plt.xlabel(\"Alpha i's\")\n",
    "plt.ylabel(\"Error measure\")\n",
    "plt.show()\n",
    "\n",
    "\n",
    "best_alpha = np.argmin(log_error_array)\n",
    "clf = SGDClassifier(alpha=alpha[best_alpha], penalty='l2', loss='log', random_state=42)\n",
    "clf.fit(X_train, y_train)\n",
    "sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
    "sig_clf.fit(X_train, y_train)\n",
    "\n",
    "predict_y = sig_clf.predict_proba(X_train)\n",
    "print('For values of best alpha = ', alpha[best_alpha], \"The train log loss is:\",log_loss(y_train, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "predict_y = sig_clf.predict_proba(X_test)\n",
    "print('For values of best alpha = ', alpha[best_alpha], \"The test log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "predicted_y =np.argmax(predict_y,axis=1)\n",
    "print(\"Total number of data points :\", len(predicted_y))\n",
    "plot_confusion_matrix(y_test, predicted_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 4.6 Linear SVM with hyperparameter tuning </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For values of alpha =  1e-05 The log loss is: 0.43265966745657364\n",
      "For values of alpha =  0.0001 The log loss is: 0.4447926111196293\n",
      "For values of alpha =  0.001 The log loss is: 0.47373394439650957\n",
      "For values of alpha =  0.01 The log loss is: 0.5010686668305662\n",
      "For values of alpha =  0.1 The log loss is: 0.4833996303500727\n",
      "For values of alpha =  1 The log loss is: 0.5826624279703996\n",
      "For values of alpha =  10 The log loss is: 0.6469219083535502\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For values of best alpha =  1e-05 The train log loss is: 0.42558907403151536\n",
      "For values of best alpha =  1e-05 The test log loss is: 0.43265966745657364\n",
      "Total number of data points : 80858\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "from warnings import simplefilter\n",
    "from sklearn.exceptions import ConvergenceWarning\n",
    "simplefilter(\"ignore\", category=ConvergenceWarning)\n",
    "    \n",
    "\n",
    "alpha = [10 ** x for x in range(-5, 2)] # hyperparam for SGD classifier.\n",
    "\n",
    "log_error_array=[]\n",
    "for i in alpha:\n",
    "    clf = SGDClassifier(alpha=i, penalty='l1', loss='hinge',max_iter=1000, random_state=42)\n",
    "    clf.fit(X_train, y_train)\n",
    "    sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
    "    sig_clf.fit(X_train, y_train)\n",
    "    predict_y = sig_clf.predict_proba(X_test)\n",
    "    log_error_array.append(log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "    print('For values of alpha = ', i, \"The log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(alpha, log_error_array,c='g')\n",
    "for i, txt in enumerate(np.round(log_error_array,3)):\n",
    "    ax.annotate((alpha[i],np.round(txt,3)), (alpha[i],log_error_array[i]))\n",
    "plt.grid()\n",
    "plt.title(\"Cross Validation Error for each alpha\")\n",
    "plt.xlabel(\"Alpha i's\")\n",
    "plt.ylabel(\"Error measure\")\n",
    "plt.show()\n",
    "\n",
    "\n",
    "best_alpha = np.argmin(log_error_array)\n",
    "clf = SGDClassifier(alpha=alpha[best_alpha], penalty='l1', loss='hinge', random_state=42)\n",
    "clf.fit(X_train, y_train)\n",
    "sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
    "sig_clf.fit(X_train, y_train)\n",
    "\n",
    "predict_y = sig_clf.predict_proba(X_train)\n",
    "print('For values of best alpha = ', alpha[best_alpha], \"The train log loss is:\",log_loss(y_train, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "predict_y = sig_clf.predict_proba(X_test)\n",
    "print('For values of best alpha = ', alpha[best_alpha], \"The test log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "predicted_y =np.argmax(predict_y,axis=1)\n",
    "print(\"Total number of data points :\", len(predicted_y))\n",
    "plot_confusion_matrix(y_test, predicted_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 4.7 Applying XGBoost with hyperparameter tuning using RandomsearchCV </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "## For Hyper Parameter Optimization\n",
    "\n",
    "param_grid = {\n",
    "        'max_depth': [6, 10, 15, 20],\n",
    "        'learning_rate': [0.001, 0.01, 0.1, 0.2, 0.3, 0.5],\n",
    "        'subsample': [0.5, 0.6, 0.7, 0.8, 0.9, 1.0],\n",
    "        'colsample_bytree': [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],\n",
    "        'min_child_weight': [0.5, 1.0, 3.0, 5.0, 7.0, 10.0],\n",
    "        'gamma': [0, 0.25, 0.5, 1.0],\n",
    "        'n_estimators': [50,100,150,200,300,400,500]}\n",
    "\n",
    "def timer(start_time=None):\n",
    "    if not start_time:\n",
    "        start_time = datetime.now()\n",
    "        return start_time\n",
    "    elif start_time:\n",
    "        thour, temp_sec = divmod((datetime.now() - start_time).total_seconds(), 3600)\n",
    "        tmin, tsec = divmod(temp_sec, 60)\n",
    "        print('\\n Time taken: %i hours %i minutes and %s seconds.' % (thour, tmin, round(tsec, 2)))\n",
    "\n",
    "        \n",
    "clf = xgb.XGBClassifier(nthread=-1)\n",
    "\n",
    "kfold = StratifiedKFold(n_splits=5, shuffle=True)\n",
    "random_search=RandomizedSearchCV(clf,param_distributions=param_grid,n_iter=5,scoring='neg_log_loss',n_jobs=-1,cv=kfold,verbose=3,random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 5 candidates, totalling 25 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 12 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  11 out of  25 | elapsed: 25.4min remaining: 32.3min\n",
      "[Parallel(n_jobs=-1)]: Done  20 out of  25 | elapsed: 30.4min remaining:  7.6min\n",
      "[Parallel(n_jobs=-1)]: Done  25 out of  25 | elapsed: 52.1min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Time taken: 0 hours 53 minutes and 36.96 seconds.\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "# Here we go\n",
    "start_time = timer(None) # timing starts from this point for \"start_time\" variable\n",
    "\n",
    "random_search.fit(X_train, y_train)\n",
    "\n",
    "timer(start_time) # timing ends here for \"start_time\" variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Score is: -0.322309 from using these combination of param_grid: {'subsample': 1.0, 'n_estimators': 100, 'min_child_weight': 7.0, 'max_depth': 20, 'learning_rate': 0.3, 'gamma': 1.0, 'colsample_bytree': 0.8}\n",
      "\n",
      "mean : -0.544230, std : (0.001176) with param_grid : {'subsample': 0.7, 'n_estimators': 400, 'min_child_weight': 10.0, 'max_depth': 20, 'learning_rate': 0.001, 'gamma': 0, 'colsample_bytree': 0.9}\n",
      "mean : -0.332417, std : (0.003358) with param_grid : {'subsample': 1.0, 'n_estimators': 400, 'min_child_weight': 7.0, 'max_depth': 15, 'learning_rate': 0.01, 'gamma': 0, 'colsample_bytree': 1.0}\n",
      "mean : -0.325151, std : (0.002826) with param_grid : {'subsample': 0.9, 'n_estimators': 100, 'min_child_weight': 5.0, 'max_depth': 20, 'learning_rate': 0.3, 'gamma': 0.25, 'colsample_bytree': 0.9}\n",
      "mean : -0.517692, std : (0.001353) with param_grid : {'subsample': 0.7, 'n_estimators': 500, 'min_child_weight': 3.0, 'max_depth': 20, 'learning_rate': 0.001, 'gamma': 0.25, 'colsample_bytree': 0.8}\n",
      "mean : -0.322309, std : (0.004740) with param_grid : {'subsample': 1.0, 'n_estimators': 100, 'min_child_weight': 7.0, 'max_depth': 20, 'learning_rate': 0.3, 'gamma': 1.0, 'colsample_bytree': 0.8}\n"
     ]
    }
   ],
   "source": [
    "# Summarize results\n",
    "print(\"Best Score is: %f from using these combination of param_grid: %s\"%(random_search.best_score_,random_search.best_params_))\n",
    "print()\n",
    "means = random_search.cv_results_['mean_test_score']\n",
    "stds = random_search.cv_results_['std_test_score']\n",
    "params = random_search.cv_results_['params']\n",
    "for mean, stdev, param in zip(means, stds, params):\n",
    "    print(\"mean : %f, std : (%f) with param_grid : %r\" % (mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "              colsample_bynode=1, colsample_bytree=0.8, gamma=1.0, gpu_id=-1,\n",
       "              importance_type='gain', interaction_constraints='',\n",
       "              learning_rate=0.3, max_delta_step=0, max_depth=20,\n",
       "              min_child_weight=7.0, missing=nan, monotone_constraints='()',\n",
       "              n_estimators=100, n_jobs=-1, nthread=-1, num_parallel_tree=1,\n",
       "              random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1,\n",
       "              subsample=1.0, tree_method='exact', validate_parameters=1,\n",
       "              verbosity=None)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_search.best_estimator_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subsample': 1.0,\n",
       " 'n_estimators': 100,\n",
       " 'min_child_weight': 7.0,\n",
       " 'max_depth': 20,\n",
       " 'learning_rate': 0.3,\n",
       " 'gamma': 1.0,\n",
       " 'colsample_bytree': 0.8}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_search.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<html>\n",
    "<body><b>\n",
    "<p style=\"color: #0099cc\">SO, After Applying XGBoost with hyperparameter tuning using RandomsearchCV I got the best parameter for best score. Now, I am going to apply this best parameter to XGBClassifier to getting best logg loss score.</p>\n",
    "</b></body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The train log loss is: 0.17265366315508418\n",
      "The test log loss is: 0.31755595356758365\n",
      "Total number of data points : 80858\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf=xgb.XGBClassifier(n_jobs=-1,random_state=42,\n",
    "                      max_depth=20,\n",
    "                      n_estimators=100,\n",
    "                      subsample= 1.0, \n",
    "                      min_child_weight= 7.0,\n",
    "                      learning_rate= 0.3,\n",
    "                      gamma=1.0,\n",
    "                      colsample_bytree= 0.8)\n",
    "clf.fit(X_train,y_train)\n",
    "\n",
    "predict_y = clf.predict_proba(X_train)\n",
    "print(\"The train log loss is:\",log_loss(y_train, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "predict_y = clf.predict_proba(X_test)\n",
    "print(\"The test log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))\n",
    "\n",
    "predicted_y =np.argmax(predict_y,axis=1)\n",
    "print(\"Total number of data points :\", len(predicted_y))\n",
    "plot_confusion_matrix(y_test, predicted_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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": 2
}