Train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\externals\\joblib\\__init__.py:15: FutureWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "import re, nltk\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from bs4 import BeautifulSoup\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.corpus import stopwords\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.externals import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizer(Reviews): \n",
    "    soup = BeautifulSoup(Reviews, 'lxml')   # removing HTML encoding such as ‘&amp’,’&quot’\n",
    "    souped = soup.get_text()\n",
    "    only_words = re.sub(\"(@[A-Za-z0-9]+)|([^A-Za-z \\t])|(\\w+:\\/\\\\\\S+)\",\" \", souped) # removing @mentions, hashtags, urls.\n",
    "\n",
    "    tokens = nltk.word_tokenize(only_words)\n",
    "    removed_letters = [word for word in tokens if len(word)>2] # removing words with length less than or equal to 2\n",
    "    lower_case = [l.lower() for l in removed_letters]\n",
    "\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    filtered_result = list(filter(lambda l: l not in stop_words, lower_case))\n",
    "\n",
    "    wordnet_lemmatizer = WordNetLemmatizer()\n",
    "    lemmas = [wordnet_lemmatizer.lemmatize(t) for t in filtered_result]\n",
    "    return lemmas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Cross_validation(data, targets, tfidf, clf_cv, model_name): \n",
    "\n",
    "    kf = KFold(n_splits=10, shuffle=True, random_state=1) # 10-fold cross-validation\n",
    "    scores=[]\n",
    "    data_train_list = []\n",
    "    targets_train_list = []\n",
    "    data_test_list = []\n",
    "    targets_test_list = []\n",
    "    iteration = 0\n",
    "    print(\"Performing cross-validation for {}...\".format(model_name))\n",
    "    for train_index, test_index in kf.split(data):\n",
    "        iteration += 1\n",
    "        print(\"Iteration \", iteration)\n",
    "        data_train_cv, targets_train_cv = data[train_index], targets[train_index]\n",
    "        data_test_cv, targets_test_cv = data[test_index], targets[test_index]\n",
    "        data_train_list.append(data_train_cv) # appending training data for each iteration\n",
    "        data_test_list.append(data_test_cv) # appending test data for each iteration\n",
    "        targets_train_list.append(targets_train_cv) # appending training targets for each iteration\n",
    "        targets_test_list.append(targets_test_cv) # appending test targets for each iteration\n",
    "        tfidf.fit(data_train_cv) # learning vocabulary of training set\n",
    "        data_train_tfidf_cv = tfidf.transform(data_train_cv)\n",
    "        print(\"Shape of training data: \", data_train_tfidf_cv.shape)\n",
    "        data_test_tfidf_cv = tfidf.transform(data_test_cv)\n",
    "        print(\"Shape of test data: \", data_test_tfidf_cv.shape)\n",
    "        clf_cv.fit(data_train_tfidf_cv, targets_train_cv) # Fitting SVC\n",
    "        score = clf_cv.score(data_test_tfidf_cv, targets_test_cv) # Calculating accuracy\n",
    "        scores.append(score) # appending cross-validation accuracy for each iteration\n",
    "    print(\"List of cross-validation accuracies for {}: \".format(model_name), scores)\n",
    "    mean_accuracy = np.mean(scores)\n",
    "    print(\"Mean cross-validation accuracy for {}: \".format(model_name), mean_accuracy)\n",
    "    print(\"Best cross-validation accuracy for {}: \".format(model_name), max(scores))\n",
    "    max_acc_index = scores.index(max(scores)) # best cross-validation accuracy\n",
    "    max_acc_data_train = data_train_list[max_acc_index] # training data corresponding to best cross-validation accuracy\n",
    "    max_acc_data_test = data_test_list[max_acc_index] # test data corresponding to best cross-validation accuracy\n",
    "    max_acc_targets_train = targets_train_list[max_acc_index] # training targets corresponding to best cross-validation accuracy\n",
    "    max_acc_targets_test = targets_test_list[max_acc_index] # test targets corresponding to best cross-validation accuracy\n",
    "\n",
    "    return mean_accuracy, max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def c_matrix(max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test, tfidf, targets, clf, model_name):\n",
    "    tfidf.fit(max_acc_data_train)\n",
    "    max_acc_data_train_tfidf = tfidf.transform(max_acc_data_train)\n",
    "    max_acc_data_test_tfidf = tfidf.transform(max_acc_data_test)\n",
    "    clf.fit(max_acc_data_train_tfidf, max_acc_targets_train) # Fitting Model\n",
    "    targets_pred = clf.predict(max_acc_data_test_tfidf) # Prediction on test data\n",
    "    conf_mat = confusion_matrix(max_acc_targets_test, targets_pred)\n",
    "    d={0:'Negative', 1: 'Positive'}\n",
    "    sentiment_df = targets.drop_duplicates().sort_values()\n",
    "    sentiment_df= sentiment_df.apply(lambda x:d[x])\n",
    "    sns.heatmap(conf_mat, annot=True, fmt='d', xticklabels=sentiment_df.values, yticklabels=sentiment_df.values)\n",
    "    plt.ylabel('Actual')\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.title(\"Confusion Matrix (Best Accuracy) - {}\".format(model_name))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SVC_Save(data, targets, tfidf):\n",
    "    tfidf.fit(data) # learn vocabulary of entire data\n",
    "    data_tfidf = tfidf.transform(data)\n",
    "    pd.DataFrame.from_dict(data=dict([word, i] for i, word in enumerate(tfidf.get_feature_names())), orient='index').to_csv('vocabulary_SVC.csv', header=False)\n",
    "    print(\"Shape of tfidf matrix for saved SVC Model: \", data_tfidf.shape)\n",
    "    clf = LinearSVC().fit(data_tfidf, targets)\n",
    "    joblib.dump(clf, 'svc.sav')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NBC_Save(data, targets, tfidf):\n",
    "    tfidf.fit(data) # learn vocabulary of entire data\n",
    "    data_tfidf = tfidf.transform(data)\n",
    "    pd.DataFrame.from_dict(data=dict([word, i] for i, word in enumerate(tfidf.get_feature_names())), orient='index').to_csv('vocabulary_NBC.csv', header=False)\n",
    "    print(\"Shape of tfidf matrix for saved NBC Model: \", data_tfidf.shape)\n",
    "    clf = MultinomialNB(alpha=1.0).fit(data_tfidf, targets)\n",
    "    joblib.dump(clf, 'nbc.sav')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    #### Reading training dataset as dataframe\n",
    "    df = pd.read_csv(\"train.csv\", encoding = \"ISO-8859-1\")\n",
    "    pd.set_option('display.max_colwidth', -1) # Setting this so we can see the full content of cells\n",
    "    #### Normalizing Reviews\n",
    "    df['normalized_tweet'] = df.tweet.apply(normalizer)\n",
    "    df = df[df['normalized_tweet'].map(len) > 0] # removing rows with normalized reviews of length 0\n",
    "    print(\"Printing top 5 rows of dataframe showing original and cleaned reviews....\")\n",
    "    print(df[['tweet','normalized_tweet']].head())\n",
    "    d = {'Low': 0, 'High': 1}\n",
    "    df['label'] = df['label'].astype(str).map(d).fillna(df['label'])\n",
    "    #df.Rating.replace(to_replace=['Low', 'High'], value=[0, 1])\n",
    "    #df.drop(['Medicine', 'Condition'], axis=1, inplace=True)\n",
    "    #### Saving cleaned reviews to csv\n",
    "    df.to_csv('cleaned_tweet_data.csv', encoding='utf-8', index=False)\n",
    "    #### Reading cleaned reviews as dataframe\n",
    "    cleaned_data = pd.read_csv(\"cleaned_tweet_data.csv\", encoding = \"ISO-8859-1\")\n",
    "    pd.set_option('display.max_colwidth', -1)\n",
    "    data = cleaned_data.normalized_tweet\n",
    "    targets = cleaned_data.label\n",
    "    tfidf = TfidfVectorizer(sublinear_tf=True, min_df=30, norm='l2', ngram_range=(1,3)) # min_df=30 is a clever way of feature engineering\n",
    "\n",
    "    SVC_clf = LinearSVC() # SVC Model\n",
    "    SVC_mean_accuracy, max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test = Cross_validation(data, targets, tfidf, SVC_clf, \"SVC\") # SVC cross-validation\n",
    "    c_matrix(max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test, tfidf, targets, SVC_clf, \"SVC\") # SVC confusion matrix\n",
    "\n",
    "    NBC_clf = MultinomialNB() # NBC Model\n",
    "    NBC_mean_accuracy, max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test = Cross_validation(data, targets, tfidf, NBC_clf, \"NBC\") # NBC cross-validation\n",
    "    c_matrix(max_acc_data_train, max_acc_data_test, max_acc_targets_train, max_acc_targets_test, tfidf, targets, NBC_clf, \"NBC\") # NBC confusion matrix\n",
    "\n",
    "    if SVC_mean_accuracy > NBC_mean_accuracy:\n",
    "        SVC_Save(data, targets, tfidf)\n",
    "    else:\n",
    "        NBC_Save(data, targets, tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\bhara\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to\n",
      "[nltk_data]     C:\\Users\\bhara\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n",
      "D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py:4: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing top 5 rows of dataframe showing original and cleaned reviews....\n",
      "                                                                                                                                   tweet  \\\n",
      "0  #fingerprint #Pregnancy Test https://goo.gl/h1MfQV #android #apps #beautiful #cute #health #igers #iphoneonly #iphonesia #iphone        \n",
      "1  Finally a transparant silicon case ^^ Thanks to my uncle :) #yay #Sony #Xperia #S #sonyexperiasâ¦ http://instagram.com/p/YGEt5JC6JM/   \n",
      "2  We love this! Would you go? #talk #makememories #unplug #relax #iphone #smartphone #wifi #connect... http://fb.me/6N3LsUpCu             \n",
      "3  I'm wired I know I'm George I was made that way ;) #iphone #cute #daventry #home http://instagr.am/p/Li_5_ujS4k/                        \n",
      "4  What amazing service! Apple won't even talk to me about a question I have unless I pay them $19.95 for their stupid support!            \n",
      "\n",
      "                                                                                                                normalized_tweet  \n",
      "0  [fingerprint, pregnancy, test, http, goo, mfqv, android, apps, beautiful, cute, health, igers, iphoneonly, iphonesia, iphone]  \n",
      "1  [finally, transparant, silicon, case, thanks, uncle, yay, sony, xperia, sonyexperias, http, instagram, com, yget]              \n",
      "2  [love, would, talk, makememories, unplug, relax, iphone, smartphone, wifi, connect, http, lsupcu]                              \n",
      "3  [wired, know, george, made, way, iphone, cute, daventry, home, http, instagr, ujs]                                             \n",
      "4  [amazing, service, apple, even, talk, question, unless, pay, stupid, support]                                                  \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py:18: FutureWarning: Passing a negative integer is deprecated in version 1.0 and will not be supported in future version. Instead, use None to not limit the column width.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing cross-validation for SVC...\n",
      "Iteration  1\n",
      "Shape of training data:  (7127, 603)\n",
      "Shape of test data:  (792, 603)\n",
      "Iteration  2\n",
      "Shape of training data:  (7127, 596)\n",
      "Shape of test data:  (792, 596)\n",
      "Iteration  3\n",
      "Shape of training data:  (7127, 603)\n",
      "Shape of test data:  (792, 603)\n",
      "Iteration  4\n",
      "Shape of training data:  (7127, 598)\n",
      "Shape of test data:  (792, 598)\n",
      "Iteration  5\n",
      "Shape of training data:  (7127, 605)\n",
      "Shape of test data:  (792, 605)\n",
      "Iteration  6\n",
      "Shape of training data:  (7127, 611)\n",
      "Shape of test data:  (792, 611)\n",
      "Iteration  7\n",
      "Shape of training data:  (7127, 602)\n",
      "Shape of test data:  (792, 602)\n",
      "Iteration  8\n",
      "Shape of training data:  (7127, 608)\n",
      "Shape of test data:  (792, 608)\n",
      "Iteration  9\n",
      "Shape of training data:  (7127, 602)\n",
      "Shape of test data:  (792, 602)\n",
      "Iteration  10\n",
      "Shape of training data:  (7128, 634)\n",
      "Shape of test data:  (791, 634)\n",
      "List of cross-validation accuracies for SVC:  [0.8838383838383839, 0.88510101010101, 0.86489898989899, 0.9053030303030303, 0.8876262626262627, 0.875, 0.8901515151515151, 0.8825757575757576, 0.8825757575757576, 0.8925410872313527]\n",
      "Mean cross-validation accuracy for SVC:  0.884961179430206\n",
      "Best cross-validation accuracy for SVC:  0.9053030303030303\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing cross-validation for NBC...\n",
      "Iteration  1\n",
      "Shape of training data:  (7127, 603)\n",
      "Shape of test data:  (792, 603)\n",
      "Iteration  2\n",
      "Shape of training data:  (7127, 596)\n",
      "Shape of test data:  (792, 596)\n",
      "Iteration  3\n",
      "Shape of training data:  (7127, 603)\n",
      "Shape of test data:  (792, 603)\n",
      "Iteration  4\n",
      "Shape of training data:  (7127, 598)\n",
      "Shape of test data:  (792, 598)\n",
      "Iteration  5\n",
      "Shape of training data:  (7127, 605)\n",
      "Shape of test data:  (792, 605)\n",
      "Iteration  6\n",
      "Shape of training data:  (7127, 611)\n",
      "Shape of test data:  (792, 611)\n",
      "Iteration  7\n",
      "Shape of training data:  (7127, 602)\n",
      "Shape of test data:  (792, 602)\n",
      "Iteration  8\n",
      "Shape of training data:  (7127, 608)\n",
      "Shape of test data:  (792, 608)\n",
      "Iteration  9\n",
      "Shape of training data:  (7127, 602)\n",
      "Shape of test data:  (792, 602)\n",
      "Iteration  10\n",
      "Shape of training data:  (7128, 634)\n",
      "Shape of test data:  (791, 634)\n",
      "List of cross-validation accuracies for NBC:  [0.8813131313131313, 0.8863636363636364, 0.8636363636363636, 0.8888888888888888, 0.8863636363636364, 0.8737373737373737, 0.875, 0.8901515151515151, 0.8838383838383839, 0.8925410872313527]\n",
      "Mean cross-validation accuracy for NBC:  0.8821834016524281\n",
      "Best cross-validation accuracy for NBC:  0.8925410872313527\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of tfidf matrix for saved SVC Model:  (7919, 681)\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}