Movie_Recommendation_Learners_Notebook_.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cf3GloRNvOOG"
      },
      "source": [
        "# **Project - Recommendation Systems: Movie Recommendation System**\n",
        "\n",
        "## **Marks: 40**\n",
        "---------------\n",
        "## **Context**\n",
        "---------------\n",
        "\n",
        "Online streaming platforms like **Netflix** have plenty of movies in their repository and if we can build a **Recommendation System** to recommend **relevant movies** to users, based on their **historical interactions**, this would **improve customer satisfaction** and hence, it will also improve the revenue of the platform. The techniques that we will learn here will not only be limited to movies, it can be any item for which you want to build a recommendation system.\n",
        "\n",
        "-----------------\n",
        "## **Objective**\n",
        "-----------------\n",
        "\n",
        "In this project we will be building various recommendation systems: \n",
        "- Knowledge/Rank based recommendation system\n",
        "- Similarity-Based Collaborative filtering\n",
        "- Matrix Factorization Based Collaborative Filtering\n",
        "\n",
        "we are going to use the **ratings** dataset. \n",
        "\n",
        "-----------------\n",
        "## **Dataset**\n",
        "-----------------\n",
        "\n",
        "The **ratings** dataset contains the following attributes: \n",
        "- userId\n",
        "- movieId\n",
        "- rating\n",
        "- timestamp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VcUTqJ5pwmuY"
      },
      "source": [
        "Sometimes, the installation of the surprise library, which is used to build recommendation systems, faces issues in Jupyter. To avoid any issues, it is advised to use **Google Colab** for this case study.\n",
        "\n",
        "Let's start by mounting the Google drive on Colab."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FYrMMOH6sm8f"
      },
      "outputs": [],
      "source": [
        "# uncomment if you are using google colab\n",
        "\n",
        "#from google.colab import drive\n",
        "#drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRmwxTz1xKew"
      },
      "source": [
        "**Installing surprise library**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J1TItcxtwIAZ"
      },
      "outputs": [],
      "source": [
        "# Installing surprise library, only do it for first time\n",
        "!pip install surprise"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hczXgBkvOOG"
      },
      "source": [
        "## **Importing the necessary libraries and overview of the dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gem2ozi_vOOG"
      },
      "outputs": [],
      "source": [
        "# Used to ignore the warning given as output of the code\n",
        "import warnings                                 \n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# Basic libraries of python for numeric and dataframe computations\n",
        "import numpy as np                              \n",
        "import pandas as pd\n",
        "\n",
        "# Basic library for data visualization\n",
        "import matplotlib.pyplot as plt     \n",
        "\n",
        "# Slightly advanced library for data visualization            \n",
        "import seaborn as sns                           \n",
        "\n",
        "# A dictionary output that does not raise a key error\n",
        "from collections import defaultdict             \n",
        "\n",
        "# A performance metrics in surprise\n",
        "from surprise import accuracy\n",
        "\n",
        "# Class is used to parse a file containing ratings, data should be in structure - user ; item ; rating\n",
        "from surprise.reader import Reader\n",
        "\n",
        "# Class for loading datasets\n",
        "from surprise.dataset import Dataset\n",
        "\n",
        "# For model tuning model hyper-parameters\n",
        "from surprise.model_selection import GridSearchCV\n",
        "\n",
        "# For splitting the rating data in train and test dataset\n",
        "from surprise.model_selection import train_test_split\n",
        "\n",
        "# For implementing similarity based recommendation system\n",
        "from surprise.prediction_algorithms.knns import KNNBasic\n",
        "\n",
        "# For implementing matrix factorization based recommendation system\n",
        "from surprise.prediction_algorithms.matrix_factorization import SVD\n",
        "\n",
        "# For implementing cross validation\n",
        "from surprise.model_selection import KFold"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ewHMWerQ2N9T"
      },
      "source": [
        "### **Loading the data**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EdQIx3OLvOOG"
      },
      "outputs": [],
      "source": [
        "# Import the dataset\n",
        "rating = pd.read_csv('ratings.csv')\n",
        "#rating = pd.read_csv('/content/drive/MyDrive/ratings.csv') # Uncomment this line code  and comment above line of code if you are using google colab."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WAW3gTmB2N9a"
      },
      "source": [
        "Let's check the **info** of the data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8zF1K1hDvOOG"
      },
      "outputs": [],
      "source": [
        "rating.info()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "202Ux9MH2N9f"
      },
      "source": [
        "- There are **1,00,004 observations** and **4 columns** in the data\n",
        "- All the columns are of **numeric data type**\n",
        "- The data type of the timestamp column is int64 which is not correct. We can convert this to DateTime format but **we don't need timestamp for our analysis**. Hence, **we can drop this column**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fltadjTcvOOH"
      },
      "outputs": [],
      "source": [
        "# Dropping timestamp column\n",
        "rating = rating.drop(['timestamp'], axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mHOFHmoBwIAw"
      },
      "source": [
        "## **Question 1: Exploring the dataset (7 Marks)**\n",
        "\n",
        "Let's explore the dataset and answer some basic data-related questions:\n",
        "\n",
        "###**Q 1.1 Print the top 5 rows of the dataset (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1Q6gs-IO2N9i"
      },
      "outputs": [],
      "source": [
        "# Printing the top 5 rows of the dataset Hint: use .head()\n",
        "\n",
        "# Remove _______and complete the code\n",
        "______________________"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fBZYy0HavOOH"
      },
      "source": [
        "### **Q 1.2 Describe the distribution of ratings. (1 Mark)**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lO-EYEl3wIA2"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize = (12, 4))\n",
        "\n",
        "# Remove _______and complete the code\n",
        "sns.countplot(________________)\n",
        "\n",
        "plt.tick_params(labelsize = 10)\n",
        "plt.title(\"Distribution of Ratings \", fontsize = 10)\n",
        "plt.xlabel(\"Ratings\", fontsize = 10)\n",
        "plt.ylabel(\"Number of Ratings\", fontsize = 10)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgRDrtHhwIA4"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOBD03d9vOOH"
      },
      "source": [
        "### **Q 1.3 What is the total number of unique users and unique movies? (1 Mark)**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RMpbsZGGvOOH"
      },
      "outputs": [],
      "source": [
        "# Finding number of unique users\n",
        "#remove _______ and complete the code\n",
        "rating['userId']._______________"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CI8gofnx2N9m"
      },
      "source": [
        "**Write your answer here:______**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9A6Qmo_6vOOH"
      },
      "outputs": [],
      "source": [
        "# Finding number of unique movies\n",
        "# Remove _______ and complete the code\n",
        "\n",
        "rating['movieId'].______________"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mDWJghQ62N9o"
      },
      "source": [
        "**Write your answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mR9tzSzTvOOH"
      },
      "source": [
        "### **Q 1.4 Is there a movie in which the same user interacted with it more than once? (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xstEDCVfvOOH"
      },
      "outputs": [],
      "source": [
        "rating.groupby(['userId', 'movieId']).count()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d1E2i5rZvOOI"
      },
      "outputs": [],
      "source": [
        "rating.groupby(['userId', 'movieId']).count()['rating'].sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynCEs7q3vOOI"
      },
      "source": [
        "**Write your Answer here:__________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQgjqRnevOOI"
      },
      "source": [
        "### **Q 1.5 Which is the most interacted movie in the dataset? (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4LBbXdoDvOOI"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "rating['movieId']._______________"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PSo-c_XAvOOI"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fVkc1FK22N9r"
      },
      "outputs": [],
      "source": [
        "# Plotting distributions of ratings for 341 interactions with movieid 356 \n",
        "plt.figure(figsize=(7,7))\n",
        "\n",
        "rating[rating['movieId'] == 356]['rating'].value_counts().plot(kind='bar')\n",
        "\n",
        "plt.xlabel('Rating')\n",
        "\n",
        "plt.ylabel('Count')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pQn17ro2N9s"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0kXJ_iTEvOOI"
      },
      "source": [
        "### **Q 1.6 Which user interacted the most with any movie in the dataset? (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t7ehlMLDvOOI"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "rating['userId'].____________"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-Sdna2ovOOI"
      },
      "source": [
        "**Write your Answer here:_______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lHReghdivOOI"
      },
      "source": [
        "### **Q 1.7 What is the distribution of the user-movie interactions in this dataset? (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0XArWJ7l2N9v"
      },
      "outputs": [],
      "source": [
        "# Finding user-movie interactions distribution\n",
        "count_interactions = rating.groupby('userId').count()['movieId']\n",
        "count_interactions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JoNCRm88vOOI"
      },
      "outputs": [],
      "source": [
        "# Plotting user-movie interactions distribution\n",
        "\n",
        "plt.figure(figsize=(15,7))\n",
        "# Remove _______ and complete the code\n",
        "\n",
        "sns.histplot(_______________)\n",
        "\n",
        "plt.xlabel('Number of Interactions by Users')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vmj5nPiN2N9w"
      },
      "source": [
        "**Write your Answer here:__________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "knK9ML0bwIBR"
      },
      "source": [
        "#### As we have now explored the data, let's start building Recommendation systems\n",
        "\n",
        "## **Question 2: Create Rank-Based Recommendation System (3 Marks)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CqFN5jDJvOOJ"
      },
      "source": [
        "### **Model 1: Rank-Based Recommendation System**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W26vIRn1vOOJ"
      },
      "source": [
        "Rank-based recommendation systems provide recommendations based on the most popular items. This kind of recommendation system is useful when we have **cold start** problems. Cold start refers to the issue when we get a new user into the system and the machine is not able to recommend movies to the new user, as the user did not have any historical interactions in the dataset. In those cases, we can use rank-based recommendation system to recommend movies to the new user."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I3t4uyGlvOOK"
      },
      "source": [
        "To build the rank-based recommendation system, we take **average** of all the ratings provided to each movie and then rank them based on their average rating."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xuMR3XFIvOOK"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Calculating average ratings\n",
        "average_rating = rating.groupby('movieId')._____________\n",
        "\n",
        "# Calculating the count of ratings\n",
        "count_rating = rating.groupby('movieId')._______________\n",
        "\n",
        "# Making a dataframe with the count and average of ratings\n",
        "final_rating = pd.DataFrame({'avg_rating':average_rating, 'rating_count':count_rating})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J6NLX6FIvOOK"
      },
      "outputs": [],
      "source": [
        "final_rating.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pv31nHm_2N9y"
      },
      "source": [
        "Now, let's create a function to find the **top n movies** for a recommendation based on the average ratings of movies. We can also add a **threshold for a minimum number of interactions** for a movie to be considered for recommendation. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Fy0SbxnevOOK"
      },
      "outputs": [],
      "source": [
        "def top_n_movies(data, n, min_interaction=100):\n",
        "    \n",
        "    #Finding movies with minimum number of interactions\n",
        "    recommendations = data[data['rating_count'] >= min_interaction]\n",
        "    \n",
        "    #Sorting values w.r.t average rating \n",
        "    recommendations = recommendations.sort_values(by='avg_rating', ascending=False)\n",
        "    \n",
        "    return recommendations.index[:n]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fi9vhL4Z2N9y"
      },
      "source": [
        "We can **use this function with different n's and minimum interactions** to get movies to recommend"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkz4LlTpvOOK"
      },
      "source": [
        "#### **Recommending top 5 movies with 50 minimum interactions based on popularity**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u-JX_ES9vOOK"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "list(top_n_movies(_____________))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KRFTrsBVvOOK"
      },
      "source": [
        "#### **Recommending top 5 movies with 100 minimum interactions based on popularity**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U2wvxF2rvOOK"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "list(top_n_movies(_______________))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_3SW8bLkvOOK"
      },
      "source": [
        "#### **Recommending top 5 movies with 200 minimum interactions based on popularity**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t6ziQvDgvOOK"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "list(top_n_movies(________________))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r4vrsunx2N91"
      },
      "source": [
        "Now that we have seen **how to apply the Rank-Based Recommendation System**, let's apply the **Collaborative Filtering Based Recommendation Systems**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJI5kiiGvOOK"
      },
      "source": [
        "## **Model 2: User based Collaborative Filtering Recommendation System (7 Marks)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVjPUvj82N92"
      },
      "source": [
        "![collaborative_filtering.PNG](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/collaborative_filtering.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4yaWX37vOOK"
      },
      "source": [
        "In the above **interactions matrix**, out of users B and C, which user is most likely to interact with the movie, \"The Terminal\"?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QoSujZuuvOOK"
      },
      "source": [
        "In this type of recommendation system, `we do not need any information` about the users or items. We only need user item interaction data to build a collaborative recommendation system. For example - \n",
        "<ol>\n",
        "    <li><b>Ratings</b> provided by users. For example - ratings of books on goodread, movie ratings on imdb etc</li>\n",
        "    <li><b>Likes</b> of users on different facebook posts, likes on youtube videos</li>\n",
        "    <li><b>Use/buying</b> of a product by users. For example - buying different items on e-commerce sites</li>\n",
        "    <li><b>Reading</b> of articles by readers on various blogs</li>\n",
        "</ol>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A_3GtPzuvOOK"
      },
      "source": [
        "**Types of Collaborative Filtering**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igZX3WbqvOOK"
      },
      "source": [
        "- Similarity/Neighborhood based\n",
        "\n",
        " * User-User Similarity Based  \n",
        " * Item-Item similarity based\n",
        "\n",
        "- Model based"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0D3MuFHqvOOK"
      },
      "source": [
        "#### **Building Similarity/Neighborhood based Collaborative Filtering**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vyCEv8eJvOOK"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/cosine.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "skzc0N1_nVNB"
      },
      "source": [
        "### **Building a baseline user-user similarity based recommendation system**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4Uo_MYMnVNB"
      },
      "source": [
        "- Below, we are building **similarity-based recommendation systems** using `cosine` similarity and using **KNN to find similar users** which are the nearest neighbor to the given user.  \n",
        "- We will be using a new library, called `surprise`, to build the remaining models. Let's first import the necessary classes and functions from this library."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hxjJMTwnVNB"
      },
      "source": [
        "Below we are loading the **`rating` dataset**, which is a **pandas DataFrame**, into a **different format called `surprise.dataset.DatasetAutoFolds`**, which is required by this library. To do this, we will be **using the classes `Reader` and `Dataset`**. Finally splitting the data into train and test set."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3PpFZlW0q_d"
      },
      "source": [
        "#### **Making the dataset into surprise dataset and splitting it into train and test set**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rGfYDiOCpe4X"
      },
      "outputs": [],
      "source": [
        "# Instantiating Reader scale with expected rating scale\n",
        "reader = Reader(rating_scale=(0, 5))\n",
        "\n",
        "# Loading the rating dataset\n",
        "data = Dataset.load_from_df(rating[['userId', 'movieId', 'rating']], reader)\n",
        "\n",
        "# Splitting the data into train and test dataset\n",
        "trainset, testset = train_test_split(data, test_size=0.2, random_state=42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmHTEt7TnVNC"
      },
      "source": [
        "#### **Build the first baseline similarity based recommendation system using cosine similarity and KNN**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vO3FL7iape8A"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Defining Nearest neighbour algorithm\n",
        "algo_knn_user = KNNBasic(_____________)\n",
        "\n",
        "# Train the algorithm on the trainset or fitting the model on train dataset \n",
        "algo_knn_user.fit(______________)\n",
        "\n",
        "# Predict ratings for the testset\n",
        "predictions = algo_knn_user.test(___________)\n",
        "\n",
        "# Then compute RMSE\n",
        "accuracy.rmse(__________)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6y7zChf8wIBr"
      },
      "source": [
        "### **Q 3.1 What is the RMSE for baseline user based collaborative filtering recommendation system? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yE5kvdZenVNC"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qelE7GyrwIBs"
      },
      "source": [
        "### **Q 3.2 What is the Predicted  rating for an user with userId=4 and for movieId=10 and movieId=3? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "reFD0-nsnVNC"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sxd23bZ9pe_x"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_knn_user.predict(___, ___, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuVbIR3SnVNE"
      },
      "source": [
        "**Write your Answer here:_______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EXSgq8OEnVNE"
      },
      "source": [
        "Let's predict the rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PbFcBj1PpfEV"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_knn_user.predict(_____, _____, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cm2xqtcQnVNE"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ejjof6csnVNF"
      },
      "source": [
        "### **Improving user-user similarity based recommendation system by tuning its hyper-parameters**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x_kxe-_JnVNF"
      },
      "source": [
        "Below we will be tuning hyper-parmeters for the `KNNBasic` algorithms. Let's try to understand different hyperparameters of KNNBasic algorithm - "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p2j4VvfQnVNF"
      },
      "source": [
        "- **k** (int) – The (max) number of neighbors to take into account for aggregation (see this note). Default is 40.\n",
        "- **min_k** (int) – The minimum number of neighbors to take into account for aggregation. If there are not enough neighbors, the prediction is set to the global mean of all ratings. Default is 1.\n",
        "- **sim_options** (dict) – A dictionary of options for the similarity measure. And there are four similarity measures available in surprise - \n",
        "    - cosine\n",
        "    - msd (default)\n",
        "    - pearson\n",
        "    - pearson baseline\n",
        "    \n",
        "For more details please refer the official documentation https://surprise.readthedocs.io/en/stable/knn_inspired.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lTLnYn_JwIBx"
      },
      "source": [
        "### **Q 3.3 Perform hyperparameter tuning for the baseline user based collaborative filtering recommendation system and find the RMSE for tuned user based collaborative filtering recommendation system? (3 Marks)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KpGhU15gpfHg"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Setting up parameter grid to tune the hyperparameters\n",
        "param_grid = {_____________}\n",
        "\n",
        "# Performing 3-fold cross validation to tune the hyperparameters\n",
        "grid_obj = GridSearchCV(_________, param_grid, measures=['rmse', 'mae'], cv=3, n_jobs=-1)\n",
        "\n",
        "# Fitting the data\n",
        "grid_obj.fit(data)\n",
        "\n",
        "# Best RMSE score\n",
        "print(grid_obj.best_score['rmse'])\n",
        "\n",
        "# Combination of parameters that gave the best RMSE score\n",
        "print(grid_obj.best_params['rmse'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2fHNvu7nVNF"
      },
      "source": [
        "Once the grid search is **complete**, we can get the **optimal values for each of those hyperparameters** as shown above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_K6yd6XnVNF"
      },
      "source": [
        "Below we are analysing evaluation metrics - RMSE and MAE at each and every split to analyze the impact of each value of hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TzJxk_Z4q1A8"
      },
      "outputs": [],
      "source": [
        "results_df = pd.DataFrame.from_dict(grid_obj.cv_results)\n",
        "results_df.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHWgxu_YnVNG"
      },
      "source": [
        "Now, let's build the **final model by using tuned values of the hyperparameters**, which we received by using **grid search cross-validation**.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PujRJA8X_JEJ"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Using the optimal similarity measure for user-user based collaborative filtering\n",
        "# Creating an instance of KNNBasic with optimal hyperparameter values\n",
        "similarity_algo_optimized_user = KNNBasic(__________________,verbose=False)\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "similarity_algo_optimized_user.fit(_______________)\n",
        "\n",
        "# Predicting ratings for the testset\n",
        "predictions = similarity_algo_optimized_user.test(____________)\n",
        "\n",
        "# Computing RMSE on testset\n",
        "accuracy.rmse(predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YA37vQ6qnVNG"
      },
      "source": [
        "**Write your Answer here:__________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gZQybgVwIB1"
      },
      "source": [
        "### **Q 3.4 What is the Predicted rating for an user with userId =4 and for movieId= 10 and movieId=3 using tuned user based collaborative filtering? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YhcAXK0CnVNG"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10` with the optimized model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FgV63lHiq1TV"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "similarity_algo_optimized_user.predict(___,___, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMBeqeUtnVNG"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P1JLqz6mnVNH"
      },
      "source": [
        "Below we are predicting rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`, by using the optimized model as shown below - "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HXO2Ztjhq1bN"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "similarity_algo_optimized_user.predict(___,___, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PN_tYvepnVNH"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2QsfqhanVNH"
      },
      "source": [
        "### **Identifying similar users to a given user (nearest neighbors)**\n",
        "\n",
        "We can also find out the similar users to a given user or its nearest neighbors based on this KNNBasic algorithm. Below we are finding 5 most similar user to the `userId=4` based on the `msd` distance metric"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "evkmTb6P5HYO"
      },
      "outputs": [],
      "source": [
        "similarity_algo_optimized_user.get_neighbors(4, k=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z0NsrX_anVNH"
      },
      "source": [
        "### **Implementing the recommendation algorithm based on optimized KNNBasic model**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3ESobDynVNI"
      },
      "source": [
        "Below we will be implementing a function where the input parameters are - \n",
        "\n",
        "- data: a rating dataset\n",
        "- user_id: an user id against which we want the recommendations\n",
        "- top_n: the number of movies we want to recommend\n",
        "- algo: the algorithm we want to use to predict the ratings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vW9V1Tk65HlY"
      },
      "outputs": [],
      "source": [
        "def get_recommendations(data, user_id, top_n, algo):\n",
        "    \n",
        "    # Creating an empty list to store the recommended movie ids\n",
        "    recommendations = []\n",
        "    \n",
        "    # Creating an user item interactions matrix \n",
        "    user_item_interactions_matrix = data.pivot(index='userId', columns='movieId', values='rating')\n",
        "    \n",
        "    # Extracting those movie ids which the user_id has not interacted yet\n",
        "    non_interacted_movies = user_item_interactions_matrix.loc[user_id][user_item_interactions_matrix.loc[user_id].isnull()].index.tolist()\n",
        "    \n",
        "    # Looping through each of the movie id which user_id has not interacted yet\n",
        "    for item_id in non_interacted_movies:\n",
        "        \n",
        "        # Predicting the ratings for those non interacted movie ids by this user\n",
        "        est = algo.predict(user_id, item_id).est\n",
        "        \n",
        "        # Appending the predicted ratings\n",
        "        recommendations.append((item_id, est))\n",
        "\n",
        "    # Sorting the predicted ratings in descending order\n",
        "    recommendations.sort(key=lambda x: x[1], reverse=True)\n",
        "\n",
        "    return recommendations[:top_n] # returing top n highest predicted rating movies for this user"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oj_S7kh4nVNI"
      },
      "source": [
        "#### **Predicted top 5 movies for userId=4 with similarity based recommendation system**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qWbR85mI5Hrk"
      },
      "outputs": [],
      "source": [
        "#remove _______ and complete the code\n",
        "recommendations = get_recommendations(rating,__,__,similarity_algo_optimized_user)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33GchLEiwICA"
      },
      "source": [
        "### **Q 3.5 Predict the top 5 movies for userId=4 with similarity based recommendation system (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b5WfIX0Z6_q2"
      },
      "outputs": [],
      "source": [
        "recommendations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pqm4J6aQwICB"
      },
      "source": [
        "## **Model 3: Item based Collaborative Filtering Recommendation System (7 Marks)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fa8W64l5wICB"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Definfing similarity measure\n",
        "sim_options = {____________}\n",
        "\n",
        "# Defining Nearest neighbour algorithm\n",
        "algo_knn_item = KNNBasic(___________,verbose=False)\n",
        "\n",
        "# Train the algorithm on the trainset or fitting the model on train dataset \n",
        "algo_knn_item.fit(__________)\n",
        "\n",
        "# Predict ratings for the testset\n",
        "predictions = algo_knn_item.test(testset)\n",
        "\n",
        "# Then compute RMSE\n",
        "accuracy.rmse(predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oW6HXjoVwICC"
      },
      "source": [
        "### **Q 4.1 What is the RMSE for baseline item based collaborative filtering recommendation system ?(1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsagkpFDwICD"
      },
      "source": [
        "**Write your Answer here:__________**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uXRReHXt2UD8"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "egyW6VMYwICD"
      },
      "source": [
        "### **Q 4.2 What is the Predicted  rating for an user with userId =4 and for movieId= 10 and movieId=3? (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RmzxmaDbwICE",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_knn_item.predict(___,___, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fyPeJdK6wICF"
      },
      "source": [
        "**Write your Answer here:__________**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CTSx7Wl5wICG"
      },
      "source": [
        "Let's predict  the rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-l8G1XG5wICG"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_knn_item.predict(___,___, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKqI9IyhwICH"
      },
      "source": [
        "**Write your Answer here:__________**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "utHBZ67JwICI"
      },
      "source": [
        "### **Q 4.3 Perform hyperparameter tuning for the baseline item based collaborative filtering recommendation system and find the RMSE for tuned item based collaborative filtering recommendation system? (3 Marks)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0ZmIvW--wICJ"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Setting up parameter grid to tune the hyperparameters\n",
        "param_grid = {__________}\n",
        "\n",
        "# Performing 3-fold cross validation to tune the hyperparameters\n",
        "grid_obj = GridSearchCV(__________, ________, measures=['rmse', 'mae'], cv=3, n_jobs=-1)\n",
        "\n",
        "# Fitting the data\n",
        "grid_obj.fit(______)\n",
        "\n",
        "# Best RMSE score\n",
        "print(grid_obj.best_score['rmse'])\n",
        "\n",
        "# Combination of parameters that gave the best RMSE score\n",
        "print(grid_obj.best_params['rmse'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_uAej6IMwICK"
      },
      "source": [
        "Once the **grid search** is complete, we can get the **optimal values for each of those hyperparameters as shown above**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2W3LQWA9wICK"
      },
      "source": [
        "Below we are analysing evaluation metrics - RMSE and MAE at each and every split to analyze the impact of each value of hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ITKMae3LwICL",
        "scrolled": false
      },
      "outputs": [],
      "source": [
        "results_df = pd.DataFrame.from_dict(grid_obj.cv_results)\n",
        "results_df.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJkmvdsf2rUt"
      },
      "source": [
        "Now let's build the **final model** by using **tuned values of the hyperparameters** which we received by using grid search cross-validation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "46irii4pwICL"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "# Creating an instance of KNNBasic with optimal hyperparameter values\n",
        "similarity_algo_optimized_item = KNNBasic(sim_options=_________, k=__, min_k=__,verbose=False)\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "similarity_algo_optimized_item.fit(___________)\n",
        "\n",
        "# Predicting ratings for the testset\n",
        "predictions = similarity_algo_optimized_item.test(__________)\n",
        "\n",
        "# Computing RMSE on testset\n",
        "accuracy.rmse(predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OTdrMpQUwICM"
      },
      "source": [
        "**Write your Answer here:__________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tiDcRQDvwICN"
      },
      "source": [
        "### **Q 4.4 What is the Predicted rating for an item with userId =4 and for movieId= 10 and movieId=3 using tuned item based collaborative filtering? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5IGjjEtpwICN"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10` with the optimized model as shown below"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wg8APEG4wICO"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "similarity_algo_optimized_item.predict(__,__, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUXl61_5wICP"
      },
      "source": [
        "**Write your Answer here:___________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HDNNs3cqwICP"
      },
      "source": [
        "Let's predict the rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`, by using the optimized model:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oEew8TwvwICQ"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "similarity_algo_optimized_item.predict(___, __, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sTKvXHU0wICR"
      },
      "source": [
        "**Write your Answer here:________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xquRIW-XwICS"
      },
      "source": [
        "### **Identifying similar items to a given item (nearest neighbors)**\n",
        "We can also find out the similar items to a given item or its nearest neighbors based on this KNNBasic algorithm. Below we are finding 5 most similar items to the `movieId=3` based on the `msd` distance metric"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b4HbXJv-wICS"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "similarity_algo_optimized_item.get_neighbors(___, k=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PI69gPEdwICZ"
      },
      "source": [
        "#### **Predicted top 5 movies for userId=4 with similarity based recommendation system**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RAzdWtCSwICa"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "recommendations = get_recommendations(rating, ____, 5, similarity_algo_optimized_item)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_cDPuGWcwICb"
      },
      "source": [
        "### **Q 4.5 Predict the top 5 movies for userId=4 with similarity based recommendation system (1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kJICKPecwICb"
      },
      "outputs": [],
      "source": [
        "recommendations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rKgJpSA9vOOL"
      },
      "source": [
        "## **Model 4: Based Collaborative Filtering - Matrix Factorization using SVD (7 Marks)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YF6ZGyqhCAob"
      },
      "source": [
        "Model-based Collaborative Filtering is a **personalized recommendation system**, the recommendations are based on the past behavior of the user and it is not dependent on any additional information. We use **latent features** to find recommendations for each user."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uxGWVpOMvOOL"
      },
      "source": [
        "**Latent Features:** The features that are not present in the empirical data but can be inferred from the data. For example:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZfVDC0IuvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF3.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W2TTW8YfvOOL"
      },
      "source": [
        "Now if we notice the above movies closely:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDcl6w2WvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF4.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3l7fsZWNvOOL"
      },
      "source": [
        "Here **Action**, **Romance**, **Suspense** and **Comedy** are latent features of the corresponding movies. Similarly, we can compute the latent features for users as shown below:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Ad4w7bvvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF5.PNG)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4Otha8ovOOL"
      },
      "source": [
        "### **Singular Value Decomposition (SVD)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sGl3QkLvOOL"
      },
      "source": [
        "SVD is used to **compute the latent features** from the **user-item matrix**. But SVD does not work when we **miss values** in the **user-item matrix**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C80zDC6xvOOL"
      },
      "source": [
        "First we need to convert the below movie-rating dataset:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xA_MGBrwvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF3.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3q39l4__vOOL"
      },
      "source": [
        "into an user-item matrix as shown below:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kAz3MNfEvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF6.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6piwQzq3vOOL"
      },
      "source": [
        "We have already done this above while computing cosine similarities."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOzTLIfIvOOL"
      },
      "source": [
        "**SVD decomposes this above matrix into three separate matrices:**\n",
        "- U matrix\n",
        "- Sigma matrix\n",
        "- V transpose matrix"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IVq1fCrBvOOL"
      },
      "source": [
        "#### **U-matrix**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y9wsChCmvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF7.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hA1dXvYXvOOL"
      },
      "source": [
        "the above matrix is a n x k matrix, where:\n",
        "- n is number of users\n",
        "- k is number of latent features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dplq-n9dvOOL"
      },
      "source": [
        "#### **Sigma-matrix**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kB6jCN5svOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF8.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-twhbZ3wvOOL"
      },
      "source": [
        "the above matrix is a k x k matrix, where:\n",
        "- k is number of latent features\n",
        "- Each diagonal entry is the singular value of the original interaction matrix"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nr0dF0XcvOOL"
      },
      "source": [
        "#### **V-transpose matrix**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hz82XFEgvOOL"
      },
      "source": [
        "![test_image](https://raw.githubusercontent.com/GL-ACADOPS/RS-IMAGES/main/CF9.PNG)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9B1119q2N-M"
      },
      "source": [
        "the above matrix is a kxn matrix, where:\n",
        "- k is the number of latent features\n",
        "- n is the number of items"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uOtkUXmAnVNL"
      },
      "source": [
        "### **Build a baseline matrix factorization recommendation system**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "07-2PT5Ssjqm"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Using SVD matrix factorization\n",
        "algo_svd = SVD()\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "algo_svd.fit(_______)\n",
        "\n",
        "# Predicting ratings for the testset\n",
        "predictions = algo_svd.test(______)\n",
        "\n",
        "# Computing RMSE on the testset\n",
        "accuracy.rmse(predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2271PkTuwICu"
      },
      "source": [
        "### **Q 5.1 What is the RMSE for baseline SVD based collaborative filtering recommendation system? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQ6fTuCDnVNL"
      },
      "source": [
        "**Write your Answer here:___________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fsBGQrwCwICv"
      },
      "source": [
        "### **Q 5.2 What is the Predicted  rating for an user with userId =4 and for movieId= 10 and movieId=3? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HD2AU1DnnVNM"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yWIhfdxXsjqm"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_svd.predict(___, ___, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oIjzqDY5nVNM"
      },
      "source": [
        "**Write your Answer here:______**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1aYxVeMnVNM"
      },
      "source": [
        "Let's predict the rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "APm-uMSvcAMf"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "algo_svd.predict(____, 3, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEL6dy3wnVNM"
      },
      "source": [
        "**Write your Answer here:_____**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x13Eb9Owvpcw"
      },
      "source": [
        "### **Improving matrix factorization based recommendation system by tuning its hyper-parameters**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qbd3L1d2nVNM"
      },
      "source": [
        "In SVD, rating is predicted as - "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wp38lmEqnVNM"
      },
      "source": [
        "$$\\hat{r}_{u i}=\\mu+b_{u}+b_{i}+q_{i}^{T} p_{u}$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bHVAYuFznVNN"
      },
      "source": [
        "If user $u$ is unknown, then the bias $b_{u}$ and the factors $p_{u}$ are assumed to be zero. The same applies for item $i$ with $b_{i}$ and $q_{i}$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jCfY5mr7nVNN"
      },
      "source": [
        "To estimate all the unknown, we minimize the following regularized squared error:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1WyyjmK7nVNN"
      },
      "source": [
        "$$\\sum_{r_{u i} \\in R_{\\text {train }}}\\left(r_{u i}-\\hat{r}_{u i}\\right)^{2}+\\lambda\\left(b_{i}^{2}+b_{u}^{2}+\\left\\|q_{i}\\right\\|^{2}+\\left\\|p_{u}\\right\\|^{2}\\right)$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-GBMNL9qnVNN"
      },
      "source": [
        "The minimization is performed by a very straightforward **stochastic gradient descent**:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CwJJRsJGnVNN"
      },
      "source": [
        "$$\\begin{aligned} b_{u} & \\leftarrow b_{u}+\\gamma\\left(e_{u i}-\\lambda b_{u}\\right) \\\\ b_{i} & \\leftarrow b_{i}+\\gamma\\left(e_{u i}-\\lambda b_{i}\\right) \\\\ p_{u} & \\leftarrow p_{u}+\\gamma\\left(e_{u i} \\cdot q_{i}-\\lambda p_{u}\\right) \\\\ q_{i} & \\leftarrow q_{i}+\\gamma\\left(e_{u i} \\cdot p_{u}-\\lambda q_{i}\\right) \\end{aligned}$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nuRjcsUknVNN"
      },
      "source": [
        "There are many hyperparameters to tune in this algorithm, you can find a full list of hyperparameters [here](https://surprise.readthedocs.io/en/stable/matrix_factorization.html#surprise.prediction_algorithms.matrix_factorization.SVD)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQcDPhhcnVNN"
      },
      "source": [
        "Below we will be tuning only three hyperparameters -\n",
        "- **n_epochs**: The number of iteration of the SGD algorithm\n",
        "- **lr_all**: The learning rate for all parameters\n",
        "- **reg_all**: The regularization term for all parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ksN4zUnUwIC_"
      },
      "source": [
        "### **Q 5.3 Perform hyperparameter tuning for the baseline SVD based collaborative filtering recommendation system and find the RMSE for tuned SVD based collaborative filtering recommendation system? (3 Marks)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4bM81V_hvtwv"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Set the parameter space to tune\n",
        "param_grid = {'n_epochs': [10, 20, 30], 'lr_all': [0.001, 0.005, 0.01],\n",
        "              'reg_all': [0.2, 0.4, 0.6]}\n",
        "\n",
        "# Performing 3-fold gridsearch cross validation\n",
        "gs = GridSearchCV(____, param_grid, measures=['rmse', 'mae'], cv=3, n_jobs=-1)\n",
        "\n",
        "# Fitting data\n",
        "gs.fit(____)\n",
        "\n",
        "# Best RMSE score\n",
        "print(gs.best_score['rmse'])\n",
        "\n",
        "# Combination of parameters that gave the best RMSE score\n",
        "print(gs.best_params['rmse'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjIaWSIAnVNN"
      },
      "source": [
        "Once the **grid search** is complete, we can get the **optimal values** for each of those hyperparameters, as shown above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2CfLdGf0nVNN"
      },
      "source": [
        "Below we are analysing evaluation metrics - RMSE and MAE at each and every split to analyze the impact of each value of hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RMb3t3z_vt8W"
      },
      "outputs": [],
      "source": [
        "results_df = pd.DataFrame.from_dict(gs.cv_results)\n",
        "results_df.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KzY78HsrnVNO"
      },
      "source": [
        "Now, we will **the build final model** by using **tuned values** of the hyperparameters, which we received using grid search cross-validation above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TA_7xe-nnhuu"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "\n",
        "# Building the optimized SVD model using optimal hyperparameter search\n",
        "svd_algo_optimized = SVD(n_epochs=_, lr_all=_, reg_all=_)\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "svd_algo_optimized.fit(_______)\n",
        "\n",
        "# Predicting ratings for the testset\n",
        "predictions = svd_algo_optimized.test(_________)\n",
        "\n",
        "# Computing RMSE\n",
        "accuracy.rmse(predictions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UruWuDiCwIDE"
      },
      "source": [
        "### **Q 5.4 What is the Predicted rating for an user with userId =4 and for movieId= 10 and movieId=3 using SVD based collaborative filtering? (1 Mark)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "md0-dL56nVNO"
      },
      "source": [
        "Let's us now predict rating for an user with `userId=4` and for `movieId=10` with the optimized model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s6C1PAfboM8_"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "svd_algo_optimized.predict(___, ____, r_ui=4, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VdiEtzEznVNO"
      },
      "source": [
        "**Write your Answer here:_________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qd2bRtIQ4ze5"
      },
      "source": [
        "Let's predict the rating for the same `userId=4` but for a movie which this user has not interacted before i.e. `movieId=3`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k1xjn3kOoQyg"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "svd_algo_optimized.predict(___, ____, verbose=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5jlUBrbFwIDH"
      },
      "source": [
        "### **Q 5.5 Predict the top 5 movies for userId=4 with SVD based recommendation system?(1 Mark)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1LGeE2EB_n90"
      },
      "outputs": [],
      "source": [
        "# Remove _______ and complete the code\n",
        "get_recommendations(rating, ___, ___, svd_algo_optimized)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xgKmqss1vqGz"
      },
      "source": [
        "### **Predicting ratings for already interacted movies** "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNlUEB13wIDJ"
      },
      "source": [
        "Below we are comparing the rating predictions of users for those movies which has been already watched by an user. This will help us to understand how well are predictions are as compared to the actual ratings provided by users"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hQIPHA7-vg7W"
      },
      "outputs": [],
      "source": [
        "def predict_already_interacted_ratings(data, user_id, algo):\n",
        "    \n",
        "    # Creating an empty list to store the recommended movie ids\n",
        "    recommendations = []\n",
        "    \n",
        "    # Creating an user item interactions matrix \n",
        "    user_item_interactions_matrix = data.pivot(index='userId', columns='movieId', values='rating')\n",
        "    \n",
        "    # Extracting those movie ids which the user_id has interacted already\n",
        "    interacted_movies = user_item_interactions_matrix.loc[user_id][user_item_interactions_matrix.loc[user_id].notnull()].index.tolist()\n",
        "    \n",
        "    # Looping through each of the movie id which user_id has interacted already\n",
        "    for item_id in interacted_movies:\n",
        "        \n",
        "        # Extracting actual ratings\n",
        "        actual_rating = user_item_interactions_matrix.loc[user_id, item_id]\n",
        "        \n",
        "        # Predicting the ratings for those non interacted movie ids by this user\n",
        "        predicted_rating = algo.predict(user_id, item_id).est\n",
        "        \n",
        "        # Appending the predicted ratings\n",
        "        recommendations.append((item_id, actual_rating, predicted_rating))\n",
        "\n",
        "    # Sorting the predicted ratings in descending order\n",
        "    recommendations.sort(key=lambda x: x[1], reverse=True)\n",
        "\n",
        "    return pd.DataFrame(recommendations, columns=['movieId', 'actual_rating', 'predicted_rating']) # returing top n highest predicted rating movies for this user"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5T0q833lwIDK"
      },
      "source": [
        "Here we are comparing the predicted ratings by `similarity based recommendation` system against actual ratings for `userId=7`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IWQvGj-vyWj3"
      },
      "outputs": [],
      "source": [
        "predicted_ratings_for_interacted_movies = predict_already_interacted_ratings(rating, 7, similarity_algo_optimized_item)\n",
        "df = predicted_ratings_for_interacted_movies.melt(id_vars='movieId', value_vars=['actual_rating', 'predicted_rating'])\n",
        "sns.displot(data=df, x='value', hue='variable', kde=True);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yt9XGhb4wIDM"
      },
      "source": [
        "**Write your Answer here:__________**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jfNXSEw9wIDM"
      },
      "source": [
        "Below we are comparing the predicted ratings by `matrix factorization based recommendation` system against actual ratings for `userId=7`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6lYjMDhU0xuQ"
      },
      "outputs": [],
      "source": [
        "predicted_ratings_for_interacted_movies = predict_already_interacted_ratings(rating, 7, svd_algo_optimized)\n",
        "df = predicted_ratings_for_interacted_movies.melt(id_vars='movieId', value_vars=['actual_rating', 'predicted_rating'])\n",
        "sns.displot(data=df, x='value', hue='variable', kde=True);"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aT0zASb-wIDO"
      },
      "outputs": [],
      "source": [
        "# Instantiating Reader scale with expected rating scale\n",
        "reader = Reader(rating_scale=(0, 5))\n",
        "\n",
        "# Loading the rating dataset\n",
        "data = Dataset.load_from_df(rating[['userId', 'movieId', 'rating']], reader)\n",
        "\n",
        "# Splitting the data into train and test dataset\n",
        "trainset, testset = train_test_split(data, test_size=0.2, random_state=42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGbfBUnawIDO"
      },
      "source": [
        "## **Precision and Recall @ k**\n",
        "\n",
        "RMSE is not the only metric we can use here. We can also examine two fundamental measures, precision and recall. We also add a parameter k which is helpful in understanding problems with multiple rating outputs.\n",
        "\n",
        "**Precision@k** - It is the **fraction of recommended items that are relevant in `top k` predictions**. Value of k is the number of recommendations to be provided to the user. One can choose a variable number of recommendations to be given to a unique user.  \n",
        "\n",
        "**Recall@k** - It is the **fraction of relevant items that are recommended to the user in `top k` predictions**.\n",
        "\n",
        "**Recall** - It is the **fraction of actually relevant items that are recommended to the user** i.e. if out of 10 relevant movies, 6 are recommended to the user then recall is 0.60. Higher the value of recall better is the model. It is one of the metrics to do the performance assessment of classification models.\n",
        "\n",
        "**Precision** - It is the **fraction of recommended items that are relevant actually** i.e. if out of 10 recommended items, 6 are found relevant by the user then precision is 0.60. The higher the value of precision better is the model. It is one of the metrics to do the performance assessment of classification models.\n",
        "\n",
        "See the Precision and Recall @ k section of your notebook and follow the instructions to compute various precision/recall values at various values of k.\n",
        "\n",
        "To know more about precision recall in Recommendation systems refer to these links : \n",
        "\n",
        "https://surprise.readthedocs.io/en/stable/FAQ.html\n",
        "\n",
        "https://medium.com/@m_n_malaeb/recall-and-precision-at-k-for-recommender-systems-618483226c54"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_norGWOwIDP"
      },
      "source": [
        "### **Question6: Compute the precision and recall, for each of the 6 models, at k = 5 and 10. This is 6 x 2 = 12 numerical values? (4 marks)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gihoUY5uwIDQ",
        "scrolled": false
      },
      "outputs": [],
      "source": [
        "# Function can be found on surprise documentation FAQs\n",
        "def precision_recall_at_k(predictions, k=10, threshold=3.5):\n",
        "    \"\"\"Return precision and recall at k metrics for each user\"\"\"\n",
        "\n",
        "    # First map the predictions to each user.\n",
        "    user_est_true = defaultdict(list)\n",
        "    for uid, _, true_r, est, _ in predictions:\n",
        "        user_est_true[uid].append((est, true_r))\n",
        "\n",
        "    precisions = dict()\n",
        "    recalls = dict()\n",
        "    for uid, user_ratings in user_est_true.items():\n",
        "\n",
        "        # Sort user ratings by estimated value\n",
        "        user_ratings.sort(key=lambda x: x[0], reverse=True)\n",
        "\n",
        "        # Number of relevant items\n",
        "        n_rel = sum((true_r >= threshold) for (_, true_r) in user_ratings)\n",
        "\n",
        "        # Number of recommended items in top k\n",
        "        n_rec_k = sum((est >= threshold) for (est, _) in user_ratings[:k])\n",
        "\n",
        "        # Number of relevant and recommended items in top k\n",
        "        n_rel_and_rec_k = sum(((true_r >= threshold) and (est >= threshold))\n",
        "                              for (est, true_r) in user_ratings[:k])\n",
        "\n",
        "        # Precision@K: Proportion of recommended items that are relevant\n",
        "        # When n_rec_k is 0, Precision is undefined. We here set it to 0.\n",
        "\n",
        "        precisions[uid] = n_rel_and_rec_k / n_rec_k if n_rec_k != 0 else 0\n",
        "\n",
        "        # Recall@K: Proportion of relevant items that are recommended\n",
        "        # When n_rel is 0, Recall is undefined. We here set it to 0.\n",
        "\n",
        "        recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 0\n",
        "\n",
        "    return precisions, recalls\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "57qD5TFRnm1W"
      },
      "outputs": [],
      "source": [
        "# A basic cross-validation iterator.\n",
        "kf = KFold(n_splits=5)\n",
        "\n",
        "# Make list of k values\n",
        "K = [5, 10]\n",
        "\n",
        "# Remove _______ and complete the code\n",
        "# Make list of models\n",
        "models = [_________________________________________________________]\n",
        "\n",
        "for k in K:\n",
        "    for model in models:\n",
        "        print('> k={}, model={}'.format(k,model.__class__.__name__))\n",
        "        p = []\n",
        "        r = []\n",
        "        for trainset, testset in kf.split(data):\n",
        "            model.fit(trainset)\n",
        "            predictions = model.test(testset, verbose=False)\n",
        "            precisions, recalls = precision_recall_at_k(predictions, k=k, threshold=3.5)\n",
        "\n",
        "            # Precision and recall can then be averaged over all users\n",
        "            p.append(sum(prec for prec in precisions.values()) / len(precisions))\n",
        "            r.append(sum(rec for rec in recalls.values()) / len(recalls))\n",
        "        \n",
        "        print('-----> Precision: ', round(sum(p) / len(p), 3))\n",
        "        print('-----> Recall: ', round(sum(r) / len(r), 3))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "08dezW5P6O1Z"
      },
      "source": [
        "### **Question 7 ( 5 Marks)**\n",
        "**7.1 Compare the results from the base line user-user and item-item based models.**\n",
        "\n",
        "**7.2 How do these baseline models compare to each other with respect to the tuned user-user and item-item models?**\n",
        "\n",
        "**7.3 The matrix factorization model is different from the collaborative filtering models. Briefly describe this difference. Also, compare the RMSE and precision recall for the models.**\n",
        "\n",
        "**7.4 Does it improve? Can you offer any reasoning as to why that might be?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2W0MdIZ1wIDS"
      },
      "source": [
        "**Write your Answer here:__________**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgDOPCXOvOOM"
      },
      "source": [
        "### **Conclusions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WJ4L2PwQvOOM"
      },
      "source": [
        "In this case study, we saw three different ways of building recommendation systems: \n",
        "- rank-based using averages\n",
        "- similarity-based collaborative filtering\n",
        "- model-based (matrix factorization) collaborative filtering"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4XP9B9bVvOOM"
      },
      "source": [
        "We also understood advantages/disadvantages of these recommendation systems and when to use which kind of recommendation systems. Once we build these recommendation systems, we can use **A/B Testing** to measure the effectiveness of these systems."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fAQfeVYLvOOM"
      },
      "source": [
        "Here is an article explaining how [Amazon use **A/B Testing**](https://aws.amazon.com/blogs/machine-learning/using-a-b-testing-to-measure-the-efficacy-of-recommendations-generated-by-amazon-personalize/) to measure effectiveness of its recommendation systems."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}