Email_Spam.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Email Spam Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import string \n",
    "%matplotlib inline\n",
    "import collections\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn import feature_extraction\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from nltk.corpus import stopwords\n",
    "import nltk\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.git',\n",
       " '.gitignore',\n",
       " '.ipynb_checkpoints',\n",
       " 'DecisionTreeClassifier.sav',\n",
       " 'Email_Spam-checkpoint.ipynb',\n",
       " 'Email_Spam.ipynb',\n",
       " 'ENSampleMethodClassifier.sav',\n",
       " 'flask_api',\n",
       " 'LogisticRegressionClassifier.sav',\n",
       " 'ML-Pipeline',\n",
       " 'ML-Pipeline.ipynb',\n",
       " 'NaieveBayesClassifier.sav',\n",
       " 'README.md',\n",
       " 'Spam.csv',\n",
       " 'SVMclassifier.sav']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir('/Users/KBrig/ML-Pipeline')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part1: Data Reading and Exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "path='/Users/KBrig/ML-Pipeline/spam.csv'\n",
    "#EmData= pd.read_csv('Spam.csv',encoding='cp1252')\n",
    "EmData= pd.read_csv(path,encoding='cp1252',dtype={'type':np.str, 'Email_body':np.str})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>type</th>\n",
       "      <th>Email_body</th>\n",
       "      <th>Unnamed: 2</th>\n",
       "      <th>Unnamed: 3</th>\n",
       "      <th>Unnamed: 4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ham</td>\n",
       "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ham</td>\n",
       "      <td>Ok lar... Joking wif u oni...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>spam</td>\n",
       "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ham</td>\n",
       "      <td>U dun say so early hor... U c already then say...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ham</td>\n",
       "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   type                                         Email_body Unnamed: 2  \\\n",
       "0   ham  Go until jurong point, crazy.. Available only ...        NaN   \n",
       "1   ham                      Ok lar... Joking wif u oni...        NaN   \n",
       "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...        NaN   \n",
       "3   ham  U dun say so early hor... U c already then say...        NaN   \n",
       "4   ham  Nah I don't think he goes to usf, he lives aro...        NaN   \n",
       "\n",
       "  Unnamed: 3 Unnamed: 4  \n",
       "0        NaN        NaN  \n",
       "1        NaN        NaN  \n",
       "2        NaN        NaN  \n",
       "3        NaN        NaN  \n",
       "4        NaN        NaN  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EmData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "EmData=EmData[['type','Email_body']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "column type : <class 'str'>\n",
      "column Email_body : <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#print(EmData.shape)\n",
    "for col in EmData.columns:\n",
    "    print ('column', col,':', type(col[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 5572 entries, 0 to 5571\n",
      "Data columns (total 2 columns):\n",
      "type          5572 non-null object\n",
      "Email_body    5572 non-null object\n",
      "dtypes: object(2)\n",
      "memory usage: 87.1+ KB\n"
     ]
    }
   ],
   "source": [
    "EmData.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"4\" halign=\"left\">Email_body</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "      <th>unique</th>\n",
       "      <th>top</th>\n",
       "      <th>freq</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>type</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ham</th>\n",
       "      <td>4825</td>\n",
       "      <td>4516</td>\n",
       "      <td>Sorry, I'll call later</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spam</th>\n",
       "      <td>747</td>\n",
       "      <td>653</td>\n",
       "      <td>Please call our customer service representativ...</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Email_body                                                               \n",
       "          count unique                                                top freq\n",
       "type                                                                          \n",
       "ham        4825   4516                             Sorry, I'll call later   30\n",
       "spam        747    653  Please call our customer service representativ...    4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EmData.groupby('type').describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x16d463e4da0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.countplot(x='type',data=EmData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EmData['y']=EmData['type'].apply(lambda x: x =='spam').astype(int)\n",
    "EmData['type_num']= EmData.type.map({'ham':0, 'spam':1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>type</th>\n",
       "      <th>Email_body</th>\n",
       "      <th>type_num</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ham</td>\n",
       "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ham</td>\n",
       "      <td>Ok lar... Joking wif u oni...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>spam</td>\n",
       "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ham</td>\n",
       "      <td>U dun say so early hor... U c already then say...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ham</td>\n",
       "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   type                                         Email_body  type_num\n",
       "0   ham  Go until jurong point, crazy.. Available only ...         0\n",
       "1   ham                      Ok lar... Joking wif u oni...         0\n",
       "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...         1\n",
       "3   ham  U dun say so early hor... U c already then say...         0\n",
       "4   ham  Nah I don't think he goes to usf, he lives aro...         0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EmData.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "EmData['lngth']= EmData['Email_body'].apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x16d464cba20>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.boxenplot(x='type',y='lngth', data=EmData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "# Part2: Data Splitting\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5572,)\n",
      "(5572,)\n"
     ]
    }
   ],
   "source": [
    "X = EmData.Email_body\n",
    "y= EmData.type_num\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cross_validation import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3, random_state=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3900,)\n",
      "(1672,)\n",
      "(3900,)\n",
      "(1672,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# Part3: Feature Engineering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Extraction with default values of \"CountVectorizer\" and \"English\" stop words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "def pip(classifier):\n",
    "    #SW = set(stopwords.words('english'))\n",
    "    pipeline = Pipeline([\n",
    "        ('vect', CountVectorizer()),  # strings to token integer counts\n",
    "        ('tfidf', TfidfTransformer()),  # integer counts to weighted TF-IDF scores\n",
    "        ('clf', classifier),\n",
    "    ])\n",
    "    return(pipeline)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "#tfidf = TfidfVectorizer(min_df=2, max_df=0.5, ngram_range=(2, 3))\n",
    "#features = tfidf.fit_transform(X_train)\n",
    "#pd.DataFrame(\n",
    " #   features.todense(),\n",
    "  #  columns=tfidf.get_feature_names())\n",
    "#tfidf.get_feature_names()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# Part4: Model Building"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Naieve Bayes Classifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB\n",
    "pip_NB= pip(MultinomialNB(fit_prior=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip...near_tf=False, use_idf=True)), ('clf', MultinomialNB(alpha=1.0, class_prior=None, fit_prior=False))])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pip_NB.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving NB model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the model to disk\n",
    "filename = 'NaieveBayesClassifier.sav'\n",
    "pickle.dump(pip_NB, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Testing NB Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_NB = pip_NB.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Performance Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.99      0.98      0.99      1471\n",
      "          1       0.87      0.94      0.90       201\n",
      "\n",
      "avg / total       0.98      0.98      0.98      1672\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(predictions_NB,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9293596910768144"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NB_roc_auc_score=roc_auc_score(y_test,predictions_NB)\n",
    "NB_roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "pip_LR= pip(LogisticRegression(random_state=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Training "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip...nalty='l2', random_state=0, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False))])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pip_LR.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving LR model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'LogisticRegressionClassifier.sav'\n",
    "pickle.dump(pip_LR, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing LR Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_LR = pip_LR.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Performance Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       1.00      0.97      0.98      1497\n",
      "          1       0.79      0.99      0.88       175\n",
      "\n",
      "avg / total       0.98      0.97      0.97      1672\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(predictions_LR,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8961012329164721"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#ROC score\n",
    "LR_roc_auc_score=roc_auc_score(y_test,predictions_LR)\n",
    "LR_roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# SVM Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import SGDClassifier\n",
    "pip_SVM= pip(SGDClassifier(random_state=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip...lty='l2', power_t=0.5, random_state=0, shuffle=True,\n",
       "       tol=None, verbose=0, warm_start=False))])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pip_SVM.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'SVMclassifier.sav'\n",
    "pickle.dump(pip_SVM, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_SVM = pip_SVM.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       1.00      0.99      0.99      1470\n",
      "          1       0.91      0.99      0.95       202\n",
      "\n",
      "avg / total       0.99      0.99      0.99      1672\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(predictions_SVM,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9553903814847999"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SVM_roc_auc_score=roc_auc_score(y_test,predictions_SVM)\n",
    "SVM_roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# Decision Trees Classifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import tree\n",
    "pip_DT=pip(tree.DecisionTreeClassifier())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip...      min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best'))])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pip_DT.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'DecisionTreeClassifier.sav'\n",
    "pickle.dump(pip_DT, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_DT = pip_DT.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.98      0.98      0.98      1452\n",
      "          1       0.86      0.85      0.85       220\n",
      "\n",
      "avg / total       0.96      0.96      0.96      1672\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(predictions_DT,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.917551077066744"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DT_roc_auc_score=roc_auc_score(y_test,predictions_DT)\n",
    "DT_roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Ensamble Methods Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "pip_EM = pip(RandomForestClassifier(n_estimators=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "        strip...n_jobs=1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False))])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pip_EM.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'ENSampleMethodClassifier.sav'\n",
    "pickle.dump(pip_EM, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_EM = pip_EM.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       1.00      0.97      0.98      1503\n",
      "          1       0.77      0.99      0.87       169\n",
      "\n",
      "avg / total       0.98      0.97      0.97      1672\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(predictions_EM,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8849772219628232"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "EM_roc_auc_score=roc_auc_score(y_test,predictions_EM)\n",
    "EM_roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Comparing the accuracy of different ML models "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.9293596910768144,\n",
       " 0.8961012329164721,\n",
       " 0.9553903814847999,\n",
       " 0.917551077066744,\n",
       " 0.8849772219628232]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy=[NB_roc_auc_score,LR_roc_auc_score,SVM_roc_auc_score,DT_roc_auc_score,EM_roc_auc_score]\n",
    "accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['NB', 'LR', 'SVM', 'DT', 'EM']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "models= [\"NB\", \"LR\", \"SVM\", \"DT\", \"EM\"]\n",
    "models\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'model': models,'accuracy': accuracy}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "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>model</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NB</td>\n",
       "      <td>0.929360</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LR</td>\n",
       "      <td>0.896101</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>SVM</td>\n",
       "      <td>0.955390</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DT</td>\n",
       "      <td>0.917551</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>EM</td>\n",
       "      <td>0.884977</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  model  accuracy\n",
       "0    NB  0.929360\n",
       "1    LR  0.896101\n",
       "2   SVM  0.955390\n",
       "3    DT  0.917551\n",
       "4    EM  0.884977"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Performane = pd.DataFrame(data=d)\n",
    "Performane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Comparing the Accuracy of Different ML Models')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xu8FXW9//HXGxA1IS+wtRQETX4mlUdzp6csoKwET96gk3gp6eapDl0sKywfR8I81MnSfqmV9cPCSqSy4ljHSySSJy0XcSk0FBVli9b2mppmyOf3x3yXDIu116wNe/babN7Px2M99sx8vzPzWbNnzWfm+501SxGBmZlZIwNaHYCZmfV9ThZmZlbIycLMzAo5WZiZWSEnCzMzK+RkYWZmhZwsthOSTpV0fS+ta7SkkDSoN9a3vZB0oqS1kp6SdOgWLuN/JJ2eG/+8pIclPdRT6zCQNE3SzU3W/Y6kz5cd09ZysugmSadIqqQP04Ppw/f6VsdVJCK+HxFvLWPZktZIenMZy86tYz9JGyRdWuZ6+rgLgOkRMSQiltYWpgT9dNo3H5G0UNJJ+ToRMSkivpvqjwQ+AYyNiJc0s44ySZop6XsFddZIek7S8Jrpy9L7H53GmzoA505sfl8zfXhaz5puv5F+ysmiGyR9HLgI+E9gL2Bf4FLg+FbGVaSfnOG/C3gMmCppx95ccR/afqOAlQV1/ikihgAHAt8BLpZ0boPlPRIRf+nmOurqxe10L3Bybr2vAnbeymXuIumVufFT0nqsKiL8auIF7Ao8Bfxrgzo7kiWTdel1EbBjKpsAdACfAv4CPAicABwD3Ak8Cnwmt6yZwI+Aq4Angd+THQiq5TOAu1PZ7cCJubJpwP8CF6blfj5NuzlXJ4APAHeRHYQvAZTKBgJfBh4m+8BMT/UH1XnPVwAbgGfS9vkUMDrVPx24Py3ns7l5BuTifwSYD+xRsP3vBj4I/Bl4e03ZK4Ab0nv9c3U7pvfxmdx2WgKMzMU3KLeMRcD7Gmy/lwG/SvE+DHwf2C03/0jgaqAz1bk47Q+PAq/K1dszbau2Ou9xAHAOcF/aR+aS7Xc7pm0bwNPA3V1sowAOqJn2duBZYFj+fQJvTnFsSMu+st46gL2BH6f3dS/wkTr76PeAv6bldvm/bbRfABOB54B/pDiWd/Ee16RtdFtu2gXAZ9OyR6dp3wE+38TnuhrTOcCXctMraZlrctMOStvvcbKEelyubBiwIG2H3wHnsenn7eVs3EdXAe/Ilb0QKzAcuCat41Hg18CAVh//IsLJoukNle3M66lzwMzVmQXcSnZAaAN+A5yXyiak+f8D2AF4f/oA/gAYSnbAexbYP9WfmT44b0/1z0of1h1S+b+mD/IA4KT0AX9pKpuW1vVhYBDZWdc0Nk8W1wC7kV0hdQITU9kHyBLQCGB34Jd0kSxS/TXAm3Pj1Q/gt9K6/wn4O3BQKv9Y2k4jyA6E3wSubLBd35Dm3x34GrAgVzaULPF+AtgpjR+Ryj4J/IHsLFspjmE0lyxqt98BwFtSvG3AYuCiVH8gsJwsueyS4nh9KrsU+GJuPR8F/ruL9/keYDWwPzCELPlcUfM/O6DBdqqXLHZI72VSnfc5Aejoahlk+9YSsn12cIrrHuDomn30hFR350b/2yb2i5nA9wo+h2vIEt0qsoP3QGAt2RXR1iSL0Wk5A9NyV6X1rMltx9VkJx+DgTeRnYAcmMrnkSXGXYBXAg+QPm9p2lrg3WT706vJEuUramMFZgPfSOvbgWzfV6uPfxFOFs1vKDgVeKigzt3AMbnxo3M72wSyM7mBaXxo2kmPyNVfApyQhmcCt+bKBpAdFN/QxbqXAcen4WnA/TXl09g8Wbw+Nz4fmJGGfwX8W67szWxZshiRm/Y7YGoavgM4Klf2UrKDTlfL/zbw0zT82lR3zzR+MrC0i/lWVbdJzfRqfI2Sxf31lpmrf0J1vSmmznrxA0ekA8WANF4hd1ZZU3ch8KHc+IH57cIWJIs0/SHg1DrvcwKNk8URdfajs4HLc/vo4pryLv+3TewXM2k+WZxDdmCdSHbGPoitSxaDyE6Kjga+QHZVkU8Wb0jbcUBu3itTzAPTe3x5ruw/2ZgsTgJ+XbPebwLn1sZKdsL5s0b/51a9+kpb7LbgEWC4pEERsb6LOnuTNSFU3ZemvbCMiHg+DT+T/v45V/4M2Rll1drqQERskNRRXZ6kdwEfJ9vZSfMNrzdvAw/lhv+WW/feNfM3s6zuLH8U8BNJG3Llz5P1Az2QX4Ckncmuot4HEBG3SLqfrE35IrLmn7u7WH+jsiKbvGdJewL/l+ygMZQseT+WW8999faLiPitpKeB8ZIeJLtCWdDFOuvtP4Oos12aJWkHsiuhR7dg9lHA3pIez00bSNY0UlW7bzT631Z1tV90xxVkV3f7kTXX9YS5ZCcKrwPGAWNyZXsDayMi/77uA/Yh276D2HRb5P+Po4AjarbjILL3UOtLZAnoekkAl0XEF7bgvfQ4d3A37xayZqITGtRZR7ZjVO2bpm2pkdUBSQPILu3XSRpFdik/nawtejfgj2RNLVWxFet9MK1rszi60N11rSVrFtkt99opIuodEE8EXgxcKumhdIvnPmQd3tVlvazBeuqVPZ3+vig37SU1dWrf0+w07eCIeDFwGhu391pg3wYdvN9N9d8J/Cginu2iXr39Zz2bnlB01/FpGb/bgnnXAvfW/J+GRsQxuTq126k7/9taTe9HEXEfWbPsMWTNdT3hx8C/APek5eetA0amz2HVvmRJvJNsG4+sKataC9xUs02GRMQHawOIiCcj4hMRsT9wLPBxSUdt/Vvbek4WTYqIJ8jabi+RdIKkF0naQdIkSf+Vql0JnCOpLd3a9x9knX9b6jBJk9NB6GNk7bu3krWBBtlOiqR3k7WT9pT5wEcl7SNpN+DTBfX/TNae3axvAOenpEfaXl3dUXY6MAd4FXBIeh0JHJLugrkGeImkj0naUdJQSUekeb8NnCdpjDIHSxoWEZ1kH/LTJA2U9B66TjhVQ8k6Xh+XtA9Zf0jV78gS7Bck7SJpJ0lH5sqvIEt6p9H4LPhK4Mx0m/AQsqaMqxpcyXZJ0h6STiW7ceGLEfFId5dB9r7+KunTknZO2+qVkl7TYJ7u/G9r/RkYXXNAbuS9wJsi4ukuygem/0X1NbjRwtJy3kS6iq3xW7KTjE+lz/0EsoP5vNRacDUwMx0XxpLtt1XXAP9H0jvTvDtIeo2kg2pXIultkg5QdlnxV7Krsudr67WCk0U3RMRXyJp+ziE7UK8lO7v/aaryebI26RVkHau/T9O21M/I2jsfIzsrnRwR/4iI28nuVrqF7AP2KrK7d3rKt4Dryd7HUuAXZGdOXe20s8mS5OOSzmpi+V8la4q5XtKTZAnwiNpK6aB8FFlH8kO51xLgWuD0iHiSrOP5WLLmjbuAN6ZFfIUs8V1P9sH7f2y8xfL9ZAf8R8huLvhNQcyfI+uYfAL4Obmz2XSwOJasiel+srveTsqVd5DtC8GmTTi15rCxeeVesivZDxfEVWu5pKfIOmPfB5wZEf/RzWUAm7yvQ1I8D5Ml4F0bzNbU/7YLP0x/H6n93kMX8d0dEZUGVWaQNe1WX79qYpmViNis6TIingOOAyaRbYdLgXdFxJ9SlelkzWkPkfVBXJ6b90ngrcBUsiuUh4Avkt0AUGsMWd/JU2Sf70sjYlFR3L2hequk9TGSZpJ1cp3WB2KZBHwjIkYVVra6JM0B1kXEOa2OxWxLuIPbNpM6ld9Idka+F3Au8JOWBrUNS98qngz48Rm2zXIzlNUjsmaXx8iaoe4g63+xbpJ0HtnNB1+KiHtbHY/ZlnIzlJmZFfKVhZmZFeo3fRbDhw+P0aNHtzoMM7NtypIlSx6OiLaiev0mWYwePZpKpdFddGZmVktS7RcQ63IzlJmZFXKyMDOzQk4WZmZWyMnCzMwKOVmYmVkhJwszMyvUb26dNWvWuHHjWh1Cr1m8eHGrQ7B+wlcWZmZWyMnCzMwKOVmYmVkhJwszMyvkDm7b7rjT16z7fGVhZmaFnCzMzKyQk4WZmRVysjAzs0JOFmZmVsjJwszMCjlZmJlZIScLMzMrVGqykDRR0ipJqyXNqFM+StJCSSskLZI0Ilf2vKRl6bWgzDjNzKyx0r7BLWkgcAnwFqADuE3Sgoi4PVftAmBuRHxX0puA2cA7U9kzEXFIWfGZmVnzyryyOBxYHRH3RMRzwDzg+Jo6Y4GFafjGOuVmZtYHlJks9gHW5sY70rS85cCUNHwiMFTSsDS+k6SKpFslnVBvBZLOSHUqnZ2dPRm7mZnllJksVGda1IyfBYyXtBQYDzwArE9l+0ZEO3AKcJGkl222sIjLIqI9Itrb2tp6MHQzM8sr86mzHcDI3PgIYF2+QkSsAyYDSBoCTImIJ3JlRMQ9khYBhwJ3lxivmZl1ocwri9uAMZL2kzQYmApscleTpOGSqjGcDcxJ03eXtGO1DnAkkO8YNzOzXlRasoiI9cB04DrgDmB+RKyUNEvScanaBGCVpDuBvYDz0/SDgIqk5WQd31+ouYvKzMx6kSJquxG2Te3t7VGpVFodhpnZNkXSktQ/3JC/wW1mZoWcLMzMrJCThZmZFXKyMDOzQk4WZmZWyMnCzMwKOVmYmVkhJwszMyvkZGFmZoWcLMzMrJCThZmZFXKyMDOzQk4WZmZWyMnCzMwKOVmYmVkhJwszMyvkZGFmZoWcLMzMrJCThZmZFSo1WUiaKGmVpNWSZtQpHyVpoaQVkhZJGlFT/mJJD0i6uMw4zcyssdKShaSBwCXAJGAscLKksTXVLgDmRsTBwCxgdk35ecBNZcVoZmbNKfPK4nBgdUTcExHPAfOA42vqjAUWpuEb8+WSDgP2Aq4vMUYzM2tCmcliH2BtbrwjTctbDkxJwycCQyUNkzQA+DLwyUYrkHSGpIqkSmdnZw+FbWZmtcpMFqozLWrGzwLGS1oKjAceANYDHwJ+ERFraSAiLouI9ohob2tr64mYzcysjkElLrsDGJkbHwGsy1eIiHXAZABJQ4ApEfGEpNcCb5D0IWAIMFjSUxGxWSe5mZmVr8xkcRswRtJ+ZFcMU4FT8hUkDQcejYgNwNnAHICIODVXZxrQ7kRhZtY6pTVDRcR6YDpwHXAHMD8iVkqaJem4VG0CsErSnWSd2eeXFY+ZmW05RdR2I2yb2tvbo1KptDoMM7NtiqQlEdFeVM/f4DYzs0JOFmZmVsjJwszMCjlZmJlZIScLMzMr5GRhZmaFnCzMzKyQk4WZmRVysjAzs0JOFmZmVsjJwszMCjlZmJlZIScLMzMr5GRhZmaFnCzMzKyQk4WZmRVysjAzs0JOFmZmVsjJwszMCpWaLCRNlLRK0mpJM+qUj5K0UNIKSYskjchNXyJpmaSVkj5QZpxmZtZYaclC0kDgEmASMBY4WdLYmmoXAHMj4mBgFjA7TX8QeF1EHAIcAcyQtHdZsZqZWWNlXlkcDqyOiHsi4jlgHnB8TZ2xwMI0fGO1PCKei4i/p+k7lhynmZkVGFTisvcB1ubGO8iuEvKWA1OArwInAkMlDYuIRySNBH4OHAB8MiLWdTeAcePGbVHg26LFixe3OgQz68fKPGNXnWlRM34WMF7SUmA88ACwHiAi1qbmqQOA0yXttdkKpDMkVSRVOjs7ezZ6MzN7QZnJogMYmRsfAWxydRAR6yJickQcCnw2TXuitg6wEnhD7Qoi4rKIaI+I9ra2tp6O38zMkjKTxW3AGEn7SRoMTAUW5CtIGi6pGsPZwJw0fYSkndPw7sCRwKoSYzUzswZKSxYRsR6YDlwH3AHMj4iVkmZJOi5VmwCsknQnsBdwfpp+EPBbScuBm4ALIuIPZcVqZmaNKaK2G2Hb1N7eHpVKpdVhmJltUyQtiYj2onq+JdXMzAo5WZiZWaGmkoWkH0v6l1xntJmZbUeaPfh/HTgFuEvSFyS9vMSYzMysj2kqWUTELyPiVODVwBrgBkm/kfRuSTuUGaCZmbVe081KkoYB04D3AUvJHtHxauCGUiIzM7M+o6lnQ0m6Gng5cAVwbEQ8mIqukuT7Vc3M+rlmHyR4cUT8ql5BM/fnmpnZtq3ZZqiDJO1WHZG0u6QPlRSTmZn1Mc0mi/dHxOPVkYh4DHh/OSGZmVlf02yyGCDphUeOp1/BG1xOSGZm1tc022dxHTBf0jfIfpPiA8C1pUVlZmZ9SrPJ4tPAvwEfJPtRo+uBb5cVlJmZ9S1NJYuI2ED2Le6vlxuOmZn1Rc1+z2IMMBsYC+xUnR4R+5cUl5mZ9SHNdnBfTnZVsR54IzCX7At6Zma2HWg2WewcEQvJfizpvoiYCbypvLDMzKwvabaD+9n0ePK7JE0HHgD2LC8sMzPrS5q9svgY8CLgI8BhwGnA6WUFZWZmfUthskhfwHtHRDwVER0R8e6ImBIRtzYx70RJqyStljSjTvkoSQslrZC0SNKINP0QSbdIWpnKTtqid2dmZj2iMFlExPPAYflvcDcjJZlLgElkd1GdLGlsTbULgLkRcTAwi+yOK4C/Ae+KiFcAE4GL8s+mMjOz3tVsn8VS4GeSfgg8XZ0YEVc3mOdwYHVE3AMgaR5wPHB7rs5Y4Mw0fCPw07TcO3PrWCfpL0Ab8DhmZtbrmu2z2AN4hOwOqGPT620F8+wDrM2Nd6RpecuBKWn4RGBo+pGlF0g6nOw5VHc3GauZmfWwZr/B/e4tWHa9ZquoGT8LuFjSNGAx2V1W619YgPRSsu9znJ6+Rb7pCqQzgDMA9t133y0I0czMmtHsN7gvZ/MDPRHxngazdQAjc+MjgHU1868DJqd1DAGmRMQTafzFwM+Bc7rqTI+Iy4DLANrb2zeLz8zMekazfRbX5IZ3ImsyWtdF3arbgDGS9iO7YpgKnJKvIGk48Gi6ajgbmJOmDwZ+Qtb5/cMmYzQzs5I02wz14/y4pCuBXxbMsz59ge86YCAwJyJWSpoFVCJiATABmC0pyJqh/j3N/g5gHDAsNVEBTIuIZU29KzMz61GK6H7rjaQDgZ9HxAE9H9KWaW9vj0ql0uowzLYp48aNa3UIvWbx4sWtDqFPkrQkItqL6jXbZ/Ekm/ZZPET2GxdmZrYdaLYZamjZgZiZWd/V1PcsJJ0oadfc+G6STigvLDMz60ua/VLeudVbWgEi4nHg3HJCMjOzvqbZW2frJZVm5zWzPsqdvtasZq8sKpK+IullkvaXdCGwpMzAzMys72g2WXwYeA64CpgPPMPG70SYmVk/1+zdUE8Dm/0ehZmZbR+avRvqhvzvSUjaXdJ15YVlZmZ9SbPNUMPTHVAARMRj+De4zcy2G80miw2SXngGuKTR1HkKrZmZ9U/N3v76WeBmSTel8XGk35EwM7P+r9kO7msltZMliGXAz8juiDIzs+1Asw8SfB/wUbIfMFoG/DNwC9nPrJqZWT/XbJ/FR4HXAPdFxBuBQ4HO0qIyM7M+pdlk8WxEPAsgaceI+BNwYHlhmZlZX9JsB3dH+p7FT4EbJD1G8c+qmplZP9FsB/eJaXCmpBuBXYFrS4vKzMz6lG4/OTYibiquZWZm/UmzfRZmZrYdKzVZSJooaZWk1ZI2exChpFGSFkpaIWmRpBG5smslPS7pmjJjNDOzYqUlC0kDgUuAScBY4GRJY2uqXQDMjYiDgVnA7FzZl4B3lhWfmZk1r8wri8OB1RFxT0Q8B8wDjq+pMxZYmIZvzJdHxELgyRLjMzOzJpWZLPYB1ubGO9K0vOXAlDR8IjBU0rBmVyDpDEkVSZXOTn9H0MysLGUmC9WZVvuk2rOA8ZKWAuOBB4D1za4gIi6LiPaIaG9ra9vySM3MrKFu3zrbDR3AyNz4CGq+yBcR64DJAJKGAFMi4okSYzIzsy1Q5pXFbcAYSftJGgxMBRbkK0gaLqkaw9nAnBLjMTOzLVRasoiI9cB04DrgDmB+RKyUNEvScanaBGCVpDuBvYDzq/NL+jXwQ+AoSR2Sji4rVjMza0wR/eMH79rb26NSqbQ6DDOzbYqkJRHRXlTP3+A2M7NCThZmZlbIycLMzAo5WZiZWSEnCzMzK+RkYWZmhZwszMyskJOFmZkVcrIwM7NCThZmZlbIycLMzAo5WZiZWSEnCzMzK+RkYWZmhZwszMyskJOFmZkVcrIwM7NCThZmZlbIycLMzAqVmiwkTZS0StJqSTPqlI+StFDSCkmLJI3IlZ0u6a70Or3MOM3MrLHSkoWkgcAlwCRgLHCypLE11S4A5kbEwcAsYHaadw/gXOAI4HDgXEm7lxWrmZk1VuaVxeHA6oi4JyKeA+YBx9fUGQssTMM35sqPBm6IiEcj4jHgBmBiibGamVkDZSaLfYC1ufGONC1vOTAlDZ8IDJU0rMl5kXSGpIqkSmdnZ48FbmZmmyozWajOtKgZPwsYL2kpMB54AFjf5LxExGUR0R4R7W1tbVsbr5mZdWFQicvuAEbmxkcA6/IVImIdMBlA0hBgSkQ8IakDmFAz76ISYzUzswbKvLK4DRgjaT9Jg4GpwIJ8BUnDJVVjOBuYk4avA94qaffUsf3WNM3MzFqgtGQREeuB6WQH+TuA+RGxUtIsScelahOAVZLuBPYCzk/zPgqcR5ZwbgNmpWlmZtYCitisK2Cb1N7eHpVKpdVhmJltUyQtiYj2onr+BreZmRVysjAzs0JOFmZmVqjMW2etDxk3blyrQ+g1ixcvbnUIZv2OryzMzKyQk4WZmRVysjAzs0JOFmZmVsgd3NsJd/qa2dbwlYWZmRVysjAzs0JOFmZmVsjJwszMCjlZmJlZIScLMzMr5GRhZmaFnCzMzKyQk4WZmRVysjAzs0KlJgtJEyWtkrRa0ow65ftKulHSUkkrJB2Tpg+WdLmkP0haLmlCmXGamVljpSULSQOBS4BJwFjgZElja6qdA8yPiEOBqcClafr7ASLiVcBbgC9L8lWQmVmLlHkAPhxYHRH3RMRzwDzg+Jo6Abw4De8KrEvDY4GFABHxF+BxoL3EWM3MrIEyk8U+wNrceEealjcTOE1SB/AL4MNp+nLgeEmDJO0HHAaMrF2BpDMkVSRVOjs7ezp+MzNLykwWqjMtasZPBr4TESOAY4ArUnPTHLLkUgEuAn4DrN9sYRGXRUR7RLS3tbX1aPBmZrZRmb9n0cGmVwMj2NjMVPVeYCJARNwiaSdgeGp6OrNaSdJvgLtKjNXMzBoo88riNmCMpP0kDSbrwF5QU+d+4CgASQcBOwGdkl4kaZc0/S3A+oi4vcRYzcysgdKuLCJivaTpwHXAQGBORKyUNAuoRMQC4BPAtySdSdZENS0iQtKewHWSNgAPAO8sK04zMyumiNpuhG1Te3t7VCqVVodhZrZNkbQkIgrvNvV3F8zMrJCThZmZFXKyMDOzQk4WZmZWyMnCzMwKOVmYmVmhMr/BbWa2zRg3blyrQ+g1ixcv7vY8vrIwM7NCThZmZlbIycLMzAo5WZiZWSF3cJuZsWWdvtsTX1mYmVkhJwszMyvkZGFmZoWcLMzMrJCThZmZFXKyMDOzQv3mZ1UldQL3tToOYDjwcKuD6CO8LTbyttjI22KjvrAtRkVEW1GlfpMs+gpJlWZ+z3Z74G2xkbfFRt4WG21L28LNUGZmVsjJwszMCjlZ9LzLWh1AH+JtsZG3xUbeFhttM9vCfRZmZlbIVxZmZlbIycLMzAo5WWwhSSHpy7nxsyTNTMMzJT0gaZmkP0n6uqR+va0lPVVnWn473C7p5FbEVjZJn5W0UtKK9F7/R9LsmjqHSLojDa+R9Oua8mWS/tibcZdN0vPpfa2UtFzSxyUNkHR0mr5M0lOSVqXhua2OuQy57VB9zUjTF0m6X5JydX9a77PUF/j3LLbc34HJkmZHRL0v1VwYERekJLEYGA/c2KsR9g3V7TAGWCLpRxHxj1YH1VMkvRZ4G/DqiPi7pOHAK4DLgbNzVacCP8iND5U0MiLWSjqo9yLuVc9ExCEAkvYke/+7RsS5wHVp+iLgrIiotCzK8r2wHep4HDgSuFnSbsBLey+s7unXZ7slW092J8OZBfUGAzsBj5UeUR8WEXcBfwN2b3UsPeylwMMR8XeAiHg4Im4CHpd0RK7eO4B5ufH5wElp+GTgyt4ItlUi4i/AGcD0/Jm0MY/sRAJgMnB1C2NpyMli61wCnCpp1zplZ0paBjwI3BkRy3o3tL5F0quBu9JBoz+5Hhgp6U5Jl0oan6ZfSToISPpn4JGUMKt+RHZwADgW+O/eCrhVIuIesmPOnq2OpZftXNMMdVKubCEwTtJAsv3lqtaEWMzJYitExF+BucBH6hRfmC499wR2kTS1Tp3twZmSVgG/BWa2OJYeFxFPAYeRnTV3AldJmkZ2xvj21Aw5lc2vHB4FHkv7xR1kV13bg+3xquKZiDgk98onhOeBm8muMneOiDUtibAJThZb7yLgvcAu9QpT+/y1wLjeDKoPuTAiDiT7MMyVtFOrA+ppEfF8RCxKbfHTgSkRsRZYQ9ZXNYWs2anWVWRXp/26CapK0v5kB8f+dnW5teYBX6P+PtJnOFlspYh4lOyf/N565al99nXA3b0ZV18TEVcDFeD0VsfSkyQdmDrvqw5h49OPrwQuBO6OiI46s/8E+C9SZ29/JqkN+AZwcfibwLV+Dcymj580+G6onvFlsjPKvDMlnQbsAKwALu31qHrXiyTlD4hfqVNnFvADSd+KiA29FFfZhgBfS3eyrAdWkzVJAfwQ+Crw4XozRsSTwBcB+mmf786p324Hsm1zBfX3i/6uuh2qro2IGdWRlDwv6P2wuseP+zAzs0JuhjIzs0JOFmZmVsjJwszMCjlZmJlZIScLMzMr5GRh1gLpybPDt7aOWW9xsjAzs0JOFmZNkjQ6/T7JtyX9UdL3Jb1Z0v9KukvS4ZL2SL9JsELSrZIOTvMOk3S9pKWSvknuGUmSTpP0u/SQuW+mh8qZ9SlOFmbdcwDZt7IPBl4OnAK8HjgL+AzwOWBpRBycxqs/6HMucHNEHAosAPYFSL9lcRJwZHrw5PPAqb32bsya5Md9mHXPvRHxBwBJK4GFERGS/gCMBkaRPTiQiPhVuqLYlexBkpPT9J+ZXSVTAAAAwElEQVRLqv6+yVFkT629LT3yY2f8oD3rg5wszLrn77nhDbnxDWSfp/V15omav3kCvhsRZ9cpM+sz3Axl1rMWk5qRJE0g+xW9v9ZMn8TGXwxcSPa7F3umsj0kjertoM2K+MrCrGfNBC6XtILsB42qj2T/HHClpN8DNwH3A0TE7ZLOAa5PP5T0D+Df2fiYc7M+wU+dNTOzQm6GMjOzQk4WZmZWyMnCzMwKOVmYmVkhJwszMyvkZGFmZoWcLMzMrND/B4Nfpve9O0TEAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=sns.boxplot(x='model', y='accuracy', data=Performane,linewidth=5)\n",
    "ax.set_title(\"Comparing the Accuracy of Different ML Models\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# Model Tuning with Cross Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "scores = cross_val_score(pip_SVM, X_train, y_train, scoring='accuracy', cv=5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pip= [MultinomialNB(), LogisticRegression(random_state=0), SGDClassifier(random_state=0), tree.DecisionTreeClassifier(), RandomForestClassifier(n_estimators=10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9874375322436217"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9841969204281504, 0.9893758959916511, 0.9915618309408132, 0.8948630615786991, 0.9811047809228761]\n"
     ]
    }
   ],
   "source": [
    "Acc_with_CV=[]\n",
    "for l in model_pip:\n",
    "    Acc_with_CV.append (cross_val_score(pip(l), X_train, y_train, scoring='roc_auc', cv=5).mean())\n",
    "print(Acc_with_CV)\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "Performane['Accuracy_with_CV']=Acc_with_CV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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>model</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>Accuracy_with_CV</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NB</td>\n",
       "      <td>0.929360</td>\n",
       "      <td>0.984197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LR</td>\n",
       "      <td>0.896101</td>\n",
       "      <td>0.989376</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>SVM</td>\n",
       "      <td>0.955390</td>\n",
       "      <td>0.991562</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DT</td>\n",
       "      <td>0.917551</td>\n",
       "      <td>0.894863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>EM</td>\n",
       "      <td>0.884977</td>\n",
       "      <td>0.981105</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  model  accuracy  Accuracy_with_CV\n",
       "0    NB  0.929360          0.984197\n",
       "1    LR  0.896101          0.989376\n",
       "2   SVM  0.955390          0.991562\n",
       "3    DT  0.917551          0.894863\n",
       "4    EM  0.884977          0.981105"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Performane.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "##STEMMING\n",
    "\n",
    "#from nltk.stem.snowball import SnowballStemmer\n",
    "#stemmer = SnowballStemmer(\"english\", ignore_stopwords=True)\n",
    "\n",
    "#class StemmedCountVectorizer(CountVectorizer):\n",
    "#    def build_analyzer(self):\n",
    "#        analyzer = super(StemmedCountVectorizer, self).build_analyzer()\n",
    "#        return lambda doc: ([stemmer.stem(w) for w in analyzer(doc)])\n",
    "\n",
    "#stemmed_count_vect = StemmedCountVectorizer(stop_words='english')\n",
    "\n",
    "#text_mnb_stemmed = Pipeline([('vect', stemmed_count_vect),\n",
    "#                            ('tfidf', TfidfTransformer()),\n",
    " #                            ('mnb', MultinomialNB()),\n",
    "  #                          ])\n",
    "\n",
    "#text_mnb_stemmed = text_mnb_stemmed.fit(X_train, y_train)\n",
    "\n",
    "#predicted_mnb_stemmed = text_mnb_stemmed.predict(X_test)\n",
    "\n",
    "#np.mean(predicted_mnb_stemmed == y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# Parameters Tuning with GridSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing differnt parameters, e.g. comparing the performance of NB with unigram and Bigram "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    " parameters_NB = {'vect__ngram_range': [(1, 2), (2, 3)],\n",
    "                  'vect__analyzer':['word','char'],\n",
    "                  'tfidf__use_idf': (True, False),\n",
    "                  'clf__alpha': (1e-2, 1e-3),\n",
    "                 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_clf_NB = GridSearchCV(pip(MultinomialNB(fit_prior=False)), parameters_NB, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_clf_NB = gs_clf_NB.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9874358974358974"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_clf_NB.best_score_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'clf__alpha': 0.01,\n",
       " 'tfidf__use_idf': True,\n",
       " 'vect__analyzer': 'char',\n",
       " 'vect__ngram_range': (2, 3)}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_clf_NB.best_params_"
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}