tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building a MovieLens Recommender System\n",
    "\n",
    "<img src=\"images/movielens.png\" width='25%' align='right'/>\n",
    "\n",
    "Want to know how Spotify, Amazon, and Netflix generate recommendations for their users? In this tutorial, we will explore two types of recommender systems: 1) collaborative filtering, and 2) content-based filtering. We will build our own recommendation system using the [MovieLens](https://movielens.org/home) dataset in Python.\n",
    "\n",
    "### What is MovieLens?\n",
    "\n",
    "MovieLens is a recommender system that was developed by GroupLens, a computer science research lab at the University of Minnesota. It recommends movies to its users based on their movie ratings. It is also a dataset that is widely used in research and teaching contexts. \n",
    "\n",
    "### Tutorial Outline\n",
    "\n",
    "This tutorial is broken down into 7 steps:\n",
    "\n",
    "1. Importing the dependnecies\n",
    "1. Loading the data\n",
    "1. Exploratory data analysis \n",
    "1. Data pre-processing\n",
    "1. Collaborative filtering using k-Nearest Neighbors\n",
    "1. Handling the cold-start problem with content-based filtering \n",
    "1. Dimensionality reduction with matrix factorization\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Import Dependencies\n",
    "\n",
    "We are using [pandas.DataFrame](http://pandas.pydata.org/pandas-docs/version/0.19/generated/pandas.DataFrame.html) to represent our data. We will visualize our data with [matplotlib](https://matplotlib.org/) and [seaborn](https://seaborn.pydata.org/).\n",
    "\n",
    "**What is a DataFrame?**\n",
    "\n",
    "- a two-dimensional Pandas data structure\n",
    "- columns represent features, rows represent items\n",
    "- analogous to an Excel spreadsheet or SQL table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Load Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's download a small version of the MovieLens dataset. You can download the data [here](https://grouplens.org/datasets/movielens/). \n",
    "\n",
    "<img src=\"images/download_movielens.png\" width='40%'/>\n",
    "\n",
    "\n",
    "We're working with data in `ml-latest-small.zip` and will need to add the following files to our repository:\n",
    "\n",
    "- ratings.csv\n",
    "- movies.csv\n",
    "\n",
    "Alternatively, you can access the data here:\n",
    "\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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "movies = pd.read_csv('https://s3-us-west-2.amazonaws.com/recommender-tutorial/movies.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of ratings: 100836\n",
      "Number of unique movieId's: 9724\n",
      "Number of unique users: 610\n",
      "Average number of ratings per user: 165.3\n",
      "Average number of ratings per movie: 10.37\n"
     ]
    }
   ],
   "source": [
    "n_ratings = len(ratings)\n",
    "n_movies = ratings['movieId'].nunique()\n",
    "n_users = ratings['userId'].nunique()\n",
    "\n",
    "print(f\"Number of ratings: {n_ratings}\")\n",
    "print(f\"Number of unique movieId's: {n_movies}\")\n",
    "print(f\"Number of unique users: {n_users}\")\n",
    "print(f\"Average number of ratings per user: {round(n_ratings/n_users, 2)}\")\n",
    "print(f\"Average number of ratings per movie: {round(n_ratings/n_movies, 2)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is the distribution of movie ratings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.countplot(x=\"rating\", data=ratings, palette=\"viridis\")\n",
    "plt.title(\"Distribution of movie ratings\", fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean global rating: 3.5.\n",
      "Mean rating per user: 3.66.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Mean global rating: {round(ratings['rating'].mean(),2)}.\")\n",
    "\n",
    "mean_ratings = ratings.groupby('userId')['rating'].mean()\n",
    "print(f\"Mean rating per user: {round(mean_ratings.mean(),2)}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Which movies are most frequently rated?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Forrest Gump (1994)                          329\n",
       "Shawshank Redemption, The (1994)             317\n",
       "Pulp Fiction (1994)                          307\n",
       "Silence of the Lambs, The (1991)             279\n",
       "Matrix, The (1999)                           278\n",
       "Star Wars: Episode IV - A New Hope (1977)    251\n",
       "Jurassic Park (1993)                         238\n",
       "Braveheart (1995)                            237\n",
       "Terminator 2: Judgment Day (1991)            224\n",
       "Schindler's List (1993)                      220\n",
       "Name: title, dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_ratings = ratings.merge(movies, on='movieId')\n",
    "movie_ratings['title'].value_counts()[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Forrest Gump`, `Shawshank Redemption`, and `Pulp Fiction` have the most ratings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are the lowest and highest rated movies? \n",
    "\n",
    "Which movie has the lowest and highest average rating?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2689</th>\n",
       "      <td>3604</td>\n",
       "      <td>Gypsy (1962)</td>\n",
       "      <td>Musical</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      movieId         title   genres\n",
       "2689     3604  Gypsy (1962)  Musical"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_ratings = ratings.groupby('movieId')[['rating']].mean()\n",
    "lowest_rated = mean_ratings['rating'].idxmin()\n",
    "movies[movies['movieId']==lowest_rated]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Gypsy` has the lowest average rating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>53</td>\n",
       "      <td>Lamerica (1994)</td>\n",
       "      <td>Adventure|Drama</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    movieId            title           genres\n",
       "48       53  Lamerica (1994)  Adventure|Drama"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "highest_rated = mean_ratings['rating'].idxmax()\n",
    "movies[movies['movieId'] == highest_rated]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many ratings does `Lamerica` have?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>13368</th>\n",
       "      <td>85</td>\n",
       "      <td>53</td>\n",
       "      <td>5.0</td>\n",
       "      <td>889468268</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96115</th>\n",
       "      <td>603</td>\n",
       "      <td>53</td>\n",
       "      <td>5.0</td>\n",
       "      <td>963180003</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       userId  movieId  rating  timestamp\n",
       "13368      85       53     5.0  889468268\n",
       "96115     603       53     5.0  963180003"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratings[ratings['movieId']==highest_rated]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/lamerica.png\" align='left' width='7%'/>\n",
    "\n",
    "`Lamerica` may be the \"highest\" rated movie, but it only has 2 ratings. A better approach for evaluating movie popularity is to do look at the [Bayesian average](https://en.wikipedia.org/wiki/Bayesian_average)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bayesian Average\n",
    "\n",
    "[Bayesian Average](https://en.wikipedia.org/wiki/Bayesian_average) is defined as:\n",
    "\n",
    "$r_{i} = \\frac{C \\times m + \\Sigma{\\text{reviews}}}{C+N}$\n",
    "\n",
    "where $C$ represents our confidence, $m$ represents our prior, and $N$ is the total number of reviews for movie $i$. In this case, our prior $m$ will be the average mean rating across all movies. By defintion, C represents \"the typical data set size\". Let's make $C$ be the average number of ratings for a given movie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>movieId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>215</td>\n",
       "      <td>3.920930</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>110</td>\n",
       "      <td>3.431818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>52</td>\n",
       "      <td>3.259615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7</td>\n",
       "      <td>2.357143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>49</td>\n",
       "      <td>3.071429</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         count      mean\n",
       "movieId                 \n",
       "1          215  3.920930\n",
       "2          110  3.431818\n",
       "3           52  3.259615\n",
       "4            7  2.357143\n",
       "5           49  3.071429"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_stats = ratings.groupby('movieId')['rating'].agg(['count', 'mean'])\n",
    "movie_stats.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of ratings for a given movie: 10.37\n",
      "Average rating for a given movie: 3.26\n"
     ]
    }
   ],
   "source": [
    "C = movie_stats['count'].mean()\n",
    "m = movie_stats['mean'].mean()\n",
    "\n",
    "print(f\"Average number of ratings for a given movie: {C:.2f}\")\n",
    "print(f\"Average rating for a given movie: {m:.2f}\")\n",
    "\n",
    "def bayesian_avg(ratings):\n",
    "    bayesian_avg = (C*m+ratings.sum())/(C+ratings.count())\n",
    "    return round(bayesian_avg, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test our `bayesian_avg` function out on `Lamerica`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.543"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lamerica = pd.Series([5, 5])\n",
    "bayesian_avg(lamerica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Lamerica`'s average Bayesian rating is 3.5. \n",
    "\n",
    "Let's now apply `bayesian_avg` to all movies in our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "bayesian_avg_ratings = ratings.groupby('movieId')['rating'].agg(bayesian_avg).reset_index()\n",
    "bayesian_avg_ratings.columns = ['movieId', 'bayesian_avg']\n",
    "movie_stats = movie_stats.merge(bayesian_avg_ratings, on='movieId')"
   ]
  },
  {
   "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>movieId</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>bayesian_avg</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>277</th>\n",
       "      <td>318</td>\n",
       "      <td>317</td>\n",
       "      <td>4.429022</td>\n",
       "      <td>4.392</td>\n",
       "      <td>Shawshank Redemption, The (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>659</th>\n",
       "      <td>858</td>\n",
       "      <td>192</td>\n",
       "      <td>4.289062</td>\n",
       "      <td>4.236</td>\n",
       "      <td>Godfather, The (1972)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2224</th>\n",
       "      <td>2959</td>\n",
       "      <td>218</td>\n",
       "      <td>4.272936</td>\n",
       "      <td>4.227</td>\n",
       "      <td>Fight Club (1999)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>224</th>\n",
       "      <td>260</td>\n",
       "      <td>251</td>\n",
       "      <td>4.231076</td>\n",
       "      <td>4.193</td>\n",
       "      <td>Star Wars: Episode IV - A New Hope (1977)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>50</td>\n",
       "      <td>204</td>\n",
       "      <td>4.237745</td>\n",
       "      <td>4.191</td>\n",
       "      <td>Usual Suspects, The (1995)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      movieId  count      mean  bayesian_avg  \\\n",
       "277       318    317  4.429022         4.392   \n",
       "659       858    192  4.289062         4.236   \n",
       "2224     2959    218  4.272936         4.227   \n",
       "224       260    251  4.231076         4.193   \n",
       "46         50    204  4.237745         4.191   \n",
       "\n",
       "                                          title  \n",
       "277            Shawshank Redemption, The (1994)  \n",
       "659                       Godfather, The (1972)  \n",
       "2224                          Fight Club (1999)  \n",
       "224   Star Wars: Episode IV - A New Hope (1977)  \n",
       "46                   Usual Suspects, The (1995)  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_stats = movie_stats.merge(movies[['movieId', 'title']])\n",
    "movie_stats.sort_values('bayesian_avg', ascending=False).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the Bayesian average, we see that `Shawshank Redemption`, `The Godfather`, and `The Usual Suspects` are the most highly rated movies. This result makes much more sense since these movies are critically acclaimed films."
   ]
  },
  {
   "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>movieId</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>bayesian_avg</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1172</th>\n",
       "      <td>1556</td>\n",
       "      <td>19</td>\n",
       "      <td>1.605263</td>\n",
       "      <td>2.190</td>\n",
       "      <td>Speed 2: Cruise Control (1997)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2679</th>\n",
       "      <td>3593</td>\n",
       "      <td>19</td>\n",
       "      <td>1.657895</td>\n",
       "      <td>2.224</td>\n",
       "      <td>Battlefield Earth (2000)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1372</th>\n",
       "      <td>1882</td>\n",
       "      <td>33</td>\n",
       "      <td>1.954545</td>\n",
       "      <td>2.267</td>\n",
       "      <td>Godzilla (1998)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1144</th>\n",
       "      <td>1499</td>\n",
       "      <td>27</td>\n",
       "      <td>1.925926</td>\n",
       "      <td>2.297</td>\n",
       "      <td>Anaconda (1997)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1988</th>\n",
       "      <td>2643</td>\n",
       "      <td>16</td>\n",
       "      <td>1.687500</td>\n",
       "      <td>2.307</td>\n",
       "      <td>Superman IV: The Quest for Peace (1987)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      movieId  count      mean  bayesian_avg  \\\n",
       "1172     1556     19  1.605263         2.190   \n",
       "2679     3593     19  1.657895         2.224   \n",
       "1372     1882     33  1.954545         2.267   \n",
       "1144     1499     27  1.925926         2.297   \n",
       "1988     2643     16  1.687500         2.307   \n",
       "\n",
       "                                        title  \n",
       "1172           Speed 2: Cruise Control (1997)  \n",
       "2679                 Battlefield Earth (2000)  \n",
       "1372                          Godzilla (1998)  \n",
       "1144                          Anaconda (1997)  \n",
       "1988  Superman IV: The Quest for Peace (1987)  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_stats.sort_values('bayesian_avg', ascending=True).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With Bayesian averaging, it looks like `Speed 2: Cruise Control`, `Battlefield Earth`, and `Godzilla` are the worst rated movies. `Gypsy` isn't so bad after all."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Glimpse at Movie Genres\n",
    "\n",
    "The movies dataset needs to be cleaned in two ways:\n",
    "\n",
    "- `genres` is expressed as a string with a pipe `|` separating each genre. We will manipulate this string into a list, which will make it much easier to analyze.\n",
    "- `title` currently has (year) appended at the end. We will extract year from each title string and create a new column for it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>[Adventure, Animation, Children, Comedy, Fantasy]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>[Adventure, Children, Fantasy]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>[Comedy, Romance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>[Comedy, Drama, Romance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>[Comedy]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId                               title  \\\n",
       "0        1                    Toy Story (1995)   \n",
       "1        2                      Jumanji (1995)   \n",
       "2        3             Grumpier Old Men (1995)   \n",
       "3        4            Waiting to Exhale (1995)   \n",
       "4        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                              genres  \n",
       "0  [Adventure, Animation, Children, Comedy, Fantasy]  \n",
       "1                     [Adventure, Children, Fantasy]  \n",
       "2                                  [Comedy, Romance]  \n",
       "3                           [Comedy, Drama, Romance]  \n",
       "4                                           [Comedy]  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies['genres'] = movies['genres'].apply(lambda x: x.split(\"|\"))\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How many movie genres are there?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 20 genres.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Counter({'Adventure': 1263,\n",
       "         'Animation': 611,\n",
       "         'Children': 664,\n",
       "         'Comedy': 3756,\n",
       "         'Fantasy': 779,\n",
       "         'Romance': 1596,\n",
       "         'Drama': 4361,\n",
       "         'Action': 1828,\n",
       "         'Crime': 1199,\n",
       "         'Thriller': 1894,\n",
       "         'Horror': 978,\n",
       "         'Mystery': 573,\n",
       "         'Sci-Fi': 980,\n",
       "         'War': 382,\n",
       "         'Musical': 334,\n",
       "         'Documentary': 440,\n",
       "         'IMAX': 158,\n",
       "         'Western': 167,\n",
       "         'Film-Noir': 87,\n",
       "         '(no genres listed)': 34})"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "genre_frequency = Counter(g for genres in movies['genres'] for g in genres)\n",
    "\n",
    "print(f\"There are {len(genre_frequency)} genres.\")\n",
    "\n",
    "genre_frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5 most common genres: \n",
      " [('Drama', 4361), ('Comedy', 3756), ('Thriller', 1894), ('Action', 1828), ('Romance', 1596)]\n"
     ]
    }
   ],
   "source": [
    "print(\"The 5 most common genres: \\n\", genre_frequency.most_common(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The top 5 genres are: `Drama`, `Comedy`, `Thriller`, `Action` and `Romance`.\n",
    "\n",
    "Let's also visualize genres popularity with a barplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "genre_frequency_df = pd.DataFrame([genre_frequency]).T.reset_index()\n",
    "genre_frequency_df.columns = ['genre', 'count']\n",
    "\n",
    "sns.barplot(x='genre', y='count', data=genre_frequency_df.sort_values(by='count', ascending=False))\n",
    "plt.xticks(rotation=90)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Data Pre-processing\n",
    "\n",
    "We are going to use a technique called colaborative filtering to generate recommendations for users. This technique is based on the premise that similar people like similar things. \n",
    "\n",
    "The first step is to transform our data into a user-item matrix, also known as a \"utility\" matrix. In this matrix, rows represent users and columns represent movies. The beauty of collaborative filtering is that it doesn't require any information about the users or the movies user to generate recommendations.\n",
    "\n",
    "<img src=\"images/user_movie_matrix.png\" width=50%/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `create_X()` function outputs a sparse matrix $X$ with four mapper dictionaries:\n",
    "\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/column of the utility matrix corresponds to which user/movie id.\n",
    "\n",
    "Our $X$ (user-item) matrix is a [scipy.sparse.csr_matrix](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html) which stores the data sparsely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import csr_matrix\n",
    "\n",
    "def create_X(df):\n",
    "    \"\"\"\n",
    "    Generates a sparse matrix from ratings dataframe.\n",
    "    \n",
    "    Args:\n",
    "        df: pandas dataframe containing 3 columns (userId, movieId, rating)\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",
    "    M = df['userId'].nunique()\n",
    "    N = df['movieId'].nunique()\n",
    "\n",
    "    user_mapper = dict(zip(np.unique(df[\"userId\"]), list(range(M))))\n",
    "    movie_mapper = dict(zip(np.unique(df[\"movieId\"]), list(range(N))))\n",
    "    \n",
    "    user_inv_mapper = dict(zip(list(range(M)), np.unique(df[\"userId\"])))\n",
    "    movie_inv_mapper = dict(zip(list(range(N)), np.unique(df[\"movieId\"])))\n",
    "    \n",
    "    user_index = [user_mapper[i] for i in df['userId']]\n",
    "    item_index = [movie_mapper[i] for i in df['movieId']]\n",
    "\n",
    "    X = csr_matrix((df[\"rating\"], (user_index,item_index)), shape=(M,N))\n",
    "    \n",
    "    return X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper\n",
    "\n",
    "X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper = create_X(ratings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(610, 9724)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our `X` matrix contains 610 users and 9724 movies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating sparsity\n",
    "\n",
    "Here, we calculate sparsity by dividing the number of stored elements by total number of elements. The number of stored (non-empty) elements in our matrix ([nnz](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.nnz.html)) is equivalent to the number of ratings in our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix sparsity: 1.7%\n"
     ]
    }
   ],
   "source": [
    "n_total = X.shape[0]*X.shape[1]\n",
    "n_ratings = X.nnz\n",
    "sparsity = n_ratings/n_total\n",
    "print(f\"Matrix sparsity: {round(sparsity*100,2)}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`csr_matrix.nnz` counts the stored values in our sparse matrix. The rest of our cells are empty.\n",
    "\n",
    "The **cold start problem** is when there are new users and movies in our matrix that do not have any ratings. In our Movielens dataset, all users and movies have at least one rating but in general, it's useful to check which users and movies have few interactions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "610"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_ratings_per_user = X.getnnz(axis=1)\n",
    "len(n_ratings_per_user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most active user rated 2698 movies.\n",
      "Least active user rated 20 movies.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Most active user rated {n_ratings_per_user.max()} movies.\")\n",
    "print(f\"Least active user rated {n_ratings_per_user.min()} movies.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9724"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_ratings_per_movie = X.getnnz(axis=0)\n",
    "len(n_ratings_per_movie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most rated movie has 329 ratings.\n",
      "Least rated movie has 1 ratings.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Most rated movie has {n_ratings_per_movie.max()} ratings.\")\n",
    "print(f\"Least rated movie has {n_ratings_per_movie.min()} ratings.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16,4))\n",
    "plt.subplot(1,2,1)\n",
    "sns.kdeplot(n_ratings_per_user, shade=True)\n",
    "plt.xlim(0)\n",
    "plt.title(\"Number of Ratings Per User\", fontsize=14)\n",
    "plt.xlabel(\"number of ratings per user\")\n",
    "plt.ylabel(\"density\")\n",
    "plt.subplot(1,2,2)\n",
    "sns.kdeplot(n_ratings_per_movie, shade=True)\n",
    "plt.xlim(0)\n",
    "plt.title(\"Number of Ratings Per Movie\", fontsize=14)\n",
    "plt.xlabel(\"number of ratings per movie\")\n",
    "plt.ylabel(\"density\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Item-item Recommendations with k-Nearest Neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to find the $k$ movies that have the most similar user engagement vectors for movie $i$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "def find_similar_movies(movie_id, X, movie_mapper, movie_inv_mapper, k, metric='cosine'):\n",
    "    \"\"\"\n",
    "    Finds k-nearest neighbours for a given movie id.\n",
    "    \n",
    "    Args:\n",
    "        movie_id: id of the movie of interest\n",
    "        X: user-item utility matrix\n",
    "        k: number of similar movies to retrieve\n",
    "        metric: distance metric for kNN calculations\n",
    "    \n",
    "    Output: returns list of k similar movie ID's\n",
    "    \"\"\"\n",
    "    X = X.T\n",
    "    neighbour_ids = []\n",
    "    \n",
    "    movie_ind = movie_mapper[movie_id]\n",
    "    movie_vec = X[movie_ind]\n",
    "    if isinstance(movie_vec, (np.ndarray)):\n",
    "        movie_vec = movie_vec.reshape(1,-1)\n",
    "    # use k+1 since kNN output includes the movieId of interest\n",
    "    kNN = NearestNeighbors(n_neighbors=k+1, algorithm=\"brute\", metric=metric)\n",
    "    kNN.fit(X)\n",
    "    neighbour = kNN.kneighbors(movie_vec, return_distance=False)\n",
    "    for i in range(0,k):\n",
    "        n = neighbour.item(i)\n",
    "        neighbour_ids.append(movie_inv_mapper[n])\n",
    "    neighbour_ids.pop(0)\n",
    "    return neighbour_ids"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`find_similar_movies()` takes in a `movieId` and `X` matrix, and outputs a list of $k$ movies that are similar to the `movieId` of interest.\n",
    "\n",
    "Let's see how it works in action. We will first create another mapper that maps movieId to title so that our results are interpretable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3114, 480, 780, 260, 356, 364, 1210, 648, 1265]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similar_movies = find_similar_movies(1, X, movie_mapper, movie_inv_mapper, k=10)\n",
    "similar_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`find_similar_movies()` returns a list of `movieId`'s that are most similar to your movie of interest. Let's convert these id's to titles so that we can interpret our results. To make things easier, we will create a dictionary that maps `movieId` to `title`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Toy Story (1995):\n",
      "Toy Story 2 (1999)\n",
      "Jurassic Park (1993)\n",
      "Independence Day (a.k.a. ID4) (1996)\n",
      "Star Wars: Episode IV - A New Hope (1977)\n",
      "Forrest Gump (1994)\n",
      "Lion King, The (1994)\n",
      "Star Wars: Episode VI - Return of the Jedi (1983)\n",
      "Mission: Impossible (1996)\n",
      "Groundhog Day (1993)\n"
     ]
    }
   ],
   "source": [
    "movie_titles = dict(zip(movies['movieId'], movies['title']))\n",
    "\n",
    "movie_id = 1\n",
    "\n",
    "similar_movies = find_similar_movies(movie_id, X, movie_mapper, movie_inv_mapper, metric='cosine', k=10)\n",
    "movie_title = movie_titles[movie_id]\n",
    "\n",
    "print(f\"Because you watched {movie_title}:\")\n",
    "for i in similar_movies:\n",
    "    print(movie_titles[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results above show the 10 movies that are most similar to Toy Story. Most movies in this list are family movies from the 1990s, which seems pretty reasonable. Note that these recommendations are based solely on user-item ratings. Movie features such as genres are not used in this approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also play around with the kNN distance metric and see what results you would get if you use \"manhattan\" or \"euclidean\" instead of \"cosine\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Toy Story (1995):\n",
      "Toy Story 2 (1999)\n",
      "Mission: Impossible (1996)\n",
      "Independence Day (a.k.a. ID4) (1996)\n",
      "Bug's Life, A (1998)\n",
      "Nutty Professor, The (1996)\n",
      "Willy Wonka & the Chocolate Factory (1971)\n",
      "Babe (1995)\n",
      "Groundhog Day (1993)\n",
      "Mask, The (1994)\n"
     ]
    }
   ],
   "source": [
    "movie_id = 1\n",
    "\n",
    "similar_movies = find_similar_movies(movie_id, X, movie_mapper, movie_inv_mapper, metric='euclidean', k=10)\n",
    "movie_title = movie_titles[movie_id]\n",
    "\n",
    "print(f\"Because you watched {movie_title}:\")\n",
    "for i in similar_movies:\n",
    "    print(movie_titles[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 6: Handling the cold-start problem\n",
    "\n",
    "Collaborative filtering relies solely on user-item interactions within the utility matrix. The issue with this approach is that brand new users or items with no iteractions get excluded from the recommendation system. This is called the **cold start problem**. Content-based filtering is a way to handle this problem by generating recommendations based on user and item features.\n",
    "\n",
    "First, we need to convert the `genres` column into binary features. Each genre will have its own column in the dataframe, and will be populated with 0 or 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 9742 unique movies in our movies dataset.\n"
     ]
    }
   ],
   "source": [
    "n_movies = movies['movieId'].nunique()\n",
    "print(f\"There are {n_movies} unique movies in our movies dataset.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "genres = set(g for G in movies['genres'] for g in G)\n",
    "\n",
    "for g in genres:\n",
    "    movies[g] = movies.genres.transform(lambda x: int(g in x))\n",
    "    \n",
    "movie_genres = movies.drop(columns=['movieId', 'title','genres'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>Horror</th>\n",
       "      <th>Crime</th>\n",
       "      <th>Adventure</th>\n",
       "      <th>IMAX</th>\n",
       "      <th>War</th>\n",
       "      <th>Mystery</th>\n",
       "      <th>Drama</th>\n",
       "      <th>Fantasy</th>\n",
       "      <th>Musical</th>\n",
       "      <th>Documentary</th>\n",
       "      <th>Sci-Fi</th>\n",
       "      <th>Western</th>\n",
       "      <th>Thriller</th>\n",
       "      <th>Romance</th>\n",
       "      <th>Children</th>\n",
       "      <th>Action</th>\n",
       "      <th>(no genres listed)</th>\n",
       "      <th>Comedy</th>\n",
       "      <th>Film-Noir</th>\n",
       "      <th>Animation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Horror  Crime  Adventure  IMAX  War  Mystery  Drama  Fantasy  Musical  \\\n",
       "0       0      0          1     0    0        0      0        1        0   \n",
       "1       0      0          1     0    0        0      0        1        0   \n",
       "2       0      0          0     0    0        0      0        0        0   \n",
       "3       0      0          0     0    0        0      1        0        0   \n",
       "4       0      0          0     0    0        0      0        0        0   \n",
       "\n",
       "   Documentary  Sci-Fi  Western  Thriller  Romance  Children  Action  \\\n",
       "0            0       0        0         0        0         1       0   \n",
       "1            0       0        0         0        0         1       0   \n",
       "2            0       0        0         0        1         0       0   \n",
       "3            0       0        0         0        1         0       0   \n",
       "4            0       0        0         0        0         0       0   \n",
       "\n",
       "   (no genres listed)  Comedy  Film-Noir  Animation  \n",
       "0                   0       1          0          1  \n",
       "1                   0       0          0          0  \n",
       "2                   0       1          0          0  \n",
       "3                   0       1          0          0  \n",
       "4                   0       1          0          0  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_genres.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions of our genres cosine similarity matrix: (9742, 9742)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "cosine_sim = cosine_similarity(movie_genres, movie_genres)\n",
    "print(f\"Dimensions of our genres cosine similarity matrix: {cosine_sim.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, after passing the `movie_genres` dataframe into the cosine_similarity() function, we get a cosine similarity matrix of shape $(n_{\\text{movies}}, n_{\\text{movies}})$.\n",
    "\n",
    "This matrix is populated with values between 0 and 1 which represent the degree of similarity between movies along the x and y axes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a movie finder function\n",
    "Let's say we want to get recommendations for movies that are similar to Jumanji. To get results from our recommender, we need to know the exact title of a movie in our dataset.\n",
    "\n",
    "In our dataset, Jumanji is actually listed as 'Jumanji (1995)'. If we misspell Jumanji or forget to include its year of release, our recommender won't be able to identify which movie we're interested in.\n",
    "\n",
    "To make our recommender more user-friendly, we can use a Python package called [fuzzywuzzy](https://pypi.org/project/fuzzywuzzy/) which will find the most similar title to a string that you pass in. Let's create a function called `movie_finder()` which take advantage of fuzzywuzzy's string matching algorithm to get the most similar title to a user-inputted string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test this out with our Jumanji example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jumanji (1995)'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "title = movie_finder('juminji')\n",
    "title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get relevant recommendations for `Jumanji`, we need to find its index in the cosine simialrity matrix. To identify which row we should be looking at, we can create a movie index mapper which maps a movie title to the index that it represents in our matrix.\n",
    "\n",
    "Let's create a movie index dictionary called `movie_idx` where the keys are movie titles and values are movie indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Movie index for Jumanji: 1\n"
     ]
    }
   ],
   "source": [
    "movie_idx = dict(zip(movies['title'], list(movies.index)))\n",
    "idx = movie_idx[title]\n",
    "print(f\"Movie index for Jumanji: {idx}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using this handy `movie_idx` dictionary, we know that Jumanji is represented by index 1 in our matrix. Let's get the top 10 most similar movies to Jumanji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_recommendations=10\n",
    "sim_scores = list(enumerate(cosine_sim[idx]))\n",
    "sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)\n",
    "sim_scores = sim_scores[1:(n_recommendations+1)]\n",
    "similar_movies = [i[0] for i in sim_scores]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`similar_movies` is an array of indices that represents Jumanji's top 10 recommendations. We can get the corresponding movie titles by either creating an inverse movie_idx mapper or using iloc on the title column of the movies dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Jumanji (1995):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "53                     Indian in the Cupboard, The (1995)\n",
       "109                     NeverEnding Story III, The (1994)\n",
       "767                       Escape to Witch Mountain (1975)\n",
       "1514            Darby O'Gill and the Little People (1959)\n",
       "1556                                  Return to Oz (1985)\n",
       "1617                        NeverEnding Story, The (1984)\n",
       "1618    NeverEnding Story II: The Next Chapter, The (1...\n",
       "1799                        Santa Claus: The Movie (1985)\n",
       "3574    Harry Potter and the Sorcerer's Stone (a.k.a. ...\n",
       "6075    Chronicles of Narnia: The Lion, the Witch and ...\n",
       "Name: title, dtype: object"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(f\"Because you watched {title}:\")\n",
    "movies['title'].iloc[similar_movies]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool! These recommendations seem pretty relevant and similar to Jumanji. The first 5 movies are family-friendly films from the 90s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test our recommender further with other movie titles. For your convenience, let's package the steps into a single function which takes in the movie title of interest and number of recommendations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_content_based_recommendations(title_string, n_recommendations=10):\n",
    "    title = movie_finder(title_string)\n",
    "    idx = movie_idx[title]\n",
    "    sim_scores = list(enumerate(cosine_sim[idx]))\n",
    "    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)\n",
    "    sim_scores = sim_scores[1:(n_recommendations+1)]\n",
    "    similar_movies = [i[0] for i in sim_scores]\n",
    "    print(f\"Because you watched {title}:\")\n",
    "    print(movies['title'].iloc[similar_movies])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Toy Story (1995):\n",
      "1706                                       Antz (1998)\n",
      "2355                                Toy Story 2 (1999)\n",
      "2809    Adventures of Rocky and Bullwinkle, The (2000)\n",
      "3000                  Emperor's New Groove, The (2000)\n",
      "3568                             Monsters, Inc. (2001)\n",
      "Name: title, dtype: object\n"
     ]
    }
   ],
   "source": [
    "get_content_based_recommendations('toy story', 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 7: Dimensionality Reduction with Matrix Factorization (advanced)\n",
    "\n",
    "Matrix factorization (MF) is a linear algebra technique that 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. MF 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",
    "<img src=\"images/matrix_factorization.png\" width=\"50%\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9724, 20)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.decomposition import TruncatedSVD\n",
    "\n",
    "svd = TruncatedSVD(n_components=20, n_iter=10)\n",
    "Q = svd.fit_transform(X.T)\n",
    "Q.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Because you watched Toy Story (1995):\n",
      "Home Alone (1990)\n",
      "Jurassic Park (1993)\n",
      "Aladdin (1992)\n",
      "Willy Wonka & the Chocolate Factory (1971)\n",
      "Back to the Future (1985)\n",
      "Forrest Gump (1994)\n",
      "Groundhog Day (1993)\n",
      "Star Wars: Episode IV - A New Hope (1977)\n",
      "Princess Bride, The (1987)\n"
     ]
    }
   ],
   "source": [
    "movie_id = 1\n",
    "similar_movies = find_similar_movies(movie_id, Q.T, movie_mapper, movie_inv_mapper, metric='cosine', k=10)\n",
    "movie_title = movie_titles[movie_id]\n",
    "\n",
    "print(f\"Because you watched {movie_title}:\")\n",
    "for i in similar_movies:\n",
    "    print(movie_titles[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results above are the most similar movies to Toy Story using kNN on our “compressed” movie-factor matrix. We reduced the dimensions down to n_components=20. We can think of each component representing a latent feature such as movie genre."
   ]
  }
 ],
 "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": 2
}