part-3-implicit-feedback-recommender.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3: Building a Recommender System with Implicit Feedback\n",
    "\n",
    "In this tutorial, we will build an implicit feedback recommender system using the [implicit](https://github.com/benfred/implicit) package.\n",
    "\n",
    "What is implicit feedback, exactly? Let's revisit collaborative filtering. In [Part 1](https://github.com/topspinj/recommender-tutorial/blob/master/part-1-item-item-recommender.ipynb), we learned that [collaborative filtering](https://en.wikipedia.org/wiki/Collaborative_filtering) is based on the assumption that `similar users like similar things`. The user-item matrix, or \"utility matrix\", is the foundation of collaborative filtering. In the utility matrix, rows represent users and columns represent items. \n",
    "\n",
    "<img src=\"images/utility-matrix.png\" width=\"30%\"/>\n",
    "\n",
    "The cells of the matrix are populated by a given user's degree of preference towards an item, which can come in the form of:\n",
    "\n",
    "1. **explicit feedback:** direct feedback towards an item (e.g., movie ratings which we explored in [Part 1](https://github.com/topspinj/recommender-tutorial/blob/master/part-1-item-item-recommender.ipynb))\n",
    "2. **implicit feedback:** indirect behaviour towards an item (e.g., purchase history, browsing history, search behaviour)\n",
    "\n",
    "Implicit feedback makes assumptions about a user's preference based on their actions towards items. Let's take Netflix for example. If you binge-watch a show and blaze through all seasons in a week, there's a high chance that you like that show. However, if you start watching a series and stop halfway through the first episode, there's suspicion to believe that you probably don't like that show. \n",
    "\n",
    "<img src=\"images/netflix_implicit_feedback.png\" width=\"50%\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Import Dependencies\n",
    "\n",
    "We'll be using the following packages to build our implicit feedback recommender system:\n",
    "\n",
    "- [numpy](https://numpy.org/)\n",
    "- [pandas](https://pandas.pydata.org/)\n",
    "- [implicit](https://github.com/benfred/implicit)\n",
    "- scipy (specifically, the [csr_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html) class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.sparse import csr_matrix\n",
    "\n",
    "import implicit\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Load the Data\n",
    "\n",
    "Since we're already familiar with MovieLens from Part 1 and 2 of this tutorial series, we'll continue using this dataset. You can access the MovieLens dataset that we'll be working with via this zip file url [here](https://grouplens.org/datasets/movielens/), or directly download [here](http://files.grouplens.org/datasets/movielens/ml-latest-small.zip). We're working with data in `ml-latest-small.zip` and will need to add the following files to our local directory: \n",
    "- ratings.csv\n",
    "- movies.csv\n",
    "\n",
    "Alternatively, you can access the data here: \n",
    "- https://s3-us-west-2.amazonaws.com/recommender-tutorial/movies.csv\n",
    "- https://s3-us-west-2.amazonaws.com/recommender-tutorial/ratings.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratings = pd.read_csv(\"https://s3-us-west-2.amazonaws.com/recommender-tutorial/ratings.csv\")\n",
    "movies = pd.read_csv(\"https://s3-us-west-2.amazonaws.com/recommender-tutorial/movies.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964982703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964981247</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964982224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>47</td>\n",
       "      <td>5.0</td>\n",
       "      <td>964983815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>50</td>\n",
       "      <td>5.0</td>\n",
       "      <td>964982931</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating  timestamp\n",
       "0       1        1     4.0  964982703\n",
       "1       1        3     4.0  964981247\n",
       "2       1        6     4.0  964982224\n",
       "3       1       47     5.0  964983815\n",
       "4       1       50     5.0  964982931"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratings.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this implicit feedback tutorial, we'll treat movie ratings as the number of times that a user watched a movie. For example, if Jane (a user in our database) gave `Batman` a rating of 1 and `Legally Blonde` a rating of 5, we'll assume that Jane watched Batman one time and Legally Blonde five times. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Transforming the Data\n",
    "\n",
    "Similar to [Part 1](https://github.com/topspinj/recommender-tutorial/blob/master/part-1-item-item-recommender.ipynb), we need to transform the `ratings` dataframe into a user-item matrix where rows represent users and columns represent movies. The cells of this matrix will be populated with implicit feedback: in this case, the number of times a user watched a movie. \n",
    "\n",
    "The `create_X()` function outputs a sparse matrix **X** with four mapper dictionaries:\n",
    "- **user_mapper:** maps user id to user index\n",
    "- **movie_mapper:** maps movie id to movie index\n",
    "- **user_inv_mapper:** maps user index to user id\n",
    "- **movie_inv_mapper:** maps movie index to movie id\n",
    "\n",
    "We need these dictionaries because they map which row and column of the utility matrix corresponds to which user ID and movie ID, respectively.\n",
    "\n",
    "The **X** (user-item) matrix is a [scipy.sparse.csr_matrix](scipylinkhere) which stores the data sparsely.\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"images/user-movie-matrix.png\" width=\"500px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_X(df):\n",
    "    \"\"\"\n",
    "    Generates a sparse matrix from ratings dataframe.\n",
    "    \n",
    "    Args:\n",
    "        df: pandas dataframe\n",
    "    \n",
    "    Returns:\n",
    "        X: sparse matrix\n",
    "        user_mapper: dict that maps user id's to user indices\n",
    "        user_inv_mapper: dict that maps user indices to user id's\n",
    "        movie_mapper: dict that maps movie id's to movie indices\n",
    "        movie_inv_mapper: dict that maps movie indices to movie id's\n",
    "    \"\"\"\n",
    "    N = df['userId'].nunique()\n",
    "    M = df['movieId'].nunique()\n",
    "\n",
    "    user_mapper = dict(zip(np.unique(df[\"userId\"]), list(range(N))))\n",
    "    movie_mapper = dict(zip(np.unique(df[\"movieId\"]), list(range(M))))\n",
    "    \n",
    "    user_inv_mapper = dict(zip(list(range(N)), np.unique(df[\"userId\"])))\n",
    "    movie_inv_mapper = dict(zip(list(range(M)), np.unique(df[\"movieId\"])))\n",
    "    \n",
    "    user_index = [user_mapper[i] for i in df['userId']]\n",
    "    movie_index = [movie_mapper[i] for i in df['movieId']]\n",
    "\n",
    "    X = csr_matrix((df[\"rating\"], (movie_index, user_index)), shape=(M, N))\n",
    "    \n",
    "    return X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper = create_X(ratings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Movie Title Mappers\n",
    "\n",
    "We need to interpret a movie title from its index in the user-item matrix and vice versa. Let's create 2 helper functions that make this interpretation easy:\n",
    "\n",
    "- `get_movie_index()` - converts a movie title to movie index\n",
    "    - Note that this function uses [fuzzywuzzy](https://github.com/seatgeek/fuzzywuzzy)'s string matching to get the approximate movie title match based on the string that gets passed in. This means that you don't need to know the exact spelling and formatting of the title to get the corresponding movie index.\n",
    "- `get_movie_title()` - converts a movie index to movie title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fuzzywuzzy import process\n",
    "\n",
    "def movie_finder(title):\n",
    "    all_titles = movies['title'].tolist()\n",
    "    closest_match = process.extractOne(title,all_titles)\n",
    "    return closest_match[0]\n",
    "\n",
    "movie_title_mapper = dict(zip(movies['title'], movies['movieId']))\n",
    "movie_title_inv_mapper = dict(zip(movies['movieId'], movies['title']))\n",
    "\n",
    "def get_movie_index(title):\n",
    "    fuzzy_title = movie_finder(title)\n",
    "    movie_id = movie_title_mapper[fuzzy_title]\n",
    "    movie_idx = movie_mapper[movie_id]\n",
    "    return movie_idx\n",
    "\n",
    "def get_movie_title(movie_idx): \n",
    "    movie_id = movie_inv_mapper[movie_idx]\n",
    "    title = movie_title_inv_mapper[movie_id]\n",
    "    return title "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's time to test it out! Let's get the movie index of `Legally Blonde`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3282"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_movie_index('Legally Blonde')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's pass this index value into `get_movie_title()`. We're expecting Legally Blonde to get returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Legally Blonde (2001)'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_movie_title(3282)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! These helper functions will be useful when we want to interpret our recommender results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Building Our Implicit Feedback Recommender Model\n",
    "\n",
    "\n",
    "We've transformed and prepared our data so that we can start creating our recommender model.\n",
    "\n",
    "The [implicit](https://github.com/benfred/implicit) package is built around a linear algebra technique called [matrix factorization](https://en.wikipedia.org/wiki/Matrix_factorization_(recommender_systems)), which can help us discover latent features underlying the interactions between users and movies. These latent features give a more compact representation of user tastes and item descriptions. Matrix factorization is particularly useful for very sparse data and can enhance the quality of recommendations. The algorithm works by factorizing the original user-item matrix into two factor matrices:\n",
    "\n",
    "- user-factor matrix (n_users, k)\n",
    "- item-factor matrix (k, n_items)\n",
    "\n",
    "We are reducing the dimensions of our original matrix into \"taste\" dimensions. We cannot interpret what each latent feature $k$ represents. However, we could imagine that one latent feature may represent users who like romantic comedies from the 1990s, while another latent feature may represent movies which are independent foreign language films.\n",
    "\n",
    "$$X_{mn} \\approx P_{mk} \\times Q_{nk}^T = \\hat{X}$$\n",
    "\n",
    "<img src=\"images/matrix-factorization.png\" width=\"60%\"/>\n",
    "\n",
    "In traditional matrix factorization, such as SVD, we would attempt to solve the factorization at once which can be very computationally expensive. As a more practical alternative, we can use a technique called `Alternating Least Squares (ALS)` instead. With ALS, we solve for one factor matrix at a time:\n",
    "\n",
    "- Step 1: hold user-factor matrix fixed and solve for the item-factor matrix\n",
    "- Step 2: hold item-factor matrix fixed and solve for the user-item matrix\n",
    "\n",
    "We alternate between Step 1 and 2 above, until the dot product of the item-factor matrix and user-item matrix is approximately equal to the original X (user-item) matrix. This approach is less computationally expensive and can be run in parallel.\n",
    "\n",
    "The [implicit](https://github.com/benfred/implicit) package implements matrix factorization using Alternating Least Squares (see docs [here](https://implicit.readthedocs.io/en/latest/als.html)). Let's initiate the model using the `AlternatingLeastSquares` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:OpenBLAS detected. Its highly recommend to set the environment variable 'export OPENBLAS_NUM_THREADS=1' to disable its internal multithreading\n"
     ]
    }
   ],
   "source": [
    "model = implicit.als.AlternatingLeastSquares(factors=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model comes with a couple of hyperparameters that can be tuned to generate optimal results:\n",
    "\n",
    "- factors ($k$): number of latent factors,\n",
    "- regularization ($\\lambda$): prevents the model from overfitting during training\n",
    "\n",
    "In this tutorial, we'll set $k = 50$ and $\\lambda = 0.01$ (the default). In a real-world scenario, I highly recommend tuning these hyperparameters before generating recommendations to generate optimal results.\n",
    "\n",
    "The next step is to fit our model with our user-item matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15.0/15 [00:06<00:00,  2.30it/s]\n"
     ]
    }
   ],
   "source": [
    "model.fit(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's test out the model's recommendations. We can use the model's `similar_items()` method which returns the most relevant movies of a given movie. We can use our helpful `get_movie_index()` function to get the movie index of the movie that we're interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(314, 0.9999999),\n",
       " (277, 0.87162775),\n",
       " (510, 0.8275397),\n",
       " (257, 0.82705915),\n",
       " (97, 0.7511661),\n",
       " (461, 0.7223397),\n",
       " (418, 0.6889433),\n",
       " (1938, 0.6659612),\n",
       " (123, 0.6441393),\n",
       " (43, 0.61916924)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_of_interest = 'forrest gump'\n",
    "\n",
    "movie_index = get_movie_index(movie_of_interest)\n",
    "related = model.similar_items(movie_index)\n",
    "related"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of `similar_items()` is not user-friendly. We'll need to use our `get_movie_title()` function to interpret what our results are. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Forrest Gump (1994)...\n",
      "Shawshank Redemption, The (1994)\n",
      "Silence of the Lambs, The (1991)\n",
      "Pulp Fiction (1994)\n",
      "Braveheart (1995)\n",
      "Schindler's List (1993)\n",
      "Jurassic Park (1993)\n",
      "Matrix, The (1999)\n",
      "Apollo 13 (1995)\n",
      "Seven (a.k.a. Se7en) (1995)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Because you watched {movie_finder(movie_of_interest)}...\")\n",
    "for r in related:\n",
    "    recommended_title = get_movie_title(r[0])\n",
    "    if recommended_title != movie_finder(movie_of_interest):\n",
    "        print(recommended_title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we treat user ratings as implicit feedback, the results look pretty good! You can test out other movies by changing the `movie_of_interest` variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Generating User-Item Recommendations\n",
    "\n",
    "A cool feature of [implicit](https://github.com/benfred/implicit) is that you can pull personalized recommendations for a given user. Let's test it out on a user in our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_id = 95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of movies rated by user 95: 168\n"
     ]
    }
   ],
   "source": [
    "user_ratings = ratings[ratings['userId']==user_id].merge(movies[['movieId', 'title']])\n",
    "user_ratings = user_ratings.sort_values('rating', ascending=False)\n",
    "print(f\"Number of movies rated by user {user_id}: {user_ratings['movieId'].nunique()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "User 95 watched 168 movies. Their highest rated movies are below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>95</td>\n",
       "      <td>1089</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1048382826</td>\n",
       "      <td>Reservoir Dogs (1992)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>95</td>\n",
       "      <td>1221</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1043340018</td>\n",
       "      <td>Godfather: Part II, The (1974)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>95</td>\n",
       "      <td>3019</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1043340112</td>\n",
       "      <td>Drugstore Cowboy (1989)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>95</td>\n",
       "      <td>1175</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1105400882</td>\n",
       "      <td>Delicatessen (1991)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>95</td>\n",
       "      <td>1196</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1043340018</td>\n",
       "      <td>Star Wars: Episode V - The Empire Strikes Back...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    userId  movieId  rating   timestamp  \\\n",
       "24      95     1089     5.0  1048382826   \n",
       "34      95     1221     5.0  1043340018   \n",
       "83      95     3019     5.0  1043340112   \n",
       "26      95     1175     5.0  1105400882   \n",
       "27      95     1196     5.0  1043340018   \n",
       "\n",
       "                                                title  \n",
       "24                              Reservoir Dogs (1992)  \n",
       "34                     Godfather: Part II, The (1974)  \n",
       "83                            Drugstore Cowboy (1989)  \n",
       "26                                Delicatessen (1991)  \n",
       "27  Star Wars: Episode V - The Empire Strikes Back...  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_ratings = ratings[ratings['userId']==user_id].merge(movies[['movieId', 'title']])\n",
    "user_ratings = user_ratings.sort_values('rating', ascending=False)\n",
    "top_5 = user_ratings.head()\n",
    "top_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Their lowest rated movies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>93</th>\n",
       "      <td>95</td>\n",
       "      <td>3690</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1043339908</td>\n",
       "      <td>Porky's Revenge (1985)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>122</th>\n",
       "      <td>95</td>\n",
       "      <td>5283</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1043339957</td>\n",
       "      <td>National Lampoon's Van Wilder (2002)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>95</td>\n",
       "      <td>4015</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1043339957</td>\n",
       "      <td>Dude, Where's My Car? (2000)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>164</th>\n",
       "      <td>95</td>\n",
       "      <td>7373</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1105401093</td>\n",
       "      <td>Hellboy (2004)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>109</th>\n",
       "      <td>95</td>\n",
       "      <td>4732</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1043339283</td>\n",
       "      <td>Bubble Boy (2001)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     userId  movieId  rating   timestamp                                 title\n",
       "93       95     3690     2.0  1043339908                Porky's Revenge (1985)\n",
       "122      95     5283     2.0  1043339957  National Lampoon's Van Wilder (2002)\n",
       "100      95     4015     2.0  1043339957          Dude, Where's My Car? (2000)\n",
       "164      95     7373     1.0  1105401093                        Hellboy (2004)\n",
       "109      95     4732     1.0  1043339283                     Bubble Boy (2001)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bottom_5 = user_ratings[user_ratings['rating']<3].tail()\n",
    "bottom_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on their preferences above, we can get a sense that user 95 likes action and crime movies from the early 1990's over light-hearted American comedies from the early 2000's. Let's see what recommendations our model will generate for user 95.\n",
    "\n",
    "We'll use the `recommend()` method, which takes in the user index of interest and transposed user-item matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(855, 1.127779),\n",
       " (1043, 0.98673713),\n",
       " (1210, 0.9256185),\n",
       " (3633, 0.90900886),\n",
       " (1978, 0.8929481),\n",
       " (4155, 0.84075284),\n",
       " (2979, 0.82858247),\n",
       " (3609, 0.78015),\n",
       " (4791, 0.7672245),\n",
       " (4010, 0.7530525)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_t = X.T.tocsr()\n",
    "\n",
    "user_idx = user_mapper[user_id]\n",
    "recommendations = model.recommend(user_idx, X_t)\n",
    "recommendations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can't interpret the results as is since movies are represented by their index. We'll have to loop over the list of recommendations and get the movie title for each movie index. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abyss, The (1989)\n",
      "Star Trek: First Contact (1996)\n",
      "Hunt for Red October, The (1990)\n",
      "Lord of the Rings: The Fellowship of the Ring, The (2001)\n",
      "Star Wars: Episode I - The Phantom Menace (1999)\n",
      "Chicago (2002)\n",
      "Crouching Tiger, Hidden Dragon (Wo hu cang long) (2000)\n",
      "Ocean's Eleven (2001)\n",
      "Lord of the Rings: The Return of the King, The (2003)\n",
      "Punch-Drunk Love (2002)\n"
     ]
    }
   ],
   "source": [
    "for r in recommendations:\n",
    "    recommended_title = get_movie_title(r[0])\n",
    "    print(recommended_title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "User 95's recommendations consist of action, crime, and thrillers. None of their recommendations are comedies. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}