notebook.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sistemi di raccomandazione in Python\n",
    "\n",
    "Nome: Davide  \n",
    "Cognome: Barbagallo  \n",
    "Matricola: 1000016775  \n",
    "Corso: Social Media Management  \n",
    "Docente: Antonino Furnari  \n",
    "Anno accademico: 2022/23  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduzione\n",
    "\n",
    "I **sistemi di raccomandazione** sono dei sistemi software che permettono di predire le preferenze di un utente basandoci sui dati raccolti in passato su di esso.  \n",
    "A differenza dei sistemi tradizionali, essi possono predire il gradimento dell'utente anche per oggetti meno popolari, catturando il cosiddetto fenomeno **long-tail**.  \n",
    "Un sistema di raccomandazione conserva le valutazioni in una matrice, chiamata **matrice di utilità** $M$, avente grandezza $|U| \\times |I|$, dove:  \n",
    "- $U$ è l'insieme degli utenti\n",
    "- $I$ è l'insieme degli item\n",
    "\n",
    "L'insieme delle celle della matrice $M$, composto da tutte le possibili coppie $(u, i)$ dove $u \\in U$ e $i \\in I$, contiene le valutazioni degli utenti sugli item.  \n",
    "Le valutazioni possono essere definite in diversi spazi, come l'insieme dei numeri reali $R$ o l'insieme dei numeri binari $\\{0, 1\\}$.\n",
    "\n",
    "I sistemi di raccomandazione possono dividersi in due categorie.  \n",
    "La prima categoria contiene i sistemi di raccomandazione **content-based** che utilizzano le informazioni sulle proprietà degli item per generare un profilo di ogni item. Inoltre, mantengono un profilo dell'utente che riflette le sue preferenze in base alle proprietà degli item che ha già valutato in passato. Per suggerire nuovi item all'utente, il sistema calcola la similarità tra il profilo dell'utente e quello degli item presenti ancora da valutare, e suggerisce gli item che presentano la maggiore somiglianza. Le predizioni sugli item vengono quindi effettuate sulla base della corrispondenza tra le proprietà degli item suggeriti e il profilo dell'utente.  \n",
    "La seconda categoria contiene i sistemi **collaborative-filtering** che utilizzano le informazioni sulle interazioni passate degli utenti con gli item per generare raccomandazioni personalizzate. In particolare, questi sistemi possono essere basati sulla similarità tra gli utenti (user-based collaborative filtering) o tra gli item (item-based collaborative filtering).  \n",
    "Nel caso dell'user-based collaborative filtering, le predizioni sugli item per un utente vengono fatte basandosi sull'esperienza degli altri utenti simili a lui. Questo viene fatto calcolando la similarità tra il profilo di gradimento dell'utente corrente e quello degli altri utenti, e utilizzando queste informazioni per generare una lista di raccomandazioni personalizzate.  \n",
    "Nel caso dell'item-based collaborative filtering, invece, le predizioni sugli item vengono fatte basandosi sulla similarità tra gli item presenti nel catalogo. Il sistema cerca gli item che sono stati graditi da utenti simili a quello corrente, e utilizza queste informazioni per generare una lista di raccomandazioni personalizzate.  \n",
    "In entrambi i casi, i sistemi di raccomandazione collaborative filtering sfruttano la conoscenza delle preferenze degli utenti per generare raccomandazioni personalizzate, senza la necessità di conoscere dettagliate informazioni sulle proprietà degli item.\n",
    "\n",
    "## Obiettivo\n",
    "Creeremo diversi sistemi di raccomandazione per confrontarne le prestazioni. Oltre ai sistemi classici, useremo anche due sistemi personalizzati:\n",
    "- un sistema che normalizza le valutazioni degli item secondo una media pesata utilizzando il timestamp associato ad esse.\n",
    "- un sistema che utilizza delle valutazioni binarie invece delle valutazioni reali.  \n",
    "\n",
    "Useremo la versione ridotta del [dataset MovieLens](https://grouplens.org/datasets/movielens/latest/) per generare i sistemi di raccomandazione. Al suo interno sono presenti due file in formato `.csv`:  \n",
    "- `movies.csv`: contiene l'elenco dei film, con i campi `movieId`, `title` e `genres`.  \n",
    "- `ratings.csv`: contiene l'elenco delle valutazione relative agli utenti, con i campi `userId`, `movieId`, `rating`, `timestamp`. \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparazione dell'ambiente\n",
    "All'interno del nostro progetto, useremo diverse librerie:  \n",
    "- [`pandas`](https://pandas.pydata.org/), permette di leggere e manipolare i dati in formato `.csv`.\n",
    "- [`surprise`](https://surpriselib.com/), permette la creazione e l'addestramento dei sistemi di raccomandazione in Python.  \n",
    "- [`matplotlib`](https://matplotlib.org/), permette la creazione di grafici e la loro visualizzazione.\n",
    "- [`numpy`](https://numpy.org/), permette di utilizzare array multidimensionali e di eseguire operazioni matematiche su di essi.\n",
    "- [`scipy`](https://www.scipy.org/), permette di eseguire operazioni matematiche su array multidimensionali. Lo useremo per effettuare alcuni test statistici.\n",
    "\n",
    "Iniziamo leggendo i file `.csv` sopra elencati ed organizziamoli in due `DataFrame` di `pandas`.   \n",
    "I data frame ci consentono di organizzare i dati in tabelle, dove ogni colonna rappresenta un attributo e ogni riga rappresenta un record, rendendo più semplice la lettura e la manipolazione dei dati.  \n",
    "La funzione `read_csv()` ci permette di leggere i file, creare i data frame partendo da questi ultimi ed assegnarli alle variabili `movie_dataset` e `rating_dataset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "movie_dataset_path = os.path.join(os.getcwd(), 'movie-dataset', 'movies.csv')\n",
    "rating_dataset_path = os.path.join(os.getcwd(), 'movie-dataset', 'ratings.csv')\n",
    "\n",
    "movie_dataset = pd.read_csv(movie_dataset_path, sep=',', engine='python')\n",
    "rating_dataset = pd.read_csv(rating_dataset_path, sep=',', engine='python')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una volta caricati i dati, verifichiamone l'**integrità**.  \n",
    "L'integrità dei dati è essenziale per garantire l'affidabilità dei risultati dell'analisi.  \n",
    "La presenza di righe con dati incompleti, come i valori `NaN`, potrebbero influenzare negativamente i risultati.  \n",
    "Per scartare i dati incompleti, possiamo utilizzare la funzione `dropna()`, che restituisce un nuovo data frame partendo da quello originale, eliminando le righe che contengono valori `NaN`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_dataset = movie_dataset.dropna()\n",
    "rating_dataset = rating_dataset.dropna()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dopo aver verificato l'integrità dei dati, è necessario organizzare i dati in delle strutture utilizzabili dai sistemi di raccomandazione.  \n",
    "La libreria `surprise` organizza i dati in una struttura chiamata `Dataset`, formata da triple `(user, item, rating)`.  \n",
    "Per poter strutturare i dati in questo modo, utilizziamo la funzione la funzione `load_from_df()` passando in input il data frame contenente le valutazioni degli utenti e un oggetto `Reader()` per specificare il range di definizione delle valutazioni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min value of rating: 0.5\n",
      "Max value of rating: 5.0\n",
      "Possible values assumed by ratings: [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]\n"
     ]
    }
   ],
   "source": [
    "from surprise import Dataset, Reader\n",
    "\n",
    "all_values: list[float] = rating_dataset['rating'].unique().tolist()\n",
    "all_values.sort()\n",
    "min_value: float = all_values[0]\n",
    "max_value: float = all_values[-1]\n",
    "\n",
    "elaborated_data = Dataset.load_from_df(rating_dataset[['userId', 'movieId', 'rating']], Reader(rating_scale=(min_value, max_value)))\n",
    "\n",
    "print('Min value of rating:', min_value)\n",
    "print('Max value of rating:', max_value)\n",
    "print('Possible values assumed by ratings:', all_values)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da una prima osservazione dal data set, possiamo notare che le valutazioni degli utenti sono comprese tra 0.5 e 5.0.  \n",
    "Inoltre, i valori sono definiti con un passo di 0.5. Ciò significa che una valutazione non potrà assumere, ad esempio, il valore 3.7."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analisi dei dati\n",
    "\n",
    "Dal data frame delle valutazioni, possiamo calcolare alcuni proprietà specifiche per ogni utente.  \n",
    "Creiamo dunque il data frame `users_dataset` che sarà popolato da alcune informazioni ottenute dal data frame `rating_dataset`, quali:\n",
    "- `mean`: la media aritmetica dei rating dell'utente\n",
    "- `weighted_mean`: la media pesata dei rating dell'utente, utilizzando il timestamp come peso. Durante il calcolo, normalizziamo i timestamp in modo che siano compresi in un intervallo definito fra 0.5 e 1.5.\n",
    "- `mean_diff`: la differenza fra la media aritmetica e la media pesata dell'utente\n",
    "- `time_diff`: la differenza fra il timestamp della prima valutazione dell'utente e il timestamp dell'ultima valutazione dell'utente.\n",
    "\n",
    "Calcoliamo dunque queste informazioni per ogni utente e popoliamo il data frame `users_dataset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>weighted_mean</th>\n",
       "      <th>mean_diff</th>\n",
       "      <th>time_diff</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>userId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.366379</td>\n",
       "      <td>4.363284</td>\n",
       "      <td>0.003095</td>\n",
       "      <td>739163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.948276</td>\n",
       "      <td>4.007142</td>\n",
       "      <td>0.058866</td>\n",
       "      <td>505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.435897</td>\n",
       "      <td>2.287578</td>\n",
       "      <td>0.148320</td>\n",
       "      <td>970</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.555556</td>\n",
       "      <td>3.480049</td>\n",
       "      <td>0.075507</td>\n",
       "      <td>62496114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>3.636364</td>\n",
       "      <td>3.667064</td>\n",
       "      <td>0.030700</td>\n",
       "      <td>590</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>606</th>\n",
       "      <td>3.657399</td>\n",
       "      <td>3.640449</td>\n",
       "      <td>0.016951</td>\n",
       "      <td>197231731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>607</th>\n",
       "      <td>3.786096</td>\n",
       "      <td>3.710835</td>\n",
       "      <td>0.075261</td>\n",
       "      <td>34768995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>608</th>\n",
       "      <td>3.134176</td>\n",
       "      <td>3.250530</td>\n",
       "      <td>0.116354</td>\n",
       "      <td>72402187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>609</th>\n",
       "      <td>3.270270</td>\n",
       "      <td>3.238706</td>\n",
       "      <td>0.031564</td>\n",
       "      <td>278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>610</th>\n",
       "      <td>3.688556</td>\n",
       "      <td>3.589850</td>\n",
       "      <td>0.098706</td>\n",
       "      <td>16417448</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>610 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            mean  weighted_mean  mean_diff  time_diff\n",
       "userId                                               \n",
       "1       4.366379       4.363284   0.003095     739163\n",
       "2       3.948276       4.007142   0.058866        505\n",
       "3       2.435897       2.287578   0.148320        970\n",
       "4       3.555556       3.480049   0.075507   62496114\n",
       "5       3.636364       3.667064   0.030700        590\n",
       "...          ...            ...        ...        ...\n",
       "606     3.657399       3.640449   0.016951  197231731\n",
       "607     3.786096       3.710835   0.075261   34768995\n",
       "608     3.134176       3.250530   0.116354   72402187\n",
       "609     3.270270       3.238706   0.031564        278\n",
       "610     3.688556       3.589850   0.098706   16417448\n",
       "\n",
       "[610 rows x 4 columns]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "users_list = rating_dataset['userId'].unique().tolist()\n",
    "users_dataset = pd.DataFrame(columns=['mean', 'weighted_mean', 'mean_diff', 'time_diff'])\n",
    "users_dataset.index.name = 'userId'\n",
    "\n",
    "def map_range(x: float, in_min: float, in_max: float, out_min = 0.5, out_max = 1.5) -> float:\n",
    "    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min\n",
    "\n",
    "for user in users_list:\n",
    "    single_ratings = rating_dataset[rating_dataset['userId'] == user]\n",
    "    single_last_timestamp = single_ratings['timestamp'].max()\n",
    "    single_first_timestamp = single_ratings['timestamp'].min()\n",
    "    user_ratings = single_ratings['rating'].tolist()\n",
    "    user_timestamps = list(map(lambda x: map_range(x, single_first_timestamp, single_last_timestamp), single_ratings['timestamp'].tolist()))\n",
    "    user_mean = np.mean(user_ratings)\n",
    "    user_weighted_mean = np.average(user_ratings, weights=user_timestamps)\n",
    "    user_mean_diff = abs(user_mean - user_weighted_mean)\n",
    "    user_time_diff = single_last_timestamp - single_first_timestamp\n",
    "    users_dataset = pd.concat([users_dataset, pd.DataFrame([[user_mean, user_weighted_mean, user_mean_diff, user_time_diff]], columns=['mean', 'weighted_mean', 'mean_diff', 'time_diff'], index=[user])])\n",
    "    users_dataset.index.name = 'userId'\n",
    "    \n",
    "users_dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una volta calcolate queste informazioni, possiamo visualizzarle in dei grafici.  \n",
    "I primi due grafici mostrano la distribuzione dei valori di `mean` e `weighted_mean` in modo da poter visualizzare eventuali differenze fra le due."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "(fig, axis) = plt.subplots(nrows = 1, ncols = 2, figsize=(24, 6))\n",
    "axis[0].hist(users_dataset['mean'], bins = 20, color = 'tomato')\n",
    "axis[0].set_title('Frequency of mean ratings')\n",
    "axis[0].set_xlabel('Mean')\n",
    "axis[0].set_ylabel('Frequency')\n",
    "axis[1].hist(users_dataset['weighted_mean'], bins = 20, color = 'darkorange')\n",
    "axis[1].set_title('Frequency of weighted mean ratings')\n",
    "axis[1].set_xlabel('Weighted mean')\n",
    "axis[1].set_ylabel('Frequency')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ad una prima impressione, notiamo che l'istogramma della media pesata è leggermente spostato verso destra rispetto a quello della media aritmetica.  \n",
    "Ciò significa che il calcolo della media pesata, nella maggioranza degli utenti del dataset, ha portato ad un valore maggiore rispetto alla media aritmetica."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il terzo grafico mostra, per ogni utente, un punto caratterizzato dai valori `(mean, weighted_mean)`.  \n",
    "Questo grafico ci viene in aiuto per verificare per quanti utenti la media pesata è maggiore della media aritmetica.\n",
    "\n",
    "Il quarto grafico mostra, per ogni utente, un punto caratterizzato dai valori `(mean_diff, time_diff)`.  \n",
    "Questo grafico ci permette di verificare se, all'aumentare della differenza fra le due medie, aumenta anche la differenza fra i timestamp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Time difference')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "(fig, axis) = plt.subplots(nrows = 1, ncols = 2, figsize=(24, 6))\n",
    "axis[0].plot(users_dataset['mean'], users_dataset['weighted_mean'], 'o', color = 'orange')\n",
    "axis[0].plot([0.5, 5.0], [0.5, 5.0], '-', color = 'tab:blue')\n",
    "axis[0].set_title('Difference between mean and weighted mean')\n",
    "axis[0].set_xlabel('Mean')\n",
    "axis[0].set_ylabel('Weighted mean')\n",
    "axis[1].plot(users_dataset['mean_diff'], users_dataset['time_diff'], 'o', color = 'limegreen')\n",
    "axis[1].set_title('Correlation between mean difference and time difference')\n",
    "axis[1].set_xlabel('Mean difference')\n",
    "axis[1].set_ylabel('Time difference')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da una analisi del terzo grafico, notiamo che la maggior parte dei punti sono molto vicini alla retta `y = x`, che rappresenta l'uguaglianza fra i due valori.  \n",
    "Inoltre, notiamo che molti punti sono posizionati sopra la retta. Quindi, come hanno mostrato i primi due grafici, la media pesata è maggiore della media aritmetica per un buon numero di utenti.\n",
    "\n",
    "Analizzando invece il quarto grafico, notiamo che i punti sono distribuiti principalmente nella parte bassa del grafico.  \n",
    "Questo ci permette di affermare che non è detto che all'aumentare della differenza fra le due medie, aumenti anche la differenza fra i timestamp."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predizioni dei rating con sistemi integrati in `surprise`\n",
    "\n",
    "Iniziamo la creazione ed il test dei sistemi di raccomandazione forniti dalla libreria `surprise`.  \n",
    "Per iniziare, occorre prendere il data set e suddividerlo in due parti:\n",
    "- **Training set**, un sottoinsieme del data set utilizzato per addestrare il sistema di raccomandazione. Su questi dati, l'algoritmo cerca di creare un modello che permetta di predire i rating degli utenti.\n",
    "- **Test set**, un sottoinsieme del data set utilizzato per testare il sistema di raccomandazione. Su questi dati, l'algoritmo cerca di predire i rating degli utenti utilizzando il modello creato con il training set. I rating predetti vengono poi confrontati con i rating reali per calcolare le performance del sistema di raccomandazione.\n",
    "\n",
    "Per poter suddividere il data set, possiamo utilizzare due metodi differenti:\n",
    "- **Split**, implica la suddivisione del dataset in due parti, una per il training e l'altra per il testing. Nel nostro caso, il training set contiene l'80% del dataset mentre il test set contiene il restante 20%. Questa tecnica è semplice e veloce da implementare, tuttavia, una suddivisione non accurata (ad esempio, non tenendo conto del bilanciamento del dataset) può influenzare negativamente le performance del sistema di raccomandazione. La libreria `surprise` fornisce un metodo per effettuare lo split del dataset, chiamato `train_test_split()`.\n",
    "- **Cross Validation**, prevede di suddividere il dataset in `k` parti uguali, chiamate fold (da qui il nome `k-fold`). Il modello viene poi addestrato su `k-1` fold e testato sul fold rimanente. Questo processo viene ripetuto k volte, utilizzando un fold differente come test set ad ogni ripetizione. In questo modo, ogni osservazione viene utilizzata sia per il training che per il testing. Questa tecnica può essere utile per valutare il modello in modo più accurato, riducendo l'effetto della scelta casuale dei dati di training e testing ottenuti con un semplice split. La libreria `surprise` fornisce una classe, chiamata `KFold`, che permette di effettuare la cross validation.\n",
    "\n",
    "Una volta addestrato e testato il sistema di raccomandazione, possiamo calcolare le sue performance utilizzando le seguenti metriche:\n",
    "- **RMSE** (Root Mean Squared Error), misura l'errore medio del sistema di raccomandazione, che viene calcolata come la radice quadrata della media dei quadrati delle differenze tra le valutazioni previste e quelle effettive degli utenti.  \n",
    "La sua formula è:\n",
    "$$\n",
    "RMSE = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n}(y_i - \\hat{y_i})^2}\n",
    "$$\n",
    "- **MSE** (Mean Squared Error), misura l'errore medio del sistema di raccomandazione, che viene calcolata come la media dei quadrati delle differenze tra le valutazioni previste e quelle effettive degli utenti.  \n",
    "La sua formula è:\n",
    "$$\n",
    "MSE = \\frac{1}{n}\\sum_{i=1}^{n}(y_i - \\hat{y_i})^2\n",
    "$$\n",
    "- **MAE** (Mean Absolute Error), misura l'errore medio del sistema di raccomandazione, che viene calcolata come la media dei valori assoluti delle differenze tra le valutazioni previste e quelle effettive degli utenti.   \n",
    "La sua formula è:\n",
    "$$\n",
    "MAE = \\frac{1}{n}\\sum_{i=1}^{n}|y_i - \\hat{y_i}|\n",
    "$$\n",
    "\n",
    "Creiamo una funzione chiamata `test_algorithm()` che ci permette di addestrare, testare e calcolare le performance di un sistema di raccomandazione.\n",
    "Creiamo anche una funzione chiamata `format_results()` che ci permette di formattare i risultati ottenuti dalla funzione `test_algorithm()`, in modo da poterli organizzare in un data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise import AlgoBase, Trainset, accuracy\n",
    "from surprise.model_selection import KFold, train_test_split\n",
    "\n",
    "\n",
    "def test_algorithm(algorithm: AlgoBase) -> tuple[dict[str, float], dict[str, np.ndarray]]:\n",
    "    train, test = train_test_split(elaborated_data, test_size=0.2)\n",
    "    algorithm.fit(train)\n",
    "    split_predictions = algorithm.test(test)\n",
    "    split_predictions_measure = dict[str, float]()\n",
    "    split_predictions_measure['rmse'] = accuracy.rmse(split_predictions, verbose=False)\n",
    "    split_predictions_measure['mae'] = accuracy.mae(split_predictions, verbose=False)\n",
    "    split_predictions_measure['mse'] = accuracy.mse(split_predictions, verbose=False)\n",
    "    \n",
    "    kf = KFold(n_splits=5)\n",
    "    cross_predictions_measure = dict[str, np.ndarray]()\n",
    "    cross_predictions_measure['rmse'] = np.array([])\n",
    "    cross_predictions_measure['mae'] = np.array([])\n",
    "    cross_predictions_measure['mse'] = np.array([])\n",
    "    for k_train, k_test in kf.split(elaborated_data):\n",
    "        algorithm.fit(k_train)\n",
    "        k_predictions = algorithm.test(k_test)\n",
    "        cross_predictions_measure['rmse'] = np.append(cross_predictions_measure['rmse'], accuracy.rmse(k_predictions, verbose=False))\n",
    "        cross_predictions_measure['mae'] = np.append(cross_predictions_measure['mae'], accuracy.mae(k_predictions, verbose=False))\n",
    "        cross_predictions_measure['mse'] = np.append(cross_predictions_measure['mse'], accuracy.mse(k_predictions, verbose=False))\n",
    "    \n",
    "    return (split_predictions_measure, cross_predictions_measure)\n",
    "\n",
    "def format_results(algo_name: str, results: tuple[dict[str, float], dict[str, np.ndarray]]) -> pd.DataFrame:\n",
    "    return pd.DataFrame({\n",
    "        'Split RMSE': results[0]['rmse'], \n",
    "        'Split MAE': results[0]['mae'], \n",
    "        'Split MSE': results[0]['mse'], \n",
    "        'Cross RMSE': results[1]['rmse'].mean(), \n",
    "        'Cross MAE': results[1]['mae'].mean(), \n",
    "        'Cross MSE': results[1]['mse'].mean()\n",
    "    }, index=[algo_name])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creiamo una lista di `AlgoBase` (la classe con cui la libreria costruisce tutti i sistemi), chiamata `algorithms`, che contiene i seguenti algoritmi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "algorithms: list[AlgoBase] = []"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NormalPredictor\n",
    "Il predittore normale è un semplice algoritmo di raccomandazione che restituisce una valutazione casuale, calcolata dalla distribuzione dei dati del training set.  \n",
    "Questo algoritmo stima i parametri della distribuzione normale (cioè media e varianza) basandosi sul [metodo della massima verosimiglianza](https://it.wikipedia.org/wiki/Metodo_della_massima_verosimiglianza).  \n",
    "Affinché questo funzioni correttamente, è necessario che il dataset sia distribuito normalmente secondo la colonna `rating`.  \n",
    "Per verificare questa ipotesi, utilizziamo il test di [Shapiro-Wilk](https://it.wikipedia.org/wiki/Test_di_Shapiro-Wilk), fornitoci dalla libreria `scipy`. \n",
    "Utilizziamo il secondo parametro restituito, rappresentante il p-value, per verificare se i dati sono normalmente distribuiti. Ciò significa il p-value deve essere maggiore di 0.05. \n",
    "\n",
    "Poiché il test funziona al meglio con un massimo di 5000 valori, utilizziamo la tecnica di **bootstrap** per creare diversi sample di 5000 elementi ciascuno. Questa tecnica di split ci permette di mantenere la distribuzione dei dati, ma di ridurre la dimensione del dataset. Nel nostro caso, creiamo 50 sample da 5000 elementi ciascuno. Se i sample che seguono la distribuzione normale sono maggiori di quelli che non la seguono, possiamo dire che il dataset è distribuito normalmente secondo la colonna `rating`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I dati non sono normalmente distribuiti\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import shapiro\n",
    "from surprise.prediction_algorithms import NormalPredictor\n",
    "\n",
    "data = np.array(rating_dataset['rating'].tolist())\n",
    "n_bootstraps = 50\n",
    "bootstrap_samples_size = 5000\n",
    "samples = np.random.choice(data, size=(n_bootstraps, bootstrap_samples_size), replace=True)\n",
    "positive_samples = 0\n",
    "negative_samples = 0\n",
    "\n",
    "for sample in samples:\n",
    "    stat, p = shapiro(sample)\n",
    "    alpha = 0.05\n",
    "    if p > alpha:\n",
    "        positive_samples += 1\n",
    "    else:\n",
    "        negative_samples += 1\n",
    "        \n",
    "if positive_samples > negative_samples:\n",
    "    print('I dati sono normalmente distribuiti')\n",
    "    algorithms.append(NormalPredictor())\n",
    "else:\n",
    "    print('I dati non sono normalmente distribuiti')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poiché i dati non sono normalmente distribuiti, non possiamo utilizzare questo algoritmo."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predittori basati sulla fattorizzazione della matrice\n",
    "La fattorizzazione di una matrice è una tecnica matematica che permette di rappresentare una matrice come prodotto di altre matrici più semplici.  \n",
    "Fra i sistemi di raccomandazione che implementano questa tecnica, abbiamo:\n",
    "- **SVD** (Singular Value Decomposition), ci permette di scomporre una matrice $A$ in tre parti: una matrice unitaria di sinistra $U$, una matrice diagonale di valori singolari $\\Sigma$ e una matrice unitaria di destra $V$. I valori singolari rappresentano l'importanza relativa di ciascuna delle colonne di $U$ e di $V$ nella rappresentazione della matrice originale $A$.\n",
    "- **SVD++** (Singular Value Decomposition Plus Plus), una variante dell'algoritmo SVD, presentata da Simon Funk durante il concorso di Netflix. Questo algoritmo tiene conto anche di altre informazioni esterne alle valutazioni (cronologia visualizzazioni, popolarità fra gli utenti) per migliorare le performance del sistema di raccomandazione.\n",
    "- **NMF** (Non-negative Matrix Factorization), ci permette di scomporre una matrice $A$ in due matrici $W$ e $H$, in modo che il prodotto di queste due matrici sia il più simile possibile alla matrice originale $A$. Questo algoritmo è molto simile a SVD, tuttavia, le matrici $W$ e $H$ conterranno solo valori positivi. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise.prediction_algorithms import NMF, SVD, SVDpp\n",
    "\n",
    "algorithms.extend([SVD(), SVDpp(), NMF()])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predittori basati su KNN\n",
    "Gli algoritmi basati su KNN (K-Nearest Neighbors) sono algoritmi che stimano il rating basandosi sui k utenti (o item) più simili all'utente (o item) di cui si vuole stimare il rating.  \n",
    "Esistono diverse varianti che normalizzano i rating in modo diverso:\n",
    "- **KNNBasic**, i rating non sono normalizzati\n",
    "- **KNNWithMeans**, i rating sono normalizzati sottraendo la media degli utenti (o item)\n",
    "- **KNNWithZScore**, i rating sono normalizzati sottraendo la media degli utenti (o item) e dividendo per la deviazione standard\n",
    "- **KNNBaseline**, i rating sono normalizzati sottraendo un termine di baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise import KNNBaseline, KNNBasic, KNNWithMeans, KNNWithZScore\n",
    "\n",
    "algorithms.extend([KNNBaseline(k=40, verbose=False), KNNBasic(k=40, verbose=False), KNNWithMeans(k=40, verbose=False), KNNWithZScore(k=40, verbose=False)])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Altri predittori\n",
    "Altri predittori degni di nota sono:\n",
    "- **SlopeOne**, è un algoritmo di raccomandazione collaborativo che si basa sulle differenze medie tra le valutazioni degli utenti. Ad esempio, se un utente U ha valutato l'oggetto A con una valutazione di 4 e la differenza media tra l'item A e l'item C è di 2, allora l'algoritmo assegna all'item C, per l'utente U, una valutazione di 6.\n",
    "- **CoClustering**, è un algoritmo di clustering collaborativo, dove utenti ed item sono raggruppati in cluster cercando di massimizzare la similarità tra gli utenti e gli item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise.prediction_algorithms import CoClustering, SlopeOne\n",
    "\n",
    "algorithms.extend([SlopeOne(), CoClustering()])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dopo aver creato la lista di algoritmi, creiamo un data frame, chiamato `results`, che conterrà i risultati di tutti gli algoritmi.  \n",
    "Eseguiamo ogni algoritmo con la funzione creata prima e salviamo i risultati nel data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Split RMSE</th>\n",
       "      <th>Split MAE</th>\n",
       "      <th>Split MSE</th>\n",
       "      <th>Cross RMSE</th>\n",
       "      <th>Cross MAE</th>\n",
       "      <th>Cross MSE</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Algorithm Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>SVD</th>\n",
       "      <td>0.866508</td>\n",
       "      <td>0.666745</td>\n",
       "      <td>0.750836</td>\n",
       "      <td>0.873731</td>\n",
       "      <td>0.670925</td>\n",
       "      <td>0.763433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SVDpp</th>\n",
       "      <td>0.867114</td>\n",
       "      <td>0.665156</td>\n",
       "      <td>0.751886</td>\n",
       "      <td>0.860830</td>\n",
       "      <td>0.659707</td>\n",
       "      <td>0.741051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NMF</th>\n",
       "      <td>0.937051</td>\n",
       "      <td>0.713942</td>\n",
       "      <td>0.878065</td>\n",
       "      <td>0.923069</td>\n",
       "      <td>0.706289</td>\n",
       "      <td>0.852130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNBaseline</th>\n",
       "      <td>0.879233</td>\n",
       "      <td>0.673030</td>\n",
       "      <td>0.773051</td>\n",
       "      <td>0.875976</td>\n",
       "      <td>0.668948</td>\n",
       "      <td>0.767360</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNBasic</th>\n",
       "      <td>0.939662</td>\n",
       "      <td>0.721510</td>\n",
       "      <td>0.882964</td>\n",
       "      <td>0.948517</td>\n",
       "      <td>0.726577</td>\n",
       "      <td>0.899704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNWithMeans</th>\n",
       "      <td>0.904090</td>\n",
       "      <td>0.692484</td>\n",
       "      <td>0.817379</td>\n",
       "      <td>0.896989</td>\n",
       "      <td>0.685032</td>\n",
       "      <td>0.804644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNWithZScore</th>\n",
       "      <td>0.892622</td>\n",
       "      <td>0.678955</td>\n",
       "      <td>0.796774</td>\n",
       "      <td>0.895530</td>\n",
       "      <td>0.679851</td>\n",
       "      <td>0.801988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SlopeOne</th>\n",
       "      <td>0.904516</td>\n",
       "      <td>0.690274</td>\n",
       "      <td>0.818150</td>\n",
       "      <td>0.901568</td>\n",
       "      <td>0.688619</td>\n",
       "      <td>0.812843</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CoClustering</th>\n",
       "      <td>0.954063</td>\n",
       "      <td>0.740656</td>\n",
       "      <td>0.910236</td>\n",
       "      <td>0.945268</td>\n",
       "      <td>0.731450</td>\n",
       "      <td>0.893555</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Split RMSE  Split MAE  Split MSE  Cross RMSE  Cross MAE   \n",
       "Algorithm Name                                                            \n",
       "SVD               0.866508   0.666745   0.750836    0.873731   0.670925  \\\n",
       "SVDpp             0.867114   0.665156   0.751886    0.860830   0.659707   \n",
       "NMF               0.937051   0.713942   0.878065    0.923069   0.706289   \n",
       "KNNBaseline       0.879233   0.673030   0.773051    0.875976   0.668948   \n",
       "KNNBasic          0.939662   0.721510   0.882964    0.948517   0.726577   \n",
       "KNNWithMeans      0.904090   0.692484   0.817379    0.896989   0.685032   \n",
       "KNNWithZScore     0.892622   0.678955   0.796774    0.895530   0.679851   \n",
       "SlopeOne          0.904516   0.690274   0.818150    0.901568   0.688619   \n",
       "CoClustering      0.954063   0.740656   0.910236    0.945268   0.731450   \n",
       "\n",
       "                Cross MSE  \n",
       "Algorithm Name             \n",
       "SVD              0.763433  \n",
       "SVDpp            0.741051  \n",
       "NMF              0.852130  \n",
       "KNNBaseline      0.767360  \n",
       "KNNBasic         0.899704  \n",
       "KNNWithMeans     0.804644  \n",
       "KNNWithZScore    0.801988  \n",
       "SlopeOne         0.812843  \n",
       "CoClustering     0.893555  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algorithms_results = pd.DataFrame(columns=['Split RMSE', 'Split MAE', 'Split MSE', 'Cross RMSE', 'Cross MAE', 'Cross MSE'])\n",
    "algorithms_results.index.name = 'Algorithm Name'\n",
    "\n",
    "for algo in algorithms:\n",
    "    split_result, cross_result = test_algorithm(algo)\n",
    "    result_df = format_results(algo.__class__.__name__, (split_result, cross_result))\n",
    "    algorithms_results = pd.concat([algorithms_results, result_df])\n",
    "    algorithms_results.index.name = 'Algorithm Name'\n",
    "    \n",
    "algorithms_results"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predizione dei rating con media pesata\n",
    "\n",
    "Una possibile variante del sistema `KNNWithMeans` è quella di normalizzare i rating utilizzando una media pesata delle valutazioni (utilizzando i timestamp come pesi) invece della media aritmetica. \n",
    "\n",
    "Per creare una sistema di raccomandazione personalizzato, `surprise` ci permette di creare delle nuove classi che ereditano da quelle già esistenti.  \n",
    "Creiamo una nuova classe chiamata `KNNWithMeansWeighted` che eredita dalla classe `KNNWithMeans` e sovrascrive il metodo `fit()`. All'interno del metodo vengono infatti effettuati i calcoli per trovare la media delle valutazioni per utenti.  \n",
    "Per una limitazione della libreria (i timestamp non vengono presi in considerazione nella creazione dei dataset), non è possibile fare il calcolo direttamente all'interno del metodo, ma possiamo utilizzare l'id utente per poter accedere al data frame degli utenti e recuperare la media pesata che abbiamo calcolato in precedenza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KNNWithWeightedMeans(KNNWithMeans):\n",
    "    def __init__(self, k=40, min_k=1, sim_options={}, verbose=False):\n",
    "        super().__init__(k, min_k, sim_options, verbose)\n",
    "        \n",
    "    __name__ = 'KNNWithWeightedMeans'\n",
    "        \n",
    "    def fit(self, trainset: Trainset):\n",
    "        super().fit(trainset)\n",
    "        self.means = np.zeros(self.n_x)\n",
    "        for x, _ in self.xr.items():\n",
    "            user_id = trainset.to_raw_uid(x)\n",
    "            weighted_mean = users_dataset.loc[user_id]['weighted_mean']\n",
    "            self.means[x] = weighted_mean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una volta creata la classe, possiamo utilizzarla come qualsiasi altro predittore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Split RMSE</th>\n",
       "      <th>Split MAE</th>\n",
       "      <th>Split MSE</th>\n",
       "      <th>Cross RMSE</th>\n",
       "      <th>Cross MAE</th>\n",
       "      <th>Cross MSE</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Algorithm Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>SVD</th>\n",
       "      <td>0.866508</td>\n",
       "      <td>0.666745</td>\n",
       "      <td>0.750836</td>\n",
       "      <td>0.873731</td>\n",
       "      <td>0.670925</td>\n",
       "      <td>0.763433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SVDpp</th>\n",
       "      <td>0.867114</td>\n",
       "      <td>0.665156</td>\n",
       "      <td>0.751886</td>\n",
       "      <td>0.860830</td>\n",
       "      <td>0.659707</td>\n",
       "      <td>0.741051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NMF</th>\n",
       "      <td>0.937051</td>\n",
       "      <td>0.713942</td>\n",
       "      <td>0.878065</td>\n",
       "      <td>0.923069</td>\n",
       "      <td>0.706289</td>\n",
       "      <td>0.852130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNBaseline</th>\n",
       "      <td>0.879233</td>\n",
       "      <td>0.673030</td>\n",
       "      <td>0.773051</td>\n",
       "      <td>0.875976</td>\n",
       "      <td>0.668948</td>\n",
       "      <td>0.767360</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNBasic</th>\n",
       "      <td>0.939662</td>\n",
       "      <td>0.721510</td>\n",
       "      <td>0.882964</td>\n",
       "      <td>0.948517</td>\n",
       "      <td>0.726577</td>\n",
       "      <td>0.899704</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNWithMeans</th>\n",
       "      <td>0.904090</td>\n",
       "      <td>0.692484</td>\n",
       "      <td>0.817379</td>\n",
       "      <td>0.896989</td>\n",
       "      <td>0.685032</td>\n",
       "      <td>0.804644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNWithZScore</th>\n",
       "      <td>0.892622</td>\n",
       "      <td>0.678955</td>\n",
       "      <td>0.796774</td>\n",
       "      <td>0.895530</td>\n",
       "      <td>0.679851</td>\n",
       "      <td>0.801988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SlopeOne</th>\n",
       "      <td>0.904516</td>\n",
       "      <td>0.690274</td>\n",
       "      <td>0.818150</td>\n",
       "      <td>0.901568</td>\n",
       "      <td>0.688619</td>\n",
       "      <td>0.812843</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CoClustering</th>\n",
       "      <td>0.954063</td>\n",
       "      <td>0.740656</td>\n",
       "      <td>0.910236</td>\n",
       "      <td>0.945268</td>\n",
       "      <td>0.731450</td>\n",
       "      <td>0.893555</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNNWithWeightedMeans</th>\n",
       "      <td>0.894051</td>\n",
       "      <td>0.680652</td>\n",
       "      <td>0.799327</td>\n",
       "      <td>0.895835</td>\n",
       "      <td>0.684486</td>\n",
       "      <td>0.802546</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      Split RMSE  Split MAE  Split MSE  Cross RMSE  Cross MAE   \n",
       "Algorithm Name                                                                  \n",
       "SVD                     0.866508   0.666745   0.750836    0.873731   0.670925  \\\n",
       "SVDpp                   0.867114   0.665156   0.751886    0.860830   0.659707   \n",
       "NMF                     0.937051   0.713942   0.878065    0.923069   0.706289   \n",
       "KNNBaseline             0.879233   0.673030   0.773051    0.875976   0.668948   \n",
       "KNNBasic                0.939662   0.721510   0.882964    0.948517   0.726577   \n",
       "KNNWithMeans            0.904090   0.692484   0.817379    0.896989   0.685032   \n",
       "KNNWithZScore           0.892622   0.678955   0.796774    0.895530   0.679851   \n",
       "SlopeOne                0.904516   0.690274   0.818150    0.901568   0.688619   \n",
       "CoClustering            0.954063   0.740656   0.910236    0.945268   0.731450   \n",
       "KNNWithWeightedMeans    0.894051   0.680652   0.799327    0.895835   0.684486   \n",
       "\n",
       "                      Cross MSE  \n",
       "Algorithm Name                   \n",
       "SVD                    0.763433  \n",
       "SVDpp                  0.741051  \n",
       "NMF                    0.852130  \n",
       "KNNBaseline            0.767360  \n",
       "KNNBasic               0.899704  \n",
       "KNNWithMeans           0.804644  \n",
       "KNNWithZScore          0.801988  \n",
       "SlopeOne               0.812843  \n",
       "CoClustering           0.893555  \n",
       "KNNWithWeightedMeans   0.802546  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algo = KNNWithWeightedMeans(k=40, verbose=False)\n",
    "split_result, cross_result = test_algorithm(algo)\n",
    "result_df = format_results(algo.__class__.__name__, (split_result, cross_result))\n",
    "algorithms_results = pd.concat([algorithms_results, result_df])\n",
    "algorithms_results.index.name = 'Algorithm Name'\n",
    "\n",
    "algorithms_results"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predizione binaria\n",
    "\n",
    "I sistemi di raccomandazione sono in grado di lavorare anche con rating binari, dove i valori sono:\n",
    "- `0`, se l'utente non gradisce l'item\n",
    "- `1`, se l'utente gradisce l'item\n",
    "\n",
    "Per poter utilizzare un predittore binario, dobbiamo convertire i rating reali in rating binari.  \n",
    "Utilizzeremo una soglia, chiamata `binary_threshold`, calcolata attraverso la media delle valutazioni dei rating reali.  \n",
    "Copiamo il data frame delle valutazioni in un nuovo data frame, chiamato `binarized_df`, e applichiamo, sulla colonna delle valutazioni, una funzione lambda che restituisce `1` se il rating è maggiore o uguale alla soglia, altrimenti restituisce `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_threshold = np.mean(rating_dataset['rating'].tolist())\n",
    "binarized_df = rating_dataset.copy()\n",
    "binarized_df['rating'] = binarized_df['rating'].apply(lambda x: 1 if x >= binary_threshold else 0)\n",
    "\n",
    "binarized_data = Dataset.load_from_df(binarized_df[['userId', 'movieId', 'rating']], reader=Reader(rating_scale=(0, 1)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nella predizione binaria, cambiano anche le metriche di valutazione:\n",
    "- **TP** (True Positive), numero di rating positivi predetti correttamente\n",
    "- **TN** (True Negative), numero di rating negativi predetti correttamente\n",
    "- **FP** (False Positive), numero di rating negativi predetti erroneamente\n",
    "- **FN** (False Negative), numero di rating positivi predetti erroneamente\n",
    "\n",
    "A partire da questo quattro metriche, possiamo calcolare altre metriche come:\n",
    "- **Accuracy**, percentuale di rating predetti correttamente\n",
    "- **Precision**, percentuale di rating positivi predetti correttamente\n",
    "- **Recall**, percentuale di rating positivi predetti correttamente rispetto al numero di rating positivi reali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise import Prediction\n",
    "\n",
    "def tp(predictions: list[Prediction]) -> int:\n",
    "    return len([1 for p in predictions if p.est == p.r_ui and p.r_ui == 1])\n",
    "    \n",
    "def tn(predictions: list[Prediction]) -> int:\n",
    "    return len([1 for p in predictions if p.est == p.r_ui and p.r_ui == 0])\n",
    "\n",
    "def fp(predictions: list[Prediction]) -> int:\n",
    "    return len([1 for p in predictions if p.est != p.r_ui and p.r_ui == 0])\n",
    "\n",
    "def fn(predictions: list[Prediction]) -> int:\n",
    "    return len([1 for p in predictions if p.est != p.r_ui and p.r_ui == 1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Occorre anche creare un predittore binario poiché la libreria `surprise` non lo fornisce.  \n",
    "È importante ricordare che i predittori binari seguono logiche diverse rispetto ai predittori reali.    \n",
    "La prima cosa che cambia è il calcolo della similarità fra utenti. La misura utilizzata infatti sarà la similarità di Jaccard, definita come:\n",
    "$$\n",
    "J(A,B) = \\frac{|A \\cap B|}{|A \\cup B|}\n",
    "$$\n",
    "dove $A$ e $B$ sono due insiemi. Questa misura corrisponde alla percentuale di elementi in comune fra i due insiemi rispetto al numero totale di elementi.  \n",
    "Per questo motivo, la funzione `compute_similarities()` viene sovrascritta e viene calcolata la similarità di Jaccard fra gli utenti.  \n",
    "Inoltre, i sistemi binari restituiscono predizioni dove i valori sono solamente due, cioè:\n",
    "- `0`, se è più probabile che l'utente non gradisca l'item\n",
    "- `1`, se è più probabile che l'utente gradisca l'item\n",
    "\n",
    "Per questo motivo, la funzione `estimate()` viene sovrascritta e restituisce la mediana fra tutti i rating, in modo che venga restituito quale fra i valori `0` e `1` compare più spesso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BinaryPredictor(AlgoBase):\n",
    "    \n",
    "    __name__ = 'BinaryPredictor'\n",
    "    \n",
    "    def fit(self, trainset):\n",
    "        super().fit(trainset)\n",
    "        self.sim = self.compute_similarities()\n",
    "    \n",
    "    def estimate(self, u, i):\n",
    "        neighbors = self.get_neighbors(u, i)\n",
    "        if len(neighbors) == 0:\n",
    "            return 0\n",
    "        else:\n",
    "            return np.median([r for (_, _, r) in neighbors])\n",
    "            \n",
    "    # Compute Jaccard similarity between users u and v\n",
    "    def similarity(self, u, v):\n",
    "        u_items = set([i for (i, _) in self.trainset.ur[u]])\n",
    "        v_items = set([i for (i, _) in self.trainset.ur[v]])\n",
    "        \n",
    "        union = u_items.union(v_items)\n",
    "        intersection = u_items.intersection(v_items)\n",
    "        \n",
    "        return len(intersection) / len(union)\n",
    "            \n",
    "    # Compute all similarities between users\n",
    "    def compute_similarities(self):\n",
    "        sim = np.zeros((self.trainset.n_users, self.trainset.n_users), np.double)\n",
    "        for u in range(self.trainset.n_users):\n",
    "            for v in range(self.trainset.n_users):\n",
    "                sim[u, v] = self.similarity(u, v)\n",
    "        return sim\n",
    "    \n",
    "    # Get the k-nearest neighbors of user u that have rated item i\n",
    "    def get_neighbors(self, u, i):\n",
    "        neighbors = [(u2, self.sim[u, u2], r) for (u2, r) in self.trainset.ir[i]]\n",
    "        neighbors = sorted(neighbors, key=lambda x: x[1], reverse=True)\n",
    "        return [(v, sim_uv, r) for (v, sim_uv, r) in neighbors[:40] if sim_uv > 0.5]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una volta creato il predittore binario e le metriche di valutazione, possiamo creare una funzione che lo esegue e calcola le metriche di valutazione, chiamata `test_binary_algorithm()`. Essa è molto simile alla funzione `test_algorithm()` creata in precedenza, ma utilizza il il dataset binario e le metriche di valutazione binarie.  \n",
    "Inoltre, creiamo anche una funzione `format_binary_results()` che formatta i risultati ottenuti in modo da poterli stampare in modo più leggibile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_binary_algorithm(algorithm: AlgoBase) -> tuple[dict[str, float], dict[str, np.ndarray]]:\n",
    "    train, test = train_test_split(binarized_data, test_size=0.2)\n",
    "    algorithm.fit(train)\n",
    "    split_predictions = algorithm.test(test)\n",
    "    split_predictions_measure = dict[str, float]()\n",
    "    split_predictions_measure['tp'] = tp(split_predictions)\n",
    "    split_predictions_measure['tn'] = tn(split_predictions)\n",
    "    split_predictions_measure['fp'] = fp(split_predictions)\n",
    "    split_predictions_measure['fn'] = fn(split_predictions)\n",
    "    \n",
    "    kf = KFold(n_splits=5)\n",
    "    cross_predictions_measure = dict[str, np.ndarray]()\n",
    "    cross_predictions_measure['tp'] = np.array([])\n",
    "    cross_predictions_measure['tn'] = np.array([])\n",
    "    cross_predictions_measure['fp'] = np.array([])\n",
    "    cross_predictions_measure['fn'] = np.array([])\n",
    "    for k_train, k_test in kf.split(binarized_data):\n",
    "        algorithm.fit(k_train)\n",
    "        k_predictions = algorithm.test(k_test)\n",
    "        cross_predictions_measure['tp'] = np.append(cross_predictions_measure['tp'], tp(k_predictions))\n",
    "        cross_predictions_measure['tn'] = np.append(cross_predictions_measure['tn'], tn(k_predictions))\n",
    "        cross_predictions_measure['fp'] = np.append(cross_predictions_measure['fp'], fp(k_predictions))\n",
    "        cross_predictions_measure['fn'] = np.append(cross_predictions_measure['fn'], fn(k_predictions))\n",
    "    \n",
    "    return (split_predictions_measure, cross_predictions_measure)\n",
    "\n",
    "def format_binary_results(algo_name: str, results: tuple[dict[str, float], dict[str, np.ndarray]]) -> pd.DataFrame:\n",
    "    df = pd.DataFrame({\n",
    "        'Split TP': results[0]['tp'], \n",
    "        'Split TN': results[0]['tn'], \n",
    "        'Split FP': results[0]['fp'], \n",
    "        'Split FN': results[0]['fn'], \n",
    "        'Cross TP': results[1]['tp'].mean(), \n",
    "        'Cross TN': results[1]['tn'].mean(), \n",
    "        'Cross FP': results[1]['fp'].mean(),\n",
    "        'Cross FN': results[1]['fn'].mean(),\n",
    "    }, index=[algo_name])\n",
    "    df.index.name = 'Algorithm Name'\n",
    "    derived_df = pd.DataFrame({\n",
    "        'Split Accuracy': (split_result['tp'] + split_result['tn']) / (split_result['tp'] + split_result['tn'] + split_result['fp'] + split_result['fn']),\n",
    "        'Cross Accuracy': (cross_result['tp'].mean() + cross_result['tn'].mean()) / (cross_result['tp'].mean() + cross_result['tn'].mean() + cross_result['fp'].mean() + cross_result['fn'].mean()),\n",
    "        'Split Precision': split_result['tp'] / (split_result['tp'] + split_result['fp']),\n",
    "        'Cross Precision': cross_result['tp'].mean() / (cross_result['tp'].mean() + cross_result['fp'].mean()),\n",
    "        'Split Recall': split_result['tp'] / (split_result['tp'] + split_result['fn']),\n",
    "        'Cross Recall': cross_result['tp'].mean() / (cross_result['tp'].mean() + cross_result['fn'].mean()),\n",
    "    }, index=[algo.__class__.__name__])\n",
    "    derived_df.index.name = 'Algorithm Name'\n",
    "    return (df, derived_df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creato tutto, possiamo eseguire il predittore binario e calcolare le metriche di valutazione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Split TP</th>\n",
       "      <th>Split TN</th>\n",
       "      <th>Split FP</th>\n",
       "      <th>Split FN</th>\n",
       "      <th>Cross TP</th>\n",
       "      <th>Cross TN</th>\n",
       "      <th>Cross FP</th>\n",
       "      <th>Cross FN</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Algorithm Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BinaryPredictor</th>\n",
       "      <td>3</td>\n",
       "      <td>10489</td>\n",
       "      <td>4</td>\n",
       "      <td>9672</td>\n",
       "      <td>3.0</td>\n",
       "      <td>10448.8</td>\n",
       "      <td>2.4</td>\n",
       "      <td>9713.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Split TP  Split TN  Split FP  Split FN  Cross TP  Cross TN   \n",
       "Algorithm Name                                                                \n",
       "BinaryPredictor         3     10489         4      9672       3.0   10448.8  \\\n",
       "\n",
       "                 Cross FP  Cross FN  \n",
       "Algorithm Name                       \n",
       "BinaryPredictor       2.4    9713.0  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algo = BinaryPredictor()\n",
    "split_result, cross_result = test_binary_algorithm(algo)\n",
    "(result_df, derived_df) = format_binary_results(algo.__class__.__name__, (split_result, cross_result))\n",
    "\n",
    "result_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Split Accuracy</th>\n",
       "      <th>Cross Accuracy</th>\n",
       "      <th>Split Precision</th>\n",
       "      <th>Cross Precision</th>\n",
       "      <th>Split Recall</th>\n",
       "      <th>Cross Recall</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Algorithm Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BinaryPredictor</th>\n",
       "      <td>0.52023</td>\n",
       "      <td>0.518257</td>\n",
       "      <td>0.428571</td>\n",
       "      <td>0.555556</td>\n",
       "      <td>0.00031</td>\n",
       "      <td>0.000309</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Split Accuracy  Cross Accuracy  Split Precision   \n",
       "Algorithm Name                                                     \n",
       "BinaryPredictor         0.52023        0.518257         0.428571  \\\n",
       "\n",
       "                 Cross Precision  Split Recall  Cross Recall  \n",
       "Algorithm Name                                                \n",
       "BinaryPredictor         0.555556       0.00031      0.000309  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "derived_df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusioni\n",
    "\n",
    "Analizzando tutti i predittori, notiamo che le misure di performance per i predittori basati su valori reali si aggirano tutti intorno allo stesso valore. Questo perché, nonostante gli algoritmi effettuino calcoli diversi per predirre le valutazioni, la grandezza del dataset minimizza le differenze fra di essi.  \n",
    "\n",
    "Analizzando la prima variante presentata, ovvero il predittore basato sulla media pesata, notiamo che le performance sono leggermente migliori rispetto al predittore basato sulla media aritmetica. Tuttavia, come visto nella sezione relativa all'analisi dei dati, la media pesata e la media aritmetica differiscono di poco per ogni utente. Questo significa che non sarà possibile ottenere performance molto distanti da quelle ottenute utilizzando il predittore basato la media aritmetica.\n",
    "\n",
    "Analizzando la seconda variante, ovvero il predittore binario, notiamo che le sue performance sono molto basse. La conversione dei rating reali in rating binari ha portato a perdere molte informazioni, ovvero tutti i valori intermedi, rendendo il predittore meno accurato."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.6 ('python-reccomendation-XMPX0F2E')",
   "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "68d2b6b8a1c82637b047727f5e628000fa094bf771643027fb9a5034d8507928"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}