Naive Bayes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "import os\n",
    "import string\n",
    "from tqdm import tqdm\n",
    "import re\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as pyplt\n",
    "\n",
    "\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import PorterStemmer\n",
    "import nltk\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn import preprocessing\n",
    "from sklearn.preprocessing import Normalizer\n",
    "\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from collections import Counter\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn import model_selection\n",
    "from sklearn.metrics import f1_score, roc_curve, auc, roc_auc_score\n",
    "\n",
    "from sklearn.naive_bayes import  MultinomialNB\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>ProductId</th>\n",
       "      <th>UserId</th>\n",
       "      <th>ProfileName</th>\n",
       "      <th>HelpfulnessNumerator</th>\n",
       "      <th>HelpfulnessDenominator</th>\n",
       "      <th>Score</th>\n",
       "      <th>Time</th>\n",
       "      <th>Summary</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>B001E4KFG0</td>\n",
       "      <td>A3SGXH7AUHU8GW</td>\n",
       "      <td>delmartian</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1303862400</td>\n",
       "      <td>Good Quality Dog Food</td>\n",
       "      <td>I have bought several of the Vitality canned d...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>B00813GRG4</td>\n",
       "      <td>A1D87F6ZCVE5NK</td>\n",
       "      <td>dll pa</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1346976000</td>\n",
       "      <td>Not as Advertised</td>\n",
       "      <td>Product arrived labeled as Jumbo Salted Peanut...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>B000LQOCH0</td>\n",
       "      <td>ABXLMWJIXXAIN</td>\n",
       "      <td>Natalia Corres \"Natalia Corres\"</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1219017600</td>\n",
       "      <td>\"Delight\" says it all</td>\n",
       "      <td>This is a confection that has been around a fe...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id   ProductId          UserId                      ProfileName  \\\n",
       "0   1  B001E4KFG0  A3SGXH7AUHU8GW                       delmartian   \n",
       "1   2  B00813GRG4  A1D87F6ZCVE5NK                           dll pa   \n",
       "2   3  B000LQOCH0   ABXLMWJIXXAIN  Natalia Corres \"Natalia Corres\"   \n",
       "\n",
       "   HelpfulnessNumerator  HelpfulnessDenominator  Score        Time  \\\n",
       "0                     1                       1      1  1303862400   \n",
       "1                     0                       0      0  1346976000   \n",
       "2                     1                       1      1  1219017600   \n",
       "\n",
       "                 Summary                                               Text  \n",
       "0  Good Quality Dog Food  I have bought several of the Vitality canned d...  \n",
       "1      Not as Advertised  Product arrived labeled as Jumbo Salted Peanut...  \n",
       "2  \"Delight\" says it all  This is a confection that has been around a fe...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using the SQLite Table to read data.\n",
    "con = sqlite3.connect('database.sqlite') \n",
    "\n",
    "#filtering only positive and negative review\n",
    "filtered_data = pd.read_sql_query(\"\"\" SELECT * FROM Reviews WHERE Score != 3 \"\"\", con) \n",
    "\n",
    "#mapping positive and negative review\n",
    "def partition(x):\n",
    "    if x < 3:\n",
    "        return 0\n",
    "    return 1\n",
    "\n",
    "#changing reviews with score less than 3 to be negative and more than 3 to be positive.\n",
    "score = filtered_data['Score']\n",
    "positiveNegative = score.map(partition) \n",
    "filtered_data['Score'] = positiveNegative\n",
    "filtered_data.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>ProductId</th>\n",
       "      <th>UserId</th>\n",
       "      <th>ProfileName</th>\n",
       "      <th>HelpfulnessNumerator</th>\n",
       "      <th>HelpfulnessDenominator</th>\n",
       "      <th>Score</th>\n",
       "      <th>Time</th>\n",
       "      <th>Summary</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>78445</td>\n",
       "      <td>B000HDL1RQ</td>\n",
       "      <td>AR5J8UI46CURR</td>\n",
       "      <td>Geetha Krishnan</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1199577600</td>\n",
       "      <td>LOACKER QUADRATINI VANILLA WAFERS</td>\n",
       "      <td>DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>138317</td>\n",
       "      <td>B000HDOPYC</td>\n",
       "      <td>AR5J8UI46CURR</td>\n",
       "      <td>Geetha Krishnan</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1199577600</td>\n",
       "      <td>LOACKER QUADRATINI VANILLA WAFERS</td>\n",
       "      <td>DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>138277</td>\n",
       "      <td>B000HDOPYM</td>\n",
       "      <td>AR5J8UI46CURR</td>\n",
       "      <td>Geetha Krishnan</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1199577600</td>\n",
       "      <td>LOACKER QUADRATINI VANILLA WAFERS</td>\n",
       "      <td>DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>73791</td>\n",
       "      <td>B000HDOPZG</td>\n",
       "      <td>AR5J8UI46CURR</td>\n",
       "      <td>Geetha Krishnan</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1199577600</td>\n",
       "      <td>LOACKER QUADRATINI VANILLA WAFERS</td>\n",
       "      <td>DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>155049</td>\n",
       "      <td>B000PAQ75C</td>\n",
       "      <td>AR5J8UI46CURR</td>\n",
       "      <td>Geetha Krishnan</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1199577600</td>\n",
       "      <td>LOACKER QUADRATINI VANILLA WAFERS</td>\n",
       "      <td>DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Id   ProductId         UserId      ProfileName  HelpfulnessNumerator  \\\n",
       "0   78445  B000HDL1RQ  AR5J8UI46CURR  Geetha Krishnan                     2   \n",
       "1  138317  B000HDOPYC  AR5J8UI46CURR  Geetha Krishnan                     2   \n",
       "2  138277  B000HDOPYM  AR5J8UI46CURR  Geetha Krishnan                     2   \n",
       "3   73791  B000HDOPZG  AR5J8UI46CURR  Geetha Krishnan                     2   \n",
       "4  155049  B000PAQ75C  AR5J8UI46CURR  Geetha Krishnan                     2   \n",
       "\n",
       "   HelpfulnessDenominator  Score        Time  \\\n",
       "0                       2      5  1199577600   \n",
       "1                       2      5  1199577600   \n",
       "2                       2      5  1199577600   \n",
       "3                       2      5  1199577600   \n",
       "4                       2      5  1199577600   \n",
       "\n",
       "                             Summary  \\\n",
       "0  LOACKER QUADRATINI VANILLA WAFERS   \n",
       "1  LOACKER QUADRATINI VANILLA WAFERS   \n",
       "2  LOACKER QUADRATINI VANILLA WAFERS   \n",
       "3  LOACKER QUADRATINI VANILLA WAFERS   \n",
       "4  LOACKER QUADRATINI VANILLA WAFERS   \n",
       "\n",
       "                                                Text  \n",
       "0  DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...  \n",
       "1  DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...  \n",
       "2  DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...  \n",
       "3  DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...  \n",
       "4  DELICIOUS WAFERS. I FIND THAT EUROPEAN WAFERS ...  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display= pd.read_sql_query(\"\"\"\n",
    "SELECT *\n",
    "FROM Reviews\n",
    "WHERE Score != 3 AND UserId=\"AR5J8UI46CURR\"\n",
    "ORDER BY ProductID\n",
    "\"\"\", con)\n",
    "display.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sorting according to ProductId \n",
    "sorted_data=filtered_data.sort_values('ProductId', axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(364173, 10)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#removing duplicate\n",
    "final_df = sorted_data.drop_duplicates(subset={\"UserId\",\"ProfileName\",\"Time\",\"Text\"}, keep='first', inplace=False)\n",
    "final_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69.25890143662969"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#percentage of data remain after removing duplicate data\n",
    "(final_df['Id'].size*1.0)/(filtered_data['Id'].size*1.0)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data cleaning\n",
    "final_df = final_df[final_df.HelpfulnessNumerator<=final_df.HelpfulnessDenominator]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(364171, 10)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1    307061\n",
       "0     57110\n",
       "Name: Score, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(final_df.shape)\n",
    "#No of reviews left for each class\n",
    "final_df['Score'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /home/dharma/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "stopwords = set(stopwords.words('english')) #set of stopwords\n",
    "sno = nltk.stem.SnowballStemmer('english') #initialising the snowball stemmer\n",
    "\n",
    "def cleanhtml(sentence): #to remove html-tags\n",
    "    cleanr = re.compile('<.*?>')\n",
    "    cleantext = re.sub(cleanr, ' ', sentence)\n",
    "    return cleantext\n",
    "\n",
    "def cleanpunc(sentence): #to clean punctuation or special characters\n",
    "    cleaned = re.sub(r'[?|!|\\'|\"|#]',r'',sentence)\n",
    "    cleaned = re.sub(r'[.|,|)|(|\\|/]',r' ',cleaned)\n",
    "    return  cleaned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pre-processing phase, as it process whole dataset, it will take some time\n",
    "if not os.path.isfile('final.sqlite'):\n",
    "    final_string=[]\n",
    "    positive_words=[] \n",
    "    negative_words=[] \n",
    "    \n",
    "    for i, sent in enumerate(tqdm(final_df['Text'].values)):\n",
    "        filtered_sentence=[]\n",
    "        sent=cleanhtml(sent) # remove HTMl tags\n",
    "        \n",
    "        for w in sent.split():\n",
    "            # we have used cleanpunc(w).split(), one more split function here because consider w=\"abc.def\", cleanpunc(w) will return \"abc def\"\n",
    "            # if we dont use .split() function then we will be considring \"abc def\" as a single word, but if you use .split() function we will get \"abc\", \"def\"\n",
    "            for cleaned_words in cleanpunc(w).split():\n",
    "                if((cleaned_words.isalpha()) & (len(cleaned_words)>2)):    \n",
    "                    if(cleaned_words.lower() not in stopwords):\n",
    "                        s=(sno.stem(cleaned_words.lower())).encode('utf8')\n",
    "                        filtered_sentence.append(s)\n",
    "                        if (final_df['Score'].values)[i] == 1: \n",
    "                            positive_words.append(s) \n",
    "                        if(final_df['Score'].values)[i] == 0:\n",
    "                            negative_words.append(s) \n",
    "        \n",
    "        str1 = b\" \".join(filtered_sentence) #final string of cleaned words\n",
    "        final_string.append(str1)\n",
    "\n",
    "    #storing the data into .sqlite file \n",
    "    final_df['CleanedText'] = final_string #adding a column of CleanedText \n",
    "    final_df['CleanedText'] = final_df['CleanedText'].str.decode(\"utf-8\")\n",
    "    \n",
    "    #store final table into an SQlLite table for future.\n",
    "    conn = sqlite3.connect('final.sqlite')\n",
    "    c=conn.cursor()\n",
    "    conn.text_factory = str\n",
    "    final_df.to_sql('Reviews', conn,  schema=None, if_exists='replace', \\\n",
    "                 index=True, index_label=None, chunksize=None, dtype=None)\n",
    "    conn.close()\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.isfile('final.sqlite'):\n",
    "    conn = sqlite3.connect('final.sqlite')\n",
    "    final_df = pd.read_sql_query(\"\"\" SELECT * FROM Reviews WHERE Score != 3 \"\"\", conn)\n",
    "    conn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(364171, 12)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sorting dataframe based on time\n",
    "final_df = final_df.sort_values('Time', axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')\n",
    "final_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = final_df['CleanedText']\n",
    "Y = final_df['Score']\n",
    "\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.80, random_state=0)\n",
    "X_train, X_cv, Y_train, Y_cv = train_test_split(X_train, Y_train, test_size=.50, random_state=0)\n",
    "#to reduce the percentage of test data, as we have less computing power\n",
    "X_test, X_rest, Y_test, Y_rest = train_test_split(X_test, Y_test, test_size=.90, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#BoW\n",
    "count_vect = CountVectorizer()\n",
    "bow_train = count_vect.fit_transform(X_train)\n",
    "bow_cv = count_vect.transform(X_cv)\n",
    "bow_test = count_vect.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Normalize bow vectorized Data\n",
    "bow_train = preprocessing.normalize(bow_train)\n",
    "bow_cv = preprocessing.normalize(bow_cv)\n",
    "bow_test = preprocessing.normalize(bow_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bigram tfidf vectorizer \n",
    "tf_idf_vect = TfidfVectorizer(ngram_range=(1,2))\n",
    "tfidf_train = tf_idf_vect.fit_transform(X_train)\n",
    "tfidf_cv = tf_idf_vect.transform(X_cv)\n",
    "tfidf_test = tf_idf_vect.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Normalize tfidf vectorized Data\n",
    "tfidf_train = preprocessing.normalize(tfidf_train)\n",
    "tfidf_cv = preprocessing.normalize(tfidf_cv)\n",
    "tfidf_test = preprocessing.normalize(tfidf_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(36417, 617879)\n",
      "(36417,)\n",
      "(36417, 617879)\n",
      "(36417,)\n",
      "(29133, 617879)\n",
      "(29133,)\n"
     ]
    }
   ],
   "source": [
    "print(tfidf_train.shape)\n",
    "print(Y_train.shape)\n",
    "print(tfidf_cv.shape)\n",
    "print(Y_cv.shape)\n",
    "print(tfidf_test.shape)\n",
    "print(Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mulnb(X_train,X_cv,Y_train,Y_cv):\n",
    "    best_alpha=0\n",
    "    max_roc_auc=-1\n",
    "    pred_cv = []\n",
    "    pred_train = []\n",
    "    alpha=[100,50,10,5,1,0.5,0.1,0.05,0.01,0.005,0.001] \n",
    "    for i in tqdm(alpha[-11:]):\n",
    "        mulbnb = MultinomialNB(alpha=i)\n",
    "        mulbnb.fit(X_train,Y_train)\n",
    "        \n",
    "        probs = mulbnb.predict_proba(X_cv)\n",
    "        prob = mulbnb.predict_proba(X_train)\n",
    "        \n",
    "        probs = probs[:,1]\n",
    "        prob = prob[:,1]\n",
    "        \n",
    "        auc_score_cv = roc_auc_score(Y_cv,probs)\n",
    "        auc_score_train = roc_auc_score(Y_train,prob)\n",
    "        \n",
    "        pred_cv.append(auc_score_cv)\n",
    "        pred_train.append(auc_score_train)\n",
    "        \n",
    "        if(max_roc_auc<auc_score_cv):\n",
    "            max_roc_auc=auc_score_cv\n",
    "            best_alpha=i\n",
    "            \n",
    "    sns.set_style(\"darkgrid\")\n",
    "    plt.xscale('log')\n",
    "    plt.plot(alpha, pred_cv,'r-', label = 'CV Data')\n",
    "    plt.plot(alpha,pred_train,'g-', label ='Train Data')\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.title(r'Auc Score v/s $\\alpha$')\n",
    "    plt.xlabel(r\"alpha values\",fontsize=12)\n",
    "    plt.ylabel(\"roc_auc\",fontsize=12)\n",
    "    plt.show()\n",
    "    \n",
    "    # calculate roc curve\n",
    "    fpr, tpr, thresholds = roc_curve(Y_cv,probs)\n",
    "    # plot no skill\n",
    "    pyplt.plot([0, 1], [0, 1], linestyle='--')\n",
    "    # plot the roc curve for the model\n",
    "    pyplt.plot(fpr, tpr, marker='.')\n",
    "    #plt.plot(k,pred_cv)\n",
    "    pyplt.title(\"Line Plot of ROC Curve on Train Data\")\n",
    "    pyplt.ylabel('True Positive Rate')\n",
    "    pyplt.xlabel('False Positive Rate')\n",
    "    pyplt.show()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testing(X_train,Y_train,X_test,Y_test,optimal_alpha):\n",
    "    bnb = MultinomialNB(optimal_alpha,fit_prior=True, class_prior=None)\n",
    "    bnb.fit(X_train,Y_train)\n",
    "    \n",
    "    probs = bnb.predict_proba(X_test) \n",
    "    # keep probabilities for the positive outcome only\n",
    "    probs = probs[:, 1]\n",
    "    # calculate roc curve\n",
    "    fpr, tpr, thresholds = roc_curve(Y_test,probs)\n",
    "    # plot no skill\n",
    "    plt.plot([0, 1], [0, 1], linestyle='--')\n",
    "    # plot the roc curve for the model\n",
    "    plt.plot(fpr, tpr, marker='.')\n",
    "    plt.title(\"Line Plot of ROC Curve on Test Data\")\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.xlabel('False Positive Rate')    \n",
    "    plt.show\n",
    "    \n",
    "    prediction=bnb.predict(X_test) \n",
    "    print(\"AUC Score\",roc_auc_score(Y_test,probs))\n",
    "    print(\"macro f1 score:\",metrics.f1_score(Y_test, prediction, average = 'macro'))\n",
    "    print(\"micro f1 scoore:\",metrics.f1_score(Y_test, prediction, average = 'micro'))\n",
    "    print(\"Precision recall report:\\n\",metrics.classification_report(Y_test, prediction))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 11/11 [00:02<00:00,  4.57it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# find optimal alpha \n",
    "mulnb(tfidf_train, tfidf_cv, Y_train, Y_cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC Score 0.9158440369184426\n",
      "macro f1 score: 0.5271846860952226\n",
      "micro f1 scoore: 0.8533278412796486\n",
      "Precision recall report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.07      0.13      4594\n",
      "           1       0.85      1.00      0.92     24539\n",
      "\n",
      "    accuracy                           0.85     29133\n",
      "   macro avg       0.91      0.54      0.53     29133\n",
      "weighted avg       0.87      0.85      0.80     29133\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#algorithm = brute force, optimal_k=11\n",
    "testing(tfidf_train, Y_train, tfidf_test, Y_test, optimal_alpha=0.1)"
   ]
  }
 ],
 "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": 4
}