Finding Promising Business Locations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategic Location using Facebook Analytics\n",
    "\n",
    "If you were to open your own cafe, would you not want to effortlessly identify the most suitable location to set up your shop? Choosing an optimal physical location is a critical decision for numerous businesses, as many factors contribute to the final choice of the location.\n",
    "Features selected:\n",
    "* category of cafe\n",
    "* category of neighboring cafes\n",
    "* checkins of localities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#preprocessing\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def JsontoDataFrame(jsonFile):\n",
    "    data=pd.read_json(jsonFile)\n",
    "    data=data.as_matrix()\n",
    "    data= data.transpose()\n",
    "    data=pd.DataFrame(data,columns=['Category','Check-Ins','Latitude','Likes','Longitude','Name'])\n",
    "    return data\n",
    "\n",
    "def filterFoodRelated(data):\n",
    "    totalIndex=0\n",
    "    remIndex=[]\n",
    "    keepIndex=[]\n",
    "    uniqueCategories=[]\n",
    "    frConstraints=['Diner','Fruit','Vegetable','Caterer','Bar','Pub','Grill','Hotel','Restaurant','Lounge','Pizza Place','Dessert Shop','Coffee','Food','Beverage','Cafe']\n",
    "    \n",
    "    for index,rows in data.iterrows():\n",
    "        #print index,rows['Category']\n",
    "        for cat in rows['Category']:\n",
    "            categorysublist=cat.split(' ')\n",
    "            if len(set(categorysublist).intersection(frConstraints))>0:\n",
    "                keepIndex.append(index)\n",
    "                uniqueCategories.append(cat)\n",
    "                break\n",
    "            \n",
    "        totalIndex=index\n",
    "    \n",
    "    remIndex=list(set(range(totalIndex+1))-set(keepIndex))\n",
    "    data=data.drop(data.index[remIndex]).reset_index(drop=True)\n",
    "    return data,list(set(uniqueCategories))\n",
    "    \n",
    "all_data=JsontoDataFrame('fbData.json')\n",
    "food_data,unique_categories=filterFoodRelated(all_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Label Binarizer Encoding Categories\n",
    "from sklearn import preprocessing\n",
    "lb=preprocessing.LabelBinarizer()\n",
    "lb.fit(unique_categories)\n",
    "\n",
    "def orCategories(bcat1,bcat2):\n",
    "    \"\"\"\n",
    "    Oring Category Codes \n",
    "    \"\"\"\n",
    "    result_cat=[]\n",
    "    for val1,val2 in zip(bcat1,bcat2):\n",
    "        if val1==1 or val2==1:\n",
    "            result_cat.append(1)\n",
    "        else:\n",
    "            result_cat.append(0)\n",
    "    #print 'res',result_cat\n",
    "    return result_cat\n",
    "\n",
    "def addBinaryCategoryData(data):\n",
    "    \"\"\"\n",
    "    Finding Binary Category Codes of all entries\n",
    "    \"\"\"\n",
    "    binary_category=[]\n",
    "    for catlist in data[\"Category\"]:\n",
    "        final_category=[0]*len(lb.classes_)\n",
    "        for cat in catlist:\n",
    "            if cat in unique_categories:\n",
    "                #print cat\n",
    "                binary_encoded_cat=lb.transform([str(cat)])[0]\n",
    "                finalcat=orCategories(final_category,binary_encoded_cat)\n",
    "                binary_category.append(finalcat)\n",
    "    return binary_category\n",
    "\n",
    "food_data['Category Code']=pd.Series(addBinaryCategoryData(food_data))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Finding Neigbouring Food related Joints\n",
    "from math import radians, cos, sin, asin, sqrt\n",
    "\n",
    "def haversine_dist(lon1, lat1, lon2, lat2):\n",
    "    \"\"\"\n",
    "    Calculate the great circle distance between two points \n",
    "    on the earth (specified in decimal degrees)\n",
    "    \"\"\"\n",
    "    # convert decimal degrees to radians \n",
    "    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\n",
    "    # haversine formula \n",
    "    dlon = lon2 - lon1 \n",
    "    dlat = lat2 - lat1 \n",
    "    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2\n",
    "    c = 2 * asin(sqrt(a)) \n",
    "    m = 6367 * c*1000\n",
    "    return m\n",
    "\n",
    "\n",
    "def findNeighbors(data,target_latitude,target_longitude,distance,is_food_related=True):\n",
    "    \"\"\"\n",
    "    Finding Neighbors to a given point on map\n",
    "    \"\"\"\n",
    "    neighbor_name=[]\n",
    "    neighbor_category=[0]*len(lb.classes_)\n",
    "    neighbor_checkins=0\n",
    "    if is_food_related:\n",
    "        for latitude,longitude,name,binary_category,check_in in zip(data['Latitude'],data['Longitude'],data['Name'],data['Category Code'],data['Check-Ins']):\n",
    "            neighbor_latitide=latitude\n",
    "            neighbor_longitude=longitude\n",
    "            if haversine_dist(target_longitude,target_latitude,neighbor_longitude,neighbor_latitide) < distance and target_longitude!=neighbor_longitude and neighbor_latitide!=target_latitude:\n",
    "                neighbor_name.append(name)\n",
    "                if is_food_related:\n",
    "                    neighbor_category=orCategories(neighbor_category,binary_category)\n",
    "                neighbor_checkins=neighbor_checkins+check_in\n",
    "    else:\n",
    "        for latitude,longitude,name,check_in in zip(data['Latitude'],data['Longitude'],data['Name'],data['Check-Ins']):\n",
    "            neighbor_latitide=latitude\n",
    "            neighbor_longitude=longitude\n",
    "            if haversine_dist(target_longitude,target_latitude,neighbor_longitude,neighbor_latitide) < distance and target_longitude!=neighbor_longitude and neighbor_latitide!=target_latitude:\n",
    "                neighbor_name.append(name)\n",
    "                neighbor_checkins=neighbor_checkins+check_in\n",
    "    return neighbor_name,neighbor_category,neighbor_checkins\n",
    "         \n",
    "def findAllNeighbors(distance,is_food_related=True,*data):\n",
    "    DISTANCE=distance\n",
    "    all_neighbour_name=[]\n",
    "    all_neighbour_category=[]\n",
    "    all_neighbour_checkins=[]\n",
    "    if is_food_related:\n",
    "        for lat,lon in zip(data[0]['Latitude'],data[0]['Longitude']):\n",
    "            neighbor_name,neighbor_category,neighbor_checkins=findNeighbors(data[0],lat,lon,DISTANCE,True)\n",
    "            all_neighbour_name.append(neighbor_name)\n",
    "            all_neighbour_category.append(neighbor_category)\n",
    "            all_neighbour_checkins.append(neighbor_checkins)\n",
    "    \n",
    "    else:\n",
    "        food_related_joints=data[0]['Name']\n",
    "        for lat,lon,name in zip(data[1]['Latitude'],data[1]['Longitude'],data[1]['Name']):\n",
    "            #Error in this line\n",
    "            #print name in food_related_joints returns false\n",
    "            if name[0] in food_related_joints[0]:\n",
    "                for lat,lon in zip(data[1]['Latitude'],data[1]['Longitude']):\n",
    "                    neighbor_name,neighbor_category,neighbor_checkins=findNeighbors(data[1],lat,lon,DISTANCE,False)\n",
    "                    all_neighbour_name.append(neighbor_name)\n",
    "                    all_neighbour_checkins.append(neighbor_checkins)  \n",
    "\n",
    "    return all_neighbour_name,all_neighbour_category,all_neighbour_checkins\n",
    "\n",
    "    \n",
    "\n",
    "def findAverageNeighborCheckIns(data,is_food_related=True):\n",
    "    average_neigbor_checkins=[]\n",
    "    if is_food_related:\n",
    "        column_total_check_ins='Food-Related Neighbor Total Check-Ins'\n",
    "        column_neigbor_names='Food-Related Neighbor Names'\n",
    "    else:\n",
    "        column_total_check_ins='All Neighbor Total Check-Ins'\n",
    "        column_neigbor_names='All Neighbor Names'\n",
    "    for neigbors,check_ins in zip(data[column_neigbor_names],data[column_total_check_ins]):\n",
    "        average_neigbor_checkins.append(check_ins/len(neigbors))\n",
    "    return average_neigbor_checkins\n",
    "    \n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Food Related DataFrame Modification\n",
    "all_neighbour_name,all_neighbour_category,all_neighbour_checkins=findAllNeighbors(1000,True,food_data,all_data) \n",
    "\n",
    "food_data['Food-Related Neighbor Names']=pd.Series(all_neighbour_name)\n",
    "food_data['Food-Related Neighbor Category Codes']=pd.Series(all_neighbour_category)\n",
    "food_data['Food-Related Neighbor Total Check-Ins']=pd.Series(all_neighbour_checkins)\n",
    "#food_data.drop('Food-Related Neighbor Check-Ins', axis=1, inplace=True)\n",
    "food_data['Food-Related Neighbor Average Check-Ins']=pd.Series(findAverageNeighborCheckIns(food_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#All Neighbors DataFrame Modification\n",
    "all_neighbour_name,all_neighbour_category,all_neighbour_checkins=findAllNeighbors(1000,False,food_data,all_data) \n",
    "\n",
    "food_data['All Neighbor Names']=pd.Series(all_neighbour_name)\n",
    "food_data['All Neighbor Total Check-Ins']=pd.Series(all_neighbour_checkins)\n",
    "food_data['All Neighbor Average Check-Ins']=pd.Series(findAverageNeighborCheckIns(food_data,False))\n",
    "#food_data.drop('All Neighbor Category Codes', axis=1, inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Rearranging Columns\n",
    "food_data=food_data[['Name','Category','Likes','Check-Ins','Latitude','Longitude','Category Code','Food-Related Neighbor Names','Food-Related Neighbor Category Codes',\n",
    "                    'Food-Related Neighbor Total Check-Ins','Food-Related Neighbor Average Check-Ins','All Neighbor Names','All Neighbor Total Check-Ins'\n",
    "                    ,'All Neighbor Average Check-Ins']]\n",
    "data_of_interest=food_data[['Name','Category','Likes','Check-Ins','Category Code','Food-Related Neighbor Category Codes',\n",
    "                    'Food-Related Neighbor Total Check-Ins','Food-Related Neighbor Average Check-Ins','All Neighbor Total Check-Ins'\n",
    "                    ,'All Neighbor Average Check-Ins']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Transfering to csv\n",
    "data_of_interest.to_csv('Final Data.csv',encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "X_train=data_of_interest[['Category Code','Food-Related Neighbor Category Codes','Food-Related Neighbor Total Check-Ins'\n",
    "                         ,'Food-Related Neighbor Average Check-Ins','All Neighbor Total Check-Ins','All Neighbor Average Check-Ins']]\n",
    "Y_train=data_of_interest[['Check-Ins']]\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def convertBinaryArrayToNumber(array):\n",
    "    number=0\n",
    "    array.reverse()\n",
    "    i=0\n",
    "    for val in array:\n",
    "        number=number+val*pow(2,i)\n",
    "        i=i+1\n",
    "    return number\n",
    "        \n",
    "def convertCodeToNumber(data):\n",
    "    category_decode=[]\n",
    "    neighbor_category_decode=[]\n",
    "    for cat_code,n_cat_code in zip(data['Category Code'],data['Food-Related Neighbor Category Codes']):\n",
    "        category_decode.append(convertBinaryArrayToNumber(cat_code))\n",
    "        neighbor_category_decode.append(convertBinaryArrayToNumber(n_cat_code))\n",
    "        #category_decode.append(lb.inverse_transform(cat_code))\n",
    "        #neighbor_category_decode.append(ib.inverse_transform(n_cat_code))\n",
    "        \n",
    "    return category_decode,neighbor_category_decode\n",
    "        \n",
    "\n",
    "category_decode,neighbor_category_decode=convertCodeToNumber(X_train)  \n",
    "X_train['Category Code']=pd.Series(category_decode)\n",
    "X_train['Food-Related Neighbor Category Codes']=pd.Series(neighbor_category_decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Converting float to int\n",
    "#uncomment it once for first run\n",
    "Y_train.to_csv('Target.csv')\n",
    "Y_train=pd.read_csv('Target.csv',dtype='float64')\n",
    "Y_train.drop('Unnamed: 0', axis=1, inplace=True)\n",
    "\n",
    "Y_train=Y_train.values.astype(int)\n",
    "X_train=X_train.values.astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing models\n",
    "* Linear Regressor\n",
    "* Ridge\n",
    "* Support Vector Machine\n",
    "\n",
    "Support vector gives 8210.6410256410254 error and hence we will choose support vector machine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8916.3846153846152"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Testing out models\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "\n",
    "linearrgr = LinearRegression()\n",
    "linearrgr.fit(X_train,Y_train)\n",
    "ypred=linearrgr.predict(X_train).astype(int)\n",
    "mean_absolute_error(ypred,Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8916.3846153846152"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#RidgeRegression\n",
    "from sklearn import linear_model \n",
    "\n",
    "ridge=linear_model.Ridge(alpha=0.5)\n",
    "ridge.fit(X_train,Y_train)\n",
    "yprred=ridge.predict(X_train).astype(int)\n",
    "mean_absolute_error(yprred,Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8210.6410256410254"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Support vector machines\n",
    "from sklearn import svm\n",
    "\n",
    "supvecmac=svm.SVR()\n",
    "supvecmac.fit(X_train,Y_train)\n",
    "yprred=supvecmac.predict(X_train)\n",
    "\n",
    "mean_absolute_error(yprred,Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TrainedModel.pkl',\n",
       " 'TrainedModel.pkl_01.npy',\n",
       " 'TrainedModel.pkl_02.npy',\n",
       " 'TrainedModel.pkl_03.npy',\n",
       " 'TrainedModel.pkl_04.npy',\n",
       " 'TrainedModel.pkl_05.npy',\n",
       " 'TrainedModel.pkl_06.npy',\n",
       " 'TrainedModel.pkl_07.npy',\n",
       " 'TrainedModel.pkl_08.npy',\n",
       " 'TrainedModel.pkl_09.npy',\n",
       " 'TrainedModel.pkl_10.npy']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.externals import joblib\n",
    "\n",
    "joblib.dump(supvecmac,'TrainedModel.pkl')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}