Movie Rating Prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CREATING CLEAN DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Tokenization using regular expression\n",
    "from nltk.tokenize import RegexpTokenizer\n",
    "tokenizer = RegexpTokenizer(r\"\\w+\")\n",
    "\n",
    "#Stopword Removal\n",
    "from nltk.corpus import stopwords\n",
    "st= set(stopwords.words('english'))\n",
    "\n",
    "#Stemming\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "ss = SnowballStemmer('english')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_stem_data(review):\n",
    "    review=review.lower()\n",
    "    review=review.replace(\"<br /><br />\",\" \")\n",
    "    \n",
    "    #Tokenize\n",
    "    tokens = tokenizer.tokenize(review)\n",
    "    n_token = [w for w in tokens if w not in st]\n",
    "    stemm_token= [ss.stem(token) for token in n_token]\n",
    "    \n",
    "    cleaned_review=' '.join(stemm_token)\n",
    "    return cleaned_review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "out = open('Cleaned_file.txt','w',encoding=\"utf8\")\n",
    "\n",
    "with open(\"imdb_trainX.txt\",encoding=\"ISO-8859-1\") as f:\n",
    "    reviews = f.readlines()\n",
    "\n",
    "for review in reviews:\n",
    "    cleaned_review = get_stem_data(review)\n",
    "    print((cleaned_review),file=out)\n",
    "\n",
    "out.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# From scratch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Buiding Multinomial Naive Bayes Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Creating A dictionary to store word count\n",
    "from nltk.tokenize import word_tokenize\n",
    "def dic_rating(x):\n",
    "    a={}\n",
    "    for i in range(len(x)):\n",
    "        for j in word_tokenize(x[i]):\n",
    "            try:\n",
    "                a[j]+=1\n",
    "            except:\n",
    "                a[j]=1\n",
    "    return a\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def prior_prob(y_train,rating):\n",
    "    total_example=len(y_train)\n",
    "    class_example = np.sum(y_train==rating)\n",
    "    \n",
    "    return float((class_example)/(total_example))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cond_prob(x_train,y_train,word,rating):\n",
    "    x_filter= x_train[y_train==rating]\n",
    "    \n",
    "    a=dic_rating(x_filter)\n",
    "    try:\n",
    "        numerator = a[word] + 1\n",
    "    except:\n",
    "        numerator = 1 \n",
    "    s=0\n",
    "    for i in a:\n",
    "        s+=a[i]\n",
    "    denominator = s+ len(a)\n",
    "    return  float(numerator/(denominator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def predict(x_train,y_train,x_test):\n",
    "    \n",
    "    post_prob=[]\n",
    "    \n",
    "    \n",
    "    for rating in np.unique(y_train):\n",
    "        likehood=1\n",
    "        \n",
    "        for word in word_tokenize(x_test):\n",
    "            cond= cond_prob(x_train,y_train,word,rating)\n",
    "            likehood*=cond\n",
    "       \n",
    "        prior= prior_prob(y_train,rating)\n",
    "        prob= float(likehood*prior)\n",
    "        post_prob.append(prob)\n",
    "     \n",
    "    pred = np.argmax(post_prob)\n",
    "    return pred\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating training and test dataset in numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(\"Cleaned_file.text\",encoding=\"ISO-8859-1\") as f:\n",
    "    reviews = f.readlines()\n",
    "x_train=[]\n",
    "for review in reviews:\n",
    "    x_train.append(review)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(\"imdb_trainY.txt\",encoding=\"utf8\") as m:\n",
    "    ratings= m.readlines()\n",
    "y_train=[]\n",
    "for rating in ratings:\n",
    "    y_train.append(int(rating))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_train=np.array(y_train)\n",
    "x_train=np.array(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_test=[]\n",
    "with open(\"imdb_testX.txt\",encoding=\"ISO-8859-1\") as b:\n",
    "    reviews = b.readlines()\n",
    "\n",
    "for review in reviews:\n",
    "    x_test.append(get_stem_data(review))\n",
    "\n",
    "y_test=[]\n",
    "with open(\"imdb_testY.txt\",encoding=\"ISO-8859-1\") as h:\n",
    "    reviews = h.readlines()\n",
    "\n",
    "for rating in ratings:\n",
    "    y_test.append(int(rating))\n",
    "y_test=np.array(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in x_test:\n",
    "    predicted_array=[]\n",
    "    predicted_array.append(predict(x_train,y_train,str(i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Sklearn "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cv = CountVectorizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_vec = cv.fit_transform(x_train[:5000]).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB,BernoulliNB, GaussianNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mb = MultinomialNB()\n",
    "mb.fit(x_vec,y_train[:5000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "xt_vec = cv.transform(x_test[:5000]).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.33000000000000002"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mb.score(xt_vec,y_test[:5000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multivariate Bernoulli Event Model Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "bnb = BernoulliNB(binarize=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 10  7 ..., 10 10 10]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "bnb.fit(x_vec,y_train[:5000])\n",
    "y_predict=bnb.predict(xt_vec)\n",
    "print(y_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.35299999999999998"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bnb.score(xt_vec,y_test[:5000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10,  7, ..., 10, 10, 10])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bnb.predict(xt_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cnf_matrix = confusion_matrix(y_train[:5000],y_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  89  158   13  734]\n",
      " [  96  136   13  932]\n",
      " [  63  112    6  674]\n",
      " [ 160  261   19 1534]]\n"
     ]
    }
   ],
   "source": [
    "print(cnf_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}