diff --git a/analytics_small.ipynb b/analytics_small.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b6f7494f9dcd736b78efecb0128a9476936d4754 --- /dev/null +++ b/analytics_small.ipynb @@ -0,0 +1,731 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Display The Movies : \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>title</th>\n", + " <th>genres</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>3</th>\n", + " <td>Grumpier Old Men (1995)</td>\n", + " <td>Comedy|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>15</th>\n", + " <td>Cutthroat Island (1995)</td>\n", + " <td>Action|Adventure|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>34</th>\n", + " <td>Babe (1995)</td>\n", + " <td>Children|Drama</td>\n", + " </tr>\n", + " <tr>\n", + " <th>59</th>\n", + " <td>Confessional, The (Confessionnal, Le) (1995)</td>\n", + " <td>Drama|Mystery</td>\n", + " </tr>\n", + " <tr>\n", + " <th>64</th>\n", + " <td>Two if by Sea (1996)</td>\n", + " <td>Comedy|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>148652</th>\n", + " <td>The Ridiculous 6 (2015)</td>\n", + " <td>Comedy|Western</td>\n", + " </tr>\n", + " <tr>\n", + " <th>151307</th>\n", + " <td>The Lovers and the Despot</td>\n", + " <td>(no genres listed)</td>\n", + " </tr>\n", + " <tr>\n", + " <th>152173</th>\n", + " <td>Michael Jackson's Thriller (1983)</td>\n", + " <td>Horror</td>\n", + " </tr>\n", + " <tr>\n", + " <th>160440</th>\n", + " <td>The Maid's Room (2014)</td>\n", + " <td>Thriller</td>\n", + " </tr>\n", + " <tr>\n", + " <th>160656</th>\n", + " <td>Tallulah (2016)</td>\n", + " <td>Drama</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>912 rows × 2 columns</p>\n", + "</div>" + ], + "text/plain": [ + " title \\\n", + "movieId \n", + "3 Grumpier Old Men (1995) \n", + "15 Cutthroat Island (1995) \n", + "34 Babe (1995) \n", + "59 Confessional, The (Confessionnal, Le) (1995) \n", + "64 Two if by Sea (1996) \n", + "... ... \n", + "148652 The Ridiculous 6 (2015) \n", + "151307 The Lovers and the Despot \n", + "152173 Michael Jackson's Thriller (1983) \n", + "160440 The Maid's Room (2014) \n", + "160656 Tallulah (2016) \n", + "\n", + " genres \n", + "movieId \n", + "3 Comedy|Romance \n", + "15 Action|Adventure|Romance \n", + "34 Children|Drama \n", + "59 Drama|Mystery \n", + "64 Comedy|Romance \n", + "... ... \n", + "148652 Comedy|Western \n", + "151307 (no genres listed) \n", + "152173 Horror \n", + "160440 Thriller \n", + "160656 Drama \n", + "\n", + "[912 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Display The Ratings : \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>userId</th>\n", + " <th>movieId</th>\n", + " <th>rating</th>\n", + " <th>timestamp</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>15</td>\n", + " <td>34</td>\n", + " <td>3.0</td>\n", + " <td>997938310</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>15</td>\n", + " <td>95</td>\n", + " <td>1.5</td>\n", + " <td>1093028331</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>15</td>\n", + " <td>101</td>\n", + " <td>4.0</td>\n", + " <td>1134522072</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>15</td>\n", + " <td>123</td>\n", + " <td>4.0</td>\n", + " <td>997938358</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>15</td>\n", + " <td>125</td>\n", + " <td>3.5</td>\n", + " <td>1245362506</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5291</th>\n", + " <td>665</td>\n", + " <td>3908</td>\n", + " <td>1.0</td>\n", + " <td>1046967201</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5292</th>\n", + " <td>665</td>\n", + " <td>4052</td>\n", + " <td>4.0</td>\n", + " <td>992838277</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5293</th>\n", + " <td>665</td>\n", + " <td>4351</td>\n", + " <td>4.0</td>\n", + " <td>992837743</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5294</th>\n", + " <td>665</td>\n", + " <td>4643</td>\n", + " <td>4.0</td>\n", + " <td>997239207</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5295</th>\n", + " <td>665</td>\n", + " <td>5502</td>\n", + " <td>4.0</td>\n", + " <td>1046967596</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>5296 rows × 4 columns</p>\n", + "</div>" + ], + "text/plain": [ + " userId movieId rating timestamp\n", + "0 15 34 3.0 997938310\n", + "1 15 95 1.5 1093028331\n", + "2 15 101 4.0 1134522072\n", + "3 15 123 4.0 997938358\n", + "4 15 125 3.5 1245362506\n", + "... ... ... ... ...\n", + "5291 665 3908 1.0 1046967201\n", + "5292 665 4052 4.0 992838277\n", + "5293 665 4351 4.0 992837743\n", + "5294 665 4643 4.0 997239207\n", + "5295 665 5502 4.0 1046967596\n", + "\n", + "[5296 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Reload modules automatically before entering the execution of code\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "# Third-party imports\n", + "import numpy as np \n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from scipy.sparse import csr_matrix\n", + "\n", + "# Constants and functions\n", + "from constants import Constant as C\n", + "from loaders import load_ratings\n", + "from loaders import load_items\n", + "from tabulate import tabulate\n", + "\n", + "# Call the load_items() function and create a variable df_items\n", + "df_movies = load_items()\n", + "\n", + "# Display the DataFrame\n", + "print(\"Display The Movies : \")\n", + "display(df_movies)\n", + "\n", + "# Call the load_ratings() function and create a variable df_ratings\n", + "df_ratings = load_ratings()\n", + "\n", + "# Display the DataFrame\n", + "print(\"Display The Ratings : \")\n", + "display(df_ratings)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of movies: 912\n" + ] + } + ], + "source": [ + "# NUMBER OF MOVIES\n", + "n_movies = df_movies['title'].nunique()\n", + "print(f\"Number of movies: {n_movies}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minimum range: 1921\n", + "Maximum range: 2016\n" + ] + } + ], + "source": [ + "# THE YEAR RANGE\n", + "df_movies['annee'] = df_movies['title'].str.extract(r'\\((.{4})\\)')\n", + "df_movies['annee'] = pd.to_numeric(df_movies['annee'], errors='coerce')\n", + "\n", + "min_range = int(df_movies['annee'].min())\n", + "max_range = int(df_movies['annee'].max())\n", + "print(\"Minimum range:\", min_range)\n", + "print(\"Maximum range:\", max_range)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "List of all genres:\n", + "(no genres listed) |\n", + "Action |\n", + "Adventure |\n", + "Animation |\n", + "Children |\n", + "Comedy |\n", + "Crime |\n", + "Documentary |\n", + "Drama |\n", + "Fantasy |\n", + "Film-Noir |\n", + "Horror |\n", + "IMAX |\n", + "Musical |\n", + "Mystery |\n", + "Romance |\n", + "Sci-Fi |\n", + "Thriller |\n", + "War |\n", + "Western |\n" + ] + } + ], + "source": [ + "# LIST OF MOVIE GENRES\n", + "def tabulate_genres(df_movies):\n", + " \"\"\"Tabulate list of movie genres.\"\"\"\n", + " # Split genres and explode\n", + " df_movies['genres'] = df_movies['genres'].str.split('|')\n", + " df_movies = df_movies.explode('genres')\n", + " unique_genres = sorted(df_movies['genres'].unique())\n", + "\n", + " # Tabulate\n", + " print(\"\\nList of all genres:\")\n", + " genres_table = [[genre, \"|\"] for genre in unique_genres]\n", + " print(tabulate(genres_table, tablefmt=\"plain\", numalign=\"left\"))\n", + "\n", + "# Call the tabulate_genres function\n", + "tabulate_genres(df_movies)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings: 5296\n" + ] + } + ], + "source": [ + "# THE TOTAL NUMBER OF RATINGS\n", + "n_ratings = df_ratings['rating'].count()\n", + "print(f\"Number of ratings: {n_ratings}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of users: 107\n" + ] + } + ], + "source": [ + "# THE NUMBER OF UNIQUE USERS\n", + "n_users = df_ratings['userId'].nunique()\n", + "print(f\"Number of users: {n_users}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of unique movies : 834\n" + ] + } + ], + "source": [ + "# THE NUMBER OF UNIQUE MOVIES (IN THE RATING MATRIX)\n", + "unique_movies = df_ratings[\"movieId\"].unique()\n", + "num_unique_movies = len(unique_movies)\n", + "print(f\"Number of unique movies : {num_unique_movies}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings of the most rated movie(s): 75\n" + ] + } + ], + "source": [ + "# THE NUMBER OF RATINGS OF THE MOST RATED MOVIES\n", + "def most_rated_movies_ratings_count(df_ratings):\n", + " movie_ratings_count = df_ratings.groupby('movieId')['rating'].count()\n", + " most_rated_movies = movie_ratings_count[movie_ratings_count == movie_ratings_count.max()]\n", + " print(f\"Number of ratings of the most rated movie(s): {most_rated_movies.max()}\")\n", + "\n", + "most_rated_movies_ratings_count(df_ratings)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings of the least rated movie(s): 1\n" + ] + } + ], + "source": [ + "# THE NUMBER OF RATINGS OF THE LESS RATED MOVIES\n", + "def least_rated_movies_ratings_count(df_ratings):\n", + " movie_ratings_count = df_ratings.groupby('movieId')['rating'].count()\n", + " least_rated_movies = movie_ratings_count[movie_ratings_count == movie_ratings_count.min()]\n", + " print(\"Number of ratings of the least rated movie(s):\", least_rated_movies.min())\n", + "\n", + "least_rated_movies_ratings_count(df_ratings)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All possible rating values, from smallest to highest:\n", + "0.5\n", + "1.0\n", + "1.5\n", + "2.0\n", + "2.5\n", + "3.0\n", + "3.5\n", + "4.0\n", + "4.5\n", + "5.0\n" + ] + } + ], + "source": [ + "# ALL THE POSSIBLE RATING VALUES; FROM THE SMALLEST VALUE TO THE VALUE HIGHEST\n", + "def all_possible_ratings(df_ratings):\n", + " rating_values = sorted(df_ratings['rating'].unique())\n", + " print(\"All possible rating values, from smallest to highest:\")\n", + " for rating in rating_values:\n", + " print(rating)\n", + "\n", + "all_possible_ratings(df_ratings)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of movies that were not rated at all: 78\n" + ] + } + ], + "source": [ + "# THE NUMBER OF MOVIES THAT WERE NOT RATED AT ALL\n", + "def unrated_movies_count(df_ratings, df_movies):\n", + " rated_movies = df_ratings['movieId'].unique() if 'movieId' in df_ratings.columns else []\n", + " unrated_movies_count = df_movies[~df_movies.index.isin(rated_movies)].shape[0]\n", + " print(\"Number of movies that were not rated at all:\", unrated_movies_count)\n", + "\n", + "unrated_movies_count(df_ratings, df_movies)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "LONG-TAIL PROPERTY" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 2000x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Rating Frequency Distribution\n", + "merged_df = pd.merge(df_ratings,df_movies, on='movieId')\n", + "rating_counts = merged_df['movieId'].value_counts()\n", + "value_counts = rating_counts.value_counts().sort_index()\n", + "\n", + "plt.figure(figsize=(20, 6))\n", + "plt.plot(value_counts.values, value_counts.index, marker='o', color='skyblue', linestyle='-') # Swap x and y arguments\n", + "plt.title('Rating Frequency Distribution')\n", + "plt.xlabel('Number of Movies') # Update x-label\n", + "plt.ylabel('Number of Ratings') # Update y-label\n", + "plt.xticks(rotation=45)\n", + "plt.grid(axis='x', linestyle='--', alpha=0.7) # Change grid to x-axis\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "M = df_ratings['userId'].nunique()\n", + "N = df_ratings['movieId'].nunique()\n", + "user_mapper = dict(zip(np.unique(df_ratings[\"userId\"]), list(range(M))))\n", + "movie_mapper = dict(zip(np.unique(df_ratings[\"movieId\"]), list(range(N))))\n", + "user_inv_mapper = dict(zip(list(range(M)), np.unique(df_ratings[\"userId\"])))\n", + "movie_inv_mapper = dict(zip(list(range(N)), np.unique(df_ratings[\"movieId\"])))\n", + "user_index = [user_mapper[i] for i in df_ratings['userId']]\n", + "item_index = [movie_mapper[i] for i in df_ratings['movieId']]\n", + "X = csr_matrix((df_ratings[\"rating\"], (user_index,item_index)), shape=(M,N))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "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", + "# Assuming df_ratings contains your ratings dataframe\n", + "\n", + "X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper = create_X(df_ratings)\n", + "\n", + "# Extract the 100 first users and 100 first items\n", + "X_sub = X[:100, :100]\n", + "\n", + "# Plot the non-zero values of the sparse matrix\n", + "plt.figure(figsize=(8, 6))\n", + "plt.spy(X_sub, markersize=1)\n", + "plt.title('Non-zero values of a sparse matrix')\n", + "plt.xlabel('Movie Index')\n", + "plt.ylabel('User Index')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix sparsity: 5.93%\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)}%\")" + ] + } + ], + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analytics_tiny.ipynb b/analytics_tiny.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..cbd97046779ac36eb9182155f2bcc573b94b1ec6 --- /dev/null +++ b/analytics_tiny.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Display The Movies : \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>movieId</th>\n", + " <th>title</th>\n", + " <th>genres</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>3</td>\n", + " <td>Grumpier Old Men (1995)</td>\n", + " <td>Comedy|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>15</td>\n", + " <td>Cutthroat Island (1995)</td>\n", + " <td>Action|Adventure|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>34</td>\n", + " <td>Babe (1995)</td>\n", + " <td>Children|Drama</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>59</td>\n", + " <td>Confessional, The (Confessionnal, Le) (1995)</td>\n", + " <td>Drama|Mystery</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>64</td>\n", + " <td>Two if by Sea (1996)</td>\n", + " <td>Comedy|Romance</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>907</th>\n", + " <td>148652</td>\n", + " <td>The Ridiculous 6 (2015)</td>\n", + " <td>Comedy|Western</td>\n", + " </tr>\n", + " <tr>\n", + " <th>908</th>\n", + " <td>151307</td>\n", + " <td>The Lovers and the Despot</td>\n", + " <td>(no genres listed)</td>\n", + " </tr>\n", + " <tr>\n", + " <th>909</th>\n", + " <td>152173</td>\n", + " <td>Michael Jackson's Thriller (1983)</td>\n", + " <td>Horror</td>\n", + " </tr>\n", + " <tr>\n", + " <th>910</th>\n", + " <td>160440</td>\n", + " <td>The Maid's Room (2014)</td>\n", + " <td>Thriller</td>\n", + " </tr>\n", + " <tr>\n", + " <th>911</th>\n", + " <td>160656</td>\n", + " <td>Tallulah (2016)</td>\n", + " <td>Drama</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>912 rows × 3 columns</p>\n", + "</div>" + ], + "text/plain": [ + " movieId title \\\n", + "0 3 Grumpier Old Men (1995) \n", + "1 15 Cutthroat Island (1995) \n", + "2 34 Babe (1995) \n", + "3 59 Confessional, The (Confessionnal, Le) (1995) \n", + "4 64 Two if by Sea (1996) \n", + ".. ... ... \n", + "907 148652 The Ridiculous 6 (2015) \n", + "908 151307 The Lovers and the Despot \n", + "909 152173 Michael Jackson's Thriller (1983) \n", + "910 160440 The Maid's Room (2014) \n", + "911 160656 Tallulah (2016) \n", + "\n", + " genres \n", + "0 Comedy|Romance \n", + "1 Action|Adventure|Romance \n", + "2 Children|Drama \n", + "3 Drama|Mystery \n", + "4 Comedy|Romance \n", + ".. ... \n", + "907 Comedy|Western \n", + "908 (no genres listed) \n", + "909 Horror \n", + "910 Thriller \n", + "911 Drama \n", + "\n", + "[912 rows x 3 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Display The Ratings : \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>userId</th>\n", + " <th>movieId</th>\n", + " <th>rating</th>\n", + " <th>timestamp</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>15</td>\n", + " <td>34</td>\n", + " <td>3.0</td>\n", + " <td>997938310</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>15</td>\n", + " <td>95</td>\n", + " <td>1.5</td>\n", + " <td>1093028331</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>15</td>\n", + " <td>101</td>\n", + " <td>4.0</td>\n", + " <td>1134522072</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>15</td>\n", + " <td>123</td>\n", + " <td>4.0</td>\n", + " <td>997938358</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>15</td>\n", + " <td>125</td>\n", + " <td>3.5</td>\n", + " <td>1245362506</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5291</th>\n", + " <td>665</td>\n", + " <td>3908</td>\n", + " <td>1.0</td>\n", + " <td>1046967201</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5292</th>\n", + " <td>665</td>\n", + " <td>4052</td>\n", + " <td>4.0</td>\n", + " <td>992838277</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5293</th>\n", + " <td>665</td>\n", + " <td>4351</td>\n", + " <td>4.0</td>\n", + " <td>992837743</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5294</th>\n", + " <td>665</td>\n", + " <td>4643</td>\n", + " <td>4.0</td>\n", + " <td>997239207</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5295</th>\n", + " <td>665</td>\n", + " <td>5502</td>\n", + " <td>4.0</td>\n", + " <td>1046967596</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>5296 rows × 4 columns</p>\n", + "</div>" + ], + "text/plain": [ + " userId movieId rating timestamp\n", + "0 15 34 3.0 997938310\n", + "1 15 95 1.5 1093028331\n", + "2 15 101 4.0 1134522072\n", + "3 15 123 4.0 997938358\n", + "4 15 125 3.5 1245362506\n", + "... ... ... ... ...\n", + "5291 665 3908 1.0 1046967201\n", + "5292 665 4052 4.0 992838277\n", + "5293 665 4351 4.0 992837743\n", + "5294 665 4643 4.0 997239207\n", + "5295 665 5502 4.0 1046967596\n", + "\n", + "[5296 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Reload modules automatically before entering the execution of code\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "# Third-party imports\n", + "import numpy as np \n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from scipy.sparse import csr_matrix\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "# Constants and functions\n", + "from constants import Constant as C\n", + "\n", + "# We use a pd.read_csv() so importing the loaders is not necessary\n", + "# from loaders import load_ratings \n", + "# from loaders import load_items\n", + "\n", + "from tabulate import tabulate\n", + "\n", + "# Call the load_items() function and create a variable df_items\n", + "df_movies = pd.read_csv(\"data/tiny/content/movies.csv\")\n", + "\n", + "# Display the DataFrame\n", + "print(\"Display The Movies : \")\n", + "display(df_movies)\n", + "\n", + "# Call the load_ratings() function and create a variable df_ratings\n", + "df_ratings = pd.read_csv(\"data/tiny/evidence/ratings.csv\")\n", + "\n", + "# Display the DataFrame\n", + "print(\"Display The Ratings : \")\n", + "display(df_ratings)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of movies: 912\n" + ] + } + ], + "source": [ + "# NUMBER OF MOVIES\n", + "n_movies = df_movies['title'].nunique()\n", + "print(f\"Number of movies: {n_movies}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minimum range: 1921\n", + "Maximum range: 2016\n" + ] + } + ], + "source": [ + "# THE YEAR RANGE\n", + "df_movies['annee'] = df_movies['title'].str.extract(r'\\((.{4})\\)')\n", + "df_movies['annee'] = pd.to_numeric(df_movies['annee'], errors='coerce')\n", + "\n", + "min_range = int(df_movies['annee'].min())\n", + "max_range = int(df_movies['annee'].max())\n", + "print(\"Minimum range:\", min_range)\n", + "print(\"Maximum range:\", max_range)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "List of all genres:\n", + "(no genres listed) |\n", + "Action |\n", + "Adventure |\n", + "Animation |\n", + "Children |\n", + "Comedy |\n", + "Crime |\n", + "Documentary |\n", + "Drama |\n", + "Fantasy |\n", + "Film-Noir |\n", + "Horror |\n", + "IMAX |\n", + "Musical |\n", + "Mystery |\n", + "Romance |\n", + "Sci-Fi |\n", + "Thriller |\n", + "War |\n", + "Western |\n" + ] + } + ], + "source": [ + "# LIST OF MOVIE GENRES\n", + "def tabulate_genres(df_movies):\n", + " \"\"\"Tabulate list of movie genres.\"\"\"\n", + " # Split genres and explode\n", + " df_movies['genres'] = df_movies['genres'].str.split('|')\n", + " df_movies = df_movies.explode('genres')\n", + " unique_genres = sorted(df_movies['genres'].unique())\n", + "\n", + " # Tabulate\n", + " print(\"\\nList of all genres:\")\n", + " genres_table = [[genre, \"|\"] for genre in unique_genres]\n", + " print(tabulate(genres_table, tablefmt=\"plain\", numalign=\"left\"))\n", + "\n", + "# Call the tabulate_genres function\n", + "tabulate_genres(df_movies)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings: 5296\n" + ] + } + ], + "source": [ + "# THE TOTAL NUMBER OF RATINGS\n", + "n_ratings = df_ratings['rating'].count()\n", + "print(f\"Number of ratings: {n_ratings}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of users: 107\n" + ] + } + ], + "source": [ + "# THE NUMBER OF UNIQUE USERS\n", + "n_users = df_ratings['userId'].nunique()\n", + "print(f\"Number of users: {n_users}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of unique movies : 834\n" + ] + } + ], + "source": [ + "# THE NUMBER OF UNIQUE MOVIES (IN THE RATING MATRIX)\n", + "unique_movies = df_ratings[\"movieId\"].unique()\n", + "num_unique_movies = len(unique_movies)\n", + "print(f\"Number of unique movies : {num_unique_movies}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings of the most rated movie(s): 75\n" + ] + } + ], + "source": [ + "# THE NUMBER OF RATINGS OF THE MOST RATED MOVIES\n", + "def most_rated_movies_ratings_count(df_ratings):\n", + " movie_ratings_count = df_ratings.groupby('movieId')['rating'].count()\n", + " most_rated_movies = movie_ratings_count[movie_ratings_count == movie_ratings_count.max()]\n", + " print(f\"Number of ratings of the most rated movie(s): {most_rated_movies.max()}\")\n", + "\n", + "most_rated_movies_ratings_count(df_ratings)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of ratings of the least rated movie(s): 1\n" + ] + } + ], + "source": [ + "# THE NUMBER OF RATINGS OF THE LESS RATED MOVIES\n", + "def least_rated_movies_ratings_count(df_ratings):\n", + " movie_ratings_count = df_ratings.groupby('movieId')['rating'].count()\n", + " least_rated_movies = movie_ratings_count[movie_ratings_count == movie_ratings_count.min()]\n", + " print(\"Number of ratings of the least rated movie(s):\", least_rated_movies.min())\n", + "\n", + "least_rated_movies_ratings_count(df_ratings)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All possible rating values, from smallest to highest:\n", + "0.5\n", + "1.0\n", + "1.5\n", + "2.0\n", + "2.5\n", + "3.0\n", + "3.5\n", + "4.0\n", + "4.5\n", + "5.0\n" + ] + } + ], + "source": [ + "# ALL THE POSSIBLE RATING VALUES; FROM THE SMALLEST VALUE TO THE VALUE HIGHEST\n", + "def all_possible_ratings(df_ratings):\n", + " rating_values = sorted(df_ratings['rating'].unique())\n", + " print(\"All possible rating values, from smallest to highest:\")\n", + " for rating in rating_values:\n", + " print(rating)\n", + "\n", + "all_possible_ratings(df_ratings)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of movies that were not rated at all: 846\n" + ] + } + ], + "source": [ + "# THE NUMBER OF MOVIES THAT WERE NOT RATED AT ALL\n", + "def unrated_movies_count(df_ratings, df_movies):\n", + " rated_movies = df_ratings['movieId'].unique() if 'movieId' in df_ratings.columns else []\n", + " unrated_movies_count = df_movies[~df_movies.index.isin(rated_movies)].shape[0]\n", + " print(\"Number of movies that were not rated at all:\", unrated_movies_count)\n", + "\n", + "unrated_movies_count(df_ratings, df_movies)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LONG-TAIL PROPERTY" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 2000x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Rating Frequency Distribution\n", + "merged_df = pd.merge(df_ratings,df_movies, on='movieId')\n", + "rating_counts = merged_df['movieId'].value_counts()\n", + "value_counts = rating_counts.value_counts().sort_index()\n", + "\n", + "plt.figure(figsize=(20, 6))\n", + "plt.plot(value_counts.values, value_counts.index, marker='o', color='skyblue', linestyle='-') # Swap x and y arguments\n", + "plt.title('Rating Frequency Distribution')\n", + "plt.xlabel('Number of Movies') # Update x-label\n", + "plt.ylabel('Number of Ratings') # Update y-label\n", + "plt.xticks(rotation=45)\n", + "plt.grid(axis='x', linestyle='--', alpha=0.7) # Change grid to x-axis\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "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", + "# Assuming df_ratings contains your ratings dataframe\n", + "\n", + "X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper = create_X(df_ratings)\n", + "\n", + "# Extract the 100 first users and 100 first items\n", + "X_sub = X[:100, :100]\n", + "\n", + "# Plot the non-zero values of the sparse matrix\n", + "plt.figure(figsize=(8, 6))\n", + "plt.spy(X_sub, markersize=1)\n", + "plt.title('Non-zero values of a sparse matrix')\n", + "plt.xlabel('Movie Index')\n", + "plt.ylabel('User Index')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix sparsity: 5.93%\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)}%\")" + ] + } + ], + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/evaluator.ipynb b/evaluator.ipynb deleted file mode 100644 index b88bfe44a4e7d2898edb216abecfd1b673f059b6..0000000000000000000000000000000000000000 --- a/evaluator.ipynb +++ /dev/null @@ -1,460 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "a665885b", - "metadata": {}, - "source": [ - "# Evaluator Module\n", - "The Evaluator module creates evaluation reports.\n", - "\n", - "Reports contain evaluation metrics depending on models specified in the evaluation config." - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "id": "6aaf9140", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "# reloads modules automatically before entering the execution of code\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "# imports\n", - "import numpy as np \n", - "import pandas as pd\n", - "\n", - "# local imports\n", - "from configs import EvalConfig\n", - "from constants import Constant as C\n", - "from loaders import export_evaluation_report\n", - "from loaders import load_ratings\n", - "\n", - "# New imports\n", - "from surprise.model_selection import train_test_split\n", - "from surprise import accuracy\n", - "from surprise.model_selection import LeaveOneOut\n", - "from collections import Counter" - ] - }, - { - "cell_type": "markdown", - "id": "d47c24a4", - "metadata": {}, - "source": [ - "# 1. Model validation functions\n", - "Validation functions are a way to perform crossvalidation on recommender system models. " - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "id": "d6d82188", - "metadata": {}, - "outputs": [], - "source": [ - "# -- implement the function generate_split_predictions --\n", - "def generate_split_predictions(algo, ratings_dataset, eval_config):\n", - " \"\"\"Generate predictions on a random test set specified in eval_config\"\"\"\n", - " \n", - " # Spliting the data into train and test sets\n", - " trainset, testset = train_test_split(ratings_dataset, test_size=eval_config.test_size)\n", - "\n", - " # Training the algorithm on the train data set\n", - " algo.fit(trainset)\n", - "\n", - " # Predict ratings for the testset\n", - " predictions = algo.test(testset)\n", - " \n", - " return predictions\n", - "\n", - "# -- implement the function generate_loo_top_n --\n", - "def generate_loo_top_n(algo, ratings_dataset, eval_config):\n", - " \"\"\"Generate top-n recommendations for each user on a random Leave-one-out split (LOO)\"\"\"\n", - " \n", - " # Create a LeaveOneOut split\n", - " loo = LeaveOneOut(n_splits=1)\n", - " \n", - " for trainset, testset in loo.split(ratings_dataset):\n", - " algo.fit(trainset) # Train the algorithm on the training set\n", - " anti_testset = trainset.build_anti_testset() # Build the anti test-set\n", - " predictions = algo.test(anti_testset) # Get predictions on the anti test-set\n", - " top_n = {}\n", - " for uid, iid, _, est, _ in predictions:\n", - " if uid not in top_n:\n", - " top_n[uid] = []\n", - " top_n[uid].append((iid, est))\n", - " for uid, user_ratings in top_n.items():\n", - " user_ratings.sort(key=lambda x: x[1], reverse=True)\n", - " top_n[uid] = user_ratings[:eval_config.top_n_value] # Get top-N recommendations\n", - " anti_testset_top_n = top_n\n", - " return anti_testset_top_n, testset\n", - "\n", - "def generate_full_top_n(algo, ratings_dataset, eval_config):\n", - " \"\"\"Generate top-n recommendations for each user with full training set (LOO)\"\"\"\n", - "\n", - " full_trainset = ratings_dataset.build_full_trainset() # Build the full training set\n", - " algo.fit(full_trainset) # Train the algorithm on the full training set\n", - " anti_testset = full_trainset.build_anti_testset() # Build the anti test-set\n", - " predictions = algo.test(anti_testset) # Get predictions on the anti test-set\n", - " top_n = {}\n", - " for uid, iid, _, est, _ in predictions:\n", - " if uid not in top_n:\n", - " top_n[uid] = []\n", - " top_n[uid].append((iid, est))\n", - " for uid, user_ratings in top_n.items():\n", - " user_ratings.sort(key=lambda x: x[1], reverse=True)\n", - " top_n[uid] = user_ratings[:eval_config.top_n_value] # Get top-N recommendations\n", - " anti_testset_top_n = top_n\n", - " return anti_testset_top_n\n", - "\n", - "def precomputed_information(movie_data):\n", - "\n", - " \"\"\" Returns a dictionary that precomputes relevant information for evaluating in full mode\n", - " \n", - " Dictionary keys:\n", - " - precomputed_dict[\"item_to_rank\"] : contains a dictionary mapping movie ids to rankings\n", - " - (-- for your project, add other relevant information here -- )\n", - " \"\"\"\n", - "\n", - " # Initialize an empty dictionary to store item_id to rank mapping\n", - " item_to_rank = {}\n", - " \n", - " # Calculate popularity rank for each movie\n", - " ratings_count = movie_data.groupby('movieId').size().sort_values(ascending=False)\n", - " \n", - " # Assign ranks to movies based on their popularity\n", - " for rank, (movie_id, _) in enumerate(ratings_count.items(), start=1):\n", - " item_to_rank[movie_id] = rank\n", - " \n", - " # Create the precomputed dictionary\n", - " precomputed_dict = {}\n", - " precomputed_dict[\"item_to_rank\"] = item_to_rank\n", - " \n", - " return precomputed_dict\n", - "\n", - "def create_evaluation_report(eval_config, sp_ratings, precomputed_dict, available_metrics):\n", - "\n", - " \"\"\" Create a DataFrame evaluating various models on metrics specified in an evaluation config. \n", - " \"\"\"\n", - " \n", - " evaluation_dict = {}\n", - " for model_name, model, arguments in eval_config.models:\n", - " print(f'Handling model {model_name}')\n", - " algo = model(**arguments)\n", - " evaluation_dict[model_name] = {}\n", - " \n", - " # Type 1 : split evaluations\n", - " if len(eval_config.split_metrics) > 0:\n", - " print('Training split predictions')\n", - " predictions = generate_split_predictions(algo, sp_ratings, eval_config)\n", - " for metric in eval_config.split_metrics:\n", - " print(f'- computing metric {metric}')\n", - " assert metric in available_metrics['split']\n", - " evaluation_function, parameters = available_metrics[\"split\"][metric]\n", - " evaluation_dict[model_name][metric] = evaluation_function(predictions, **parameters) \n", - " \n", - " # Type 2 : loo evaluations\n", - " if len(eval_config.loo_metrics) > 0:\n", - " print('Training loo predictions')\n", - " anti_testset_top_n, testset = generate_loo_top_n(algo, sp_ratings, eval_config)\n", - " for metric in eval_config.loo_metrics:\n", - " assert metric in available_metrics['loo']\n", - " evaluation_function, parameters = available_metrics[\"loo\"][metric]\n", - " evaluation_dict[model_name][metric] = evaluation_function(anti_testset_top_n, testset, **parameters)\n", - " \n", - " # Type 3 : full evaluations\n", - " if len(eval_config.full_metrics) > 0:\n", - " print('Training full predictions')\n", - " anti_testset_top_n = generate_full_top_n(algo, sp_ratings, eval_config)\n", - " for metric in eval_config.full_metrics:\n", - " assert metric in available_metrics['full']\n", - " evaluation_function, parameters = available_metrics[\"full\"][metric]\n", - " evaluation_dict[model_name][metric] = evaluation_function(\n", - " anti_testset_top_n,\n", - " **precomputed_dict,\n", - " **parameters\n", - " )\n", - " \n", - " return pd.DataFrame.from_dict(evaluation_dict).T" - ] - }, - { - "cell_type": "markdown", - "id": "f7e83d1d", - "metadata": {}, - "source": [ - "# 2. Evaluation metrics\n", - "Implement evaluation metrics for either rating predictions (split metrics) or for top-n recommendations (loo metric, full metric)" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "id": "f1849e55", - "metadata": {}, - "outputs": [], - "source": [ - "# -- implement the function get_hit_rate --\n", - "def get_hit_rate(anti_testset_top_n, testset):\n", - " \n", - " \"\"\"Compute the average hit over the users (loo metric)\n", - " \n", - " A hit (1) happens when the movie in the testset has been picked by the top-n recommender\n", - " A fail (0) happens when the movie in the testset has not been picked by the top-n recommender\n", - " \"\"\"\n", - "\n", - " hits = 0\n", - " total_users = len(testset)\n", - " for uid, true_iid, _ in testset:\n", - " if uid in anti_testset_top_n and true_iid in {iid for iid, _ in anti_testset_top_n[uid]}:\n", - " hits += 1\n", - " hit_rate = hits / total_users\n", - "\n", - " return hit_rate\n", - "\n", - "# -- implement the function get_novelty --\n", - "def get_novelty(anti_testset_top_n, item_to_rank):\n", - "\n", - " \"\"\"Compute the average novelty of the top-n recommendation over the users (full metric)\n", - " \n", - " The novelty is defined as the average ranking of the movies recommended\n", - " \"\"\"\n", - "\n", - " total_rank_sum = 0\n", - " total_recommendations = 0\n", - " for uid, recommendations in anti_testset_top_n.items():\n", - " for iid, _ in recommendations:\n", - " if iid in item_to_rank:\n", - " total_rank_sum += item_to_rank[iid]\n", - " total_recommendations += 1\n", - " if total_recommendations == 0:\n", - " return 0 # Avoid division by zero\n", - " average_rank_sum = total_rank_sum / total_recommendations \n", - " \n", - " return average_rank_sum" - ] - }, - { - "cell_type": "markdown", - "id": "1a9855b3", - "metadata": {}, - "source": [ - "# 3. Evaluation workflow\n", - "Load data, evaluate models and save the experimental outcomes" - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "id": "704f4d2a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Handling model baseline_1\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model baseline_2\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model baseline_3\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model baseline_4\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model ContentBased_sample\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model ContentBased_score\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "Handling model ContentBased_Lr\n", - "Training split predictions\n", - "- computing metric mae\n", - "- computing metric rmse\n", - "Training loo predictions\n", - "Training full predictions\n", - "The data has been exported to the evaluation report\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>mae</th>\n", - " <th>rmse</th>\n", - " <th>hit_rate</th>\n", - " <th>novelty</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>baseline_1</th>\n", - " <td>1.561178</td>\n", - " <td>1.792482</td>\n", - " <td>0.074766</td>\n", - " <td>99.405607</td>\n", - " </tr>\n", - " <tr>\n", - " <th>baseline_2</th>\n", - " <td>1.471412</td>\n", - " <td>1.819364</td>\n", - " <td>0.000000</td>\n", - " <td>429.942991</td>\n", - " </tr>\n", - " <tr>\n", - " <th>baseline_3</th>\n", - " <td>0.878270</td>\n", - " <td>1.085591</td>\n", - " <td>0.074766</td>\n", - " <td>99.405607</td>\n", - " </tr>\n", - " <tr>\n", - " <th>baseline_4</th>\n", - " <td>0.705673</td>\n", - " <td>0.912313</td>\n", - " <td>0.130841</td>\n", - " <td>60.202804</td>\n", - " </tr>\n", - " <tr>\n", - " <th>ContentBased_sample</th>\n", - " <td>1.013747</td>\n", - " <td>1.350417</td>\n", - " <td>0.084112</td>\n", - " <td>178.048598</td>\n", - " </tr>\n", - " <tr>\n", - " <th>ContentBased_score</th>\n", - " <td>1.461846</td>\n", - " <td>1.803067</td>\n", - " <td>0.018692</td>\n", - " <td>437.222430</td>\n", - " </tr>\n", - " <tr>\n", - " <th>ContentBased_Lr</th>\n", - " <td>1.202626</td>\n", - " <td>1.460273</td>\n", - " <td>0.084112</td>\n", - " <td>278.046729</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " mae rmse hit_rate novelty\n", - "baseline_1 1.561178 1.792482 0.074766 99.405607\n", - "baseline_2 1.471412 1.819364 0.000000 429.942991\n", - "baseline_3 0.878270 1.085591 0.074766 99.405607\n", - "baseline_4 0.705673 0.912313 0.130841 60.202804\n", - "ContentBased_sample 1.013747 1.350417 0.084112 178.048598\n", - "ContentBased_score 1.461846 1.803067 0.018692 437.222430\n", - "ContentBased_Lr 1.202626 1.460273 0.084112 278.046729" - ] - }, - "execution_count": 112, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "AVAILABLE_METRICS = {\n", - " \"split\": {\n", - " \"mae\": (accuracy.mae, {'verbose': False}),\n", - " \"rmse\": (accuracy.rmse, {'verbose': False})\n", - " },\n", - " \"loo\": {\n", - " \"hit_rate\": (get_hit_rate, {}),\n", - " },\n", - " \"full\": {\n", - " \"novelty\": (get_novelty, {}),\n", - " }\n", - "}\n", - "\n", - "sp_ratings = load_ratings(surprise_format=True)\n", - "precomputed_dict = precomputed_information(pd.read_csv(\"data/tiny/evidence/ratings.csv\"))\n", - "evaluation_report = create_evaluation_report(EvalConfig, sp_ratings, precomputed_dict, AVAILABLE_METRICS)\n", - "export_evaluation_report(evaluation_report)" - ] - }, - { - "cell_type": "markdown", - "id": "6f8b6d19", - "metadata": {}, - "source": [ - "dire quel modèle est meilleur ?\n" - ] - } - ], - "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.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/models.py b/models.py deleted file mode 100644 index c288a5b8f7812d2b4187ec75540a77012b0997b3..0000000000000000000000000000000000000000 --- a/models.py +++ /dev/null @@ -1,181 +0,0 @@ -# standard library imports -from collections import defaultdict - -# third parties imports -import pandas as pd -import numpy as np -import random as rd -from surprise import AlgoBase, SVD, KNNWithMeans -from surprise import PredictionImpossible - -# import local -from loaders import load_items, load_ratings -from constants import Constant as C -from sklearn.linear_model import LinearRegression - - -def get_top_n(predictions, n): - """Return the top-N recommendation for each user from a set of predictions. - Source: inspired by https://github.com/NicolasHug/Surprise/blob/master/examples/top_n_recommendations.py - and modified by cvandekerckh for random tie breaking - - Args: - predictions(list of Prediction objects): The list of predictions, as - returned by the test method of an algorithm. - n(int): The number of recommendation to output for each user. Default - is 10. - Returns: - A dict where keys are user (raw) ids and values are lists of tuples: - [(raw item id, rating estimation), ...] of size n. - """ - - rd.seed(0) - - # First map the predictions to each user. - top_n = defaultdict(list) - for uid, iid, true_r, est, _ in predictions: - top_n[uid].append((iid, est)) - - # Then sort the predictions for each user and retrieve the k highest ones. - for uid, user_ratings in top_n.items(): - rd.shuffle(user_ratings) - user_ratings.sort(key=lambda x: x[1], reverse=True) - top_n[uid] = user_ratings[:n] - - return top_n - - -# First algorithm -class ModelBaseline1(AlgoBase): - def __init__(self): - AlgoBase.__init__(self) - - def estimate(self, u, i): - return 2 - - -# Second algorithm -class ModelBaseline2(AlgoBase): - def __init__(self): - AlgoBase.__init__(self) - - def fit(self, trainset): - AlgoBase.fit(self, trainset) - rd.seed(0) - - def estimate(self, u, i): - return rd.uniform(self.trainset.rating_scale[0], self.trainset.rating_scale[1]) - - -# Third algorithm -class ModelBaseline3(AlgoBase): - def __init__(self): - AlgoBase.__init__(self) - - def fit(self, trainset): - AlgoBase.fit(self, trainset) - self.the_mean = np.mean([r for (_, _, r) in self.trainset.all_ratings()]) - - return self - - def estimate(self, u, i): - return self.the_mean - - -# Fourth Model -class ModelBaseline4(SVD): - def __init__(self): - SVD.__init__(self, n_factors=100) - - -class ContentBased(AlgoBase): - def __init__(self, features_method, regressor_method): - AlgoBase.__init__(self) - self.regressor_method = regressor_method - self.content_features = self.create_content_features(features_method) - - def create_content_features(self, features_method): - """Content Analyzer""" - df_items = load_items() - if features_method is None: - df_features = None - elif features_method == "title_length": # a naive method that creates only 1 feature based on title length - df_features = df_items[C.LABEL_COL].apply(lambda x: len(x)).to_frame('n_character_title') - else: # (implement other feature creations here) - raise NotImplementedError(f'Feature method {features_method} not yet implemented') - return df_features - - - def fit(self, trainset): - """Profile Learner""" - AlgoBase.fit(self, trainset) - - # Preallocate user profiles - self.user_profile = {u: None for u in trainset.all_users()} - - if self.regressor_method == 'random_score': - for u in self.user_profile : - self.user_profile[u] = rd.uniform(0.5,5) - - elif self.regressor_method == 'random_sample': - for u in self.user_profile: - self.user_profile[u] = [rating for _, rating in self.trainset.ur[u]] - elif self.regressor_method == 'linear_regression' : - for u in self.user_profile: - - user_ratings = [rating for _, rating in trainset.ur[u]] - item_ids = [iid for iid, _ in trainset.ur[u]] - - df_user = pd.DataFrame({'item_id': item_ids, 'user_ratings': user_ratings}) - - df_user["item_id"] = df_user["item_id"].map(trainset.to_raw_iid) - - df_user = df_user.merge(self.content_features, left_on = "item_id", right_index = True, how = 'left') - - X = df_user['n_character_title'].values.reshape(-1,1) - - y = df_user['user_ratings'].values - - linear_regressor = LinearRegression(fit_intercept = False) - - linear_regressor.fit(X,y) - - # Store the computed user profile - self.user_profile[u] = linear_regressor - else : - pass - - # (implement here the regressor fitting) - - def estimate(self, u, i): - """Scoring component used for item filtering""" - # First, handle cases for unknown users and items - if not (self.trainset.knows_user(u) and self.trainset.knows_item(i)): - raise PredictionImpossible('User and/or item is unkown.') - - - if self.regressor_method == 'random_score': - rd.seed() - score = rd.uniform(0.5,5) - - elif self.regressor_method == 'random_sample': - rd.seed() - score = rd.choice(self.user_profile[u]) - - elif self.regressor_method == 'linear_regression': - - raw_item_id = self.trainset.to_raw_iid(i) - - item_features = self.content_features.loc[raw_item_id:raw_item_id, :].values - - linear_regressor = self.user_profile[u] - - score= linear_regressor.predict(item_features)[0] - else : - score = None - - # (implement here the regressor prediction) - - return score - -