part-2-cold-start-problem.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Handling the Cold Start Problem with Content-Based Filtering\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 interactions 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",
    "In this tutorial, we will generate item-item recommendations using content-based filtering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Import Dependencies\n",
    "\n",
    "We will be using the following Python packages:\n",
    "\n",
    "- [numpy](https://numpy.org/): for scientific computing \n",
    "- [pandas](https://pandas.pydata.org/): for data manipulation \n",
    "- [scikit-learn](https://scikit-learn.org/stable/): for machine learning \n",
    "- [matplotlib](https://matplotlib.org/), [seaborn](https://seaborn.pydata.org/): for data visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Load the Data\n",
    "\n",
    "Let's assume we're building a recommender system for a new movie platform and we know very little about our current users. We don't have enough interactios data in our system to rely on collaborative filtering. \n",
    "\n",
    "What we do have is movie features: which genres a movie belongs to, and which year it was released. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies = pd.read_csv(\"https://s3-us-west-2.amazonaws.com/recommender-tutorial/movies.csv\")\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Data Cleaning and Exploration\n",
    "\n",
    "Before exploring our movie features dataset, we need to clean in two ways:\n",
    "\n",
    "1. 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",
    "2. 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": "markdown",
   "metadata": {},
   "source": [
    "#### Converting Genres from String Format to List \n",
    "\n",
    "The genres column is currently a string separated with pipes. Let's convert this into a list using the \"split\" function.\n",
    "\n",
    "We want \n",
    "`\"Adventure|Children|Fantasy\"`\n",
    "to convert to this:\n",
    "`[Adventure, Children, Fantasy]`."
   ]
  },
  {
   "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>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": 3,
     "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?\n",
    "\n",
    "We can use Python's Counter to create a dictionary containing frequency counts of each genre in our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 20 genre labels.\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": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "genres_counts = Counter(g for genres in movies['genres'] for g in genres)\n",
    "print(f\"There are {len(genres_counts)} genre labels.\")\n",
    "genres_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 20 genre labels and 19 genres that are used to describe movies in this dataset. Some movies don't have any genres, hence the label `(no genres listed)`. \n",
    "\n",
    "Let's remove all movies having `(no genres listed)` as its genre label. We'll also remove this from our `genre_counts` dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "movies = movies[movies['genres']!='(no genres listed)']\n",
    "\n",
    "del genres_counts['(no genres listed)']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What are the most popular genres?\n",
    "\n",
    "We can use `Counter`'s [most_common()](https://docs.python.org/2/library/collections.html#collections.Counter.most_common) method to get the genres with the highest movie counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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\", genres_counts.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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAF2CAYAAADeLrQCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd7hkVZWw8Xd1Ew0ISMsIDYKIOoiSWkBwxsCIGBADiCjKGAb9BhXFHFEUw5jFMaCAoCjRAAYEEQVBhW6CJBlaGUcQBRUQEwqs74+9q7vu5XbQrn3q9L3v73nu01Wnqs461fdWnXV2WDsyE0mSJPXPrHEfgCRJkqZmoiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPbXKuA+ghfXWWy832WSTcR+GJEnSMi1YsOA3mTlnqsemZaK2ySabMH/+/HEfhiRJ0jJFxM+X9Jhdn5IkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPTUt1/octuvG+zbd/+n/9/mm+5ckSTOXLWqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTzRO1iJgdERdFxNfq/U0j4kcRsTAijo+I1er21ev9hfXxTYb28Ya6/aqIeHzrY5YkSeqDLlrUDgSuHLr/XuBDmfkA4CbghXX7C4Gb6vYP1ecREVsAzwIeAuwGfDwiZndw3JIkSWPVNFGLiLnAk4DP1PsBPBY4qT7laOCp9fYe9T718V3q8/cAjsvM2zLzGmAhsH3L45YkSeqD1i1qHwZeC9xZ798buDkzb6/3rwU2rLc3BH4BUB+/pT5/0fYpXrNIROwfEfMjYv6NN9446vchSZLUuWaJWkQ8GbghMxe0ijEsMw/PzHmZOW/OnDldhJQkSWpqlYb73hl4SkQ8EVgDWAv4CLB2RKxSW83mAtfV518HbARcGxGrAPcCfju0fWD4NZIkSdNWsxa1zHxDZs7NzE0okwG+k5nPAc4C9qxP2w/4ar19Sr1Pffw7mZl1+7PqrNBNgc2B81sdtyRJUl+0bFFbktcBx0XEO4GLgCPq9iOAz0XEQuB3lOSOzLw8Ik4ArgBuBw7IzDu6P2xJkqRudZKoZeZ3ge/W2z9jilmbmfkXYK8lvP5Q4NB2RyhJktQ/rkwgSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPTWOlQlmhCdu9dJm+/7GJR9rtm9JktQftqhJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPVUs0QtItaIiPMj4pKIuDwi3l63bxoRP4qIhRFxfESsVrevXu8vrI9vMrSvN9TtV0XE41sdsyRJUp+0bFG7DXhsZm4FbA3sFhE7Au8FPpSZDwBuAl5Yn/9C4Ka6/UP1eUTEFsCzgIcAuwEfj4jZDY9bkiSpF5olaln8od5dtf4k8FjgpLr9aOCp9fYe9T718V0iIur24zLztsy8BlgIbN/quCVJkvqi6Ri1iJgdERcDNwBnAD8Fbs7M2+tTrgU2rLc3BH4BUB+/Bbj38PYpXjMca/+ImB8R82+88cYWb0eSJKlTTRO1zLwjM7cG5lJawR7cMNbhmTkvM+fNmTOnVRhJkqTOdDLrMzNvBs4CHgGsHRGr1IfmAtfV29cBGwHUx+8F/HZ4+xSvkSRJmrZazvqcExFr19trAo8DrqQkbHvWp+0HfLXePqXepz7+nczMuv1ZdVbopsDmwPmtjluSJKkvVln2U/5h9wWOrjM0ZwEnZObXIuIK4LiIeCdwEXBEff4RwOciYiHwO8pMTzLz8og4AbgCuB04IDPvaHjckiRJvdAsUcvMHwPbTLH9Z0wxazMz/wLstYR9HQocOupjlCRJ6jNXJpAkSeopEzVJkqSeMlGTJEnqKRM1SZKknjJRkyRJ6ikTNUmSpJ4yUZMkSeopEzVJkqSeMlGTJEnqKRM1SZKknjJRkyRJ6ikTNUmSpJ4yUZMkSeopEzVJkqSeMlGTJEnqKRM1SZKknjJRkyRJ6ikTNUmSpJ4yUZMkSeopEzVJkqSeMlGTJEnqKRM1SZKknjJRkyRJ6ikTNUmSpJ4yUZMkSeqp5UrUIuLM5dkmSZKk0VllaQ9GxBrA3YD1ImIdIOpDawEbNj42SZKkGW2piRrwYuAVwAbAAhYnar8HPtbwuCRJkma8pSZqmfkR4CMR8bLMPKyjY5IkSRLLblEDIDMPi4idgE2GX5OZxzQ6LkmSpBlvuRK1iPgcsBlwMXBH3ZyAiZokSVIjy5WoAfOALTIzWx6MJEmSFlveOmqXAf/U8kAkSZI00fK2qK0HXBER5wO3DTZm5lOaHJUkSZKWO1F7W8uDkCRJ0l0t76zP77U+EEmSJE20vLM+b6XM8gRYDVgV+GNmrtXqwCRJkma65W1Ru+fgdkQEsAewY6uDkiRJ0vLP+lwki68Aj29wPJIkSaqWt+vz6UN3Z1Hqqv2lyRFJkiQJWP5Zn7sP3b4d+F9K96ckSZIaWd4xas9vfSCSJEmaaLnGqEXE3Ij4ckTcUH9Ojoi5rQ9OkiRpJlveyQRHAacAG9SfU+s2SZIkNbK8idqczDwqM2+vP58F5jQ8LkmSpBlveRO130bEvhExu/7sC/y25YFJkiTNdMubqL0AeCbwK+B6YE/g3xsdkyRJklj+8hyHAPtl5k0AEbEu8H5KAidJkqQGlrdF7WGDJA0gM38HbNPmkCRJkgTLn6jNioh1Bndqi9rytsZJkiTpH7C8idoHgB9ExDsi4h3AecB/Le0FEbFRRJwVEVdExOURcWDdvm5EnBERV9d/16nbIyI+GhELI+LHEbHt0L72q8+/OiL2+8feqiRJ0spluRK1zDwGeDrw6/rz9Mz83DJedjvwqszcAtgROCAitgBeD5yZmZsDZ9b7AE8ANq8/+wOfgEWtdwcDOwDbAwcPt+5JkiRNV8vdfZmZVwBX/B3Pv54yQ5TMvDUirgQ2pKwR+uj6tKOB7wKvq9uPycwEfhgRa0fEfetzz6jj4oiIM4DdgC8u77FIkiStjJa363OFRMQmlMkHPwLWr0kclHIf69fbGwK/GHrZtXXbkrZPjrF/RMyPiPk33njjSI9fkiRpHJonahFxD+Bk4BWZ+fvhx2rrWY4iTmYenpnzMnPenDkumiBJklZ+TRO1iFiVkqQdm5lfqpt/Xbs0qf/eULdfB2w09PK5dduStkuSJE1rzRK1iAjgCODKzPzg0EOnAIOZm/sBXx3a/rw6+3NH4JbaRfotYNeIWKdOIti1bpMkSZrWWtZC2xl4LnBpRFxct70ReA9wQkS8EPg5ZWkqgG8ATwQWAn8Cng+luG4tCXJBfd4hg4kFkiRJ01mzRC0zvw/EEh7eZYrnJ3DAEvZ1JHDk6I5OkiSp/zqZ9SlJkqS/n8tATSNPftTrmu37a997b7N9S5KkqdmiJkmS1FMmapIkST1loiZJktRTjlHTCnnS7gc33f/XT3170/1LktRntqhJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPuSi7Vkq77n1Is32ffvxbm+1bkqS/hy1qkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPbXKuA9AWlk85t/f0XT/Z332LU33L0la+diiJkmS1FMmapIkST1loiZJktRTjlGTeuyR/6/tuLjvf8JxcZLUZ7aoSZIk9ZSJmiRJUk+ZqEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk81S9Qi4siIuCEiLhvatm5EnBERV9d/16nbIyI+GhELI+LHEbHt0Gv2q8+/OiL2a3W8kiRJfdOyRe2zwG6Ttr0eODMzNwfOrPcBngBsXn/2Bz4BJbEDDgZ2ALYHDh4kd5IkSdNds0QtM88Gfjdp8x7A0fX20cBTh7Yfk8UPgbUj4r7A44EzMvN3mXkTcAZ3Tf4kSZKmpa7HqK2fmdfX278C1q+3NwR+MfS8a+u2JW2/i4jYPyLmR8T8G2+8cbRHLUmSNAZjW5Q9MzMicoT7Oxw4HGDevHkj2680E+1wULvF4H/0wakXgt/uTYc0iwmw4NC3Nt2/JLXQdYvar2uXJvXfG+r264CNhp43t25b0nZJkqRpr+tE7RRgMHNzP+CrQ9ufV2d/7gjcUrtIvwXsGhHr1EkEu9ZtkiRJ016zrs+I+CLwaGC9iLiWMnvzPcAJEfFC4OfAM+vTvwE8EVgI/Al4PkBm/i4i3gFcUJ93SGZOnqAgSZI0LTVL1DJznyU8tMsUz03ggCXs50jgyBEemiRJ0krBlQkkSZJ6ykRNkiSpp0zUJEmSespETZIkqadM1CRJknrKRE2SJKmnTNQkSZJ6amxrfUpSH2z9zrc12/fFb263b0kzgy1qkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUU5bnkKSObfWBg5vt+5JXvb3ZviV1zxY1SZKknjJRkyRJ6im7PiVpBpj3ybc03f/8l7yj6f6lmcoWNUmSpJ6yRU2S1MxjPv/GZvs+a993Ndu31Be2qEmSJPWUiZokSVJPmahJkiT1lImaJElST5moSZIk9ZSJmiRJUk+ZqEmSJPWUddQkSdPKnl99bdP9n7THfzXdvzTMFjVJkqSeMlGTJEnqKbs+JUlaQS8788Cm+z9sl4803b/6yxY1SZKknjJRkyRJ6im7PiVJWkm9/ewXNNv3wf96ZLN9a/nZoiZJktRTJmqSJEk9ZaImSZLUUyZqkiRJPWWiJkmS1FMmapIkST1loiZJktRTJmqSJEk9ZaImSZLUU65MIEmSltsnz3ta0/2/ZKcvN93/ysZETZIk9d6Xf/Svzfb9tB3ObrbvFWXXpyRJUk+ZqEmSJPWUiZokSVJPOUZNkiRpCj+8YLtm+97x4QuW63m2qEmSJPXUSpOoRcRuEXFVRCyMiNeP+3gkSZJaWykStYiYDfw38ARgC2CfiNhivEclSZLU1kqRqAHbAwsz82eZ+VfgOGCPMR+TJElSU5GZ4z6GZYqIPYHdMvNF9f5zgR0y86VDz9kf2L/efRBw1T8Ybj3gNytwuCtLzHHFnSkxxxXX9zr9Yo4r7kyJOa64vtfpF3NF4t4vM+dM9cC0mfWZmYcDh6/ofiJifmbOG8Eh9TrmuOLOlJjjiut7nX4xxxV3psQcV1zf6/SL2SruytL1eR2w0dD9uXWbJEnStLWyJGoXAJtHxKYRsRrwLOCUMR+TJElSUytF12dm3h4RLwW+BcwGjszMyxuFW+Hu05Uk5rjizpSY44rre51+MccVd6bEHFdc3+v0i9kk7koxmUCSJGkmWlm6PiVJkmYcEzVJkqSeMlGbISJiVkQ8c9zHIUmSlp+J2gyRmXcCrx33cUgrm7qEnfQPi2KjZT9TK5vaCLJTyxgmamMSES+LiHU6DvvtiHh1RGwUEesOfjo+hk5FxN06jBURsW9EvLXe3zgitu8wfmfvdRwiYnZEnDWG0FdHxPu6Xl+4vt8N6t/RxhGx8TSNuXtEdH4u6jJulll73+gi1kwUEa+a6ncZEfeOiCNaxq6NIP/dMsZKUZ6jtYjYHHg3ZcH3NQbbM/P+DcOuD1wQERcCRwLfyvZTcPeu/x4wtC2BZu8zIuYA/wFswtDfW2a+oFXMGncn4DPAPYCNI2Ir4MWZ+Z8Nw34cuBN4LHAIcCtwMvDwhjE7fa8R8f3MfGRE3Er521n0EOV8tNaoYw5k5h0RcWdE3Cszb2kVZwpbUWo3fqaeDI4EjsvM37cKGBEvAw4Gfk35m4Ly//2w6RSz2hv4cEScTCm99JPG8cYV98KIeHhmXtA4ziIRcSoTP6cTZOZTGsXdGXgbcD/K9/7g+6HVueZBlP/fAzLz3HoM/0npRfpwo5jDzoyIZwBfanEetzwH5eRD+YL6ELA78HxgVma+tXHcAHat8eYBJwBHZOZPW8btUkScB5wDLADuGGzPzJMbx/0RsCdwSmZuU7ddlplbNox5YWZuGxEXDcW8JDO3ahWzxuj8vY5LRHwV2AY4A/jjYHtmvryj+I8CvgCsDZwEvCMzFzaIs5CynvFvR73vPsUcir0WsA/luzCBo4AvZuat0yVuRPwEeADwc8rf7iB5aZl8P2ppj2fm9xrF/QnwSu76vd/sb6tesP43cBnwYOBq4FWZeX2rmEOxbwXuDtwO/IURX7jaolasmZlnRkRk5s+Bt0XEAqBpopaZGRG/An5F+QWvA5wUEWdk5sjHk9WusYOAjTNz/9qS+KDM/NqoYw25W2a+ruH+lygzf1Fy4UXuWNJzR+RvdTxTwqLWxDuX/pLR6Oq9RsTTM/NL9fY6mXlTizhL8aX605n6O30S5WS+CfAB4FjgXyjdWQ9sEPYXQJethuOKCUBm/j4iTgLWBF4BPA14TUR8NDMPmyZxHz/i/S1Tq0RsOdySmd/sOOZlwPnAbpRhXZ0kaQCZec+W+zdRK26rXRpX1xUQrqN0IzUTEQcCzwN+Q+m2ek1m/m1wHLQZ+H8U5QpnMPDxOuBEoGWi9rWIeGJmdj0+4xf1CisjYlXgQODKxjE/CnwZuE9EHEpp5Xpz45jQ7Xt9M4sTpTOBbRvFmVJmHl2XkRskR1dl5t8ah70aOAt4X2aeN7T9pIj410YxfwZ8NyK+Dtw22JiZH2wUb1wxiYg9gH+ntDYdA2yfmTfUC8srgCaJWtdxayMAEXEfhobYdGEMw3vOioj3Ub4rhv+WLmwRLCKeC7wd+BSwGWW4wn9HxP8Ar87MGxrFfXBm/iQipvweHNX7NVErDgTuBrwceAdljNF+jWOuCzx98OEdyMw7I+LJjWJulpl7R8Q+NdafYlIzTAMHAm+MiL8CgxNq07FM1UuAjwAbUhLS05k4Nm/kMvPY2hK7C6Xp+6mZ2To5hG7fayzhdici4tHA0cD/1vgbRcR+mXl2w7APy8w/TPVAwy7X/6s/q9WfLowjJpRWrA9N/h3W76cXTpe4EfEUSmvsBsANlPFbVwIPGXWsKRzF4uE9j6EO72kYb4f677yhbUk5t7awJ/CYofPpgoh4BOW78Ye0G4d9ELA/5fc62cjer2PUOhbLmGWZmb9rGPs8ShJxbh1LtRllPEZnMxOnq9o9dnlmPnjcx9JSHXuyD+VL/vPAsxlK2FpdMQ/FXwA8OzOvqvcfSPkb3q5hzP8C3gn8GTiNMrj+lZn5+VYxh2LfLTP/1DrOpJj3AFhScjriWLOBb2fmY1rHGnfciLiEcuL+dmZuExGPAfbNzJbJ6CD2gszcLiIuzcyHDm9rEGsWsGdmnjDqff8jImLjzPy/cR/HirBFDYiIecCbWDxDBYBGgzwXUDLtADYGbqq316ZczW7aIObAwZQTzUYRcSywM6Xpv6l6JTnoIvpu4zFxg5hHAwdm5s31/jrAB1rNNq0zEq8ax5dCRGwKvIy7zqxtMaPremDQFfarodvQ9op5YNVBkgaQmf9Tu3tb2jUzXxsRT6O05D0dOJuSqDZRWwOOoMNZyxGxJfA5Sms/EfEb4HmZeXmrmOOayTumuH/LzN9Gqbs1KzPPioguZiRCh8N7aq/QaymT48YiItYGnkG5kPxnSitmy3irAv+PofMc8KlRDcswUSuOBV4DXErjwd+ZuSlARHwa+PJg7FZEPAF4auPYZ0QpB7IjJTk8MDN/0zJmRLyHUp7i2LrpwIjYOTPf0DIupbvq5sGdzLwpIrZpHHMd4PKIOJ+JMxKbTIEf8hXKSf1U2v/9dtryMYX5EfEZFidJzwHmN445SASfBJyYmbe0HzHAhymDz08ByMxLGo6HGzgcOCgzz4JF3cyfZvGY1lb+AFwaEV3P5O067s21tfIc4NiIuGE4bmOTh/c8hrbDe74dEa8Gjmfi/23LHqM1gT0oydk2wD0p59SWwyIGPkH5nvh4vf/cuu1Fo9i5XZ8srg3VccxFTdBL2zaiWEsd8N2yuyoifgxsnaUo4KDL4aKWU9JrnEuARw9mJdYu5++1+P8dijnlVPjWM68i4keZucOyn9ks/uGZuX9HsVanjL8bfF7PAT6embct+VUrHPM9lC/8PwPbU1q/v9by/3zwO40OS71Mtf/WMWuMKROGzDx6OsSNiFcA51EmKPyJMmzgOcC9gGNzDOVQWouIa6bYnK0mL0TEFyizsE8HjgO+AywcNIy01vqzY4tacXC9Sj+TiTNUWpYB+GVEvJmJLQO/bBRrqoGOA110V60NDK6k7tU41sAHgB9ExImU1sM9gUNbBhzjVPiPRMTBlC+p5jOspjBv2U9ZcTXJPzIzn8PELtemMvP1dZzaLbXL7I+UK/eWxjFr+WcR8RZK9yfAvpSZoE3VmbxrUsoGXbXMF4wwbkeh5lJaSB9M6bU5l5K4ndqyhWlYbTXca9JQkOMys0nJkK4SpCFbUIYRXQlcWT+nXbZC3RERm2WtgRoR92eEJZJM1IrnUz5EqzKxInfLRG0fypixL9dYZ9dtIzfm7qp3AxdFWfonKH34r28dNDOPqQPPB+/96Zl5RcuYMbFa/2qUv6c/djDD9aGUpvbHMvHvt3UCPtBk6vtk9cv3fhGxWmb+tYuYQzYA/i0ihssqHNMwXuezloEXUEocDL73zqnbmoqI3YH3Uz4zm0bE1sAhrYcMREclKzLz1TXeapSLmp0o55zDI+LmzOxiabL1phgKcp9WwaLjmp2ZuXVEPJhyDv12HV95z4hYPzN/3SLmJK+hlCT5GeU8dz/K73gk7PoEIuKqzHzQmGLfPTObjlOIiKcv7fHGLYdExH1ZvIzS+Zn5q5bxhuLOpizVNTzAvpOB/lEGMe0B7JiZTRPTKBXltxhD8tK5iDiGMjj4FCaOfWnWwlZbKx9NOaF/A3gC8P3M3LNRvNnAyzPzQy323zf1guqxlIlGna2sER2vSBMR9wIeQZnE9QhKT8OlmTmyE/pSYi8Anjb4/ouI+1HGSDepgxgRx1Mmzj0vM7esidt5mbl1i3hTxN+OMlZtL+DazGw9znIwLGOQR1w1yuEYtqgV50XEFq1bXIZFt2tR7r6Ux5q0HMZdCwFeW//dICI2aN0tFxPXLbyDuqQH7dctBBYtwvyVepJv3YJ4GeVLv3nLVkR8ODNfEUtYQ7CDiRM/rT+zKIOFu7AnpYDmRZn5/IhYn4YzPmvL4bMpCURzPfid/m2KCRpdrOjRyYo0EXE4pVbarcCPKN2eH8xuV/V4E/D9iPge5bvwXyj1v1oZR83ORTJzAaWW2qsp77WJpUzw2SEiyBHVdzRRK3YELq4DIG+jgzXYKF/Cnczq6uKKbQqdFAJcigMpTe1drpU43HI5i9LN8ZcOQq8N/CQiLmDiGLUWJ9jB+KX3N9j3UtWWpnsOupI69OdacuD2KGtD3gBs1Djm9yPiY9x11lyLC5yx/U6ry2tiOrt2kb2cksy01lXJio2B1SkrXFxHuWi9eamvGLHMPK1eNO9YN72i8Yz/v9Zxh4Pl9DZj6Ltp1CLio8t4SquZn6+ZYtugQWAjYPYogpioFbuNI2h2tz7jvpn5+Yg4aAnHMfJuo6FZgE/IzAnJyqRxPq2MY93C4ZbL2yk1t1oPOofSctiJeqUKpSTGnyfN5l29cew7ImLnljGWYH6UukyfpnTn/AH4QeOYgy6iQ4a2NbnAGfqdbp2ZHxl+LMpSd60nybyM0uJzG2XB+29RSki0NlXJiueNOkhm7lZbkx5CGZ/2KmDLiPgd8IPMbPb5naJnYzBhbeMoNR9b9Wy8jbvW7GzZYPASSs/CCZT32EnrXWZO6K2q309vptSYfNmo4jhGbUhMWoOt5XimKAsBfxD4GGW5jQOBeZn5rAaxXpyZn6rdcHeRmW8fdcyh2BdOHgcx1bYGcY+gjBfobN3CKPXhzl3WtukgIn4I/FvW6vVR6kOd3nosSER8gjLA/kQmtjR1slB7RGwCrJWZP+4iXpeW8FldVB6kYdy9MvPEZW2bDnEjYi4ladkJeDJw78xcu2G8w+tg/rOmeDgzs1nPRkTcm8U1O3/YsgWvxtoL2JtykXw8cNLwBIqWImIX4C2Ui6l3ZeYZI92/idqiyvl3WYMtM5utwRYR61Fmdf0b5Q/5dEoB2iZddV0PUI6If6KcUCcvM7QW8MlsvNTSTEhKo9b/i4mzTWFx132z2aYRcfHkgcFTbWsQ96gpNmc2WnGixjwzM3dZ1rYRxZqy1XugxYVGHUf0bEptunOGHroncGeL9zkp/rgu5jqJGxEvpyRmO1HWOz5v6OfSQav0dNLlZ2aK2HOBZ1GG37wuMz+3jJesSKwnUVqDbwEOzczvt4hj12fxDkrmP2ENtpYB69XFc1rGmBTvjvqF3NVMssdTlqeaS0mCB4na74E3tg7eMiGbLMpyPzsBcyadaNdiRGMUppK1SHNmdjWoftgfI2LbQddJlGXY/tw6aJfjLWsX/d2A9aLUnRq+2NiwUdjB7/JBlJnSp5f0macAABNaSURBVNT7uwPnN4p5HmVpsPWYOKb0VqBZy2GU1VieCGw4aYzRWpRWkekSdxNKC/ArM/P6BvtfpojYCzgtM2+NUr9zW+AdmXnRiOOM4zMzHH9bSomOxwHfpAxVaOlUypjD3wKvjbJ01iKjGidsolZ0vgZbdLs+48C5XQ1QzlJM8uiIeEZmnjzq/S9LRMwBXksZFzLcnd2iqX81yiDkVZg4E/H3lBmDzcT4FoN/BXBiRAzGvNyX0u3QVL1aPozSfQSlBejAzLx2ya/6h72Y8j43oHzhD19sfKxBvEUXGBFxNrBtZt5a77+N0o3fIubPgZ9TSkZ06ZeUsY5PYeIJ9VbgldMlbmYutZW0I2/JzBMj4pGUXpz3AZ+kDLsZpc4/MwARcQhlibcrKSsTvCEzmyX7QzqpUWrXJxAR36YsEfNuylXlDcDDW463ibLE0RFMWl80G1a3H9M4hXcB/5UTK2K/KjPf3CpmjXM6JSF9NWWg6X7AjZn5uoYx71dPep2KiK8CL2s5pnIo1sOBX2Tmr6JUzH8xZZHyK4C3ZuNK61EqrH+BidXzn5OZj2sY82WZeVir/S8h5lWU9Wpvq/dXB36cDes9RsSOlCT4nykXH7PpoGBzRKyadfHq+v2wURdjAIfjTneDsYYR8W5Kd+sXWo4/7PozExF3AtdQluiCxUNBuqjgMPlYFvU0jGyfJmoQEXendNt0tgZbjHl9xq5M9WXQ0fiTBZm5XUT8ePAhjYgLMvPhy3rtCsR8ICUx3ISJraRNS5HU1pdtKF1jTReDj4gLKZMIfhelnMxxlJbhrYF/zkZFYIfij2ts3E7c9ffabGWCiHgT8EzKyiVQLiSPz8x3N4w5nzK250RKaZnnAQ/MzDe0ilnjfpfSurUKpRXmBkpx1JataoMZem+jjElehcUn9SbrUY5TRHyNUhrkcZRuzz9Tio83Wcd1CV2t72zRe1Pj3W9pj3d5Ad3i/Dbjuz5r19HXsiyzdCfQ1fpvna/PWK/Kn8FdTziHLOk1IzA7IlYfahlYk8ZlHKrBlfL1dcDnL4F1G8c8kdKd8BkalVoZFhEPoKy88JZJD/0LZcxRC7OHWs32Bg6vXdsnR8TFjWIO+21E7At8sd7fhzI+pJmI+BywGXAxi3+vScMlpDLz0Ij4JouLdT5/1OOJlhB3YUTMzsw7gKMi4iKgaaIG3Cszfx8RLwKOycyDI6KLWbVHULo6F9DB53XMnkkpQ/X+zLw5ymoxU9UAG5Wpulo/wei7WoFuE7HlMPLSIDM+UauD7O+MiHtlZpd1t8axPuNXKbNTFtCw+OAkxwJn1tl6QZlg0EUy/M4oS7a8itKdsxZtx70A3J6Zn2gcY9iHKWMxLh3eGKU+07soJ6JRmx0Rq9TxH7swsbp5F98nL6D8Pj9E+bycR9v6TFBal7bIDrofImL4YuJ/68+ixxp3Lf8pynqUF0dZhP56Si9Da6vUxOGZlBl0XbklM7/ZYbxxWo8yLo+I2Lhu+0nDeIPE90mUi7mvR8Q7WwWbYub7oodoPAN+CiOfyDbjE7XqD8CldfzLcNfRyxvG3Au4f3a7PuPczOy0uG9mvreOx/s3ygfpW5SuhtZxB4v/3kJHAz6BUyPiPyndVcOtpK1OrutPTtJqvEuj1Ptq4YvA96IsevxnajmH2rrX/EKnXjm3XtJossuAf6JdK+WwBZTPyeCqfMJYG6Blt9xzKePSXkq5qNmI0gLf2iGU74XvZ+YFEXF/ShX/1s6KiPdRltDrpFdjjL7O4r+rNYBNgasok61auC4iPkXpan1v7c1plvSPaeb7BBHxMEpv1ayoq9TkiOo7OkYNiIj9ptpeZy62ivkVYP/MbL4+41DMw4HDpjq5N467DYsXyL0GODkzm80AqjE7n1UbZQmyyZqNeYmIqzNz8yU8tjAzH9Ao7o6UWZ6nZ+Yf67YHAvdoOAblMKa+YgbaXlTVSThbU8YAtl6ia8aJiHu3HA+8lLidT67qi1rG4j8z80WN9n83SlfrpZl5dW0xfWhmnt4i3rhFxJGUZaMuZ6iHLEdU39EWNUpCVss5kJk3dhS2s/UZI+Iyyh/PKsDzI+JnNF7TtJ6496k/v6HMwIw6FrALX6F0/Z1KNws8k5mbdhFnyPyI+I/M/PTwxjrWp1n9oMz84RTb/qdVvGr+0O230+GyWZQB552Iuy75M0HjMaxPptSUnDy4vnW30Q/r+MajgG920cUM0OF3Ue9k5oUR0WwyW5ZF2G+gFFG+mlKfrotW0nHZMTO3aLXzGd2iFhFB+cJ/KaVZNih/UIc1HmBPRDxqqu3ZoDxHRNzE4rUDp4o58oGYdbr0OcALM3Nh3fazrmZUjWNWbb2KPAjYOMuyLZtTFob/2jJe+o/GW5/SzfpXFidm8yilFZ6Wmb9qEXfcWpYVGLcY75I/CymlVi7tKlmqcYMyNOIFlCK/JwCfbZ3818/Pu4ANMvMJEbEF8IjMbDG2c6xiYiHuWZRZmPfOzMc3incw5bvoQZn5wIjYADgxM8exVm9zUZYs/EBmXtFk/zM8UTsIeAKlC/Kauu3+lNkpp2Xj5ZbqF8WgXMT5rbpBuyiHMUXMp1Km+u9MWZz3OOAzXbU6RcSzgc3pdlbt8ZSE6XmZuWVN3M7roHTEY4At693LM/M7LeONW9d/zzGm+mJdq8nhLjnGJY3q3/LngbsDlwCvz8wfNIr1TUor3psyc6uIWAW4KDMf2iLeOMXEJfVup0xSOTkz/9Io3sWUkkEXDi6qYqhU0nRTG15OoSzGPvLeqpmeqF0EPC4nLRZbu0FPb3nVHhHPpExZ/i7ll/ovwGsy86QGsa6lLAA/pWy7UPndgT0oXaCPpZQ0+HLrsQpRCjs+F/gpE8cMtGyRmJ+Z84ZbfCLikmxUq2imGkOiNq76Yl3Xbns4pevze0y8uGn2/VDj3ptSuPi5wK8pQxZOofQCnNjq4i5qXcVJn9fmNflmgog4PzO3H3xW63ngB9M4UVtI6U2ZXMB+JL1VM32M2qqTkzQo49SiVF1v6U2U1Q9ugEXJ4beBkSdqlBaAe9Cgvsuy1MHmXwC+EKXq+F7A6ygtXS2NY1btX6PUiUuAiNiM7sqgTGuTpt/fLSJ+P3iIDsZRZcf1xWIMtduAQykz4NegtBx25QeUlSaemhOXApsfEZ9sGPePNUkcfF53pIOZy12KiFOW9njDCTEn1Fmfa0fEf1C6tT+9jNeszG7MzKX+X6+ImZ6oLe0k3voEP2tSV+dvaTd9+frWY+6WR2beBBxef1q7jDJho7NZtZRB56cBG0XEsZRu33/vMP60Nebp9+OoL9ZZ7bYhG2Tmlst+2sg9aEnvMzPf2zDuQZSWu80i4lxgDo3X5h2DRwC/oJTV+RGNL9Yj4hWU2oYfppRF+j3wIMrycme0jD1mF0XEFyiT14Zbo0dSnmOmJ2pbDV2ZDxvUmmnptIj4FosrrO8NfKNRrM5b0nqgs1m1Q/s+PSIWADtS/s8PnKrFViud51ISsy7ri3VZu23gGxGxa1clFIZbe8p8golalz+pMx8fRUkkArgqp9/an/9EqWW2D6VE0teBL2bm5Y3izaUkaQ+mdAOeS0ncms1C74k1KeeZXYe2JaVG3wqb0WPUxiHqsj+ZeW4tivfI+tDNlPVFf9ogZuuK5r3T5azaoZinUrp5T6ldvlqJRcTG2cFC95Ninkr5gr8nHdduq93Ld6/x/kbjbuWIuJGltPa0/KzW+LMplfM3YeI4wKZj8sYlStHZfShjo9+eDWtZ1hboecBOlFa9RwA3tyxhMZ3N9Ba1cfgwdWxLbRb9EkBEPLQ+tvuoA860JA3Kl3xXs2qHvJ/SMvqe2pJ3HGUd2SYzq9TcVyhlDIiIkzOziyr9p1DWbz1n0vaW67cCY+le7rq1Z7JTgb8waQD4dFMTtCdR/p83AT5KKevT0pqUZfvuVX9+Sfl/nlaio0LcJmrdG8eyPzPOFLNqD4uIJrNqB2oLwPfqlfpjgf8AjqR8YWnlM9zC00n9P8oM6U7Xbx1Xkd06MeM0yjCQQWvPdyOiaWvPkLnTdRbiQEQcQynd8w1KK9pljeMdTlmW6lZKK+l5wAfr+OTpaP6yn7LiTNS6t/ZSHluzs6OY/rqcVbtInfW5O6VlbVu6WYBebeQSbrc0jgu5g4D9gQ9M8VhSLjqaGFNrz8A3uxyTNyb7UtavPhB4+dBYwFbd2hsDq1NWIbgOuJYyrGdayobLTA4zUeveWJb9mYG6nFULQEScAGxPaSX4GPC9cRYP1QobTDYKYM2OSoJ0fiGXmfvXfztdUqnr1p4p/BD4ckTMooMxeeOQma1nJ0+Ot1tdaeIhlPFprwK2rC3CP8jMLpd+ay4iPpyZrxgaWzrBqMaUOpmgYzFDl/3pWkS8j7JI7vCs2ksz87UNYz4e+Hbt0pH+bhHxReA7S7iQe1xm7t04fmdFdqMsMzeYdDN8IuokYYqIayhdzZ0umTVTRMRcSominYAnU5asWtqFyEonIrbLzAWtJ6+ZqI3JTFv2Zxwmzao9JzObdKnUOEs0qlo6mv7GeSG3pCK7oxoQ3TcRcTbwaFu9RyciXk5JzHaitFKeN/Rz6XT7v+5qZriJmmaE2r2xT2Ye22DfR9Wb96F8QQ2S7sdQ1vp88qhjanobx4VcRFxJ90V2xyYiPkuZJPJNOlwyazqLiA9Sa6dlZpc1AMdieDm7ljPDHaOmaSUi1gIOADaklDo4o95/NWWR55Enapn5/Br7DMqJ7vp6/77AZ0cdT9NfZp4FnNVx2HEU2R2na+rPanS7ZNa0lZkHjfsYOtbJzHATNU03nwNuoqwf+CLgjZQP01Mz8+LGsedOuor8NXC/xjGlUVkPuCIihovsZmbuMcZjaiYz3z7uY9BKr5OZ4XZ9alqJiEsz86H19mxK68DGXRSdjYiPAZszcQLD1dN1jI+ml0kDooNSZPdZmfmQMR1SUxFxFlPP1GtWjkTTS0TcQZkQE5RZ2X8aPMQIJ8TYoqbpZtFafZl5R0Rc29XKAJn50oh4GvCvddN5lK4kqffqah7bUFYJ2IvSLfjJ8R5VU68eur0GZf3W28d0LFoJZebsLuKYqGm6GdS+gon1r7qqkfS/lAkFgxPdyY3jSSskIh5IKTi7D/Ab4HhKb0unddW6lpmT61aeW7t9pV4xUdO00tUVzrCZeqLTtPETytqiT87MhQAR8crxHlJ7EbHu0N1ZwHaUdSmlXjFRk1bcjDzRadp4OvAs4KyIOA04jomz2aarBZQxakHp8rwGeOFYj0iagpMJpBUUEU+lnOh2piwfdRzwmczcdKwHJv0dIuLulEr9+1DW9zwG+PI0XwtT6j0TNWlEPNFpuoiIdSjjLPfOzF3GfTwtRMQBwLGZeXO9vw6lKPbHx3tk0kQmalIDM+FEJ63MIuLizNx60raLMnObcR2TNBUTNUnSjBMRlwIPGyyZVesu/ni61o3TysvJBJKkmeg04PiI+FS9/+K6TeoVW9QkSTNORMyiJGeDoQlnUCYB3TG+o5LuykRNkjQjRcRqwIMoZTquysy/LeMlUudM1CRJM05EPBo4mrKaSAAbAftl5tljPCzpLkzUJEkzTkQsAJ6dmVfV+w8EvpiZ2433yKSJZo37ACRJGoNVB0kaQGb+D7DqGI9HmpKzPiVJM9H8iPgM8Pl6/znA/DEejzQluz4lSTNORKwOHAA8sm46B/h4Zt42vqOS7spETZI0I0XEHIDMvHHcxyItiWPUJEkzRhRvi4jfAFcBV0XEjRHx1nEfmzQVEzVJ0kzySmBn4OGZuW5mrgvsAOwcEa8c76FJd2XXpyRpxoiIi4DHZeZvJm2fA5zuouzqG1vUJEkzyaqTkzRYNE7N8hzqHRM1SdJM8td/8DFpLOz6lCTNGBFxB/DHqR4C1shMW9XUKyZqkiRJPWXXpyRJUk+ZqEmSJPWUiZokSVJPmahJ0gqIiFXGfQySpi8TNUkzSkS8JSKuiojvR8QXI+LVEbFZRJwWEQsi4pyIeHB97mcj4qMRcV5E/Cwi9qzbH12fdwpwRd22b0ScHxEXR8SnImJ2/flsRFwWEZda+V7S38srQUkzRkQ8HHgGsBWluOmFwALgcOAlmXl1ROwAfBx4bH3ZfYFHAg8GTgFOqtu3BbbMzGsi4p+BvYGdM/NvEfFx4DnA5cCGmblljb92B29T0jRioiZpJtkZ+Gpm/gX4S0ScCqwB7AScGBGD560+9JqvZOadwBURsf7Q9vMz85p6exdgO+CCuo81gRuAU4H7R8RhwNeB09u8LUnTlYmapJluFnBzZm69hMdvG7odQ7f/OGn70Zn5hskvjoitgMcDLwGeCbxgxQ5X0kziGDVJM8m5wO4RsUZE3AN4MvAn4JqI2Asgiq3+zv2eCewZEfep+1g3Iu4XEesBszLzZODNlO5SSVputqhJmjEy84I6AeDHwK+BS4FbKOPJPhERb6aMXTsOuOTv2O8V9bWnR8Qs4G/AAcCfgaPqNoC7tLhJ0tK4hJSkGSUi7pGZf4iIuwFnA/tn5oXjPi5JmootapJmmsMjYgvKJIKjTdIk9ZktapIkST3lZAJJkqSeMlGTJEnqKRM1SZKknjJRkyRJ6ikTNUmSpJ76/x38DLu/tY6dAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "genres_counts_df = pd.DataFrame([genres_counts]).T.reset_index()\n",
    "genres_counts_df.columns = ['genres', 'count']\n",
    "genres_counts_df = genres_counts_df.sort_values(by='count', ascending=False)\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "sns.barplot(x='genres', y='count', data=genres_counts_df, palette='viridis')\n",
    "plt.xticks(rotation=90)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot above shows that `Drama` and `Comedy` are the two most popular movie genres. The least popular movie genres are `Westerns`, `IMAX`, and `Film-Noir`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parsing out year from movie title\n",
    "\n",
    "In our dataset, movie titles currently the year of release appended to it in brackets, e.g., `\"Toy Story (1995)\"`. We want to use the year of a movie's release as a feature, so let's parse it out from the title string and create a new `year` column for it.\n",
    "\n",
    "We can start with writing a function that parses out year from the title string. In the code below, `extract_year_from_title()` takes in the title and does the following:\n",
    "\n",
    "- generates a list by splitting out each word by spaces (e.g., `[\"Toy\", \"Story\", \"(1995)\"]`)\n",
    "- gets the last element of the list (e.g., `\"(1995)\"`)\n",
    "- if the last element has brackets surrounding it, these `()` brackets get stripped (e.g., `\"1995\"`)\n",
    "- converts the year into an integer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re \n",
    "\n",
    "def extract_year_from_title(title):\n",
    "    t = title.split(' ')\n",
    "    year = None\n",
    "    if re.search(r'\\(\\d+\\)', t[-1]):\n",
    "        year = t[-1].strip('()')\n",
    "        year = int(year)\n",
    "    return year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test out this function with our example of `\"Toy Story (1995)\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Year of release: 1995\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "title = \"Toy Story (1995)\"\n",
    "year = extract_year_from_title(title)\n",
    "print(f\"Year of release: {year}\")\n",
    "print(type(year))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our function `extract_year_from_title()` works! It's able to successfully parse out year from the title string as shown above. We can now apply this to all titles in our `movies` dataframe using Pandas' [apply()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html) method."
   ]
  },
  {
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "      <th>year</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",
       "      <td>1995.0</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",
       "      <td>1995.0</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",
       "      <td>1995.0</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",
       "      <td>1995.0</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",
       "      <td>1995.0</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    year  \n",
       "0  [Adventure, Animation, Children, Comedy, Fantasy]  1995.0  \n",
       "1                     [Adventure, Children, Fantasy]  1995.0  \n",
       "2                                  [Comedy, Romance]  1995.0  \n",
       "3                           [Comedy, Drama, Romance]  1995.0  \n",
       "4                                           [Comedy]  1995.0  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies['year'] = movies['title'].apply(extract_year_from_title)\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How many different years of release are covered in our dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "106"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies['year'].nunique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are over 100 years of release in our dataset. Let's collapse this down into decades to get a general sense of when movies were released in our dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What was the most popular decade of movie release?\n",
    "\n",
    "Before we begin, we'll remove all movies with null year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original number of movies: 9742\n"
     ]
    }
   ],
   "source": [
    "print(f\"Original number of movies: {movies['movieId'].nunique()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of movies after removing null years: 9718\n"
     ]
    }
   ],
   "source": [
    "movies = movies[~movies['year'].isnull()]\n",
    "print(f\"Number of movies after removing null years: {movies['movieId'].nunique()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We filtered out 24 movies that don't have a year of release. \n",
    "\n",
    "Now, there are two ways to get the decade of a year:\n",
    "\n",
    "1. converting year to string, replacing the fourth (last) number with a 0\n",
    "2. rounding year down to the nearest 10 \n",
    "\n",
    "We'll show both implementations in the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1990"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1995\n",
    "\n",
    "def get_decade(year):\n",
    "    year = str(year)\n",
    "    decade_prefix = year[0:3] # get first 3 digits of year\n",
    "    decade = f'{decade_prefix}0' # append 0 at the end\n",
    "    return int(decade)\n",
    "\n",
    "get_decade(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1990"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def round_down(year):\n",
    "    return year - (year%10)\n",
    "\n",
    "round_down(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two functions `get_decade()` and `round_down()` both accomplish the same thing: they both get the decade of a year.\n",
    "\n",
    "We can apply either of these functions to all years in our `movies` dataset. We'll use `round_down()` in this example to a create a new column called `'decade'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "movies['decade'] = movies['year'].apply(round_down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]),\n",
       " <a list of 12 Text xticklabel objects>)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "sns.countplot(movies['decade'], palette='Blues')\n",
    "plt.xticks(rotation=90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see from the plot above, the most common decade is the 2000s followed by the 1990s for movies in our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Transforming the Data\n",
    "\n",
    "In order to build a content-based filtering recommender, we need to set up our dataset so that rows represent movies and columns represent features (i.e., genres and decades).\n",
    "\n",
    "First, we need to manipulate the `genres` column so that each genre is represented as a separate binary feature. \"1\" indicates that the movie falls under a given genre, while \"0\" does not. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "genres = list(genres_counts.keys())\n",
    "\n",
    "for g in genres:\n",
    "    movies[g] = movies['genres'].transform(lambda x: int(g in x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at what the movie genres columns look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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>Adventure</th>\n",
       "      <th>Animation</th>\n",
       "      <th>Children</th>\n",
       "      <th>Comedy</th>\n",
       "      <th>Fantasy</th>\n",
       "      <th>Romance</th>\n",
       "      <th>Drama</th>\n",
       "      <th>Action</th>\n",
       "      <th>Crime</th>\n",
       "      <th>Thriller</th>\n",
       "      <th>Horror</th>\n",
       "      <th>Mystery</th>\n",
       "      <th>Sci-Fi</th>\n",
       "      <th>War</th>\n",
       "      <th>Musical</th>\n",
       "      <th>Documentary</th>\n",
       "      <th>IMAX</th>\n",
       "      <th>Western</th>\n",
       "      <th>Film-Noir</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</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>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",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</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>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",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</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>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",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</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>0</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>4</th>\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>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",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Adventure  Animation  Children  Comedy  Fantasy  Romance  Drama  Action  \\\n",
       "0          1          1         1       1        1        0      0       0   \n",
       "1          1          0         1       0        1        0      0       0   \n",
       "2          0          0         0       1        0        1      0       0   \n",
       "3          0          0         0       1        0        1      1       0   \n",
       "4          0          0         0       1        0        0      0       0   \n",
       "\n",
       "   Crime  Thriller  Horror  Mystery  Sci-Fi  War  Musical  Documentary  IMAX  \\\n",
       "0      0         0       0        0       0    0        0            0     0   \n",
       "1      0         0       0        0       0    0        0            0     0   \n",
       "2      0         0       0        0       0    0        0            0     0   \n",
       "3      0         0       0        0       0    0        0            0     0   \n",
       "4      0         0       0        0       0    0        0            0     0   \n",
       "\n",
       "   Western  Film-Noir  \n",
       "0        0          0  \n",
       "1        0          0  \n",
       "2        0          0  \n",
       "3        0          0  \n",
       "4        0          0  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies[genres].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Our genres columns are represented as binary feautres. The next step is to wrangle our `decade` column so that each decade has its own column. We can do this using pandas' [get_dummies()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.get_dummies.html) function, which works by creating a categorical variable into binary variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>1900.0</th>\n",
       "      <th>1910.0</th>\n",
       "      <th>1920.0</th>\n",
       "      <th>1930.0</th>\n",
       "      <th>1940.0</th>\n",
       "      <th>1950.0</th>\n",
       "      <th>1960.0</th>\n",
       "      <th>1970.0</th>\n",
       "      <th>1980.0</th>\n",
       "      <th>1990.0</th>\n",
       "      <th>2000.0</th>\n",
       "      <th>2010.0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</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>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</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>1</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>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>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>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   1900.0  1910.0  1920.0  1930.0  1940.0  1950.0  1960.0  1970.0  1980.0  \\\n",
       "0       0       0       0       0       0       0       0       0       0   \n",
       "1       0       0       0       0       0       0       0       0       0   \n",
       "2       0       0       0       0       0       0       0       0       0   \n",
       "3       0       0       0       0       0       0       0       0       0   \n",
       "4       0       0       0       0       0       0       0       0       0   \n",
       "\n",
       "   1990.0  2000.0  2010.0  \n",
       "0       1       0       0  \n",
       "1       1       0       0  \n",
       "2       1       0       0  \n",
       "3       1       0       0  \n",
       "4       1       0       0  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_decades = pd.get_dummies(movies['decade'])\n",
    "movie_decades.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's create a new `movie_features` dataframe by combining our genres features and decade features. We can do this using pandas' [concat](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.concat.html) function which concatenates (appends) genres and decades into a single dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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>Adventure</th>\n",
       "      <th>Animation</th>\n",
       "      <th>Children</th>\n",
       "      <th>Comedy</th>\n",
       "      <th>Fantasy</th>\n",
       "      <th>Romance</th>\n",
       "      <th>Drama</th>\n",
       "      <th>Action</th>\n",
       "      <th>Crime</th>\n",
       "      <th>Thriller</th>\n",
       "      <th>...</th>\n",
       "      <th>1920.0</th>\n",
       "      <th>1930.0</th>\n",
       "      <th>1940.0</th>\n",
       "      <th>1950.0</th>\n",
       "      <th>1960.0</th>\n",
       "      <th>1970.0</th>\n",
       "      <th>1980.0</th>\n",
       "      <th>1990.0</th>\n",
       "      <th>2000.0</th>\n",
       "      <th>2010.0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</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>...</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",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</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>...</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",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</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>...</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",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</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",
       "    <tr>\n",
       "      <th>4</th>\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>...</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",
       "<p>5 rows × 31 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Adventure  Animation  Children  Comedy  Fantasy  Romance  Drama  Action  \\\n",
       "0          1          1         1       1        1        0      0       0   \n",
       "1          1          0         1       0        1        0      0       0   \n",
       "2          0          0         0       1        0        1      0       0   \n",
       "3          0          0         0       1        0        1      1       0   \n",
       "4          0          0         0       1        0        0      0       0   \n",
       "\n",
       "   Crime  Thriller   ...    1920.0  1930.0  1940.0  1950.0  1960.0  1970.0  \\\n",
       "0      0         0   ...         0       0       0       0       0       0   \n",
       "1      0         0   ...         0       0       0       0       0       0   \n",
       "2      0         0   ...         0       0       0       0       0       0   \n",
       "3      0         0   ...         0       0       0       0       0       0   \n",
       "4      0         0   ...         0       0       0       0       0       0   \n",
       "\n",
       "   1980.0  1990.0  2000.0  2010.0  \n",
       "0       0       1       0       0  \n",
       "1       0       1       0       0  \n",
       "2       0       1       0       0  \n",
       "3       0       1       0       0  \n",
       "4       0       1       0       0  \n",
       "\n",
       "[5 rows x 31 columns]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_features = pd.concat([movies[genres], movie_decades], axis=1)\n",
    "movie_features.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our `movie_features` dataframe is ready. The next step is to start building our recommender. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Building a \"Similar Movies\" Recommender Using Cosine Similarity\n",
    "\n",
    "We're going to build our item-item recommender using a similarity metric called [cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity). \n",
    "\n",
    "Cosine similarity looks at the cosine angle between two vectors (e.g., $A$ and $B$). The smaller the cosine angle, the higher the degree of similarity between $A$ and $B$. You can calculate the similarity between $A$ and $B$ with this equation:\n",
    "\n",
    "$$\\cos(\\theta) = \\frac{A\\cdot B}{||A|| ||B||}$$\n",
    "\n",
    "In this tutorial, we're going to use scikit-learn's cosine similarity [function](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.cosine_similarity.html) to generate a cosine similarity matrix of shape $(n_{\\text{movies}}, n_{\\text{movies}})$. With this cosine similarity matrix, we'll be able to extract movies that are most similar to the movie of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions of our movie features cosine similarity matrix: (9718, 9718)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "cosine_sim = cosine_similarity(movie_features, movie_features)\n",
    "print(f\"Dimensions of our movie features cosine similarity matrix: {cosine_sim.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, after passing the `movie_features` 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": [
    "### Let's create a movie finder function\n",
    "\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": 23,
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jumanji (1995)'"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_idx = dict(zip(movies['title'], list(movies.index)))\n",
    "idx = movie_idx[title]\n",
    "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": 26,
   "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": 27,
   "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",
       "1618    NeverEnding Story II: The Next Chapter, The (1...\n",
       "8719                   The Cave of the Golden Rose (1991)\n",
       "9565                            Gulliver's Travels (1996)\n",
       "1357                                Borrowers, The (1997)\n",
       "1565                                     Tall Tale (1995)\n",
       "2539                We're Back! A Dinosaur's Story (1993)\n",
       "5624    Kirikou and the Sorceress (Kirikou et la sorci...\n",
       "5975    Asterix & Obelix vs. Caesar (Astérix et Obélix...\n",
       "Name: title, dtype: object"
      ]
     },
     "execution_count": 27,
     "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. \n",
    "\n",
    "We can test our recommender further with other movie titles. For your convenience, I've packaged the steps into a single function which takes in the movie title of interest and number of recommendations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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\"Recommendations for {title}:\")\n",
    "    print(movies['title'].iloc[similar_movies])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommendations for Aladdin (1992):\n",
      "1177                                      Hercules (1997)\n",
      "95                          Muppet Treasure Island (1996)\n",
      "673     Land Before Time III: The Time of the Great Gi...\n",
      "1757                                 Bug's Life, A (1998)\n",
      "3727                Ferngully: The Last Rainforest (1992)\n",
      "Name: title, dtype: object\n"
     ]
    }
   ],
   "source": [
    "get_content_based_recommendations('aladin', 5)"
   ]
  }
 ],
 "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
}