Project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# All Imports\n",
    "from collections import Counter\n",
    "from operator import itemgetter\n",
    "import ConfigParser\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import sys\n",
    "import time\n",
    "import io\n",
    "import os\n",
    "import re\n",
    "import nltk\n",
    "import string\n",
    "import shutil\n",
    "import hashlib\n",
    "from sklearn.cross_validation import KFold\n",
    "from sklearn import cross_validation\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "#nltk.download()\n",
    "from tabulate import tabulate\n",
    "from nltk.corpus import sentiwordnet\n",
    "from nltk.corpus import SentiWordNetCorpusReader, SentiSynset\n",
    "import pylab as plt\n",
    "import numpy as np\n",
    "import scipy.stats as stats\n",
    "import pylab as pl\n",
    "%matplotlib inline\n",
    "swn_root = './'\n",
    "swn_filename = 'SentiWordNet_3.0.0_20130122.txt'\n",
    "swn = SentiWordNetCorpusReader(swn_root,swn_filename,encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Converts a file to list of strings where each item is one line of the file.\n",
    "def file2string(filename):\n",
    "    result = []\n",
    "    result = io.open(filename, encoding='utf8').readlines()\n",
    "    for val in range(0,len(result)):\n",
    "        result[val]=re.sub(\"\\n\",\"\",result[val])        \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created product dictionary with 40 products\n"
     ]
    }
   ],
   "source": [
    "#Create a dictionary with product id as key and item title and manufacturer tuple as value taking a file as input\n",
    "def productsDictionary(productsfile):\n",
    "    productlst = file2string(productsfile)\n",
    "    result = {}\n",
    "    for product in productlst:\n",
    "        temp = product.split(\"\\t\")\n",
    "        result[temp[0]]=(temp[1],temp[2])\n",
    "    return result\n",
    "\n",
    "product_dictionary = productsDictionary(\"items.txt\")\n",
    "print \"Created product dictionary with\",len(product_dictionary.keys()),\"products\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## To calculate the Sentiment score of a review. \n",
    "\n",
    "\n",
    "def calculateSynsetScore(review):\n",
    "    tokens = nltk.word_tokenize(review)\n",
    "    score = 0\n",
    "    for t in tokens:\n",
    "        try:\n",
    "            synset = swn.senti_synsets(t)[0]\n",
    "            #print t,\"\\t\",synset\n",
    "            score = score + synset.pos_score() - synset.neg_score()\n",
    "        except(IndexError):\n",
    "            #print \"Index error at:\", t\n",
    "            pass\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# preprocess the review data\n",
    "\n",
    "\n",
    "# URLs\n",
    "reg_URL = re.compile(r\"http\\S+\")\n",
    "\n",
    "# Spliting by word boundaries\n",
    "reg_Wordbound = re.compile(r\"\\W+\")\n",
    "\n",
    "# Replace Repeating words like gooooooooood \n",
    "\n",
    "reg_Repeat = re.compile(r\"(.)\\1{1,}\", re.IGNORECASE);\n",
    "\n",
    "def replace_repeat(match):\n",
    "    return match.group(1)+match.group(1)\n",
    "\n",
    "# Emoticons\n",
    "#replacing emoticons, you can specify any name\n",
    "\n",
    "emoticons = [('', [':-)', ':)', '(:', '(-:', ':-D', ':D', 'X-D', 'XD', 'xD', '<3', ':\\*', ';-)', ';)', ';-D', ';D', '(;', '(-;', ':-(', ':(', '(:', '(-:', ':,(', ':\\'(', ':\"(', ':(('] )]\n",
    "\n",
    "\n",
    "punct_list = []\n",
    "\n",
    "for i in string.punctuation:\n",
    "    punct_list.append(i)\n",
    "    \n",
    "# Punctuations\n",
    "punctuations = \\\n",
    "    [   #Classify all punctuation as same\n",
    "        #you can control which punctuation to use by creating new punctuation list\n",
    "        #i have stripped down all the punctuations, you can put something in that blank\n",
    "        ('',punct_list ),\\\n",
    "    ]\n",
    "\n",
    "\n",
    "#For emoticon regexes\n",
    "\n",
    "def escape_paren(arr):\n",
    "    return [review.replace(')', '[)}\\]]').replace('(', '[({\\[]') for review in arr]\n",
    "\n",
    "def reg_Union(arr):\n",
    "    return '(' + '|'.join( arr ) + ')'\n",
    "\n",
    "reg_Emoticons = [ (repl, re.compile(reg_Union(escape_paren(regx))) ) \\\n",
    "                    for (repl, regx) in emoticons ]\n",
    "\n",
    "\n",
    "#For punctuation replacement\n",
    "def replace_punctuations(match):\n",
    "    review = match.group(0)\n",
    "    repl = []\n",
    "    for (key, parr) in punctuations :\n",
    "        for punc in parr :\n",
    "            if punc in review:\n",
    "                repl.append(key)\n",
    "    if( len(repl)>0 ) :\n",
    "        return ' ' + ' '.join(repl) + ' '\n",
    "    else :\n",
    "        return ' '\n",
    "\n",
    "\n",
    "def preprocess_Urls(review, subject='', query=[]):\n",
    "    return re.sub( regURL, '', review )\n",
    "\n",
    "def preprocess_Emoticons(review, subject='', query=[]):\n",
    "    for (repl, regx) in regEmoticons :\n",
    "        review = re.sub(regx, ' '+repl+' ', review)\n",
    "    return review\n",
    "\n",
    "def preprocess_Punctuations(review, subject='', query=[]):\n",
    "    return re.sub( reg_Wordbound , replace_punctuations, review )\n",
    "\n",
    "def preprocess_Repeatings(review, subject='', query=[]):\n",
    "    return re.sub( reg_Repeat, replace_repeat, review )\n",
    "\n",
    "\n",
    "def processAll(review, subject='', query=[]):\n",
    "\n",
    "    if(len(query)>0):\n",
    "        query_regex = \"|\".join([ re.escape(q) for q in query])\n",
    "        review = re.sub(query_regex, '', review, flags=re.IGNORECASE )\n",
    "    \n",
    "    review = re.sub( reg_URL, '', review )\n",
    "    \n",
    "\n",
    "    for (repl, regx) in reg_Emoticons :\n",
    "        review = re.sub(regx, ' '+repl+' ', review)\n",
    "\n",
    "\n",
    "    review = review.replace('\\'',' ')\n",
    "\n",
    "    #replcae underscore with space\n",
    "    review = review.replace('_',' ')\n",
    "    \n",
    "\n",
    "    review = re.sub( reg_Wordbound , replace_punctuations, review )\n",
    "    review = re.sub( reg_Repeat, replace_repeat, review )\n",
    "    \n",
    "    lst = review.lower().split()\n",
    "    \n",
    "    \n",
    "    return ' '.join(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this would not be replaced. '"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Replace the word which contains n't i.e wouldn't,shouldn't  \n",
    "#   with  would not, should not and return the string.   \n",
    "\n",
    "def replace_with_not(string):\n",
    "    ns = \"\"\n",
    "    suffix = \"n't\"\n",
    "    word = \"not\"\n",
    "    for stn in string.split():\n",
    "        if stn.endswith(suffix):\n",
    "            stn = stn[:-3]\n",
    "            ns += stn + ' ' + word + ' '\n",
    "        else:\n",
    "            ns += stn + ' '\n",
    "    return ns\n",
    "    \n",
    "replace_with_not(\"this wouldn't be replaced.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Reads a file named (productID).txt and returns a list of all reviews present in that file for the given productID\n",
    "def getAllReviews(productID):\n",
    "    reviews = file2string(\"Reviews_Data/\"+ productID+\".txt\") \n",
    "    result = []\n",
    "    for review_line in reviews:\n",
    "        #print review.split(\"->\")[1],\"\\n\"\n",
    "        review = review_line.split(\"->\")[1]\n",
    "        r1 = processAll(review)\n",
    "        review = replace_with_not(r1)\n",
    "        score = calculateSynsetScore(review)\n",
    "        result.append((review,score))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading reviews for Product ID: B004KZJ0UM \tNumber of total reviews: 316\n",
      "Reading reviews for Product ID: B00ZOO1RFO \tNumber of total reviews: 76\n",
      "Reading reviews for Product ID: B00K6ZIL0K \tNumber of total reviews: 22\n",
      "Reading reviews for Product ID: B00PGELA04 \tNumber of total reviews: 46\n",
      "Reading reviews for Product ID: B00SV72ZA2 \tNumber of total reviews: 70\n",
      "Reading reviews for Product ID: B00HRO37UC \tNumber of total reviews: 53\n",
      "Reading reviews for Product ID: B011KFQASE \tNumber of total reviews: 100\n",
      "Reading reviews for Product ID: B00PPTP9IO \tNumber of total reviews: 92\n",
      "Reading reviews for Product ID: B00Z1R85O0 \tNumber of total reviews: 15\n",
      "Reading reviews for Product ID: B00VGNZ4PG \tNumber of total reviews: 50\n",
      "Reading reviews for Product ID: B00THEP15O \tNumber of total reviews: 55\n",
      "Reading reviews for Product ID: B01606KJ6C \tNumber of total reviews: 49\n",
      "Reading reviews for Product ID: B015PYZXRU \tNumber of total reviews: 39\n",
      "Reading reviews for Product ID: B00VKL0I96 \tNumber of total reviews: 39\n",
      "Reading reviews for Product ID: B00XPUUGDI \tNumber of total reviews: 74\n",
      "Reading reviews for Product ID: B00V2KX5JA \tNumber of total reviews: 74\n",
      "Reading reviews for Product ID: B00MMLW3X2 \tNumber of total reviews: 100\n",
      "Reading reviews for Product ID: B00KDI9C4O \tNumber of total reviews: 52\n",
      "Reading reviews for Product ID: B00RY4X8A4 \tNumber of total reviews: 100\n",
      "Reading reviews for Product ID: B00ZS64K7K \tNumber of total reviews: 23\n",
      "Reading reviews for Product ID: B00X9KPSKK \tNumber of total reviews: 73\n",
      "Reading reviews for Product ID: B00FF6J532 \tNumber of total reviews: 244\n",
      "Reading reviews for Product ID: B00K4PATO8 \tNumber of total reviews: 100\n",
      "Reading reviews for Product ID: B00IU745S8 \tNumber of total reviews: 85\n",
      "Reading reviews for Product ID: B00NJNE6AA \tNumber of total reviews: 99\n",
      "Reading reviews for Product ID: B015JVBD64 \tNumber of total reviews: 39\n",
      "Reading reviews for Product ID: B00N9ERISQ \tNumber of total reviews: 51\n",
      "Reading reviews for Product ID: B00K4PAV5U \tNumber of total reviews: 74\n",
      "Reading reviews for Product ID: B00YD1OQ1G \tNumber of total reviews: 38\n",
      "Reading reviews for Product ID: B00U8DHPX4 \tNumber of total reviews: 60\n",
      "Reading reviews for Product ID: B013PK8LGQ \tNumber of total reviews: 18\n",
      "Reading reviews for Product ID: B014B9IS1S \tNumber of total reviews: 6\n",
      "Reading reviews for Product ID: B015JVB9C2 \tNumber of total reviews: 30\n",
      "Reading reviews for Product ID: B015P3SH9W \tNumber of total reviews: 59\n",
      "Reading reviews for Product ID: B010DODAWM \tNumber of total reviews: 37\n",
      "Reading reviews for Product ID: B015JJNF8K \tNumber of total reviews: 62\n",
      "Reading reviews for Product ID: B00IB04M5K \tNumber of total reviews: 79\n",
      "Reading reviews for Product ID: B010DOD2G6 \tNumber of total reviews: 30\n",
      "Reading reviews for Product ID: B00ZOLT5YC \tNumber of total reviews: 100\n",
      "Reading reviews for Product ID: B00KMRGF28 \tNumber of total reviews: 100\n",
      "\n",
      "Counter({100: 6, 39: 3, 74: 3, 30: 2, 6: 1, 15: 1, 18: 1, 22: 1, 23: 1, 37: 1, 38: 1, 46: 1, 49: 1, 50: 1, 51: 1, 52: 1, 53: 1, 55: 1, 59: 1, 316: 1, 62: 1, 70: 1, 73: 1, 76: 1, 79: 1, 85: 1, 92: 1, 99: 1, 60: 1, 244: 1})\n"
     ]
    }
   ],
   "source": [
    "#Create a dictionary with product id as key and list of its reviews as value.\n",
    "\n",
    "product_ids = product_dictionary.keys()\n",
    "product_reviews = {}\n",
    "\n",
    "for id in product_ids:\n",
    "    reviews = getAllReviews(id)\n",
    "    product_reviews[id]=reviews;\n",
    "    print \"Reading reviews for Product ID:\",id,\"\\tNumber of total reviews:\",len(reviews)\n",
    "\n",
    "cnt = Counter()\n",
    "for key in product_reviews.keys():\n",
    "    #print \"Product ID:\",key,\"\\tNumber of reviews:\",len(product_reviews[key])\n",
    "    cnt[len(product_reviews[key])]+=1\n",
    "print \"\\n\",cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Item Number   Product Title                                                        Sentiment Score\n",
      "-------------  ------------------------------------------------------------------  -----------------\n",
      "      1        Microsoft Surface 2 (32 GB)                                              1.94442\n",
      "      2        Dell Inspiron i7359-6790SLV 2-in-1 Touchscreen Laptop                    1.74788\n",
      "      3        G-Tab Iota Quad Core Android Tablet PC                                   1.45588\n",
      "      4        2015 Newest Dell Chromebook, 11.6 inch HD Non-Touch LCD                   1.25\n",
      "      5        Microsoft Surface Pro 4, Intel Core i5                                   1.23724\n",
      "      6        Dell Inspiron 3000 15.6-Inches Windows 8.1 Laptop                        1.05556\n",
      "      7        Microsoft Surface 3 Tablet                                                0.94\n",
      "      8        Dell 15 5000 i15547-5003sLV 16-Inch Touch Screen Laptop                 0.923913\n",
      "      9        ASUS F555LA-AB31 15.6-inch Full-HD Laptop                                0.83728\n",
      "     10        Dell Inspiron 15 7000 Series i7537T Touchscreen Laptop                  0.784222\n",
      "     11        Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop                       0.758446\n",
      "     12        2015 Newest Model Dell XPS13 Ultrabook Computer                          0.7475\n",
      "     13        Lenovo Flex 2 15.6-Inch Touchscreen Laptop (59418271) Black             0.636364\n",
      "     14        2015 Newest Dell Inspiron 2 in 1 Convertible Touchscreen Laptop         0.633333\n",
      "     15        Dell Inspiron 15.6-Inch Touchscreen Laptop (i15RVT-6195BLK)             0.608491\n",
      "     16        Dell Inspiron 15.6-Inch Touchscreen Laptop                              0.569257\n",
      "     17        Dell Inspiron i5552-4391BLK 15.6 Inch Touchscreen Laptop                0.560897\n",
      "     18        Dell Inspiron i5558-2859BLK 15.6 Inch Touchscreen Laptop                0.560897\n",
      "     19        Dell Inspiron i3541-2001BLK 15.6-Inch Laptop                            0.530063\n",
      "     20        Dell Latitude D630 14.1-Inch Notebook PC - Silver 2011 Model            0.528063\n",
      "     21        Acer Aspire Switch 10 E SW3-013-1566 2-in-1 Tablet & Laptop             0.493952\n",
      "     22        Dell Inspiron i3000-5099SLV Touchscreen Laptop                            0.475\n",
      "     23        Dell Inspiron i3543 15.6-Inch Touchscreen Laptop                        0.460526\n",
      "     24        Toshiba Radius 2-in-1 11.6\" Touch-screen Laptop                         0.449728\n",
      "     25        Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen                       0.38587\n",
      "     26        2015 Newest Model DELL Inspiron 15 Touchscreen Laptop                     0.375\n",
      "     27        Dell Inspiron N2840 14-Inch Laptop                                      0.371711\n",
      "     28        ASUS K200MA-DS01T(S) 11.6-Inch HD Touchscreen Laptop (Black)              0.365\n",
      "     29        Dell Inspiron 11 3000 Series 2-in-1  11.6 Inch Laptop                   0.364865\n",
      "     30        Dell Inspiron 15.6 Inch Laptop                                          0.363636\n",
      "     31        Dell Latitude E6420 Premium 14.1-Inch Business Laptop                   0.333333\n",
      "     32        ASUS X551MA 15.6 Inch Laptop                                            0.264286\n",
      "     33        Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop                 0.252083\n",
      "     34        Dell Inspiron i3531-1200BK 16-Inch Laptop,Black                          0.23125\n",
      "     35        Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                             0.2225\n",
      "     36        Microsoft Surface 2 32GB 10.6\" Tablet                                   0.156863\n",
      "     37        2015 Newest Model Dell Inspiron 15 Laptop Computer                      0.155405\n",
      "     38        HP Pavilion x360 13-a010nr Convertible Touchscreen Laptop               0.146212\n",
      "     39        Dell Inspiron 15 5000 15.6 Inch Laptop                                   0.1375\n",
      "     40        HP Pavilion X360 13.3-Inch WLED HD Touch-screen Convertible Laptop        0.125\n"
     ]
    }
   ],
   "source": [
    "#Calculates average sentiment of all reviews that a product received.\n",
    "def productAverageScore(reviews_dict):\n",
    "    result = []\n",
    "    for pid in reviews_dict.keys():\n",
    "        reviews_lst = reviews_dict[pid]\n",
    "        sum = 0\n",
    "        for review in reviews_lst:\n",
    "            sum+=review[1]\n",
    "        \n",
    "        avg = sum/len(reviews_lst)\n",
    "        result.append((pid,avg))\n",
    "        result = sorted(result,key = itemgetter(1),reverse = True)\n",
    "    \n",
    "    return result\n",
    "        \n",
    "product_avg = productAverageScore(product_reviews)\n",
    "#print product_avg[0][1]\n",
    "\n",
    "cnt = 0\n",
    "table = []\n",
    "for val in range(len(product_avg)):\n",
    "    cnt+=1\n",
    "    table.append([cnt,product_dictionary[product_avg[val][0]][0],product_avg[val][1]])\n",
    "    \n",
    "print tabulate(table,headers=[\"Item Number\",\"Product Title\",\"Sentiment Score\"], tablefmt=\"simple\", numalign=\"center\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niIiIiIiIiIiIiIiIiF39PwuPXIKrBqxKAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa06556f590>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Histogram of Product Average rating. \n",
    "\n",
    "h = []\n",
    "for i in range(len(product_avg)):\n",
    "    h.append(product_avg[i][1])\n",
    "\n",
    "#h = sorted(h)\n",
    "#print mp.mean(h)   \n",
    "fit = stats.norm.pdf(h, np.mean(h), np.std(h))  #this is a fitting indeed\n",
    "\n",
    "pl.plot(h,fit,'-o')\n",
    "\n",
    "pl.hist(h,normed=True)      #use this to draw histogram of your data\n",
    "\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Calculates average sentiment of all reviews that a product received.\n",
    "def productFeatureScore(reviews_dict,feature):\n",
    "    result = []\n",
    "    for pid in reviews_dict.keys():\n",
    "        reviews_lst = reviews_dict[pid]\n",
    "        sum = 0.0\n",
    "        cnt = 0.0\n",
    "        for review in reviews_lst:\n",
    "            reviewstr = review[0].lower()\n",
    "            if re.findall(feature, reviewstr):\n",
    "                sum+=review[1]\n",
    "                cnt+=1\n",
    "        if cnt != 0:\n",
    "            avg = sum/cnt\n",
    "            result.append((pid,avg))\n",
    "        result = sorted(result,key = itemgetter(1),reverse = True)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Item Number   Product Title                                                        Sentiment Score\n",
      "-------------  ------------------------------------------------------------------  -----------------\n",
      "      1        Microsoft Surface 2 (32 GB)                                              5.29421\n",
      "      2        Acer Aspire Switch 10 E SW3-013-1566 2-in-1 Tablet & Laptop               4.25\n",
      "      3        Dell Inspiron i7359-6790SLV 2-in-1 Touchscreen Laptop                    3.40217\n",
      "      4        Dell Inspiron i3000-5099SLV Touchscreen Laptop                            3.375\n",
      "      5        Microsoft Surface Pro 4, Intel Core i5                                   2.41667\n",
      "      6        Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen                       2.33333\n",
      "      7        G-Tab Iota Quad Core Android Tablet PC                                     2.2\n",
      "      8        Dell Inspiron 15 7000 Series i7537T Touchscreen Laptop                   1.96685\n",
      "      9        Microsoft Surface 3 Tablet                                               1.93182\n",
      "     10        ASUS F555LA-AB31 15.6-inch Full-HD Laptop                                 1.802\n",
      "     11        Lenovo Flex 2 15.6-Inch Touchscreen Laptop (59418271) Black               1.55\n",
      "     12        Toshiba Radius 2-in-1 11.6\" Touch-screen Laptop                            1.5\n",
      "     13        Dell Inspiron i3543 15.6-Inch Touchscreen Laptop                         1.45833\n",
      "     14        Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop                        1.40179\n",
      "     15        Dell Inspiron 15.6-Inch Touchscreen Laptop                               1.32031\n",
      "     16        Dell Inspiron 11 3000 Series 2-in-1  11.6 Inch Laptop                    1.3125\n",
      "     17        ASUS X551MA 15.6 Inch Laptop                                               1.3\n",
      "     18        Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop                  1.26562\n",
      "     19        2015 Newest Model Dell XPS13 Ultrabook Computer                          1.09375\n",
      "     20        2015 Newest Model Dell Inspiron 15 Laptop Computer                       1.08333\n",
      "     21        Dell Inspiron 15.6-Inch Touchscreen Laptop (i15RVT-6195BLK)              1.06818\n",
      "     22        Dell 15 5000 i15547-5003sLV 16-Inch Touch Screen Laptop                 0.958333\n",
      "     23        2015 Newest Dell Inspiron 2 in 1 Convertible Touchscreen Laptop           0.875\n",
      "     24        2015 Newest Model DELL Inspiron 15 Touchscreen Laptop                   0.855769\n",
      "     25        Dell Latitude D630 14.1-Inch Notebook PC - Silver 2011 Model            0.791667\n",
      "     26        Dell Inspiron i3541-2001BLK 15.6-Inch Laptop                             0.6625\n",
      "     27        HP Pavilion x360 13-a010nr Convertible Touchscreen Laptop                0.6585\n",
      "     28        ASUS K200MA-DS01T(S) 11.6-Inch HD Touchscreen Laptop (Black)            0.566667\n",
      "     29        Dell Inspiron i3531-1200BK 16-Inch Laptop,Black                            0.5\n",
      "     30        Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                            0.0909091\n",
      "     31        HP Pavilion X360 13.3-Inch WLED HD Touch-screen Convertible Laptop      0.0568182\n",
      "     32        Dell Inspiron 15.6 Inch Laptop                                              0\n",
      "     33        Microsoft Surface 2 32GB 10.6\" Tablet                                    -0.125\n",
      "     34        Dell Inspiron i5552-4391BLK 15.6 Inch Touchscreen Laptop                  -0.5\n",
      "     35        Dell Inspiron i5558-2859BLK 15.6 Inch Touchscreen Laptop                  -0.5\n",
      "     36        Dell Inspiron 15 5000 15.6 Inch Laptop                                    -0.5\n"
     ]
    }
   ],
   "source": [
    "#Searching for products with reviews related to touch\n",
    "product_touch = productFeatureScore(product_reviews,\"touch\")\n",
    "\n",
    "cnt = 0\n",
    "table = []\n",
    "for val in range(len(product_touch)):\n",
    "    cnt+=1\n",
    "    table.append([cnt,product_dictionary[product_touch[val][0]][0],product_touch[val][1]])\n",
    "print tabulate(table,headers=[\"Item Number\",\"Product Title\",\"Sentiment Score\"], tablefmt=\"simple\", numalign=\"center\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Item Number   Product Title                                                        Sentiment Score\n",
      "-------------  ------------------------------------------------------------------  -----------------\n",
      "      1        Microsoft Surface 2 (32 GB)                                               9.625\n",
      "      2        Dell Latitude E6420 Premium 14.1-Inch Business Laptop                     6.125\n",
      "      3        Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop                   5.125\n",
      "      4        Dell Inspiron i7359-6790SLV 2-in-1 Touchscreen Laptop                     5.025\n",
      "      5        Toshiba Radius 2-in-1 11.6\" Touch-screen Laptop                          4.5625\n",
      "      6        Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen                         3.5\n",
      "      7        ASUS F555LA-AB31 15.6-inch Full-HD Laptop                                2.40687\n",
      "      8        Dell Latitude D630 14.1-Inch Notebook PC - Silver 2011 Model             2.34683\n",
      "      9        Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                             2.3125\n",
      "     10        Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop                         2.25\n",
      "     11        Lenovo Flex 2 15.6-Inch Touchscreen Laptop (59418271) Black               1.875\n",
      "     12        G-Tab Iota Quad Core Android Tablet PC                                   1.78125\n",
      "     13        Microsoft Surface Pro 4, Intel Core i5                                    1.75\n",
      "     14        Dell Inspiron 15.6-Inch Touchscreen Laptop (i15RVT-6195BLK)              1.66667\n",
      "     15        2015 Newest Model Dell Inspiron 15 Laptop Computer                        1.65\n",
      "     16        2015 Newest Dell Chromebook, 11.6 inch HD Non-Touch LCD                   1.625\n",
      "     17        Dell 15 5000 i15547-5003sLV 16-Inch Touch Screen Laptop                  1.5625\n",
      "     18        Microsoft Surface 3 Tablet                                               1.45833\n",
      "     19        ASUS X551MA 15.6 Inch Laptop                                              1.375\n",
      "     20        Dell Inspiron 15 7000 Series i7537T Touchscreen Laptop                    1.273\n",
      "     21        2015 Newest Model Dell XPS13 Ultrabook Computer                           1.15\n",
      "     22        Dell Inspiron 15.6-Inch Touchscreen Laptop                                  1\n",
      "     23        Dell Inspiron i3541-2001BLK 15.6-Inch Laptop                              0.525\n",
      "     24        ASUS K200MA-DS01T(S) 11.6-Inch HD Touchscreen Laptop (Black)              0.25\n",
      "     25        HP Pavilion x360 13-a010nr Convertible Touchscreen Laptop                 0.25\n",
      "     26        Dell Inspiron 15 5000 15.6 Inch Laptop                                    0.125\n",
      "     27        Dell Inspiron i3543 15.6-Inch Touchscreen Laptop                            0\n",
      "     28        2015 Newest Model DELL Inspiron 15 Touchscreen Laptop                    -0.125\n",
      "     29        Dell Inspiron i5552-4391BLK 15.6 Inch Touchscreen Laptop                 -0.6875\n",
      "     30        Dell Inspiron i5558-2859BLK 15.6 Inch Touchscreen Laptop                 -0.6875\n",
      "     31        Dell Inspiron 15.6 Inch Laptop                                            -0.75\n",
      "     32        Dell Inspiron i3531-1200BK 16-Inch Laptop,Black                          -0.875\n",
      "     33        HP Pavilion X360 13.3-Inch WLED HD Touch-screen Convertible Laptop       -1.375\n"
     ]
    }
   ],
   "source": [
    "#Searching for products with reviews related to processor\n",
    "product_processor = productFeatureScore(product_reviews,\"processor\")\n",
    "\n",
    "cnt = 0\n",
    "table = []\n",
    "for val in range(len(product_processor)):\n",
    "    cnt+=1\n",
    "    table.append([cnt,product_dictionary[product_processor[val][0]][0],product_processor[val][1]])\n",
    "print tabulate(table,headers=[\"Item Number\",\"Product Title\",\"Sentiment Score\"], tablefmt=\"simple\", numalign=\"center\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Item Number   Product Title                                                 Sentiment Score\n",
      "-------------  -----------------------------------------------------------  -----------------\n",
      "      1        Microsoft Surface 2 (32 GB)                                       5.36538\n",
      "      2        Dell Inspiron 15.6-Inch Touchscreen Laptop (i15RVT-6195BLK)        4.25\n",
      "      3        Dell Inspiron i3531-1200BK 16-Inch Laptop,Black                    4.25\n",
      "      4        G-Tab Iota Quad Core Android Tablet PC                               3\n",
      "      5        Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                       1.875\n",
      "      6        2015 Newest Model DELL Inspiron 15 Touchscreen Laptop              1.875\n",
      "      7        Dell Inspiron 11 3000 Series 2-in-1  11.6 Inch Laptop              1.625\n",
      "      8        Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop                  1.125\n",
      "      9        Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop            1.125\n",
      "     10        2015 Newest Model Dell XPS13 Ultrabook Computer                   1.0625\n",
      "     11        Dell Inspiron i3543 15.6-Inch Touchscreen Laptop                   0.625\n",
      "     12        Microsoft Surface 3 Tablet                                        0.4375\n",
      "     13        Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen                 0.125\n",
      "     14        Toshiba Radius 2-in-1 11.6\" Touch-screen Laptop                   -0.0625\n",
      "     15        Dell Inspiron 15.6 Inch Laptop                                    -0.5625\n",
      "     16        ASUS X551MA 15.6 Inch Laptop                                        -1\n",
      "     17        ASUS F555LA-AB31 15.6-inch Full-HD Laptop                         -3.625\n"
     ]
    }
   ],
   "source": [
    "#Searching for products with reviews related to processor\n",
    "product_storage = productFeatureScore(product_reviews,\"storage\")\n",
    "\n",
    "cnt =0\n",
    "table = []\n",
    "for val in range(len(product_storage)):\n",
    "    cnt+=1\n",
    "    table.append([cnt,product_dictionary[product_storage[val][0]][0],product_storage[val][1]])\n",
    "print tabulate(table,headers=[\"Item Number\",\"Product Title\",\"Sentiment Score\"], tablefmt=\"simple\", numalign=\"center\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Create Graph for Every method. \n",
    "\n",
    "def Create_Graph(var):\n",
    "    x = []\n",
    "    y = []\n",
    "    p = []\n",
    "    for i in range(len(var)):\n",
    "        p.append(i+1)\n",
    "        #print p\n",
    "        x.append(product_dictionary[var[i][0]][0])            \n",
    "        y.append(var[i][1])\n",
    "    plt.bar(p,y,align='center')\n",
    "    #plt.figure(figsize=(1,1))\n",
    "    plt.xticks(p)\n",
    "    plt.xlabel('Products')\n",
    "    plt.ylabel('Average Ratings')\n",
    "    plt.show()\n",
    "    table = []\n",
    "    cnt = 0\n",
    "    for i in x:\n",
    "        cnt+=1\n",
    "        table.append([cnt,i])\n",
    "    print tabulate(table,headers=[\"Item Number\",\"Product ID\"], tablefmt=\"grid\", numalign=\"center\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEPCAYAAAC9RFRvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa065553050>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+-------------------------------------------------------------+\n",
      "|  Item Number  | Product ID                                                  |\n",
      "+===============+=============================================================+\n",
      "|       1       | Microsoft Surface 2 (32 GB)                                 |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       2       | Acer Aspire Switch 10 E SW3-013-1566 2-in-1 Tablet & Laptop |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       3       | Dell Inspiron i7359-6790SLV 2-in-1 Touchscreen Laptop       |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       4       | Dell Inspiron i3000-5099SLV Touchscreen Laptop              |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       5       | Microsoft Surface Pro 4, Intel Core i5                      |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       6       | Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen          |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       7       | G-Tab Iota Quad Core Android Tablet PC                      |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       8       | Dell Inspiron 15 7000 Series i7537T Touchscreen Laptop      |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       9       | Microsoft Surface 3 Tablet                                  |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|      10       | ASUS F555LA-AB31 15.6-inch Full-HD Laptop                   |\n",
      "+---------------+-------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "## Create a graph of top 10 best 'Touch' feature laptop. \n",
    "\n",
    "\n",
    "Create_Graph(product_touch[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEPCAYAAACjjWTcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEu1JREFUeJzt3XmQpHV9x/F37y7HsrsNTCQLXixZI5GIqwQNils2Bszi\ngWcpqICi5vJAMaKkUsUkVSmFCooVgtHgElDBA0XFKxyxuSwRDbscC2oMyKGAcZGdBQ+EyR/fp5ne\ncXbmme7n10/3/N6vqq4+pqe/v4HtTz/9fX7P7wFJkiRJkiRJkiRJkiRJkiQNgfXAPcANXY+NAZcA\nPwAuBnarYVySlJ1FCV/7bGDdtMfeR4T9k4HLivuSpBG3im237G8BVha39yzuS5ISS7llP5OVRGuH\n4nrlLM+VJFVk0GHfbbK4SJISWzLgevcQ7Zu7gb2Ae2d60po1ayY3btw4yHFJ0kKwEXj6TD8Y9Jb9\nl4Fji9vHAl+c6UkbN25kcnJyYJeTTz7ZetYbulrWG/16g74Aa7YXvinD/nzgW8C+wB3AG4EPAIcR\nUy+fX9yXJCWWso1z1HYePzRhTUnSDOrcQTs0Wq2W9aw3dLWsN/r1hkmj7gFsx2TRf5IkldRoNGA7\nue6WvSRlwLCXpAws2LBvNsdoNBqVX5rNsbr/NEmatwXbs4/eVYq+fwP3J0gaRvbsJSlzhr0kZcCw\nl6QMGPaSlAHDXpIyYNhLUgYMe0nKgGEvSRkw7CUpA4a9JGXAsJekDBj2kpQBw16SMmDYS1IGDHtJ\nyoBhL0kZMOwlKQOGvSRlwLCXpAwY9pKUAcNekjJg2EtSBgx7ScqAYS9JGTDsJSkDhr0kZcCwl6QM\nGPaSlAHDXpIyYNhLUgbqCvuTgJuAG4DzgJ1qGockZaGOsF8FvAU4ANgfWAwcWcM4JCkbS2qouQV4\nCNgFeLi4vquGcUhSNurYst8MnAbcDvwE+AVwaQ3jkKRs1LFlvxp4J9HOuR/4HPA64FPdTxofH3/0\ndqvVotVqDWp8kjQS2u027Xa71HMbaYcyo9cAhwFvLu4fDRwEvLXrOZOTk5N9FWk0GkB/r7GdV6bf\nsUlSCpF7M+d6HW2cW4hwX0oM6lBgUw3jkKRs1BH2G4Fzge8C1xePfayGcUhSNupo45RhG0eS5mnY\n2jiSpAEz7CUpA4a9JGXAsJekDBj2kpQBw16SMmDYS1IGDHtJyoBhL0kZMOwlKQOGvSRlwLCXpAwY\n9pKUAcNekjJg2EtSBgx7ScqAYS9JGTDsJSkDhr0kZcCwl6QMGPaSlAHDXpIyMN+wXww0UwxEkpRO\nmbA/nwj4ZcANwM3AiSkHJUmqVpmw3w/YArwM+DqwCjg64ZgkSRUrE/ZLgB2IsL8IeAiYTDkoSVK1\nyoT9R4HbgOXAFcSW/f3phiRJqlqjx99ZDPy24rF0m5yc7O/LQ6PRIM0XkAb9jk2SUojcmznXl5T4\n/XczlZqdBL0f+B6woYLxSZISK7Nlfx5wINGvbwAvImbl7A1cAJySYFxu2UvSPM22ZV8m7K8EDge2\nFveXA18D1hFb90/pf4i/w7CXpHmaLezL7KDdA/hN1/2HgJXAg8Cv+h2cJCm9Mj37TwHXAF8kPjFe\nQrR2lgGb0g1NklSVsrNxngkcTPRFrga+m2xEwTaOJM1Tvz17iKmWexLfBDpJd3vfI9s+w16S5qnf\nqZdvB04G7gUe7np8/z7GtBtwFvDHRCIfB3y7j9eTJM2izJb9j4BnAT+vsO45wOXAeuIDZxnbHpXr\nlr0kzVO/s3FuJxZCq8quwFoi6CGOxB355ReazTEajUbll2ZzrO4/TdICUKaNcyvwTeCrTE3BnAQ+\n2GPNfYCfAWcDa4i5+scTUzlH1sTEfaT4JjEx0cuKFpK0rbJb9pcCOxIHVK0oLr1aAhwAnFlcPwC8\nr4/XkyTNocyW/XjFNe8sLtcW9y9ghrAfH58q22q1aLVaFQ9DkkZbu92m3W6Xeu5sPYIPE+2Vi2b4\n2SRwxLxHNuUK4M3AD4gPk6XAe7tff9R20LpDWFLdep16eW5xfdoMP+s3fd5OHJm7IzHb5419vp4k\naRZl9v69Ezi9xGNVcst+jnqSNF2/Uy+PneGxN/QxHknSgM3WxjkKeC0xVbK7b7+Cag+wkiQlNlvY\nfwv4KbHE8T8z9dVgAtiYeFySpAoN6xE79uznqCdJ0/Xbs382MSd+K3HikkeodvkESVJiZcL+DKJ3\n/0NgZ+BNxNGvkqQRUSbsIYJ+MbHE8dnE+WclSSOizHIJDwA7ETtlTwXuZnh7/ZKkGZTZsj+meN7b\niJUpHw+8MuWgJEnV6mULfTnwVuCUisfSzdk4c9STpOl6nY3zWOBfgK8R7ZvlwLuAW4DHVTtESVJK\ncy2EdhVx0pJ1wI3EeWIPJPr2kqQRMVsbZwPw9K77dwJ7s+1Jx1OxjTNHPUmartcljhcBnROgNoDN\nxPljOzZXMThJUnqzbdnfxvY3VSeBP6h8NF2v75b97PUkabrZtuyHdb68YT9HvWZzrDjJebVWrNid\nLVv80iaNIsO+UsMR9n6TkDRdvwuhSZJGnGGvUprNMRqNRuWXZnNs7uKS+la2jbMWeBKxCNoexAFW\nt6YaFLZxsq8naf76beOMAycCJxX3dwQ+WcXAJEmDUSbsXw68lFj9EuAu4jy0kqQRUSbsf02cnapj\nWaKxSJISKRP2nwM+CuwG/AVwGXBWykFJkqpVdgftC4oLwH8Cl6QZzqPcQZt5PUnz50FVlRqOMFzo\n9STNX7+zcSZmuNwJXEja9XEkSRUpcw7aDwN3AOcX948EVgPXAeuBVpKRSZIqU6aNcz3wtGmPdda6\n3wisqXpQ2MbJul6qRd7Ahd60sPXbxnkQeE3x3EXAq4FfFT+z2arKRdBPJrmk+hCRhl2ZsH8dcDRw\nb3E5Bng9sBR4W7qhSZKq4myc+b9y7W2OhV4vXa2Z60kLRa+nJexYCrwJ2A/Yuevx4/oemSRpIMq0\ncT4BrATWAZcDTwC2phyUJKlaZdo4nZk3nVk5OwBXAX+acFy2cTKuZxtH6k2/s3F+U1zfD+xPrJGz\nRyUjkyQNRJmw/xgwBvw98GVgE3BqBbUXEwdmXVTBa0mSZjHXDtpFxPIIm4l+/T4V1j6e+OBwbXxJ\nSmyuLftHiLNUVe3xwAuJpZKHdfqnJC0YZdo4lwB/S8zCGeu69ONDwHvY9qQokqREysyzP5KYGvHW\naY/32tJ5MXEk7nW4iJokDUSZsF9Vcc3nAEcQbZydgSZwLrEMw6PGx8cfvd1qtWi1WhUPQ5JGW7vd\npt1ul3pumX75MuAE4InAW4A/BPYFvtLj+Lo9j2gRvWTa486zz7ie8+yl3vQ7z/5sYq79c4r7PwH+\nqZKRBd95kpRYmbBfDZzC1MFVD1RY/3KipSNJSqhM2P+aWAytY3XxmCRpRJTZQTsOfIOYG38ecDDw\nhnRDkiRVrewBTY8BDipuXwP8LM1wHuUO2ozruYNW6k2/69lfRJxs/EtU26+XJA1ImZ79acBaYh2b\nC4BXse1JTCRJQ24+69IsAQ4h5tqvIw6GSsU2Tsb1bONIvem3jQMxG+cI4NXAAcA5lYxMkjQQZcL+\ns8RZqb4BnEHMjXcBMy0YzeYYExP3JXntFSt2Z8uWzUleW5qPMm2cdcTKlw8X99cSi6NNXxitSrZx\nMq436DaObSMtFP22cb5BtG6OIto4twKfr2pwkqT0Zgv7fYmAfw0xr/5zxCdGK/2wJElVmi3sbyZW\ntvxz4PbisROSj0iSVLnZ5tm/AvglcAXwb8Cf4SkEJWkklQnv5cBLiZbOIcSJRi4ELk44LnfQZlzP\nHbRSb2bbQTvfLfUx4gjaI4Hn9zesWRn2Gdcz7KXeVBn2g2LYZ1zPsJd60++ZqiRJI86wl6QMGPaS\nlAHDXpIyYNhLUgYMe0nKgGEvSRkw7CUpA4a9JGXAsJekDBj2kpQBw16SMmDYS1IGDHtJyoBhL0kZ\nMOylAWs2x2g0GkkuzeZY3X+ehpQnL5n/K9d+co+FXm+hn7xk0PWazTEmJu6rvNKKFbuzZcvmyl9X\nvZvt5CVLBjsUSYMWQV/9h8vExMzbin64DCfDXlKlBv3honLs2Usaaan2gSy0/R91hP0TgG8CNwE3\nAu+oYQySFoipbxLVXlK0oupURxvnIeBdwAZgOfA94BLg5hrGIklZqGPL/m4i6AG2EiH/2BrGIUnZ\nqLtnvwp4BnBNzeOQpAWtztk4y4ELgOOJLfxtjI+PP3q71WrRarUGNS5JGgntdpt2u13quXXNZdoB\n+ArwdeD0GX7uQVUZ11voBzktnHr1/1upo94wm+2gqjraOA3g48AmZg56SVLF6gj7g4HXA4cA1xWX\ndTWMQ5KyUUfP/irq3zEsSVkxdCUpA4a9JGXAsJekDBj2kpQBw16SMmDYS1IGDHtJyoBhL0kZMOwl\nKQOGvSRlwLCXpAwY9pKUAcNekjJg2EtSBgx7ScqAYS9JGTDsJSkDhr0kZcCwl6QMGPaSlAHDXpIy\nYNhLUgYMe0nKgGEvSRkw7CUpA4a9JGXAsJekDBj2kpQBw16SMmDYS1IGDHtJyoBhL0kZMOwlKQOG\nvSRlwLCXpAzUFfbrgFuAHwLvrWkMkpSNOsJ+MXAGEfj7AUcBT6lhHF3a1rPeENay3ujXGx51hP2z\ngP8BbgMeAj4NvLSGcXRpW896Q1jLeqNfb3jUEfaPA+7oun9n8ZgkKZE6wn6yhpqSlLVGDTUPAsaJ\nnj3AScAjwCldz9kArBnssCRp5G0Enl73IDqWAD8CVgE7EsFe8w5aSVIKhwPfJ3bUnlTzWCRJkiSN\nuvXAPcANA6r3BOCbwE3AjcA7EtbaGbiGaJNtAt6fsFa3xcB1wEUDqHUbcH1R7zsDqLcbcAFwM/Hf\n9KCEtfYl/q7O5X7S/nuB+JZ9E/F+OA/YKXG944taNxa3qzbT+3sMuAT4AXAx8f9UGVgLPIPBhf2e\nTO08WU60slLur9iluF4CfBt4bsJaHScAnwK+PIBatxJv3kE5BziuuL0E2HVAdRcBPyU2FlJZBfwv\nUwH/GeDYhPWeSrzvdiY2EC4BVldcY6b396nAicXt9wIfqLjm0Mp9bZwrgfsGWO9uYksbYCuxhfjY\nhPUeLK53JN5QmxPWAng88ELgLAY302tQdXYlwmN9cf+3xNb2IBxKTGq4Y64n9mELcZDjLsQH2S7A\nXQnr/RHxzfNXwMPA5cArKq4x0/v7COJDm+L6ZRXXHFq5h32dVhFbHdckrLGI+HC5h2gfbUpYC+BD\nwHuIqbSDMAlcCnwXeEviWvsAPwPOBv4b+HemvjmldiTRVklpM3AacDvwE+AXxH/bVG4kPjzHiP+O\nLyI2FlJbSbwfKK5XDqCmhsQqBtfG6VhOBNSgtip2Jdo4rYQ1Xgz8a3G7xWB69nsV13sQH2prE9Y6\nkNjyfWZx/3TgHxPW69iR+JDZI3Gd1cTGwO8RW/YXAq9LXPM44n1wOXAmsbFQtVVs+/6evqWf+tvu\n0HDLfvB2AD4PfBL44oBq3g98lQisVJ5DfEW+FTgfeD5wbsJ6EH1siDC8kFh3KZU7i8u1xf0LgAMS\n1us4HPge8TemdCDwLeDnRIvqC8T/05TWF3WfR3yT+H7iehBb83sWt/cC7h1AzaFg2A9WA/g4sQV1\neuJaj2FqpsFS4DBiVkcqf0fsQNyHaDv8F3BMwnq7ACuK28uAF5D2G9rdRM/8ycX9Q4mZK6kdRXx4\npnYLMbtoKfHv9FDSt/1+v7h+IvBy0reqICYOdHY8H8vgNrhUs/OJ/uSviTfyGxPXey7Rz97A1JS6\ndbP+Ru/2J3rLG4jpie9JVGcmzyP9bJx9iL9tA9H/HcTBeWuILfuNxJZv6tk4y4D/Y+pDLbUTmZp6\neQ7xLTSlK4p6G4BDErx+5/39G6be32PEvginXkqSJEmSJEmSJEmSJEmSJEnK1cPE8Qw3AJ8lDhrq\nVRv4kx5+b1fgr/uoK/XNI2i10D1ILDi3P3FwzV9N+/mSebzWZHGZr92Bv+nh96TKGPbKyZXAk4gj\nfK8EvkQcfbsTsZrl9cRRx63i+UuBTxPLBnyBbb8VbO26/ari9yFWUbyQqaN7n02smb6a+IZxCrE2\nyxVMfeMYxHkGJGlBmyiulxDh/pdE2G8F9i5+9m5iDX6IM0T9mPgAOKHr8f2JVS87i591XhfglUyF\n/WeYOqPUIqBZ1Olet+cEYi0hiHVolvf0l0nz4Ja9FrqlxBb0tcRpDNcTAfsdItQBDiZWIYVYefHH\nxIJna7sev4HY8p/LIcBHituPECcFmX6ClWuJdVpOBp7Gtt8SpCTm06+URtEviZ79dA9Mu7+9M15t\n7/Hu3v30nb5znT3rSuKD5MXAfwAfBD4xx+9IfXHLXorw7Zyo48nEkru3EH311xaPP5XYCu+4hzi1\n3iJied5O+F/G1MybxUQbZ4JtV658IrE+/VnFZaYPI6lShr0Wuplmz0yfVXMm8V64ntgheyzRn/8I\n0U/fBPwDcValjvcBXwGuJpbR7TieaOVcXzz/KcQJQa4mWkGnEjuANxA7g18NfLj3P0+SJEmSJEmS\nJEmSJEmSJEmSJEmSJP2O/wcVSQzOeruSXgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa04d246310>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+--------------------------------------------------------------+\n",
      "|  Item Number  | Product ID                                                   |\n",
      "+===============+==============================================================+\n",
      "|       1       | Microsoft Surface 2 (32 GB)                                  |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       2       | Dell Latitude E6420 Premium 14.1-Inch Business Laptop        |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       3       | Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop      |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       4       | Dell Inspiron i7359-6790SLV 2-in-1 Touchscreen Laptop        |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       5       | Toshiba Radius 2-in-1 11.6\" Touch-screen Laptop              |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       6       | Dell Inspiron 15 i5548-4167SLV - 15.6\" Touchscreen           |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       7       | ASUS F555LA-AB31 15.6-inch Full-HD Laptop                    |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       8       | Dell Latitude D630 14.1-Inch Notebook PC - Silver 2011 Model |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|       9       | Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                 |\n",
      "+---------------+--------------------------------------------------------------+\n",
      "|      10       | Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop            |\n",
      "+---------------+--------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "## Create a graph of top 10 best 'Processor' feature laptop. \n",
    "\n",
    "\n",
    "Create_Graph(product_processor[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEPCAYAAAC9RFRvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEsZJREFUeJzt3XuQpFV5x/Hv7A4L7GUWJm5ARFmCwWCJKwQIils2Bi1U\nvGIhaATBMjFRIUFAScViTFUSoYJCRTGJuAQQ8LKKiLeIhoYNlAjIXnDBGAUB5RaXsLPgBdnJH8/b\n27OT2d63L+ft3tPfT1VX39/nHdj+9enznvcckCRJkiRJkiRJkiRJkiRJyt5uwErgLmA9cHh/d0eS\n1I1LgVOK26PA4j7uiySpC4uBn/R7JyRpmMxJuO19gUeBS4DvA58C5iesJ0lDL2WojwIHAxcV108A\nH0xYT5KG3mjCbT9QXG4t7q9kRqgvW7Zsas2aNQl3QZKytAZ40WxPpGypPwTcD+xf3D8K+MFWe7Vm\nDVNTU5VdzjnnHOtZz3pDUK/qv63qC7BsW8GbsqUO8D7gCmAe8GPg5MT1JGmopQ71NcChiWtIkgop\nu18GTq1Ws571rDcE9ar+2wbJSJ/rTxX9Q5KkkkZGRmAb+T1ULXVJyp2hLkkZMdQlKSOGuiRlxFCX\npIwY6pKUEUNdkjJiqEtSRgx1ScqIoS5JGTHUJSkjhrokZcRQl6SMGOqSlBFDXZIyYqhLUkYMdUnK\nyA4f6mNj44yMjCS5jI2N9/vPk6S27PDL2cWyTqmWxBvB5fYkDRqXs5OkIWGoS1JGDHVJyoihLkkZ\nMdQlKSOGuiRlxFCXpIyMVlDjXmAj8DTwFHBYBTUlaShVEepTQA3YUEEtSRpqVXW/9PvMVUkaClWE\n+hTwbeA24F0V1JOkoVVF98sRwIPAEuA64G5gVQV1JWnoVBHqDxbXjwJXEwdKt4T6xMTElhfWajVq\ntVoFuyRJO456vU69Xi/12tR93fOBucAksAD4FvDh4hqcpVGS2tZqlsbULfU9iNZ5o9YVNANdktRj\n/R6VYktdktrkfOqSNCQMdUnKiKEuSRkx1CUpI4a6JGXEUJekjBjqkpQRQ12SMmKoS1JGDHVJyoih\nLkkZMdQlKSOGuiRlxFCXpIwY6pKUEUNdkjJiqEtSRgx1ScqIoS5JGTHUJSkjhrokZcRQl6SMGOqS\nlBFDXZIyYqi3aWxsnJGRkZ5fxsbGB6KepB3bSJ/rT01NTXW1gZGREaC7bbTYOjP3L129/1+rH/Uk\nDb7Ihdnz25a6JGXEUJekjBjqkpSRKkJ9LnAHcG0FtSRpqLUb6nOBsTbfcxqwnnRHMyVJhTKhfhUR\n5AuAdcBdwFklt7838GrgYvo/0kaSslcm1J8PbATeAHwDWAq8veT2PwacCWzuZOckSe0ZLfmanYhQ\n/wTwFOW6Uo4BHiH602vbetHExMSW27VajVptmy+VpKFUr9ep1+ulXlumS+RU4APAWuA1wHOAy4Hl\n23nf3xMt+t8CuxBdOF8ETpz2Gk8+alGrH/UkDb5WJx910s89Qhww/W0b73kZcAbw2hmPG+otavWj\nnqTB1yrUy3S/vJ9mqjQS5nHgdmB1G/thgkhSYmVa6lcChxDjzEeILph1wD7ASuDcLurbUm9Rqx/1\nJA2+brtfVgGvAjYV9xcCXweOJlrrB3Sxb4Z6i1r9qCdp8HU7odcS4DfT7j8F7AE8Cfyq252TJPVO\nmT71K4BbgC8T3wyvJbpkFhBnikqSBkTZ0S+HAkcQ/QA3Abf1qL7dLy1q9aOepMHXiyGNc4E9iZZ9\nIwnu63rPDPWWtfpRT9Lg63ZI4/uAc4izQ5+e9viBXe+ZJKmnyrTUfwwcBvwiQX1b6i1q9aOepMHX\n7eiX+4gJvSRJA65M98s9wPXA12gObZwCPppqpyRJnSkT6vcVl3nFJWV/hySpC/1euMI+9Ra1+lFP\n0uDrdPTLhcRSdLOtLToFvK7rPZMk9VSrUL+suD5/luds4knSAGoV6rcX1y8CLpjx3F8CNyTZI0lS\nx8oMaTxplsfe0eP9kCT1QKuW+gnAW4F92bpffRFpTkSSJHWpVajfDDxITL37jzSPtE4CaxLvlySp\nAw5pbL11hzRKGjjdThPwYuBWYuWjp4DNOG2AJA2kMqH+caJv/UfALsA7gYtS7pQkqTNlQh0i0OcS\nU+9eQqxPKkkaMGXmfnkC2Jk4OHoe8BD974uXJM2iTEv9xOJ17yUWm94bODblTkmSOtNJi3sh8B7g\n3B7Ud/RLi1r9qCdp8HU6+mUv4J+ArxPdLguBvwLuBp7V212UJPXC9ib0+k9icYyjgTuB7wKHEP3q\nkqQB06r7ZTUxmVfDA8A+bL34dLfsfmlRqx/1JA2+TudTnwOMN7YBbAAWT3t+Qy92TpLUO61a6vey\n7SbiFPB7Jba/CzFF787EUnjXAGdP344t9W3X6kc9SYOvVUu9ivHm84mhkKNEH/0ZxTUY6i1r9aOe\npMHX7dwv3XqyuJ5HnJVqt40kJVJFqM8hDro+DFwPrK+gpiQNpTLTBHRrMzGKZjHw70ANqDeenJiY\n2PLCWq1GrVarYJe0LWNj40xOPtbz7S5atDsbN/ojTepEvV6nXq+Xem3ZPvXlwHOJybyWECci3dPB\nvn0I+CWx6AbYp96y1jDUk9S+bvvUJ4CzaI5amQd8pmTtZwC7Fbd3BV4B3FHyvZKkNpXpfnkjcBBw\ne3H/Z8Q6pWU8E7iU+PKYA1wOfKfNfZQklVQm1H9N9Is3LGhj++uAg9vaI0lSx8p0v3wB+BeiG+VP\niZb2xSl3SpLUmbIHSl9ZXCBGsFzXo/oeKG1RaxjqSWpfv88obcVQb1FrGOpJal+3o18mZ7k8AFxN\nuflfJEkVKXOg9ELgfuCq4v7xwH7E0MQVxMlEkqQBUKb7ZS3wwhmPNeZaXwMs66K+3S8tag1DPUnt\n67b75UngLTTHmh8H/Kp4zk+pJA2QMqH+NuDtwCPF5UTgT4gzRN+bbtckSe1y9Evrrdv9kriepPZ1\nupxdw67AO4HnEysZNZzS9Z5JknqqTPfL5cAewNHE0nTPBjal3ClJUmfKdL80Rro0RsHsRCxH90c9\nqG/3S4taw1BPUvu6Hf3ym+L6ceBAYg6YJT3ZM0lST5XpU/9XYBz4G+ArxAIZH0q5U5Kkzmwv1OcQ\n0wJsIPrT902+R5Kkjm2v+2UzseqRJGkHUKZP/TrgDGLUy/i0iyRpwJQZ/XIvsw+H6EVXjKNfWtQa\nhnqS2tftyUdLe7kzkqR0ynS/LCBGu3yquP/7wDHJ9kiS1LEyoX4JMVb9JcX9nwN/l2yPJEkdKxPq\n+wHn0jwJ6Yl0uyNJ6kaZUP81MalXw37FY5KkAVPmQOkE8E1gb+BK4AjgHel2SZLUqbLzqT8DOLy4\nfQvwaI/qO6SxRa1hqCepfd0OabyWWHT6GuxPl6SBVqZP/XxgObAeWAm8ma0Xy5AkDYh2lrMbBY4E\n3kUsmDHWg/p2v7SoNQz1JLWv2/nUIUa/HAu8GzgUuLTk+54NXA/8ALgTOLXk+yRJHSjTUv88scrR\nN4HPElPwbi65/T2Ly2piHvbbgTcAdxXP21JvUWsY6klqX7cHSlcAJwBPF/eXA8cD7ynx3oeKC8S6\npncBe9EMdUlSD5UJ9W8CBxPBfhxwD/DFDmotBQ4ihkRKkhJoFerPI4L8LcS49C8Qzf1aB3UWEiNn\nTiNa7FtMTExsuV2r1ajVOtm8JOWrXq9Tr9dLvbZVn/pm4KvAe4H7isfuof151HcqtvMN4IIZz9mn\n3qLWMNST1L5OR7+8CfglcCPwz8Afb2sjrWoDnybGuM8MdElSj5UJ6YXA64mumCOBy4CrgW+VeO9L\niS+FtTSbf2cT/fRgS71lrWGoJ6l9rVrq7ba8x4kzSo8HXt7dbgGGestaw1BPUvt6Geq9Zqi3qDUM\n9cbGxpmcfKzn1RYt2p2NGzf0vZ6UgqHe+dYNdet1VU9KoRfTBEiSdgCGuiRlxFCXpIwY6pKUEUNd\nkjJiqEtSRgx1ScqIoS4lNDY2zsjISM8vY2Pj/f7TNKA8+aj11j35yHo7VD0NB08+kqQhYahLUkYM\ndUnKiKEuSRkx1CUpI4a6JGXEUJekjBjqkpQRQ12SMmKoS1JGDHVJyoihLkkZMdQlKSOGuiRlxFCX\npIwY6pKUEUNdkjKSOtRXAA8D6xLXkUS1y+elquVyfd1JvZzdcmATcBlw4CzPu5xdi1rWs94g16v6\ns6emfi5ntwp4LHENSUPAXwbljPZ7BySpjMnJx0j1y2ByMnWnRXU8UCpJGel7S31iYmLL7VqtRq1W\n69u+SNIgqtfr1Ov1Uq+t4jfHUuBaPFDadi3rWW+Q6+Xz2Zu93iDr54HSq4Cbgf2B+4GTE9eTpKHW\n76MDttRb1LKe9Qa5Xj6fvdnrDbJ+ttQlSRUy1CUpI4a6JGXEUJekjBjqkpQRQ12SMmKoS1JGDHVJ\nyoihLkkZMdQlKSOGuiRlxFCXpIwY6pKUEUNdkjJiqEtSRgx1ScqIoS5JGTHUJSkjhrokZcRQl6SM\nGOqSlBFDXZIyYqhLUkYMdUnKiKEuSRkx1CUpI4a6JGXEUJekjKQO9aOBu4EfAR9IXEuShl7KUJ8L\nfJwI9ucDJwAHJKxXQt161rPeUNSrstZgSRnqhwH/DdwLPAV8Fnh9wnol1K1nPesNRb0qaw2WlKH+\nLOD+afcfKB6TJCWSMtSnEm5bkjSLkYTbPhyYIPrUAc4GNgPnTnvNamBZwn2QpBytAV5UddFR4MfA\nUmAeEeB9PlAqSerGq4AfEgdMz+7zvkiSJEkaNCuAh4F1FdV7NnA98APgTuDUxPV2AW4hurjWA/+Q\nuB7EeQh3ANdWUAtiaOzaoub3EtfaDVgJ3EX89zw8Ya3nEX9T4/I46f+9nE3821wHXAnsnLjeaUWt\nO4vbvTbb53scuA74L+BbxP9TZWQ5cBDVhfqeNA9iLCS6oFIfT5hfXI8C3wVemrje6cAVwFcS12m4\nh/igVuFS4JTi9iiwuKK6c4AHiUZBKkuBn9AM8s8BJyWs9wLic7cL0RC4DtivxzVm+3yfB5xV3P4A\n8JEe1xxYwzL3yyrgsQrrPUS0mgE2ES2+vRLXfLK4nkd8eDYkrLU38GrgYtKOoJqpilqLiZBYUdz/\nLdF6rsJRxOCC+7f3wi5sJE4GnE98Yc0Hfpaw3h8QvyJ/BTwN3AC8qcc1Zvt8v474cqa4fkOPaw6s\nYQn1flpKtCJuSVxnDvFF8jDR9bM+Ya2PAWcSQ1SrMgV8G7gNeFfCOvsCjwKXAN8HPkXzV1BqxxPd\nISltAM4H7gN+Dvwv8d81lTuJL8lx4r/ja4hGQWp7EJ8Fius9Kqipii2luu6XhoVECFXZSlhMdL/U\nEm3/GOATxe0a1fWpP7O4XkJ8eS1PVOcQoiV7aHH/AuBvE9Wabh7xZbIkcZ39iC/83yFa6lcDb0tc\n8xTic3ADcBHRKOi1pWz9+Z7Zck/5y3Wg2FJPZyfgi8BngC9XWPdx4GtEOKXwEuKn7T3AVcDLgcsS\n1ZruweL6USKIDktU54HicmtxfyVwcKJa070KuJ34+1I6BLgZ+AXRtfQl4v9pSiuKui8jfhn8MHE9\niNb5nsXtZwKPVFBzIBjqaYwAnyZaRBdUUO8ZNI/u7wq8ghhJkcJfEwfy9iW6C/4DODFRrYb5wKLi\n9gLglaT71fUQ0ae9f3H/KGKkSGonEF+Sqd1NjObZlfh3ehRpu+oAfre4fg7wRtJ3MUEcwG8cAD6J\nahtWqsBVRP/hr4kP7MmJ672U6G9eTXOo2tEt39GdA4n+39XEsL8zE9aa7mVUM/plX+JvW0300aY+\nkW0Z0VJfQ7RkU49+WQD8D80vrtTOojmk8VLiV2VKNxb1VgNHJth+4/P9G5qf73HiWIFDGiVJkiRJ\nkiRJkiRJkiRJkiR16mnifIB1wOeJk2s6VQf+sIP3LQb+vIu6Utc8o1S5eJKYOO1A4iSUd894frSN\nbU3R2cLpuwN/0cH7pJ4x1JWjVcBziTNeVwHXEGei7kzMvriWOAO3Vrx+V+CzxOnyX2LrVv6mabff\nXLwfYta/q2me6fpiYs7u/YhfDOcSc4/cSPMXROo57iUpG5PF9SgR4n9GhPomYJ/iufcTc8BDrDj0\nUyLoT5/2+IHELI2NSbwa2wU4lmaof47mCkVzgLGizvQ5aU4n5sqBmGdlYUd/mdQGW+rKxa5Ei/hW\nYum7FUSQfo8Ib4AjiFkzIWYK/CkxcdfyaY+vI1ry23Mk8Mni9mZi8YmZi3jcSsxDcg7wQrZu9UtJ\ntNPPKA2yXxJ96jM9MeP+tlZP2tbj0/vWZx583d5KTKuIL4xjgH8DPgpcvp33SF2xpa5hsormghD7\nE1PB3k30e7+1ePwFRKu64WFiSbY5xLSxjZD/Ds2RLnOJ7pdJtp5p8TnE/OgXF5fZvnSknjLUlYvZ\nRqvMHMVyEfFvfi1xYPQkov/8k0R/93rgw8QqPQ0fBL4K3ERM79pwGtEFs7Z4/QHEwhM3EV045xEH\nYlcTB2WPAy7s/M+TJEmSJEmSJEmSJEmSJEmSJEmSJKkL/weROWGw3pj20QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa04d46b510>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+-------------------------------------------------------------+\n",
      "|  Item Number  | Product ID                                                  |\n",
      "+===============+=============================================================+\n",
      "|       1       | Microsoft Surface 2 (32 GB)                                 |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       2       | Dell Inspiron 15.6-Inch Touchscreen Laptop (i15RVT-6195BLK) |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       3       | Dell Inspiron i3531-1200BK 16-Inch Laptop,Black             |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       4       | G-Tab Iota Quad Core Android Tablet PC                      |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       5       | Dell Inspiron i5748-2143sLV 17.3-Inch Laptop                |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       6       | 2015 Newest Model DELL Inspiron 15 Touchscreen Laptop       |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       7       | Dell Inspiron 11 3000 Series 2-in-1  11.6 Inch Laptop       |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       8       | Dell Inspiron 15 i5548-1670SLV Touchscreen Laptop           |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|       9       | Dell - Inspiron I3542-11001BK 15.6\" Touch-Screen Laptop     |\n",
      "+---------------+-------------------------------------------------------------+\n",
      "|      10       | 2015 Newest Model Dell XPS13 Ultrabook Computer             |\n",
      "+---------------+-------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "## Create a graph of top 10 best 'Storage' feature laptop. \n",
    "\n",
    "\n",
    "Create_Graph(product_storage[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of Reviews collected are 2829.\n"
     ]
    }
   ],
   "source": [
    "## Storing one by one processed review in result set. So result set has all the reviews. \n",
    "\n",
    "\n",
    "result = []\n",
    "for i in product_ids:\n",
    "    reviews = file2string(\"Reviews_Data/\"+ i +\".txt\")\n",
    "    for review_line in reviews:\n",
    "        review = review_line.split(\"->\")[1]\n",
    "        r1 = processAll(review)\n",
    "        \n",
    "        result.append(review)\n",
    "        \n",
    "print \"Total number of Reviews collected are %d.\" %len(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "######     Do not run this code   #########\n",
    "## I have already done this and store all the reviews in Data Folder. This will make a different file for each \n",
    "##  review and store in Data Folder. \n",
    "\n",
    "i = 1\n",
    "rslt = []\n",
    "for review in result:\n",
    "    #print review\n",
    "    score = calculateSynsetScore(review)\n",
    "    rslt.append((review,score))\n",
    "    f = open('Data/r'+ str(i) +'.txt','w+')\n",
    "    f.write(review)\n",
    "    f.close()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subdirectories are:['test', 'train']\n"
     ]
    }
   ],
   "source": [
    "# Here is the path to the data directory.\n",
    "\n",
    "path = 'Data'\n",
    "print('subdirectories are:' + str(os.listdir(path)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## To get the list of files on specific path. \n",
    "\n",
    "def get_files(path):\n",
    "    list = []\n",
    "    #get list of files in geiven directory\n",
    "    for a in sorted(os.listdir(path)):\n",
    "        #append all files path to list\n",
    "        list.append(path + os.sep + a)\n",
    "    return list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "files = get_files('Data/train/pos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "######     Do not run this code   #########\n",
    "## This script is for distinguishing reviews based on it's sentiment score. if sentiment score > 0 then put it in pos folder\n",
    "##      else move into neg folder. DO this procedure separately for train and test data both.  \n",
    "\n",
    "pos = []\n",
    "neg = []\n",
    "\n",
    "dest1 = 'Data/train/pos'        ## or 'Data/test/pos'\n",
    "dest2 = 'Data/train/neg'        ## or 'Data/train/neg'\n",
    "\n",
    "for file in files:\n",
    "    f = open(file,'r+')\n",
    "    m = processAll(f.read())\n",
    "    review = replace_with_not(m)\n",
    "    score = calculateSynsetScore(review)\n",
    "    if score > 0:\n",
    "        #pos.append(m)\n",
    "        shutil.move(file, dest1)\n",
    "    else:\n",
    "        #neg.append(m)\n",
    "        shutil.move(file, dest2)\n",
    "    \n",
    "        \n",
    "    f.close()\n",
    "\n",
    "    f = open(file,'wb')\n",
    "    f.write(str(review))\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found 1103 positive and 1093 negative training files\n",
      "first positive file: Data/train/pos/r1.txt\n",
      "first negative file: Data/train/neg/r10.txt\n"
     ]
    }
   ],
   "source": [
    "pos_train_files = get_files(path + os.sep + 'train' + os.sep + 'pos')\n",
    "neg_train_files = get_files(path + os.sep + 'train' + os.sep + 'neg')\n",
    "all_train_files = pos_train_files + neg_train_files\n",
    "\n",
    "print('found %d positive and %d negative training files' %\n",
    "      (len(pos_train_files), len(neg_train_files)))\n",
    "print('first positive file: %s' % pos_train_files[0])\n",
    "print('first negative file: %s' % neg_train_files[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first 3 and last 3 labels are: [1 1 1 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "def get_true_labels(file_names):\n",
    "    \"\"\"Return a *numpy array* of ints for the true sentiment labels of each file.\n",
    "    1 means positive, 0 means negative. Use the name of the file to determine\n",
    "    the true label.\n",
    "    Params:\n",
    "        file_names....a list of .txt file paths, e.g., Data/train/pos/r1.txt\n",
    "    Returns:\n",
    "        a numpy array of 1 or 0 values corresponding to each element\n",
    "        of file_names, where 1 indicates a positive review, and 0\n",
    "        indicates a negative review.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    labels =[]\n",
    "    for f in file_names:\n",
    "        if 'pos' in f:\n",
    "            labels.append(1)\n",
    "        elif 'neg' in f:\n",
    "            labels.append(0)\n",
    "    lst = np.array(labels)\n",
    "    return lst\n",
    "\n",
    "labels = get_true_labels(all_train_files)\n",
    "print('first 3 and last 3 labels are: %s' % str(labels[[1,2,3,-3,-2,-1]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive Product Review:  just exactly what i wanted and would recommend to anyone looking for a great personal computer for everyday use very satisfied \n",
      "\n",
      "Negative Product Review:  it s disappointing how limited this version of the surface is my daughter cannot use many online textbooks or watch videos for school because the microsoft 8 rt os doesn t allow installation of the necessary plugins or software \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#let's look randomly how does a Posotive and negative review look like\n",
    "\n",
    "f = open(pos_train_files[3],'r')\n",
    "print \"Positive Product Review: \", f.read(), \"\\n\"\n",
    "f.close()\n",
    "\n",
    "f = open(neg_train_files[0],'r')\n",
    "print \"Negative Product Review: \", f.read(), \"\\n\"\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def tokenize(text):\n",
    "    \"\"\"Given a string, return a list of tokens such that: (1) all\n",
    "    tokens are lowercase, (2) all punctuation is removed. Note that\n",
    "    underscore (_) is not considered punctuation.\n",
    "    Params:\n",
    "        text....a string\n",
    "    Returns:\n",
    "        a list of tokens\n",
    "    \"\"\"\n",
    "    \"\"\"regex = re.compile('[%s]' % re.escape(string.punctuation))\n",
    "    text = regex.sub('\\P{P}_','',text)\n",
    "    #text = regex.sub(\\P{P}_+,\"\", text)\n",
    "    #text = text.translate(string.maketrans(\"\",\"\"), string.punctuation)\n",
    "    #preg_replace('/^[^\\P{P}_-]+|[^\\P{P}_-]+$/u', '', text)\n",
    "    print text   \"\"\"\n",
    "    \n",
    "    return re.sub('\\W', ' ', text).lower().split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Including Common Stop Words Matrix represents 2196 Documents with 7689 Features \n",
      "\n",
      "first document has terms:\n",
      "[6, 28, 93, 164, 203, 235, 282, 323, 356, 505, 528, 547, 577, 578, 584, 590, 595, 612, 615, 663, 678, 694, 702, 727, 753, 808, 823, 881, 922, 931, 959, 972, 1022, 1174, 1188, 1216, 1222, 1244, 1409, 1488, 1495, 1632, 1728, 1731, 1757, 1818, 1867, 1886, 1889, 1906, 1991, 2021, 2039, 2157, 2167, 2169, 2173, 2181, 2236, 2293, 2295, 2324, 2345, 2461, 2463, 2465, 2474, 2486, 2492, 2504, 2548, 2557, 2584, 2674, 2694, 2726, 2729, 2790, 2824, 2836, 2870, 2886, 2912, 2929, 2935, 2975, 3006, 3028, 3032, 3050, 3061, 3102, 3151, 3201, 3213, 3368, 3376, 3402, 3433, 3483, 3576, 3589, 3591, 3612, 3645, 3680, 3695, 3702, 3707, 3712, 3768, 3784, 3839, 3919, 3945, 3983, 4006, 4039, 4040, 4045, 4060, 4065, 4153, 4156, 4165, 4184, 4230, 4244, 4292, 4300, 4318, 4343, 4395, 4401, 4413, 4424, 4439, 4445, 4476, 4490, 4496, 4556, 4571, 4573, 4653, 4662, 4678, 4681, 4722, 4732, 4737, 4738, 4746, 4762, 4907, 5048, 5055, 5077, 5093, 5107, 5127, 5200, 5207, 5217, 5310, 5311, 5433, 5444, 5483, 5689, 5749, 5819, 5830, 5854, 5862, 5863, 5878, 5891, 5946, 5951, 6040, 6088, 6128, 6140, 6148, 6182, 6235, 6267, 6355, 6368, 6393, 6410, 6437, 6456, 6490, 6491, 6546, 6547, 6634, 6651, 6689, 6708, 6735, 6745, 6777, 6810, 6812, 6815, 6837, 6843, 6855, 6859, 6889, 6909, 6927, 7082, 7085, 7211, 7213, 7215, 7216, 7246, 7250, 7253, 7259, 7309, 7316, 7390, 7413, 7443, 7446, 7454, 7465, 7469, 7472, 7478, 7486, 7516, 7524, 7548, 7585, 7589, 7606, 7665]\n"
     ]
    }
   ],
   "source": [
    "def do_vectorize_including_stop_words(filenames, tokenizer_fn=tokenize, min_df=1,\n",
    "                 max_df=1., binary=True, ngram_range=(1,1)):\n",
    "    \"\"\"\n",
    "    Convert a list of filenames into a sparse csr_matrix, where\n",
    "    each row is a file and each column represents a unique word.\n",
    "    Use sklearn's CountVectorizer: http://goo.gl/eJ2PJ5\n",
    "    Params:\n",
    "        filenames.......list of review file names\n",
    "        tokenizer_fn....the function used to tokenize each document\n",
    "        min_df..........remove terms from the vocabulary that don't appear\n",
    "                        in at least this many documents\n",
    "        max_df..........remove terms from the vocabulary that appear in more\n",
    "                        than this fraction of documents\n",
    "        binary..........If true, each documents is represented by a binary\n",
    "                        vector, where 1 means a term occurs at least once in \n",
    "                        the document. If false, the term frequency is used instead.\n",
    "        ngram_range.....A tuple (n,m) means to use phrases of length n to m inclusive.\n",
    "                        E.g., (1,2) means consider unigrams and bigrams.\n",
    "    Return:\n",
    "        A tuple (X, vec), where X is the csr_matrix of feature vectors,\n",
    "        and vec is the CountVectorizer object.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    \n",
    "    vec = CountVectorizer(input = 'filename', tokenizer = tokenizer_fn,\n",
    "                         min_df = min_df, max_df = max_df, binary = binary, ngram_range = ngram_range,dtype=int)    \n",
    "    X=vec.fit_transform(filenames)\n",
    "    return (X,vec)\n",
    "\n",
    "    \n",
    "matrix_stop, vec_stop = do_vectorize_including_stop_words(all_train_files)\n",
    "print ('Including Common Stop Words Matrix represents %d Documents with %d Features ' % (matrix_stop.shape[0], matrix_stop.shape[1]))\n",
    "print\n",
    "print('first document has terms:\\n%s' % (str(sorted(matrix_stop[1].nonzero()[1]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'a', u'about', u'above', u'after', u'again', u'against', u'all', u'am', u'an', u'and', u'any', u'are', u\"aren't\", u'as', u'at', u'be', u'because', u'been', u'before', u'being', u'below', u'between', u'both', u'but', u'by', u\"can't\", u'cannot', u'could', u\"couldn't\", u'did', u\"didn't\", u'do', u'does', u\"doesn't\", u'doing', u\"don't\", u'down', u'during', u'each', u'few', u'for', u'from', u'further', u'had', u\"hadn't\", u'has', u\"hasn't\", u'have', u\"haven't\", u'having', u'he', u\"he'd\", u\"he'll\", u\"he's\", u'her', u'here', u\"here's\", u'hers', u'herself', u'him', u'himself', u'his', u'how', u\"how's\", u'i', u\"i'd\", u\"i'll\", u\"i'm\", u\"i've\", u'if', u'in', u'into', u'is', u\"isn't\", u'it', u\"it's\", u'its', u'itself', u\"let's\", u'me', u'more', u'most', u\"mustn't\", u'my', u'myself', u'no', u'nor', u'not', u'of', u'off', u'on', u'once', u'only', u'or', u'other', u'ought', u'our', u'ours', u'ourselves', u'out', u'over', u'own', u'same', u\"shan't\", u'she', u\"she'd\", u\"she'll\", u\"she's\", u'should', u\"shouldn't\", u'so', u'some', u'such', u'than', u'that', u\"that's\", u'the', u'their', u'theirs', u'them', u'themselves', u'then', u'there', u\"there's\", u'these', u'they', u\"they'd\", u\"they'll\", u\"they're\", u\"they've\", u'this', u'those', u'through', u'to', u'too', u'under', u'until', u'up', u'very', u'was', u\"wasn't\", u'we', u\"we'd\", u\"we'll\", u\"we're\", u\"we've\", u'were', u\"weren't\", u'what', u\"what's\", u'when', u\"when's\", u'where', u\"where's\", u'which', u'while', u'who', u\"who's\", u'whom', u'why', u\"why's\", u'with', u\"won't\", u'would', u\"wouldn't\", u'you', u\"you'd\", u\"you'll\", u\"you're\", u\"you've\", u'your', u'yours', u'yourself', u'yourselves']\n",
      "\n",
      "There are total 174 stop words in English\n"
     ]
    }
   ],
   "source": [
    "##  Get the Common stop words in English \n",
    "##  https://github.com/Alir3z4/python-stop-words\n",
    "\n",
    "\n",
    "from stop_words import get_stop_words\n",
    "\n",
    "stop_words = get_stop_words('english')\n",
    "print stop_words\n",
    "print\n",
    "\n",
    "print (\"There are total %d stop words in English\" % len(stop_words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our feature vector has 120 stop words\n"
     ]
    }
   ],
   "source": [
    "## Find how many words are there in our feature matrix\n",
    "\n",
    "cnt = len(set(vec_stop.get_feature_names()).intersection(stop_words))\n",
    "print \"Our feature vector has %d stop words\" % (cnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix represents 2196 documents with 7409 features excluding stop words\n",
      "\n",
      "first document has terms:\n",
      "[6, 28, 93, 164, 203, 235, 282, 323, 501, 539, 636, 651, 667, 777, 791, 887, 911, 923, 973, 1162, 1187, 1352, 1431, 1438, 1574, 1668, 1671, 1697, 1757, 1806, 1825, 1828, 1845, 1929, 1958, 1976, 2103, 2105, 2109, 2117, 2170, 2224, 2226, 2255, 2274, 2386, 2404, 2410, 2421, 2465, 2474, 2501, 2591, 2642, 2700, 2734, 2791, 2837, 2876, 2927, 2931, 2959, 3000, 3261, 3455, 3468, 3470, 3491, 3523, 3557, 3578, 3641, 3656, 3711, 3788, 3813, 3851, 3874, 3907, 3908, 3913, 3928, 3933, 4020, 4023, 4032, 4107, 4155, 4163, 4180, 4204, 4258, 4269, 4294, 4326, 4340, 4346, 4399, 4413, 4497, 4560, 4583, 4726, 4864, 4871, 4893, 4909, 4923, 4943, 5016, 5023, 5033, 5126, 5127, 5246, 5257, 5296, 5502, 5562, 5632, 5643, 5667, 5675, 5690, 5703, 5758, 5763, 5893, 5930, 5942, 5982, 6035, 6147, 6160, 6185, 6202, 6229, 6248, 6281, 6282, 6337, 6338, 6424, 6441, 6478, 6523, 6533, 6564, 6611, 6654, 6689, 6839, 6842, 6966, 6968, 6969, 6997, 7001, 7004, 7010, 7060, 7139, 7190, 7193, 7201, 7253, 7311, 7315]\n"
     ]
    }
   ],
   "source": [
    "def do_vectorize(filenames, tokenizer_fn=tokenize, min_df=1,\n",
    "                 max_df=1., binary=True, ngram_range=(1,1)):\n",
    "    \n",
    "    \"\"\"\n",
    "    Convert a list of filenames into a sparse csr_matrix, where\n",
    "    each row is a file and each column represents a unique word.\n",
    "    Use sklearn's CountVectorizer: http://goo.gl/eJ2PJ5\n",
    "    Params:\n",
    "        filenames.......list of review file names\n",
    "        tokenizer_fn....the function used to tokenize each document\n",
    "        min_df..........remove terms from the vocabulary that don't appear\n",
    "                        in at least this many documents\n",
    "        max_df..........remove terms from the vocabulary that appear in more\n",
    "                        than this fraction of documents\n",
    "        binary..........If true, each documents is represented by a binary\n",
    "                        vector, where 1 means a term occurs at least once in \n",
    "                        the document. If false, the term frequency is used instead.\n",
    "        ngram_range.....A tuple (n,m) means to use phrases of length n to m inclusive.\n",
    "                        E.g., (1,2) means consider unigrams and bigrams.\n",
    "    Return:\n",
    "        A tuple (X, vec), where X is the csr_matrix of feature vectors,\n",
    "        and vec is the CountVectorizer object.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    vec = CountVectorizer(input='filename', tokenizer=tokenizer_fn, min_df=min_df,\n",
    "                 max_df=max_df, binary=binary, ngram_range=ngram_range, stop_words = 'english', dtype=int)\n",
    "    \n",
    "    X = vec.fit_transform(filenames)   \n",
    "    return (X,vec)\n",
    "    \n",
    "matrix, vec = do_vectorize(all_train_files)\n",
    "print ('matrix represents %d documents with %d features excluding stop words' % (matrix.shape[0], matrix.shape[1]))\n",
    "print \n",
    "print('first document has terms:\\n%s' % ((sorted(matrix[1].nonzero()[1]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tokenize_with_not(text):\n",
    "    \"\"\"Does the same thing as tokenize_with_punct, with the following difference:\n",
    "    whenever the term 'not' appears, change the two subsequent tokens to have the prefix\n",
    "    'not_' prior to the token. See the example below. You may call \n",
    "    tokenize_with_punct as a subroutine.\n",
    "    Params:\n",
    "        text....a string\n",
    "    Returns:\n",
    "        a list of tokens\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    not_tokens = tokenize(text)\n",
    "    i=0\n",
    "    while (i<len(not_tokens)):\n",
    "        if not_tokens[i] == 'not':\n",
    "            if i < len(not_tokens)-2:\n",
    "                not_tokens[i+1] = \"not_\" + not_tokens[i+1]\n",
    "                not_tokens[i+2] = \"not_\" + not_tokens[i+2]\n",
    "                i+=2\n",
    "                \n",
    "            elif i< len(not_tokens)-1:\n",
    "                not_tokens[i+1] =\"not_\"+ not_tokens[i+1]\n",
    "                i+=1\n",
    "                \n",
    "        i+=1\n",
    "        \n",
    "    return not_tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first shuffled document Data/train/pos/r1181.txt has label 1 and terms: [71, 1415, 1459, 1874, 1910, 1929, 2229, 2404, 2417, 2552, 2566, 2941, 2958, 3210, 3581, 3732, 3900, 4508, 4552, 4871, 5056, 5650, 5839, 6095, 6611, 6966, 7001, 7012, 7313, 7315, 7375]\n"
     ]
    }
   ],
   "source": [
    "# Do not modify. This is to randomize the order of the documents, but\n",
    "# in a way that is consistent across platforms.\n",
    "# See: http://stackoverflow.com/a/18992474/1756896\n",
    "# You should run this block once to get the shuffled data.\n",
    "def repeatable_random(seed):\n",
    "    hash = str(seed)\n",
    "    while True:\n",
    "        hash = hashlib.md5(hash).digest()\n",
    "        for c in hash:\n",
    "            yield ord(c)\n",
    "\n",
    "def repeatable_shuffle(X, y, filenames):\n",
    "    r = repeatable_random(42) \n",
    "    indices = sorted(range(X.shape[0]), key=lambda x: next(r))\n",
    "    return X[indices], y[indices], np.array(filenames)[indices]\n",
    "\n",
    "X, y, filenames = repeatable_shuffle(matrix, labels, all_train_files)\n",
    "\n",
    "print('first shuffled document %s has label %d and terms: %s' % \n",
    "      (filenames[0], y[0], sorted(X[0].nonzero()[1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Naive Bayes Classifier\n",
    "#  http://scikit-learn.org/stable/modules/naive_bayes.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "def get_clf_naive():\n",
    "    return MultinomialNB(alpha = 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fold 0 accuracy=0.7250\n",
      "fold 1 accuracy=0.6697\n",
      "fold 2 accuracy=0.6310\n",
      "fold 3 accuracy=0.6651\n",
      "fold 4 accuracy=0.6856\n",
      "average cross validation accuracy=0.6753\n"
     ]
    }
   ],
   "source": [
    "def do_cross_validation(X, y, n_folds=5, verbose=False):\n",
    "    \"\"\"\n",
    "    Perform n-fold cross validation, calling get_clf() to train n\n",
    "    different classifiers. Use sklearn's KFold class: http://goo.gl/wmyFhi\n",
    "    Be sure not to shuffle the data, otherwise your output will differ.\n",
    "    Params:\n",
    "        X.........a csr_matrix of feature vectors\n",
    "        y.........the true labels of each document\n",
    "        n_folds...the number of folds of cross-validation to do\n",
    "        verbose...If true, report the testing accuracy for each fold.\n",
    "    Return:\n",
    "        the average testing accuracy across all folds.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    g = get_clf_naive()\n",
    "    kf = cross_validation.KFold(len(y), n_folds=n_folds)\n",
    "    accuracies = []\n",
    "    \n",
    "    for train_idx, test_idx in kf:    \n",
    "        g.fit(X[train_idx], y[train_idx])\n",
    "        #print len(train_idx)\n",
    "        predicted = g.predict(X[test_idx])\n",
    "        acc = accuracy_score(y[test_idx], predicted)\n",
    "        if verbose:\n",
    "            print \"fold %d accuracy=%.4f\"  %(len(accuracies),acc)\n",
    "        accuracies.append(acc)\n",
    "    avg = np.mean(accuracies)\n",
    "    return avg\n",
    "\n",
    "print('average cross validation accuracy=%.4f' %\n",
    "      do_cross_validation(X, y, verbose=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy using default settings: 0.6753\n"
     ]
    }
   ],
   "source": [
    "def do_expt(filenames, y, tokenizer_fn=tokenize,\n",
    "            min_df=1, max_df=1., binary=True,\n",
    "            ngram_range=(1,1), n_folds=5):\n",
    "    \"\"\"\n",
    "    Run one experiment, which consists of vectorizing each file,\n",
    "    performing cross-validation, and returning the average accuracy.\n",
    "    You should call do_vectorize and do_cross_validation here.\n",
    "    Params:\n",
    "        filenames.......list of review file names\n",
    "        y...............the true sentiment labels for each file\n",
    "        tokenizer_fn....the function used to tokenize each document\n",
    "        min_df..........remove terms from the vocabulary that don't appear\n",
    "                        in at least this many documents\n",
    "        max_df..........remove terms from the vocabulary that appear in more\n",
    "                        than this fraction of documents\n",
    "        binary..........If true, each documents is represented by a binary\n",
    "                        vector, where 1 means a term occurs at least once in \n",
    "                        the document. If false, the term frequency is used instead.\n",
    "        ngram_range.....A tuple (n,m) means to use phrases of length n to m inclusive.\n",
    "                        E.g., (1,2) means consider unigrams and bigrams.\n",
    "        n_folds.........The number of cross-validation folds to use.\n",
    "    Returns:\n",
    "        the average cross validation testing accuracy.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    \n",
    "    mat, vec = do_vectorize(filenames.tolist(),tokenizer_fn=tokenizer_fn,binary=binary,min_df=min_df,max_df=max_df,ngram_range=ngram_range)\n",
    "    avg = do_cross_validation(mat, y,n_folds = n_folds)\n",
    "    return avg\n",
    "\n",
    "\n",
    "print('accuracy using default settings: %.4g' % do_expt(filenames, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAELCAYAAAAY3LtyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nNW/3ikylAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa04dc20e90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[0.66712204007285969,\n",
       " 0.67529612756264246,\n",
       " 0.6816977999169781,\n",
       " 0.68266472060050032]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare_n_folds(filenames, y):\n",
    "    \"\"\"\n",
    "    Vary the setting of n_folds parameter in the do_expt \n",
    "    function to be in [2,5,10,20]. For each setting, call do_expt and \n",
    "    store the resulting accuracy. Plot the accuracies for each setting.\n",
    "    Also return the list of accuracies. Use the default value for all\n",
    "    other arguments to the do_expt function.\n",
    "    Params:\n",
    "        filenames....list of training file names\n",
    "        y............true labels for each file (a numpy array)\n",
    "    Returns:\n",
    "        a list of average testing accuracies, one per fold.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    fold_list = [2,5,10,20]\n",
    "    \n",
    "    result = [do_expt(filenames,y,n_folds = nf) for nf in fold_list]\n",
    "    plt.plot(fold_list, result,'bo-')\n",
    "    plt.xlabel('n_folds')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.show()\n",
    "    return result    \n",
    "    \n",
    "compare_n_folds(filenames, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.67529612756264246, 0.74177365914267956]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare_binary(filenames, y):\n",
    "    \"\"\"\n",
    "    How does the binary parameter affect results? \n",
    "    Call do_expt twice, once with binary=True, and once with binary=False.\n",
    "    Return the average accuracies for each. Use the default parameters for the\n",
    "    remaining arguments in do_expt.\n",
    "    Params:\n",
    "        filenames....list of training file names\n",
    "        y............true labels for each file (a numpy array)\n",
    "    Returns:\n",
    "        a list of average testing accuracies. The first entry\n",
    "        is for binary=True, the second is for binary=False.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    accuracies=[]\n",
    "    accuracies.append(do_expt(filenames,y,binary=True))\n",
    "    accuracies.append(do_expt(filenames,y,binary=False))\n",
    "    return accuracies\n",
    "          \n",
    "compare_binary(filenames, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hi',\n",
       " '!',\n",
       " 'how',\n",
       " \"'\",\n",
       " 's',\n",
       " 'it',\n",
       " 'going',\n",
       " '?',\n",
       " '?',\n",
       " '?',\n",
       " 'an_underscore',\n",
       " 'is',\n",
       " 'not',\n",
       " '*',\n",
       " 'really',\n",
       " '*',\n",
       " 'punctuation',\n",
       " '.']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def tokenize_with_punct(text):\n",
    "    \"\"\"Given a string, return a list of tokens such that: (1) all\n",
    "    tokens are lowercase, (2) all punctuation is kept as separate tokens.\n",
    "    Note that underscore (_) is not considered punctuation.\n",
    "    Params:\n",
    "        text....a string\n",
    "    Returns:\n",
    "        a list of tokens\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    text = re.sub(r'[\\x85]',\" \",text)\n",
    "    return re.findall(r\"[\\w]+|[^\\w\\s]\", text.lower())\n",
    "   \n",
    "    \n",
    "tokenize_with_punct(\"Hi! How's it going??? an_underscore is not *really* punctuation.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not the fiancée of not Henri\n",
      "tokenize: not, the, fianc, e, of, not, henri\n",
      "tokenize_with_punct: not, the, fianc, é, e, of, not, henri\n",
      "tokenize_with_not: not, not_the, not_fianc, e, of, not, not_henri\n",
      "[u'hi', u'there', u'how', u'are', u'you', u'?']\n",
      "[u'hi', u'there', u'how', u'are', u'you', u'?']\n",
      "[u'hi', u'there', u'how', u'are', u'you', u'?']\n"
     ]
    }
   ],
   "source": [
    "nonascii_string = u'not the fiancée of not Henri'\n",
    "print nonascii_string\n",
    "print('tokenize: %s' % \n",
    "      ', '.join(tokenize(nonascii_string)))\n",
    "print('tokenize_with_punct: %s' %\n",
    "      ', '.join(tokenize_with_punct(nonascii_string)))\n",
    "print('tokenize_with_not: %s' %\n",
    "      ', '.join(tokenize_with_not(nonascii_string)))\n",
    "\n",
    "print tokenize_with_punct(u'hi there\\n how are you?')\n",
    "#[u'hi', u'there', u'how', u'are', u'you', u'?']\n",
    "\n",
    "print tokenize_with_punct(u'hi there \\x85 how are you?')\n",
    "#[u'hi', u'there', u'how', u'are', u'you', u'?']\n",
    "\n",
    "print tokenize_with_punct(u'hi there \\r how are you?')\n",
    "#[u'hi', u'there', u'how', u'are', u'you', u'?']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.67529612756264246, 0.67529612756264246, 0.69852350383102091]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def tokenizer_expt(all_train_files, y):\n",
    "    \"\"\"\n",
    "    How does the tokenizer affect results? \n",
    "    Call do_expt three times, using three different tokenizers:\n",
    "    1- tokenize\n",
    "    2- tokenize_with_punct\n",
    "    3- tokenize_with_not\n",
    "    Return the average cross-validation accuracy for each approach,\n",
    "    in the above order. Use the default parameters for all other \n",
    "    arguments to do_expt.\n",
    "    Params:\n",
    "        filenames....list of training file names\n",
    "        y............true labels for each file (a numpy array)\n",
    "    Returns:\n",
    "        a list of average testing accuracies for each tokenizer.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###      \n",
    "    return [do_expt(filenames=all_train_files, y=y,tokenizer_fn = t) \n",
    "            for t in [tokenize,tokenize_with_punct,tokenize_with_not]]\n",
    "\n",
    "tokenizer_expt(filenames, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##So among these tokenizers, we are getting maximum accuracy in tokenize_with_not. So we are going to use\n",
    "## tokenize_with_not in every function from now. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEQCAYAAABxzUkqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n8v9Ltnix+EmzqAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa04d451490>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[0.69852350383102091,\n",
       " 0.69761027127769726,\n",
       " 0.70535307517084278,\n",
       " 0.70398426175191553,\n",
       " 0.70125284738041005,\n",
       " 0.70307620625388267,\n",
       " 0.6998892110167737,\n",
       " 0.70535618140401735,\n",
       " 0.70444191343963547,\n",
       " 0.70717954027749008]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def min_df_expt(filenames, y):\n",
    "    \"\"\"\n",
    "    Vary the setting of min_df parameter in the do_expt \n",
    "    function to be ints in the range (1,10) (inclusive). For each setting,\n",
    "    call do_expt and store the resulting accuracy. Plot the accuracies for each setting.\n",
    "    Also return the list of accuracies. Use the default value for all\n",
    "    other arguments to the do_expt function, except that the tokenizer\n",
    "    should be tokenize_with_not.\n",
    "    Params:\n",
    "        filenames....list of training file names\n",
    "        y............true labels for each file (a numpy array)\n",
    "    Returns:\n",
    "        a list of average testing accuracies, one per min_df value.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    accuracy = [do_expt(filenames,y,tokenizer_fn = tokenize_with_not, min_df=i) for i in range(1,11)]\n",
    "    plt.plot(range(1,11), accuracy,'bo-')\n",
    "    plt.xlabel('min_df')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.show()\n",
    "    return accuracy\n",
    "\n",
    "min_df_expt(filenames, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEQCAYAAACjnUNyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa04d4292d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[0.63978981155518733,\n",
       " 0.6525336508593913,\n",
       " 0.65753986332574033,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726,\n",
       " 0.69761027127769726]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def max_df_expt(filenames, y):\n",
    "    \"\"\"\n",
    "    Vary the setting of max_df parameter in the do_expt \n",
    "    function to be one of [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.].\n",
    "    For each setting, call do_expt and store the resulting accuracy.\n",
    "    Plot the accuracies for each setting. Also return the list of accuracies.\n",
    "    Use the default value for all other arguments to the do_expt function,\n",
    "    except that the tokenizer=tokenize_with_not and min_df=2.\n",
    "    Params:\n",
    "        filenames....list of training file names\n",
    "        y............true labels for each file (a numpy array)\n",
    "    Returns:\n",
    "        a list of average testing accuracies, one per max_df value.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    max_dflist = [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.]\n",
    "    accuracy = [do_expt(filenames, y, tokenizer_fn = tokenize_with_not, min_df = 2, max_df = i) \n",
    "                for i in max_dflist]\n",
    "    plt.plot(max_dflist, accuracy,'bo-')\n",
    "    plt.xlabel('max_df')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.show()\n",
    "    return accuracy\n",
    "    \n",
    "max_df_expt(filenames, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultinomialNB(alpha=0.1, class_prior=None, fit_prior=True)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First, we'll train our final classifier using our best settings.\n",
    "X, vec = do_vectorize(filenames, tokenizer_fn=tokenize_with_not,\n",
    "                      binary=False, min_df=3, max_df=.4)\n",
    "clf = get_clf_naive()\n",
    "clf.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'>\n",
      "(1, 2954)\n"
     ]
    }
   ],
   "source": [
    "print type(clf.coef_)\n",
    "print clf.coef_.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -7.66254205  -8.00841506  -5.73859224  -5.66454527  -7.66254205\n",
      " -10.40631033  -8.00841506  -8.00841506 -10.40631033  -7.92900828]\n",
      "[u'0', u'00', u'1', u'10', u'100', u'1080', u'1080p', u'11', u'11ac', u'12']\n"
     ]
    }
   ],
   "source": [
    "# Here are the first 10 coefficients.\n",
    "print(clf.coef_[0][:10])\n",
    "# The features corresponding to them can be found using the vectorizer's get_feature_names method.\n",
    "print(vec.get_feature_names()[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.24      0.30      0.26      1093\n",
      "          1       0.05      0.04      0.04      1103\n",
      "\n",
      "avg / total       0.14      0.17      0.15      2196\n",
      "\n",
      "[[ 329  764]\n",
      " [1063   40]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predict_label = []\n",
    "m = clf.predict_proba(X)\n",
    "for pos, neg in m:\n",
    "    if pos > neg:\n",
    "        predict_label.append(1)\n",
    "    else:\n",
    "        predict_label.append(0)\n",
    "print(metrics.classification_report(y,np.array(predict_label)))\n",
    "print(metrics.confusion_matrix(y,np.array(predict_label)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top positive coefs: []\n",
      "top negative coefs: [(u'120', -12.804205602486388), (u'1366', -12.804205602486388), (u'144', -12.804205602486388), (u'149', -12.804205602486388), (u'21', -12.804205602486388)]\n"
     ]
    }
   ],
   "source": [
    "def get_top_coefficients(clf, vec, n=10):\n",
    "    \"\"\" Get the top n coefficients for each class (positive/negative).\n",
    "    Params:\n",
    "        clf...a LogisticRegression object that has already been fit to data.\n",
    "        vec...a CountVectorizer\n",
    "        n.....the number of features to print per class.\n",
    "    Returns:\n",
    "        Two lists of tuples. The first list containts the top terms for the positive\n",
    "        class. Each entry is a tuple of (string, float) pairs, where\n",
    "        string is the feature name and float is the coefficient.\n",
    "        The second list is the same but for the negative class.\n",
    "        In each list, entries should be sorted in descending order of \n",
    "        absolute value.\"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    pos_coef = []\n",
    "    neg_coef = []\n",
    "    #iterating through all feature names and their assigned coeeficient value\n",
    "    for i in zip(vec.get_feature_names(),clf.coef_[0]):\n",
    "        #if coef is positive then append it to positive coefficient list \n",
    "        if i[1] > 0:\n",
    "            pos_coef.append(i)\n",
    "        #if coef is negative then append it to negative coefficient list \n",
    "        else:\n",
    "            neg_coef.append(i)\n",
    "    return sorted(pos_coef, key=lambda x:x[1], reverse=True)[:5], sorted(neg_coef, key=lambda x:x[1], reverse=False)[:5]\n",
    "\n",
    "pos_coef, neg_coef = get_top_coefficients(clf, vec, n=5)\n",
    "print('top positive coefs: %s' % str(pos_coef))\n",
    "print('top negative coefs: %s' % str(neg_coef))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_test represents 550 documents with 2954 features\n",
      "y_test has 219 positive and 331 negative labels\n",
      "first testing file is Data/test/pos/r2196.txt\n",
      "last testing file is Data/test/neg/r2745.txt\n",
      "testing accuracy=0.6091\n"
     ]
    }
   ],
   "source": [
    "# Do not modify.\n",
    "pos_test_files = get_files(path + os.sep + 'test' + os.sep + 'pos')\n",
    "neg_test_files = get_files(path + os.sep + 'test' + os.sep + 'neg')\n",
    "all_test_files = pos_test_files + neg_test_files\n",
    "# Note that we call .transform, not .fit_transform, since we \n",
    "# don't want to learn a new vocabulary.\n",
    "X_test = vec.transform(all_test_files)\n",
    "y_test = np.array([1] * len(pos_test_files) + [0] * len(neg_test_files))\n",
    "print('X_test represents %d documents with %d features' % (X_test.shape[0], X_test.shape[1]))\n",
    "print('y_test has %d positive and %d negative labels' % (len(np.where(y_test==1)[0]),\n",
    "                                                          len(np.where(y_test==0)[0])))\n",
    "print('first testing file is %s' % all_test_files[0])\n",
    "print('last testing file is %s' % all_test_files[-1])\n",
    "print('testing accuracy=%.4g' % accuracy_score(y_test, clf.predict(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'filename': 'Data/test/pos/r2488.txt',\n",
       "  'index': 130,\n",
       "  'predicted': 0,\n",
       "  'probas': array([  1.00000000e+00,   1.88060135e-13]),\n",
       "  'truth': 1},\n",
       " {'filename': 'Data/test/pos/r2427.txt',\n",
       "  'index': 104,\n",
       "  'predicted': 0,\n",
       "  'probas': array([  9.99810302e-01,   1.89697564e-04]),\n",
       "  'truth': 1},\n",
       " {'filename': 'Data/test/neg/r2389.txt',\n",
       "  'index': 324,\n",
       "  'predicted': 1,\n",
       "  'probas': array([  2.54300534e-04,   9.99745699e-01]),\n",
       "  'truth': 0},\n",
       " {'filename': 'Data/test/pos/r2255.txt',\n",
       "  'index': 35,\n",
       "  'predicted': 0,\n",
       "  'probas': array([ 0.99814817,  0.00185183]),\n",
       "  'truth': 1},\n",
       " {'filename': 'Data/test/neg/r2476.txt',\n",
       "  'index': 370,\n",
       "  'predicted': 1,\n",
       "  'probas': array([ 0.00311235,  0.99688765]),\n",
       "  'truth': 0},\n",
       " {'filename': 'Data/test/neg/r2272.txt',\n",
       "  'index': 252,\n",
       "  'predicted': 1,\n",
       "  'probas': array([ 0.0032878,  0.9967122]),\n",
       "  'truth': 0},\n",
       " {'filename': 'Data/test/neg/r2633.txt',\n",
       "  'index': 479,\n",
       "  'predicted': 1,\n",
       "  'probas': array([ 0.00539518,  0.99460482]),\n",
       "  'truth': 0},\n",
       " {'filename': 'Data/test/neg/r2274.txt',\n",
       "  'index': 254,\n",
       "  'predicted': 1,\n",
       "  'probas': array([ 0.00572095,  0.99427905]),\n",
       "  'truth': 0},\n",
       " {'filename': 'Data/test/pos/r2502.txt',\n",
       "  'index': 133,\n",
       "  'predicted': 0,\n",
       "  'probas': array([ 0.99377502,  0.00622498]),\n",
       "  'truth': 1},\n",
       " {'filename': 'Data/test/neg/r2477.txt',\n",
       "  'index': 371,\n",
       "  'predicted': 1,\n",
       "  'probas': array([ 0.00646231,  0.99353769]),\n",
       "  'truth': 0}]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_top_errors(X_test, y_test, filenames, clf, n=10):\n",
    "    \"\"\"\n",
    "    Use clf to predict the labels of the testing data in X_test. \n",
    "    We want to find incorrectly predicted documents. Furthermore, we want to look at those \n",
    "    where the probability of the incorrect label, according to the classifier, is highest.\n",
    "    Use the .predict_proba method of the classifier to get the probabilities of\n",
    "    each class label. Return the n documents that were misclassified, sorted by the\n",
    "    probability of the incorrect label. The returned value is a list of dicts, defined below.\n",
    "    Params:\n",
    "        X_test......the testing matrix\n",
    "        y_test......the true labels for each testing document\n",
    "        filenames...the filenames for each testing document\n",
    "        clf.........a trained LogisticRegression object\n",
    "        n...........the number of errors to return\n",
    "    Returns:\n",
    "        A list of n dicts containing the following key/value pairs:\n",
    "           index: the index of this document (in the filenames array)\n",
    "           probas: a numpy array containing the probability of class 0 and 1\n",
    "           truth: the true label\n",
    "           predicted: the predicted label\n",
    "           filename: the path to the file for this document\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "   \n",
    "    \n",
    "    lst = []\n",
    "    newlist = []\n",
    "    predicted = clf.predict(X_test)\n",
    "    \n",
    "    predicted_proba = clf.predict_proba(X_test)\n",
    "    \n",
    "    for i in range(len(predicted)):\n",
    "        probability = predicted_proba[i][predicted[i]]\n",
    "        d = {}\n",
    "        dic = {}\n",
    "        \n",
    "        if predicted[i] != y_test[i]:\n",
    "            \n",
    "            if predicted[i] == 0:\n",
    "                dic['index'] = i\n",
    "                dic['probas'] = predicted_proba[i][0]\n",
    "            else:\n",
    "                dic['index'] = i\n",
    "                dic['probas'] = predicted_proba[i][1]\n",
    "            \n",
    "            lst.append(dic)\n",
    "    newlist = sorted(lst, key=itemgetter('probas'),reverse=True) \n",
    "    \n",
    "    #print ls\n",
    "    p = []            \n",
    "    for i in newlist[:n]:\n",
    "        p.append(i.values()[0])\n",
    "           \n",
    "    #print p\n",
    "    ls = []\n",
    "    for i in p:\n",
    "        d={}\n",
    "        d['filename'] = filenames[i]\n",
    "        d['index'] = i\n",
    "        d['predicted'] = predicted[i]\n",
    "        d['probas'] = predicted_proba[i]\n",
    "        d['truth'] = y_test[i]\n",
    "    \n",
    "        ls.append(d)\n",
    "    \n",
    "    \n",
    "    return ls \n",
    "    \n",
    "errors = get_top_errors(X_test, y_test, all_test_files, clf)\n",
    "errors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.24      0.30      0.26      1093\n",
      "          1       0.05      0.04      0.04      1103\n",
      "\n",
      "avg / total       0.14      0.17      0.15      2196\n",
      "\n",
      "[[ 329  764]\n",
      " [1063   40]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predict_label = []\n",
    "m = clf.predict_proba(X)\n",
    "for pos, neg in m:\n",
    "    if pos > neg:\n",
    "        predict_label.append(1)\n",
    "    else:\n",
    "        predict_label.append(0)\n",
    "print(metrics.classification_report(y,np.array(predict_label)))\n",
    "print(metrics.confusion_matrix(y,np.array(predict_label)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for document Data/test/pos/r2196.txt, the term most predictive of class 0 is appear (index=224)\n",
      "for document Data/test/pos/r2196.txt, the term most predictive of class 1 is use (index=2781)\n"
     ]
    }
   ],
   "source": [
    "# Given a document, find the term in it that is most strongly associated\n",
    "# with a given class label, according to a trained classifier.\n",
    "def most_predictive_term_in_doc(instance, clf, class_idx):\n",
    "    \"\"\"\n",
    "    Params:\n",
    "        instance....one row in the X csr_matrix, corresponding to a document.\n",
    "        clf.........a trained LogisticRegression classifier\n",
    "        class_idx...0 or 1. The class for which we should find the most \n",
    "                    predictive term in this document.\n",
    "    Returns:\n",
    "        The index corresponding to the term that appears in this instance\n",
    "        and has the highest coefficient for class class_idx.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    lst = []\n",
    "    lm = []\n",
    "    newlist = []\n",
    "    newlist1 = []\n",
    "    \n",
    "    for i in instance.nonzero()[1]:\n",
    "        lst.append(i)\n",
    "    \n",
    "    for i in lst:\n",
    "        clff = {}\n",
    "        clff['index']=i\n",
    "        clff['coef'] = (clf.coef_[0][i])\n",
    "        lm.append(clff)\n",
    "    \n",
    "   \n",
    "    newlist = sorted(lm, key=itemgetter('coef'),reverse=True) \n",
    "    \n",
    "    newlist1 = sorted(lm, key=itemgetter('coef')) \n",
    "    \n",
    "    if class_idx  == 1:\n",
    "        return int(newlist[0]['index'])\n",
    "    \n",
    "    else:\n",
    "        return int(newlist1[0]['index'] )\n",
    "    \n",
    "    \n",
    "#most_predictive_term_in_doc(X_test[0], clf, 0)\n",
    "neg_idx = most_predictive_term_in_doc(X_test[0], clf, 0)\n",
    "pos_idx = most_predictive_term_in_doc(X_test[0], clf, 1)\n",
    "print('for document %s, the term most predictive of class 0 is %s (index=%d)' %\n",
    "      (all_test_files[0], vec.get_feature_names()[neg_idx], neg_idx))\n",
    "print('for document %s, the term most predictive of class 1 is %s (index=%d)' %\n",
    "      (all_test_files[0], vec.get_feature_names()[pos_idx], pos_idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Decision Tree Classifier\n",
    "## http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "def get_clf_tree():\n",
    "    return DecisionTreeClassifier(random_state=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fold 0 accuracy=0.7909\n",
      "fold 1 accuracy=0.7950\n",
      "fold 2 accuracy=0.7973\n",
      "fold 3 accuracy=0.8087\n",
      "fold 4 accuracy=0.8246\n",
      "average cross validation accuracy=0.8033\n"
     ]
    }
   ],
   "source": [
    "def do_cross_validation(X, y, n_folds=5, verbose=False):\n",
    "    \"\"\"\n",
    "    Perform n-fold cross validation, calling get_clf() to train n\n",
    "    different classifiers. Use sklearn's KFold class: http://goo.gl/wmyFhi\n",
    "    Be sure not to shuffle the data, otherwise your output will differ.\n",
    "    Params:\n",
    "        X.........a csr_matrix of feature vectors\n",
    "        y.........the true labels of each document\n",
    "        n_folds...the number of folds of cross-validation to do\n",
    "        verbose...If true, report the testing accuracy for each fold.\n",
    "    Return:\n",
    "        the average testing accuracy across all folds.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    g = get_clf_tree()\n",
    "    kf = cross_validation.KFold(len(y), n_folds=n_folds)\n",
    "    accuracies = []\n",
    "    \n",
    "    for train_idx, test_idx in kf:    \n",
    "        g.fit(X[train_idx], y[train_idx])\n",
    "        #print len(train_idx)\n",
    "        predicted = g.predict(X[test_idx])\n",
    "        acc = accuracy_score(y[test_idx], predicted)\n",
    "        if verbose:\n",
    "            print \"fold %d accuracy=%.4f\"  %(len(accuracies),acc)\n",
    "        accuracies.append(acc)\n",
    "    avg = np.mean(accuracies)\n",
    "    return avg\n",
    "\n",
    "print('average cross validation accuracy=%.4f' %\n",
    "      do_cross_validation(X, y, verbose=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy using default settings: 0.8101\n"
     ]
    }
   ],
   "source": [
    "def do_expt(filenames, y, tokenizer_fn=tokenize,\n",
    "            min_df=1, max_df=1., binary=True,\n",
    "            ngram_range=(1,1), n_folds=5):\n",
    "    \"\"\"\n",
    "    Run one experiment, which consists of vectorizing each file,\n",
    "    performing cross-validation, and returning the average accuracy.\n",
    "    You should call do_vectorize and do_cross_validation here.\n",
    "    Params:\n",
    "        filenames.......list of review file names\n",
    "        y...............the true sentiment labels for each file\n",
    "        tokenizer_fn....the function used to tokenize each document\n",
    "        min_df..........remove terms from the vocabulary that don't appear\n",
    "                        in at least this many documents\n",
    "        max_df..........remove terms from the vocabulary that appear in more\n",
    "                        than this fraction of documents\n",
    "        binary..........If true, each documents is represented by a binary\n",
    "                        vector, where 1 means a term occurs at least once in \n",
    "                        the document. If false, the term frequency is used instead.\n",
    "        ngram_range.....A tuple (n,m) means to use phrases of length n to m inclusive.\n",
    "                        E.g., (1,2) means consider unigrams and bigrams.\n",
    "        n_folds.........The number of cross-validation folds to use.\n",
    "    Returns:\n",
    "        the average cross validation testing accuracy.\n",
    "    \"\"\"\n",
    "    ###TODO\n",
    "    ###\n",
    "    \n",
    "    \n",
    "    mat, vec = do_vectorize(filenames.tolist(),tokenizer_fn=tokenizer_fn,binary=binary,min_df=min_df,max_df=max_df,ngram_range=ngram_range)\n",
    "    avg = do_cross_validation(mat, y,n_folds = n_folds)\n",
    "    return avg\n",
    "\n",
    "\n",
    "print('accuracy using default settings: %.4g' % do_expt(filenames, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n",
       "            max_features=None, max_leaf_nodes=None, min_samples_leaf=1,\n",
       "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "            presort=False, random_state=0, splitter='best')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First, we'll train our final classifier using our best settings.\n",
    "X, vec = do_vectorize(filenames, tokenizer_fn=tokenize,\n",
    "                      binary=True, min_df=4, max_df=.4)\n",
    "clf = get_clf_tree()\n",
    "clf.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.00      0.00      0.00      1093\n",
      "          1       0.00      0.00      0.00      1103\n",
      "\n",
      "avg / total       0.00      0.00      0.00      2196\n",
      "\n",
      "[[   3 1090]\n",
      " [1103    0]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "predict_label = []\n",
    "m = clf.predict_proba(X)\n",
    "for pos, neg in m:\n",
    "    if pos > neg:\n",
    "        predict_label.append(1)\n",
    "    else:\n",
    "        predict_label.append(0)\n",
    "print(metrics.classification_report(y,np.array(predict_label)))\n",
    "print(metrics.confusion_matrix(y,np.array(predict_label)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}