YelpRecommender.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!rm -rf ./metastore_db/\n",
    "#pyspark --executor-memory 8g --driver-memory 8g --conf spark.driver.maxResultSize=2g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import json\n",
    "import pickle\n",
    "import shutil\n",
    "import seaborn as sns\n",
    "from time import mktime\n",
    "from datetime import datetime\n",
    "from pyspark.ml.feature import StringIndexer, StandardScaler, IndexToString\n",
    "from pyspark.ml.evaluation import RegressionEvaluator\n",
    "from pyspark.ml.recommendation import ALS, ALSModel\n",
    "from pyspark.ml.tuning import ParamGridBuilder\n",
    "from pyspark.sql import Row\n",
    "from pyspark.sql.functions import UserDefinedFunction, stddev\n",
    "from pyspark.sql.functions import * # array, desc, asc, mean\n",
    "from pyspark.sql.types import StructType, StructField, StringType, DoubleType, DateType, IntegerType\n",
    "%matplotlib inline\n",
    "\n",
    "sqlc = SQLContext(sc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class YelpRecommender(object):\n",
    "    def __init__(self, folder='./', business_filename=None, reviews_filename=None):\n",
    "        self._folder = folder\n",
    "        if business_filename is None:\n",
    "            business_filename = os.path.join(folder, 'yelp_academic_dataset_business.json')\n",
    "        if reviews_filename is None:\n",
    "            reviews_filename = os.path.join(folder, 'yelp_academic_dataset_review.json')\n",
    "        \n",
    "        self._city = None\n",
    "        self._category = None\n",
    "        self._min_per_user = 0\n",
    "        self._scaler = {'mean': True, 'stdev': False}\n",
    "        \n",
    "        self._verbose = True\n",
    "        self._business = None\n",
    "        self._reviews = None\n",
    "        self._city_business = None\n",
    "        self._city_reviews = None\n",
    "        self._dataset = None\n",
    "        self._training = None\n",
    "        self._test = None\n",
    "        self._best_model = None\n",
    "        self._best_parms = None\n",
    "        self._eval = None\n",
    "        \n",
    "        self._business_dict = {}\n",
    "        self._user_dict = {}\n",
    "        self._review_dict = {}\n",
    "        \n",
    "        self.load_business(business_filename)\n",
    "        self.load_reviews(reviews_filename)\n",
    "    \n",
    "    def console(self, message):\n",
    "        if self._verbose:\n",
    "            print(message)\n",
    "            \n",
    "    @property\n",
    "    def best_model(self):\n",
    "        return self._best_model\n",
    "    \n",
    "    @property\n",
    "    def best_parms(self):\n",
    "        return self._best_parms\n",
    "    \n",
    "    @property\n",
    "    def evaluation(self):\n",
    "        return self._eval\n",
    "    \n",
    "    @property\n",
    "    def all_users(self):\n",
    "        return self._user_dict.keys()\n",
    "    \n",
    "    @staticmethod\n",
    "    def rest_to_json(row):\n",
    "        return {row.business_idn: {'name': row.name,\n",
    "                                   'address': row.address, \n",
    "                                   'stars': row.stars, \n",
    "                                   'categories': row.categories}}\n",
    "    \n",
    "    def load_business(self, filename):\n",
    "        self.console('Loading businesses data...')\n",
    "        if os.path.exists('./metastore_db/dbex.lck'):\n",
    "            os.remove('./metastore_db/dbex.lck')    \n",
    "        business = sqlc.read.json(filename)\n",
    "        business = business.select('business_id', 'name', 'city', 'stars', 'categories', 'address')\n",
    "        self._business = business\n",
    "\n",
    "    def load_reviews(self, filename):\n",
    "        self.console('Loading reviews data...')\n",
    "        if os.path.exists('./metastore_db/dbex.lck'):\n",
    "            os.remove('./metastore_db/dbex.lck')    \n",
    "        reviews = sqlc.read.json(filename)\n",
    "        reviews = reviews.select('user_id', 'business_id', 'stars', 'date')\n",
    "        self._reviews = reviews\n",
    "\n",
    "    def _get_city_businesses(self, category):\n",
    "        def is_category_listed(name, categories):\n",
    "            listed = 0.0\n",
    "            if categories is not None:\n",
    "                if name in categories:\n",
    "                    listed = 1.0\n",
    "            return listed\n",
    "        \n",
    "        is_category = UserDefinedFunction(lambda c: is_category_listed(category, c), DoubleType())\n",
    "\n",
    "        business_cat = self._business.withColumn('is_category', is_category('categories')) \\\n",
    "                                    .filter('is_category = 1.0') \\\n",
    "                                    .drop('is_category')\n",
    "\n",
    "        city_business = business_cat.filter('city = \"' + self._city +'\"')\n",
    "\n",
    "        business_indexer = StringIndexer().setInputCol('business_id').setOutputCol('business_idn')\n",
    "        business_idx_model = business_indexer.fit(city_business)\n",
    "        city_business = business_idx_model.transform(city_business)\n",
    "\n",
    "        city_business.cache()\n",
    "\n",
    "        rest = city_business.select('business_idn', 'name', 'address', 'stars', 'categories').rdd.collect()\n",
    "        rest = map(self.rest_to_json, rest)\n",
    "        rest = {k: v for d in rest for k, v in d.items()}\n",
    "\n",
    "        filename = os.path.join(folder, '%s_%s_business.pickle' % (self._city.replace(' ', '_'), self._category))\n",
    "        self.console('Saving business data to %s ...' % filename)\n",
    "        with open(filename, 'wb') as f:\n",
    "            pickle.dump(rest, f)\n",
    "        self._business_dict = rest\n",
    "\n",
    "        self._city_business = city_business\n",
    "\n",
    "    def _get_city_reviews(self):\n",
    "        reviews_city = self._reviews.join(self._city_business.select('business_id', 'business_idn'), on='business_id')\n",
    "\n",
    "        np.random.seed(42)\n",
    "        to_timestamp = UserDefinedFunction(lambda d: mktime(datetime.strptime(d, '%Y-%m-%d').timetuple()) + np.random.random(), DoubleType())\n",
    "        df_selected = reviews_city.select('user_id', 'business_idn', 'stars', to_timestamp('date').alias('timestamp')).drop('date')\n",
    "\n",
    "        if self._min_per_user > 0:\n",
    "            df_selected.createOrReplaceTempView('ratings')\n",
    "            df_selected = sqlc.sql('select user_id, business_idn, stars, timestamp \\\n",
    "                                    from ratings \\\n",
    "                                    where user_id in (select user_id \\\n",
    "                                                      from ratings \\\n",
    "                                                      group by user_id \\\n",
    "                                                      having count(1) > ' + str(self._min_per_user) + ')')\n",
    "\n",
    "        df_selected.cache()\n",
    "        user_indexer = StringIndexer().setInputCol('user_id').setOutputCol('user_idn')\n",
    "        user_idx_model = user_indexer.fit(df_selected)\n",
    "        df_selected = user_idx_model.transform(df_selected)    \n",
    "\n",
    "        df_selected.cache()\n",
    "        user_last = df_selected.select('user_id', 'timestamp').groupby('user_id').max().rdd.collectAsMap()\n",
    "        user_last_lookup = sc.broadcast(user_last)    \n",
    "\n",
    "        get_last = UserDefinedFunction(lambda c: user_last_lookup.value.get(c), DoubleType())\n",
    "        df_selected = df_selected.withColumn('last_time', get_last('user_id'))\n",
    "        df_selected.cache()\n",
    "\n",
    "        user_mapping = df_selected.select('user_id', 'user_idn').groupby('user_id').max().rdd.collectAsMap()\n",
    "        filename = os.path.join(folder, '%s_%s_user.pickle' % (self._city.replace(' ', '_'), self._category))\n",
    "        self.console('Saving user data to %s ...' % filename)\n",
    "        with open(filename, 'wb') as f:\n",
    "            pickle.dump(user_mapping, f)\n",
    "        self._user_dict = user_mapping\n",
    "\n",
    "        all_visited = df_selected.select('user_idn', 'business_idn').groupby('user_idn').agg(collect_list('business_idn')).rdd.collectAsMap()\n",
    "        filename = os.path.join(folder, '%s_%s_review.pickle' % (self._city.replace(' ', '_'), self._category))\n",
    "        self.console('Saving review data to %s ...' % filename)\n",
    "        with open(filename, 'wb') as f:\n",
    "            pickle.dump(all_visited, f)\n",
    "        self._review_dict = all_visited\n",
    "\n",
    "        self._city_reviews = df_selected\n",
    "\n",
    "    def _apply_scaler(self, mean=True, stdev=False):\n",
    "        if mean:\n",
    "            user_means = self._city_reviews.select('user_id', 'stars').groupby('user_id').mean().rdd.collectAsMap()\n",
    "        else:\n",
    "            user_means = {}\n",
    "\n",
    "        user_means_lookup = sc.broadcast(user_means)\n",
    "\n",
    "        if stdev:\n",
    "            user_stds = self._city_reviews.select('user_id', 'stars').groupby('user_id').agg(stddev('stars').alias('stddev')).rdd.collect()\n",
    "            user_stds = dict(map(lambda row: (row.user_id, row.stddev if row.stddev > 0.0 else 1.0), user_stds))\n",
    "        else:\n",
    "            user_stds = {}\n",
    "        user_stds_lookup = sc.broadcast(user_stds)    \n",
    "\n",
    "        center_user_stars = UserDefinedFunction(lambda cols: (float(cols[1]) - user_means_lookup.value.get(cols[0], 0.0))/user_stds_lookup.value.get(cols[0], 1.0), DoubleType())\n",
    "\n",
    "        df_scaled = self._city_reviews.withColumn('centered', center_user_stars(array('user_id','stars'))) \\\n",
    "                        .drop('stars') \\\n",
    "                        .withColumnRenamed('centered', 'stars')\n",
    "\n",
    "        df_scaled.cache()\n",
    "\n",
    "        self._dataset = df_scaled\n",
    "\n",
    "    def _training_test_split(self):\n",
    "        training = self._dataset.filter('last_time <> timestamp')\n",
    "        test = self._dataset.filter('last_time = timestamp')\n",
    "        \n",
    "        # https://github.com/apache/spark/pull/12896\n",
    "        available_business = sc.broadcast(set(training.select('business_idn').distinct().rdd.map(lambda t: t.business_idn).collect()))\n",
    "        is_available = UserDefinedFunction(lambda idn: 1.0 if idn in available_business.value else 0.0, DoubleType())    \n",
    "        test = test.withColumn('available', is_available('business_idn'))\n",
    "        test = test.filter('available = 1.0')\n",
    "\n",
    "        self._training, self._test = training, test\n",
    "\n",
    "    def _grid_search(self, paramGrid):\n",
    "        model_list = []\n",
    "        eval_lists = {'train_rmse': [], 'test_rmse': []}\n",
    "\n",
    "        param_list = [dict(map(lambda t: (t[0].name, t[1]), params.items())) for params in paramGrid]\n",
    "\n",
    "        for idx, params in enumerate(param_list):\n",
    "            self.console(\"Training model %d/%d with %s\" % (idx + 1, len(param_list), params))\n",
    "            model = ALS(userCol=\"user_idn\", itemCol=\"business_idn\", ratingCol=\"stars\", seed=42).setParams(**params)\n",
    "            model = model.fit(self._training)\n",
    "            model_list.append(model)\n",
    "\n",
    "            predictions = model.transform(self._training)\n",
    "            evaluator = RegressionEvaluator(metricName=\"rmse\", labelCol=\"stars\",\n",
    "                                            predictionCol=\"prediction\")\n",
    "            train_rmse = evaluator.evaluate(predictions)\n",
    "            eval_lists['train_rmse'].append(train_rmse)\n",
    "            self.console(\"Train Root-mean-square error = \" + str(train_rmse))\n",
    "\n",
    "            predictions = model.transform(self._test)\n",
    "            evaluator = RegressionEvaluator(metricName=\"rmse\", labelCol=\"stars\",\n",
    "                                            predictionCol=\"prediction\")\n",
    "            test_rmse = evaluator.evaluate(predictions)\n",
    "            eval_lists['test_rmse'].append(test_rmse)\n",
    "            self.console(\"Test Root-mean-square error = \" + str(test_rmse))\n",
    "\n",
    "        best_seq = np.argmin(eval_lists['test_rmse'])\n",
    "        best_model = model_list[best_seq]\n",
    "        best_parms = param_list[best_seq]\n",
    "        \n",
    "        self._best_model, self._best_parms, self._eval = best_model, best_parms, eval_lists\n",
    "        \n",
    "        model_filename = os.path.join(folder, '%s_als_model_regParm%0.1f_rank%d_maxIter%d' % (self._city.replace(' ', '_'), best_parms['regParam'], best_parms['rank'], best_parms['maxIter']))\n",
    "        self.console(\"Best model parameters: %s\" % best_parms)\n",
    "        self.console(\"Saving best model to %s\" % model_filename)\n",
    "        if os.path.exists(model_filename):\n",
    "            shutil.rmtree(model_filename)\n",
    "        best_model.save(model_filename)\n",
    "    \n",
    "    def fit(self, city, category, parms, verbose=True):\n",
    "        self._verbose = verbose\n",
    "        \n",
    "        self._city = city\n",
    "        self._category = category\n",
    "        self._min_per_user = parms['min_per_user']\n",
    "        self._scaler = parms['scaler']\n",
    "        \n",
    "        self.console('Filtering businesses for the city...')\n",
    "        self._get_city_businesses(self._category)\n",
    "        self.console('Filtering reviews for the city...')\n",
    "        self._get_city_reviews()\n",
    "        self.console('Scaling user ratings...')\n",
    "        self._apply_scaler(mean=self._scaler['mean'], stdev=self._scaler['stdev'])\n",
    "        self.console('Splitting dataset into training and test...')\n",
    "        self._training_test_split()\n",
    "\n",
    "        als = ALS()\n",
    "        paramGrid = ParamGridBuilder() \\\n",
    "            .addGrid(als.rank, parms['als']['rank']) \\\n",
    "            .addGrid(als.maxIter, parms['als']['maxIter']) \\\n",
    "            .addGrid(als.regParam, parms['als']['regParam']) \\\n",
    "            .build()\n",
    "\n",
    "        self.console('Performing grid search over parameters...')\n",
    "        self._grid_search(paramGrid)\n",
    "        self.console('Finished!')\n",
    "        \n",
    "    def recommend(self, user_id, n):\n",
    "        n_business = len(self._business_dict)\n",
    "        user_idn = self._user_dict[user_id]\n",
    "        visited = self._review_dict[user_idn]\n",
    "        test_user = sqlc.createDataFrame([Row(user_idn=user_idn, business_idn=float(i)) for i in list(set(range(n_business)).difference(set(visited)))])\n",
    "\n",
    "        pred_test = self._best_model.transform(test_user).na.fill(-5.0)\n",
    "        top_pred = pred_test.orderBy(desc('prediction')).select('business_idn').rdd.map(lambda row: row.business_idn).take(n)\n",
    "        response = map(lambda idn: self._business_dict[idn], top_pred)\n",
    "        return json.dumps(response)\n",
    "    \n",
    "    def list_ratings(self, user_id, n):\n",
    "        user_idn = self._user_dict[user_id]\n",
    "        visited = self._review_dict[user_idn]\n",
    "        response = sorted(map(lambda idn: self._business_dict[idn], visited), key=lambda k: k['stars'], reverse=True)[:n]\n",
    "        return json.dumps(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading businesses data...\n",
      "Loading reviews data...\n"
     ]
    }
   ],
   "source": [
    "folder = './dataset'\n",
    "\n",
    "rec = YelpRecommender(folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtering businesses for the city...\n",
      "Saving business data to ./dataset/Edinburgh_Restaurants_business.pickle ...\n",
      "Filtering reviews for the city...\n",
      "Saving user data to ./dataset/Edinburgh_Restaurants_user.pickle ...\n",
      "Saving review data to ./dataset/Edinburgh_Restaurants_review.pickle ...\n",
      "Scaling user ratings...\n",
      "Splitting dataset into training and test...\n",
      "Performing grid search over parameters...\n",
      "Training model 1/18 with {'regParam': 1.0, 'rank': 5, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.912371011185\n",
      "Test Root-mean-square error = 0.955528800143\n",
      "Training model 2/18 with {'regParam': 0.3, 'rank': 5, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.745469998851\n",
      "Test Root-mean-square error = 0.948756638183\n",
      "Training model 3/18 with {'regParam': 0.1, 'rank': 5, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.525197930941\n",
      "Test Root-mean-square error = 1.04287028516\n",
      "Training model 4/18 with {'regParam': 1.0, 'rank': 5, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.912411405327\n",
      "Test Root-mean-square error = 0.955527818845\n",
      "Training model 5/18 with {'regParam': 0.3, 'rank': 5, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.730552896163\n",
      "Test Root-mean-square error = 0.945782674791\n",
      "Training model 6/18 with {'regParam': 0.1, 'rank': 5, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.499259600459\n",
      "Test Root-mean-square error = 1.04424990762\n",
      "Training model 7/18 with {'regParam': 1.0, 'rank': 10, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.912378526422\n",
      "Test Root-mean-square error = 0.955527376778\n",
      "Training model 8/18 with {'regParam': 0.3, 'rank': 10, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.723419435075\n",
      "Test Root-mean-square error = 0.9429564116\n",
      "Training model 9/18 with {'regParam': 0.1, 'rank': 10, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.406884428891\n",
      "Test Root-mean-square error = 1.00423061191\n",
      "Training model 10/18 with {'regParam': 1.0, 'rank': 10, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.912412588654\n",
      "Test Root-mean-square error = 0.955527748732\n",
      "Training model 11/18 with {'regParam': 0.3, 'rank': 10, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.711216262481\n",
      "Test Root-mean-square error = 0.947984498837\n",
      "Training model 12/18 with {'regParam': 0.1, 'rank': 10, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.385681014143\n",
      "Test Root-mean-square error = 1.00591065713\n",
      "Training model 13/18 with {'regParam': 1.0, 'rank': 20, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.912367342062\n",
      "Test Root-mean-square error = 0.955527566505\n",
      "Training model 14/18 with {'regParam': 0.3, 'rank': 20, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.712750683571\n",
      "Test Root-mean-square error = 0.943963181155\n",
      "Training model 15/18 with {'regParam': 0.1, 'rank': 20, 'maxIter': 5}\n",
      "Train Root-mean-square error = 0.33140468527\n",
      "Test Root-mean-square error = 0.972839603252\n",
      "Training model 16/18 with {'regParam': 1.0, 'rank': 20, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.912410788588\n",
      "Test Root-mean-square error = 0.955527691858\n",
      "Training model 17/18 with {'regParam': 0.3, 'rank': 20, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.703049414435\n",
      "Test Root-mean-square error = 0.945475782233\n",
      "Training model 18/18 with {'regParam': 0.1, 'rank': 20, 'maxIter': 10}\n",
      "Train Root-mean-square error = 0.31912429297\n",
      "Test Root-mean-square error = 0.986608227246\n",
      "Best model parameters: {'regParam': 0.3, 'rank': 10, 'maxIter': 5}\n",
      "Saving best model to ./dataset/Edinburgh_als_model_regParm0.3_rank10_maxIter5\n",
      "Finished!\n"
     ]
    }
   ],
   "source": [
    "parms = {'min_per_user': 4,\n",
    "         'scaler': {'mean': True, 'stdev': False},\n",
    "         'als': {'rank': [5, 10, 20],\n",
    "                 'maxIter': [5, 10],\n",
    "                 'regParam': [1.0, 0.3, 0.1]}}\n",
    "\n",
    "rec.fit('Edinburgh', 'Restaurants', parms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pred = rec.best_model.transform(rec._test)\n",
    "pred_df = pred.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x7f8e7ace63d0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dvgodoy/Programs/anaconda/lib/python2.7/site-packages/matplotlib/collections.py:590: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  if self._edgecolors == str('face'):\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAGICAYAAABbQ3cmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngBAREV8KECIi4ksBQkREfP1/QE98x1MzxbMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8e7ace66d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lmplot(x='stars', y='prediction', data=pred_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TqbSA-djveQQOJ3n1o-GaQ\n"
     ]
    }
   ],
   "source": [
    "user_id = np.random.choice(rec.all_users)\n",
    "print(user_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{u'address': u'28 Easter Rd',\n",
       "  u'categories': [u'Fast Food', u'Chinese', u'Restaurants'],\n",
       "  u'name': u'Ricebox Take Away Food Shops',\n",
       "  u'stars': 2.0},\n",
       " {u'address': u'8 Gloucester Street',\n",
       "  u'categories': [u'Restaurants', u'Thai'],\n",
       "  u'name': u'Songkran',\n",
       "  u'stars': 4.0},\n",
       " {u'address': u'National Gallery Complex, The Mound',\n",
       "  u'categories': [u'Breakfast & Brunch',\n",
       "   u'Restaurants',\n",
       "   u'Tea Rooms',\n",
       "   u'Modern European',\n",
       "   u'British',\n",
       "   u'Coffee & Tea',\n",
       "   u'Food'],\n",
       "  u'name': u'Victor & Carina Contini The Scottish Cafe and Restaurant',\n",
       "  u'stars': 4.0}]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "json.loads(rec.recommend(user_id, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{u'address': u'9 Dundee Terrace',\n",
       "  u'categories': [u'Indian', u'Restaurants'],\n",
       "  u'name': u'Guru Balti Restaurant',\n",
       "  u'stars': 4.5},\n",
       " {u'address': u'325 Leith Walk',\n",
       "  u'categories': [u'Restaurants', u'Italian', u'Pizza'],\n",
       "  u'name': u'La Favorita',\n",
       "  u'stars': 4.5},\n",
       " {u'address': u'50 Potterow',\n",
       "  u'categories': [u'Food',\n",
       "   u'Imported Food',\n",
       "   u'Restaurants',\n",
       "   u'Pakistani',\n",
       "   u'Specialty Food',\n",
       "   u'Ethnic Food'],\n",
       "  u'name': u'The Original Mosque Kitchen',\n",
       "  u'stars': 4.0}]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "json.loads(rec.list_ratings(user_id, 3))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}