diff --git a/README.md b/README.md
index d332b11c9b43c5004d23e45cc1ae439969c093f2..99f4fc9c745c651463538098f777a9ac020e569c 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,7 @@ Ce code **définit** plusieurs **algorithmes** de base de **recommandation** pou
## Datasets
### Small
+<<<<<<< HEAD
Le **small dataset** de données contient les données traditionnelles de **MovieLens** et est celui que nous devons utiliser lors de l'**évaluation** des modèles et de la construction de notre **système de recommandation**.
@@ -56,25 +57,43 @@ Le **test dataset** est une version encore plus petite **(6 utilisateurs et 10 a
Le **tiny dataset** est une version plus petite du small dataset et est utilisé pour **déboguer** notre code. Cela est utile lorsque certains modèles prennent beaucoup de temps à s'exécuter et que nous voulons **accélérer** le temps de calcul.
+=======
+Le **small dataset** de données contient les données traditionnelles de **MovieLens** et est celui que nous devons utiliser lors de l'**évaluation** des modèles et de la construction de notre **système de recommandation**.
+
+### Test
+
+Le **test dataset** est une version encore plus petite **(6 utilisateurs et 10 articles)** et contient l'exemple utilisé dans les diapositives de la conférence. Nous utilisons ce dataset afin de **mieux comprendre** le fonctionnement des algorithmes lors du développement de nos modèles.
+
+### Tiny
+
+Le **tiny dataset** est une version plus petite du small dataset et est utilisé pour **déboguer** notre code. Cela est utile lorsque certains modèles prennent beaucoup de temps à s'exécuter et que nous voulons **accélérer** le temps de calcul.
+>>>>>>> Evaluator
-## Rendus
+## Rendu
+
+<<<<<<< HEAD
### Analytics_UI
Lors de ce rendu, différentes analyses ont pu être effectuées sur les datasets disponibles afin de mieux comprendre les différentes données auxquelles nous allons faire face tout au long du projet. Une description détaillée des différentes analyses, menées dans les jupyter notebook, est décrite ci-dessous. Les jupyter notebook peuvent être lancés (run) indépendamment de tout autre fichier (.py) ou (.ipynb).
+=======
+### Evaluator block
+Le Jupyter Notebook peut être lancé indépendemment de tout autre code.
+>>>>>>> Evaluator
- - analytics_small.ipynb
-
- Dans le notebook "analytics_small.ipynb", plusieurs analyses ont été menées sur un ensemble de données lié aux notes de films. Tout d'abord, le nombre total de notes a été calculé, permettant ainsi d'avoir une vue d'ensemble de la taille de l'ensemble de données. Ensuite, le nombre d'utilisateurs uniques a été déterminé, offrant ainsi un aperçu de la diversité des utilisateurs qui ont contribué aux évaluations des films. De même, le nombre de films uniques dans la matrice des notes a été extrait, ce qui donne un aperçu du nombre de films différents présents dans l'ensemble de données.
+- **evaluator.ipynb**
- Une analyse a également été réalisée pour identifier le(s) film(s) le(s) plus noté(s), ainsi que le(s) film(s) le(s) moins noté(s). Ces informations permettent de repérer les tendances de popularité et les cas exceptionnels dans les données. Ensuite, toutes les valeurs de notation possibles ont été recueillies, de la plus petite à la plus grande valeur. Cette étape est importante pour comprendre la gamme des évaluations et identifier d'éventuelles anomalies ou biais dans les données.
+ Pour ce jupyter notebook Evaluator.ipynb, l'importation de certains **packages** et modules clés est essentielle. Dans notre cas, nous avons importé les packages `model_selection` et `accuracy` de **Surprise**, ce dernier étant nécessaire pour effectuer une **validation croisée** et utiliser des **métriques** prédéfinies pour **évaluer les modèles**. Cela nous permettra d'obtenir des informations précieuses sur les performances de nos modèles de recommandation.
- Un autre aspect exploré était le nombre de films qui n'ont reçu aucune note. Cette mesure offre un aperçu de la couverture des évaluations dans l'ensemble de données et peut révéler des lacunes potentielles. En ce qui concerne la section "Long-tail property", une évaluation de la sparsité de la matrice a été réalisée. Cela impliquait le calcul d'une métrique de sparsité ainsi qu'une observation visuelle de la distribution des notes dans la matrice. Cette analyse permet de déterminer dans quelle mesure les données suivent la propriété de la longue traîne, souvent observée dans les systèmes de recommandation.
+ En ce qui concerne l'adaptation des **loaders**, nous avons apporté des modifications à la fonction `load_ratings()`. Cette fonction a été ajustée pour permettre le chargement de données dans un **format** compatible avec **Surprise**. Un argument supplémentaire, `surprise_format`, a été ajouté pour conditionner le chargement en un objet **Dataset** compatible Surprise à partir d'un **DataFrame Pandas**. Cela simplifie grandement le processus de préparation des données pour l'entraînement des modèles.
- En complément des analyses mentionnées, une distribution des 'ratings' par films a été effectuée. Cette distribution offre un aperçu détaillé de la manière dont les différentes notes sont réparties entre les films, mettant en lumière les tendances de notation et les variations de popularité parmi les films. De plus, une matrice de sparsité a été calculée pour évaluer la densité des données. Cette matrice montre la proportion de cases vides ou non renseignées dans la matrice des notes, ce qui est crucial pour comprendre la disponibilité des données et leur potentiel pour l'analyse et la modélisation.
+ Pour évaluer nos modèles, nous avons mis en œuvre trois méthodes de **validation croisée**. La première méthode, `generate_split_predictions()`, divise l'ensemble de données en un ensemble d'entraînement et un ensemble de test en utilisant `train_test_split` de Surprise. Ensuite, avec `generate_loo_top_n()`, nous appliquons un processus **"leave-one-out"** pour générer des recommandations top-N et évaluer les performances du modèle. Enfin, `generate_full_top_n()` utilise l'**ensemble complet de données** pour **générer des recommandations** top-N sans division. Ces approches nous offrent une vision complète des performances de nos modèles dans différents scénarios.
+ Pour améliorer notre évaluation, nous avons également introduit trois **nouvelles métriques**. La **première**, `rmse (split type)`, représente la racine carrée de l'erreur quadratique moyenne pour évaluer les prédictions. **Ensuite**, `hit rate (loo type)` mesure le taux de succès, indiquant le pourcentage d'utilisateurs pour lesquels l'un des films recommandés correspond à ceux notés dans l'ensemble de test. **Enfin**, `novelty (full type)` évalue la nouveauté des recommandations en fonction de la popularité des films recommandés, fournissant ainsi des informations sur la diversité et la pertinence des suggestions.
+
+<<<<<<< HEAD
- analytics_tiny.ipynb
Dans le notebook "analytics_tiny.ipynb", plusieurs analyses ont été menées sur un ensemble de données, surnommé "tiny", étant un dataset réduit du dataset "small". Tout d'abord, le nombre total de notes a été calculé, permettant ainsi d'avoir une vue d'ensemble de la taille de l'ensemble de données. Ensuite, le nombre d'utilisateurs uniques a été déterminé, offrant ainsi un aperçu de la diversité des utilisateurs qui ont contribué aux évaluations des films. De même, le nombre de films uniques dans la matrice des notes a été extrait, ce qui donne un aperçu du nombre de films différents présents dans l'ensemble de données.
@@ -114,6 +133,9 @@ Lors de ce rendu, différentes analyses ont pu être effectuées sur les dataset
### User_based (à compléter)
### Recommender_UI (à compléter)
+=======
+ Pour conclure notre processus d'évaluation, nous avons mis en place une fonction `export_evaluation_report()`. Cette fonction permet d'**exporter le rapport** d'évaluation vers un **fichier CSV** dans un répertoire spécifié. Cela facilite le partage et la consultation des résultats, ce qui est crucial pour optimiser nos modèles et affiner nos stratégies de recommandation.
+>>>>>>> Evaluator
## Contact
@@ -140,13 +162,15 @@ Nous tenons à exprimer notre gratitude envers plusieurs parties qui ont jouées
## Références
-1. **Analytics_UI**
+### Evaluator_block
+
- https://forge.uclouvain.be/cvandekerckh/mlsmm2156
- https://bit.ly/3qnwKXa
- https://bit.ly/4cBLxDM
- https://numpy.org/doc/stable/user/quickstart.html
- https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html
- https://pandas.pydata.org/docs/reference/frame.html
+<<<<<<< HEAD
- https://www.jillcates.com/pydata-workshop/html/tutorial.html
2. **Evaluator_block**
@@ -166,3 +190,7 @@ Nous tenons à exprimer notre gratitude envers plusieurs parties qui ont jouées
4. **Recommender_UI** (à compléter)
+=======
+ - https://surprise.readthedocs.io/en/stable/
+
+>>>>>>> Evaluator
diff --git a/analytics_small.ipynb b/analytics_small.ipynb
deleted file mode 100644
index 305d69b4ce1cb26ec2294448405d3dcbd7f83e59..0000000000000000000000000000000000000000
--- a/analytics_small.ipynb
+++ /dev/null
@@ -1,733 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "The autoreload extension is already loaded. To reload it, use:\n",
- " %reload_ext autoreload\n",
- "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": 4,
- "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": 5,
- "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": 6,
- "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": 7,
- "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": 8,
- "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": 9,
- "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": 10,
- "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": 11,
- "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": 12,
- "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": 13,
- "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": 14,
- "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": 15,
- "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": 16,
- "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": 17,
- "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_test.ipynb b/analytics_test.ipynb
deleted file mode 100644
index 570e09ecf88e4237b76f2acdd948a611a24ee63b..0000000000000000000000000000000000000000
--- a/analytics_test.ipynb
+++ /dev/null
@@ -1,454 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "ename": "FileNotFoundError",
- "evalue": "[Errno 2] No such file or directory: '../data/test/content/movies.csv'",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[1], line 22\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtabulate\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m tabulate\n\u001b[1;32m 21\u001b[0m \u001b[38;5;66;03m# Call the load_items() function and create a variable df_items\u001b[39;00m\n\u001b[0;32m---> 22\u001b[0m df_movies \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m../data/test/content/movies.csv\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# Display the DataFrame\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDisplay The Movies : \u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
- "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pandas/io/parsers/readers.py:948\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 935\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 936\u001b[0m dialect,\n\u001b[1;32m 937\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 944\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m 945\u001b[0m )\n\u001b[1;32m 946\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 948\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pandas/io/parsers/readers.py:611\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 608\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 610\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 611\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 613\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 614\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n",
- "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1448\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1447\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1448\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1705\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1703\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1704\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1705\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1706\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1707\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1708\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1709\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1710\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1711\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1712\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1713\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1714\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1715\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1716\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n",
- "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pandas/io/common.py:863\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 858\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 859\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 860\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 861\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 862\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 863\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 864\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 865\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 866\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 867\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 868\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 869\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 870\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 871\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 872\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n",
- "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../data/test/content/movies.csv'"
- ]
- }
- ],
- "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/test/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/test/evidence/ratings.csv\")\n",
- "\n",
- "# Display the DataFrame\n",
- "print(\"Display The Ratings : \")\n",
- "display(df_ratings)\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of movies: 10\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Minimum range: 1973\n",
- "Maximum range: 2002\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n",
- "List of all genres:\n",
- "Action |\n",
- "Adventure |\n",
- "Animation |\n",
- "Children |\n",
- "Comedy |\n",
- "Drama |\n",
- "Fantasy |\n",
- "Horror |\n",
- "IMAX |\n",
- "Musical |\n",
- "Mystery |\n",
- "Romance |\n",
- "Sci-Fi |\n",
- "War |\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of ratings: 30\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of users: 6\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of unique movies : 10\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of ratings of the most rated movie(s): 4\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of ratings of the least rated movie(s): 2\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "All possible rating values, from smallest to highest:\n",
- "1.0\n",
- "1.5\n",
- "2.0\n",
- "2.5\n",
- "3.0\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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Number of movies that were not rated at all: 10\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": null,
- "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()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "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",
- "\n",
- "# Plot the non-zero values of the sparse matrix\n",
- "plt.figure(figsize=(8, 6))\n",
- "plt.spy(X, 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": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Matrix sparsity: 50.0%\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
deleted file mode 100644
index 00a7b11787925c12d34ba70a28e9823e1c1d0ce8..0000000000000000000000000000000000000000
--- a/analytics_tiny.ipynb
+++ /dev/null
@@ -1,725 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "The autoreload extension is already loaded. To reload it, use:\n",
- " %reload_ext autoreload\n",
- "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": 4,
- "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": 5,
- "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": 6,
- "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": 7,
- "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": 8,
- "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": 9,
- "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": 10,
- "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": 11,
- "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": 12,
- "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": 13,
- "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": 14,
- "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": 15,
- "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": 16,
- "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
index 25f747191a0860dbeb3b3d3f8a05ab4bc3fe7f0a..c6e61513a1ea1a1ff88286fa764f36f771de2175 100644
--- a/evaluator.ipynb
+++ b/evaluator.ipynb
@@ -22,17 +22,17 @@
"%load_ext autoreload\n",
"%autoreload 2\n",
"\n",
- "# third parties imports\n",
+ "# imports\n",
"import numpy as np \n",
"import pandas as pd\n",
- "# -- add new imports here --\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",
- "# -- add new imports here --\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",
@@ -50,27 +50,30 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": 2,
"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",
- " # -- implement the function generate_split_predictions --\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",
- "\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",
- " # -- implement the function generate_loo_top_n --\n",
+ " \n",
" # Create a LeaveOneOut split\n",
" loo = LeaveOneOut(n_splits=1)\n",
" \n",
@@ -91,6 +94,7 @@
"\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",
@@ -107,12 +111,14 @@
" 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",
@@ -130,8 +136,10 @@
" 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",
@@ -184,18 +192,19 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 3,
"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",
- " # -- implement the function get_hit_rate --\n",
"\n",
" hits = 0\n",
" total_users = len(testset)\n",
@@ -206,12 +215,14 @@
"\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",
- " # -- implement the function get_novelty --\n",
+ "\n",
" total_rank_sum = 0\n",
" total_recommendations = 0\n",
" for uid, recommendations in anti_testset_top_n.items():\n",
@@ -237,7 +248,7 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 4,
"id": "704f4d2a",
"metadata": {},
"outputs": [
@@ -302,31 +313,31 @@
" <tbody>\n",
" <tr>\n",
" <th>baseline_1</th>\n",
- " <td>1.567221</td>\n",
- " <td>1.788369</td>\n",
- " <td>0.074766</td>\n",
+ " <td>1.517749</td>\n",
+ " <td>1.745787</td>\n",
+ " <td>0.056075</td>\n",
" <td>99.405607</td>\n",
" </tr>\n",
" <tr>\n",
" <th>baseline_2</th>\n",
- " <td>1.502872</td>\n",
- " <td>1.840696</td>\n",
- " <td>0.056075</td>\n",
+ " <td>1.472806</td>\n",
+ " <td>1.805674</td>\n",
+ " <td>0.000000</td>\n",
" <td>429.942991</td>\n",
" </tr>\n",
" <tr>\n",
" <th>baseline_3</th>\n",
- " <td>0.873993</td>\n",
- " <td>1.076982</td>\n",
- " <td>0.065421</td>\n",
+ " <td>0.868666</td>\n",
+ " <td>1.076227</td>\n",
+ " <td>0.093458</td>\n",
" <td>99.405607</td>\n",
" </tr>\n",
" <tr>\n",
" <th>baseline_4</th>\n",
- " <td>0.730657</td>\n",
- " <td>0.938814</td>\n",
- " <td>0.186916</td>\n",
- " <td>57.465421</td>\n",
+ " <td>0.713063</td>\n",
+ " <td>0.912046</td>\n",
+ " <td>0.074766</td>\n",
+ " <td>60.349533</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
@@ -334,13 +345,13 @@
],
"text/plain": [
" mae rmse hit_rate novelty\n",
- "baseline_1 1.567221 1.788369 0.074766 99.405607\n",
- "baseline_2 1.502872 1.840696 0.056075 429.942991\n",
- "baseline_3 0.873993 1.076982 0.065421 99.405607\n",
- "baseline_4 0.730657 0.938814 0.186916 57.465421"
+ "baseline_1 1.517749 1.745787 0.056075 99.405607\n",
+ "baseline_2 1.472806 1.805674 0.000000 429.942991\n",
+ "baseline_3 0.868666 1.076227 0.093458 99.405607\n",
+ "baseline_4 0.713063 0.912046 0.074766 60.349533"
]
},
- "execution_count": 20,
+ "execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
@@ -350,15 +361,12 @@
" \"split\": {\n",
" \"mae\": (accuracy.mae, {'verbose': False}),\n",
" \"rmse\": (accuracy.rmse, {'verbose': False})\n",
- " # Add new split metrics here if needed\n",
" },\n",
" \"loo\": {\n",
" \"hit_rate\": (get_hit_rate, {}),\n",
- " # Add new loo metrics here if needed\n",
" },\n",
" \"full\": {\n",
" \"novelty\": (get_novelty, {}),\n",
- " # Add new full metrics here if needed\n",
" }\n",
"}\n",
"\n",
@@ -367,6 +375,24 @@
"evaluation_report = create_evaluation_report(EvalConfig, sp_ratings, precomputed_dict, AVAILABLE_METRICS)\n",
"export_evaluation_report(evaluation_report)"
]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9fbf23fd",
+ "metadata": {},
+ "source": [
+ "Analyzing the provided data on different baselines, several observations can be made across various metrics.\n",
+ "\n",
+ "Firstly, looking at the Mean Absolute Error (MAE), baseline_4 stands out with the lowest value of 0.713063, indicating superior accuracy in predictions compared to the other baselines. Following closely behind is baseline_3 with a MAE of 0.868666, showcasing commendable precision in its predictions.\n",
+ "\n",
+ "Next, considering the Root Mean Square Error (RMSE), baseline_4 again exhibits the best performance with a value of 0.912046, suggesting minimal overall prediction errors. Baseline_3 maintains strong performance here as well, with an RMSE of 1.076227.\n",
+ "\n",
+ "Examining the Hit Rate, baseline_3 leads the pack with 9.35%, signifying a higher success rate in recommendations compared to the other baselines. Meanwhile, baseline_1 and baseline_4 show lower hit rates at 5.61% and 7.48% respectively.\n",
+ "\n",
+ "Lastly, looking at the Novelty metric, baseline_4 scores the lowest at 60.35, indicating that its recommendations are less novel or more conventional compared to the others. On the other hand, baseline_1 scores the highest in novelty at 99.41, implying that its recommendations are more diverse or less conventional.\n",
+ "\n",
+ "In summary, baseline_4 appears to excel in several metrics including MAE, RMSE, and maintaining relatively low novelty. Baseline_3 stands out with a higher hit rate, showcasing effectiveness in recommendation success. Baseline_2, despite not excelling in the other metrics, exhibits an exceptionally high novelty score, indicating a unique approach to recommendations compared to the rest."
+ ]
}
],
"metadata": {
diff --git a/user_based.ipynb b/user_based.ipynb
deleted file mode 100644
index fded6f506d137724a7ccf2cad09be556cf85ebc0..0000000000000000000000000000000000000000
--- a/user_based.ipynb
+++ /dev/null
@@ -1,759 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "f4a8f664",
- "metadata": {},
- "source": [
- "# Custom User-based Model\n",
- "The present notebooks aims at creating a UserBased class that inherits from the Algobase class (surprise package) and that can be customized with various similarity metrics, peer groups and score aggregation functions. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "00d1b249",
- "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",
- "# standard library imports\n",
- "# -- add new imports here --\n",
- "\n",
- "# third parties imports\n",
- "import numpy as np \n",
- "import pandas as pd\n",
- "# -- add new imports here --\n",
- "\n",
- "# local imports\n",
- "from constants import Constant as C\n",
- "from loaders import load_ratings,load_items \n",
- "from surprise import KNNWithMeans, accuracy, AlgoBase, PredictionImpossible\n",
- "\n",
- "import heapq"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "22716aa3",
- "metadata": {},
- "source": [
- "# 1. Loading Data\n",
- "Prepare a dataset in order to help implementing a user-based recommender system"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "aafd1712",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "user: 11 item: 364 r_ui = 4.00 est = 3.42 {'was_impossible': True, 'reason': 'User and/or item is unknown.'}\n"
- ]
- }
- ],
- "source": [
- "\n",
- "# Create Surprise Dataset from the pandas DataFrame and Reader\n",
- "surprise_data = load_ratings(surprise_format=True)\n",
- "\n",
- "trainset = surprise_data.build_full_trainset()\n",
- "\n",
- "\n",
- "testset = trainset.build_anti_testset()\n",
- "\n",
- "\n",
- "sim_options = {\n",
- " 'name': 'msd', # Mean Squared Difference (Mean Square Error)\n",
- " 'user_based': True, # User-based collaborative filtering\n",
- " 'min_support': 3 # Minimum number of common ratings required\n",
- "}\n",
- "\n",
- "\n",
- "# Build an algorithm, and train it.\n",
- "algo = KNNWithMeans(sim_options=sim_options, k=3, min_k=2)\n",
- "algo.fit(trainset)\n",
- "algo.test(testset)\n",
- "\n",
- "\n",
- "uid = str(11) # raw user id (as in the ratings file). They are **strings**!\n",
- "iid = str(364) \n",
- "\n",
- "pred = algo.predict(uid, iid, r_ui=4, verbose=True)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "cf3ccdc0",
- "metadata": {},
- "outputs": [],
- "source": [
- "# -- load data, build trainset and anti testset --\n",
- "# it depends on the tiny dataset\n",
- "surprise_data = load_ratings(surprise_format=True)\n",
- "df_movies = load_items()\n",
- "\n",
- "# Assuming you have a pandas DataFrame named 'df' with columns ['user_id', 'item_id', 'rating']\n",
- "\n",
- "# Build train set with all available ratings\n",
- "trainset = surprise_data.build_full_trainset()\n",
- "\n",
- "# Build anti-test set\n",
- "testset = trainset.build_anti_testset()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "94adf3a6",
- "metadata": {},
- "source": [
- "# 2. Explore Surprise's user-based algorithm\n",
- "Displays user-based predictions and similarity matrix on the test dataset using the KNNWithMeans class"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "e6fb78b7",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "3.4190898791540785\n"
- ]
- }
- ],
- "source": [
- "# -- using surprise's user-based algorithm, explore the impact of different parameters and displays predictions --\n",
- "\n",
- "# Define the similarity options\n",
- "sim_options = {\n",
- " 'name': 'msd', # Mean Squared Difference (Mean Square Error)\n",
- " 'user_based': True, # User-based collaborative filtering\n",
- " 'min_support': 3 # Minimum number of common ratings required\n",
- "}\n",
- "\n",
- "# Create an instance of KNNWithMeans with the specified options\n",
- "knn_model = KNNWithMeans(k=3, min_k=2, sim_options=sim_options)\n",
- "\n",
- "# Train the algorithm on the trainset\n",
- "knn_model.fit(trainset).test(testset)\n",
- "\n",
- "# Make an estimation for user 11 and item 364\n",
- "prediction = knn_model.predict('11', '364')\n",
- "print(prediction.est)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "ffe89c56",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "Predictions with min_k = 1:\n",
- "User: 15, Item: 942, Rating: 3.7769516356699464\n",
- "User: 15, Item: 2117, Rating: 2.9340004894942537\n",
- "User: 15, Item: 2672, Rating: 2.371008709611413\n",
- "User: 15, Item: 5054, Rating: 3.010328638497653\n",
- "User: 15, Item: 6322, Rating: 1.711175832857413\n",
- "User: 15, Item: 6323, Rating: 1.7645762379992287\n",
- "User: 15, Item: 6757, Rating: 3.010328638497653\n",
- "User: 15, Item: 7700, Rating: 3.561484741491386\n",
- "User: 15, Item: 7981, Rating: 3.386000174210522\n",
- "User: 15, Item: 8600, Rating: 3.320743223639117\n",
- "User: 15, Item: 8620, Rating: 2.7538763809343654\n",
- "User: 15, Item: 31952, Rating: 3.7409900837647396\n",
- "User: 15, Item: 3, Rating: 2.222062601579949\n",
- "User: 15, Item: 64, Rating: 0.9224387353614938\n",
- "User: 15, Item: 206, Rating: 2.35668733389394\n",
- "User: 15, Item: 249, Rating: 3.1290259851652826\n",
- "User: 15, Item: 276, Rating: 2.1800017354806753\n",
- "User: 15, Item: 369, Rating: 2.3082373858282694\n",
- "User: 15, Item: 504, Rating: 2.2600496220227573\n",
- "User: 15, Item: 515, Rating: 3.6575674086958188\n",
- "User: 15, Item: 522, Rating: 2.4562020809509626\n",
- "User: 15, Item: 580, Rating: 1.9073310817298395\n",
- "User: 15, Item: 599, Rating: 2.780847470837928\n",
- "User: 15, Item: 915, Rating: 2.761094249104645\n",
- "User: 15, Item: 966, Rating: 3.0894953051643195\n",
- "User: 15, Item: 1274, Rating: 2.9873500196382845\n",
- "User: 15, Item: 1299, Rating: 3.0779327239728005\n",
- "User: 15, Item: 1345, Rating: 2.2037629856623138\n",
- "User: 15, Item: 1354, Rating: 2.001877412379849\n",
- "User: 15, Item: 532, Rating: 2.7123071345260277\n",
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "Predictions with min_k = 2:\n",
- "User: 15, Item: 942, Rating: 3.7769516356699464\n",
- "User: 15, Item: 2117, Rating: 2.9340004894942537\n",
- "User: 15, Item: 2672, Rating: 2.371008709611413\n",
- "User: 15, Item: 5054, Rating: 2.693661971830986\n",
- "User: 15, Item: 6322, Rating: 1.711175832857413\n",
- "User: 15, Item: 6323, Rating: 1.7645762379992287\n",
- "User: 15, Item: 6757, Rating: 2.693661971830986\n",
- "User: 15, Item: 7700, Rating: 3.561484741491386\n",
- "User: 15, Item: 7981, Rating: 3.386000174210522\n",
- "User: 15, Item: 8600, Rating: 3.320743223639117\n",
- "User: 15, Item: 8620, Rating: 2.7538763809343654\n",
- "User: 15, Item: 31952, Rating: 3.7409900837647396\n",
- "User: 15, Item: 3, Rating: 2.222062601579949\n",
- "User: 15, Item: 64, Rating: 0.9224387353614938\n",
- "User: 15, Item: 206, Rating: 2.35668733389394\n",
- "User: 15, Item: 249, Rating: 3.1290259851652826\n",
- "User: 15, Item: 276, Rating: 2.1800017354806753\n",
- "User: 15, Item: 369, Rating: 2.3082373858282694\n",
- "User: 15, Item: 504, Rating: 2.2600496220227573\n",
- "User: 15, Item: 515, Rating: 3.6575674086958188\n",
- "User: 15, Item: 522, Rating: 2.4562020809509626\n",
- "User: 15, Item: 580, Rating: 1.9073310817298395\n",
- "User: 15, Item: 599, Rating: 2.780847470837928\n",
- "User: 15, Item: 915, Rating: 2.761094249104645\n",
- "User: 15, Item: 966, Rating: 2.693661971830986\n",
- "User: 15, Item: 1274, Rating: 2.9873500196382845\n",
- "User: 15, Item: 1299, Rating: 3.0779327239728005\n",
- "User: 15, Item: 1345, Rating: 2.2037629856623138\n",
- "User: 15, Item: 1354, Rating: 2.001877412379849\n",
- "User: 15, Item: 532, Rating: 2.7123071345260277\n",
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "Predictions with min_k = 3:\n",
- "User: 15, Item: 942, Rating: 3.7769516356699464\n",
- "User: 15, Item: 2117, Rating: 2.9340004894942537\n",
- "User: 15, Item: 2672, Rating: 2.371008709611413\n",
- "User: 15, Item: 5054, Rating: 2.693661971830986\n",
- "User: 15, Item: 6322, Rating: 2.693661971830986\n",
- "User: 15, Item: 6323, Rating: 1.7645762379992287\n",
- "User: 15, Item: 6757, Rating: 2.693661971830986\n",
- "User: 15, Item: 7700, Rating: 2.693661971830986\n",
- "User: 15, Item: 7981, Rating: 3.386000174210522\n",
- "User: 15, Item: 8600, Rating: 2.693661971830986\n",
- "User: 15, Item: 8620, Rating: 2.7538763809343654\n",
- "User: 15, Item: 31952, Rating: 2.693661971830986\n",
- "User: 15, Item: 3, Rating: 2.222062601579949\n",
- "User: 15, Item: 64, Rating: 0.9224387353614938\n",
- "User: 15, Item: 206, Rating: 2.35668733389394\n",
- "User: 15, Item: 249, Rating: 3.1290259851652826\n",
- "User: 15, Item: 276, Rating: 2.1800017354806753\n",
- "User: 15, Item: 369, Rating: 2.3082373858282694\n",
- "User: 15, Item: 504, Rating: 2.2600496220227573\n",
- "User: 15, Item: 515, Rating: 3.6575674086958188\n",
- "User: 15, Item: 522, Rating: 2.4562020809509626\n",
- "User: 15, Item: 580, Rating: 1.9073310817298395\n",
- "User: 15, Item: 599, Rating: 2.780847470837928\n",
- "User: 15, Item: 915, Rating: 2.761094249104645\n",
- "User: 15, Item: 966, Rating: 2.693661971830986\n",
- "User: 15, Item: 1274, Rating: 2.9873500196382845\n",
- "User: 15, Item: 1299, Rating: 3.0779327239728005\n",
- "User: 15, Item: 1345, Rating: 2.2037629856623138\n",
- "User: 15, Item: 1354, Rating: 2.001877412379849\n",
- "User: 15, Item: 532, Rating: 2.7123071345260277\n"
- ]
- }
- ],
- "source": [
- "# Playing with KNN\n",
- "\n",
- "# Define the similarity options\n",
- "sim_options = {\n",
- " 'name': 'msd', # Mean Squared Difference (Mean Square Error)\n",
- " 'user_based': True, # User-based collaborative filtering\n",
- " 'min_support': 3 # Minimum number of common ratings required. This data is\n",
- "}\n",
- "\n",
- "# Create an instance of KNNWithMeans with the specified options\n",
- "def predict_ratings(trainset, testset, min_k_values):\n",
- " for min_k in min_k_values:\n",
- " knn_model = KNNWithMeans(sim_options=sim_options, k=3, min_k=min_k)\n",
- " # Train the algorithm on the trainset\n",
- " knn_model.fit(trainset)\n",
- "\n",
- " # Make predictions for all ratings in the anti testset\n",
- " predictions = knn_model.test(testset)\n",
- "\n",
- " # Display 30 predictions\n",
- " print(f\"Predictions with min_k = {min_k}:\")\n",
- " for prediction in predictions[:30]:\n",
- " print(f\"User: {prediction.uid}, Item: {prediction.iid}, Rating: {prediction.est}\")\n",
- "\n",
- "# Assuming trainset and testset are already defined\n",
- "predict_ratings(trainset, testset, min_k_values=[1, 2, 3])"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "c5209097",
- "metadata": {},
- "source": [
- "Quelque soit les neighbours (1,2,3) la valeur du ratings ne change pas "
- ]
- },
- {
- "cell_type": "markdown",
- "id": "c8890e11",
- "metadata": {},
- "source": [
- "1).Predictions with min_k = 1: In this case, the model makes predictions without considering any minimum number of neighbors. Each prediction is made solely based on the similarity between the target user and other users who have rated the same items. Consequently, we observe varying prediction values for different items. For instance, for user 15 and item 942, the predicted rating is 3.777, while for item 64, the predicted rating is only 0.922. This indicates that the model heavily relies on the ratings from users who may have rated only a single item in common with the target user, leading to potentially erratic predictions.\n",
- "\n",
- "2). Predictions with min_k = 2: Here, a minimum of 2 neighbors are required to make a prediction. This introduces a bit of regularization, ensuring that predictions are made based on a slightly broader consensus. We notice that the predictions are somewhat similar to those with min_k = 1, but there are slight changes in some ratings. For example, the rating for item 5054 changes from 3.010 to 2.694. This suggests that the model is slightly more conservative in its predictions due to the requirement of at least two neighbors.\n",
- "\n",
- "3). Predictions with min_k = 3: With a minimum of 3 neighbors, the model becomes even more conservative. It requires a stronger consensus among users before making predictions. As a result, we see more uniformity in the predicted ratings compared to the previous cases. For example, for item 6322, the prediction changes from 1.711 (min_k = 1) to 2.694 (min_k = 2) and finally to 2.694 again (min_k = 3). This indicates that the model is increasingly cautious as it demands more agreement among neighbors before making predictions"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "cc806424",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n",
- "Prédictions avec min_support = 1:\n",
- "User: 15, Item: 942, Actual_k: 3\n",
- "User: 15, Item: 2117, Actual_k: 3\n",
- "User: 15, Item: 2672, Actual_k: 3\n",
- "User: 15, Item: 5054, Actual_k: 1\n",
- "User: 15, Item: 6322, Actual_k: 2\n",
- "User: 15, Item: 6323, Actual_k: 3\n",
- "User: 15, Item: 6757, Actual_k: 1\n",
- "User: 15, Item: 7700, Actual_k: 2\n",
- "User: 15, Item: 7981, Actual_k: 3\n",
- "User: 15, Item: 8600, Actual_k: 2\n",
- "User: 15, Item: 8620, Actual_k: 3\n",
- "User: 15, Item: 31952, Actual_k: 2\n",
- "User: 15, Item: 3, Actual_k: 3\n",
- "User: 15, Item: 64, Actual_k: 3\n",
- "User: 15, Item: 206, Actual_k: 3\n",
- "User: 15, Item: 249, Actual_k: 3\n",
- "User: 15, Item: 276, Actual_k: 3\n",
- "User: 15, Item: 369, Actual_k: 3\n",
- "User: 15, Item: 504, Actual_k: 3\n",
- "User: 15, Item: 515, Actual_k: 3\n",
- "User: 15, Item: 522, Actual_k: 3\n",
- "User: 15, Item: 580, Actual_k: 3\n",
- "User: 15, Item: 599, Actual_k: 3\n",
- "User: 15, Item: 915, Actual_k: 3\n",
- "User: 15, Item: 966, Actual_k: 1\n",
- "User: 15, Item: 1274, Actual_k: 3\n",
- "User: 15, Item: 1299, Actual_k: 3\n",
- "User: 15, Item: 1345, Actual_k: 3\n",
- "User: 15, Item: 1354, Actual_k: 3\n",
- "User: 15, Item: 532, Actual_k: 3\n",
- "\n",
- "Prédictions avec min_support = 2:\n",
- "User: 15, Item: 942, Actual_k: 3\n",
- "User: 15, Item: 2117, Actual_k: 3\n",
- "User: 15, Item: 2672, Actual_k: 3\n",
- "User: 15, Item: 5054, Actual_k: 1\n",
- "User: 15, Item: 6322, Actual_k: 2\n",
- "User: 15, Item: 6323, Actual_k: 3\n",
- "User: 15, Item: 6757, Actual_k: 1\n",
- "User: 15, Item: 7700, Actual_k: 2\n",
- "User: 15, Item: 7981, Actual_k: 3\n",
- "User: 15, Item: 8600, Actual_k: 2\n",
- "User: 15, Item: 8620, Actual_k: 3\n",
- "User: 15, Item: 31952, Actual_k: 2\n",
- "User: 15, Item: 3, Actual_k: 3\n",
- "User: 15, Item: 64, Actual_k: 3\n",
- "User: 15, Item: 206, Actual_k: 3\n",
- "User: 15, Item: 249, Actual_k: 3\n",
- "User: 15, Item: 276, Actual_k: 3\n",
- "User: 15, Item: 369, Actual_k: 3\n",
- "User: 15, Item: 504, Actual_k: 3\n",
- "User: 15, Item: 515, Actual_k: 3\n",
- "User: 15, Item: 522, Actual_k: 3\n",
- "User: 15, Item: 580, Actual_k: 3\n",
- "User: 15, Item: 599, Actual_k: 3\n",
- "User: 15, Item: 915, Actual_k: 3\n",
- "User: 15, Item: 966, Actual_k: 1\n",
- "User: 15, Item: 1274, Actual_k: 3\n",
- "User: 15, Item: 1299, Actual_k: 3\n",
- "User: 15, Item: 1345, Actual_k: 3\n",
- "User: 15, Item: 1354, Actual_k: 3\n",
- "User: 15, Item: 532, Actual_k: 3\n",
- "\n",
- "Prédictions avec min_support = 3:\n",
- "User: 15, Item: 942, Actual_k: 3\n",
- "User: 15, Item: 2117, Actual_k: 3\n",
- "User: 15, Item: 2672, Actual_k: 3\n",
- "User: 15, Item: 5054, Actual_k: 1\n",
- "User: 15, Item: 6322, Actual_k: 2\n",
- "User: 15, Item: 6323, Actual_k: 3\n",
- "User: 15, Item: 6757, Actual_k: 1\n",
- "User: 15, Item: 7700, Actual_k: 2\n",
- "User: 15, Item: 7981, Actual_k: 3\n",
- "User: 15, Item: 8600, Actual_k: 2\n",
- "User: 15, Item: 8620, Actual_k: 3\n",
- "User: 15, Item: 31952, Actual_k: 2\n",
- "User: 15, Item: 3, Actual_k: 3\n",
- "User: 15, Item: 64, Actual_k: 3\n",
- "User: 15, Item: 206, Actual_k: 3\n",
- "User: 15, Item: 249, Actual_k: 3\n",
- "User: 15, Item: 276, Actual_k: 3\n",
- "User: 15, Item: 369, Actual_k: 3\n",
- "User: 15, Item: 504, Actual_k: 3\n",
- "User: 15, Item: 515, Actual_k: 3\n",
- "User: 15, Item: 522, Actual_k: 3\n",
- "User: 15, Item: 580, Actual_k: 3\n",
- "User: 15, Item: 599, Actual_k: 3\n",
- "User: 15, Item: 915, Actual_k: 3\n",
- "User: 15, Item: 966, Actual_k: 1\n",
- "User: 15, Item: 1274, Actual_k: 3\n",
- "User: 15, Item: 1299, Actual_k: 3\n",
- "User: 15, Item: 1345, Actual_k: 3\n",
- "User: 15, Item: 1354, Actual_k: 3\n",
- "User: 15, Item: 532, Actual_k: 3\n",
- "\n",
- "Matrice de similarité:\n",
- "[[1. 0.39130435 0.35942029 ... 0.24358974 0.28513238 0.21451104]\n",
- " [0.39130435 1. 0.32786885 ... 0.30967742 0.42424242 0.21621622]\n",
- " [0.35942029 0.32786885 1. ... 0.36666667 0.72727273 0.34375 ]\n",
- " ...\n",
- " [0.24358974 0.30967742 0.36666667 ... 1. 0.6779661 0.37569061]\n",
- " [0.28513238 0.42424242 0.72727273 ... 0.6779661 1. 0.83333333]\n",
- " [0.21451104 0.21621622 0.34375 ... 0.37569061 0.83333333 1. ]]\n",
- "None\n"
- ]
- }
- ],
- "source": [
- "def analyse_min_support(knn_model, testset):\n",
- " # Rétablir min_k à 2\n",
- " knn_model.min_k = 2\n",
- "\n",
- " # Modifier min_support de 1 Ã 3 et observer actual_k\n",
- " for min_support in range(1, 4):\n",
- " knn_model.sim_options['min_support'] = min_support\n",
- " predictions_min_support = knn_model.test(testset[:30]) # Prendre les 30 premières prédictions pour l'affichage\n",
- " print(f\"\\nPrédictions avec min_support = {min_support}:\")\n",
- " for prediction in predictions_min_support:\n",
- " actual_k = prediction.details['actual_k']\n",
- " print(f\"User: {prediction.uid}, Item: {prediction.iid}, Actual_k: {actual_k}\")\n",
- "\n",
- " # Visualiser la matrice de similarité\n",
- " similarity_matrix = knn_model.sim # Algorithme de knn_model\n",
- " print(\"\\nMatrice de similarité:\")\n",
- " print(similarity_matrix)\n",
- "\n",
- "# Appel de la fonction et impression de l'analyse\n",
- "result = analyse_min_support(knn_model, testset)\n",
- "print(result)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "2dd01f5b",
- "metadata": {},
- "source": [
- "# 3. Implement and explore a customizable user-based algorithm\n",
- "Create a self-made user-based algorithm allowing to customize the similarity metric, peer group calculation and aggregation function"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "d03ed9eb",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[[3. 1.5 4. ... nan nan nan]\n",
- " [nan nan nan ... nan nan nan]\n",
- " [4. 3. 3. ... nan nan nan]\n",
- " ...\n",
- " [4.5 nan nan ... nan nan nan]\n",
- " [nan nan nan ... nan nan nan]\n",
- " [2. nan nan ... nan nan nan]]\n"
- ]
- }
- ],
- "source": [
- "class UserBased(AlgoBase):\n",
- " def __init__(self, k=3, min_k=1, sim_options={}, **kwargs):\n",
- " AlgoBase.__init__(self, sim_options=sim_options, **kwargs)\n",
- " self.k = k\n",
- " self.min_k = min_k\n",
- " self.sim_options = sim_options\n",
- "\n",
- " \n",
- " def fit(self, trainset):\n",
- " AlgoBase.fit(self, trainset)\n",
- " self.compute_rating_matrix()\n",
- " self.compute_similarity_matrix()\n",
- " self.compute_mean_ratings()\n",
- " \n",
- " def estimate(self, u, i):\n",
- " if not (self.trainset.knows_user(u) and self.trainset.knows_item(i)):\n",
- " raise PredictionImpossible('User and/or item is unknown.')\n",
- "\n",
- " estimate = self.mean_ratings[u]\n",
- "\n",
- " # Step 1: Create the peer group of user u for item i\n",
- " peer_group = []\n",
- " for j, rating in enumerate(self.trainset.ir[i]):\n",
- " if rating is not None:\n",
- " similarity = self.sim[u, j] # Similarity between user u and user j for item i\n",
- " peer_group.append((j, similarity, rating))\n",
- "\n",
- " # Step 2: Pick up the top neighbors efficiently\n",
- " k_neighbors = heapq.nlargest(self.min_k, peer_group, key=lambda x: x[1]) # Top k neighbors based on similarity\n",
- "\n",
- " # Step 3: Compute the weighted average\n",
- " actual_k = len(k_neighbors)\n",
- " if actual_k >= self.min_k:\n",
- " weighted_sum = 0\n",
- " total_similarity = 0\n",
- " for j, similarity, rating_list in k_neighbors:\n",
- " # Assuming rating_list is a list or array containing ratings\n",
- " rating = rating_list[0] # Access the first element of the rating list\n",
- " weighted_sum += similarity * rating\n",
- " total_similarity += similarity\n",
- "\n",
- " if total_similarity != 0:\n",
- " peer_group_average = weighted_sum / total_similarity\n",
- " estimate += peer_group_average\n",
- "\n",
- " return estimate\n",
- "\n",
- " \n",
- " def compute_rating_matrix(self):\n",
- " # Get the number of users and items\n",
- " n_users = self.trainset.n_users\n",
- " n_items = self.trainset.n_items\n",
- " \n",
- " ratings_matrix = np.empty((n_users, n_items))\n",
- " ratings_matrix[:] = np.nan\n",
- "\n",
- " # Fill in the ratings matrix with available ratings\n",
- " for user_id, user_ratings in self.trainset.ur.items():\n",
- " if user_ratings: # Check if user has ratings\n",
- " for item_id, rating in user_ratings:\n",
- " ratings_matrix[user_id, item_id] = rating\n",
- " \n",
- " # Set the computed ratings matrix to self.ratings_matrix\n",
- " self.ratings_matrix = ratings_matrix\n",
- " \n",
- " def compute_similarity_matrix(self):\n",
- " # Get the number of users\n",
- " n_users = self.trainset.n_users\n",
- " \n",
- " # Initialize the similarity matrix with zeros and ones in the diagonal\n",
- " similarity_matrix = np.eye(n_users)\n",
- " \n",
- " # Iterate through pairs of users to compute similarities\n",
- " for i in range(n_users):\n",
- " for j in range(i + 1, n_users):\n",
- " # Compute support\n",
- " support = np.sum(~np.isnan(self.ratings_matrix[i]) & ~np.isnan(self.ratings_matrix[j]))\n",
- " \n",
- " # Check if support is greater than or equal to min_k\n",
- " if support >= self.min_k:\n",
- " # Compute similarity using Jaccard similarity\n",
- " intersection = np.sum(~np.isnan(self.ratings_matrix[i]) & ~np.isnan(self.ratings_matrix[j]))\n",
- " union = np.sum(~np.isnan(self.ratings_matrix[i]) | ~np.isnan(self.ratings_matrix[j]))\n",
- " similarity = intersection / union\n",
- " similarity_matrix[i, j] = similarity\n",
- " similarity_matrix[j, i] = similarity # Similarity matrix is symmetric\n",
- " \n",
- " # Set the computed similarity matrix to self.sim\n",
- " self.sim = similarity_matrix\n",
- " \n",
- " def compute_mean_ratings(self):\n",
- " # Compute the mean rating of every user\n",
- " mean_ratings = []\n",
- " for user_id, ratings in self.trainset.ur.items():\n",
- " if ratings: # Check if user has ratings\n",
- " mean_rating = np.mean([rating[1] for rating in ratings])\n",
- " mean_ratings.append(mean_rating)\n",
- " else:\n",
- " mean_ratings.append(0) # If no ratings available, set mean to 0\n",
- " \n",
- " # Set the computed mean ratings\n",
- " self.mean_ratings = mean_ratings\n",
- "\n",
- " \n",
- "user_based_instance = UserBased(trainset=trainset)\n",
- "\n",
- "# Appel de la méthode fit pour calculer les matrices des évaluations, de similarité et les moyennes des évaluations\n",
- "user_based_instance.fit(trainset)\n",
- "\n",
- "# Affichage de la matrice des évaluations\n",
- "print(user_based_instance.ratings_matrix)\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "dfdc9cfe",
- "metadata": {},
- "source": [
- "# 4. Compare KNNWithMeans with UserBased\n",
- "Try to replicate KNNWithMeans with your self-made UserBased and check that outcomes are identical"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "id": "be53ae27",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "UserBased MAE: 1.5398252671298895\n",
- "UserBased RMSE: 1.5553141029705104\n",
- "KNNWithMeans MAE: 0.5419110316300769\n",
- "KNNWithMeans RMSE: 0.7019543155680094\n"
- ]
- }
- ],
- "source": [
- "# 1. Obtain Predictions\n",
- "# Using UserBased algorithm\n",
- "user_based_predictions = []\n",
- "for uid, iid, true_r in testset:\n",
- " user_based_pred = user_based_instance.predict(uid, iid)\n",
- " user_based_predictions.append((uid, iid, true_r, user_based_pred.est, {}))\n",
- "\n",
- "# Using KNNWithMeans algorithm\n",
- "knn_predictions = []\n",
- "for uid, iid, true_r in testset:\n",
- " knn_pred = knn_model.predict(uid, iid)\n",
- " knn_predictions.append((uid, iid, true_r, knn_pred.est, knn_pred.details))\n",
- "\n",
- "# 2. Calculate Metrics\n",
- "# Calculate MAE and RMSE for UserBased algorithm\n",
- "user_based_mae = accuracy.mae(user_based_predictions, verbose=False)\n",
- "user_based_rmse = accuracy.rmse(user_based_predictions, verbose=False)\n",
- "\n",
- "# Calculate MAE and RMSE for KNNWithMeans algorithm\n",
- "knn_mae = accuracy.mae(knn_predictions, verbose=False)\n",
- "knn_rmse = accuracy.rmse(knn_predictions, verbose=False)\n",
- "\n",
- "# 3. Compare Results\n",
- "print(\"UserBased MAE:\", user_based_mae)\n",
- "print(\"UserBased RMSE:\", user_based_rmse)\n",
- "print(\"KNNWithMeans MAE:\", knn_mae)\n",
- "print(\"KNNWithMeans RMSE:\", knn_rmse)\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "cced76d9",
- "metadata": {},
- "source": [
- "# 5. Compare MSD and Jacard\n",
- "Compare predictions made with MSD similarity and Jacard similarity\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "id": "c20d8e19",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Computing the msd similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "Computing the cosine similarity matrix...\n",
- "Done computing similarity matrix.\n",
- "RMSE: 0.9501\n",
- "RMSE: 0.9613\n",
- "RMSE with MSD similarity: 0.9500902346226462\n",
- "RMSE with Jaccard similarity: 0.9612909313186003\n"
- ]
- }
- ],
- "source": [
- "from surprise import accuracy\n",
- "from surprise.model_selection import train_test_split\n",
- "from surprise import Dataset, Reader\n",
- "from surprise import KNNBasic\n",
- "\n",
- "\n",
- "# Split the dataset into training and testing sets\n",
- "trainset, testset = train_test_split(surprise_data, test_size=0.2)\n",
- "\n",
- "# Initialize the model with MSD similarity\n",
- "sim_options_msd = {'name': 'msd'}\n",
- "user_based_msd = KNNBasic(sim_options=sim_options_msd)\n",
- "user_based_msd.fit(trainset)\n",
- "\n",
- "# Initialize the model with Jacard similarity\n",
- "sim_options_jaccard = {'name': 'cosine'}\n",
- "user_based_jaccard = KNNBasic(sim_options=sim_options_jaccard)\n",
- "user_based_jaccard.fit(trainset)\n",
- "\n",
- "# Make predictions with each model on the test set\n",
- "predictions_msd = user_based_msd.test(testset)\n",
- "predictions_jaccard = user_based_jaccard.test(testset)\n",
- "\n",
- "# Calculate and display the performances of the two models\n",
- "rmse_msd = accuracy.rmse(predictions_msd)\n",
- "rmse_jaccard = accuracy.rmse(predictions_jaccard)\n",
- "\n",
- "print(\"RMSE with MSD similarity:\", rmse_msd)\n",
- "print(\"RMSE with Jaccard similarity:\", rmse_jaccard)\n"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "mon_environnement",
- "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
-}