Train_Combine_Test_imdb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Importing needed libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib as plt\n",
    "import string\n",
    "import nltk\n",
    "import re\n",
    "import unicodedata\n",
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from nltk.stem import WordNetLemmatizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package wordnet to\n",
      "[nltk_data]     /Users/nalindakulathunga/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('wordnet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames = ['amazon_cells_labelled.txt', 'imdb_train.txt', 'yelp_labelled.txt']\n",
    "with open('combined_reviews_ALL_IMDB.txt', 'w') as outfile:\n",
    "    for fname in filenames:\n",
    "        with open(fname) as infile:\n",
    "            outfile.write(infile.read())\n",
    "            \n",
    "Combined_DF = pd.read_csv(\"combined_reviews_ALL_IMDB.txt\", sep='\\t', names = [\"Review\", \"Label\"])\n",
    "Combined_DF = Combined_DF.sample(frac=1).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                              Review  Label\n",
      "0                   Lasted one day and then blew up.      0\n",
      "1                  The food came out at a good pace.      1\n",
      "2  I give Wirefly 1 star.I will contact Cingular/...      0\n",
      "3                              bad fit, way too big.      0\n",
      "4  The good cinematography also makes her and Mon...      1\n",
      "5  Good value, works fine - power via USB, car, o...      1\n",
      "6  I've bought $5 wired headphones that sound bet...      0\n",
      "7  First off the reception sucks, I have never ha...      0\n",
      "8                   Protects the phone on all sides.      1\n",
      "9                         This case seems well made.      1\n"
     ]
    }
   ],
   "source": [
    "print Combined_DF.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "Combined_Df_RW = Combined_DF.drop('Label', axis=1)\n",
    "Combined_Df_LB = Combined_DF[\"Label\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "___________ Reviews _____________\n",
      "\n",
      "                                              Review\n",
      "0                   Lasted one day and then blew up.\n",
      "1                  The food came out at a good pace.\n",
      "2  I give Wirefly 1 star.I will contact Cingular/...\n",
      "3                              bad fit, way too big.\n",
      "4  The good cinematography also makes her and Mon...\n",
      "5  Good value, works fine - power via USB, car, o...\n",
      "6  I've bought $5 wired headphones that sound bet...\n",
      "7  First off the reception sucks, I have never ha...\n",
      "8                   Protects the phone on all sides.\n",
      "9                         This case seems well made.\n",
      "\n",
      "___________ Labels _____________\n",
      "\n",
      "0    0\n",
      "1    1\n",
      "2    0\n",
      "3    0\n",
      "4    1\n",
      "5    1\n",
      "6    0\n",
      "7    0\n",
      "8    1\n",
      "9    1\n",
      "Name: Label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print \"\\n___________ Reviews _____________\\n\"\n",
    "print Combined_Df_RW.head(10)\n",
    "print \"\\n___________ Labels _____________\\n\"\n",
    "print Combined_Df_LB.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Spliting data in to training and testing sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "Imdb_test_DF = pd.read_csv(\"imdb_test.txt\", sep='\\t', names = [\"Review\", \"Label\"])\n",
    "Imdb_test_Df_RW = Imdb_test_DF.drop('Label', axis=1)\n",
    "Imdb_test_Df_LB = Imdb_test_DF[\"Label\"]\n",
    "\n",
    "X_train = Combined_Df_RW\n",
    "X_test  = Imdb_test_Df_RW\n",
    "y_train = Combined_Df_LB\n",
    "y_test  = Imdb_test_Df_LB\n",
    "\n",
    "#X_train, X_test, y_train, y_test = train_test_split(Combined_Df_RW, Combined_Df_LB, test_size=0.33, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "___________ Training Reviews _____________\n",
      "\n",
      "                                              Review\n",
      "0                   Lasted one day and then blew up.\n",
      "1                  The food came out at a good pace.\n",
      "2  I give Wirefly 1 star.I will contact Cingular/...\n",
      "3                              bad fit, way too big.\n",
      "4  The good cinematography also makes her and Mon...\n",
      "\n",
      "___________ Training Labels _____________\n",
      "\n",
      "0    0\n",
      "1    1\n",
      "2    0\n",
      "3    0\n",
      "4    1\n",
      "Name: Label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print \"\\n___________ Training Reviews _____________\\n\"\n",
    "print X_train.head()\n",
    "print \"\\n___________ Training Labels _____________\\n\"\n",
    "print y_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "___________ Testing Reviews _____________\n",
      "\n",
      "                                              Review\n",
      "0  The entire audience applauded at the conclusio...\n",
      "1  I left the theater with a lilt in my step, joy...\n",
      "2  Duris has a wholesome appearance and gives a f...\n",
      "3             The rest of the cast also play well.  \n",
      "4  Cinematography noteworthy including fine views...\n",
      "\n",
      "___________ Testing Labels _____________\n",
      "\n",
      "0    1\n",
      "1    1\n",
      "2    1\n",
      "3    1\n",
      "4    1\n",
      "Name: Label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print \"\\n___________ Testing Reviews _____________\\n\"\n",
    "print X_test.head()\n",
    "print \"\\n___________ Testing Labels _____________\\n\"\n",
    "print y_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training data length:\n",
      "2302\n",
      "\n",
      "Testing data length:\n",
      "446\n"
     ]
    }
   ],
   "source": [
    "print \"\\nTraining data length:\"\n",
    "print len(X_train)\n",
    "print \"\\nTesting data length:\"\n",
    "print len(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Naive Guesser: (assuming all labels to be positive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of the naively assumed list:\n",
      "446\n"
     ]
    }
   ],
   "source": [
    "Y_pred_all_Pos = []\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    Y_pred_all_Pos.append(1)\n",
    "\n",
    "print \"length of the naively assumed list:\"\n",
    "print len(Y_pred_all_Pos)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy with Naive guesser:\n",
      "0.5672645739910314\n"
     ]
    }
   ],
   "source": [
    "print \"Accuracy with Naive guesser:\"\n",
    "print np.mean(Y_pred_all_Pos == y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          P       0.00      0.00      0.00       193\n",
      "          N       0.57      1.00      0.72       253\n",
      "\n",
      "avg / total       0.32      0.57      0.41       446\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nalindakulathunga/anaconda2/lib/python2.7/site-packages/sklearn/metrics/classification.py:1113: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "print(metrics.classification_report(y_test, Y_pred_all_Pos, target_names=\"PN\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Functions prepare words for lemmatizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def strip_accents(text):\n",
    "    \"\"\"\n",
    "    Remove accents from input String.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        text = unicode(text, 'utf-8')\n",
    "    except (TypeError, NameError): # unicode is a default on python 3 \n",
    "        pass\n",
    "    text = unicodedata.normalize('NFD', text)\n",
    "    text = text.encode('ascii', 'ignore')\n",
    "    text = text.decode(\"utf-8\")\n",
    "    return str(text)\n",
    "\n",
    "def text_to_id(text):\n",
    "    \"\"\"\n",
    "    Convert input text to id.\n",
    "    \"\"\"\n",
    "    text = strip_accents(text.lower())\n",
    "    text = re.sub('[ ]+', '_', text)\n",
    "    text = re.sub('[^0-9a-zA-Z_-]', '', text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Pre-Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PreProcess(InList = []):\n",
    "    \"\"\"\n",
    "    This function gets an input list and remove punctuations, convers charactors to lower case and laso look for \n",
    "    any empty strings if available. Then it lemmatize the words. Returns a list with lemmatized sentences. \n",
    "    \"\"\"\n",
    "    X_List_nopunc = [''.join(c for c in s if c not in string.punctuation) for s in InList]\n",
    "    X_List_nopunc_noempty = [s for s in X_List_nopunc if s]\n",
    "    X_List_nopunc_noempty_nocaps = [x.lower() for x in X_List_nopunc_noempty]\n",
    "    \n",
    "    sent_list = []\n",
    "\n",
    "    count = 0\n",
    "    for item in range(len(InList)):\n",
    "        count += 1\n",
    "        word_string = \"\"\n",
    "        for word in X_List_nopunc_noempty_nocaps[item][:].split(): \n",
    "            word_str = text_to_id(word)\n",
    "            new_word = WordNetLemmatizer().lemmatize(word_str, 'v')\n",
    "            word_string += str(new_word) + \" \"\n",
    "        if word_string != \"\":\n",
    "            sent_list.append(word_string)\n",
    "    \n",
    "    return sent_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_List = X_train[\"Review\"].tolist()\n",
    "X_train_List_cleaned = PreProcess(X_train_List)\n",
    "\n",
    "X_test_List = X_test[\"Review\"].tolist()\n",
    "X_test_List_cleaned = PreProcess(X_test_List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Making a pipeline for the process with Multinomial Naive Bayes classifier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "text_clf_optimized = Pipeline([('vect_opt', CountVectorizer(stop_words='english')),\n",
    "                     ('tfidf_opt', TfidfTransformer()),\n",
    "                     ('clf_opt', MultinomialNB(alpha=0.6))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nalindakulathunga/anaconda2/lib/python2.7/site-packages/sklearn/feature_extraction/text.py:1059: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  if hasattr(X, 'dtype') and np.issubdtype(X.dtype, np.float):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vect_opt', CountVectorizer(analyzer=u'word', binary=False, decode_error=u'strict',\n",
       "        dtype=<type 'numpy.int64'>, encoding=u'utf-8', input=u'content',\n",
       "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "        ngram_range=(1, 1), preprocessor=None, stop_words='english',\n",
       " ...e,\n",
       "         use_idf=True)), ('clf_opt', MultinomialNB(alpha=0.6, class_prior=None, fit_prior=True))])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text_clf_optimized.fit(X_train_List_cleaned, y_train) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy (Trained on all and tested on Imdb):\n",
      "0.7466367713004485\n"
     ]
    }
   ],
   "source": [
    "predicted_opt = text_clf_optimized.predict(X_test_List_cleaned)\n",
    "print \"Accuracy (Trained on all and tested on Imdb):\"\n",
    "print np.mean(predicted_opt == y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          P       0.66      0.86      0.75       193\n",
      "          N       0.86      0.66      0.75       253\n",
      "\n",
      "avg / total       0.77      0.75      0.75       446\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(y_test, predicted_opt, target_names=\"PN\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Confusion metrix plotting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as pltpy\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=pltpy.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    pltpy.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    pltpy.title(title)\n",
    "    pltpy.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    pltpy.xticks(tick_marks, classes, rotation=45)\n",
    "    pltpy.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        pltpy.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    pltpy.tight_layout()\n",
    "    pltpy.ylabel('True label')\n",
    "    pltpy.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Confusion matrix for MultinomialNB:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[166  27]\n",
      " [ 86 167]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10cb54490>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# Compute confusion matrix\n",
    "cnf_matrix_NB = confusion_matrix(y_test, predicted_opt)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "pltpy.figure()\n",
    "plot_confusion_matrix(cnf_matrix_NB, classes=\"NP\",\n",
    "                      title='Confusion matrix - Trained on all and tested on Imdb')\n",
    "pltpy.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}