{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial - build LinearSVC model with sklearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial demonstrates how to use the Sci-kit Learn (sklearn) package to build linearSVC model, rank features, and use the model for prediction. We will be using the Kaggle sentiment data again.\n",
    "\n",
    "Note that sklearn actually provides two SVM algorithms: SVC and LinearSVC. \n",
    "\n",
    "The SVC module allows for choosing nonlinear kernels, and it uses one-vs-one strategy for multi-class classification.\n",
    "\n",
    "The LinearSVC module uses the linear kernel, and it uses one-vs-all strategy for multi-class classification, so linearSVC is generally faster than SVC. Since linear kernel works better for text classification in general, this tutorial demonstrates how to use LinearSVC for text classification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1: Read in data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# read in the training data\n",
    "# the data set includes four columns: PhraseId, SentenceId, Phrase, Sentiment\n",
    "# In this data set a sentence is further split into phrases \n",
    "# in order to build a sentiment classification model\n",
    "# that can not only predict sentiment of sentences but also shorter phrases\n",
    "\n",
    "# A data example:\n",
    "# PhraseId SentenceId Phrase Sentiment\n",
    "# 1 1 A series of escapades demonstrating the adage that what is good for the goose is also good for the gander , some of which occasionally amuses but none of which amounts to much of a story .1\n",
    "\n",
    "# the Phrase column includes the training examples\n",
    "# the Sentiment column includes the training labels\n",
    "# \"0\" for very negative\n",
    "# \"1\" for negative\n",
    "# \"2\" for neutral\n",
    "# \"3\" for positive\n",
    "# \"4\" for very positive\n",
    "\n",
    "\n",
    "import pandas as p\n",
    "train=p.read_csv(\"kaggle-sentiment/train.tsv\", delimiter='\\t')\n",
    "y=train['Sentiment'].values\n",
    "X=train['Phrase'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2: Split train/test data for hold-out test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(117045,) (117045,) (39015,) (39015,)\n",
      "illusion\n",
      "2\n",
      "escape movie\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# check the sklearn documentation for train_test_split\n",
    "# http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html\n",
    "# \"test_size\" : float, int, None, optional\n",
    "# If float, should be between 0.0 and 1.0 and represent the proportion of the dataset to include in the test split. \n",
    "# If int, represents the absolute number of test samples. \n",
    "# If None, the value is set to the complement of the train size. \n",
    "# By default, the value is set to 0.25. The default will change in version 0.21. It will remain 0.25 only if train_size is unspecified, otherwise it will complement the specified train_size.    \n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=None, random_state=0)\n",
    "\n",
    "print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)\n",
    "print(X_train[0])\n",
    "print(y_train[0])\n",
    "print(X_test[0])\n",
    "print(y_test[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample output from the code above:\n",
    "\n",
    "(93636,) (93636,) (62424,) (62424,)\n",
    "almost in a class with that of Wilde\n",
    "3\n",
    "escape movie\n",
    "2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2.1 Data Checking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4}\n",
      "[[    0  5228]\n",
      " [    1 20482]\n",
      " [    2 59601]\n",
      " [    3 24837]\n",
      " [    4  6897]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:9: DeprecationWarning: `itemfreq` is deprecated!\n",
      "`itemfreq` is deprecated and will be removed in a future version. Use instead `np.unique(..., return_counts=True)`\n",
      "  if __name__ == '__main__':\n"
     ]
    }
   ],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# Check how many training examples in each category\n",
    "# this is important to see whether the data set is balanced or skewed\n",
    "\n",
    "training_labels = set(y_train)\n",
    "print(training_labels)\n",
    "from scipy.stats import itemfreq\n",
    "training_category_dist = itemfreq(y_train)\n",
    "print(training_category_dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sample output shows that the data set is skewed with 47718/93636=51% \"neutral\" examples. All other categories are smaller.\n",
    "\n",
    "{0, 1, 2, 3, 4}\n",
    "[[    0  4141]\n",
    " [    1 16449]\n",
    " [    2 47718]\n",
    " [    3 19859]\n",
    " [    4  5469]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 3: Vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# sklearn contains two vectorizers\n",
    "\n",
    "# CountVectorizer can give you Boolean or TF vectors\n",
    "# http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html\n",
    "\n",
    "# TfidfVectorizer can give you TF or TFIDF vectors\n",
    "# http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfVectorizer.html\n",
    "\n",
    "# Read the sklearn documentation to understand all vectorization options\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "# several commonly used vectorizer setting\n",
    "\n",
    "#  unigram boolean vectorizer, set minimum document frequency to 5\n",
    "unigram_bool_vectorizer = CountVectorizer(encoding='latin-1', binary=True, min_df=5, stop_words='english')\n",
    "\n",
    "#  unigram term frequency vectorizer, set minimum document frequency to 5\n",
    "unigram_count_vectorizer = CountVectorizer(encoding='latin-1', binary=False, min_df=5, stop_words='english')\n",
    "\n",
    "#  unigram and bigram term frequency vectorizer, set minimum document frequency to 5\n",
    "gram12_count_vectorizer = CountVectorizer(encoding='latin-1', ngram_range=(1,2), min_df=5, stop_words='english')\n",
    "\n",
    "#  unigram tfidf vectorizer, set minimum document frequency to 5\n",
    "unigram_tfidf_vectorizer = TfidfVectorizer(encoding='latin-1', use_idf=True, min_df=5, stop_words='english')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3.1: Vectorize the training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(117045, 13247)\n",
      "[[0 0 0 ... 0 0 0]]\n",
      "13247\n",
      "[('illusion', 5790), ('gore', 5084), ('entertaining', 3918), ('somewhat', 10851), ('standardized', 11090), ('surprise', 11484), ('mayhem', 7255), ('geared', 4915), ('maximum', 7253), ('comfort', 2241)]\n",
      "5800\n"
     ]
    }
   ],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# The vectorizer can do \"fit\" and \"transform\"\n",
    "# fit is a process to collect unique tokens into the vocabulary\n",
    "# transform is a process to convert each document to vector based on the vocabulary\n",
    "# These two processes can be done together using fit_transform(), or used individually: fit() or transform()\n",
    "\n",
    "# fit vocabulary in training documents and transform the training documents into vectors\n",
    "X_train_vec = unigram_count_vectorizer.fit_transform(X_train)\n",
    "\n",
    "# check the content of a document vector\n",
    "print(X_train_vec.shape)\n",
    "print(X_train_vec[0].toarray())\n",
    "\n",
    "# check the size of the constructed vocabulary\n",
    "print(len(unigram_count_vectorizer.vocabulary_))\n",
    "\n",
    "# print out the first 10 items in the vocabulary\n",
    "print(list(unigram_count_vectorizer.vocabulary_.items())[:10])\n",
    "\n",
    "# check word index in vocabulary\n",
    "print(unigram_count_vectorizer.vocabulary_.get('imaginative'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample output:\n",
    "\n",
    "(93636, 11967)\n",
    "[[0 0 0 ..., 0 0 0]]\n",
    "11967\n",
    "[('imaginative', 5224), ('tom', 10809), ('smiling', 9708), ('easy', 3310), ('diversity', 3060), ('impossibly', 5279), ('buy', 1458), ('sentiments', 9305), ('households', 5095), ('deteriorates', 2843)]\n",
    "5224"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3.2: Vectorize the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(39015, 13247)\n"
     ]
    }
   ],
   "source": [
    "# this step is the same as the NB script\n",
    "\n",
    "# use the vocabulary constructed from the training data to vectorize the test data. \n",
    "# Therefore, use \"transform\" only, not \"fit_transform\", \n",
    "# otherwise \"fit\" would generate a new vocabulary from the test data\n",
    "\n",
    "X_test_vec = unigram_count_vectorizer.transform(X_test)\n",
    "\n",
    "# print out #examples and #features in the test set\n",
    "print(X_test_vec.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample output:\n",
    "\n",
    "(62424, 14324)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 4: Train a LinearSVC classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/sklearn/svm/base.py:929: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  \"the number of iterations.\", ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LinearSVC(C=1, class_weight=None, dual=True, fit_intercept=True,\n",
       "          intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
       "          multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
       "          verbose=0)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the LinearSVC module\n",
    "from sklearn.svm import LinearSVC\n",
    "\n",
    "# initialize the LinearSVC model\n",
    "svm_clf = LinearSVC(C=1)\n",
    "\n",
    "# use the training data to train the model\n",
    "svm_clf.fit(X_train_vec,y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 4.1 Interpret a trained LinearSVC model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Very negative words\n",
      "(1.563367429512415, 'disappointment')\n",
      "(1.57538972344908, 'pompous')\n",
      "(1.583801555009775, 'unrecoverable')\n",
      "(1.6268035769501388, 'cesspool')\n",
      "(1.6497785814984984, 'stinks')\n",
      "(1.666772182881303, 'disgusting')\n",
      "(1.6750735671433656, 'unwatchable')\n",
      "(1.747064624973504, 'unappealing')\n",
      "(1.848245571664325, 'turd')\n",
      "(1.8867164498206463, 'uninspiring')\n",
      "\n",
      "not very negative words\n",
      "(-1.8066451313338003, 'nifty')\n",
      "(-1.7975884974271399, 'hawke')\n",
      "(-1.6953591946006585, 'collar')\n",
      "(-1.6809078653158591, 'giddy')\n",
      "(-1.662168499923614, 'admitted')\n",
      "(-1.5001999820619334, 'victim')\n",
      "(-1.498243333219461, 'demographically')\n",
      "(-1.4679512028538113, 'goodwill')\n",
      "(-1.4639028919745245, 'clamoring')\n",
      "(-1.4615437394097017, 'won')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## interpreting LinearSVC models\n",
    "## http://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn.svm.LinearSVC\n",
    "\n",
    "## LinearSVC uses a one-vs-all strategy to extend the binary SVM classifier to multi-class problems\n",
    "## for the Kaggle sentiment classification problem, there are five categories 0,1,2,3,4 with 0 as very negative and 4 very positive\n",
    "## LinearSVC builds five binary classifier, \"very negative vs. others\", \"negative vs. others\", \"neutral vs. others\", \"positive vs. others\", \"very positive vs. others\", \n",
    "## and then pick the most confident prediction as the final prediction.\n",
    "\n",
    "## Linear SVC also ranks all features based on their contribution to distinguish the two concepts in each binary classifier\n",
    "## For category \"0\" (very negative), get all features and their weights and sort them in increasing order\n",
    "feature_ranks = sorted(zip(svm_clf.coef_[0], unigram_count_vectorizer.get_feature_names()))\n",
    "\n",
    "## get the 10 features that are best indicators of very negative sentiment (they are at the bottom of the ranked list)\n",
    "very_negative_10 = feature_ranks[-10:]\n",
    "print(\"Very negative words\")\n",
    "for i in range(0, len(very_negative_10)):\n",
    "    print(very_negative_10[i])\n",
    "print()\n",
    "\n",
    "## get 10 features that are least relevant to \"very negative\" sentiment (they are at the top of the ranked list)\n",
    "not_very_negative_10 = feature_ranks[:10]\n",
    "print(\"not very negative words\")\n",
    "for i in range(0, len(not_very_negative_10)):\n",
    "    print(not_very_negative_10[i])\n",
    "print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample output:\n",
    "\n",
    "Very negative words\n",
    "(1.5635285973159958, 'stunning')\n",
    "(1.6005795078256047, 'astonish')\n",
    "(1.610812924790558, 'refreshes')\n",
    "(1.6148905161082145, 'flawless')\n",
    "(1.6474647033330083, 'phenomenal')\n",
    "(1.6506425169734038, 'masterful')\n",
    "(1.67761558779458, 'masterfully')\n",
    "(1.8781421016763864, 'glorious')\n",
    "(1.9801881772566481, 'miraculous')\n",
    "(2.0143251933052397, 'perfection')\n",
    "\n",
    "not very negative words\n",
    "(-2.3147454187985117, 'sacrifices')\n",
    "(-1.8650987318574794, 'maintained')\n",
    "(-1.8305667747223913, 'placed')\n",
    "(-1.7974037295239631, 'argue')\n",
    "(-1.6800998534753624, '19')\n",
    "(-1.6684863939524339, 'homage')\n",
    "(-1.6179084517399509, 'failure')\n",
    "(-1.6088792786048403, 'breezy')\n",
    "(-1.6059138072144292, 'bore')\n",
    "(-1.5466693614369267, 'clone')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Very positive words\n",
      "(-1.8066451313338003, 'nifty')\n",
      "(-1.7975884974271399, 'hawke')\n",
      "(-1.6953591946006585, 'collar')\n",
      "(-1.6809078653158591, 'giddy')\n",
      "(-1.662168499923614, 'admitted')\n",
      "(-1.5001999820619334, 'victim')\n",
      "(-1.498243333219461, 'demographically')\n",
      "(-1.4679512028538113, 'goodwill')\n",
      "(-1.4639028919745245, 'clamoring')\n",
      "(-1.4615437394097017, 'won')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# write code similar to the above sample code \n",
    "# and print out the 10 most indicative words for the \"very positive\" category\n",
    "\n",
    "# Your code starts here\n",
    "very_positive_10 = feature_ranks[:10]\n",
    "print(\"Very positive words\")\n",
    "for i in range(0, len(very_positive_10)):\n",
    "    print(very_positive_10[i])\n",
    "print()\n",
    "    \n",
    "# Your code ends here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample output\n",
    "\n",
    "(1.5635285973159958, 'stunning')\n",
    "(1.6005795078256047, 'astonish')\n",
    "(1.610812924790558, 'refreshes')\n",
    "(1.6148905161082145, 'flawless')\n",
    "(1.6474647033330083, 'phenomenal')\n",
    "(1.6506425169734038, 'masterful')\n",
    "(1.67761558779458, 'masterfully')\n",
    "(1.8781421016763864, 'glorious')\n",
    "(1.9801881772566481, 'miraculous')\n",
    "(2.0143251933052397, 'perfection')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 5: Test the LinearSVC classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6301678841471229"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test the classifier on the test data set, print accuracy score\n",
    "\n",
    "svm_clf.score(X_test_vec,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  586   786   421    45     6]\n",
      " [  460  2665  3349   295    22]\n",
      " [  116  1343 16988  1427   107]\n",
      " [   18   239  3665  3509   659]\n",
      " [    1    25   333  1112   838]]\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      0.32      0.39      1844\n",
      "           1       0.53      0.39      0.45      6791\n",
      "           2       0.69      0.85      0.76     19981\n",
      "           3       0.55      0.43      0.48      8090\n",
      "           4       0.51      0.36      0.43      2309\n",
      "\n",
      "    accuracy                           0.63     39015\n",
      "   macro avg       0.55      0.47      0.50     39015\n",
      "weighted avg       0.61      0.63      0.61     39015\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# print confusion matrix and classification report\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "y_pred = svm_clf.predict(X_test_vec)\n",
    "cm=confusion_matrix(y_test, y_pred, labels=[0,1,2,3,4])\n",
    "print(cm)\n",
    "print()\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "target_names = ['0','1','2','3','4']\n",
    "print(classification_report(y_test, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 5.1 Interpret the prediction result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.34991952 -0.52391355  0.24892444 -0.92725694 -1.05271412]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "## get the confidence scores for all test examples from each of the five binary classifiers\n",
    "svm_confidence_scores = svm_clf.decision_function(X_test_vec)\n",
    "## get the confidence score for the first test example\n",
    "print(svm_confidence_scores[0])\n",
    "\n",
    "## sample output: array([-1.05306321, -0.62746206,  0.31074854, -0.89709483, -1.08343089]\n",
    "## because the confidence score is the highest for category 2, \n",
    "## the prediction should be 2. \n",
    "\n",
    "## Confirm by printing out the actual prediction\n",
    "print(y_test[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 5.2 Error Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 minutes into the film you 'll be white-knuckled and unable to look away .\n",
      "errors: 1\n"
     ]
    }
   ],
   "source": [
    "# print out specific type of error for further analysis\n",
    "\n",
    "# print out the very positive examples that are mistakenly predicted as negative\n",
    "# according to the confusion matrix, there should be 53 such examples\n",
    "# note if you use a different vectorizer option, your result might be different\n",
    "\n",
    "err_cnt = 0\n",
    "for i in range(0, len(y_test)):\n",
    "    if(y_test[i]==4 and y_pred[i]==0):\n",
    "        print(X_test[i])\n",
    "        err_cnt = err_cnt+1\n",
    "print(\"errors:\", err_cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the film is not entirely successful\n",
      "The Master of Disguise is funny -- not\n",
      "But if the essence of magic is its make-believe promise of life that soars above the material realm , this is the opposite of a truly magical movie .\n",
      "is not Edward Burns ' best film\n",
      "Once the expectation of laughter has been quashed by whatever obscenity is at hand , even the funniest idea is n't funny .\n",
      "It may not be a great piece of filmmaking ,\n",
      "errors: 6\n"
     ]
    }
   ],
   "source": [
    "# write code to print out \n",
    "# the errors that very negative examples were mistakenly predicted as very positive?\n",
    "# and the errors that very positive examples were mistakenly predicted as very negative?\n",
    "\n",
    "# Try find lingustic patterns for these two types of errors\n",
    "# Based on the above error analysis, what suggestions would you give to improve the current model?\n",
    "\n",
    "# Your code starts here\n",
    "err_cnt = 0\n",
    "for i in range(0, len(y_test)):\n",
    "    if(y_test[i]==0 and y_pred[i]==4):\n",
    "        print(X_test[i])\n",
    "        err_cnt = err_cnt+1\n",
    "print(\"errors:\", err_cnt)\n",
    "\n",
    "## SUGGESTIONS: I would add bigrams and negation features\n",
    "# Your code ends here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 6: write the prediction output to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred=svm_clf.predict(X_test_vec)\n",
    "output = open('linearSVC_prediction_output.csv', 'w')\n",
    "for x, value in enumerate(y_pred):\n",
    "    output.write(str(value) + '\\n') \n",
    "output.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 6.1 Prepare submission to Kaggle sentiment classification competition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "########## submit to Kaggle submission\n",
    "\n",
    "# we are still using the model trained on 60% of the training data\n",
    "# you can re-train the model on the entire data set \n",
    "#   and use the new model to predict the Kaggle test data\n",
    "# below is sample code for using a trained model to predict Kaggle test data \n",
    "#    and format the prediction output for Kaggle submission\n",
    "\n",
    "# read in the test data\n",
    "kaggle_test=p.read_csv(\"kaggle-sentiment/test.tsv\", delimiter='\\t') \n",
    "\n",
    "# preserve the id column of the test examples\n",
    "kaggle_ids=kaggle_test['PhraseId'].values\n",
    "\n",
    "# read in the text content of the examples\n",
    "kaggle_X_test=kaggle_test['Phrase'].values\n",
    "\n",
    "# vectorize the test examples using the vocabulary fitted from the 60% training data\n",
    "kaggle_X_test_vec=unigram_count_vectorizer.transform(kaggle_X_test)\n",
    "\n",
    "# predict using the NB classifier that we built\n",
    "kaggle_pred=svm_clf.fit(X_train_vec, y_train).predict(kaggle_X_test_vec)\n",
    "\n",
    "# combine the test example ids with their predictions\n",
    "kaggle_submission=zip(kaggle_ids, kaggle_pred)\n",
    "\n",
    "# prepare output file\n",
    "outf=open('kaggle_submission_linearSVC_2.csv', 'w')\n",
    "\n",
    "# write header\n",
    "outf.write('PhraseId,Sentiment\\n')\n",
    "\n",
    "# write predictions with ids to the output file\n",
    "for x, value in enumerate(kaggle_submission): outf.write(str(value[0]) + ',' + str(value[1]) + '\\n')\n",
    "\n",
    "# close the output file\n",
    "outf.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 2, ..., 1, 1, 2])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate your Kaggle submissions with boolean representation and TF representation\n",
    "# submit to Kaggle\n",
    "# report your scores here\n",
    "# which model gave better performance in the hold-out test\n",
    "# which model gave better performance in the Kaggle test\n",
    "\n",
    "# Your code starts here\n",
    "\n",
    "\n",
    "# Your code ends here\n",
    "\n",
    "kaggle_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Use the entire Kaggle training data set to build a LinearSVC model\n",
    "# then do 3-fold CV for the LinearSVC model that you built\n",
    "\n",
    "# Your code starts here\n",
    "# KAGGLE 0.58792\n",
    "# HOLDOUT 0.6236864026656415\n",
    "\n",
    "# Your code ends here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(*args, **kw)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# hide axes\n",
    "fig.patch.set_visible(False)\n",
    "ax.axis('off')\n",
    "ax.axis('tight')\n",
    "\n",
    "df = pd.DataFrame(np.random.randn(10, 4), columns=list('ABCD'))\n",
    "\n",
    "ax.table(cellText=df.values, colLabels=df.columns, loc='center')\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "data = [[ 66386, 174296,  75131, 577908,  32015],\n",
    "        [ 58230, 381139,  78045,  99308, 160454],\n",
    "        [ 89135,  80552, 152558, 497981, 603535],\n",
    "        [ 78415,  81858, 150656, 193263,  69638],\n",
    "        [139361, 331509, 343164, 781380,  52269]]\n",
    "\n",
    "columns = ('Freeze', 'Wind', 'Flood', 'Quake', 'Hail')\n",
    "rows = ['%d year' % x for x in (100, 50, 20, 10, 5)]\n",
    "\n",
    "values = np.arange(0, 2500, 500)\n",
    "value_increment = 1000\n",
    "\n",
    "# Get some pastel shades for the colors\n",
    "colors = plt.cm.BuPu(np.linspace(0, 0.5, len(rows)))\n",
    "n_rows = len(data)\n",
    "\n",
    "index = np.arange(len(columns)) + 0.3\n",
    "bar_width = 0.4\n",
    "\n",
    "# Initialize the vertical-offset for the stacked bar chart.\n",
    "y_offset = np.zeros(len(columns))\n",
    "\n",
    "# Plot bars and create text labels for the table\n",
    "cell_text = []\n",
    "for row in range(n_rows):\n",
    "    plt.bar(index, data[row], bar_width, bottom=y_offset, color=colors[row])\n",
    "    y_offset = y_offset + data[row]\n",
    "    cell_text.append(['%1.1f' % (x / 1000.0) for x in y_offset])\n",
    "# Reverse colors and text labels to display the last value at the top.\n",
    "colors = colors[::-1]\n",
    "cell_text.reverse()\n",
    "\n",
    "# Add a table at the bottom of the axes\n",
    "the_table = plt.table(cellText=cell_text,\n",
    "                      rowLabels=rows,\n",
    "                      rowColours=colors,\n",
    "                      colLabels=columns,\n",
    "                      loc='bottom')\n",
    "\n",
    "# Adjust layout to make room for the table:\n",
    "plt.subplots_adjust(left=0.2, bottom=0.2)\n",
    "\n",
    "plt.ylabel(\"Loss in ${0}'s\".format(value_increment))\n",
    "plt.yticks(values * value_increment, ['%d' % val for val in values])\n",
    "plt.xticks([])\n",
    "plt.title('Loss by Disaster')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Add a table at the bottom of the axes\n",
    "the_table = plt.table(cellText=cell_text,\n",
    "                      rowLabels=rows,\n",
    "                      rowColours=colors,\n",
    "                      colLabels=columns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}