Naive Bayes with BOW, TFIDF, Word2Vec, TFIDF weighted Word2Vec Twitter US Airline Sentiment Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes with BOW, TFIDF, Word2Vec, TFIDF weighted Word2Vec for Twitter US Airline Sentiment Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use(\"dark_background\")\n",
    "sns.set_palette(\"dark\")\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from gensim.models import Word2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "from sklearn.metrics import roc_auc_score,accuracy_score,recall_score\n",
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.model_selection import StratifiedKFold\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "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>tweet_id</th>\n",
       "      <th>airline_sentiment</th>\n",
       "      <th>negativereason</th>\n",
       "      <th>airline</th>\n",
       "      <th>text_clean</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>570306133677760513</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Virgin America</td>\n",
       "      <td>dhepburn said</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>570301130888122368</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Virgin America</td>\n",
       "      <td>plus added commercials experience tacky</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>570301083672813571</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Virgin America</td>\n",
       "      <td>not today must mean need take another trip</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>570301031407624196</td>\n",
       "      <td>1</td>\n",
       "      <td>Bad Flight</td>\n",
       "      <td>Virgin America</td>\n",
       "      <td>really aggressive blast obnoxious entertainmen...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>570300817074462722</td>\n",
       "      <td>1</td>\n",
       "      <td>Can't Tell</td>\n",
       "      <td>Virgin America</td>\n",
       "      <td>really big bad thing</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             tweet_id  airline_sentiment negativereason         airline  \\\n",
       "0  570306133677760513                  0            NaN  Virgin America   \n",
       "1  570301130888122368                  0            NaN  Virgin America   \n",
       "2  570301083672813571                  0            NaN  Virgin America   \n",
       "3  570301031407624196                  1     Bad Flight  Virgin America   \n",
       "4  570300817074462722                  1     Can't Tell  Virgin America   \n",
       "\n",
       "                                          text_clean  \n",
       "0                                      dhepburn said  \n",
       "1            plus added commercials experience tacky  \n",
       "2         not today must mean need take another trip  \n",
       "3  really aggressive blast obnoxious entertainmen...  \n",
       "4                               really big bad thing  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twDF = pd.read_csv(\"Dataset/tweets_preprocessed.csv\").drop(['Unnamed: 0'],axis=1)\n",
    "twDF.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(14519, 5)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twDF.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    9113\n",
       "0    5406\n",
       "Name: airline_sentiment, dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twDF[\"airline_sentiment\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is an imbalanced dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twDF.loc[twDF['text_clean'].isnull()].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Removing records with Null values\n",
    "twDF=twDF.loc[twDF['text_clean'].notnull()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(14519, 5)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twDF.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# twDF.to_csv(\"Dataset/tweets_preprocessed.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = twDF['airline_sentiment'].values\n",
    "X = twDF[['text_clean']]\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, stratify=y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Naive Bayes with Bag of words "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10163, 1) (10163,)\n",
      "(4356, 1) (4356,)\n",
      "====================================================================================================\n",
      "After vectorizations\n",
      "(10163, 16254) (10163,)\n",
      "(4356, 16254) (4356,)\n",
      "====================================================================================================\n"
     ]
    }
   ],
   "source": [
    "# Getting BOW \n",
    "print(X_train.shape, y_train.shape)\n",
    "print(X_test.shape, y_test.shape)\n",
    "print(\"=\"*100)\n",
    "\n",
    "vectorizer = CountVectorizer(min_df=2,ngram_range=(1,4))\n",
    "vectorizer.fit(X_train['text_clean'])\n",
    "X_train_bow = vectorizer.transform(X_train['text_clean'].values)\n",
    "X_test_bow = vectorizer.transform(X_test['text_clean'].values)\n",
    "\n",
    "print(\"After vectorizations\")\n",
    "print(X_train_bow.shape, y_train.shape)\n",
    "print(X_test_bow.shape, y_test.shape)\n",
    "print(\"=\"*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10163, 16254)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_bow.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_bow=X_train_bow.toarray()\n",
    "X_test_bow=X_test_bow.toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[1223  399]\n",
      " [ 676 2058]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.64      0.75      0.69      1622\n",
      "           1       0.84      0.75      0.79      2734\n",
      "\n",
      "    accuracy                           0.75      4356\n",
      "   macro avg       0.74      0.75      0.74      4356\n",
      "weighted avg       0.77      0.75      0.76      4356\n",
      "\n",
      "AUC score for NB is  0.7533753158157269\n",
      "Train Recall score for NB is  0.8998275591785546\n",
      "Test Recall score for NB is  0.7527432333577176\n"
     ]
    }
   ],
   "source": [
    "gnb = GaussianNB()\n",
    "gnb.fit(X_train_bow, y_train)\n",
    "pred = gnb.predict(X_test_bow)\n",
    "accNB = accuracy_score(y_test, pred)\n",
    "y_pred_prob = gnb.predict_proba(X_test_bow)\n",
    "aucScoreBOW = roc_auc_score(y_test,  y_pred_prob[:,1])\n",
    "fprBOW, tprBOW, thresholds = roc_curve(y_test, y_pred_prob[:,1] )\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(y_test,pred))\n",
    "print(classification_report(y_test,pred))\n",
    "print(\"AUC score for NB is \",aucScoreBOW)\n",
    "predT=gnb.predict(X_train_bow)\n",
    "print(\"Train Recall score for NB is \",recall_score(y_train, predT))\n",
    "print(\"Test Recall score for NB is \",recall_score(y_test, pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations:**\n",
    "\n",
    "1.The test score of 0.7527 is fairly good\n",
    "\n",
    "2.But the model is quite overfitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Naive Bayes with TFIDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10163, 1) (10163,)\n",
      "(4356, 1) (4356,)\n",
      "====================================================================================================\n",
      "After vectorizations\n",
      "(10163, 16254) (10163,)\n",
      "(4356, 16254) (4356,)\n",
      "====================================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape, y_train.shape)\n",
    "print(X_test.shape, y_test.shape)\n",
    "print(\"=\"*100)\n",
    "vectorizer = TfidfVectorizer(min_df=2,ngram_range=(1,4))\n",
    "vectorizer.fit(X_train['text_clean'])\n",
    "X_train_tfidf = vectorizer.transform(X_train['text_clean'].values)\n",
    "X_test_tfidf = vectorizer.transform(X_test['text_clean'].values)\n",
    "print(\"After vectorizations\")\n",
    "print(X_train_tfidf.shape, y_train.shape)\n",
    "print(X_test_tfidf.shape, y_test.shape)\n",
    "print(\"=\"*100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_tfidf=X_train_tfidf.toarray()\n",
    "X_test_tfidf=X_test_tfidf.toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[1203  419]\n",
      " [ 668 2066]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.64      0.74      0.69      1622\n",
      "           1       0.83      0.76      0.79      2734\n",
      "\n",
      "    accuracy                           0.75      4356\n",
      "   macro avg       0.74      0.75      0.74      4356\n",
      "weighted avg       0.76      0.75      0.75      4356\n",
      "\n",
      "AUC score for NB is  0.7486731454930694\n",
      "Train Recall score for NB is  0.8998275591785546\n",
      "Test Recall score for NB is  0.7556693489392831\n"
     ]
    }
   ],
   "source": [
    "\n",
    "gnb = GaussianNB()\n",
    "gnb.fit(X_train_tfidf, y_train)\n",
    "pred = gnb.predict(X_test_tfidf)\n",
    "accNB = accuracy_score(y_test, pred)\n",
    "y_pred_prob = gnb.predict_proba(X_test_tfidf)\n",
    "aucScoreTFIDF = roc_auc_score(y_test,  y_pred_prob[:,1])\n",
    "fprTFIDF, tprTFIDF, thresholds = roc_curve(y_test, y_pred_prob[:,1] )\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(y_test,pred))\n",
    "print(classification_report(y_test,pred))\n",
    "print(\"AUC score for NB is \",aucScoreTFIDF)\n",
    "#print(\"Test Accuracy score for NB is \",accuracy_score(y_test, pred))\n",
    "predT=gnb.predict(X_train_tfidf)\n",
    "#print(\"Train Accuracy score for NB is \",accuracy_score(y_train, predT))\n",
    "#print(\"Best parameters for NB are \",gnb.best_params_)\n",
    "print(\"Train Recall score for NB is \",recall_score(y_train, predT))\n",
    "print(\"Test Recall score for NB is \",recall_score(y_test, pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations:**\n",
    "\n",
    "1.The test score of 0.7557 is fairly good\n",
    "\n",
    "2.It is very close to result of BOW\n",
    "\n",
    "3.This model is also quite overfitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Area Under the Curve (AUC) is the measure of the ability of a classifier to distinguish between classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modeling with Word2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "list_of_sentance=[]\n",
    "for sentance in twDF['text_clean']:\n",
    "    list_of_sentance.append(sentance.split())\n",
    "\n",
    "\n",
    "w2v_model=Word2Vec(list_of_sentance,min_count=1,size=300, workers=4)\n",
    "w2v_words = list(w2v_model.wv.vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['dhepburn', 'said'],\n",
       " ['plus', 'added', 'commercials', 'experience', 'tacky'],\n",
       " ['not', 'today', 'must', 'mean', 'need', 'take', 'another', 'trip']]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_sentance[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████| 14519/14519 [00:09<00:00, 1571.00it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14519\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm \n",
    "# average Word2Vec\n",
    "# compute average word2vec for each tweet.\n",
    "sent_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
    "for sent in tqdm(list_of_sentance): # for each tweet/sentence\n",
    "    sent_vec = np.zeros(300)\n",
    "    cnt_words =0; # num of words with a valid vector in the sentence/tweet\n",
    "    for word in sent: # for each word in a tweet/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            sent_vec += vec\n",
    "            cnt_words += 1\n",
    "    if cnt_words != 0:\n",
    "        sent_vec /= cnt_words\n",
    "    sent_vectors.append(sent_vec)\n",
    "print(len(sent_vectors))\n",
    "print(len(sent_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x shape= (14519, 300)   y shape= (14519,)\n"
     ]
    }
   ],
   "source": [
    "X=np.array(sent_vectors)\n",
    "y = twDF['airline_sentiment'].values\n",
    "print(\"x shape=\",X.shape,\"  y shape=\",y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train test split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, stratify=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[ 693  929]\n",
      " [ 530 2204]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.57      0.43      0.49      1622\n",
      "           1       0.70      0.81      0.75      2734\n",
      "\n",
      "    accuracy                           0.67      4356\n",
      "   macro avg       0.64      0.62      0.62      4356\n",
      "weighted avg       0.65      0.67      0.65      4356\n",
      "\n",
      "AUC score for NB is  0.6471190524941888\n",
      "Train Recall score for NB is  0.7976171813763913\n",
      "Test Recall score for NB is  0.8061448427212875\n"
     ]
    }
   ],
   "source": [
    "gnb = GaussianNB()\n",
    "gnb.fit(X_train, y_train)\n",
    "pred = gnb.predict(X_test)\n",
    "accNB = accuracy_score(y_test, pred)\n",
    "y_pred_prob = gnb.predict_proba(X_test)\n",
    "aucScoreWORD2VEC = roc_auc_score(y_test,  y_pred_prob[:,1])\n",
    "fprWORD2VEC, tprWORD2VEC, thresholds = roc_curve(y_test, y_pred_prob[:,1] )\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(y_test,pred))\n",
    "print(classification_report(y_test,pred))\n",
    "print(\"AUC score for NB is \",aucScoreWORD2VEC)\n",
    "predT=gnb.predict(X_train)\n",
    "print(\"Train Recall score for NB is \",recall_score(y_train, predT))\n",
    "print(\"Test Recall score for NB is \",recall_score(y_test, pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations:**\n",
    "\n",
    "1.The test score of 0.8061 is better than BOW and TFIDF\n",
    "\n",
    "2.But the model is not overfitting\n",
    "\n",
    "3.But the AUC is not as good"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling using TFIDF weighted word2vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_model = TfidfVectorizer()\n",
    "tfidf_model.fit(twDF['text_clean'].values)\n",
    "dictionary = dict(zip(tfidf_model.get_feature_names(), list(tfidf_model.idf_)))\n",
    "tfidf_words = set(tfidf_model.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████| 14519/14519 [00:12<00:00, 1180.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14519\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "# average Word2Vec\n",
    "from tqdm import tqdm \n",
    "\n",
    "# compute average word2vec for each tweet.\n",
    "tfidf_w2v_vectors = []; # the avg-w2v for each sentence/tweet is stored in this list\n",
    "for sentence in tqdm(twDF['text_clean'].values): # for each tweet/sentence\n",
    "    vector = np.zeros(300) # as word vectors are of zero length\n",
    "    tf_idf_weight =0; # num of words with a valid vector in the sentence/tweet\n",
    "    for word in sentence.split(): # for each word in a tweet/sentence\n",
    "        if (word in w2v_words) and (word in tfidf_words):\n",
    "            vec = w2v_model[word] # getting the vector for each word\n",
    "            tf_idf = dictionary[word]*(sentence.count(word)/len(sentence.split())) # getting the tfidf value for each word\n",
    "            vector += (vec * tf_idf) # calculating tfidf weighted w2v\n",
    "            tf_idf_weight += tf_idf\n",
    "    if tf_idf_weight != 0:\n",
    "        vector /= tf_idf_weight\n",
    "    tfidf_w2v_vectors.append(vector)\n",
    "\n",
    "print(len(tfidf_w2v_vectors))\n",
    "print(len(tfidf_w2v_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x shape= (14519, 300)   y shape= (14519,)\n"
     ]
    }
   ],
   "source": [
    "X=np.array(tfidf_w2v_vectors)\n",
    "y = twDF['airline_sentiment'].values\n",
    "print(\"x shape=\",X.shape,\"  y shape=\",y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train test split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, stratify=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[ 709  913]\n",
      " [ 598 2136]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.54      0.44      0.48      1622\n",
      "           1       0.70      0.78      0.74      2734\n",
      "\n",
      "    accuracy                           0.65      4356\n",
      "   macro avg       0.62      0.61      0.61      4356\n",
      "weighted avg       0.64      0.65      0.64      4356\n",
      "\n",
      "AUC score for NB is  0.6328320270746872\n",
      "Train Recall score for NB is  0.778805455400533\n",
      "Test Recall score for NB is  0.7812728602779809\n"
     ]
    }
   ],
   "source": [
    "gnb = GaussianNB()\n",
    "gnb.fit(X_train, y_train)\n",
    "pred = gnb.predict(X_test)\n",
    "accNB = accuracy_score(y_test, pred)\n",
    "y_pred_prob = gnb.predict_proba(X_test)\n",
    "aucScoreTFIDFWORD2VEC = roc_auc_score(y_test,  y_pred_prob[:,1])\n",
    "fprTFIDFWORD2VEC, tprTFIDFWORD2VEC, thresholds = roc_curve(y_test, y_pred_prob[:,1] )\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(y_test,pred))\n",
    "print(classification_report(y_test,pred))\n",
    "print(\"AUC score for NB is \",aucScoreTFIDFWORD2VEC)\n",
    "predT=gnb.predict(X_train)\n",
    "print(\"Train Recall score for NB is \",recall_score(y_train, predT))\n",
    "print(\"Test Recall score for NB is \",recall_score(y_test, pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations:**\n",
    "\n",
    "1.The test score of 0.78 is quite good\n",
    "\n",
    "2.It is very close to result of Word2vec\n",
    "\n",
    "3.This model is also not overfitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_table = pd.DataFrame(columns=['classifiers', 'fpr','tpr','auc'])\n",
    "\n",
    "result_table=result_table.append({'classifiers':\"Naive Bayer with BOW\",'fpr':fprBOW,'tpr':tprBOW,'auc':aucScoreBOW}, ignore_index=True)\n",
    "result_table=result_table.append({'classifiers':\"Naive Bayer with TFIDF\",'fpr':fprTFIDF,'tpr':tprTFIDF,'auc':aucScoreTFIDF}, ignore_index=True)\n",
    "result_table=result_table.append({'classifiers':\"Naive Bayer with W2V\",'fpr':fprWORD2VEC,'tpr':tprWORD2VEC,'auc':aucScoreWORD2VEC}, ignore_index=True)\n",
    "result_table=result_table.append({'classifiers':\"Naive Bayer with TFIDF weighted W2V\",'fpr':fprTFIDFWORD2VEC,'tpr':tprTFIDFWORD2VEC,'auc':aucScoreTFIDFWORD2VEC}, ignore_index=True)\n",
    "\n",
    "result_table.set_index('classifiers', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# https://abdalimran.github.io/2019-06-01/Drawing-multiple-ROC-Curves-in-a-single-plot\n",
    "sns.set()\n",
    "for i in result_table.index:\n",
    "    plt.plot(result_table.loc[i]['fpr'], \n",
    "             result_table.loc[i]['tpr'], \n",
    "             label=\"{}, AUC={:.2f}\".format(i, result_table.loc[i]['auc']))\n",
    "\n",
    "#fig = plt.figure(figsize=(8,6))\n",
    "ax = plt.gca()\n",
    "ax.set_facecolor('xkcd:black')\n",
    "ax.grid(False)\n",
    "\n",
    "plt.style.use(\"dark_background\")\n",
    "plt.plot([0,1], [0,1], color='orange')\n",
    "plt.xlabel(\"Flase Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "plt.title('ROC Curve Analysis')\n",
    "plt.legend(bbox_to_anchor=(2.1, 1), loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Best so far"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations:**\n",
    "\n",
    "1.Recall score ---> BOW:0.75274, TFIDF:0.7556, Word2Vec:0.8061 , TFIDF weighted Word2Vec:0.78127.\n",
    "\n",
    "2.BOW and TFIDF models are overfitting a little\n",
    "\n",
    "3.The Naive Bayes model with word2vec has given the best recall of 0.8061 so far.\n",
    "\n",
    "4.Next We will try Multilayer perceptron(MLP) and compare results."
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}