Hybrid-based_Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "n5Opktci8kCC",
    "outputId": "19d71634-2847-46d9-c237-1e4b755ca1f6"
   },
   "outputs": [],
   "source": [
    "#!pip install scikit-surprise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "l1eVlbZM7ioQ"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.sparse import csr_matrix\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from scipy.sparse import csr_matrix\n",
    "from scipy.sparse.linalg import svds\n",
    "\n",
    "from surprise import KNNWithMeans, Dataset, accuracy, Reader\n",
    "from surprise.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "eKWOf0S37ioS",
    "outputId": "24d15b81-8f05-4077-8fb9-cdc792cb654f",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId                               title  \\\n",
       "0        1                    Toy Story (1995)   \n",
       "1        2                      Jumanji (1995)   \n",
       "2        3             Grumpier Old Men (1995)   \n",
       "3        4            Waiting to Exhale (1995)   \n",
       "4        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                        genres  \n",
       "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
       "1                   Adventure|Children|Fantasy  \n",
       "2                               Comedy|Romance  \n",
       "3                         Comedy|Drama|Romance  \n",
       "4                                       Comedy  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df_movies = pd.read_csv(\"Data/movies.csv\")\n",
    "df_movies = pd.read_csv(\"Data/movies.csv\")\n",
    "df_movies.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "QUzgGZ8c7ioS",
    "outputId": "bb9b4880-13e1-445c-98a1-eb61a73a31d3"
   },
   "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>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>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964982703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964981247</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>4.0</td>\n",
       "      <td>964982224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>47</td>\n",
       "      <td>5.0</td>\n",
       "      <td>964983815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>50</td>\n",
       "      <td>5.0</td>\n",
       "      <td>964982931</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating  timestamp\n",
       "0       1        1     4.0  964982703\n",
       "1       1        3     4.0  964981247\n",
       "2       1        6     4.0  964982224\n",
       "3       1       47     5.0  964983815\n",
       "4       1       50     5.0  964982931"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df_ratings = pd.read_csv(\"/content/sample_data/ratings.csv\")\n",
    "df_ratings = pd.read_csv(\"Data/ratings.csv\")\n",
    "df_ratings.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "lb1930ah7ioT"
   },
   "outputs": [],
   "source": [
    "df_ratings.drop(columns='timestamp', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "osfTd50S7ioT"
   },
   "outputs": [],
   "source": [
    "df_cleaned = df_movies.merge(df_ratings, on='movieId')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "lQqoQS4A7ioT"
   },
   "outputs": [],
   "source": [
    "df_cleaned['num_viewers'] = df_cleaned.groupby('movieId')['userId'].transform('count')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "bO87-aMl7ioU",
    "outputId": "4272d649-499a-49d7-f440-098dbce520ee",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "      <th>userId</th>\n",
       "      <th>rating</th>\n",
       "      <th>num_viewers</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>215</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>6</td>\n",
       "      <td>4.0</td>\n",
       "      <td>110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>325</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>377</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "      <td>6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>384</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "      <td>6</td>\n",
       "      <td>5.0</td>\n",
       "      <td>49</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     movieId                               title  \\\n",
       "0          1                    Toy Story (1995)   \n",
       "215        2                      Jumanji (1995)   \n",
       "325        3             Grumpier Old Men (1995)   \n",
       "377        4            Waiting to Exhale (1995)   \n",
       "384        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                          genres  userId  rating  num_viewers  \n",
       "0    Adventure|Animation|Children|Comedy|Fantasy       1     4.0          215  \n",
       "215                   Adventure|Children|Fantasy       6     4.0          110  \n",
       "325                               Comedy|Romance       1     4.0           52  \n",
       "377                         Comedy|Drama|Romance       6     3.0            7  \n",
       "384                                       Comedy       6     5.0           49  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_clean = df_cleaned.drop_duplicates(subset='title', keep='first')\n",
    "df_clean.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 490
    },
    "id": "2R5-4ZIL7ioU",
    "outputId": "ebb5f56a-f8c1-4ba4-a312-fd741d723535",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "      <th>userId</th>\n",
       "      <th>rating</th>\n",
       "      <th>num_viewers</th>\n",
       "      <th>Children</th>\n",
       "      <th>Fantasy</th>\n",
       "      <th>Animation</th>\n",
       "      <th>Adventure</th>\n",
       "      <th>...</th>\n",
       "      <th>Horror</th>\n",
       "      <th>Mystery</th>\n",
       "      <th>Sci-Fi</th>\n",
       "      <th>War</th>\n",
       "      <th>Musical</th>\n",
       "      <th>Documentary</th>\n",
       "      <th>IMAX</th>\n",
       "      <th>Western</th>\n",
       "      <th>Film-Noir</th>\n",
       "      <th>(no genres listed)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>215</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>215</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "      <td>6</td>\n",
       "      <td>4.0</td>\n",
       "      <td>110</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>325</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>52</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>377</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "      <td>6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>7</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>384</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "      <td>6</td>\n",
       "      <td>5.0</td>\n",
       "      <td>49</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 26 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     movieId                               title  \\\n",
       "0          1                    Toy Story (1995)   \n",
       "215        2                      Jumanji (1995)   \n",
       "325        3             Grumpier Old Men (1995)   \n",
       "377        4            Waiting to Exhale (1995)   \n",
       "384        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                          genres  userId  rating  num_viewers  \\\n",
       "0    Adventure|Animation|Children|Comedy|Fantasy       1     4.0          215   \n",
       "215                   Adventure|Children|Fantasy       6     4.0          110   \n",
       "325                               Comedy|Romance       1     4.0           52   \n",
       "377                         Comedy|Drama|Romance       6     3.0            7   \n",
       "384                                       Comedy       6     5.0           49   \n",
       "\n",
       "     Children  Fantasy  Animation  Adventure  ...  Horror  Mystery  Sci-Fi  \\\n",
       "0         1.0      1.0        1.0        1.0  ...     0.0      0.0     0.0   \n",
       "215       1.0      1.0        0.0        1.0  ...     0.0      0.0     0.0   \n",
       "325       0.0      0.0        0.0        0.0  ...     0.0      0.0     0.0   \n",
       "377       0.0      0.0        0.0        0.0  ...     0.0      0.0     0.0   \n",
       "384       0.0      0.0        0.0        0.0  ...     0.0      0.0     0.0   \n",
       "\n",
       "     War  Musical  Documentary  IMAX  Western  Film-Noir  (no genres listed)  \n",
       "0    0.0      0.0          0.0   0.0      0.0        0.0                 0.0  \n",
       "215  0.0      0.0          0.0   0.0      0.0        0.0                 0.0  \n",
       "325  0.0      0.0          0.0   0.0      0.0        0.0                 0.0  \n",
       "377  0.0      0.0          0.0   0.0      0.0        0.0                 0.0  \n",
       "384  0.0      0.0          0.0   0.0      0.0        0.0                 0.0  \n",
       "\n",
       "[5 rows x 26 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genres_split = df_clean.genres.apply(lambda x: x.split(sep='|')).apply(pd.value_counts, 1.0).fillna(0.0)\n",
    "df_clean = pd.concat([df_clean.iloc[:,:], genres_split], axis=1)\n",
    "df_clean.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ibNYOxRG7ioU",
    "outputId": "3b0e4be3-e9b6-4424-8fac-b7982281aec3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_clean['(no genres listed)'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "JxXnWiPl7ioV"
   },
   "outputs": [],
   "source": [
    "df_clean.drop(columns=['(no genres listed)'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f5bHJNHd7ioV"
   },
   "source": [
    "# Hybrid Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "gTRCwCGC7ioW"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import surprise\n",
    "from surprise import accuracy\n",
    "from surprise import Dataset, Reader, SVD, KNNWithMeans\n",
    "from surprise.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MultiLabelBinarizer\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.neighbors import NearestNeighbors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Y4o-SMux7ioW",
    "outputId": "5e39f208-551e-4d6e-ed40-f26dddb1a4e0",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n"
     ]
    }
   ],
   "source": [
    "# create a reader to read the dataframe\n",
    "reader = Reader(rating_scale=(1.0, 5.0))\n",
    "\n",
    "# create a surprise dataset from the dataframe\n",
    "data = Dataset.load_from_df(df_clean[['userId', 'movieId', 'rating']], reader)\n",
    "\n",
    "# split the data into training and testing sets\n",
    "trainset, testset = train_test_split(data, test_size=0.25)\n",
    "\n",
    "# train a content-based model using the KNN algorithm\n",
    "k = 10\n",
    "sim_options = {'name': 'cosine', 'user_based': False}\n",
    "algo_cb = KNNWithMeans(k=k, sim_options=sim_options)\n",
    "algo_cb.fit(trainset)\n",
    "\n",
    "# train a collaborative filtering model using SVD\n",
    "algo_cf = SVD()\n",
    "algo_cf.fit(trainset)\n",
    "\n",
    "# for each user and item pair in the test set, make predictions using both models\n",
    "predictions_cf = algo_cf.test(testset)\n",
    "predictions_cb = algo_cb.test(testset)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "wT6a8tq87ioW",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# assign weights to the models\n",
    "weight_cf = 0.5\n",
    "weight_cb = 0.5\n",
    "\n",
    "# combine the predictions from both models using a weighted average\n",
    "predictions_combined = []\n",
    "\n",
    "# iterate over each prediction in the test set\n",
    "for pred_cf, pred_cb in zip(predictions_cf, predictions_cb):\n",
    "    # extract the user ID and item ID from the prediction\n",
    "    uid, iid = pred_cf.uid, pred_cf.iid\n",
    "    \n",
    "    # calculate the weighted sum of the predicted ratings\n",
    "    rating_combined = (weight_cf * pred_cf.est) + (weight_cb * pred_cb.est)\n",
    "    \n",
    "    # create a new prediction object with the combined rating\n",
    "    pred_combined = surprise.prediction_algorithms.predictions.Prediction(uid, iid, r_ui=None, est=rating_combined, details=None)\n",
    "    \n",
    "    # add the combined prediction to the list\n",
    "    predictions_combined.append(pred_combined)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "ZIb-8-V_NKQh"
   },
   "outputs": [],
   "source": [
    "##make predictions for all the movies that the user has not yet rated using the hybrid model\n",
    "\n",
    "# get the list of all movie IDs that the user has not yet rated\n",
    "user_id = 1  # replace with the user ID you want to get recommendations for\n",
    "movie_ids = df_clean[~df_clean['movieId'].isin(df_clean[df_clean['userId'] == user_id]['movieId'])]['movieId']\n",
    "\n",
    "# create a list of (user_id, movie_id, 0) tuples to make predictions on\n",
    "testset = [[user_id, movie_id, 0] for movie_id in movie_ids]\n",
    "\n",
    "# make predictions using both models\n",
    "predictions_cf = algo_cf.test(testset)\n",
    "predictions_cb = algo_cb.test(testset)\n",
    "\n",
    "# combine the predictions from both models using a weighted average\n",
    "predictions_combined = [(weight_cf * pred_cf.est) + (weight_cb * pred_cb.est) for pred_cf, pred_cb in zip(predictions_cf, predictions_cb)]\n",
    "\n",
    "# add the predictions to the dataframe\n",
    "df_clean.loc[~df_clean['movieId'].isin(df_clean[df_clean['userId'] == user_id]['movieId']), 'hybrid_score'] = predictions_combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IpMPrR5xNSSp",
    "outputId": "cdacd524-37df-4dd2-d878-0c5ef03bf4b3",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81235    Match Factory Girl, The (Tulitikkutehtaan tytt...\n",
      "78044                   Play Time (a.k.a. Playtime) (1967)\n",
      "82468                              Peaceful Warrior (2006)\n",
      "51025    Incredibly True Adventure of Two Girls in Love...\n",
      "4788                          Devil in a Blue Dress (1995)\n",
      "Name: title, dtype: object\n"
     ]
    }
   ],
   "source": [
    "#sort the movies by their hybrid scores and select the top 5 movies\n",
    "\n",
    "# get the top 5 movie recommendations based on the hybrid scores\n",
    "top_5_movies = df_clean[df_clean['userId'] != user_id].sort_values(by='hybrid_score', ascending=False).head(5)['title']\n",
    "print(top_5_movies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average difference between actual rating and predicted rating is: 0.093797240104659\n"
     ]
    }
   ],
   "source": [
    "# initialize a list to store the differences between the actual and predicted ratings\n",
    "diffs = []\n",
    "\n",
    "# iterate over the top 5 recommendations and compute the absolute difference between the actual and predicted ratings\n",
    "for index, row in top_5_movies.iterrows():\n",
    "    actual_rating = row['rating']\n",
    "    predicted_rating = row['hybrid_score']\n",
    "    diff = abs(actual_rating - predicted_rating)\n",
    "    diffs.append(diff)\n",
    "\n",
    "# compute the average difference between the actual and predicted ratings\n",
    "avg_diff = sum(diffs) / len(diffs)\n",
    "\n",
    "print(f\"The average difference between actual rating and predicted rating is: {avg_diff}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kNsgyNEB7ioW"
   },
   "source": [
    "# Recommendation for Top 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Movie: Match Factory Girl, The (Tulitikkutehtaan tyttö) (1990)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.934307207361128\n",
      "\n",
      "Movie: Play Time (a.k.a. Playtime) (1967)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.910530952258561\n",
      "\n",
      "Movie: Peaceful Warrior (2006)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.909235413870017\n",
      "\n",
      "Movie: Incredibly True Adventure of Two Girls in Love, The (1995)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.888897287582636\n",
      "\n",
      "Movie: Devil in a Blue Dress (1995)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.888042938404363\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# get the top 5 movie recommendations based on the hybrid scores\n",
    "top_5_movies = df_clean[df_clean['userId'] != user_id].sort_values(by='hybrid_score', ascending=False).head(5)\n",
    "\n",
    "# iterate over the top 5 recommendations and print the actual rating and predicted rating for each movie\n",
    "for index, row in top_5_movies.iterrows():\n",
    "    movie_title = row['title']\n",
    "    actual_rating = row['rating']\n",
    "    predicted_rating = row['hybrid_score']\n",
    "    print(f\"Movie: {movie_title}\")\n",
    "    print(f\"Actual rating: {actual_rating}\")\n",
    "    print(f\"Predicted rating: {predicted_rating}\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Movie: Step Brothers (2008)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.66531862416198\n",
      "\n",
      "Movie: Inside Job (2010)\n",
      "Actual rating: 5.0\n",
      "Predicted rating: 4.666679229775603\n",
      "\n",
      "Movie: Match Factory Girl, The (Tulitikkutehtaan tyttö) (1990)\n",
      "Actual rating: N/A\n",
      "Predicted rating: 4.934307207361128\n",
      "\n",
      "Movie: Play Time (a.k.a. Playtime) (1967)\n",
      "Actual rating: N/A\n",
      "Predicted rating: 4.910530952258561\n",
      "\n",
      "Movie: Kill Bill: Vol. 1 (2003)\n",
      "Actual rating: 4.0\n",
      "Predicted rating: 4.180664705307279\n",
      "\n",
      "Movie: Talladega Nights: The Ballad of Ricky Bobby (2006)\n",
      "Actual rating: 4.0\n",
      "Predicted rating: 4.120011704271736\n",
      "\n",
      "Movie: Shawshank Redemption, The (1994)\n",
      "Actual rating: 3.0\n",
      "Predicted rating: 3.5353953373423104\n",
      "\n",
      "Movie: Zombieland (2009)\n",
      "Actual rating: 3.0\n",
      "Predicted rating: 3.666880412743097\n",
      "\n"
     ]
    }
   ],
   "source": [
    "user_id = 2\n",
    "\n",
    "# filter the dataframe to only include movies rated by user_id\n",
    "movies_rated_by_user = df_clean[df_clean['userId'] == user_id]\n",
    "\n",
    "# get the top 5 movie recommendations based on the hybrid scores\n",
    "top_5_movies = df_clean[df_clean['userId'] != user_id].sort_values(by='hybrid_score', ascending=False).head(5)\n",
    "\n",
    "# iterate over the top 5 recommendations and print the actual rating and predicted rating for each movie\n",
    "for rating in [5.0, 4.0, 3.0]:\n",
    "    movies_with_rating = movies_rated_by_user[movies_rated_by_user['rating'] == rating].head(2)\n",
    "    for index, row in movies_with_rating.iterrows():\n",
    "        movie_title = row['title']\n",
    "        actual_rating = row['rating']\n",
    "        predicted_rating = row['hybrid_score']\n",
    "        print(f\"Movie: {movie_title}\")\n",
    "        print(f\"Actual rating: {actual_rating}\")\n",
    "        print(f\"Predicted rating: {predicted_rating}\")\n",
    "        print()\n",
    "        \n",
    "    top_movies_with_rating = top_5_movies[top_5_movies['rating'] == rating].head(2)\n",
    "    for index, row in top_movies_with_rating.iterrows():\n",
    "        movie_title = row['title']\n",
    "        actual_rating = \"N/A\"\n",
    "        predicted_rating = row['hybrid_score']\n",
    "        print(f\"Movie: {movie_title}\")\n",
    "        print(f\"Actual rating: {actual_rating}\")\n",
    "        print(f\"Predicted rating: {predicted_rating}\")\n",
    "        print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "pUqZ_1-w7ioX"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NearestNeighbors(algorithm='brute', metric='cosine')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fit the nearest neighbors model\n",
    "nn = NearestNeighbors(metric='cosine', algorithm='brute')\n",
    "nn.fit(df_clean[['rating']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "ZMJhw70Y7ioX"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top 5 ratings for 'Salem's Lot (2004):\n",
      "                 title  rating  userId\n",
      "0  'Salem's Lot (2004)     5.0       1\n",
      "Top 5 ratings for 'burbs, The (1989):\n",
      "                title  rating  userId\n",
      "1  'burbs, The (1989)     5.0       1\n",
      "Top 5 ratings for 10 Cloverfield Lane (2016):\n",
      "                        title  rating  userId\n",
      "2  10 Cloverfield Lane (2016)     5.0       1\n",
      "Top 5 ratings for 10 Things I Hate About You (1999):\n",
      "                               title  rating  userId\n",
      "3  10 Things I Hate About You (1999)     5.0       1\n",
      "Top 5 ratings for 12 Angry Men (1957):\n",
      "                 title  rating  userId\n",
      "4  12 Angry Men (1957)     5.0       1\n"
     ]
    }
   ],
   "source": [
    "# create a new DataFrame with movie title, average rating, and number of viewers\n",
    "movie_stats = df_clean.groupby('title').agg({'rating': [np.size, np.mean]})\n",
    "\n",
    "# select the 5 movies with the highest average rating\n",
    "top_movies = movie_stats['rating']['mean'].nlargest(5)\n",
    "\n",
    "# select the movie titles of the top 5 movies\n",
    "top_movie_titles = top_movies.index.tolist()\n",
    "\n",
    "# filter the dataframe to only include the top 5 movies\n",
    "top_movie_df = df_clean[df_clean['title'].isin(top_movie_titles)]\n",
    "\n",
    "# group the data by movie title and rating, and count the number of viewers for each rating\n",
    "top_movie_grouped = top_movie_df.groupby(['title', 'rating']).agg({'userId': 'count'}).reset_index()\n",
    "\n",
    "# print the top 5 movies with their average rating, number of viewers, and each rating\n",
    "for movie_title in top_movie_titles:\n",
    "    print(f'Top 5 ratings for {movie_title}:')\n",
    "    print(top_movie_grouped[top_movie_grouped['title'] == movie_title])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aWNaZdNf7ioY"
   },
   "source": [
    "# Extra Code for Model Tuning "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "qVXyICkP7ioY"
   },
   "outputs": [],
   "source": [
    "import surprise\n",
    "from surprise import Dataset, Reader, SVD\n",
    "from sklearn.metrics.pairwise import cosine_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "W0m-OiBv7ioY"
   },
   "outputs": [],
   "source": [
    "# Load the dataset using Surprise\n",
    "reader = Reader(rating_scale=(1.0, 5.0))\n",
    "data = Dataset.load_from_df(df_clean[['userId', 'title', 'rating']], reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "qDsfQx1L7ioY"
   },
   "outputs": [],
   "source": [
    "train, test = train_test_split(data, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "4D931Rbt7ioY"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<surprise.prediction_algorithms.matrix_factorization.SVD at 0x7fa8205baaf0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from surprise import SVD\n",
    "\n",
    "algo = SVD()\n",
    "trainset = data.build_full_trainset()\n",
    "algo.fit(trainset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "_lV3h7mz7ioY"
   },
   "outputs": [],
   "source": [
    "#algo.test(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "jNq_FIZ47ioY"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE:  0.5287\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5287423478193487"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "surprise.accuracy.mae(algo.test(test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "BTWjT97V7ioY",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 0.6750\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.67499337466748"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "surprise.accuracy.rmse(algo.test(test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "fWdLXpWM7ioY",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from surprise.prediction_algorithms.matrix_factorization import SVD\n",
    "SVD = SVD()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "EWXUk3Ru7ioZ"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-30-46f659693bd7>, line 9)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-30-46f659693bd7>\"\u001b[0;36m, line \u001b[0;32m9\u001b[0m\n\u001b[0;31m    rs = RandomizedSearchCV(SVD, param_distributions=, n_iter=10, measures=['rmse', 'mae'], cv=5)\u001b[0m\n\u001b[0m                                                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "from surprise.model_selection import RandomizedSearchCV\n",
    "\n",
    "# Define the search space for hyperparameters\n",
    "param_distributions = {'n_factors': [50, 100, 200],\n",
    "                       'n_epochs': [10, 20, 30],\n",
    "                       'lr_all': [0.002, 0.005, 0.01],\n",
    "                       'reg_all': [0.02, 0.1, 0.4]}\n",
    "# Create the randomized search object\n",
    "rs = RandomizedSearchCV(SVD, param_distributions= n_iter=10, measures=['rmse', 'mae'], cv=5)\n",
    "\n",
    "# Run the randomized search\n",
    "rs.fit(data)\n",
    "\n",
    "# Get the best RMSE score and the corresponding hyperparameters\n",
    "#best_rmse = rs.best_score['rmse']\n",
    "#best_params = rs.best_params['rmse']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3zE5r2wJ7ioZ"
   },
   "outputs": [],
   "source": [
    "print('Best RMSE: ' + str(best_rmse))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lNVtrNP77ioZ"
   },
   "outputs": [],
   "source": [
    "print('Best Params: ' + str(best_params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "etYg4jNf7ioZ"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python (learn-env)",
   "language": "python",
   "name": "learn-env"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}