Work.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import all the packages\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import os\n",
    "import glob\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the current working directory\n",
    "working_dir=os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the negative reviews in a list\n",
    "path_neg = working_dir+'/review_polarity/txt_sentoken/neg' # use your path\n",
    "allFiles_neg = glob.glob(path_neg + \"/*.txt\")\n",
    "list_final_neg = []\n",
    "for file in allFiles_neg:\n",
    "    temp_neg=pd.read_table(file, header=None)\n",
    "    list_neg=[]\n",
    "    for r in temp_neg[0]:\n",
    "        list_neg.append(r)\n",
    "    list_neg=''.join(list_neg)\n",
    "    list_final_neg.append(list_neg)   \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the positive reviews in a list\n",
    "path_pos = working_dir+'/review_polarity/txt_sentoken/pos' # use your path\n",
    "allFiles_pos = glob.glob(path_pos + \"/*.txt\")\n",
    "list_final_pos = []\n",
    "for file in allFiles_pos:\n",
    "    temp_pos=pd.read_table(file, header=None)\n",
    "    list_pos=[]\n",
    "    for r in temp_pos[0]:\n",
    "        list_pos.append(r)\n",
    "    list_pos=''.join(list_pos)\n",
    "    list_final_pos.append(list_pos)   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Join the two lists\n",
    "list_final = list_final_neg + list_final_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Dataframe\n",
    "df_final=pd.DataFrame(list_final, columns=['Comments'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list, containing the positive (1) or negative (0) comment\n",
    "temp_list_neg=[]\n",
    "temp_list_pos=[]\n",
    "for i in range(0,1000):\n",
    "    temp_list_neg.append(0)\n",
    "    temp_list_pos.append(1)\n",
    "temp_list= temp_list_neg + temp_list_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a 'Reviews' column containg the values 0,1\n",
    "df_final['Reviews']=temp_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the values of X and y\n",
    "X=df_final['Comments']\n",
    "y=df_final['Reviews']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into training set and test set\n",
    "X_train,X_test,y_train,y_test= train_test_split(X,y,test_size=0.2,random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Term Frequency- Inverse Document Frequency (TFIDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fitting and transforming tdidf \n",
    "vect= TfidfVectorizer(ngram_range=(1,2),stop_words='english',max_features=10000)\n",
    "X_train_dtm= vect.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform testing data (using fitted vocabulary)\n",
    "X_test_dtm = vect.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Support Vector Machine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit the SVM model (tuned)\n",
    "svc = svm.SVC(kernel='linear', C=10).fit(X_train_dtm, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict for test set\n",
    "y_pred= svc.predict(X_test_dtm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.86      0.84      0.85       200\n",
      "          1       0.84      0.86      0.85       200\n",
      "\n",
      "avg / total       0.85      0.85      0.85       400\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Precision and Recall \n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from tf_utils import random_mini_batches, convert_to_one_hot, predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creare two dataframes containing tfidf values\n",
    "df_train=pd.DataFrame(X_train_dtm.toarray(), columns=vect.get_feature_names())\n",
    "df_test=pd.DataFrame(X_test_dtm.toarray(), columns=vect.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ajaysingh/Desktop/untitled folder/tf_utils.py:64: FutureWarning: reshape is deprecated and will raise in a subsequent release. Please use .values.reshape(...) instead\n",
      "  Y = np.eye(C)[Y.reshape(-1)].T\n"
     ]
    }
   ],
   "source": [
    "# Manipulate the sets for Tensorflow\n",
    "y_train=convert_to_one_hot(y_train, 2)\n",
    "y_test=convert_to_one_hot(y_test, 2)\n",
    "X_train=df_train.T\n",
    "X_test= df_test.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert into array for Tensorflow requirement\n",
    "X_train=X_train.values\n",
    "X_test=X_test.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create_placeholders\n",
    "\n",
    "def create_placeholders(n_x, n_y):\n",
    "\n",
    "\n",
    "    X = tf.placeholder(tf.float32,[n_x, None])\n",
    "    Y = tf.placeholder(tf.float32,[n_y, None])\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize_parameters\n",
    "\n",
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [60, 10000]\n",
    "                        b1 : [60, 1]\n",
    "                        W2 : [20, 60]\n",
    "                        b2 : [20, 1]\n",
    "                        W3 : [2, 20]\n",
    "                        b3 : [2, 1]\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, b1, W2, b2, W3, b3\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)                  \n",
    "        \n",
    "   \n",
    "    W1 = tf.get_variable('W1',[60, 10000], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b1 = tf.get_variable('b1',[60,1], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    W2 = tf.get_variable('W2',[20,60], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b2 = tf.get_variable('b2',[20,1], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    W3 = tf.get_variable('W3',[2,20], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b3 = tf.get_variable('b3',[2,1], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "   \n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forward_propagation\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Z3 -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "               \n",
    "    Z1 = tf.matmul(W1,X)+b1                                              # Z1 = np.dot(W1, X) + b1\n",
    "    A1 = tf.nn.relu(Z1)                                # A1 = relu(Z1)\n",
    "    Z2 = tf.matmul(W2,A1)+b2                                             # Z2 = np.dot(W2, a1) + b2\n",
    "    A2 = tf.nn.relu(Z2)                                              # A2 = relu(Z2)\n",
    "    Z3 = tf.matmul(W3,A2)+b3                                            # Z3 = np.dot(W3,Z2) + b3\n",
    "   \n",
    "    \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute_cost \n",
    "\n",
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\n",
    "    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
    "    Y -- \"true\" labels vector placeholder, same shape as Z3\n",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "    \n",
    "    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    \n",
    "   \n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits, labels = labels))\n",
    "  \n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.001,\n",
    "          num_epochs = 40, minibatch_size = 12, print_cost = True):\n",
    "    \n",
    "    \n",
    "    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "    tf.set_random_seed(1)                             # to keep consistent results\n",
    "    seed = 3                                          # to keep consistent results\n",
    "    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)\n",
    "    n_y = Y_train.shape[0]                            # n_y : output size\n",
    "    costs = []                                        # To keep track of the cost\n",
    "    \n",
    "    # Create Placeholders of shape (n_x, n_y)\n",
    " \n",
    "    X, Y = create_placeholders(n_x, n_y)\n",
    "\n",
    "\n",
    "    # Initialize parameters\n",
    "\n",
    "    parameters = initialize_parameters()\n",
    "\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "    \n",
    "    # Initialize all the variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # Start the session to compute the tensorflow graph\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Run the initialization\n",
    "        sess.run(init)\n",
    "        \n",
    "        # Do the training loop\n",
    "        for epoch in range(num_epochs):\n",
    "\n",
    "            epoch_cost = 0.                       # Defines a cost related to an epoch\n",
    "            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "            seed = seed + 1\n",
    "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "            for minibatch in minibatches:\n",
    "\n",
    "                # Select a minibatch\n",
    "                (minibatch_X, minibatch_Y) = minibatch\n",
    "                \n",
    "                # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                # Run the session to execute the \"optimizer\" and the \"cost\", the feedict should contain a minibatch for (X,Y).\n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "                \n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                costs.append(epoch_cost)\n",
    "                \n",
    "        # plot the cost\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "        # lets save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print(\"Parameters have been trained!\")\n",
    "\n",
    "        # Calculate the correct predictions\n",
    "        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))\n",
    "\n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "        print(\"Train Accuracy:\", accuracy.eval({X: X_train, Y: y_train}))\n",
    "        print(\"Test Accuracy:\", accuracy.eval({X: X_test, Y: y_test}))\n",
    "        \n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-23-20e391a93aa1>:20: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See tf.nn.softmax_cross_entropy_with_logits_v2.\n",
      "\n",
      "Cost after epoch 0: 0.656622\n",
      "Cost after epoch 5: 0.001392\n",
      "Cost after epoch 10: 0.000221\n",
      "Cost after epoch 15: 0.000084\n",
      "Cost after epoch 20: 0.000041\n",
      "Cost after epoch 25: 0.000023\n",
      "Cost after epoch 30: 0.000013\n",
      "Cost after epoch 35: 0.000008\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a2d170278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "Train Accuracy: 1.0\n",
      "Test Accuracy: 0.865\n"
     ]
    }
   ],
   "source": [
    "# Neural Network Predictions\n",
    "parameters = model(X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SUPPORT VECTOR MACHINE ACCURACY - 85% "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NEURAL NETWORK ACCURACY        - 86.5% "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# END"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}