FoodBiz_LocationRec.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:30.156551Z",
     "start_time": "2018-06-23T22:52:30.144055Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['attributeDictFile',\n",
       " 'attributeDicts.json',\n",
       " 'attributeLists.json',\n",
       " 'business.json',\n",
       " 'business.json.zip',\n",
       " 'checkin.json',\n",
       " 'checkin.json.zip',\n",
       " 'Dataset_Challenge_Dataset_Agreement.pdf',\n",
       " 'holder.txt',\n",
       " 'photos.json',\n",
       " 'postal_codes.csv',\n",
       " 'review.json',\n",
       " 'tip.json',\n",
       " 'user.json',\n",
       " 'Yelp_Dataset_Challenge_Round_11.pdf']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import json\n",
    "import time\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.pipeline import Pipeline, make_pipeline\n",
    "from sklearn import svm\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, train_test_split, GridSearchCV\n",
    "from sklearn.metrics import precision_recall_curve, accuracy_score, f1_score\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier\n",
    "from sklearn.multioutput import MultiOutputClassifier\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from datetime import datetime\n",
    "os.chdir(\"/home/gu38/Common/DIVA/FinalProject/yelp/dataset/\")\n",
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:35.288962Z",
     "start_time": "2018-06-23T22:52:30.828717Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Function to calculate Total check-ins in a week for a business\n",
    "'''\n",
    "checkins = {}\n",
    "checkin = {}\n",
    "with open('checkin.json', 'r') as f:\n",
    "    for line in f:\n",
    "        checkin = json.loads(line)\n",
    "        checkins[checkin['business_id']] = checkin['time']\n",
    "        \n",
    "def get_checkin_count(id):\n",
    "    count = 0\n",
    "    record = checkins[id]\n",
    "    for day in record:\n",
    "        for hour in record[day]:\n",
    "            count += record[day][hour]\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Function to create binary vector for 'hours' attribute\n",
    "'''\n",
    "checkins = {}\n",
    "checkin = {}\n",
    "with open('checkin.json', 'r') as f:\n",
    "    for line in f:\n",
    "        checkin = json.loads(line)\n",
    "        checkins[checkin['business_id']] = checkin['time']\n",
    "        \n",
    "def get_checkin_count(id):\n",
    "    count = 0\n",
    "    record = checkins[id]\n",
    "    for day in record:\n",
    "        for hour in record[day]:\n",
    "            count += record[day][hour]\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:35.294678Z",
     "start_time": "2018-06-23T22:52:35.290482Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Function to extract multi-valued Attributes from Business data\n",
    "'''\n",
    "def extract_feature_lists(businesses):\n",
    "    # List of single-valued attributes\n",
    "    attributeLists = {}\n",
    "\n",
    "    #List of multi-valued(dict form) attributes\n",
    "    attributeDicts = {}\n",
    "\n",
    "    # print(\"Before \\n\", json.dumps(businesses[:1], indent=4))\n",
    "\n",
    "    #Generating a list of attribute values:\n",
    "    for entry in businesses:\n",
    "        for item in entry['attributes']:\n",
    "            param = \"attribute_\" + item\n",
    "            entry[param] = entry['attributes'][item]\n",
    "\n",
    "            if isinstance(entry[param], dict):\n",
    "                if param in attributeDicts:\n",
    "                    for var in entry[param]:\n",
    "                        if var not in attributeDicts[param]:\n",
    "                            attributeDicts[param][var] = entry[param][var]\n",
    "                else:\n",
    "                    attributeDicts[param] = entry[param]\n",
    "\n",
    "            else:\n",
    "                if param in attributeLists:\n",
    "                    if entry[param] not in attributeLists[param]:\n",
    "                        attributeLists[param].append(entry[param])\n",
    "                else:\n",
    "                    attributeLists[param] = [entry[param]]\n",
    "                    \n",
    "    return attributeLists, attributeDicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:35.334067Z",
     "start_time": "2018-06-23T22:52:35.296492Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Function to convert business attributes to binary vectors\n",
    "'''\n",
    "def generate_binary_vectors(businesses, attributeListsFile, attributeDictsFile):\n",
    "    \n",
    "    with open(attributeListsFile, 'r') as f:\n",
    "        attributeLists = json.load(f)\n",
    "    with open(attributeDictsFile, 'r') as f:\n",
    "        attributeDicts = json.load(f)\n",
    "    \n",
    "    #Converting the attribute lists into binary vectors\n",
    "    for entry in businesses:\n",
    "        for param in attributeLists:\n",
    "            if param in entry:\n",
    "                encodedEntry = []\n",
    "                \n",
    "                # Single valued alphanumerical attributes, will be converted to n-bit vectors\n",
    "                # with a single bit as '1'\n",
    "                for value in attributeLists[param]:\n",
    "                    if entry[param] == value:\n",
    "                        encodedEntry.append(1)\n",
    "                    else:\n",
    "                        encodedEntry.append(0)\n",
    "            else:\n",
    "                encodedEntry = [0] * len(attributeLists[param])\n",
    "            entry[param] = encodedEntry\n",
    "\n",
    "        for param in attributeDicts:\n",
    "            # Multi valued binary attributes, will be converted to n-bit vectors \n",
    "            # with possibly multiple bits as '1' \n",
    "            if param in entry:\n",
    "                encodedEntry = []\n",
    "                # Checking whether the binary sub-attribute value is True\n",
    "                for value in attributeDicts[param]:\n",
    "                    if entry[param][value]:\n",
    "                        encodedEntry.append(1)\n",
    "                    else:\n",
    "                        encodedEntry.append(0)\n",
    "            else:\n",
    "                encodedEntry = [0] * len(attributeDicts[param])\n",
    "\n",
    "            entry[param] = encodedEntry\n",
    "\n",
    "        # At this stage we dont need the original attributes parameter        \n",
    "        del entry['attributes']\n",
    "\n",
    "    return businesses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:35.370850Z",
     "start_time": "2018-06-23T22:52:35.337030Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Function to retrieve business parameters:\n",
    "\n",
    "Usage: prepare_data < filename, city, Labelling parameter, No. of labels>\n",
    "'''\n",
    "def prepare_data(filename, cities, parameter, maxLabels):\n",
    "\n",
    "    businesses = []\n",
    "\n",
    "    with open(filename, 'r') as f:\n",
    "        \n",
    "        interesting_categories = ['Restaurants', 'Food', 'Nightlife', 'Bars', 'Active Life', 'Sandwiches',\n",
    "                                  'Fast Food', 'American (Traditional)', 'Pizza', 'Coffee & Tea', \n",
    "                                  'Hotels & Travel', 'Italian', 'Burgers', 'Breakfast & Brunch', \n",
    "                                  'Mexican', 'Chinese', 'Specialty Food', 'Bakeries', 'Cafes', \n",
    "                                  'Chicken Wings', 'Beer', 'Wine & Spirits', 'Steakhouses', \n",
    "                                  'Dance Clubs', 'Cocktail Bars', 'Pubs', 'Adult Entertainment']\n",
    "\n",
    "        interesting_params = ['is_open', 'stars', 'categories', parameter]\n",
    "        for line in f:\n",
    "            entry = json.loads(line)\n",
    "\n",
    "            # Filtering relevant businesses by city=Vegas and selected categories\n",
    "            if entry['city'] in cities and any( i in entry['categories'] for i in interesting_categories) \\\n",
    "            and entry[parameter] != '':\n",
    "                relevantEntry = {}\n",
    "                for item in interesting_params:\n",
    "                    if item in entry:\n",
    "                        if item == 'categories':\n",
    "                            cat = {}\n",
    "                            for category in interesting_categories:\n",
    "                                if category in entry[item]:\n",
    "                                    cat[category] = True\n",
    "                                else:\n",
    "                                    cat[category] = False\n",
    "                            entry['attributes'][item] = cat\n",
    "                        else:\n",
    "                            entry['attributes'][item] = entry[item]\n",
    "\n",
    "                relevantEntry['attributes'] = entry['attributes']\n",
    "\n",
    "                businesses.append(relevantEntry)\n",
    "        print(\"\\n\\n\\n\\nData with only useful records and attributes: \\n\",\n",
    "#               json.dumps(businesses[0], indent=4))\n",
    "              businesses[0])\n",
    "                \n",
    "        counter = {}\n",
    "        for item in businesses:\n",
    "            val = item['attributes'][parameter]\n",
    "            if val not in counter:\n",
    "                counter[val] = 1\n",
    "            else:\n",
    "                counter[val] += 1\n",
    "        sortedCounter = dict(sorted(counter.items(), key=lambda item: item[1], reverse = True)[:maxLabels])\n",
    "        \n",
    "        refinedBusinesses = []\n",
    "        for entry in businesses:\n",
    "            if entry['attributes'][parameter] in sortedCounter:\n",
    "                refinedBusinesses.append(entry)\n",
    "                \n",
    "        print(\"\\n\\nSize of the final Input Vector:\\n\", len(refinedBusinesses))\n",
    "        print(refinedBusinesses[:1])\n",
    "\n",
    "#         print(\"before \\n\", json.dumps(refinedBusinesses[:1], indent=4))\n",
    "        #\n",
    "        attributesAsLists, attributesAsDicts = extract_feature_lists(refinedBusinesses)\n",
    "        \n",
    "        with open('attributeLists.json', 'w') as f:\n",
    "            f.write(json.dumps(attributesAsLists))\n",
    "            \n",
    "        with open('attributeDicts.json', 'w') as f:\n",
    "            f.write(json.dumps(attributesAsDicts))\n",
    "        \n",
    "        businessVectors = generate_binary_vectors(refinedBusinesses, 'attributeLists.json', 'attributeDicts.json')\n",
    "        \n",
    "#         print(\"\\n\\nResultant input data with binary attributes:\\n\",json.dumps(businessVectors[0], indent=4))\n",
    "        print(\"\\n\\nResultant input data with binary attributes:\\n\",businessVectors[0])\n",
    "#         for cat in interesting_categories:\n",
    "#             print(\"OR category LIKE \" + \"'\" + cat + \"'\")\n",
    "        return businessVectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:35.405489Z",
     "start_time": "2018-06-23T22:52:35.373976Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Function to invert binarized features/Labels back to original text\n",
    "'''\n",
    "def custom_invert_transform(binVec, maxLabels):\n",
    "    \n",
    "    with open('attributeLists.json', 'w') as f:\n",
    "        f.write(json.dumps(attributesAsLists))\n",
    "    with open('attributeDicts.json', 'w') as f:\n",
    "        f.write(json.dumps(attributesAsDicts))\n",
    "        \n",
    "    origList = []\n",
    "    if param in attributesAsLists:\n",
    "        for item in binVec:\n",
    "            i = 0\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:39.240942Z",
     "start_time": "2018-06-23T22:52:39.237265Z"
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "This function concatenates all the feature vectors for input and flattens the Label data\n",
    "'''\n",
    "def concat_bin_vectors(binVec, Multioutput):\n",
    "    outputConVec = []\n",
    "    outputLabelVec = []\n",
    "    for entry in binVec:\n",
    "        rowVec = []\n",
    "        for item in entry:\n",
    "            if item == 'attribute_postal_code':\n",
    "                if(not Multioutput):\n",
    "                    #Convert the list-attribute to a string and remove from binary feature vector\n",
    "                    outputLabelVec.append(''.join(map(str, entry[item])))\n",
    "                else:\n",
    "                    #Convert the list-attribute to a string and remove from binary feature vector\n",
    "                    outputLabelVec.append(entry[item])\n",
    "            else:\n",
    "                rowVec.extend(entry[item])\n",
    "        outputConVec.append(rowVec)\n",
    "    return outputConVec, outputLabelVec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:52:40.014019Z",
     "start_time": "2018-06-23T22:52:40.007852Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "Custom function to calculate HIT @N for test data\n",
    "i.e. Probability that actual zone falls into N recommended zones.\n",
    "\n",
    "Usage: hit_n < trained_Classifier, x_test, y_test, N >\n",
    "'''\n",
    "def hit_n(clf, test_data, true_labels, n):\n",
    "    \n",
    "    probs = clf.predict_proba(test_data)\n",
    "    best_n = np.argsort(probs, axis = 1)\n",
    "\n",
    "    i = 0\n",
    "    count = 0\n",
    "    for label in true_labels:\n",
    "        relevant_prediction_indices = best_n[i][-n:]\n",
    "        for j in range(n):\n",
    "            if clf.classes_[relevant_prediction_indices[j]] == label:\n",
    "                count += 1\n",
    "                break\n",
    "        i += 1\n",
    "    print(count)\n",
    "    return (count/true_labels.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-23T22:53:13.137961Z",
     "start_time": "2018-06-23T22:53:07.556225Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "Data with only useful records and attributes: \n",
      " {'attributes': {'RestaurantsReservations': False, 'categories': {'Hotels & Travel': False, 'Chinese': False, 'Wine & Spirits': False, 'Breakfast & Brunch': False, 'Restaurants': True, 'Coffee & Tea': False, 'Bars': False, 'Fast Food': True, 'Specialty Food': False, 'Steakhouses': False, 'Italian': False, 'Cafes': False, 'Pubs': False, 'Food': False, 'Bakeries': False, 'Active Life': False, 'Dance Clubs': False, 'Cocktail Bars': False, 'Nightlife': False, 'Mexican': False, 'Pizza': False, 'Beer': False, 'Burgers': True, 'Chicken Wings': False, 'Sandwiches': False, 'American (Traditional)': False, 'Adult Entertainment': False}, 'RestaurantsGoodForGroups': True, 'Ambience': {'romantic': False, 'intimate': False, 'touristy': False, 'casual': False, 'upscale': False, 'hipster': False, 'divey': False, 'trendy': False, 'classy': False}, 'is_open': 1, 'RestaurantsAttire': 'casual', 'stars': 1.0, 'WiFi': 'free', 'GoodForMeal': {'dessert': False, 'latenight': False, 'dinner': False, 'breakfast': True, 'brunch': False, 'lunch': True}, 'postal_code': '85022', 'HasTV': True, 'GoodForKids': True, 'BusinessAcceptsCreditCards': True, 'RestaurantsTableService': False, 'BusinessParking': {'valet': False, 'street': False, 'garage': False, 'lot': True, 'validated': False}, 'RestaurantsPriceRange2': 1, 'OutdoorSeating': False, 'RestaurantsDelivery': False, 'RestaurantsTakeOut': True, 'Caters': False, 'BikeParking': True, 'NoiseLevel': 'loud', 'DriveThru': True, 'Alcohol': 'none'}}\n",
      "\n",
      "\n",
      "Size of the final Input Vector:\n",
      " 18966\n",
      "[{'attributes': {'RestaurantsReservations': False, 'categories': {'Hotels & Travel': False, 'Chinese': False, 'Wine & Spirits': False, 'Breakfast & Brunch': False, 'Restaurants': True, 'Coffee & Tea': False, 'Bars': False, 'Fast Food': True, 'Specialty Food': False, 'Steakhouses': False, 'Italian': False, 'Cafes': False, 'Pubs': False, 'Food': False, 'Bakeries': False, 'Active Life': False, 'Dance Clubs': False, 'Cocktail Bars': False, 'Nightlife': False, 'Mexican': False, 'Pizza': False, 'Beer': False, 'Burgers': True, 'Chicken Wings': False, 'Sandwiches': False, 'American (Traditional)': False, 'Adult Entertainment': False}, 'RestaurantsGoodForGroups': True, 'Ambience': {'romantic': False, 'intimate': False, 'touristy': False, 'casual': False, 'upscale': False, 'hipster': False, 'divey': False, 'trendy': False, 'classy': False}, 'is_open': 1, 'RestaurantsAttire': 'casual', 'stars': 1.0, 'WiFi': 'free', 'GoodForMeal': {'dessert': False, 'latenight': False, 'dinner': False, 'breakfast': True, 'brunch': False, 'lunch': True}, 'postal_code': '85022', 'HasTV': True, 'GoodForKids': True, 'BusinessAcceptsCreditCards': True, 'RestaurantsTableService': False, 'BusinessParking': {'valet': False, 'street': False, 'garage': False, 'lot': True, 'validated': False}, 'RestaurantsPriceRange2': 1, 'OutdoorSeating': False, 'RestaurantsDelivery': False, 'RestaurantsTakeOut': True, 'Caters': False, 'BikeParking': True, 'NoiseLevel': 'loud', 'DriveThru': True, 'Alcohol': 'none'}}]\n",
      "\n",
      "\n",
      "Resultant input data with binary attributes:\n",
      " {'attribute_HasTV': [1, 0], 'attribute_DietaryRestrictions': [0, 0, 0, 0, 0, 0, 0], 'attribute_postal_code': [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'attribute_Smoking': [0, 0, 0], 'attribute_BusinessAcceptsBitcoin': [0, 0], 'attribute_Ambience': [0, 0, 0, 0, 0, 0, 0, 0, 0], 'attribute_WiFi': [1, 0, 0], 'attribute_Open24Hours': [0, 0], 'attribute_HappyHour': [0, 0], 'attribute_HairSpecializesIn': [0, 0, 0, 0, 0, 0, 0, 0], 'attribute_RestaurantsTableService': [1, 0], 'attribute_Music': [0, 0, 0, 0, 0, 0, 0], 'attribute_AgesAllowed': [0, 0, 0], 'attribute_Corkage': [0, 0], 'attribute_ByAppointmentOnly': [0, 0], 'attribute_RestaurantsGoodForGroups': [1, 0], 'attribute_RestaurantsDelivery': [1, 0], 'attribute_categories': [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], 'attribute_GoodForKids': [1, 0], 'attribute_RestaurantsCounterService': [0, 0], 'attribute_Alcohol': [1, 0, 0], 'attribute_RestaurantsReservations': [1, 0], 'attribute_stars': [1, 0, 0, 0, 0, 0, 0, 0, 0], 'attribute_Caters': [1, 0], 'attribute_BikeParking': [1, 0], 'attribute_RestaurantsPriceRange2': [1, 0, 0, 0], 'attribute_BYOBCorkage': [0, 0, 0], 'attribute_NoiseLevel': [1, 0, 0, 0], 'attribute_BusinessAcceptsCreditCards': [1, 0], 'attribute_CoatCheck': [0, 0], 'attribute_BYOB': [0, 0], 'attribute_WheelchairAccessible': [0, 0], 'attribute_BusinessParking': [0, 0, 0, 1, 0], 'attribute_AcceptsInsurance': [0, 0], 'attribute_GoodForMeal': [0, 0, 0, 1, 0, 1], 'attribute_RestaurantsAttire': [1, 0, 0], 'attribute_RestaurantsTakeOut': [1, 0], 'attribute_OutdoorSeating': [1, 0], 'attribute_is_open': [1, 0], 'attribute_GoodForDancing': [0, 0], 'attribute_DriveThru': [1, 0], 'attribute_BestNights': [0, 0, 0, 0, 0, 0, 0], 'attribute_DogsAllowed': [0, 0]}\n",
      "Data pre-processing took: 0:00:05.426978\n",
      "Training Data size: 15172\n",
      "Training Data Dimensions: (15172, 161)\n"
     ]
    }
   ],
   "source": [
    "startTime0 = datetime.now()\n",
    "cities = ['Las Vegas', 'Scottsdale', 'Tempe',\n",
    "          'Glendale', 'Phoenix', 'Chandler', 'Henderson']\n",
    "\n",
    "classificationVectors = prepare_data(\n",
    "    'business.json', cities, 'postal_code', 55)\n",
    "\n",
    "featureData, labelData = concat_bin_vectors(classificationVectors, False)\n",
    "\n",
    "featureNames = []\n",
    "for solidFeature in classificationVectors[100]:\n",
    "    for i in classificationVectors[0][solidFeature]:\n",
    "        if 'postal' not in solidFeature:\n",
    "            featureNames.append(solidFeature)\n",
    "#\n",
    "\n",
    "print(\"Data pre-processing took:\", datetime.now() - startTime0)\n",
    "\n",
    "npx = np.array(featureData)\n",
    "npy = np.array(labelData)\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(npx, npy, test_size=0.2)\n",
    "\n",
    "print(\"Training Data size:\", len(x_train))\n",
    "print(\"Training Data Dimensions:\", x_train.shape)\n",
    "\n",
    "# # SVM classifier with Radial Basis Function\n",
    "\n",
    "# startTime1 = datetime.now()\n",
    "\n",
    "# # for i in range()\n",
    "# # classifier1 = LinearSVC(loss='hinge', tol = .001)\n",
    "# classifier1 = svm.SVC(kernel='rbf', C=1, decision_function_shape='ovr')\n",
    "\n",
    "# classifier1.fit(x_train, y_train)\n",
    "# predicted1 = classifier1.predict(x_test)\n",
    "# print(\"\\nTime elapsed in SVMrbf:\", str(datetime.now() - startTime1))\n",
    "# print(\"Accuracy for SVMrbf:\", accuracy_score(y_test, predicted1))\n",
    "# # print(\"F1 for SVMrbf: \", f1_score(predicted1, y_test, average='micro'))\n",
    "\n",
    "\n",
    "# # SGD classifier\n",
    "# startTime2 = datetime.now()\n",
    "# classifier2 = SGDClassifier(loss='hinge', max_iter=200)\n",
    "\n",
    "# classifier2.fit(x_train, y_train)\n",
    "# predicted2 = classifier2.predict(x_test)\n",
    "\n",
    "# print(\"\\nTime elapsed in SGDC:\", str(datetime.now() - startTime2))\n",
    "# print(\"Accuracy for SGDC:\", accuracy_score(y_test, predicted2))\n",
    "# # print(\"F1 for SGDC: \", f1_score(predicted2, y_test, average='micro'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### SVM with rbf kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T16:40:15.754374Z",
     "start_time": "2018-06-22T16:40:15.666926Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() got an unexpected keyword argument 'n_jobs'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-4889c15f4c2a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mclassifier1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msvm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkernel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'rbf'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdecision_function_shape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ovr'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprobability\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mclassifier1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpredicted1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclassifier1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# print(\"\\nTime elapsed in SVMrbf:\", str(datetime.now() - startTime1))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'n_jobs'"
     ]
    }
   ],
   "source": [
    "classifier1 = svm.SVC(kernel='rbf', C=1, decision_function_shape='ovr', probability=True)\n",
    "\n",
    "classifier1.fit(x_train, y_train)\n",
    "predicted1 = classifier1.predict(x_test)\n",
    "# print(\"\\nTime elapsed in SVMrbf:\", str(datetime.now() - startTime1))\n",
    "print(\"Accuracy for SVMrbf:\", accuracy_score(y_test, predicted1))\n",
    "\n",
    "print(\"HIT@10 score for SVM with rbf kernel is:\", hit_n(classifier1, x_test, y_test, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.016Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "req = \"http://0.0.0.0:8000/predict?category=Bars&category=\\\n",
    "Adult+Entertainment&AgesAllowed=21plus&Smoking=yes&BusinessParking=lot&Alcohol=yes\"\n",
    "resp = requests.get(req)\n",
    "print(resp.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:27:10.309488Z",
     "start_time": "2018-06-22T17:27:10.303894Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'attribute_RestaurantsTableService': [False, True], 'attribute_WheelchairAccessible': [True, False], 'attribute_WiFi': ['free', 'paid', 'no'], 'attribute_RestaurantsTakeOut': [True, False], 'attribute_OutdoorSeating': [False, True], 'attribute_DriveThru': [True, False], 'attribute_AcceptsInsurance': [True, False], 'attribute_HappyHour': [True, False], 'attribute_HasTV': [True, False], 'attribute_RestaurantsGoodForGroups': [True, False], 'attribute_RestaurantsReservations': [False, True], 'attribute_RestaurantsDelivery': [False, True], 'attribute_Smoking': ['no', 'outdoor', 'yes'], 'attribute_BYOBCorkage': ['no', 'yes_free', 'yes_corkage'], 'attribute_BusinessAcceptsBitcoin': [False, True], 'attribute_DogsAllowed': [True, False], 'attribute_Alcohol': ['none', 'full_bar', 'beer_and_wine'], 'attribute_postal_code': ['85022', '89119', '85016', '89103', '85032', '85258', '85013', '89121', '89014', '89117', '89104', '89123', '85051', '85027', '85281', '89145', '85260', '89109', '85004', '85018', '85226', '85044', '85224', '89102', '89149', '85286', '85034', '85255', '85008', '89128', '89130', '85251', '89169', '85014', '89118', '89052', '89101', '85282', '85301', '85308', '89147', '85283', '85257', '89135', '89108', '85020', '89113', '89148', '85284', '85003', '85254', '89146', '85225', '89139', '89015'], 'attribute_Caters': [False, True], 'attribute_BYOB': [False, True], 'attribute_RestaurantsAttire': ['casual', 'dressy', 'formal'], 'attribute_BusinessAcceptsCreditCards': [True, False], 'attribute_stars': [1.0, 3.0, 4.0, 2.5, 1.5, 5.0, 3.5, 2.0, 4.5], 'attribute_RestaurantsPriceRange2': [1, 2, 3, 4], 'attribute_NoiseLevel': ['loud', 'average', 'very_loud', 'quiet'], 'attribute_Corkage': [True, False], 'attribute_Open24Hours': [False, True], 'attribute_is_open': [1, 0], 'attribute_BikeParking': [True, False], 'attribute_GoodForKids': [True, False], 'attribute_CoatCheck': [False, True], 'attribute_RestaurantsCounterService': [False, True], 'attribute_GoodForDancing': [False, True], 'attribute_AgesAllowed': ['21plus', 'allages', '18plus'], 'attribute_ByAppointmentOnly': [False, True]}\n",
      "\n",
      " {'attribute_BestNights': {'friday': False, 'sunday': False, 'wednesday': True, 'thursday': False, 'tuesday': False, 'monday': False, 'saturday': False}, 'attribute_DietaryRestrictions': {'halal': True, 'vegan': True, 'soy-free': True, 'dairy-free': True, 'gluten-free': True, 'vegetarian': True, 'kosher': False}, 'attribute_BusinessParking': {'validated': False, 'valet': False, 'garage': False, 'street': False, 'lot': True}, 'attribute_Ambience': {'upscale': False, 'classy': False, 'casual': False, 'intimate': False, 'divey': False, 'trendy': False, 'touristy': False, 'hipster': False, 'romantic': False}, 'attribute_HairSpecializesIn': {'straightperms': True, 'coloring': True, 'kids': True, 'asian': True, 'perms': True, 'curly': True, 'extensions': True, 'africanamerican': False}, 'attribute_GoodForMeal': {'breakfast': True, 'brunch': False, 'latenight': False, 'dessert': False, 'dinner': False, 'lunch': True}, 'attribute_Music': {'background_music': True, 'live': False, 'karaoke': False, 'dj': False, 'no_music': False, 'video': False, 'jukebox': False}, 'attribute_categories': {'Pizza': False, 'Beer': False, 'Hotels & Travel': False, 'Pubs': False, 'Sandwiches': False, 'American (Traditional)': False, 'Breakfast & Brunch': False, 'Burgers': True, 'Chinese': False, 'Bars': False, 'Specialty Food': False, 'Cocktail Bars': False, 'Cafes': False, 'Mexican': False, 'Steakhouses': False, 'Wine & Spirits': False, 'Fast Food': True, 'Bakeries': False, 'Adult Entertainment': False, 'Restaurants': True, 'Chicken Wings': False, 'Dance Clubs': False, 'Food': False, 'Coffee & Tea': False, 'Active Life': False, 'Nightlife': False, 'Italian': False}}\n"
     ]
    }
   ],
   "source": [
    "with open('attributeLists.json', 'r') as f:\n",
    "    attributeLists = json.load(f)\n",
    "with open('attributeDicts.json', 'r') as f:\n",
    "    attributeDicts = json.load(f)\n",
    "print(attributeLists)\n",
    "print(\"\\n\",attributeDicts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.024Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# import csv\n",
    "# with open('postal_codes.csv', 'r') as f:\n",
    "#     zips = csv.reader(f, delimiter=',')\n",
    "# #     print(type(zips))\n",
    "#     i = 0\n",
    "#     data_read = [row[0] for row in zips]\n",
    "#     print(data_read[1:2000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Random Forest classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:37:02.113690Z",
     "start_time": "2018-06-22T17:36:59.583718Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Random Forest classifier\n",
    "# estimator = [('clf', \n",
    "#                MultiOutputClassifier(RandomForestClassifier(n_estimators=200, max_features = 15, random_state=0),\n",
    "#              n_jobs=-1))]\n",
    "# pipe = Pipeline(estimator)\n",
    "# pipe = make_pipeline(RandomForestClassifier())\n",
    "# parameter_grid1 = {\"randomforestclassifier__n_estimators\" : [100, 500, 250],\n",
    "#               \"randomforestclassifier__max_features\" : [1, 10, 40],\n",
    "# #              \"randomforestclassifier__max_features\" : [x*10 for x in range(1, 11)],\n",
    "#              \"randomforestclassifier__min_impurity_decrease\": [0.1, 0.3, 0.01]\n",
    "#              }\n",
    "# # pipe\n",
    "clf1 = RandomForestClassifier(n_estimators=200, max_features = 15, random_state=0, n_jobs=-1)\n",
    "# grid1 = GridSearchCV(pipe, param_grid=parameter_grid, cv=3, n_jobs=-1)\n",
    "clf1.fit(x_train, y_train)\n",
    "predictions = clf1.predict(x_test)\n",
    "# print(\"MAP@10 score for RandomForest Classifier is:\", map_n(clf1, x_test, y_test, 10))\n",
    "# print(\"Accuracy for Random Forest:\", accuracy_score(y_test, predictions))\n",
    "# print(\"\\n\",grid.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:37:02.552259Z",
     "start_time": "2018-06-22T17:37:02.114968Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for Random Forest: 0.11307327358987876\n",
      "1557\n",
      "HIT@10 score for RandomForest Classifier is: 0.4103848181338956\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy for Random Forest:\", accuracy_score(y_test, predictions))\n",
    "print(\"HIT@10 score for RandomForest Classifier is:\", hit_n(clf1, x_test, y_test, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T16:01:22.862598Z",
     "start_time": "2018-06-22T16:01:22.738969Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3630\n",
      "Best parameters:  [(0.0315, 'attribute_WheelchairAccessible'), (0.021, 'attribute_stars'), (0.0193, 'attribute_stars'), (0.0186, 'attribute_RestaurantsTakeOut'), (0.018, 'attribute_RestaurantsPriceRange2'), (0.0175, 'attribute_stars'), (0.0169, 'attribute_stars'), (0.015, 'attribute_Caters'), (0.0136, 'attribute_is_open'), (0.0134, 'attribute_is_open'), (0.0133, 'attribute_RestaurantsPriceRange2'), (0.0132, 'attribute_stars'), (0.013, 'attribute_WiFi'), (0.0129, 'attribute_RestaurantsTableService'), (0.0129, 'attribute_BusinessAcceptsCreditCards'), (0.0124, 'attribute_RestaurantsDelivery'), (0.0124, 'attribute_Caters'), (0.0123, 'attribute_categories'), (0.0122, 'attribute_HappyHour'), (0.0117, 'attribute_OutdoorSeating'), (0.0117, 'attribute_Ambience'), (0.0115, 'attribute_categories'), (0.0114, 'attribute_BusinessAcceptsBitcoin'), (0.0113, 'attribute_Ambience'), (0.0112, 'attribute_GoodForMeal'), (0.0111, 'attribute_DriveThru'), (0.011, 'attribute_categories'), (0.0109, 'attribute_HasTV'), (0.0108, 'attribute_GoodForMeal'), (0.0108, 'attribute_BusinessParking'), (0.0107, 'attribute_OutdoorSeating'), (0.0106, 'attribute_DietaryRestrictions'), (0.0104, 'attribute_BusinessParking'), (0.0103, 'attribute_GoodForMeal'), (0.01, 'attribute_BusinessParking'), (0.0099, 'attribute_categories'), (0.0098, 'attribute_stars'), (0.0098, 'attribute_NoiseLevel'), (0.0097, 'attribute_RestaurantsDelivery'), (0.0094, 'attribute_Ambience'), (0.0092, 'attribute_RestaurantsPriceRange2'), (0.009, 'attribute_Alcohol'), (0.0088, 'attribute_stars'), (0.0088, 'attribute_BikeParking'), (0.0087, 'attribute_WiFi'), (0.0086, 'attribute_categories'), (0.0086, 'attribute_Alcohol'), (0.0084, 'attribute_DogsAllowed'), (0.0082, 'attribute_DietaryRestrictions'), (0.0081, 'attribute_categories'), (0.0078, 'attribute_Alcohol'), (0.0077, 'attribute_DietaryRestrictions'), (0.0075, 'attribute_stars'), (0.0075, 'attribute_GoodForKids'), (0.0074, 'attribute_BusinessAcceptsBitcoin'), (0.0073, 'attribute_Ambience'), (0.007, 'attribute_categories'), (0.007, 'attribute_Smoking'), (0.0069, 'attribute_categories'), (0.0069, 'attribute_categories'), (0.0069, 'attribute_DogsAllowed'), (0.0067, 'attribute_HappyHour'), (0.0065, 'attribute_RestaurantsTakeOut'), (0.0064, 'attribute_categories'), (0.0064, 'attribute_categories'), (0.0064, 'attribute_Open24Hours'), (0.0064, 'attribute_NoiseLevel'), (0.0062, 'attribute_WheelchairAccessible'), (0.0062, 'attribute_RestaurantsGoodForGroups'), (0.0062, 'attribute_HairSpecializesIn'), (0.0062, 'attribute_GoodForMeal'), (0.0062, 'attribute_BestNights'), (0.0059, 'attribute_categories'), (0.0058, 'attribute_HairSpecializesIn'), (0.0057, 'attribute_categories'), (0.0056, 'attribute_stars'), (0.0055, 'attribute_categories'), (0.0054, 'attribute_categories'), (0.0054, 'attribute_GoodForKids'), (0.0053, 'attribute_BYOBCorkage'), (0.0051, 'attribute_Smoking'), (0.0051, 'attribute_RestaurantsGoodForGroups'), (0.0051, 'attribute_NoiseLevel'), (0.005, 'attribute_RestaurantsReservations'), (0.005, 'attribute_HairSpecializesIn'), (0.005, 'attribute_BusinessParking'), (0.005, 'attribute_BikeParking'), (0.005, 'attribute_Ambience'), (0.0049, 'attribute_BusinessParking'), (0.0049, 'attribute_AcceptsInsurance'), (0.0048, 'attribute_AcceptsInsurance'), (0.0045, 'attribute_RestaurantsPriceRange2'), (0.0045, 'attribute_GoodForMeal'), (0.0043, 'attribute_categories'), (0.0042, 'attribute_categories'), (0.0042, 'attribute_RestaurantsReservations'), (0.0041, 'attribute_categories'), (0.0041, 'attribute_RestaurantsAttire'), (0.0041, 'attribute_Open24Hours'), (0.0039, 'attribute_WiFi'), (0.0039, 'attribute_Music'), (0.0039, 'attribute_HairSpecializesIn'), (0.0037, 'attribute_categories'), (0.0037, 'attribute_HairSpecializesIn'), (0.0036, 'attribute_categories'), (0.0036, 'attribute_categories'), (0.0035, 'attribute_Smoking'), (0.0035, 'attribute_BusinessAcceptsCreditCards'), (0.0034, 'attribute_BYOB'), (0.0032, 'attribute_categories'), (0.0031, 'attribute_GoodForDancing'), (0.003, 'attribute_BYOBCorkage'), (0.0029, 'attribute_GoodForMeal'), (0.0028, 'attribute_BestNights'), (0.0028, 'attribute_BestNights'), (0.0027, 'attribute_categories'), (0.0026, 'attribute_Music'), (0.0025, 'attribute_CoatCheck'), (0.0025, 'attribute_BestNights'), (0.0024, 'attribute_categories'), (0.0023, 'attribute_NoiseLevel'), (0.0023, 'attribute_BYOBCorkage'), (0.0023, 'attribute_Ambience'), (0.0022, 'attribute_RestaurantsTableService'), (0.0021, 'attribute_HasTV'), (0.002, 'attribute_categories'), (0.002, 'attribute_GoodForDancing'), (0.002, 'attribute_Ambience'), (0.0019, 'attribute_Music'), (0.0018, 'attribute_categories'), (0.0018, 'attribute_BestNights'), (0.0018, 'attribute_Ambience'), (0.0017, 'attribute_Ambience'), (0.0016, 'attribute_Music'), (0.0016, 'attribute_BestNights'), (0.0014, 'attribute_categories'), (0.0014, 'attribute_RestaurantsAttire'), (0.001, 'attribute_DriveThru'), (0.001, 'attribute_BestNights'), (0.0008, 'attribute_Corkage'), (0.0008, 'attribute_Corkage'), (0.0008, 'attribute_BYOB'), (0.0007, 'attribute_Music'), (0.0007, 'attribute_AgesAllowed'), (0.0006, 'attribute_Music'), (0.0003, 'attribute_CoatCheck'), (0.0002, 'attribute_RestaurantsCounterService'), (0.0002, 'attribute_RestaurantsAttire'), (0.0001, 'attribute_HairSpecializesIn'), (0.0001, 'attribute_DietaryRestrictions'), (0.0001, 'attribute_AgesAllowed'), (0.0001, 'attribute_AgesAllowed'), (0.0, 'attribute_RestaurantsCounterService'), (0.0, 'attribute_Music'), (0.0, 'attribute_HairSpecializesIn'), (0.0, 'attribute_HairSpecializesIn'), (0.0, 'attribute_DietaryRestrictions'), (0.0, 'attribute_DietaryRestrictions'), (0.0, 'attribute_DietaryRestrictions'), (0.0, 'attribute_ByAppointmentOnly'), (0.0, 'attribute_ByAppointmentOnly')]\n"
     ]
    }
   ],
   "source": [
    "# a = [x*10 for x in range(1, 11)]\n",
    "print(y_test.size)\n",
    "# print(map_n(grid2, x_test, y_test, 10))\n",
    "# print(\"\\n\",clf1.best_params_)\n",
    "# grid2\n",
    "print(\"Best parameters: \", sorted(zip(map(lambda x: round(x, 4), clf1.feature_importances_), featureNames), \n",
    "             reverse=True))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:39:07.161267Z",
     "start_time": "2018-06-22T17:37:19.475181Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1837\n",
      "HIT@10 score for Xtreme Gradient Boosting Classifier is: 0.4841855561412757\n",
      "Accuracy for XGBoost: 0.13494992092778071\n"
     ]
    }
   ],
   "source": [
    "# clf2 = XGBClassifier(max_depth=10, n_jobs = -1)\n",
    "\n",
    "clf2 = XGBClassifier(n_estimators = 170, min_child_weight = 0.01, n_jobs = -1)\n",
    "# parameter_grid2 = {\"xgbclassifier__n_estimators\" : [170, 120],\n",
    "# #               \"xgbclassifier__max_depth\" : [3, 5, 10],\n",
    "# #              \"randomforestclassifier__max_features\" : [x*10 for x in range(1, 11)],\n",
    "#              \"xgbclassifier__min_child_weight\": [0.01, 0.03]\n",
    "#              }\n",
    "# # pipe\n",
    "# # clf1 = RandomForestClassifier(n_estimators=200, max_features = 15, random_state=0)\n",
    "# grid2 = GridSearchCV(clf2, param_grid=parameter_grid2, cv=3, n_jobs=-1)\n",
    "clf2.fit(x_train, y_train)\n",
    "print(\"HIT@10 score for Xtreme Gradient Boosting Classifier is:\", hit_n(clf2, x_test, y_test, 10))\n",
    "# print(\"Best parameters: {}\".format(pipe.feature_importances_))\n",
    "\n",
    "# print(\"Best features: \", sorted(zip(map(lambda x: round(x, 4), clf2.feature_importances_), featureNames), \n",
    "#              reverse=True))\n",
    "\n",
    "# print(\"\\nTime elapsed in Grid Search:\", str(datetime.now() - startTime3))\n",
    "# print(grid.best_params_)\n",
    "\n",
    "# predicted3 = pipe.predict(x_test)\n",
    "# pipe = make_pipeline(PreProcessing(),\n",
    "#                     RandomForestClassifier())\n",
    "\n",
    "# classifier3.fit(x_train, y_train)\n",
    "# predicted3 = classifier3.predict(x_test)\n",
    "# print(\"\\nTime elapsed in Random Forest:\", str(datetime.now() - startTime4))\n",
    "# print(\"Accuracy for Random Forest:\", accuracy_score(y_test, predicted3))\n",
    "\n",
    "predicted3 = clf2.predict(x_test)\n",
    "print(\"Accuracy for XGBoost:\", accuracy_score(y_test, predicted3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:51:48.040758Z",
     "start_time": "2018-06-22T17:51:48.020228Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['89147', '85301', '85225', '89145', '89052', '85254', '89109', '89139', '89118', '85032']\n"
     ]
    }
   ],
   "source": [
    "probabilities = clf2.predict_proba(x_test[:1])\n",
    "best_n = np.argsort(-probabilities, axis = 1)\n",
    "\n",
    "with open('attributeLists.json', 'r') as f:\n",
    "    attributeLists = json.load(f)\n",
    "    \n",
    "n_top = 10\n",
    "topZips = []\n",
    "for index in best_n[0][:n_top]:\n",
    "    topZips.append(attributeLists['attribute_postal_code'][index])\n",
    "    \n",
    "print(topZips)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:51:54.161431Z",
     "start_time": "2018-06-22T17:51:53.953170Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best features: [(0.0311, 'attribute_BusinessParking'), (0.0207, 'attribute_BusinessParking'), (0.0187, 'attribute_Smoking'), (0.0186, 'attribute_BusinessParking'), (0.0183, 'attribute_OutdoorSeating'), (0.0139, 'attribute_categories'), (0.0136, 'attribute_WheelchairAccessible'), (0.0128, 'attribute_BikeParking'), (0.0123, 'attribute_categories'), (0.0123, 'attribute_OutdoorSeating'), (0.0122, 'attribute_NoiseLevel'), (0.0118, 'attribute_BikeParking'), (0.0117, 'attribute_RestaurantsPriceRange2'), (0.0117, 'attribute_BusinessParking'), (0.0115, 'attribute_stars'), (0.0115, 'attribute_categories'), (0.0113, 'attribute_GoodForMeal'), (0.0111, 'attribute_WiFi'), (0.0111, 'attribute_Smoking'), (0.0105, 'attribute_GoodForMeal'), (0.0105, 'attribute_Ambience'), (0.0104, 'attribute_stars'), (0.0104, 'attribute_stars'), (0.0104, 'attribute_stars'), (0.0102, 'attribute_GoodForKids'), (0.0094, 'attribute_Ambience'), (0.0093, 'attribute_RestaurantsPriceRange2'), (0.0092, 'attribute_stars'), (0.0091, 'attribute_stars'), (0.0091, 'attribute_stars'), (0.009, 'attribute_Alcohol'), (0.0089, 'attribute_categories'), (0.0087, 'attribute_BYOBCorkage'), (0.0087, 'attribute_Ambience'), (0.0087, 'attribute_Alcohol'), (0.0086, 'attribute_WiFi'), (0.0086, 'attribute_GoodForMeal'), (0.0084, 'attribute_is_open'), (0.0084, 'attribute_RestaurantsPriceRange2'), (0.0084, 'attribute_HasTV'), (0.0084, 'attribute_ByAppointmentOnly'), (0.0083, 'attribute_BusinessAcceptsBitcoin'), (0.0081, 'attribute_BusinessAcceptsCreditCards'), (0.0079, 'attribute_HasTV'), (0.0079, 'attribute_Caters'), (0.0079, 'attribute_Caters'), (0.0078, 'attribute_categories'), (0.0078, 'attribute_RestaurantsTableService'), (0.0078, 'attribute_DietaryRestrictions'), (0.0078, 'attribute_Alcohol'), (0.0077, 'attribute_RestaurantsDelivery'), (0.0077, 'attribute_GoodForMeal'), (0.0076, 'attribute_categories'), (0.0075, 'attribute_is_open'), (0.0074, 'attribute_RestaurantsGoodForGroups'), (0.0073, 'attribute_RestaurantsReservations'), (0.0072, 'attribute_categories'), (0.0071, 'attribute_categories'), (0.007, 'attribute_categories'), (0.007, 'attribute_DogsAllowed'), (0.0069, 'attribute_categories'), (0.0067, 'attribute_categories'), (0.0066, 'attribute_RestaurantsDelivery'), (0.0066, 'attribute_GoodForMeal'), (0.0066, 'attribute_DietaryRestrictions'), (0.0066, 'attribute_ByAppointmentOnly'), (0.0065, 'attribute_categories'), (0.0065, 'attribute_NoiseLevel'), (0.0065, 'attribute_GoodForMeal'), (0.0065, 'attribute_BusinessAcceptsCreditCards'), (0.0064, 'attribute_categories'), (0.0064, 'attribute_GoodForKids'), (0.0064, 'attribute_DogsAllowed'), (0.0063, 'attribute_WheelchairAccessible'), (0.0063, 'attribute_RestaurantsReservations'), (0.0061, 'attribute_BYOBCorkage'), (0.006, 'attribute_categories'), (0.006, 'attribute_DietaryRestrictions'), (0.0059, 'attribute_categories'), (0.0058, 'attribute_RestaurantsTakeOut'), (0.0058, 'attribute_NoiseLevel'), (0.0057, 'attribute_categories'), (0.0056, 'attribute_HappyHour'), (0.0055, 'attribute_BYOB'), (0.0055, 'attribute_Ambience'), (0.0054, 'attribute_GoodForDancing'), (0.0053, 'attribute_RestaurantsTableService'), (0.0053, 'attribute_AcceptsInsurance'), (0.0052, 'attribute_NoiseLevel'), (0.0051, 'attribute_stars'), (0.005, 'attribute_categories'), (0.005, 'attribute_categories'), (0.0049, 'attribute_categories'), (0.0048, 'attribute_WiFi'), (0.0045, 'attribute_categories'), (0.0045, 'attribute_Smoking'), (0.0045, 'attribute_BestNights'), (0.0045, 'attribute_Ambience'), (0.0043, 'attribute_categories'), (0.0043, 'attribute_Music'), (0.0041, 'attribute_BestNights'), (0.004, 'attribute_RestaurantsCounterService'), (0.004, 'attribute_Open24Hours'), (0.004, 'attribute_DietaryRestrictions'), (0.0039, 'attribute_stars'), (0.0038, 'attribute_categories'), (0.0038, 'attribute_RestaurantsTakeOut'), (0.0038, 'attribute_DietaryRestrictions'), (0.0038, 'attribute_BusinessAcceptsBitcoin'), (0.0037, 'attribute_RestaurantsCounterService'), (0.0036, 'attribute_categories'), (0.0036, 'attribute_RestaurantsGoodForGroups'), (0.0034, 'attribute_categories'), (0.0034, 'attribute_Music'), (0.0034, 'attribute_DriveThru'), (0.0033, 'attribute_categories'), (0.0033, 'attribute_BestNights'), (0.0033, 'attribute_BestNights'), (0.0033, 'attribute_Ambience'), (0.0032, 'attribute_DietaryRestrictions'), (0.0032, 'attribute_DietaryRestrictions'), (0.0032, 'attribute_Ambience'), (0.0031, 'attribute_Corkage'), (0.0031, 'attribute_BusinessParking'), (0.003, 'attribute_categories'), (0.0028, 'attribute_HappyHour'), (0.0027, 'attribute_RestaurantsAttire'), (0.0027, 'attribute_RestaurantsAttire'), (0.0027, 'attribute_DriveThru'), (0.0027, 'attribute_Corkage'), (0.0027, 'attribute_BestNights'), (0.0025, 'attribute_RestaurantsPriceRange2'), (0.0024, 'attribute_RestaurantsAttire'), (0.0024, 'attribute_BestNights'), (0.0023, 'attribute_Music'), (0.0023, 'attribute_GoodForDancing'), (0.0022, 'attribute_Music'), (0.0022, 'attribute_BestNights'), (0.0022, 'attribute_Ambience'), (0.0022, 'attribute_AcceptsInsurance'), (0.0021, 'attribute_Music'), (0.0021, 'attribute_AgesAllowed'), (0.0018, 'attribute_BYOB'), (0.0018, 'attribute_Ambience'), (0.0017, 'attribute_CoatCheck'), (0.0017, 'attribute_CoatCheck'), (0.0015, 'attribute_HairSpecializesIn'), (0.0015, 'attribute_AgesAllowed'), (0.0013, 'attribute_categories'), (0.0013, 'attribute_HairSpecializesIn'), (0.0011, 'attribute_Music'), (0.001, 'attribute_Open24Hours'), (0.001, 'attribute_BYOBCorkage'), (0.0009, 'attribute_HairSpecializesIn'), (0.0007, 'attribute_Music'), (0.0005, 'attribute_HairSpecializesIn'), (0.0005, 'attribute_AgesAllowed'), (0.0, 'attribute_HairSpecializesIn'), (0.0, 'attribute_HairSpecializesIn'), (0.0, 'attribute_HairSpecializesIn'), (0.0, 'attribute_HairSpecializesIn')]\n"
     ]
    }
   ],
   "source": [
    "priority = sorted(zip(map(lambda x: round(x, 4), clf2.feature_importances_), featureNames), \n",
    "             reverse=True)\n",
    "print(\"Best features:\",priority)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:52:04.148983Z",
     "start_time": "2018-06-22T17:52:04.124988Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40 38 52 15 35 50 17 53 34  4]\n",
      "0000000000000010000000000000000000000000000000000000000\n",
      "['89147', '85301', '85225', '89145', '89052', '85254', '89109', '89139', '89118', '85032']\n",
      "{'attribute_RestaurantsReservations': [False, True], 'attribute_stars': [1.0, 3.0, 4.0, 2.5, 1.5, 5.0, 3.5, 2.0, 4.5], 'attribute_Caters': [False, True], 'attribute_postal_code': ['85022', '89119', '85016', '89103', '85032', '85258', '85013', '89121', '89014', '89117', '89104', '89123', '85051', '85027', '85281', '89145', '85260', '89109', '85004', '85018', '85226', '85044', '85224', '89102', '89149', '85286', '85034', '85255', '85008', '89128', '89130', '85251', '89169', '85014', '89118', '89052', '89101', '85282', '85301', '85308', '89147', '85283', '85257', '89135', '89108', '85020', '89113', '89148', '85284', '85003', '85254', '89146', '85225', '89139', '89015'], 'attribute_BikeParking': [True, False], 'attribute_BusinessAcceptsBitcoin': [False, True], 'attribute_WiFi': ['free', 'paid', 'no'], 'attribute_HasTV': [True, False], 'attribute_Open24Hours': [False, True], 'attribute_RestaurantsGoodForGroups': [True, False], 'attribute_DriveThru': [True, False], 'attribute_RestaurantsPriceRange2': [1, 2, 3, 4], 'attribute_HappyHour': [True, False], 'attribute_NoiseLevel': ['loud', 'average', 'very_loud', 'quiet'], 'attribute_AcceptsInsurance': [True, False], 'attribute_BusinessAcceptsCreditCards': [True, False], 'attribute_RestaurantsTableService': [False, True], 'attribute_Smoking': ['no', 'outdoor', 'yes'], 'attribute_WheelchairAccessible': [True, False], 'attribute_RestaurantsDelivery': [False, True], 'attribute_ByAppointmentOnly': [False, True], 'attribute_AgesAllowed': ['21plus', 'allages', '18plus'], 'attribute_Corkage': [True, False], 'attribute_RestaurantsAttire': ['casual', 'dressy', 'formal'], 'attribute_BYOBCorkage': ['no', 'yes_free', 'yes_corkage'], 'attribute_CoatCheck': [False, True], 'attribute_RestaurantsTakeOut': [True, False], 'attribute_OutdoorSeating': [False, True], 'attribute_GoodForKids': [True, False], 'attribute_is_open': [1, 0], 'attribute_GoodForDancing': [False, True], 'attribute_RestaurantsCounterService': [False, True], 'attribute_BYOB': [False, True], 'attribute_Alcohol': ['none', 'full_bar', 'beer_and_wine'], 'attribute_DogsAllowed': [True, False]}\n"
     ]
    }
   ],
   "source": [
    "prob = clf2.predict_proba(x_test[:1])\n",
    "best_n = np.argsort(-prob, axis = 1)\n",
    "print(best_n[0][:10])\n",
    "print(y_test[0])\n",
    "with open('attributeLists.json', 'r') as f:\n",
    "    attributeLists = json.load(f)\n",
    "n_top = 10\n",
    "topZips = []\n",
    "for index in best_n[0][:n_top]:\n",
    "    topZips.append(attributeLists['attribute_postal_code'][index])\n",
    "print(topZips)\n",
    "print(attributeLists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:52:31.290238Z",
     "start_time": "2018-06-22T17:52:31.266079Z"
    }
   },
   "outputs": [],
   "source": [
    "print((predicted3)[:10])\n",
    "print((y_test)[:10])\n",
    "\n",
    "print(predicted3.size)\n",
    "print(y_test.size)\n",
    "\n",
    "print(pipe.classes_)\n",
    "\n",
    "main = pipe.classes_\n",
    "\n",
    "probs = pipe.predict_proba(x_test)\n",
    "best_n = np.argsort(probs)\n",
    "arr = best_n[10][-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.056Z"
    }
   },
   "outputs": [],
   "source": [
    "# import pickle\n",
    "import xgboost as xgb\n",
    "filename = \"Model_v0.3.pkl\"\n",
    "\n",
    "# with open('../Models/'+filename, 'wb') as file:\n",
    "#     pickle.dump(clf2, file)\n",
    "\n",
    "clf2.save_model('../Models/'+filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.060Z"
    }
   },
   "outputs": [],
   "source": [
    "with open('./attributeLists.json', 'r') as f:\n",
    "    attributeLists = json.load(f)\n",
    "\n",
    "for encodedZip in y_test[1:10]:\n",
    "    i = 0\n",
    "    for bit in encodedZip:\n",
    "        if bit == 1:\n",
    "            print(attributeLists['attribute_postal_code'][i])\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.062Z"
    }
   },
   "outputs": [],
   "source": [
    "classificationVectors[0]\n",
    "binnis = []\n",
    "with open('business.json', 'r') as f:\n",
    "    for lines in f:\n",
    "        binnis.append(json.loads(lines))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.068Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification\n",
    "from sklearn.multioutput import MultiOutputClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.utils import shuffle\n",
    "import numpy as np\n",
    "X, y1 = make_classification(n_samples=10, n_features=100, n_informative=30, n_classes=3, random_state=1)\n",
    "X1, y1 = make_classification(n_samples=10, n_features=100, n_informative=30, n_classes=3)\n",
    "y2 = shuffle(y1, random_state=1)\n",
    "y3 = shuffle(y1, random_state=2)\n",
    "Y = np.vstack((y1, y2, y3)).T\n",
    "Z = np.array([[1, 0, 0],\n",
    "       [0, 0, 1],\n",
    "       [1, 0, 0],\n",
    "       [0, 1, 0],\n",
    "       [1, 0, 0],\n",
    "       [0, 0, 1],\n",
    "       [0, 0, 1],\n",
    "       [1, 0, 0],\n",
    "       [1, 0, 0],\n",
    "       [0, 1, 0]])\n",
    "n_samples, n_features = X.shape # 10,100\n",
    "n_outputs = Y.shape[1] # 3\n",
    "n_classes = 3\n",
    "forest = RandomForestClassifier(n_estimators=100, random_state=1)\n",
    "multi_target_forest = MultiOutputClassifier(forest, n_jobs=-1)\n",
    "p = multi_target_forest.fit(X, Z).predict(X1)\n",
    "print(p)\n",
    "# print(\"Accuracy for Random Forest:\", accuracy_score(Y, p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:54:40.028560Z",
     "start_time": "2018-06-22T17:54:39.925689Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.020265811999706784\n",
      "0.07899421399997664\n"
     ]
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "print(timeit(\"[]\"))\n",
    "print(timeit(\"list()\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-22T17:51:29.362014Z",
     "start_time": "2018-06-22T17:51:29.096558Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'binnis' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-2862319886cb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbinnis\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'binnis' is not defined"
     ]
    }
   ],
   "source": [
    "binnis[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.078Z"
    }
   },
   "outputs": [],
   "source": [
    "with open('/media/gu38/Common/DIVA/FinalProject/yelp/dummy_data.json', 'r') as f:\n",
    "    dummyList = json.load(f)\n",
    "print(dummyList[0])\n",
    "dummyList2 = [\n",
    "  \"85282\", \n",
    "  \"89147\", \n",
    "  \"85224\", \n",
    "  \"85226\", \n",
    "  \"89139\", \n",
    "  \"85004\", \n",
    "  \"89130\", \n",
    "  \"89146\", \n",
    "  \"85301\", \n",
    "  \"85251\"\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.080Z"
    }
   },
   "outputs": [],
   "source": [
    "print(attribufeatures[1][10:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-04-29T22:47:50.084Z"
    }
   },
   "outputs": [],
   "source": [
    "d1={1:2,3:4}\n",
    "d2={5:6,7:9}\n",
    "d3={10:8,13:22}\n",
    "d4 = dict(d1.items() + d2.items())\n",
    "print(d4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}