program_XGB_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing the dependencies\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import itertools\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import time\n",
    "import xgboost\n",
    "from xgboost import XGBClassifier\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to plot confusion matrix\n",
    "# this function is from sklearn website\n",
    "# link - http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.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",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.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",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using unigram features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finding the unigram representation\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "vectorizer=CountVectorizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading the cleaned training tweets\n",
    "with open('sentiments/SentimentText_train.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fitting the vectorizer\n",
    "X=vectorizer.fit_transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# getting the target values i.e wheather the tweets are positive or negative\n",
    "train_data = pd.read_csv('data/train.csv', encoding = 'ISO-8859-1')\n",
    "y = train_data['Sentiment']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking the shape of the output variable\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 41679)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking the shape of the input matrix -- this is feed into the classifier for training\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# splitting into training and testing set so as to evaluate our classifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train ,y_test = train_test_split(X,y,train_size = .8 , test_size = .2 , random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "values_max_depth = []\n",
    "while i<=10:\n",
    "    model = XGBClassifier(max_depth = i)\n",
    "    model.fit(X_train, y_train)\n",
    "    values_max_depth.append(model.score(X_test, y_test))\n",
    "    i = i +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6501650165016502, 0.6767676767676768, 0.6972197219721972, 0.7073207320732073, 0.7151215121512151, 0.7187718771877187, 0.7229222922292229, 0.7287228722872288, 0.7336733673367337, 0.7356235623562356]\n"
     ]
    }
   ],
   "source": [
    "print(values_max_depth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "values_subsample = []\n",
    "while i<=10:\n",
    "    model = XGBClassifier(subsample = i/10)\n",
    "    model.fit(X_train, y_train)\n",
    "    values_subsample.append(model.score(X_test, y_test))\n",
    "    i = i +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.7015201520152016, 0.6974197419741974, 0.6992199219921992, 0.6965696569656966, 0.6983698369836984, 0.6972197219721972]\n"
     ]
    }
   ],
   "source": [
    "print(values_subsample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "values_colsample_bytree = []\n",
    "while i<=10:\n",
    "    model = XGBClassifier(colsample_bytree = i/10)\n",
    "    model.fit(X_train, y_train)\n",
    "    values_colsample_bytree.append(model.score(X_test, y_test))\n",
    "    i = i +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6925692569256926, 0.6956695669566957, 0.6966196619661966, 0.6953195319531953, 0.696019601960196, 0.6972197219721972]\n"
     ]
    }
   ],
   "source": [
    "print(values_colsample_bytree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = XGBClassifier(seed = 0,verbose =1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "curr_time = time.time()\n",
    "\n",
    "max_depth = [7,8,9,10]\n",
    "subsample = [0.7,.8,.9]\n",
    "colsample_bytree = [.5,.6,.7]\n",
    "n_estimators= [500,1000,1500,2000]\n",
    "param_grid = {'max_depth': max_depth, 'subsample' :subsample, 'colsample_bytree' : colsample_bytree,'n_estimators' :n_estimators  }\n",
    "\n",
    "grid_search = GridSearchCV(model, param_grid, cv=2, n_jobs = 4)\n",
    "grid_search.fit(X_train, y_train)\n",
    "grid_search.best_params_\n",
    "print(grid_search.best_params_)\n",
    "\n",
    "updated_time = time.time()\n",
    "time_taken = (updated_time - curr_time)/60\n",
    "print(\"time taken for the job: \",time_taken)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = XGBClassifier(seed = 0,colsample_bytree = .6, max_depth = 10, subsample=.7,n_estimators = 2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=10, min_child_weight=1, missing=None, n_estimators=2500,\n",
       "       n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n",
       "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=0, silent=True,\n",
       "       subsample=0.7)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X_test)\n",
    "# testing score\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"],\n",
    "                      title='Confusion matrix, without normalization')\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"], normalize=True,\n",
    "                      title='Normalized confusion matrix')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# finally loading the cleaned test tweets on which we have to do sentiment analysis and report to kaggle\n",
    "with open('sentiments/SentimentText_test.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test=vectorizer.transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 41679)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking the shape\n",
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "# predicting the sentiments using trained classifier\n",
    "predicted = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989,)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shape of the predicted \n",
    "predicted.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code generates output csv on the test set which is submitted to the kaggle for score evaluation\n",
    "\n",
    "output = pd.read_csv('data/test.csv', encoding = 'ISO-8859-1')\n",
    "output.drop(['SentimentText'],axis = 1)\n",
    "output['Sentiment'] = predicted\n",
    "output.to_csv('output.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using bigram features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Finding the bigram representation \n",
    "bigram_vectorizer=CountVectorizer(ngram_range=(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_train.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=bigram_vectorizer.fit_transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.read_csv('data/train.csv', encoding = 'ISO-8859-1')\n",
    "y = train_data['Sentiment']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 428766)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989,)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train ,y_test = train_test_split(X,y,train_size = .8 , test_size = .2 , random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = XGBClassifier(seed = 0,colsample_bytree = .6, max_depth = 10, subsample=.7,n_estimators = 2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=10, min_child_weight=1, missing=None, n_estimators=2500,\n",
       "       n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n",
       "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=0, silent=True,\n",
       "       subsample=0.7)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8907752122113738"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# training score\n",
    "model.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7772277227722773"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = model.predict(X_test)\n",
    "# testing score\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[6166 2616]\n",
      " [1839 9377]]\n",
      "Normalized confusion matrix\n",
      "[[0.7  0.3 ]\n",
      " [0.16 0.84]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14ce215c4a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVIAAAEmCAYAAAAwZhg4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3XecVNX9//HXexcUEQUVRSmKYgXsYKLJV42919hL7ImJxhpLLDGWny2aqjEkGjUmiiVGrGg0JGosEMUCiiKgAqJg0Nhpn98f9yzeXXZ3Bnd2Z2b3/eRxH8wtc+65M7ufPefcc89RRGBmZl9dTbkzYGZW7RxIzcxayIHUzKyFHEjNzFrIgdTMrIUcSM3MWsiB1JB0gaRb0utVJX0sqbbE55giabtSplnEOY+X9G66nhVakM7HktYoZd7KRdI4SVuXOx/tjQNpG0hB5F1JS+e2HSNpVBmz1aiIeCsiukXE/HLnpSUkdQauBnZI1/P+V00rvX9S6XJXepJulHRxoeMiYlBEjGqDLHUoDqRtpxNwUksTUcbfW2G9gC7AuHJnpBJI6lTuPLRn/oVsO1cCp0vq0dhOSVtIGi3pw/T/Frl9oyRdIulJ4FNgjbTtYkn/TlXPeyWtIOnPkv6X0uifS+OXkt5O+/4j6f+ayEd/SSGpk6TNU9p1y+eSpqTjaiSdJekNSe9Lul3S8rl0DpP0Ztp3TnMfjKSlJF2Vjv9Q0hOSlkr79kjV0Q/SNa+Xe98USadLejG9b7ikLpLWBiakwz6Q9Fj+uhp8rsek12tK+mdKZ5ak4bnjQtKa6XV3STdLmpnye27dHzZJR6S8/0zSbEmTJe3czHVPkfSjlP9PJF0vqZekByV9JOnvkpbLHX+HpBkpj/+SNChtPw44BDij7mchl/6Zkl4EPknf6cImFkkPSLoql/5wSTc0911ZEyLCSysvwBRgO+CvwMVp2zHAqPR6eWA2cBhZyfWgtL5C2j8KeAsYlPZ3TtsmAgOA7sB44LV0nk7AzcAfc3k4FFgh7TsNmAF0SfsuAG5Jr/sDAXRqcA1157w0rZ8MPA30BZYEfgfcmvYNBD4Gtkz7rgbmAds18flck9LuA9QCW6T3rQ18Amyfzn9GuuYlcp/rs0Dv9Bm+Anyvseto7LrSOY9Jr28FziErXHQBvpk7LoA10+ubgXuAZVKarwFHp31HAHOBY9N1HA9MB9TMz8XTZKXnPsB7wHPAxun6HwN+kjv+qHTeJYFfAGNz+24k/Ww1SH8s0A9YKv+zmF6vnM65DVkgngQsU+7fl2pcyp6BjrDwZSAdDHwIrEj9QHoY8GyD9zwFHJFejwIubLB/FHBObv0q4MHc+u75X7RG8jQb2DC9voDCgfS3wP1ATVp/Bdg2t3+VFEQ6AecDt+X2LQ3MoZFAmgLXZ3V5abDvPOD2BsdOA7bOfa6H5vZfAVzX2HU0dl3UD6Q3A8OAvo3kI4A1yYLjF8DA3L7v5r7HI4CJuX1d03tXbubn4pDc+l3Ab3PrJwJ/a+K9PVLa3dP6jTQeSI9q7Gcxt74P8DYwi9wfDy+Lt7hq34Yi4mXgPuCsBrt6A2822PYmWSmlztuNJPlu7vVnjax3q1uRdJqkV1K18AOyUmzPYvIt6bvA1sDBEbEgbV4NuDtVuT8gC6zzyUpXvfP5jYhPgKZu9vQkKwG+0ci+ep9LOvfb1P9cZuRef0rumhfTGYCAZ1NTwlFN5HUJ6n9XDb+nhfmJiE/Ty+byVNR3KKlW0mWpKeV/ZAGxLk/NaeznJu8+sj8QEyLiiQLHWhMcSNveT8iqfvlfvulkgSlvVbLSV52vPExXag89E9gfWC4iepCVjFXkey8C9oyID3O73gZ2jogeuaVLREwD3iGrTtal0ZWsWaExs4DPyZooGqr3uUhSSndaI8cW8kn6v2tu28p1LyJiRkQcGxG9yUqZ19a1izbI61zqf1cNv6fWcjCwJ1nNpjtZCRu+/A6b+vko9HNzCdkfwVUkHdTCPHZYDqRtLCImAsOBH+Y2PwCsLengdEPgALJ2xvtKdNplyNooZwKdJJ0PLFvoTZL6pbweHhGvNdh9HXCJpNXSsStK2jPtuxPYTdI3JS0BXEgTP2uplHkDcLWk3qnktbmkJYHbgV0lbausO9NpZFXrfy/W1WfnmUkW8A5N5ziKXPCWtJ+kvml1NlkAmt8gjfkpT5dIWiZd+6nALYubn69gGbJrf5/sj8H/a7D/XWCx+rpK2hI4Ejg8Lb+W1Kf5d1ljHEjL40KydkMAIuvjuBtZoHifrJq5W0TMKtH5RgIPkt0YeZOsBFioygewLVmp7U59eee+rjvRL4ERwMOSPiK7afK1dD3jgB8AfyErnc4GpjZzntOBl4DRwH+By8naYieQ3ST7NVlpcHdg94iYU+R1N3Qs8COyz3gQ9QPyUOAZSR+n6zopIiY3ksaJZKXbScAT6Rrb4k73zWTf3TSyG4tPN9h/PTAwNbX8rVBikpZNaZ4QEdNStf564I+p5G+LQanB2czMviKXSM3MWsiB1MyshRxIzcxayIHUzKyFPJBBATVdlo3aZVYsdzasEWut0r3cWbBGvDP1TWb/9/2S3vmvXXa1iHmfFTwuPps5MiJ2KuW5i+FAWkDtMiuywl6Xlzsb1oi/nLdjubNgjTh4t61KnmbM+4wl19m/4HGfj72mqKf1Ss2B1MyqgKCCR490IDWzyiegpqSTNpSUA6mZVYcKfuDKgdTMqoCr9mZmLecSqZlZC0gV3UZauWVlM7M81RReiklG2knSBEkTJTUcZL1uSvJ/SHo+zae1S6E0HUjNrDpIhZeCSaiWbI6wncnG/D1I0sAGh51LNsXNxsCBwLWF0nUgNbMqoFKVSDcjm1drUhrX9jaymQfygi8HPu9ONlNDs9xGamaVr/h+pD0ljcmtD4uIYbn1PtQf1HwqaUDynAvIBiw/kWwA9u0KndSB1MyqQNHdn2ZFxJDmE1pEw9HtDwJujIirJG0O/EnS4NzEj4twIDWz6lBTku5PU8lNzAj0ZdGq+9HATgAR8ZSkLmSztb7XZNZKkTMzs1YlStVGOhpYS9LqaWLGA8nm6Mp7i2y+MiStRzZd+MzmEnWJ1MyqQGn6kUbEPEknkE0IWQvcEBHjJF0IjImIEWSTUP5e0ilk1f4josDkdg6kZlYdSvRkU0Q8QDYFen7b+bnX44FvLE6aDqRmVh38rL2ZWQsU2eG+XBxIzaw6VPCz9g6kZlYFPIyemVnLuWpvZtYCdf1IK5QDqZlVgcoej9SB1Myqg0ukZmYt5DZSM7MWkO/am5m1mGocSM3MvjIBctXezKwFRONDMlcIB1IzqwJyidTMrKVq3EZqZtYyLpGambWE20jNzFpGbiM1M2s5t5GambWQS6RmZi3hNlIzs5ar5BJp5TY6mJklQtTU1BRcikpL2knSBEkTJZ3VyP6fSxqbltckfVAoTZdIzaw6lKBAKqkWuAbYHpgKjJY0Is1lD0BEnJI7/kRg40LpukRqZpVPWdW+0FKEzYCJETEpIuYAtwF7NnP8QcCthRJ1idTMqkKRgbKnpDG59WERMSy33gd4O7c+FfhaE+dbDVgdeKzQSR1Izazi1bWRFmFWRAxpNqlFRRPHHgjcGRHzC53UVXszqw4qYilsKtAvt94XmN7EsQdSRLUeXCJtN741qBcXHbgRtTXiz49P5jcPTai3/6f7b8g31l0RgKWWqKXnMkuyzkkjANh/89U4edd1AfjF/a9y+1Nvtm3m27knRz3ClT89kwXz57PXgd/hqO+fWm//Hbdcz+03/56a2lq6dl2acy/9FQPWzr6P66+5inuG30xNbS1nXHAFW2y1XTkuofxUsu5Po4G1JK0OTCMLlgcvcjppHWA54KliEnUgbQdqBJcevDH7//xx3pn9KQ+dsy0PvzCd1975aOExP7n9hYWvj95mAIP79QCgR9fOnLb7eux48aME8PC52zLyhel8+Onctr6Mdmn+/Plcdt5p/PbP99Br5T4cssfWbLXdLgsDJcDOe+7HfoceDcCoRx7g6ovP5pqb7+aN115l5L13cecjzzLz3Xf43iF78LdRz1NbW7nTEremUgTSiJgn6QRgJFAL3BAR4yRdCIyJiBHp0IOA2yKiqWp/Pa7atwMbr748k2d+zFuzPmHu/OBvo99mx416N3n8XkNX5e5ns/b2rQevzD/Hv8cHn87lw0/n8s/x7/GtwSu3VdbbvZfHjqFf/zXou+rqdF5iCXbcfV9GPXJ/vWO6LbPswtefffoJdXXUUY/cz46778sSSy5Jn1X706//Grw8dgwdlWpUcClGRDwQEWtHxICIuCRtOz8XRImICyJikT6mTXGJtB1YpcdSTP/vZwvX35n9GZusvnyjx/Zdviur9uzKE6++9+V7Z39a772r9FiqdTPcgbw34x16rdJ34XqvVXrz8vOLBsPhNw3jlj/8hrlz5/K7W+8FYOaM6ay/8dCFx6y0ch/em/FO62e6QvnJphKS9D1Jh6fXR0jqndv3B0kDy5e78mjs56up+shem/XjvuemsSAd0OgtzOJqM1aURj7LRr6wA75zHPc+/iInnfVT/vDrK7N3NvI9VHIwaU3F9CEt52dTdYE0Iq6LiJvT6hFA79y+Y/JPKHQU02d/Ru/lvyxFrrLcUsz44LNGj91zaN+F1XqA6R98Ru/lutZ/74eft15mO5iVVu7Nu+9MXbj+7jvTWbHXKk0ev+Me32bUw1nVf6VV+jDjnWkL9703Yxor9uq4zS4OpImk/pJelXSTpBcl3Smpq6RtJT0v6SVJN0haMh1/maTx6difpW0XSDpd0reBIcCf0zOxS0kaJWmIpOMlXZE77xGSfp1eHyrp2fSe36VHxqra2CmzWWOlbqzasyuda8VeQ/vx8AuLVgEH9OpGj65LMOaN9xduG/XyDLYe1IvuXTvTvWtnth7Ui1Evz2jL7LdrgzbclLcmT2LaW1OYO2cOI++9i62336XeMW9Onrjw9eOPjaRf/wEAbL39Loy89y7mfPEF096awluTJzF4o+a6SLZvpWojbQ3laCNdBzg6Ip6UdANwKvBdYNuIeE3SzcDx6f+9gXUjIiT1yCcSEXemu2+nR8QYqFftuZOs28IZaf0A4BJJ66XX34iIuZKuBQ4Bbs6nLek44DiAmm49S3z5pTd/QfDjv4zl1pP/j1qJW5+cwoTp/+OMPQYy9s3ZC4Pq3putyt9Gv13vvR98Opef3/cKD52zLQBX3zueD3zHvmQ6derEmRdeyfcP35sF8+ez5/6HMWDt9bj2qosZuMEmbL39Lgy/aRjPPDGKTp07s+yyPbjo6usAGLD2euyw697su91Qajt14qyLftZh79hDZTdrqC3bwyT1B/4VEaum9W2A84DaiNgybdsW+AGwP/AfYAxwP3BfRMyRdAHwcUT8TNIo6gfSheuSHgbOB14n6zs2IKX7Y+C9lKWlgFsj4oKm8tx5xQGxwl6Xl+gTsFJ66Lwdy50Fa8TBu23F+BefK2nUW3LltaLvIb8qeNykq3f5T4Enm1pFOUqkRUXu1N9rM2Bbsk6zJwDbLMZ5hpMF41eBu1OpVsBNEXH2YubZzMpINH5TtVKU42bTqpI2T68PAv4O9Je0Ztp2GPBPSd2A7hHxAHAysFEjaX0ELNPEef4K7JXOMTxtexT4tqSVACQtnwYmMLOKJmpqCi/lUo4S6SvAdyT9jqzafRLwNHCHpE5k1fDrgOWBeyR1IfuDdEojad0IXCfpM2Dz/I6ImC1pPDAwIp5N28ZLOhd4WFINMJesuu9nIs0qXCW3kZYjkC6IiO812PYoiw6e+g7Z2IH15NszI+Iu4K7c7q0bHLtbI+8fzpclVDOrBqrsqr2fbDKziicoa9W9kDYNpBExBRjcluc0s/bBgdTMrCVctTcza5ms+1PlRlIHUjOrAuV9lr4QB1IzqwpuIzUzawm3kZqZtYzbSM3MSqCC46gDqZlVB7eRmpm1ROmmY24VVTfViJl1PHXD6BVaikpL2knSBEkTJTU6U6ik/dPsHOMk/aVQmi6RmlkVKE0/0jS10DXA9sBUYLSkEfm53iStBZxNNpPG7LphN5vjEqmZVYUSlUg3AyZGxKSImAPcBuzZ4JhjgWsiYjZARLxHAQ6kZlb5RKkGdu4D5Ccum5q25a0NrC3pSUlPS9qpUKKu2ptZxVuMfqQ9JY3JrQ+LiGENkmqo4fRHnYC1yMY37gs8LmlwRHzQ1EkdSM2sKhQZSGcVmPxuKtAvt94XmN7IMU9HxFxgsqQJZIF1dFOJumpvZlWhRG2ko4G1JK0uaQmyiTVHNDjmb8C3snOqJ1lVf1JzibpEamaVT6XpkJ9mJz4BGAnUAjdExDhJFwJjImJE2rdDmvNtPvCjiHi/uXQdSM2s4qmEw+ilmYkfaLDt/NzrAE5NS1EcSM2sKlTwg00OpGZWHWoqOJI2GUglLdvcGyPif6XPjpnZolSiNtLW0lyJdBxZ/6p87uvWA1i1FfNlZlZPBcfRpgNpRPRrap+ZWVur+tGfJB0o6cfpdV9Jm7ZutszM6ivV6E+toWAglfQbss6ph6VNnwLXtWamzMzyBNRKBZdyKeau/RYRsYmk5wEi4r/piQAzs7ah6p+Oea6kGtKD/ZJWABa0aq7MzBqo4DhaVBvpNcBdwIqSfgo8AVzeqrkyM8sRWT/SQku5FCyRRsTNkv4DbJc27RcRL7dutszM6qvWfqR5tcBcsuq9R4wyszZV7rvyhRRz1/4c4FagN9nYfX+RdHZrZ8zMLK+qq/bAocCmEfEpgKRLgP8Al7ZmxszM8iq4QFpUIH2zwXGdKDDIqZlZKQmorcY2Ukk/J2sT/RQYJ2lkWt+B7M69mVnbqOJ+pHV35scB9+e2P9162TEza1wFx9FmBy25vi0zYmbWnGotkQIgaQBwCTAQ6FK3PSLWbsV8mZktVOltpMX0Cb0R+CPZtewM3A7c1op5MjNbhIpYyqWYQNo1IkYCRMQbEXEuaapSM7O2IFV/P9IvlDVOvCHpe8A0YKXWzZaZWX0V3ERaVIn0FKAb8EPgG8CxwFGtmSkzs4ZqalRwKYaknSRNkDRR0lmN7D9C0kxJY9NyTKE0ixm05Jn08iO+HNzZzKzNiNJU3SXVko1otz0wFRgtaUREjG9w6PCIOKHYdJvrkH83aQzSxkTEPsWexMysRUo3aMlmwMSImAQg6TZgT6BhIF0szZVIf9OShNuLDVZdjid/++1yZ8MasdzQogsM1oa+mDi1VdItsh9pT0ljcuvDImJYbr0P8HZufSrwtUbS2VfSlsBrwCkR8XYjxyzUXIf8Rwvn2cys9dXN2VSEWRExpEBSDTWsed8L3BoRX6Qb7DcB2zR3Uo8tamZVoUaFlyJMBfJTzfcFpucPiIj3I+KLtPp7oOCsyQ6kZlYVShRIRwNrSVo9TeJ5IDAif4CkVXKrewCvFEq02BHykbRkLkqbmbWZbIT8lt9tioh5kk4ARpLN/HFDRIyTdCEwJiJGAD+UtAcwD/gvcEShdIt51n4z4HqgO7CqpA2BYyLixK98NWZmi6m2RPXniHgAeKDBtvNzr88GFmsWkGKy9itgN+D9dJIX8COiZtaGqn4WUaAmIt5sUKye30r5MTNrVCXf0CkmkL6dqveRngo4kaxvlZlZm6nkZ+2LCaTHk1XvVwXeBf6etpmZtQlJFT0eaTHP2r9H1kXAzKxsKjiOFnXX/vc08sx9RBzXKjkyM2ug7mZTpSqmav/33OsuwN7Uf1bVzKzVVXAcLapqPzy/LulPwCOtliMzs4ZU9LP2ZVH0k005qwOrlTojZmZNyar25c5F04ppI53Nl22kNWSPTC0yqrSZWWuq2kCa5mrakGyeJoAFEdHkYM9mZq2lkue1b/ZhgRQ0746I+WlxEDWzNidlz9oXWsqlmFM/K2mTVs+JmVkzqvJZe0mdImIe8E3gWElvAJ+QtftGRDi4mlmbqOabTc8CmwB7tVFezMyaVMFNpM0GUgFExBttlBczs0YJVW0/0hUlndrUzoi4uhXyY2a2qOKnEimL5gJpLdCNxmfdMzNrU9X6rP07EXFhm+XEzKwJosrbSM3MKkG1jke6bZvlwsysGaKypxppMm8R8d+2zIiZWZPSdMyFlqKSknaSNEHSRElNjhsi6duSQtKQQmlWcpA3M1tIRSwF08jmnbsG2BkYCBwkaWAjxy0D/BB4ppi8OZCaWcUT2XikhZYibAZMjIhJETEHuA3Ys5HjLgKuAD4vJlEHUjOrClLhpQh9qD/Dx9S0LXcebQz0i4j7is3bVxnY2cysjRXdBtpT0pjc+rCIGFYvoUUtHNVOUg3wc+CIxcmdA6mZVbzFuGs/KyKauzk0FeiXW+8LTM+tLwMMBkalwL0yMELSHhGRD9D1OJCaWVUo0ZNNo4G1JK1ONmD9gcDBdTsj4kOgZ926pFHA6c0FUXAbqZlVgxJ1f0pDg54AjAReAW6PiHGSLpS0x1fNnkukZlbxStkhPyIeAB5osO38Jo7dupg0HUjNrCpU8pxNDqRmVhUqN4w6kJpZFajrkF+pHEjNrCpUcBx1IDWzaiBUwZV7B1IzqwoukZqZtYDkNlIzsxar4DjqJ5vai4dHPsQGg9Zh0LprcuUVly2y/4nH/8XmQzehW5dO/PWuO+vte+utt9ht5x3YaP312HiDgbw5ZUob5bpj2H6L9Xjh7vN4+Z6fcPqR2y+yv9/Ky/HQsB/y1K1n8uzws9nxmwMX2T/zyas4+bCOPWmFivhXLg6k7cD8+fM5+Yc/4J57H+T5F8dzx2238sr48fWO6ddvVYZdfyMHHHjwIu8/5sjDOeW0HzH2pVd4/N/PsuJKK7VV1tu9mhrxi7P2Z88TrmXjfS9mv502Zd01Vq53zJnH7MRdjzzH5gddzuFn/5Ffnn1Avf1XnL4vDz85ri2zXXFENh1zoaVcXLVvB0Y/+ywDBqzJ6musAcB+BxzIfffew3oDvyzZrNa/PwA1NfX/dr4yfjzz5s1j2+2yklK3bt3aJtMdxNDB/Xnj7VlMmfY+AHeMfI7dtt6AVyfNWHhMRLDs0l0A6N5tKd6Z+eHCfbtvvQGTp87ik8/mtG3GK1AlT8fsEmk7MH36NPr2/XJksD59+jJt2rSi3vv666/Ro0cPDthvH74+ZGPOPvNHzJ8/v7Wy2uH0Xqk7U9+dvXB92ruz6bNi93rHXPK7Bzhwl82Y+NBF3P3r4zn18jsA6NplCU47cnsu+V29x8I7LFftW4GkHpK+n1vvLenO5t7TXkXEItuKfS553rx5PPnE41x2+c944unRTJ48iT/ddGOJc9hxNfbL3fDb2n+nIdxy79OsudN57H3ib7n+4sORxHnH78qvb3nMpVFctW9NPYDvA9cCRMR04NtlzVGZ9OnTl6lTv5w9Ydq0qfTu3bvo92640cYLmwX22GMvnn3maeDo1shqhzPtvQ/o22u5het9ei3H9FzVHeA7e23Onj+4BoBnXpxMlyU607PH0gwdvBp7b7cRl5y8F92XWYoFC4LP58zluuH/atNrqAyV3SG/1UqkkvpLekXS7yWNk/SwpKUkDZD0kKT/SHpc0rrp+AGSnpY0Oo0N+HHa3k3So5Kek/SSpLqJqi4DBkgaK+nKdL6X03uekTQol5dRkjaVtLSkG9I5ns+lVdWGDB3KxImvM2XyZObMmcMdw29j192KG1pxyNChfDB7NjNnzgRg1D8eY931FplU0b6iMePeZM1VV2S13ivQuVMt++24CfePerHeMW/P+C9bb7YOAOus3osuS3Zm5uyP2e7oX7Durj9h3V1/wm/+PIorr3+4gwZRoIjSaDlLpK1dtV8LuCYiBgEfAPsCw4ATI2JT4HRSiRL4JfDLiBhK/aH/Pwf2johNgG8BVymrt54FvBERG0XEjxqc9zZgfwBJqwC9I+I/wDnAY+kc3wKulLR0w0xLOk7SGEljZs6aWYKPoXV16tSJn//yN+y+645stP567Lvf/gwcNIgLLzif++4dAcCY0aMZ0L8vf73rDk78/nfZZMPs70xtbS2XXvEzdtlhW4ZstD4RwVHHHFvOy2lX5s9fwCmX38691/6AsX89l7sefp5XJs3gvON3Zdet1gfgrKvv5qh9tuCZ4Wdx06VHcuz5fypzritPVrVXwaVs+Wusfa0kCUv9gUciYq20fibQmSyYTcgdumRErCfpfaBXRMyTtCwwPSK6SepMNhnVlsACYB1gdaALcF9EDM6d776IGCypTzr3QEknAStFxDlpUqwuwLx07uWBHSPilaauY9NNh8STzzQ7y4CVyXJDTyh3FqwRX0y4nQWfvlfSqLbe+hvHH+/+R8HjNl9ruf8UmLOpVbR2G+kXudfzgV7ABxGx0WKkcQiwIrBpRMyVNIUsGDYpIqZJel/SBsABwHfTLgH7RsSEpt9tZhWpcptI2/yu/f+AyZL2A1Bmw7TvabKqP2QTUtXpDryXgui3gNXS9o/IZvxrym3AGUD3iHgpbRsJnJiaBurmrzazKlDJVftydH86BDha0gvAOKDuhs/JwKmSngVWAepubf4ZGJKq5YcArwJExPvAk5JelnRlI+e5kywg357bdhFZ88KL6cbURSW9MjNrNSpiKZdWq9pHxBSy+aHr1n+W271TI2+ZBnw9IkLSgcCY9L5ZwOZNnKPh8475871Lg+uLiM/4sppvZtWkgqv2ldSPdFPgN6na/QFwVJnzY2YVIitxVm4krZgnmyLi8YjYMCI2iIgtI2JiufNkZhWihP1IJe0kaYKkiZLOamT/91Kf9bGSnpBUsGN1xQRSM7NmlaCRVFItcA2wMzAQOKiRQPmXiFg/9S66Ari6ULoOpGZWBYoZsqSoIulmwMSImBQRc8h699R7wjEi/pdbXZpFh0dYRCW1kZqZNanI3k09Uw+fOsMiYlhuvQ/wdm59KvC1Rc+lHwCnAksA2xQ6qQOpmVU8UXQgnVXgyabGUlmkxBkR1wDXSDoYOBf4TnMnddXezKpCiar2U4F+ufW+1B/bo6HbgL0KJepAamZVQSq8FGE0sJak1SUtQfbQzoj659FaudVdgdcLJeqqvZlVhVL0Ik2DIp1A9rh4LXBDRIyTdCGgRCpSAAANHUlEQVQwJiJGACdI2g6YC8ymQLUeHEjNrBqo+FkfComIB4AHGmw7P/f6pMVN04HUzCreYtxsKgsHUjOrChUcRx1IzaxKVHAkdSA1s6pQyfPaO5CaWVWo3DDqQGpm1aKCI6kDqZlVvEofj9SB1MwqX5nnrS/EgdTMqoMDqZlZSxQ9KElZOJCaWVWo4N5PDqRmVvn8iKiZWQm4am9m1kIukZqZtVAFx1EHUjOrAiUcj7Q1OJCaWcXzzSYzsxKo4DjqQGpm1cElUjOzFnIbqZlZC1VuGHUgNbMqsBjz1pdFTbkzYGZWDBXxr6h0pJ0kTZA0UdJZjew/VdJ4SS9KelTSaoXSdCA1s6pQVyptbimchmqBa4CdgYHAQZIGNjjseWBIRGwA3AlcUShdB1IzqwqlCKTAZsDEiJgUEXOA24A98wdExD8i4tO0+jTQt1CiDqRmVgWKqdgLoKekMbnluAYJ9QHezq1PTduacjTwYKHc+WaTmVW8xXiyaVZEDCmQVEPR6IHSocAQYKtCJ3UgNbOqUKK79lOBfrn1vsD0Rc+l7YBzgK0i4otCibpqb2ZVoUR37UcDa0laXdISwIHAiHrnkTYGfgfsERHvFZOoS6RmVvlK1I80IuZJOgEYCdQCN0TEOEkXAmMiYgRwJdANuCM9TfVWROzRXLoOpGZW8UTpnmyKiAeABxpsOz/3ervFTdOB1Myqgp+1NzNroQqOow6kZlYdKjiOOpCaWZWo4EjqQGpmFU9ATQXX7RXRaKd+SyTNBN4sdz5KpCcwq9yZsEa1p+9mtYhYsZQJSnqI7DMqZFZE7FTKcxfDgbQDkTSmwONzVib+bqqbn2wyM2shB1IzsxZyIO1YhpU7A9YkfzdVzG2kZmYt5BKpmVkLOZCambWQA6mZWQs5kFqTVMnD7ZhVEAdSW6gucErqK6kTsFSZs2QF+I9dZfBde6tH0m7AKcALwCfAtRHxTnlzZZAFzYiINA/70sCEiPhfufNlLpFajqT1gYuAQ8hKo0OAj13qqQwpiO4C3AnsD4yTtEGZs2U4kFp9SwJ3AIOAjYEfRMRHwGBJncuaM0PSqmS1hR3J5hz6CJiW2+8/eGXiqr0haTCwOXAf8DdgOWDLiJghaWfgKOC4iJhdxmx2aKnNujPwfbJJ2/YFDoqISZL2Bh4oZtpgax0ukXZwqRQzCFg3tYXeCTwK7CZpW+Ay4E8OouWTqu8XAQuArwFHAnunILpZ2rduGbPY4blE2oFJ6hwRcyX1B+4m+4UcCWxL9sv6DvBgRNxbd6OjbJntQBp+1pL6AP8CjiGryg8H7gWWAHYFfhwR95Yjr5ZxIO1AJPUDekTES5LWAQ4D/hIR4yVtk9bPjIj30vGd0jzgDqJtJP9Zp3bpeekm07eBjSPiHEkbARsCywLPR8QT/o7Ky1X7jmUboFZSF6Af8Dlwl6Sj0/pMYOW6gyNiXvrfv6BtQFIv4LeSOklaFxgBHJH+6P0b2EzSehExNiJuiohfR8QT4O+o3Fwi7QAalHKWA24BLk0lmW2AoWnZB3g0IrZ3CaftpRLo6sAXwHRgF2A94DtkN5mOBLoCh0bE5+XKpy3Kk9+1c5K6AmsCL0raEngJeAo4U9KCiHhM0j+A5YG3gfvBJZy2VNeEktqr3wYuAL4B7BwR90gaD+xH1pvi62RVegfSCuISaTuWSjjdgCuBOcBuwO4R8YKkM4GtgAuB5yJiTu7JGZdG20jq1nQA8CLZZJl7Ar8EfgpsBOwTEbMlrUBWGh0QEaPKlF1rgttI2ylJKwFHpG5Lj5DdSLo9Il4AiIjLgX+SdW8akg+eDqJtJ7VDTyL7ju4DbkuPfZ4NjAVul7RcRLwfEW9HxCh3vK88DqTt18rAqBRQPyZr/xws6fuSloeFwfR20p3h8mW1w5tM1qwyhy+nHP4COAOYANybSq6A/9BVIlft27FUtb+M7JfyImAd4OfAzWnbQcC+ETGnbJnsoHLNKJ0jYm7atjNwBXBuahtdg6wtdOmIeL2c+bXmuUTazuSGwhtE1mH7DrKbimcAb5E9q70V2R3gWxxE214uiO4J3CTpr5I2iIgHyf7gXS3pPLI/eMs7iFY+l0jbIUl7kAXOUyJitKSvk93QmA38HngX6J5uYvjGUhmk0udFZM/M/xpYHzgytYFuDxxO9oduZBmzaUVyIG1nUkn0VrK7vRPT3d4gGxbvPLIgenlEfFrGbHZYudLoj8luMPUGTgYeA34AfCciRuYe3/UfuirgQNpO5H5BtwF+DJwPbAd8E9iMbGzRZYHPIuKV8uW0Y5O0bkS8ml6vQvZwxPER8ZqkfwLLANt6kJjq4jbSKpfrCrNC+v8fwBiyvoiTyAYAvhoYGhHPOYi2vVy79VrAs5J+A5BG25oGfE3SN4DXyYKqg2iVcYm0HZC0E3AqMAOYAlwdER+kfV8DbgKOioh/ly2THVyawmV/skc/DwPuj4jjJB1DVmvYkmwg7QfLmE37ihxIq1xqE72H7C78MmRV+IHAaWR9Em8HTouI+8qWyQ5O0tJkj95elYYkXA54FrgjIn4sqZbsiaXXyppR+8r8rH0VanADYkngkYh4XFIN2aOGPyEb6PcfZAMAj/dNi/KJiE8kTSYrjZJ6S5xE9tQSEfFjwEG0irmNtAqlm0rfkHQY2biU+0naOSIWRMRUYB6wWlofX/eecua5I8m1ia4jqZ+kbmQl0D+nQWQg64r2c2BbSf9XpqxaibhEWkVyd+a/DvyWrPQ5A5gK/DQN3Dwe2IKsM7eVQfqOdgYuJ5u65SBgMNmULo9LepRsNKc9gS5kU4hYFXMgrSLpF3Qz4BLg2Ih4Jj1GOIts2LX9gTeBn0TEU2XMaocmaU2y5pW9yeZYWgB0jYgTUve0rsAfgF7A9mR/FK2KOZBWn+7A1mTzKj1D9tjnOLLuT2dGxAJYdN4fa10NPu/ZwJ+BTck62+8ZER9J2gF4OiL+l24SXknWAX9SeXJtpeJAWmUi4hFJ+wBXSZocEbdK+pAsuPaUNDOS8ua0Y0m1ha3IRrSfRDamQSeyu/FzU3PMWcCxwP/ImmN2jYj3y5VnKx13f6pSknYnK/U8CHwK3OUuTm0v1279NeAGsmHvXiF7JPdwsmaYecBRwAURcU/ZMmutxnftq1Rk0+8eCqwFvBQR9ykpc9Y6lFy79U+BgyJiH+BV4L9k0yYPAmqBM9LQeP5+2iFX7atYRIyQ9Dlwg6QpEfHXcuepg+pBNq7B9mQ9KW4lu/HXDXgtIn5Zd6CbXNonB9IqFxEPSzoSeKPceemo0newD3CppOmp3Xp42v1COfNmbcNtpGYlImkXsjFGfxURN5U7P9Z2HEjNSigNqn0ZWVV/Rl13NGvfHEjNSkzSihExs9z5sLbjQGpm1kLu/mRm1kIOpGZmLeRAambWQg6kZmYt5EBqRZE0X9JYSS9LuiM3QPFXSWtrSfel13tIOquZY3tI+v5XOMcFkk4vdnuDY26U9O3FOFd/SS8vbh6t/XAgtWJ9FhEbRcRgYA7wvfzO9Jj/Yv88RcSIiLismUN6AIsdSM3akgOpfRWPA2umktgrkq4FngP6SdpB0lOSnksl126QzXQq6VVJTwD71CUk6Yi66Ykl9ZJ0t6QX0rIFWef2Aak0fGU67keSRkt6UdJPc2mdI2mCpL8D6xS6CEnHpnRekHRXg1L2dpIel/RamgEUSbWSrsyd+7st/SCtfXAgtcUiqROwM/BS2rQOcHNEbAx8ApwLbBcRmwBjgFMldQF+D+wO/B+wchPJ/wr4Z0RsCGxCNmD1WcAbqTT8ozQ48lrAZsBGwKaStpS0KXAgsDFZoB5axOX8NSKGpvO9Ahyd29cf2ArYFbguXcPRwIcRMTSlf6yk1Ys4j7VzHrTEirWUpLHp9ePA9UBv4M2IeDpt/zrZVNBPptHilgCeIpvRdHJEvA4g6RbguEbOsQ3ZGJ5ExHzgQ2VTF+ftkJbn03o3ssC6DHB3RHyazjGiiGsaLOlisuaDbsDI3L7b0+Odr0ualK5hB2CDXPtp93RuzwDawTmQWrE+i4iN8htSsPwkv4lsauiDGhy3EVCqR+gEXBoRv2twjpO/wjluBPaKiBckHUE2y0CdhmlFOveJEZEPuEjqv5jntXbGVXsrpaeBb6TJ35DUVdLaZAMdry5pQDruoCbe/yhwfHpvraRlgY/ISpt1RgJH5dpe+0haCfgXsLekpSQtQ9aMUMgywDuSOgOHNNi3n6SalOc1yEa+Hwkcn45H0tqSli7iPNbOuURqJRMRM1PJ7lZJS6bN50bEa5KOA+6XNAt4gmx64oZOAoZJOhqYDxwfEU9JejJ1L3owtZOuBzyVSsQfA4dGxHNpDNCxZDOpPl5Els8jm0DwTbI233zAngD8k2ymz+9FxOeS/kDWdvpcGul+JrBXcZ+OtWcetMTMrIVctTczayEHUjOzFnIgNTNrIQdSM7MWciA1M2shB1IzsxZyIDUza6H/D7X8CH+oXT21AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14ce2235940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"],\n",
    "                      title='Confusion matrix, without normalization')\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"], normalize=True,\n",
    "                      title='Normalized confusion matrix')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_test.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test=bigram_vectorizer.transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 428766)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "predicted = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989,)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code generates output csv on the test set which is submitted to the kaggle for score evaluation\n",
    "\n",
    "output = pd.read_csv('data/test.csv', encoding = 'ISO-8859-1')\n",
    "output.drop(['SentimentText'],axis = 1)\n",
    "output['Sentiment'] = predicted\n",
    "output.to_csv('output2.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using both unigrams and bigrams features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finding the unigram representation\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "vectorizer=CountVectorizer()\n",
    "\n",
    "# #Finding the bigram representation \n",
    "bigram_vectorizer=CountVectorizer(ngram_range=(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_train.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_unigrams = vectorizer.fit_transform(SentimentText)\n",
    "X_bigrams = bigram_vectorizer.fit_transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 41679)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_unigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 428766)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_bigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import hstack \n",
    "X_combined = hstack([X_unigrams , X_bigrams])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 470445)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_combined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.read_csv('data/train.csv', encoding = 'ISO-8859-1')\n",
    "y = train_data['Sentiment']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train ,y_test = train_test_split(X_combined,y,train_size = .8 , test_size = .2 , random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = XGBClassifier(seed = 0,colsample_bytree = .6, max_depth = 10, subsample=.7,n_estimators = 2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=10, min_child_weight=1, missing=None, n_estimators=2500,\n",
       "       n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n",
       "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=0, silent=True,\n",
       "       subsample=0.7)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8978010026127939"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# training score\n",
    "model.score(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7787778777877787"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = model.predict(X_test)\n",
    "# testing score\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[6205 2577]\n",
      " [1847 9369]]\n",
      "Normalized confusion matrix\n",
      "[[0.71 0.29]\n",
      " [0.16 0.84]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14c819b97b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14ceccf6a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"],\n",
    "                      title='Confusion matrix, without normalization')\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"], normalize=True,\n",
    "                      title='Normalized confusion matrix')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_test.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_unigrams = vectorizer.transform(SentimentText)\n",
    "X_test_bigrams = bigram_vectorizer.transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 41679)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test_unigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 428766)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test_bigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import hstack \n",
    "X_test_combined = hstack([X_test_unigrams , X_test_bigrams])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 470445)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test_combined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "predicted = model.predict(X_test_combined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code generates output csv on the test set which is submitted to the kaggle for score evaluation\n",
    "\n",
    "output = pd.read_csv('data/test.csv', encoding = 'ISO-8859-1')\n",
    "output.drop(['SentimentText'],axis = 1)\n",
    "output['Sentiment'] = predicted\n",
    "output.to_csv('output3.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using unigrams bigrams and trigrams "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finding the unigram representation\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "vectorizer=CountVectorizer()\n",
    "\n",
    "# #Finding the bigram representation \n",
    "bigram_vectorizer=CountVectorizer(ngram_range=(1,2))\n",
    "\n",
    "# finding the trigram representation\n",
    "trigram_vectorizer =CountVectorizer(ngram_range=(1,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_train.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_unigrams = vectorizer.fit_transform(SentimentText)\n",
    "X_bigrams = bigram_vectorizer.fit_transform(SentimentText)\n",
    "X_trigrams = trigram_vectorizer.fit_transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 41679)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_unigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 428766)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_bigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 1178466)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_trigrams.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import hstack \n",
    "X_combined = hstack([X_unigrams , X_bigrams, X_trigrams])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989, 1648911)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_combined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.read_csv('data/train.csv', encoding = 'ISO-8859-1')\n",
    "y = train_data['Sentiment']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99989,)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train ,y_test = train_test_split(X_combined,y,train_size = .8 , test_size = .2 , random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = XGBClassifier(seed = 0,colsample_bytree = .6, max_depth = 10, subsample=.7,n_estimators = 2500,n_jobs=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=10, min_child_weight=1, missing=None, n_estimators=2500,\n",
       "       n_jobs=4, nthread=None, objective='binary:logistic', random_state=0,\n",
       "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=0, silent=True,\n",
       "       subsample=0.7)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8993636784138216"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#training score\n",
    "model.score(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7782778277827783"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#testing score\n",
    "model.score(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7782778277827783"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = model.predict(X_test)\n",
    "# testing score\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[6195 2587]\n",
      " [1847 9369]]\n",
      "Normalized confusion matrix\n",
      "[[0.71 0.29]\n",
      " [0.16 0.84]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14c87ad27b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x14c9e9de6a0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"],\n",
    "                      title='Confusion matrix, without normalization')\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=[\"positive\", \"negative\"], normalize=True,\n",
    "                      title='Normalized confusion matrix')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sentiments/SentimentText_test.txt', 'rb') as f:\n",
    "    SentimentText = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_unigrams = vectorizer.transform(SentimentText)\n",
    "X_test_bigrams = bigram_vectorizer.transform(SentimentText)\n",
    "X_test_trigrams = trigram_vectorizer.transform(SentimentText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import hstack \n",
    "X_test_combined = hstack([X_test_unigrams , X_test_bigrams,X_test_trigrams])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(299989, 1648911)"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test_combined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ADITYA\\Anaconda3\\envs\\ml\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "predicted = model.predict(X_test_combined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code generates output csv on the test set which is submitted to the kaggle for score evaluation\n",
    "\n",
    "output = pd.read_csv('data/test.csv', encoding = 'ISO-8859-1')\n",
    "output.drop(['SentimentText'],axis = 1)\n",
    "output['Sentiment'] = predicted\n",
    "output.to_csv('output4.csv', index = False)"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}