notebooks/2.Delving Deeper into Recommender Systems.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ba8ba306-f49d-46b8-8117-9a8b1cb4a8fb",
   "metadata": {},
   "source": [
    "# Delving Deeper into Recommender Systems\n",
    "\n",
    "**Author**: Elias Abou Haydar\n",
    "\n",
    "## Import necessary libraries\n",
    "This cell imports the required libraries for the code companion, including NumPy, Pandas, scikit-learn's cosine similarity, and the Surprise library for matrix factorization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d8d40c6f-b3ff-4b61-8eac-672a9b976759",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from surprise import Dataset, Reader, SVD, accuracy\n",
    "from surprise.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec5fe7a0-30bc-473d-90c3-f2cad7c608ba",
   "metadata": {},
   "source": [
    "## Load and preprocess the MovieLens 100K dataset\n",
    "In this cell, we load the MovieLens 100K dataset files (u.item and u.data) into Pandas DataFrames. We merge the movies and ratings DataFrames based on the movie_id column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36f6e7c6-d60f-46e2-ad8e-4f7a404346d5",
   "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>movie_id</th>\n",
       "      <th>title</th>\n",
       "      <th>user_id</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>308</td>\n",
       "      <td>4</td>\n",
       "      <td>887736532</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>287</td>\n",
       "      <td>5</td>\n",
       "      <td>875334088</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>148</td>\n",
       "      <td>4</td>\n",
       "      <td>877019411</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>280</td>\n",
       "      <td>4</td>\n",
       "      <td>891700426</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>66</td>\n",
       "      <td>3</td>\n",
       "      <td>883601324</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movie_id             title  user_id  rating  timestamp\n",
       "0         1  Toy Story (1995)      308       4  887736532\n",
       "1         1  Toy Story (1995)      287       5  875334088\n",
       "2         1  Toy Story (1995)      148       4  877019411\n",
       "3         1  Toy Story (1995)      280       4  891700426\n",
       "4         1  Toy Story (1995)       66       3  883601324"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the MovieLens 100K dataset\n",
    "movies = pd.read_csv('../data/ml-100k/u.item', sep='|', encoding='latin-1', header=None, usecols=[0, 1],\n",
    "                     names=['movie_id', 'title'])\n",
    "ratings = pd.read_csv('../data/ml-100k/u.data', sep='\\t', header=None,\n",
    "                      names=['user_id', 'movie_id', 'rating', 'timestamp'])\n",
    "\n",
    "# Merge movies and ratings dataframes\n",
    "df = pd.merge(movies, ratings, on='movie_id')\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36994b6e-e861-496e-bc9e-6c77648db4f4",
   "metadata": {},
   "source": [
    "## User-Based Collaborative Filtering\n",
    "\n",
    "This cell defines the user_based_cf function that implements User-Based Collaborative Filtering. It finds similar users based on their rating patterns using cosine similarity and recommends movies that similar users have rated highly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2c72fe61-dc45-4bc5-9de3-fee98ef963f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# User-Based Collaborative Filtering\n",
    "def user_based_cf(user_id, n_recommendations):\n",
    "    user_item_matrix = df.pivot_table(index='user_id', columns='movie_id', values='rating')\n",
    "    user_similarity = cosine_similarity(user_item_matrix.fillna(0))\n",
    "    \n",
    "    user_index = user_id - 1\n",
    "    similar_users = user_similarity[user_index].argsort()[::-1][1:]\n",
    "    \n",
    "    recommendations = []\n",
    "    for user in similar_users:\n",
    "        user_recommendations = user_item_matrix.iloc[user].dropna().sort_values(ascending=False)\n",
    "        recommendations.extend(user_recommendations.index)\n",
    "        if len(recommendations) >= n_recommendations:\n",
    "            break\n",
    "    \n",
    "    recommended_movies = movies[movies['movie_id'].isin(recommendations[:n_recommendations])]\n",
    "    return recommended_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54c9bd8c-bb74-47cf-85ab-fed8b344f932",
   "metadata": {},
   "source": [
    "## Item-Based Collaborative Filtering\n",
    "The item_based_cf function in this cell implements Item-Based Collaborative Filtering. It finds similar movies based on user ratings using cosine similarity and recommends movies that are similar to the given movie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6f956eb-8694-4190-9a81-fd37bf4467fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Item-Based Collaborative Filtering\n",
    "def item_based_cf(movie_id, n_recommendations):\n",
    "    movie_user_matrix = df.pivot_table(index='movie_id', columns='user_id', values='rating')\n",
    "    item_similarity = cosine_similarity(movie_user_matrix.fillna(0))\n",
    "    \n",
    "    movie_index = movie_id - 1\n",
    "    similar_movies = item_similarity[movie_index].argsort()[::-1][1:]\n",
    "    \n",
    "    recommended_movies = movies[movies['movie_id'].isin(similar_movies[:n_recommendations])]\n",
    "    return recommended_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7600c776-541b-4438-be81-895caf3be17c",
   "metadata": {},
   "source": [
    "## Matrix Factorization (SVD)\n",
    "This cell defines the matrix_factorization function that uses the Singular Value Decomposition (SVD) algorithm from the Surprise library to factorize the user-item matrix and make recommendations based on the predicted ratings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c5cc1257-2021-48c0-baa7-3ea55c96dc74",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Matrix Factorization (SVD)\n",
    "def matrix_factorization(user_id, n_recommendations):\n",
    "    reader = Reader(rating_scale=(1, 5))\n",
    "    data = Dataset.load_from_df(df[['user_id', 'movie_id', 'rating']], reader)\n",
    "    trainset, testset = train_test_split(data, test_size=0.2)\n",
    "    \n",
    "    algo = SVD()\n",
    "    algo.fit(trainset)\n",
    "    \n",
    "    user_ratings = df[df['user_id'] == user_id][['movie_id', 'rating']]\n",
    "    user_ratings['pred_rating'] = user_ratings['movie_id'].apply(lambda x: algo.predict(user_id, x).est)\n",
    "    user_ratings = user_ratings.sort_values(by='pred_rating', ascending=False)\n",
    "    \n",
    "    recommended_movies = movies[movies['movie_id'].isin(user_ratings['movie_id'][:n_recommendations])]\n",
    "    return recommended_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92b92087-44ce-4ed5-9fab-b7a146c96a43",
   "metadata": {},
   "source": [
    "## Example usage\n",
    "In this cell, we provide example usage of the three recommender system functions. We specify a user_id, movie_id, and the desired number of recommendations (n_recommendations). We call each recommender system function and prints the recommended movies for the given user or movie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "07e83ded-1b5e-4391-b71c-25b19152bba1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User-Based Collaborative Filtering:\n"
     ]
    },
    {
     "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>movie_id</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>51</th>\n",
       "      <td>52</td>\n",
       "      <td>Madness of King George, The (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>56</td>\n",
       "      <td>Pulp Fiction (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>57</th>\n",
       "      <td>58</td>\n",
       "      <td>Quiz Show (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>89</td>\n",
       "      <td>Blade Runner (1982)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>173</th>\n",
       "      <td>174</td>\n",
       "      <td>Raiders of the Lost Ark (1981)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     movie_id                               title\n",
       "51         52  Madness of King George, The (1994)\n",
       "55         56                 Pulp Fiction (1994)\n",
       "57         58                    Quiz Show (1994)\n",
       "88         89                 Blade Runner (1982)\n",
       "173       174      Raiders of the Lost Ark (1981)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example usage\n",
    "user_id = 1\n",
    "movie_id = 1\n",
    "n_recommendations = 5\n",
    "\n",
    "print(\"User-Based Collaborative Filtering:\")\n",
    "user_based_cf(user_id, n_recommendations).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fd457c45-f440-4385-8e99-347365013fc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Item-Based Collaborative Filtering:\n"
     ]
    },
    {
     "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>movie_id</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>49</td>\n",
       "      <td>I.Q. (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>115</th>\n",
       "      <td>116</td>\n",
       "      <td>Cold Comfort Farm (1995)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>119</th>\n",
       "      <td>120</td>\n",
       "      <td>Striptease (1996)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>179</th>\n",
       "      <td>180</td>\n",
       "      <td>Apocalypse Now (1979)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>403</th>\n",
       "      <td>404</td>\n",
       "      <td>Pinocchio (1940)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     movie_id                     title\n",
       "48         49               I.Q. (1994)\n",
       "115       116  Cold Comfort Farm (1995)\n",
       "119       120         Striptease (1996)\n",
       "179       180     Apocalypse Now (1979)\n",
       "403       404          Pinocchio (1940)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\nItem-Based Collaborative Filtering:\")\n",
    "item_based_cf(movie_id, n_recommendations).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "43477330-785a-49a8-a13a-386a92cd8d2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Matrix Factorization (SVD):\n"
     ]
    },
    {
     "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>movie_id</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>50</td>\n",
       "      <td>Star Wars (1977)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>64</td>\n",
       "      <td>Shawshank Redemption, The (1994)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>171</th>\n",
       "      <td>172</td>\n",
       "      <td>Empire Strikes Back, The (1980)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>173</th>\n",
       "      <td>174</td>\n",
       "      <td>Raiders of the Lost Ark (1981)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>198</td>\n",
       "      <td>Nikita (La Femme Nikita) (1990)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     movie_id                             title\n",
       "49         50                  Star Wars (1977)\n",
       "63         64  Shawshank Redemption, The (1994)\n",
       "171       172   Empire Strikes Back, The (1980)\n",
       "173       174    Raiders of the Lost Ark (1981)\n",
       "197       198   Nikita (La Femme Nikita) (1990)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\nMatrix Factorization (SVD):\")\n",
    "matrix_factorization(user_id, n_recommendations).head()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}